"""
SCOPE OF WORK — Credit Default Risk Model
==========================================
Client:       Finova Lending Group
Project:      Predict probability that a loan applicant will default within 12 months.

PROBLEM TYPE: Binary classification (default=1, no default=0)
TARGET:       loan_default (1 = defaulted within 12 months)

SUCCESS METRICS:
  Primary:    AUC-ROC >= 0.82 on held-out test set
  Secondary:  Recall >= 0.70 at a precision threshold of 0.60
              (catch 70% of defaults while keeping false positives manageable)

DATA REQUIREMENTS:
  - 3 years of loan application records (~150,000 rows)
  - Features: applicant income, credit score, debt-to-income ratio,
              loan amount, loan purpose, employment length, home ownership
  - Label: binary flag from payment records team (already available)

CONSTRAINTS:
  - Model must be explainable (regulatory requirement — SHAP values required)
  - Inference latency: < 200ms per application
  - No use of race, gender, or protected attributes as direct features
  - Data stored on-premises — no cloud processing of raw PII

DELIVERABLES:
  1. EDA report with data quality findings
  2. Trained model (XGBoost or Logistic Regression) + SHAP analysis
  3. FastAPI inference endpoint with Swagger docs
  4. Monthly drift monitoring report (PSI on input features)

TIMELINE: 8 weeks (EDA: wk1-2, Modeling: wk3-5, Deploy: wk6-7, Monitor setup: wk8)
"""

import pandas as pd

df = pd.read_csv('loan_applications.csv')

# Quick data quality audit
print("Shape:", df.shape)
print("\nMissing values (%):")
print((df.isnull().mean() * 100).sort_values(ascending=False).head(10))

print("\nValue counts for key categorical columns:")
print(df['loan_purpose'].value_counts())

print("\nNumerical summary:")
print(df[['income', 'loan_amount', 'credit_score']].describe())

# Check for obvious data quality issues
print("\nInvalid ages (< 18 or > 100):")
print(df[(df['age'] < 18) | (df['age'] > 100)].shape[0])

print("\nNegative income rows:")
print(df[df['income'] < 0].shape[0])

"""
Iteration Loop:
  1. Train baseline model on raw features
  2. Examine feature importances and error cases
  3. Form hypothesis: "credit_utilization_ratio might help"
  4. Engineer new feature, add to pipeline
  5. Retrain, compare metrics
  6. If improved: keep feature; if not: drop it
  7. Repeat until diminishing returns
"""

# Iteration 1: baseline features
baseline_features = ['income', 'loan_amount', 'credit_score', 'employment_years']

# After EDA insight: credit utilization is highly predictive
# Iteration 2: add engineered feature
df['credit_utilization'] = df['revolving_balance'] / df['credit_limit']
df['debt_to_income']      = df['total_debt'] / df['annual_income']
df['loan_to_income']      = df['loan_amount'] / df['annual_income']

enhanced_features = baseline_features + ['credit_utilization', 'debt_to_income', 'loan_to_income']

# A sneak peek at what model comparison looks like in practice.
# Every model below is a Phase 2 lesson (11-24); every one follows the
# same 3-button interface: .fit() / .predict() / .score()
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

# Always start with a baseline
models = {
    'Logistic Regression (baseline)': LogisticRegression(max_iter=1000),
    'Decision Tree':                  DecisionTreeClassifier(max_depth=5),
    'Random Forest':                  RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting':              GradientBoostingClassifier(n_estimators=100, random_state=42),
}

results = {}
for name, model in models.items():
    # cross_val_score: train/score 5 times on rotating folds (see Lesson 10)
    scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')
    results[name] = scores.mean()
    print(f"{name:40s}  accuracy = {scores.mean():.4f} ± {scores.std():.4f}")

# Pick the best model, then fine-tune it
# Logistic Regression (baseline)              accuracy = 0.7812 ± 0.0124
# Decision Tree                               accuracy = 0.7941 ± 0.0198
# Random Forest                               accuracy = 0.8347 ± 0.0087
# Gradient Boosting                           accuracy = 0.8512 ± 0.0063  <-- winner
# (In practice you'd often score with metrics from Lessons 19-20 instead)

# GridSearchCV tries every combination of the settings below and
# cross-validates each one — a tool you'll learn to wield in Lesson 27.
# For now, just see WHERE tuning sits in the lifecycle.
from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators':    [100, 200, 300],
    'max_depth':       [3, 5, 7],
    'learning_rate':   [0.05, 0.1, 0.2],
    'subsample':       [0.8, 1.0],
}

grid_search = GridSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)
grid_search.fit(X_train, y_train)

print("Best params:", grid_search.best_params_)
print("Best CV accuracy:", grid_search.best_score_)
# Best params: {'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 200, 'subsample': 0.8}
# Best CV accuracy: 0.8589

import joblib
import pickle

# joblib — recommended for sklearn models (handles large arrays efficiently)
joblib.dump(grid_search.best_estimator_, 'credit_risk_model_v1.pkl')

# Load it back
model = joblib.load('credit_risk_model_v1.pkl')

# Make a prediction (same as the original model)
sample = [[65000, 25000, 720, 3, 0.28, 0.38, 0.38]]  # 7 features
prob = model.predict_proba(sample)[0][1]
print(f"Default probability: {prob:.3f}")  # e.g., 0.124

# app.py  — minimal FastAPI inference endpoint
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI(title="Credit Risk API", version="1.0")
model = joblib.load("credit_risk_model_v1.pkl")

class LoanApplication(BaseModel):
    annual_income:       float
    loan_amount:         float
    credit_score:        int
    employment_years:    int
    credit_utilization:  float
    debt_to_income:      float
    loan_to_income:      float

@app.post("/predict")
def predict_default_risk(application: LoanApplication):
    features = [[
        application.annual_income,
        application.loan_amount,
        application.credit_score,
        application.employment_years,
        application.credit_utilization,
        application.debt_to_income,
        application.loan_to_income,
    ]]
    prob = model.predict_proba(features)[0][1]
    decision = "HIGH RISK" if prob > 0.35 else "LOW RISK"
    return {"default_probability": round(prob, 4), "decision": decision}

# Run with: uvicorn app:app --reload
# Test: POST http://localhost:8000/predict

import numpy as np
import pandas as pd

def calculate_psi(expected, actual, buckets=10):
    """
    Population Stability Index (PSI).
    PSI < 0.1:  stable — no significant change
    PSI 0.1-0.2: slight shift — investigate
    PSI > 0.2:  significant drift — consider retraining
    """
    expected_pct = np.histogram(expected, bins=buckets)[0] / len(expected)
    actual_pct   = np.histogram(actual,   bins=np.histogram(expected, bins=buckets)[1])[0] / len(actual)

    # Avoid log(0)
    expected_pct = np.where(expected_pct == 0, 0.0001, expected_pct)
    actual_pct   = np.where(actual_pct == 0,   0.0001, actual_pct)

    psi = np.sum((actual_pct - expected_pct) * np.log(actual_pct / expected_pct))
    return psi

# Compare training distribution vs recent production data
train_income    = df_train['annual_income'].values
current_income  = df_production_last_30d['annual_income'].values

psi_score = calculate_psi(train_income, current_income)
print(f"PSI for annual_income: {psi_score:.4f}")
# PSI for annual_income: 0.0312  → stable ✓

import mlflow
import mlflow.sklearn

# Track an experiment
with mlflow.start_run(run_name="GradientBoosting_v2"):
    mlflow.log_params(grid_search.best_params_)
    mlflow.log_metric("cv_auc",   grid_search.best_score_)
    mlflow.log_metric("test_auc", roc_auc_score(y_test, y_pred_proba))
    mlflow.sklearn.log_model(grid_search.best_estimator_, "model")
    print("Run logged to MLflow. View at: mlflow ui")