# Training vs test data — the basics
import pandas as pd
from sklearn.model_selection import train_test_split

# Load a dataset
df = pd.read_csv("churn.csv")

# Features (X) and label (y)
X = df.drop(columns=["churned"])   # features
y = df["churned"]                  # label (target)

# Split into training (80%) and test (20%)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print("Train:", X_train.shape)
print("Test: ", X_test.shape)

# Features and labels — a concrete example
# Predict whether a customer churns (yes/no)

# Features (what the model sees)
# - tenure_months
# - monthly_charges
# - support_tickets
# - plan_type

# Label (what we predict)
# - churned: 0 = stayed, 1 = churned

import pandas as pd

df = pd.DataFrame({
    "tenure_months":   [12, 3, 24, 1],
    "monthly_charges": [500, 800, 350, 1200],
    "support_tickets": [0, 5, 1, 8],
    "churned":         [0, 1, 0, 1],
})

X = df.drop(columns=["churned"])
y = df["churned"]
print(X.shape, y.shape)

# Epochs and learning rate with sklearn
from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

model = make_pipeline(
    StandardScaler(),
    SGDClassifier(
        loss="log_loss",
        learning_rate="constant",
        eta0=0.01,          # learning rate
        max_iter=20,        # ≈ epochs
        random_state=42,
    ),
)

model.fit(X_train, y_train)

# The model has now seen the training data
# 20 times (20 epochs) at learning rate 0.01.

# Overfitting demo — train vs test accuracy
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

for depth in [1, 3, 10, 30]:
    model = DecisionTreeClassifier(
        max_depth=depth, random_state=42
    )
    model.fit(X_train, y_train)

    train_acc = accuracy_score(y_train, model.predict(X_train))
    test_acc  = accuracy_score(y_test,  model.predict(X_test))

    print(f"depth={depth:2d}  "
          f"train={train_acc:.3f}  "
          f"test={test_acc:.3f}")

# Shallow trees underfit; very deep trees
# overfit — high train acc, lower test acc.

# Classification metrics
from sklearn.metrics import (
    accuracy_score, precision_score,
    recall_score, f1_score,
    confusion_matrix, roc_auc_score,
)

y_pred  = model.predict(X_test)
y_proba = model.predict_proba(X_test)[:, 1]

print("Accuracy: ", accuracy_score(y_test, y_pred))
print("Precision:", precision_score(y_test, y_pred))
print("Recall:   ", recall_score(y_test, y_pred))
print("F1:       ", f1_score(y_test, y_pred))
print("ROC-AUC:  ", roc_auc_score(y_test, y_proba))
print("Confusion matrix:")
print(confusion_matrix(y_test, y_pred))

# Regression metrics
from sklearn.metrics import (
    mean_absolute_error,
    mean_squared_error,
    r2_score,
)
import numpy as np

y_pred = model.predict(X_test)

mae  = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2   = r2_score(y_test, y_pred)

print(f"MAE:  {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"R²:   {r2:.3f}")

# MAE  = average absolute error
# RMSE = penalises large errors more
# R²   = fraction of variance explained

# FastAPI — serve a trained model
from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("churn_model.joblib")

class Customer(BaseModel):
    tenure_months:   int
    monthly_charges: float
    support_tickets: int

@app.post("/predict")
def predict(c: Customer):
    features = [[
        c.tenure_months,
        c.monthly_charges,
        c.support_tickets,
    ]]
    proba = model.predict_proba(features)[0][1]
    return {"churn_probability": round(float(proba), 3)}

# Data drift — simple distribution comparison
import pandas as pd
from scipy.stats import ks_2samp

# Training distribution vs current production data
train = pd.read_csv("train.csv")
live  = pd.read_csv("live.csv")

for col in ["tenure_months", "monthly_charges"]:
    stat, p = ks_2samp(train[col], live[col])
    drift = "DRIFT" if p < 0.05 else "ok"
    print(f"{col:18s} p={p:.4f}  {drift}")

# A low p-value suggests the distributions
# differ — consider retraining or investigating.