Classification supervisée
Niveau expert Data Scientist

1. Formalisation du problème

Un problème de classification consiste à apprendre une fonction f : X → Y où X ∈ ℝⁿ est l'espace des features et Y = {c₁, c₂, ..., cₖ} un ensemble fini de classes. L'objectif est de minimiser la perte empirique sur un ensemble d'entraînement tout en maximisant la capacité de généralisation sur de nouvelles données.

2. Frontière de décision et hyperplan séparateur

La plupart des classifieurs linéaires apprennent un hyperplan wᵀx + b = 0 qui partitionne l'espace des features. La qualité de cette frontière dépend de la marge (SVM), de l'entropie (arbres), ou de la vraisemblance (régression logistique).

• Régression logistique : modélise P(y=1|x) = σ(wᵀx + b) via la sigmoïde. Optimisation par descente de gradient ou Newton-Raphson. La régularisation L1 (Lasso) induit la sparsité des poids ; L2 (Ridge) les contracte vers zéro.
• LDA (Analyse discriminante linéaire) : suppose une distribution gaussienne par classe avec covariance partagée. Maximise le critère de Fisher : ratio variance inter-classe / intra-classe.
• Naive Bayes : applique le théorème de Bayes avec hypothèse d'indépendance conditionnelle des features. Très rapide, efficace en haute dimension et pour le NLP (Multinomial NB sur TF-IDF).

3. Biais-Variance Trade-off

L'erreur de généralisation se décompose : Erreur = Biais² + Variance + Bruit irréductible.

• Biais élevé (underfitting) : modèle trop simple — régression logistique sur données non linéaires, arbre de profondeur 1.
• Variance élevée (overfitting) : modèle trop complexe — arbre sans élagage sur peu de données, réseau de neurones trop large.
• Remèdes : régularisation (L1/L2/dropout), ensemble methods (averaging réduit la variance), early stopping, augmentation de données, cross-validation.

4. Théorème No Free Lunch

Aucun algorithme ne domine universellement tous les autres sur tous les problèmes. Ce théorème justifie pourquoi il faut toujours comparer plusieurs modèles sur vos données spécifiques — il n'existe pas de meilleur algorithme universel.

5. Probabilités calibrées

Un modèle peut produire de bonnes prédictions binaires mais des probabilités mal calibrées. La calibration est critique dans les domaines où les scores de confiance pilotent des décisions métier (médecine, scoring crédit, assurance).

from sklearn.calibration import CalibratedClassifierCV, calibration_curve
import matplotlib.pyplot as plt

# Calibration isotonic (non paramétrique) ou Platt scaling (sigmoid)
calibrated = CalibratedClassifierCV(base_clf, method='isotonic', cv=5)
calibrated.fit(X_train, y_train)

# Courbe de calibration (reliability diagram)
prob_true, prob_pred = calibration_curve(
    y_test, calibrated.predict_proba(X_test)[:,1], n_bins=10)
plt.plot(prob_pred, prob_true, marker='o', label='Modèle calibré')
plt.plot([0,1],[0,1], 'k--', label='Calibration parfaite')
plt.xlabel('Probabilité prédite')
plt.ylabel('Fréquence réelle')
plt.legend()
plt.title('Reliability Diagram')

1. Support Vector Machine (SVM)

Le SVM cherche l'hyperplan qui maximise la marge entre les classes. Les vecteurs supports sont les observations les plus proches de la frontière — seuls eux déterminent le modèle final.

• Kernel trick : projette implicitement les données dans un espace de dimension supérieure sans calcul explicite. Noyau RBF : K(x,x') = exp(-γ‖x-x'‖²), le plus polyvalent.
• C : compromis biais-variance. C petit → grande marge, tolérance aux erreurs. C grand → marge étroite, risque d'overfitting.
• γ (RBF) : rayon d'influence de chaque point. γ élevé → frontière très sinueuse, overfitting probable.
• Complexité : O(n² à n³) — à éviter pour n > 100 000 (préférer LinearSVC ou SGDClassifier).

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# StandardScaler indispensable — SVM sensible à l'échelle
pipe_svm = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', SVC(kernel='rbf', C=10, gamma='scale', probability=True))
])
pipe_svm.fit(X_train, y_train)
print(f"AUC : {roc_auc_score(y_test, pipe_svm.predict_proba(X_test)[:,1]):.4f}")

2. Random Forest

Ensemble de n arbres de décision entraînés sur des sous-échantillons bootstrap (bagging) avec sélection aléatoire de features à chaque nœud (max_features). Vote majoritaire en classification.

• Avantages : robuste au bruit et aux outliers, pas de normalisation requise, Feature Importance native, parallélisable.
• n_estimators : 200–500 en pratique. Convergence asymptotique — plus n augmente, plus la variance diminue.
• Feature Importance MDI : attention, biaisée vers les variables continues à haute cardinalité. Préférer Permutation Importance pour une évaluation honnête.
• Out-of-Bag score : estimation gratuite du score de généralisation via les observations non sélectionnées par le bootstrap.

from sklearn.ensemble import RandomForestClassifier
import pandas as pd

rf = RandomForestClassifier(
    n_estimators=300,
    max_features='sqrt',        # racine du nombre de features à chaque nœud
    min_samples_leaf=5,         # évite les feuilles trop petites
    class_weight='balanced',    # compense le déséquilibre
    oob_score=True,             # validation OOB gratuite
    random_state=42, n_jobs=-1
)
rf.fit(X_train, y_train)
print(f"OOB score : {rf.oob_score_:.4f}")

# Feature importance MDI
importances = pd.Series(rf.feature_importances_, index=feature_names)
print(importances.sort_values(ascending=False).head(10))

3. XGBoost & LightGBM — Gradient Boosting

Le boosting construit les arbres séquentiellement : chaque arbre prédit les résidus du précédent (pseudo-résidus du gradient de la fonction de perte). XGBoost utilise Newton Boosting (gradient du 2ème ordre) ; LightGBM la croissance leaf-wise.

• learning_rate + n_estimators + early_stopping : trilogie incontournable. Petit learning_rate + early_stopping = meilleure généralisation.
• max_depth : 3–6 en général. Les arbres peu profonds (stumps) limitent l'overfitting.
• subsample & colsample_bytree : stochasticité qui régularise et accélère.
• scale_pos_weight : ratio négatifs/positifs pour les datasets déséquilibrés.
• LightGBM : 3–10x plus rapide que XGBoost sur grands datasets. Utiliser num_leaves plutôt que max_depth.

import xgboost as xgb
from sklearn.model_selection import train_test_split

X_tr, X_val, y_tr, y_val = train_test_split(
    X_train, y_train, test_size=0.2, stratify=y_train, random_state=42)

model = xgb.XGBClassifier(
    n_estimators=1000,
    learning_rate=0.05,
    max_depth=5,
    subsample=0.8,
    colsample_bytree=0.8,
    scale_pos_weight=sum(y_train==0)/sum(y_train==1),
    eval_metric='auc',
    early_stopping_rounds=50,
    random_state=42, n_jobs=-1
)
model.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], verbose=100)
print(f"Best iteration : {model.best_iteration}")

4. Comparatif algorithmique

1. Pourquoi l'accuracy est trompeuse

Sur un dataset avec 99% de négatifs, un modèle qui prédit toujours "négatif" obtient 99% d'accuracy — mais est totalement inutile. L'accuracy est une mauvaise métrique pour les classes déséquilibrées.

2. Matrice de confusion et métriques dérivées

Prédit Positif   Prédit Négatif
Réel Positif  |  TP (Vrai +)    |  FN (Faux -)   |
Réel Négatif  |  FP (Faux +)    |  TN (Vrai -)   |

Precision   = TP / (TP + FP)         → "quand je dis positif, j'ai raison à X%"
Recall      = TP / (TP + FN)         → "je trouve X% des vrais positifs"
F1-Score    = 2 × (P × R) / (P + R) → harmonie Precision/Recall
Specificity = TN / (TN + FP)         → taux de vrais négatifs identifiés
F-beta      = (1+β²)×P×R / (β²P+R)  → β>1 favorise Recall, β<1 favorise Precision

• Maximiser Precision : quand un faux positif est coûteux (spam — éviter de classer un email légitime en spam).
• Maximiser Recall : quand un faux négatif est coûteux (cancer — éviter de rater un malade).
• F1 : compromis utile sur classes déséquilibrées.

3. ROC-AUC vs PR-AUC

La courbe ROC trace le Recall (TPR) vs le taux de faux positifs (FPR) pour tous les seuils possibles. L'AUC mesure la capacité discriminante indépendamment du seuil.

• AUC = 0.5 → aléatoire ; AUC = 1.0 → parfait. Seuil pratique : AUC > 0.85 pour production.
• Attention déséquilibre : ROC-AUC peut être optimiste. Sur classes très déséquilibrées, préférer PR-AUC (Average Precision) — plus sensible aux performances sur la classe minoritaire.

from sklearn.metrics import (roc_auc_score, average_precision_score,
                             classification_report, ConfusionMatrixDisplay,
                             RocCurveDisplay, PrecisionRecallDisplay)
import matplotlib.pyplot as plt

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

print(f"ROC-AUC  : {roc_auc_score(y_test, y_proba):.4f}")
print(f"PR-AUC   : {average_precision_score(y_test, y_proba):.4f}")
print(classification_report(y_test, y_pred, digits=4))

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=axes[0])
PrecisionRecallDisplay.from_predictions(y_test, y_proba, ax=axes[1])
plt.tight_layout()

4. Optimisation du seuil de décision

Le seuil par défaut (0.5) n'est optimal que si les coûts des erreurs sont égaux. En pratique, optimiser le seuil selon la métrique métier.

from sklearn.metrics import precision_recall_curve
import numpy as np

precisions, recalls, thresholds = precision_recall_curve(y_test, y_proba)

# Seuil optimal pour F1
f1_scores = 2 * (precisions[:-1] * recalls[:-1]) / (precisions[:-1] + recalls[:-1] + 1e-8)
best_thresh = thresholds[np.argmax(f1_scores)]
print(f"Seuil optimal F1 : {best_thresh:.3f}")

# Seuil optimal pour Recall >= 0.9 (ex: détection cancer)
recall_target = np.where(recalls >= 0.90)[0]
if len(recall_target) > 0:
    thresh_recall = thresholds[recall_target[-1]]
    print(f"Seuil pour Recall≥0.90 : {thresh_recall:.3f}")

5. Validation robuste : Stratified K-Fold

La validation croisée stratifiée garantit que chaque fold conserve la proportion des classes — indispensable sur des jeux déséquilibrés.

from sklearn.model_selection import StratifiedKFold, cross_validate

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

scores = cross_validate(model, X, y, cv=skf,
    scoring=['roc_auc', 'average_precision', 'f1'],
    return_train_score=True)

for metric in ['roc_auc', 'average_precision', 'f1']:
    val = scores[f'test_{metric}']
    train = scores[f'train_{metric}']
    print(f"{metric:22s} val: {val.mean():.4f}±{val.std():.4f}  "
          f"train: {train.mean():.4f}  gap: {train.mean()-val.mean():.4f}")

1. Pourquoi c'est un problème majeur

La plupart des problèmes métier réels sont déséquilibrés : fraude (<1%), détection de pannes (1–5%), diagnostic rare (2–10%). Un modèle naïf apprend à ignorer la classe minoritaire car cela maximise l'accuracy.

2. Stratégie 1 — class_weight

Solution la plus simple et souvent très efficace. Pénalise davantage les erreurs sur la classe minoritaire pendant l'entraînement sans modifier les données.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Automatique : poids inversement proportionnels à la fréquence
lr = LogisticRegression(class_weight='balanced', max_iter=1000)
rf = RandomForestClassifier(class_weight='balanced', n_estimators=200)

# Manuel : ratio exact négatifs/positifs (utile pour XGBoost)
import numpy as np
ratio = sum(y_train==0) / sum(y_train==1)
# xgb.XGBClassifier(scale_pos_weight=ratio)

3. Stratégie 2 — SMOTE et variantes

SMOTE (Synthetic Minority Over-sampling TEchnique) génère des exemples synthétiques de la classe minoritaire par interpolation entre voisins existants. Plus robuste que le simple re-sampling qui duplique des exemples.

from imblearn.over_sampling import SMOTE, ADASYN, BorderlineSMOTE
from imblearn.combine import SMOTETomek, SMOTEENN
from collections import Counter

print(f"Avant : {Counter(y_train)}")

# SMOTE classique
smote = SMOTE(sampling_strategy=0.5, k_neighbors=5, random_state=42)
X_res, y_res = smote.fit_resample(X_train, y_train)
print(f"Après SMOTE : {Counter(y_res)}")

# ADASYN : génère plus d'exemples là où la classification est difficile
adasyn = ADASYN(sampling_strategy=0.5, random_state=42)

# SMOTETomek : oversampling + nettoyage frontière (Tomek Links)
smotetomek = SMOTETomek(random_state=42)
X_res2, y_res2 = smotetomek.fit_resample(X_train, y_train)

4. Pipeline sécurisé avec imbalanced-learn

Critique : SMOTE ne doit s'appliquer qu'à l'entraînement, jamais au test. Utiliser la Pipeline d'imbalanced-learn garantit cela dans la cross-validation.

from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.over_sampling import SMOTE
from sklearn.preprocessing import StandardScaler
import xgboost as xgb

pipe_imb = ImbPipeline([
    ('scaler', StandardScaler()),
    ('smote', SMOTE(sampling_strategy=0.3, random_state=42)),
    ('clf', xgb.XGBClassifier(n_estimators=200, random_state=42))
])

# SMOTE s'applique seulement sur les données d'entraînement à chaque fold
scores = cross_validate(pipe_imb, X, y,
    cv=StratifiedKFold(5, shuffle=True, random_state=42),
    scoring=['roc_auc', 'average_precision'], n_jobs=-1)
print(f"PR-AUC : {scores['test_average_precision'].mean():.4f}")

5. Guide de choix

• Ratio 1:5 à 1:20 : commencer par class_weight='balanced'.
• Ratio 1:50 à 1:100 : SMOTE + class_weight combinés.
• Ratio > 1:100 ou <50 exemples minoritaires : ADASYN + changer de métrique, ou reformuler comme détection d'anomalies (Isolation Forest, Autoencoder).
• Toujours évaluer avec PR-AUC et F1, jamais l'accuracy.

1. GridSearchCV vs RandomizedSearchCV

• GridSearchCV : exhaustif, optimal pour ≤3 hyperparamètres avec peu de valeurs. Complexité exponentielle.
• RandomizedSearchCV : échantillonne n_iter combinaisons. 90% de l'efficacité de Grid pour 10% du coût. Recommandé dès 3+ hyperparamètres.

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

param_dist = {
    'n_estimators': randint(100, 800),
    'max_depth': randint(3, 8),
    'learning_rate': uniform(0.01, 0.29),
    'subsample': uniform(0.6, 0.4),
    'colsample_bytree': uniform(0.6, 0.4),
    'min_child_weight': randint(1, 10),
    'gamma': uniform(0, 0.5)
}

search = RandomizedSearchCV(
    xgb.XGBClassifier(eval_metric='auc', random_state=42),
    param_distributions=param_dist,
    n_iter=100,
    cv=StratifiedKFold(5),
    scoring='roc_auc',
    n_jobs=-1, random_state=42, verbose=1
)
search.fit(X_train, y_train)
print(f"Meilleur AUC : {search.best_score_:.4f}")
print(search.best_params_)

2. Optuna — optimisation bayésienne (TPE)

Optuna utilise le TPE (Tree-structured Parzen Estimator) pour explorer intelligemment l'espace des hyperparamètres. Bien supérieur au random search sur des espaces complexes — chaque essai informe le suivant.

import optuna
optuna.logging.set_verbosity(optuna.logging.WARNING)

def objective(trial):
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
        'max_depth': trial.suggest_int('max_depth', 3, 8),
        'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.3, log=True),
        'subsample': trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-8, 10.0, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-8, 10.0, log=True),
    }
    clf = xgb.XGBClassifier(**params, eval_metric='auc',
                             random_state=42, n_jobs=-1)
    return cross_val_score(clf, X_train, y_train,
                           cv=StratifiedKFold(5), scoring='roc_auc').mean()

study = optuna.create_study(direction='maximize',
    sampler=optuna.samplers.TPESampler(seed=42))
study.optimize(objective, n_trials=150, n_jobs=-1)
print(f"Meilleur AUC : {study.best_value:.4f}")
optuna.visualization.plot_param_importances(study)  # visualise l'importance des HP

3. Nested Cross-Validation — l'évaluation rigoureuse

La validation croisée imbriquée est le protocole correct pour évaluer et sélectionner un modèle sans biais optimiste. La boucle interne sélectionne les hyperparamètres ; la boucle externe évalue la généralisation.

from sklearn.model_selection import cross_val_score

outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)

inner_search = RandomizedSearchCV(
    xgb.XGBClassifier(random_state=42),
    param_dist, n_iter=30, cv=inner_cv,
    scoring='roc_auc', n_jobs=-1
)

# Score non biaisé de généralisation
nested_scores = cross_val_score(inner_search, X, y, cv=outer_cv, scoring='roc_auc')
print(f"AUC (nested CV) : {nested_scores.mean():.4f} ± {nested_scores.std():.4f}")

4. Stacking — méta-apprentissage

from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression

estimators = [
    ('rf', RandomForestClassifier(n_estimators=200, class_weight='balanced', random_state=42)),
    ('xgb', xgb.XGBClassifier(n_estimators=200, scale_pos_weight=ratio, random_state=42)),
    ('lr', LogisticRegression(class_weight='balanced', C=1, max_iter=1000))
]

# Le méta-modèle apprend à combiner les prédictions des modèles de base
stack = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(C=0.1),
    cv=5,
    stack_method='predict_proba'
)
stack.fit(X_train, y_train)
print(f"Stacking AUC : {roc_auc_score(y_test, stack.predict_proba(X_test)[:,1]):.4f}")

1. Pourquoi l'interprétabilité est indispensable

Le RGPD (Article 22) impose un droit à l'explication pour toute décision automatisée affectant une personne. En dehors du cadre légal, l'interprétabilité permet de détecter des biais discriminatoires, de valider que le modèle apprend les bonnes corrélations, et de gagner la confiance des équipes métier et des auditeurs.

2. SHAP (SHapley Additive exPlanations)

SHAP repose sur les valeurs de Shapley (théorie des jeux coopératifs). Pour chaque prédiction, il attribue à chaque feature une contribution marginale calculée en moyennant sur toutes les coalitions possibles. Propriétés : efficacité, symétrie, linéarité, nulle si inutile. C'est la méthode la plus rigoureuse mathématiquement.

import shap

# TreeExplainer : O(TLD) au lieu de O(2^n) — optimisé pour les arbres
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# 1. Feature importance globale (beeswarm)
shap.summary_plot(shap_values, X_test, feature_names=feature_names)

# 2. Explication individuelle (waterfall)
shap.plots.waterfall(explainer(X_test)[0])

# 3. Dépendance partielle SHAP entre 2 features
shap.dependence_plot('anciennete_client', shap_values, X_test,
                     interaction_index='montant_transaction',
                     feature_names=feature_names)

# 4. SHAP force plot (prédiction individuelle)
shap.force_plot(explainer.expected_value,
                shap_values[0,:], X_test[0,:],
                feature_names=feature_names)

3. LIME (Local Interpretable Model-agnostic Explanations)

LIME explique localement une prédiction en entraînant un modèle linéaire simple sur des perturbations de l'instance. Moins rigoureux que SHAP mais applicable à tout modèle — y compris les réseaux de neurones, les pipelines de NLP ou les modèles sans accès aux arbres internes.

from lime.lime_tabular import LimeTabularExplainer

lime_exp = LimeTabularExplainer(
    X_train,
    feature_names=feature_names,
    class_names=['Négatif', 'Positif'],
    discretize_continuous=True,
    mode='classification'
)

# Expliquer l'instance n°42
exp = lime_exp.explain_instance(
    X_test[42],
    model.predict_proba,
    num_features=10,
    num_samples=5000
)
exp.as_pyplot_figure()  # ou exp.show_in_notebook()

4. Permutation Importance

Mesure la baisse de performance quand une feature est permutée aléatoirement. Contrairement à la Feature Importance MDI, elle n'est pas biaisée par la cardinalité et est valable sur tout modèle.

from sklearn.inspection import permutation_importance
import pandas as pd

perm = permutation_importance(
    model, X_test, y_test,
    n_repeats=30,
    scoring='roc_auc',
    random_state=42, n_jobs=-1
)

perm_df = pd.DataFrame({
    'feature': feature_names,
    'mean': perm.importances_mean,
    'std': perm.importances_std
}).sort_values('mean', ascending=False)

# Features avec importance négative = bruit ou collinéarité
print(perm_df.to_string(index=False))

5. Partial Dependence Plots (PDP) & ICE Curves

Les PDP montrent l'effet marginal moyen d'une feature sur la prédiction. Les ICE (Individual Conditional Expectation) tracent la même courbe pour chaque observation — elles révèlent les interactions et l'hétérogénéité que les PDP masquent.

from sklearn.inspection import PartialDependenceDisplay

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# PDP + ICE pour une feature continue
PartialDependenceDisplay.from_estimator(
    model, X_test,
    features=['montant_transaction'],
    kind='both',              # 'average'=PDP, 'individual'=ICE, 'both'=les deux
    feature_names=feature_names,
    grid_resolution=50,
    ax=axes[0]
)

# PDP d'interaction (2D) entre deux features
PartialDependenceDisplay.from_estimator(
    model, X_test,
    features=[('montant_transaction', 'anciennete_client')],
    kind='average',
    feature_names=feature_names,
    ax=axes[1]
)
plt.tight_layout()

1. Architecture d'un pipeline production complet

Données brutes (DB, API, streaming)
    ↓ [Validation : Great Expectations / Pydantic]
Feature Store / preprocessing pipeline
    ↓ [Pipeline Scikit-learn sérialisé — zéro data leakage]
Modèle versionné (MLflow / DVC)
    ↓ [API REST FastAPI — scoring temps réel ou batch]
Monitoring continu (PSI, AUC drift, distribution scores)
    ↓ [Alerting si drift détecté — Grafana / Evidently]
Re-training automatique (Airflow / GitHub Actions CI/CD)

2. Sérialisation et versioning du modèle

import joblib, mlflow

# Sauvegarder le pipeline complet (preprocessing + modèle)
joblib.dump(pipe, 'models/clf_fraud_v1.0.pkl')

# Versioning avec MLflow
with mlflow.start_run(run_name="xgb_fraud_v1.0"):
    mlflow.log_params(study.best_params)
    mlflow.log_metric("roc_auc_test", roc_auc_score(y_test, y_proba))
    mlflow.log_metric("pr_auc_test", average_precision_score(y_test, y_proba))
    mlflow.log_metric("f1_test", f1_score(y_test, y_pred, average='weighted'))
    mlflow.log_artifact("reports/shap_summary.png")
    mlflow.sklearn.log_model(pipe, "model",
                             registered_model_name="FraudClassifier")
    mlflow.set_tags({"dataset": "2024-Q1", "smote_ratio": "0.3"})

3. API de scoring avec FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, validator
import joblib, numpy as np, time

app = FastAPI(title="Fraud Classifier API")
model = joblib.load("models/clf_fraud_v1.0.pkl")
THRESHOLD = 0.35  # seuil optimisé pour Recall >= 0.88

class TransactionFeatures(BaseModel):
    montant: float
    anciennete_client: int
    nb_transactions_30j: int
    pays_origine: str
    heure_transaction: int

    @validator('montant')
    def montant_positive(cls, v):
        if v < 0:
            raise ValueError('Le montant doit être positif')
        return v

@app.post("/predict")
def predict(data: TransactionFeatures):
    start = time.time()
    X = np.array([[data.montant, data.anciennete_client,
                   data.nb_transactions_30j, data.heure_transaction]])
    proba = float(model.predict_proba(X)[0, 1])
    label = int(proba >= THRESHOLD)
    return {
        "probabilite_fraude": round(proba, 4),
        "prediction": label,
        "alerte": label == 1,
        "latence_ms": round((time.time() - start) * 1000, 1)
    }

@app.get("/health")
def health():
    return {"status": "ok", "model_version": "1.0"}

4. Monitoring — détection du data drift

Un modèle peut se dégrader silencieusement si la distribution des données en production change (concept drift ou data drift). Indicateurs à surveiller en continu :

• PSI (Population Stability Index) : mesure le glissement de distribution feature par feature. PSI < 0.1 : stable. 0.1–0.25 : surveiller. > 0.25 : re-training urgent.
• AUC temporel : calculer l'AUC sur des fenêtres glissantes de 7 jours. Une chute > 3% signale un drift de concept.
• Distribution des scores : si les scores de probabilité se concentrent autour de 0.5, le modèle devient incertain.

from evidently.report import Report
from evidently.metric_preset import ClassificationPreset, DataDriftPreset
from evidently import ColumnMapping

column_mapping = ColumnMapping(
    target='fraude',
    prediction='score_fraude',
    numerical_features=['montant', 'anciennete_client'],
    categorical_features=['pays_origine']
)

report = Report(metrics=[DataDriftPreset(), ClassificationPreset()])
report.run(
    reference_data=df_train_sample,
    current_data=df_production_last_week,
    column_mapping=column_mapping
)
report.save_html("monitoring/drift_report_semaine42.html")

5. Checklist de mise en production

• Performances validées par nested cross-validation + holdout final jamais vu
• Calibration vérifiée (reliability diagram) si les probabilités sont utilisées en décision
• Seuil de décision optimisé selon la métrique métier (coût des erreurs)
• SHAP summary plot documenté et validé par les experts métier
• Pipeline complet sérialisé (preprocessing + modèle) — zéro data leakage possible
• Modèle versionné dans MLflow avec tous les paramètres et métriques logués
• API documentée (Swagger auto FastAPI), tests unitaires des prédictions
• Dashboard monitoring actif : AUC, PSI, distribution des scores, volume de données
• Plan de re-training défini, automatisé et testé
• Documentation RGPD : finalité, base légale, durée de conservation