ML in Production & Ethics

1. Model Monitoring: Drift Detection

Models degrade in production because the world changes. Two distinct types of drift require different responses.

Population Stability Index (PSI)

PSI quantifies how much a feature's distribution has shifted between training time and scoring time:

Thresholds: PSI < 0.10 — stable; 0.10–0.25 — investigate; ≥ 0.25 — retrain or escalate.

import numpy as np

def psi(expected: np.ndarray, actual: np.ndarray, n_bins: int = 10) -> float:
    """
    Compute Population Stability Index.
    expected: training-time distribution (1-D array of values or bin proportions)
    actual:   scoring-time distribution
    """
    # Bin using training-time quantiles
    breakpoints = np.percentile(expected, np.linspace(0, 100, n_bins + 1))
    breakpoints[0]  = -np.inf
    breakpoints[-1] =  np.inf

    expected_pcts = np.histogram(expected, bins=breakpoints)[0] / len(expected)
    actual_pcts   = np.histogram(actual,   bins=breakpoints)[0] / len(actual)

    # Clip to avoid log(0)
    expected_pcts = np.clip(expected_pcts, 1e-6, None)
    actual_pcts   = np.clip(actual_pcts,   1e-6, None)

    return float(np.sum((actual_pcts - expected_pcts) * np.log(actual_pcts / expected_pcts)))

# Usage
psi_income = psi(train_df['annual_income'].values, score_df['annual_income'].values)
print(f"PSI (annual_income): {psi_income:.4f}")
if psi_income >= 0.25:
    print("WARNING: significant drift — consider retraining")
elif psi_income >= 0.10:
    print("CAUTION: moderate drift — investigate")
else:
    print("OK: distribution is stable")

2. Model Explainability with SHAP

SHAP (SHapley Additive exPlanations) decomposes any model's prediction into the marginal contribution of each feature, grounded in cooperative game theory. It is the industry standard for both global model explanation and individual prediction explanation in regulated industries.

import shap
import xgboost as xgb
import pandas as pd
import matplotlib.pyplot as plt

# Train model
model = xgb.XGBClassifier(n_estimators=200, max_depth=4, random_state=42)
model.fit(X_train, y_train)

# Create explainer and compute SHAP values
explainer   = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)   # shape: (n_samples, n_features)

# --- Global explanation: summary plot ---
shap.summary_plot(shap_values, X_test, plot_type='bar')   # feature importance
shap.summary_plot(shap_values, X_test)                    # beeswarm (direction + magnitude)

# --- Individual explanation: waterfall / force plot ---
sample_idx = 0
shap.waterfall_plot(shap.Explanation(
    values    = shap_values[sample_idx],
    base_values = explainer.expected_value,
    data      = X_test.iloc[sample_idx],
    feature_names = X_test.columns.tolist()
))

# --- SHAP drift monitoring ---
# Average absolute SHAP value per feature — track over time
mean_shap_train = np.abs(explainer.shap_values(X_train)).mean(axis=0)
mean_shap_score = np.abs(shap_values).mean(axis=0)
shap_drift = pd.DataFrame({
    'feature':    X_test.columns,
    'shap_train': mean_shap_train,
    'shap_score': mean_shap_score,
    'ratio':      mean_shap_score / np.clip(mean_shap_train, 1e-8, None)
}).sort_values('ratio', ascending=False)
print(shap_drift.head(10))

3. Fairness and Fair Lending

Under ECOA (Equal Credit Opportunity Act) and the Fair Housing Act, Capital One credit models must not have a disparate impact on protected classes (race, gender, national origin, age, etc.) or treat applicants differently based on protected characteristics (disparate treatment).

Disparate Impact Ratio (4/5 Rule)

The approval rate for a protected group divided by the approval rate for the most-approved group. A ratio below 0.80 triggers fair lending review.

import pandas as pd

def disparate_impact_ratio(df: pd.DataFrame,
                            decision_col: str,
                            group_col: str,
                            reference_group: str) -> pd.DataFrame:
    """Compute DIR for all groups relative to the reference group."""
    approval_rates = df.groupby(group_col)[decision_col].mean()
    ref_rate       = approval_rates[reference_group]
    dir_table      = (approval_rates / ref_rate).reset_index()
    dir_table.columns = [group_col, 'DIR']
    dir_table['flag'] = dir_table['DIR'].apply(
        lambda x: 'REVIEW REQUIRED' if x < 0.80 else 'OK'
    )
    return dir_table.sort_values('DIR')

result = disparate_impact_ratio(
    df            = decisions_df,
    decision_col  = 'approved',
    group_col     = 'race_category',
    reference_group = 'White'
)
print(result)

Fairness Metrics and the Impossibility Theorem

Chouldechova's impossibility theorem: When base rates differ across groups, it is mathematically impossible to simultaneously satisfy calibration, equal opportunity, and equalized odds. Capital One must choose which criterion to prioritize based on legal requirements and business context — and document the choice explicitly for SR 11-7.

4. Champion/Challenger and Deployment

Champion/Challenger (C/C) is the standard production deployment strategy for high-stakes ML models at Capital One. It routes a controlled percentage of live traffic to the challenger model while the champion handles the remainder, enabling real-world performance comparison before full promotion.

SMOTE and Data Leakage

SMOTE (Synthetic Minority Over-sampling Technique) generates synthetic minority class samples by interpolating between existing minority samples. A critical error is applying SMOTE before train/test split.

Why this causes leakage: Synthetic samples are interpolations of real samples. If applied to the full dataset before splitting, synthetic test samples may be near-neighbors of real training samples — the model has effectively seen the test distribution during training, producing optimistically biased evaluation metrics.

from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTE
import xgboost as xgb
from sklearn.metrics import roc_auc_score

# CORRECT: split first, then apply SMOTE only to training data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

smote = SMOTE(random_state=42, k_neighbors=5)
X_train_res, y_train_res = smote.fit_resample(X_train, y_train)
# X_test is never touched by SMOTE — it reflects real-world distribution

model = xgb.XGBClassifier(n_estimators=200, random_state=42, eval_metric='logloss')
model.fit(X_train_res, y_train_res,
          eval_set=[(X_test, y_test)],
          verbose=False)

auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])
print(f"AUC on unmodified test set: {auc:.4f}")

# WRONG (never do this):
# smote = SMOTE(random_state=42)
# X_res, y_res = smote.fit_resample(X, y)          # leaks test distribution
# X_train, X_test, ... = train_test_split(X_res, y_res, ...)  # too late