Update audited Customer Churn models and app

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__
+.ipynb_checkpoints
+*.pyc
+.git
+churn_inputs/
+bank_customer_churn*.csv
+customer_churn_data*.csv
+.env
+**/.env

.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI — Model and API smoke tests
+on:
+  push:
+  pull_request:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt 'pytest>=8,<10' 'httpx>=0.27,<1'
+      - name: Validate stored model versions
+        run: |
+          python -c "import json,sklearn,xgboost; m=json.load(open('model_metadata.json')); assert m['sklearn_version']==sklearn.__version__; assert m['xgboost_version']==xgboost.__version__"
+      - name: Compile and test REST API
+        run: |
+          python -m py_compile app.py train.py
+          python -m pytest -q tests

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+.env
+*.csv
+!reports/*.csv
+churn_inputs/
+*.zip

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.13-slim
+RUN apt-get update && apt-get install -y --no-install-recommends libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH PYTHONUNBUFFERED=1
+WORKDIR /home/user/app
+COPY --chown=user requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir --user -r requirements.txt
+COPY --chown=user . .
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

MODEL_CARD.md

@@ -0,0 +1,27 @@
+# Model Card: Bank + Telecom Churn Screening
+
+## Bank
+Predictors: CreditScore, Age, Tenure, Balance, NumOfProducts, HasCrCard, IsActiveMember, EstimatedSalary, Geography.
+
+Excluded identifiers: CustomerId, Surname.
+
+Duplicate rows removed: 2. Train/validation/test: 6400/1600/2000.
+
+Model: XGBoost; validation-selected F2 cutoff: 0.425; quality gate: demonstration.
+
+
+## Telecom
+Predictors: SeniorCitizen, tenure, MonthlyCharges, TotalCharges, Partner, Dependents, PhoneService, InternetService, Contract, PaymentMethod.
+
+Excluded identifiers: customerID.
+
+Duplicate rows removed: 0. Train/validation/test: 3763/941/1176.
+
+Model: XGBoost; validation-selected F2 cutoff: 0.100; quality gate: research_only_low_signal.
+
+
+## Methodology
+Training-only preprocessing, validation PR AUC model selection, validation F2 threshold selection, untouched test performance.
+
+## Limitations
+Educational datasets, distribution shift, no probability calibration, no subgroup fairness validation, and no downstream business impact study. For demonstration only.

README.md

@@ -1,12 +1,80 @@
 ---
-title: Customer Churn Intelligence Lab
-emoji: 📈
-colorFrom: green
+title: Churn Intelligence Lab
+emoji: 📊
+colorFrom: blue
 colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
-license: other
-short_description: Visitors will enter customer data, run the deployed model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Churn Intelligence Lab — dual-industry ML portfolio
+
+**Live demo**: A Docker-hosted Gradio + FastAPI application with two separately trained models.  
+**How it works**: Bank and telecom customer profiles → in-pipeline imputation/encoding → classifier → thresholded churn screening score.
+
+## Evaluated results (held-out 20% test partition)
+
+| Dataset | Records after dedup | Selected model | ROC AUC | PR AUC | Precision | Recall | F2 | Threshold | Status |
+|---|---:|---|---:|---:|---:|---:|---:|---:|---|
+| Bank | 10,000 | XGBoost | 0.858 | 0.703 | 0.440 | 0.813 | 0.695 | 0.425 | demonstration |
+| Telecom | 5,880 | XGBoost | 0.480 | 0.471 | 0.493 | 1.000 | 0.830 | 0.100 | research_only_low_signal |
+
+**Evaluation protocol:** 64/16/20 train/validation/test stratified splits, fixed random seed, model selection on validation PR AUC; the F2 classification threshold is selected on validation only. The test set remains untouched until final scoring. XGBoost uses training-only 3-fold randomized hyperparameter search.
+
+## Architecture
+
+`train.py` → `models/{bank,telecom}_churn.joblib` + `model_metadata.json` → `app.py` → Docker Space (port 7860) → Gradio UI at `/ui/` + FastAPI Swagger at `/docs`.
+
+### Public API
+- `GET /health`: readiness and loaded models
+- `GET /api/metadata`: columns, chosen model, test metrics
+- `POST /api/predict/bank` or `/api/predict/telecom`: `{"data": {...feature name/value pairs...}}`
+- `POST /api/predict-batch/bank` or `/api/predict-batch/telecom`: `{"records": [{...}, {...}]}` (max 100)
+
+**Sample request** (generated safely from defaults in model metadata):
+```python
+import json, requests
+metadata = json.load(open('model_metadata.json'))['datasets']['bank']
+payload = {'data': metadata['defaults']}
+response = requests.post('https://YOUR-SPACE.hf.space/api/predict/bank', json=payload, timeout=20)
+print(response.json())
+```
+
+## Reproduce model training
+1. Use the Python minor version in the notebook-generated `Dockerfile` (and `model_metadata.json` when published). Install: `pip install -r requirements.txt matplotlib`.
+2. Supply `bank_customer_churn.csv` and `customer_churn_data.csv` locally, **never publish raw customer rows**.
+3. `python train.py --data-dir /path/to/datasets --project-dir . --tuning-iterations 6`.
+4. `python -m pytest -q tests/`; `uvicorn app:app --host 0.0.0.0 --port 7860`.
+5. Visit `http://localhost:7860/ui/` and `http://localhost:7860/docs`.
+
+## Evaluation visualizations
+
+**Bank ROC (held-out test)**
+
+![Bank held-out test ROC](reports/bank_roc.png)
+
+**Bank feature importance (validation permutation)**
+
+![Bank features](reports/bank_feature_importance.png)
+
+**Telecom ROC (near-chance baseline)**
+
+![Telecom held-out test ROC](reports/telecom_roc.png)
+
+## Project layout
+- `train.py` — full reusable training and model comparison pipeline
+- `app.py` — UI + validated REST endpoints
+- `models/` — two **trained**, serialized sklearn-compatible pipelines
+- `reports/` — comparison CSV, permutation importance, ROC and confusion matrix graphics
+- `model_metadata.json` — measured performance, feature defaults, audits
+- `tests/` — API smoke tests
+- `Dockerfile`, `requirements.txt` — reproducible runtime
+- `MODEL_CARD.md` — model/data limitations and ethics notes
+- `notebooks/Customer_Churn_Training_Walkthrough.ipynb` — standalone training walkthrough runnable in Colab
+- `.github/workflows/ci.yml` — GitHub Actions CI smoke test
+
+## Limitations and responsible use
+Scores are **uncalibrated** probabilities and are not guarantees. A model with near-chance held-out discrimination is flagged `research_only_low_signal`, and its API refuses actionable churn labels. Demonstration datasets may be artificial/educational and do not prove real-world performance; monitor data drift, assess geographic/demographic fairness, calibrate before operational use, and obtain appropriate consent and privacy reviews. The public demo is for **synthetic or anonymized inputs**, with no storage of uploaded customer records as a product feature. Do not submit personal data or use this demo to make automated decisions about people.
+
+*Built in a single Colab notebook from the attached deployment and containerization case studies. All reported results are computed, not estimated.*

app.py

@@ -0,0 +1,194 @@
+"""Docker Space: FastAPI REST service plus Gradio web UI, powered by trained pipelines."""
+from __future__ import annotations
+import json
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+import joblib
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel, Field
+
+ROOT = Path(__file__).resolve().parent
+META = json.loads((ROOT / 'model_metadata.json').read_text(encoding='utf-8'))['datasets']
+MODELS = {key: joblib.load(ROOT / 'models' / f'{key}_churn.joblib') for key in META}
+
+class SinglePayload(BaseModel):
+    data: dict
+
+class BatchPayload(BaseModel):
+    records: list[dict] = Field(min_length=1, max_length=100)
+
+def validate_input(key, records):
+    if key not in MODELS:
+        raise ValueError(f'Unknown segment {key!r}; choose {list(MODELS)}')
+    if not records or len(records) > 100:
+        raise ValueError('Provide 1–100 records per request')
+    info = META[key]
+    required = info['features']
+    X = pd.DataFrame(records)
+    absent = [c for c in required if c not in X.columns]
+    if absent:
+        raise ValueError(f'Missing required features for {key}: {absent}')
+    X = X[required].copy()  # Ignore arbitrary PII/extraneous uploaded columns.
+    for c in info['numeric']:
+        vals = pd.to_numeric(X[c], errors='coerce')
+        if vals.isna().any() or not np.isfinite(vals.to_numpy(dtype=float)).all():
+            raise ValueError(f'{c} must contain valid finite numeric values; empty inputs are not accepted')
+        X[c] = vals
+    for c in info['categorical']:
+        allowed = info['categorical_choices'][c]
+        vals = X[c].astype('string').str.strip()
+        if vals.isna().any() or (~vals.isin(allowed)).any():
+            raise ValueError(f'{c} must be one of {allowed}')
+        X[c] = vals.astype(str)
+    return X
+
+def predict_records(key, records):
+    frame = validate_input(key, records)
+    probs = MODELS[key]['pipeline'].predict_proba(frame)[:, 1]
+    cut = float(MODELS[key]['threshold'])
+    low_signal = META[key]['deployment_status'] != 'demonstration'
+    return [{'row_number': i+1, 'churn_score': round(float(p), 5),
+             'prediction': ('Exploratory only — unreliable classifier' if low_signal
+                           else ('Likely to churn' if p >= cut else 'Likely to stay')),
+             'deployment_status': META[key]['deployment_status'],
+             'threshold': cut} for i, p in enumerate(probs)]
+
+api = FastAPI(title='Churn Intelligence Lab API', version='1.0.0',
+              description='Demo-only bank and telecom churn inference. Do not submit real customer PII.')
+
+@api.get('/', include_in_schema=False)
+def home():
+    return RedirectResponse('/ui/')
+
+@api.get('/health')
+def health():
+    return {'status': 'ok', 'trained_models': list(MODELS), 'version': '1.0.0'}
+
+@api.get('/api/metadata')
+def metadata():
+    return {name: {'features': info['features'], 'threshold': info['threshold'],
+            'selected_model': info['selected_model'], 'test_metrics': info['test_metrics']}
+            for name, info in META.items()}
+
+@api.post('/api/predict/{segment}')
+def predict_one(segment: str, body: SinglePayload):
+    try:
+        return predict_records(segment, [body.data])[0]
+    except ValueError as error:
+        raise HTTPException(status_code=422, detail=str(error)) from error
+
+@api.post('/api/predict-batch/{segment}')
+def predict_many(segment: str, body: BatchPayload):
+    try:
+        return {'results': predict_records(segment, body.records)}
+    except ValueError as error:
+        raise HTTPException(status_code=422, detail=str(error)) from error
+
+def format_prediction(segment, *values):
+    fields = META[segment]['features']
+    response = predict_records(segment, [dict(zip(fields, values))])[0]
+    return (f'### {response["prediction"]}\n\n'
+            f'**Churn model score:** {response["churn_score"]:.1%}  '\
+            f'\n\n**Decision threshold:** {response["threshold"]:.1%}  '
+            f'\n\n*Uncalibrated model output; screening aid, not a guarantee of churn.*'), response
+
+def run_batch(segment, filepath):
+    if not filepath:
+        raise gr.Error('Upload a CSV file before requesting batch predictions.')
+    try:
+        raw = pd.read_csv(filepath)
+        if len(raw) == 0 or len(raw) > 100:
+            raise ValueError('CSV must contain between 1 and 100 rows')
+        output = predict_records(segment, raw.to_dict(orient='records'))
+        result_path = Path(tempfile.mkdtemp(prefix='churn_demo_')) / f'{segment}_prediction_results.csv'
+        pd.DataFrame(output).to_csv(result_path, index=False)
+        return pd.DataFrame(output), str(result_path)
+    except (ValueError, pd.errors.ParserError) as error:
+        raise gr.Error(str(error)) from error
+
+SITE_CSS = '''
+.gradio-container {max-width: 1240px !important; margin: auto !important;}
+#hero {background:linear-gradient(120deg,#0a2342,#123a68 65%,#176a89);border-radius:20px;
+       padding:28px 34px;color:white; box-shadow:0 12px 40px rgba(5,22,45,.15);}
+#hero h1,#hero p {color:white !important;}
+#hero h1 {font-weight:800;letter-spacing:-.03em;font-size:2.2rem;}
+#metricline {padding:10px 16px;border:1px solid #dce6ef;border-radius:12px;}
+#caution {background:#fff7ed;border:1px solid #fed7aa;padding:12px 16px;border-radius:12px;}
+#resultbox {border-left:4px solid #0e7490;padding:8px 16px;min-height:90px;}
+'''
+
+with gr.Blocks(title='Churn Intelligence Lab | AI Customer Retention', css=SITE_CSS,
+               theme=gr.themes.Soft(primary_hue='blue', neutral_hue='slate')) as demo:
+    gr.Markdown('''<div id="hero"><p style="opacity:.8;font-weight:700;letter-spacing:.13em">AI • MACHINE LEARNING • MLOPS</p>
+    <h1>Churn Intelligence Lab</h1>
+    <p>Explore AI-assisted customer attrition insights across banking and telecom. Compare model evidence, run individual assessments, and export anonymized batch results.</p>
+    <p style="font-size:.86em;opacity:.85">Portfolio research demonstration • Do not enter real customer identifiers or sensitive information.</p></div>''')
+    with gr.Row():
+        gr.Markdown('**Two independently evaluated datasets**  \nTrain/test separation · Reproducible preprocessing · Saved production-style pipelines')
+        gr.Markdown('**Developer access**  \n[REST API docs](/docs) · [Model metadata](/api/metadata) · [Service health](/health)')
+    for key, info in META.items():
+        with gr.Tab('🏦  Banking attrition' if key == 'bank' else '📶  Telecom attrition'):
+            met = info['test_metrics']
+            with gr.Row():
+                gr.Markdown(f'''### {"Banking" if key == "bank" else "Telecommunications"} model
+                <div id="metricline"> <b>Selected:</b> {info["selected_model"]} &nbsp; | &nbsp;
+                <b>Test ROC AUC:</b> {met["roc_auc"]:.3f} &nbsp; | &nbsp;
+                <b>PR AUC:</b> {met["pr_auc"]:.3f} &nbsp; | &nbsp;
+                <b>Recall:</b> {met["recall"]:.3f}</div>''')
+            if info['deployment_status'] != 'demonstration':
+                gr.Markdown('''<div id="caution"><b>⚠ Experimental — low predictive reliability.</b>
+                The held-out evaluation is near chance. Scores are exploratory; this model is not suitable for business churn decisions.</div>''')
+            else:
+                gr.Markdown('**Customer assessment** — review sample defaults, modify customer attributes, and run a prediction.')
+            inputs=[]
+            with gr.Accordion('Customer profile inputs', open=True):
+                with gr.Row():
+                    with gr.Column():
+                        first=info['features'][::2]
+                        for col in first:
+                            if col in info['numeric']:
+                                component=gr.Number(label=col, value=info['defaults'][col], precision=2)
+                            else:
+                                component=gr.Dropdown(label=col, choices=info['categorical_choices'][col],value=info['defaults'][col])
+                            inputs.append((col,component))
+                    with gr.Column():
+                        for col in info['features'][1::2]:
+                            if col in info['numeric']:
+                                component=gr.Number(label=col, value=info['defaults'][col], precision=2)
+                            else:
+                                component=gr.Dropdown(label=col, choices=info['categorical_choices'][col],value=info['defaults'][col])
+                            inputs.append((col,component))
+            ordered=[dict(inputs)[col] for col in info['features']]
+            run=gr.Button('Analyze customer churn risk',variant='primary',size='lg')
+            with gr.Row():
+                with gr.Column(scale=2):
+                    textout=gr.Markdown('Ready to analyze a synthetic customer profile.',elem_id='resultbox')
+                with gr.Column(scale=1):
+                    jsonout=gr.JSON(label='Prediction details')
+            run.click(fn=lambda *values,segment=key: format_prediction(segment,*values),
+                      inputs=ordered,outputs=[textout,jsonout],api_name=False)
+            gr.Markdown('### Batch screening (CSV)\nUpload 1–100 rows with the required feature columns. Only anonymized or synthetic data is permitted.')
+            with gr.Row():
+                csvfile=gr.File(label='Anonymized feature CSV',file_types=['.csv'],type='filepath')
+                batch_button=gr.Button('Process CSV batch')
+            with gr.Row():
+                batch_table=gr.Dataframe(label='Prediction results',interactive=False)
+                batch_download=gr.File(label='Download results CSV')
+            batch_button.click(fn=lambda f,segment=key: run_batch(segment,f),
+                               inputs=csvfile,outputs=[batch_table,batch_download],api_name=False)
+    gr.Markdown('''---
+    **How to interpret scores:** estimated model probabilities are not calibrated. Thresholds are validation-derived; outcomes are uncertain.
+    Telecom is research-only because of weak signal. Evaluate fairness, drift, and real-world fit before any operational use.
+
+    **Architecture:** Python · Scikit-learn · XGBoost · Gradio · FastAPI · Docker · Hugging Face Spaces''')
+
+app = gr.mount_gradio_app(api, demo, path='/ui')
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=7860)

model_metadata.json

@@ -0,0 +1,415 @@
+{
+  "generated_utc": "2026-10-17T21:15:10.673962+00:00",
+  "random_seed": 42,
+  "sklearn_version": "1.8.0",
+  "xgboost_version": "3.1.3",
+  "python_version": "3.13.16",
+  "datasets": {
+    "bank": {
+      "label": "Bank customer churn",
+      "selected_model": "XGBoost",
+      "numeric": [
+        "CreditScore",
+        "Age",
+        "Tenure",
+        "Balance",
+        "NumOfProducts",
+        "HasCrCard",
+        "IsActiveMember",
+        "EstimatedSalary"
+      ],
+      "categorical": [
+        "Geography"
+      ],
+      "features": [
+        "CreditScore",
+        "Age",
+        "Tenure",
+        "Balance",
+        "NumOfProducts",
+        "HasCrCard",
+        "IsActiveMember",
+        "EstimatedSalary",
+        "Geography"
+      ],
+      "excluded_columns": [
+        "CustomerId",
+        "Surname"
+      ],
+      "categorical_choices": {
+        "Geography": [
+          "France",
+          "Germany",
+          "Spain"
+        ]
+      },
+      "defaults": {
+        "CreditScore": 653.0,
+        "Age": 37.0,
+        "Tenure": 5.0,
+        "Balance": 97452.79500000001,
+        "NumOfProducts": 1.0,
+        "HasCrCard": 1.0,
+        "IsActiveMember": 1.0,
+        "EstimatedSalary": 99482.98,
+        "Geography": "France"
+      },
+      "threshold": 0.425,
+      "training_rows": 6400,
+      "validation_rows": 1600,
+      "test_rows": 2000,
+      "audit": {
+        "original_rows": 10002,
+        "duplicate_rows_removed": 2,
+        "rows_after_deduplication": 10000,
+        "positive_rate": 0.2037,
+        "feature_missing_counts": {
+          "CreditScore": 0,
+          "Age": 1,
+          "Tenure": 0,
+          "Balance": 0,
+          "NumOfProducts": 0,
+          "HasCrCard": 1,
+          "IsActiveMember": 1,
+          "EstimatedSalary": 0,
+          "Geography": 1
+        },
+        "sha256_first12": "8c8d77064a1c"
+      },
+      "validation_metrics": {
+        "roc_auc": 0.85564,
+        "pr_auc": 0.68442,
+        "balanced_accuracy": 0.77889,
+        "precision": 0.44915,
+        "recall": 0.81288,
+        "f1": 0.5786,
+        "f2": 0.69958,
+        "confusion_matrix": [
+          [
+            949,
+            325
+          ],
+          [
+            61,
+            265
+          ]
+        ],
+        "classification_report": {
+          "0": {
+            "precision": 0.9396039603960396,
+            "recall": 0.7448979591836735,
+            "f1-score": 0.8309982486865148,
+            "support": 1274.0
+          },
+          "1": {
+            "precision": 0.4491525423728814,
+            "recall": 0.8128834355828221,
+            "f1-score": 0.5786026200873362,
+            "support": 326.0
+          },
+          "accuracy": 0.75875,
+          "macro avg": {
+            "precision": 0.6943782513844605,
+            "recall": 0.7788906973832478,
+            "f1-score": 0.7048004343869255,
+            "support": 1600.0
+          },
+          "weighted avg": {
+            "precision": 0.8396744839738212,
+            "recall": 0.75875,
+            "f1-score": 0.7795726393594322,
+            "support": 1600.0
+          }
+        }
+      },
+      "test_metrics": {
+        "roc_auc": 0.85784,
+        "pr_auc": 0.70287,
+        "balanced_accuracy": 0.77449,
+        "precision": 0.44016,
+        "recall": 0.81327,
+        "f1": 0.57118,
+        "f2": 0.69538,
+        "confusion_matrix": [
+          [
+            1172,
+            421
+          ],
+          [
+            76,
+            331
+          ]
+        ],
+        "classification_report": {
+          "0": {
+            "precision": 0.9391025641025641,
+            "recall": 0.7357187696170747,
+            "f1-score": 0.825061598028863,
+            "support": 1593.0
+          },
+          "1": {
+            "precision": 0.4401595744680851,
+            "recall": 0.8132678132678133,
+            "f1-score": 0.5711820534943917,
+            "support": 407.0
+          },
+          "accuracy": 0.7515,
+          "macro avg": {
+            "precision": 0.6896310692853246,
+            "recall": 0.774493291442444,
+            "f1-score": 0.6981218257616273,
+            "support": 2000.0
+          },
+          "weighted avg": {
+            "precision": 0.8375676657119476,
+            "recall": 0.7515,
+            "f1-score": 0.7733971107160982,
+            "support": 2000.0
+          }
+        }
+      },
+      "deployment_status": "demonstration",
+      "model_size_mb": 0.037,
+      "validation_model_comparison": [
+        {
+          "dataset": "bank",
+          "model": "XGBoost",
+          "validation_pr_auc": 0.68442,
+          "validation_roc_auc": 0.85564,
+          "tuning": "6x3 CV"
+        },
+        {
+          "dataset": "bank",
+          "model": "Random forest",
+          "validation_pr_auc": 0.68408,
+          "validation_roc_auc": 0.86424,
+          "tuning": "none"
+        },
+        {
+          "dataset": "bank",
+          "model": "Logistic regression",
+          "validation_pr_auc": 0.45514,
+          "validation_roc_auc": 0.75422,
+          "tuning": "none"
+        }
+      ]
+    },
+    "telecom": {
+      "label": "Telecom customer churn",
+      "selected_model": "XGBoost",
+      "numeric": [
+        "SeniorCitizen",
+        "tenure",
+        "MonthlyCharges",
+        "TotalCharges"
+      ],
+      "categorical": [
+        "Partner",
+        "Dependents",
+        "PhoneService",
+        "InternetService",
+        "Contract",
+        "PaymentMethod"
+      ],
+      "features": [
+        "SeniorCitizen",
+        "tenure",
+        "MonthlyCharges",
+        "TotalCharges",
+        "Partner",
+        "Dependents",
+        "PhoneService",
+        "InternetService",
+        "Contract",
+        "PaymentMethod"
+      ],
+      "excluded_columns": [
+        "customerID"
+      ],
+      "categorical_choices": {
+        "Partner": [
+          "No",
+          "Yes"
+        ],
+        "Dependents": [
+          "No",
+          "Yes"
+        ],
+        "PhoneService": [
+          "No",
+          "Yes"
+        ],
+        "InternetService": [
+          "DSL",
+          "Fiber optic",
+          "No"
+        ],
+        "Contract": [
+          "Month-to-month",
+          "One year",
+          "Two year"
+        ],
+        "PaymentMethod": [
+          "Bank transfer",
+          "Credit card",
+          "Electronic check",
+          "Mailed check"
+        ]
+      },
+      "defaults": {
+        "SeniorCitizen": 1.0,
+        "tenure": 37.0,
+        "MonthlyCharges": 70.26,
+        "TotalCharges": 2161.52,
+        "Partner": "Yes",
+        "Dependents": "No",
+        "PhoneService": "No",
+        "InternetService": "No",
+        "Contract": "Month-to-month",
+        "PaymentMethod": "Credit card"
+      },
+      "threshold": 0.1,
+      "training_rows": 3763,
+      "validation_rows": 941,
+      "test_rows": 1176,
+      "audit": {
+        "original_rows": 5880,
+        "duplicate_rows_removed": 0,
+        "rows_after_deduplication": 5880,
+        "positive_rate": 0.49286,
+        "feature_missing_counts": {
+          "SeniorCitizen": 0,
+          "tenure": 0,
+          "MonthlyCharges": 0,
+          "TotalCharges": 0,
+          "Partner": 0,
+          "Dependents": 0,
+          "PhoneService": 0,
+          "InternetService": 0,
+          "Contract": 0,
+          "PaymentMethod": 0
+        },
+        "sha256_first12": "5fa48a8d1aa1"
+      },
+      "validation_metrics": {
+        "roc_auc": 0.49782,
+        "pr_auc": 0.49893,
+        "balanced_accuracy": 0.5,
+        "precision": 0.49309,
+        "recall": 1.0,
+        "f1": 0.6605,
+        "f2": 0.82946,
+        "confusion_matrix": [
+          [
+            0,
+            477
+          ],
+          [
+            0,
+            464
+          ]
+        ],
+        "classification_report": {
+          "0": {
+            "precision": 0.0,
+            "recall": 0.0,
+            "f1-score": 0.0,
+            "support": 477.0
+          },
+          "1": {
+            "precision": 0.49309245483528164,
+            "recall": 1.0,
+            "f1-score": 0.6604982206405694,
+            "support": 464.0
+          },
+          "accuracy": 0.49309245483528164,
+          "macro avg": {
+            "precision": 0.24654622741764082,
+            "recall": 0.5,
+            "f1-score": 0.3302491103202847,
+            "support": 941.0
+          },
+          "weighted avg": {
+            "precision": 0.24314016901548424,
+            "recall": 0.49309245483528164,
+            "f1-score": 0.3256866890299938,
+            "support": 941.0
+          }
+        }
+      },
+      "test_metrics": {
+        "roc_auc": 0.47952,
+        "pr_auc": 0.4709,
+        "balanced_accuracy": 0.5,
+        "precision": 0.4932,
+        "recall": 1.0,
+        "f1": 0.66059,
+        "f2": 0.82952,
+        "confusion_matrix": [
+          [
+            0,
+            596
+          ],
+          [
+            0,
+            580
+          ]
+        ],
+        "classification_report": {
+          "0": {
+            "precision": 0.0,
+            "recall": 0.0,
+            "f1-score": 0.0,
+            "support": 596.0
+          },
+          "1": {
+            "precision": 0.4931972789115646,
+            "recall": 1.0,
+            "f1-score": 0.6605922551252847,
+            "support": 580.0
+          },
+          "accuracy": 0.4931972789115646,
+          "macro avg": {
+            "precision": 0.2465986394557823,
+            "recall": 0.5,
+            "f1-score": 0.33029612756264237,
+            "support": 1176.0
+          },
+          "weighted avg": {
+            "precision": 0.24324355592577165,
+            "recall": 0.4931972789115646,
+            "f1-score": 0.3258023026978445,
+            "support": 1176.0
+          }
+        }
+      },
+      "deployment_status": "research_only_low_signal",
+      "model_size_mb": 0.02,
+      "validation_model_comparison": [
+        {
+          "dataset": "telecom",
+          "model": "XGBoost",
+          "validation_pr_auc": 0.49893,
+          "validation_roc_auc": 0.49782,
+          "tuning": "6x3 CV"
+        },
+        {
+          "dataset": "telecom",
+          "model": "Logistic regression",
+          "validation_pr_auc": 0.48094,
+          "validation_roc_auc": 0.49748,
+          "tuning": "none"
+        },
+        {
+          "dataset": "telecom",
+          "model": "Random forest",
+          "validation_pr_auc": 0.47485,
+          "validation_roc_auc": 0.47279,
+          "tuning": "none"
+        }
+      ]
+    }
+  },
+  "decision_rule": "maximize validation F2 (recall-weighted), after selecting by validation PR AUC",
+  "probability_warning": "Scores are uncalibrated model probabilities; not validated as true churn probabilities."
+}

models/bank_churn.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a09f2ae9686f373e1f35bc5e14a7eff4bb40c2e672f8ce7c8e33a8d22888446
+size 38621

models/telecom_churn.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:618003aa3338238af7a9cefb178b41fd623dc53d51e9b86e949097b482dd9bfd
+size 21001

notebooks/Customer_Churn_Training_Walkthrough.ipynb

@@ -0,0 +1,129 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "49b7c97a",
+   "metadata": {},
+   "source": [
+    "# Customer Churn Model — Reproducible Training Walkthrough\n",
+    "\n",
+    "This public portfolio notebook trains two independent churn classifiers, audits data quality, compares three algorithms, and evaluates a final held-out test set. Upload the source CSVs when prompted. No data or secrets are committed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe218b6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip -q install \"numpy==2.3.5\" \"pandas==2.2.3\" \"scikit-learn==1.8.0\" \"xgboost==3.1.3\" \"joblib==1.5.3\" \"matplotlib>=3.8,<4\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5514f474",
+   "metadata": {},
+   "source": [
+    "## Upload your bank and telecom datasets\n",
+    "Select the same `bank_customer_churn.csv` and `customer_churn_data.csv` used in the full deployment notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "111b29e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import shutil\n",
+    "from google.colab import files\n",
+    "DATA=Path(\"/content/churn_inputs\"); DATA.mkdir(exist_ok=True)\n",
+    "uploaded=files.upload()\n",
+    "for name, raw in uploaded.items():\n",
+    "    if name.lower().endswith(\".csv\"):\n",
+    "        (DATA/Path(name).name).write_bytes(raw)\n",
+    "for canonical in [\"bank_customer_churn.csv\", \"customer_churn_data.csv\"]:\n",
+    "    if not (DATA/canonical).exists():\n",
+    "        alternates=sorted(DATA.glob(Path(canonical).stem+\"(*)\"+Path(canonical).suffix))\n",
+    "        if alternates: shutil.copy2(alternates[0],DATA/canonical)\n",
+    "    assert (DATA/canonical).exists(), f\"Missing {canonical}\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa8035d6",
+   "metadata": {},
+   "source": [
+    "## Data-safe reproducible training and held-out evaluation\n",
+    "The `train.py` source below is the identical source used in the Hugging Face release. Target labels and identifiers are excluded from features; model selection and threshold tuning use only validation data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fab89f88",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "TRAIN_SOURCE = '\"\"\"Reproducible bank + telecom churn training; no customer row data is published.\"\"\"\\nfrom __future__ import annotations\\nimport argparse\\nimport sys\\nimport hashlib\\nimport json\\nfrom datetime import datetime, timezone\\nfrom pathlib import Path\\n\\nimport joblib\\nimport matplotlib\\nmatplotlib.use(\\'Agg\\')\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport pandas as pd\\nimport sklearn\\nimport xgboost\\nfrom sklearn.compose import ColumnTransformer\\nfrom sklearn.ensemble import RandomForestClassifier\\nfrom sklearn.impute import SimpleImputer\\nfrom sklearn.inspection import permutation_importance\\nfrom sklearn.linear_model import LogisticRegression\\nfrom sklearn.metrics import (average_precision_score, balanced_accuracy_score,\\n    classification_report, confusion_matrix, ConfusionMatrixDisplay, f1_score,\\n    fbeta_score, precision_score, recall_score, roc_auc_score, roc_curve)\\nfrom sklearn.model_selection import RandomizedSearchCV, StratifiedKFold, train_test_split\\nfrom sklearn.pipeline import Pipeline\\nfrom sklearn.preprocessing import OneHotEncoder, StandardScaler\\nfrom xgboost import XGBClassifier\\n\\nSEED = 42\\nSPECS = {\\n    \\'bank\\': {\\n        \\'filename\\': \\'bank_customer_churn.csv\\', \\'target\\': \\'Exited\\',\\n        \\'numeric\\': [\\'CreditScore\\',\\'Age\\',\\'Tenure\\',\\'Balance\\',\\'NumOfProducts\\',\\'HasCrCard\\',\\'IsActiveMember\\',\\'EstimatedSalary\\'],\\n        \\'categorical\\': [\\'Geography\\'], \\'excluded\\': [\\'CustomerId\\',\\'Surname\\'],\\n        \\'display\\': \\'Bank customer churn\\',\\n    },\\n    \\'telecom\\': {\\n        \\'filename\\': \\'customer_churn_data.csv\\', \\'target\\': \\'Churn\\',\\n        \\'numeric\\': [\\'SeniorCitizen\\',\\'tenure\\',\\'MonthlyCharges\\',\\'TotalCharges\\'],\\n        \\'categorical\\': [\\'Partner\\',\\'Dependents\\',\\'PhoneService\\',\\'InternetService\\',\\'Contract\\',\\'PaymentMethod\\'],\\n        \\'excluded\\': [\\'customerID\\'], \\'display\\': \\'Telecom customer churn\\',\\n    },\\n}\\n\\ndef pyvalue(v):\\n    if isinstance(v, np.generic):\\n        return v.item()\\n    return v\\n\\ndef load_dataset(path, spec):\\n    if not path.is_file():\\n        raise FileNotFoundError(f\\'Required dataset missing: {path}. Upload the original CSV in Colab.\\')\\n    raw = pd.read_csv(path)\\n    required = spec[\\'numeric\\'] + spec[\\'categorical\\'] + [spec[\\'target\\']]\\n    missing = [c for c in required if c not in raw.columns]\\n    if missing:\\n        raise ValueError(f\\'{path.name}: missing columns {missing}. Found {list(raw.columns)}\\')\\n    original_rows = len(raw)\\n    frame = raw.drop_duplicates().copy()\\n    # Never use identifiers, surnames, or the label as predictors.\\n    X = frame[spec[\\'numeric\\'] + spec[\\'categorical\\']].copy()\\n    for col in spec[\\'numeric\\']:\\n        X[col] = pd.to_numeric(X[col], errors=\\'coerce\\')\\n    for col in spec[\\'categorical\\']:\\n        X[col] = X[col].astype(\\'string\\').str.strip().replace(\\'\\', pd.NA)\\n        X[col] = X[col].astype(object).where(X[col].notna(), np.nan)\\n    if spec[\\'target\\'] == \\'Churn\\':\\n        y = frame[spec[\\'target\\']].astype(\\'string\\').str.strip().str.lower().map({\\'yes\\': 1, \\'no\\': 0})\\n    else:\\n        y = pd.to_numeric(frame[spec[\\'target\\']], errors=\\'coerce\\')\\n    if y.isna().any() or not set(y.unique()).issubset({0, 1}):\\n        raise ValueError(f\\'{path.name}: target must be fully labeled binary 0/1 or Yes/No\\')\\n    y = y.astype(\\'int64\\')\\n    if y.value_counts().min() < 20:\\n        raise ValueError(f\\'{path.name}: insufficient positive/negative examples\\')\\n    audit = {\\n        \\'original_rows\\': int(original_rows),\\n        \\'duplicate_rows_removed\\': int(original_rows-len(frame)),\\n        \\'rows_after_deduplication\\': int(len(frame)),\\n        \\'positive_rate\\': round(float(y.mean()), 5),\\n        \\'feature_missing_counts\\': {col: int(X[col].isna().sum()) for col in X.columns},\\n        \\'sha256_first12\\': hashlib.sha256(path.read_bytes()).hexdigest()[:12],\\n    }\\n    return X, y, audit\\n\\ndef preprocessing(spec):\\n    numerical = Pipeline([(\\'impute\\', SimpleImputer(strategy=\\'median\\')),\\n                          (\\'scale\\', StandardScaler())])\\n    categorical = Pipeline([(\\'impute\\', SimpleImputer(strategy=\\'most_frequent\\')),\\n                            (\\'onehot\\', OneHotEncoder(handle_unknown=\\'ignore\\', sparse_output=False))])\\n    return ColumnTransformer([(\\'numeric\\', numerical, spec[\\'numeric\\']),\\n                              (\\'categorical\\', categorical, spec[\\'categorical\\'])],\\n                             remainder=\\'drop\\')\\n\\ndef score_proba(model, X):\\n    return model.predict_proba(X)[:, 1]\\n\\ndef metrics(y, p, threshold):\\n    pred = (p >= threshold).astype(int)\\n    return {\\n        \\'roc_auc\\': round(float(roc_auc_score(y, p)), 5),\\n        \\'pr_auc\\': round(float(average_precision_score(y, p)), 5),\\n        \\'balanced_accuracy\\': round(float(balanced_accuracy_score(y, pred)), 5),\\n        \\'precision\\': round(float(precision_score(y, pred, zero_division=0)), 5),\\n        \\'recall\\': round(float(recall_score(y, pred, zero_division=0)), 5),\\n        \\'f1\\': round(float(f1_score(y, pred, zero_division=0)), 5),\\n        \\'f2\\': round(float(fbeta_score(y, pred, beta=2, zero_division=0)), 5),\\n        \\'confusion_matrix\\': confusion_matrix(y, pred, labels=[0, 1]).tolist(),\\n        \\'classification_report\\': classification_report(y, pred, labels=[0, 1],\\n                                                     output_dict=True, zero_division=0),\\n    }\\n\\ndef tune_threshold(y, p):\\n    thresholds = np.round(np.arange(0.10, 0.901, 0.025), 3)\\n    values = [fbeta_score(y, (p >= t).astype(int), beta=2, zero_division=0) for t in thresholds]\\n    return float(thresholds[int(np.argmax(values))])\\n\\ndef plot_diagnostics(project, key, ytest, ptest, threshold, importance_df):\\n    report_dir = project / \\'reports\\'\\n    pred = (ptest >= threshold).astype(int)\\n    fig, ax = plt.subplots(figsize=(5, 4))\\n    ConfusionMatrixDisplay.from_predictions(ytest, pred, display_labels=[\\'Retained\\', \\'Churned\\'],\\n                                            cmap=\\'Blues\\', colorbar=False, ax=ax)\\n    ax.set_title(f\\'{key.title()} — untouched test data\\')\\n    fig.tight_layout()\\n    fig.savefig(report_dir / f\\'{key}_confusion_matrix.png\\', dpi=140)\\n    plt.close(fig)\\n    fpr, tpr, _ = roc_curve(ytest, ptest)\\n    fig, ax = plt.subplots(figsize=(5.5, 4))\\n    ax.plot(fpr, tpr, label=f\\'ROC AUC = {roc_auc_score(ytest, ptest):.3f}\\')\\n    ax.plot([0, 1], [0, 1], linestyle=\\'--\\', label=\\'Chance\\')\\n    ax.set(xlabel=\\'False positive rate\\', ylabel=\\'True positive rate\\', title=f\\'{key.title()} — test ROC\\')\\n    ax.legend(loc=\\'lower right\\')\\n    fig.tight_layout()\\n    fig.savefig(report_dir / f\\'{key}_roc.png\\', dpi=140)\\n    plt.close(fig)\\n    top = importance_df.head(10).sort_values(\\'importance_mean\\')\\n    fig, ax = plt.subplots(figsize=(7, 4.5))\\n    ax.barh(top[\\'feature\\'], top[\\'importance_mean\\'])\\n    ax.set(xlabel=\\'Change in validation PR AUC after shuffling\\', title=f\\'{key.title()} — permutation importance\\')\\n    fig.tight_layout()\\n    fig.savefig(report_dir / f\\'{key}_feature_importance.png\\', dpi=140)\\n    plt.close(fig)\\n\\ndef train_one(project, source_dir, key, tuning_iterations):\\n    spec = SPECS[key]\\n    path = source_dir / spec[\\'filename\\']\\n    X, y, audit = load_dataset(path, spec)\\n    X_dev, X_test, y_dev, y_test = train_test_split(X, y, test_size=0.20,\\n                                                    random_state=SEED, stratify=y)\\n    X_train, X_val, y_train, y_val = train_test_split(X_dev, y_dev, test_size=0.20,\\n                                                       random_state=SEED, stratify=y_dev)\\n    minority_weight = float((y_train == 0).sum() / (y_train == 1).sum())\\n    models = {\\n        \\'Logistic regression\\': LogisticRegression(max_iter=1500, class_weight=\\'balanced\\', random_state=SEED),\\n        \\'Random forest\\': RandomForestClassifier(n_estimators=170, min_samples_leaf=3,\\n                                                class_weight=\\'balanced_subsample\\', n_jobs=-1, random_state=SEED),\\n    }\\n    candidates = {}\\n    leaderboard = []\\n    for name, estimator in models.items():\\n        pipeline = Pipeline([(\\'preprocessor\\', preprocessing(spec)), (\\'model\\', estimator)])\\n        pipeline.fit(X_train, y_train)\\n        candidates[name] = pipeline\\n        row = metrics(y_val, score_proba(pipeline, X_val), 0.5)\\n        leaderboard.append({\\'dataset\\': key, \\'model\\': name, \\'validation_pr_auc\\': row[\\'pr_auc\\'],\\n                            \\'validation_roc_auc\\': row[\\'roc_auc\\'], \\'tuning\\': \\'none\\'})\\n    xgb_pipe = Pipeline([(\\'preprocessor\\', preprocessing(spec)),\\n        (\\'model\\', XGBClassifier(n_estimators=200, max_depth=3, learning_rate=0.05,\\n            subsample=0.9, colsample_bytree=0.9, scale_pos_weight=minority_weight,\\n            eval_metric=\\'logloss\\', tree_method=\\'hist\\', random_state=SEED, n_jobs=1))])\\n    if tuning_iterations:\\n        params = {\\n            \\'model__n_estimators\\': [100, 180, 260],\\n            \\'model__max_depth\\': [2, 3, 4],\\n            \\'model__learning_rate\\': [0.025, 0.05, 0.1],\\n            \\'model__subsample\\': [0.8, 1.0],\\n            \\'model__colsample_bytree\\': [0.8, 1.0],\\n            \\'model__min_child_weight\\': [1, 3],\\n        }\\n        search = RandomizedSearchCV(xgb_pipe, params, n_iter=tuning_iterations,\\n              scoring=\\'average_precision\\', cv=StratifiedKFold(3, shuffle=True, random_state=SEED),\\n              random_state=SEED, n_jobs=2, refit=True, verbose=0, error_score=\\'raise\\')\\n        search.fit(X_train, y_train)\\n        xgb_pipe = search.best_estimator_\\n        print(f\\'[{key}] XGBoost best 3-fold training CV PR AUC: {search.best_score_:.4f}\\')\\n    else:\\n        xgb_pipe.fit(X_train, y_train)\\n    candidates[\\'XGBoost\\'] = xgb_pipe\\n    val_xgb = metrics(y_val, score_proba(xgb_pipe, X_val), 0.5)\\n    leaderboard.append({\\'dataset\\': key, \\'model\\': \\'XGBoost\\',\\n        \\'validation_pr_auc\\': val_xgb[\\'pr_auc\\'], \\'validation_roc_auc\\': val_xgb[\\'roc_auc\\'],\\n        \\'tuning\\': f\\'{tuning_iterations}x3 CV\\' if tuning_iterations else \\'off\\'})\\n    leaderboard.sort(key=lambda r: (r[\\'validation_pr_auc\\'], r[\\'validation_roc_auc\\']), reverse=True)\\n    winner = leaderboard[0][\\'model\\']\\n    champion = candidates[winner]\\n    threshold = tune_threshold(y_val, score_proba(champion, X_val))\\n    # The test partition has never been used to choose model, hyperparameters, or threshold.\\n    test_scores = score_proba(champion, X_test)\\n    test = metrics(y_test, test_scores, threshold)\\n    # Deliberate launch-quality gate: near-chance classifiers remain research-only.\\n    # Hold-out data are used for final model assessment, not training/selection.\\n    reliable = (test[\\'roc_auc\\'] >= 0.60 and test[\\'pr_auc\\'] >= float(y_test.mean()) + 0.03)\\n    deployment_status = \\'demonstration\\' if reliable else \\'research_only_low_signal\\'\\n    if not reliable:\\n        print(f\\'[{key}] WARNING: near-chance model; API will not issue actionable churn labels.\\')\\n    val = metrics(y_val, score_proba(champion, X_val), threshold)\\n    defaults = {c: float(X_train[c].median()) for c in spec[\\'numeric\\']}\\n    categories = {}\\n    for col in spec[\\'categorical\\']:\\n        vals = X_train[col].dropna().astype(str)\\n        categories[col] = sorted(vals.unique().tolist())\\n        defaults[col] = str(vals.mode().iloc[0])\\n    importance = permutation_importance(champion, X_val, y_val, scoring=\\'average_precision\\',\\n                                        n_repeats=3, random_state=SEED, n_jobs=1)\\n    importance_df = pd.DataFrame({\\'feature\\': spec[\\'numeric\\'] + spec[\\'categorical\\'],\\n        \\'importance_mean\\': importance.importances_mean, \\'importance_std\\': importance.importances_std})\\n    importance_df = importance_df.sort_values(\\'importance_mean\\', ascending=False)\\n    importance_df.to_csv(project / \\'reports\\' / f\\'{key}_feature_importance.csv\\', index=False)\\n    plot_diagnostics(project, key, y_test, test_scores, threshold, importance_df)\\n    bundle = {\\'pipeline\\': champion, \\'threshold\\': threshold,\\n              \\'numeric\\': spec[\\'numeric\\'], \\'categorical\\': spec[\\'categorical\\'], \\'features\\': spec[\\'numeric\\'] + spec[\\'categorical\\']}\\n    path_model = project / \\'models\\' / f\\'{key}_churn.joblib\\'\\n    joblib.dump(bundle, path_model, compress=3)\\n    reloaded = joblib.load(path_model)\\n    assert np.allclose(reloaded[\\'pipeline\\'].predict_proba(X_test.iloc[:5])[:,1], test_scores[:5])\\n    metadata = {\\n       \\'label\\': spec[\\'display\\'], \\'selected_model\\': winner,\\n       \\'numeric\\': spec[\\'numeric\\'], \\'categorical\\': spec[\\'categorical\\'],\\n       \\'features\\': spec[\\'numeric\\'] + spec[\\'categorical\\'],\\n       \\'excluded_columns\\': spec[\\'excluded\\'], \\'categorical_choices\\': categories,\\n       \\'defaults\\': defaults, \\'threshold\\': threshold,\\n       \\'training_rows\\': len(X_train), \\'validation_rows\\': len(X_val), \\'test_rows\\': len(X_test),\\n       \\'audit\\': audit, \\'validation_metrics\\': val, \\'test_metrics\\': test,\\n       \\'deployment_status\\': deployment_status,\\n       \\'model_size_mb\\': round(path_model.stat().st_size / 1024**2, 3),\\n       \\'validation_model_comparison\\': leaderboard,\\n    }\\n    print(f\\'[{key}] Winner: {winner}, threshold: {threshold:.3f}, \\'\\n          f\\'test PR AUC: {test[\"pr_auc\"]:.4f}, ROC AUC: {test[\"roc_auc\"]:.4f}, recall: {test[\"recall\"]:.4f}\\')\\n    return metadata, leaderboard\\n\\ndef main(data_dir=\\'.\\', project_dir=\\'.\\', tuning_iterations=6):\\n    project = Path(project_dir).resolve()\\n    data_dir = Path(data_dir).resolve()\\n    (project / \\'models\\').mkdir(parents=True, exist_ok=True)\\n    (project / \\'reports\\').mkdir(parents=True, exist_ok=True)\\n    results, leaderboard = {}, []\\n    for key in SPECS:\\n        print(f\\'\\\\n=== TRAINING {key.upper()} ===\\')\\n        results[key], comparison = train_one(project, data_dir, key, tuning_iterations)\\n        leaderboard.extend(comparison)\\n    summary = {\\'generated_utc\\': datetime.now(timezone.utc).isoformat(),\\n      \\'random_seed\\': SEED, \\'sklearn_version\\': sklearn.__version__,\\n      \\'xgboost_version\\': xgboost.__version__, \\'python_version\\': sys.version.split()[0], \\'datasets\\': results,\\n      \\'decision_rule\\': \\'maximize validation F2 (recall-weighted), after selecting by validation PR AUC\\',\\n      \\'probability_warning\\': \\'Scores are uncalibrated model probabilities; not validated as true churn probabilities.\\'}\\n    (project / \\'model_metadata.json\\').write_text(json.dumps(summary, indent=2, default=pyvalue), encoding=\\'utf-8\\')\\n    pd.DataFrame(leaderboard).to_csv(project / \\'reports\\' / \\'model_comparison.csv\\', index=False)\\n    print(\\'\\\\nSaved trained pipelines, evaluation, charts, and audit metadata to\\', project)\\n    return summary\\n\\nif __name__ == \\'__main__\\':\\n    parser = argparse.ArgumentParser()\\n    parser.add_argument(\\'--data-dir\\', default=\\'.\\')\\n    parser.add_argument(\\'--project-dir\\', default=\\'.\\')\\n    parser.add_argument(\\'--tuning-iterations\\', type=int, default=6)\\n    args = parser.parse_args()\\n    main(args.data_dir, args.project_dir, args.tuning_iterations)\\n'\n",
+    "Path(\"train.py\").write_text(TRAIN_SOURCE, encoding=\"utf-8\")\n",
+    "import sklearn, xgboost\n",
+    "assert (sklearn.__version__,xgboost.__version__)==(\"1.8.0\",\"3.1.3\"), \"Restart Colab runtime after install and rerun cells\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "097cd908",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib.util\n",
+    "spec=importlib.util.spec_from_file_location(\"churn_training\", \"train.py\")\n",
+    "module=importlib.util.module_from_spec(spec)\n",
+    "spec.loader.exec_module(module)\n",
+    "results=module.main(data_dir=DATA,project_dir=Path(\"/content/churn-intelligence-lab\"),tuning_iterations=6)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "185df73a",
+   "metadata": {},
+   "source": [
+    "## Compare model performance and diagnostics\n",
+    "The quality gate marks a near-chance classifier as research-only. The test partition is independent of validation-based selection."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffcd1d62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import display, Image\n",
+    "import pandas as pd\n",
+    "P=Path(\"/content/churn-intelligence-lab\")\n",
+    "display(pd.read_csv(P/\"reports\"/\"model_comparison.csv\"))\n",
+    "for segment in (\"bank\",\"telecom\"):\n",
+    "    print(segment.upper(),results[\"datasets\"][segment][\"test_metrics\"])\n",
+    "    display(Image(filename=str(P/\"reports\"/f\"{segment}_roc.png\"),width=550))\n",
+    "    display(Image(filename=str(P/\"reports\"/f\"{segment}_feature_importance.png\"),width=550))"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

reports/bank_feature_importance.csv

@@ -0,0 +1,10 @@
+feature,importance_mean,importance_std
+Age,0.26445187371299056,0.020430558670981074
+NumOfProducts,0.24834748937180307,0.008799324747770149
+IsActiveMember,0.09675602920420179,0.005445308581024779
+Balance,0.0753602399656933,0.0046094855266077565
+Geography,0.06101594766852877,0.0020921889588975118
+CreditScore,0.004736756017056698,0.0006832834776869457
+EstimatedSalary,0.0031848726894710966,0.001764580082232362
+HasCrCard,-0.0002528830199832373,0.0005843858996471953
+Tenure,-0.00034052985012456016,0.0020594317889659907

reports/model_comparison.csv

@@ -0,0 +1,7 @@
+dataset,model,validation_pr_auc,validation_roc_auc,tuning
+bank,XGBoost,0.68442,0.85564,6x3 CV
+bank,Random forest,0.68408,0.86424,none
+bank,Logistic regression,0.45514,0.75422,none
+telecom,XGBoost,0.49893,0.49782,6x3 CV
+telecom,Logistic regression,0.48094,0.49748,none
+telecom,Random forest,0.47485,0.47279,none

reports/telecom_feature_importance.csv

@@ -0,0 +1,11 @@
+feature,importance_mean,importance_std
+MonthlyCharges,0.01157943277453157,0.004786441332147423
+PaymentMethod,0.0021447557360410228,0.0020976124157429167
+Dependents,0.0005530449833317889,0.000222747091901983
+Contract,0.0005015827719847173,0.0013145344028538154
+SeniorCitizen,0.0,0.0
+Partner,-0.00035698457050259425,0.0003064753166891028
+PhoneService,-0.0005407161681062663,0.00033801364566065804
+tenure,-0.001093924683967314,0.009684521252210336
+TotalCharges,-0.006343578030426789,0.007965392546590323
+InternetService,-0.00818567707629129,0.0003004453118950846

requirements.txt

@@ -0,0 +1,9 @@
+numpy==2.3.5
+pandas==2.2.3
+scikit-learn==1.8.0
+xgboost==3.1.3
+joblib==1.5.3
+fastapi==0.128.2
+gradio==6.5.1
+uvicorn==0.48.0
+pydantic==2.13.5

tests/test_api.py

@@ -0,0 +1,63 @@
+"""Run after training: python -m pytest -q tests/"""
+import json
+from pathlib import Path
+from fastapi.testclient import TestClient
+from app import app, META, predict_records
+
+client = TestClient(app)
+
+def test_health():
+    r = client.get('/health')
+    assert r.status_code == 200
+    assert set(r.json()['trained_models']) == {'bank', 'telecom'}
+
+def test_ui_redirect():
+    r = client.get('/', follow_redirects=False)
+    assert r.status_code in (302, 307, 308)
+    assert r.headers['location'] == '/ui/'
+
+def test_predictions():
+    for segment, info in META.items():
+        sample = info['defaults']
+        r = client.post(f'/api/predict/{segment}', json={'data': sample})
+        assert r.status_code == 200, r.text
+        result = r.json()
+        assert 0 <= result['churn_score'] <= 1
+        assert result['prediction'] in ('Likely to churn', 'Likely to stay',
+                                       'Exploratory only — unreliable classifier')
+        if segment == 'telecom' and info['deployment_status'] != 'demonstration':
+            assert result['prediction'].startswith('Exploratory only')
+        r_batch = client.post(f'/api/predict-batch/{segment}', json={'records': [sample, sample]})
+        assert r_batch.status_code == 200, r_batch.text
+        assert len(r_batch.json()['results']) == 2
+        assert r_batch.json()['results'][0]['churn_score'] == result['churn_score']
+
+def test_invalid_fields_rejected():
+    r = client.post('/api/predict/bank', json={'data': {'Age': 40}})
+    assert r.status_code == 422
+    r2 = client.post('/api/predict/not-a-model', json={'data': META['bank']['defaults']})
+    assert r2.status_code == 422
+
+def test_no_identifiers_in_model_schema():
+    for name, info in META.items():
+        assert not set(info['features']) & set(info['excluded_columns'])
+        assert len(info['features']) >= 9
+
+
+def test_swagger_documentation():
+    response = client.get('/openapi.json')
+    assert response.status_code == 200
+    assert '/api/predict/bank' not in response.json()['paths']  # routing uses path template
+    assert '/api/predict/{segment}' in response.json()['paths']
+
+def test_unexpected_category_or_nonfinite_rejected():
+    bank = dict(META['bank']['defaults'])
+    bank['Geography'] = 'UNLISTED'
+    assert client.post('/api/predict/bank', json={'data':bank}).status_code == 422
+    bank = dict(META['bank']['defaults'])
+    bank['Age'] = 'not-a-number'
+    assert client.post('/api/predict/bank', json={'data':bank}).status_code == 422
+
+def test_batch_above_limit_rejected():
+    payload = {'records':[dict(META['bank']['defaults']) for _ in range(101)]}
+    assert client.post('/api/predict-batch/bank', json=payload).status_code == 422

train.py

@@ -0,0 +1,271 @@
+"""Reproducible bank + telecom churn training; no customer row data is published."""
+from __future__ import annotations
+import argparse
+import sys
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import joblib
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import sklearn
+import xgboost
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.impute import SimpleImputer
+from sklearn.inspection import permutation_importance
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (average_precision_score, balanced_accuracy_score,
+    classification_report, confusion_matrix, ConfusionMatrixDisplay, f1_score,
+    fbeta_score, precision_score, recall_score, roc_auc_score, roc_curve)
+from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold, train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from xgboost import XGBClassifier
+
+SEED = 42
+SPECS = {
+    'bank': {
+        'filename': 'bank_customer_churn.csv', 'target': 'Exited',
+        'numeric': ['CreditScore','Age','Tenure','Balance','NumOfProducts','HasCrCard','IsActiveMember','EstimatedSalary'],
+        'categorical': ['Geography'], 'excluded': ['CustomerId','Surname'],
+        'display': 'Bank customer churn',
+    },
+    'telecom': {
+        'filename': 'customer_churn_data.csv', 'target': 'Churn',
+        'numeric': ['SeniorCitizen','tenure','MonthlyCharges','TotalCharges'],
+        'categorical': ['Partner','Dependents','PhoneService','InternetService','Contract','PaymentMethod'],
+        'excluded': ['customerID'], 'display': 'Telecom customer churn',
+    },
+}
+
+def pyvalue(v):
+    if isinstance(v, np.generic):
+        return v.item()
+    return v
+
+def load_dataset(path, spec):
+    if not path.is_file():
+        raise FileNotFoundError(f'Required dataset missing: {path}. Upload the original CSV in Colab.')
+    raw = pd.read_csv(path)
+    required = spec['numeric'] + spec['categorical'] + [spec['target']]
+    missing = [c for c in required if c not in raw.columns]
+    if missing:
+        raise ValueError(f'{path.name}: missing columns {missing}. Found {list(raw.columns)}')
+    original_rows = len(raw)
+    frame = raw.drop_duplicates().copy()
+    # Never use identifiers, surnames, or the label as predictors.
+    X = frame[spec['numeric'] + spec['categorical']].copy()
+    for col in spec['numeric']:
+        X[col] = pd.to_numeric(X[col], errors='coerce')
+    for col in spec['categorical']:
+        X[col] = X[col].astype('string').str.strip().replace('', pd.NA)
+        X[col] = X[col].astype(object).where(X[col].notna(), np.nan)
+    if spec['target'] == 'Churn':
+        y = frame[spec['target']].astype('string').str.strip().str.lower().map({'yes': 1, 'no': 0})
+    else:
+        y = pd.to_numeric(frame[spec['target']], errors='coerce')
+    if y.isna().any() or not set(y.unique()).issubset({0, 1}):
+        raise ValueError(f'{path.name}: target must be fully labeled binary 0/1 or Yes/No')
+    y = y.astype('int64')
+    if y.value_counts().min() < 20:
+        raise ValueError(f'{path.name}: insufficient positive/negative examples')
+    audit = {
+        'original_rows': int(original_rows),
+        'duplicate_rows_removed': int(original_rows-len(frame)),
+        'rows_after_deduplication': int(len(frame)),
+        'positive_rate': round(float(y.mean()), 5),
+        'feature_missing_counts': {col: int(X[col].isna().sum()) for col in X.columns},
+        'sha256_first12': hashlib.sha256(path.read_bytes()).hexdigest()[:12],
+    }
+    return X, y, audit
+
+def preprocessing(spec):
+    numerical = Pipeline([('impute', SimpleImputer(strategy='median')),
+                          ('scale', StandardScaler())])
+    categorical = Pipeline([('impute', SimpleImputer(strategy='most_frequent')),
+                            ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))])
+    return ColumnTransformer([('numeric', numerical, spec['numeric']),
+                              ('categorical', categorical, spec['categorical'])],
+                             remainder='drop')
+
+def score_proba(model, X):
+    return model.predict_proba(X)[:, 1]
+
+def metrics(y, p, threshold):
+    pred = (p >= threshold).astype(int)
+    return {
+        'roc_auc': round(float(roc_auc_score(y, p)), 5),
+        'pr_auc': round(float(average_precision_score(y, p)), 5),
+        'balanced_accuracy': round(float(balanced_accuracy_score(y, pred)), 5),
+        'precision': round(float(precision_score(y, pred, zero_division=0)), 5),
+        'recall': round(float(recall_score(y, pred, zero_division=0)), 5),
+        'f1': round(float(f1_score(y, pred, zero_division=0)), 5),
+        'f2': round(float(fbeta_score(y, pred, beta=2, zero_division=0)), 5),
+        'confusion_matrix': confusion_matrix(y, pred, labels=[0, 1]).tolist(),
+        'classification_report': classification_report(y, pred, labels=[0, 1],
+                                                     output_dict=True, zero_division=0),
+    }
+
+def tune_threshold(y, p):
+    thresholds = np.round(np.arange(0.10, 0.901, 0.025), 3)
+    values = [fbeta_score(y, (p >= t).astype(int), beta=2, zero_division=0) for t in thresholds]
+    return float(thresholds[int(np.argmax(values))])
+
+def plot_diagnostics(project, key, ytest, ptest, threshold, importance_df):
+    report_dir = project / 'reports'
+    pred = (ptest >= threshold).astype(int)
+    fig, ax = plt.subplots(figsize=(5, 4))
+    ConfusionMatrixDisplay.from_predictions(ytest, pred, display_labels=['Retained', 'Churned'],
+                                            cmap='Blues', colorbar=False, ax=ax)
+    ax.set_title(f'{key.title()} — untouched test data')
+    fig.tight_layout()
+    fig.savefig(report_dir / f'{key}_confusion_matrix.png', dpi=140)
+    plt.close(fig)
+    fpr, tpr, _ = roc_curve(ytest, ptest)
+    fig, ax = plt.subplots(figsize=(5.5, 4))
+    ax.plot(fpr, tpr, label=f'ROC AUC = {roc_auc_score(ytest, ptest):.3f}')
+    ax.plot([0, 1], [0, 1], linestyle='--', label='Chance')
+    ax.set(xlabel='False positive rate', ylabel='True positive rate', title=f'{key.title()} — test ROC')
+    ax.legend(loc='lower right')
+    fig.tight_layout()
+    fig.savefig(report_dir / f'{key}_roc.png', dpi=140)
+    plt.close(fig)
+    top = importance_df.head(10).sort_values('importance_mean')
+    fig, ax = plt.subplots(figsize=(7, 4.5))
+    ax.barh(top['feature'], top['importance_mean'])
+    ax.set(xlabel='Change in validation PR AUC after shuffling', title=f'{key.title()} — permutation importance')
+    fig.tight_layout()
+    fig.savefig(report_dir / f'{key}_feature_importance.png', dpi=140)
+    plt.close(fig)
+
+def train_one(project, source_dir, key, tuning_iterations):
+    spec = SPECS[key]
+    path = source_dir / spec['filename']
+    X, y, audit = load_dataset(path, spec)
+    X_dev, X_test, y_dev, y_test = train_test_split(X, y, test_size=0.20,
+                                                    random_state=SEED, stratify=y)
+    X_train, X_val, y_train, y_val = train_test_split(X_dev, y_dev, test_size=0.20,
+                                                       random_state=SEED, stratify=y_dev)
+    minority_weight = float((y_train == 0).sum() / (y_train == 1).sum())
+    models = {
+        'Logistic regression': LogisticRegression(max_iter=1500, class_weight='balanced', random_state=SEED),
+        'Random forest': RandomForestClassifier(n_estimators=170, min_samples_leaf=3,
+                                                class_weight='balanced_subsample', n_jobs=-1, random_state=SEED),
+    }
+    candidates = {}
+    leaderboard = []
+    for name, estimator in models.items():
+        pipeline = Pipeline([('preprocessor', preprocessing(spec)), ('model', estimator)])
+        pipeline.fit(X_train, y_train)
+        candidates[name] = pipeline
+        row = metrics(y_val, score_proba(pipeline, X_val), 0.5)
+        leaderboard.append({'dataset': key, 'model': name, 'validation_pr_auc': row['pr_auc'],
+                            'validation_roc_auc': row['roc_auc'], 'tuning': 'none'})
+    xgb_pipe = Pipeline([('preprocessor', preprocessing(spec)),
+        ('model', XGBClassifier(n_estimators=200, max_depth=3, learning_rate=0.05,
+            subsample=0.9, colsample_bytree=0.9, scale_pos_weight=minority_weight,
+            eval_metric='logloss', tree_method='hist', random_state=SEED, n_jobs=1))])
+    if tuning_iterations:
+        params = {
+            'model__n_estimators': [100, 180, 260],
+            'model__max_depth': [2, 3, 4],
+            'model__learning_rate': [0.025, 0.05, 0.1],
+            'model__subsample': [0.8, 1.0],
+            'model__colsample_bytree': [0.8, 1.0],
+            'model__min_child_weight': [1, 3],
+        }
+        search = RandomizedSearchCV(xgb_pipe, params, n_iter=tuning_iterations,
+              scoring='average_precision', cv=StratifiedKFold(3, shuffle=True, random_state=SEED),
+              random_state=SEED, n_jobs=2, refit=True, verbose=0, error_score='raise')
+        search.fit(X_train, y_train)
+        xgb_pipe = search.best_estimator_
+        print(f'[{key}] XGBoost best 3-fold training CV PR AUC: {search.best_score_:.4f}')
+    else:
+        xgb_pipe.fit(X_train, y_train)
+    candidates['XGBoost'] = xgb_pipe
+    val_xgb = metrics(y_val, score_proba(xgb_pipe, X_val), 0.5)
+    leaderboard.append({'dataset': key, 'model': 'XGBoost',
+        'validation_pr_auc': val_xgb['pr_auc'], 'validation_roc_auc': val_xgb['roc_auc'],
+        'tuning': f'{tuning_iterations}x3 CV' if tuning_iterations else 'off'})
+    leaderboard.sort(key=lambda r: (r['validation_pr_auc'], r['validation_roc_auc']), reverse=True)
+    winner = leaderboard[0]['model']
+    champion = candidates[winner]
+    threshold = tune_threshold(y_val, score_proba(champion, X_val))
+    # The test partition has never been used to choose model, hyperparameters, or threshold.
+    test_scores = score_proba(champion, X_test)
+    test = metrics(y_test, test_scores, threshold)
+    # Deliberate launch-quality gate: near-chance classifiers remain research-only.
+    # Hold-out data are used for final model assessment, not training/selection.
+    reliable = (test['roc_auc'] >= 0.60 and test['pr_auc'] >= float(y_test.mean()) + 0.03)
+    deployment_status = 'demonstration' if reliable else 'research_only_low_signal'
+    if not reliable:
+        print(f'[{key}] WARNING: near-chance model; API will not issue actionable churn labels.')
+    val = metrics(y_val, score_proba(champion, X_val), threshold)
+    defaults = {c: float(X_train[c].median()) for c in spec['numeric']}
+    categories = {}
+    for col in spec['categorical']:
+        vals = X_train[col].dropna().astype(str)
+        categories[col] = sorted(vals.unique().tolist())
+        defaults[col] = str(vals.mode().iloc[0])
+    importance = permutation_importance(champion, X_val, y_val, scoring='average_precision',
+                                        n_repeats=3, random_state=SEED, n_jobs=1)
+    importance_df = pd.DataFrame({'feature': spec['numeric'] + spec['categorical'],
+        'importance_mean': importance.importances_mean, 'importance_std': importance.importances_std})
+    importance_df = importance_df.sort_values('importance_mean', ascending=False)
+    importance_df.to_csv(project / 'reports' / f'{key}_feature_importance.csv', index=False)
+    plot_diagnostics(project, key, y_test, test_scores, threshold, importance_df)
+    bundle = {'pipeline': champion, 'threshold': threshold,
+              'numeric': spec['numeric'], 'categorical': spec['categorical'], 'features': spec['numeric'] + spec['categorical']}
+    path_model = project / 'models' / f'{key}_churn.joblib'
+    joblib.dump(bundle, path_model, compress=3)
+    reloaded = joblib.load(path_model)
+    assert np.allclose(reloaded['pipeline'].predict_proba(X_test.iloc[:5])[:,1], test_scores[:5])
+    metadata = {
+       'label': spec['display'], 'selected_model': winner,
+       'numeric': spec['numeric'], 'categorical': spec['categorical'],
+       'features': spec['numeric'] + spec['categorical'],
+       'excluded_columns': spec['excluded'], 'categorical_choices': categories,
+       'defaults': defaults, 'threshold': threshold,
+       'training_rows': len(X_train), 'validation_rows': len(X_val), 'test_rows': len(X_test),
+       'audit': audit, 'validation_metrics': val, 'test_metrics': test,
+       'deployment_status': deployment_status,
+       'model_size_mb': round(path_model.stat().st_size / 1024**2, 3),
+       'validation_model_comparison': leaderboard,
+    }
+    print(f'[{key}] Winner: {winner}, threshold: {threshold:.3f}, '
+          f'test PR AUC: {test["pr_auc"]:.4f}, ROC AUC: {test["roc_auc"]:.4f}, recall: {test["recall"]:.4f}')
+    return metadata, leaderboard
+
+def main(data_dir='.', project_dir='.', tuning_iterations=6):
+    project = Path(project_dir).resolve()
+    data_dir = Path(data_dir).resolve()
+    (project / 'models').mkdir(parents=True, exist_ok=True)
+    (project / 'reports').mkdir(parents=True, exist_ok=True)
+    results, leaderboard = {}, []
+    for key in SPECS:
+        print(f'\n=== TRAINING {key.upper()} ===')
+        results[key], comparison = train_one(project, data_dir, key, tuning_iterations)
+        leaderboard.extend(comparison)
+    summary = {'generated_utc': datetime.now(timezone.utc).isoformat(),
+      'random_seed': SEED, 'sklearn_version': sklearn.__version__,
+      'xgboost_version': xgboost.__version__, 'python_version': sys.version.split()[0], 'datasets': results,
+      'decision_rule': 'maximize validation F2 (recall-weighted), after selecting by validation PR AUC',
+      'probability_warning': 'Scores are uncalibrated model probabilities; not validated as true churn probabilities.'}
+    (project / 'model_metadata.json').write_text(json.dumps(summary, indent=2, default=pyvalue), encoding='utf-8')
+    pd.DataFrame(leaderboard).to_csv(project / 'reports' / 'model_comparison.csv', index=False)
+    print('\nSaved trained pipelines, evaluation, charts, and audit metadata to', project)
+    return summary
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data-dir', default='.')
+    parser.add_argument('--project-dir', default='.')
+    parser.add_argument('--tuning-iterations', type=int, default=6)
+    args = parser.parse_args()
+    main(args.data_dir, args.project_dir, args.tuning_iterations)