Évaluation : métriques, cross-validation, déséquilibre

L'accuracy ment dès que les classes sont déséquilibrées

Fraude : 0,5 % des transactions. Le modèle « toujours légitime » affiche 99,5 % d'accuracy et n'attrape aucune fraude. Toute évaluation sérieuse commence par la matrice de confusion :

                    prédit fraude    prédit légitime
réelle fraude            VP                FN   ← les fraudes ratées 💸
réelle légitime          FP                VN   ← les clients bloqués à tort 😡

Précision = VP / (VP + FP) : parmi mes alertes, combien de vraies ? (coût des faux positifs)
Rappel = VP / (VP + FN) : parmi les fraudes réelles, combien j'attrape ? (coût des ratés)
F1 : moyenne harmonique des deux — le compromis en un chiffre.

Le seuil de décision déplace le curseur : seuil bas → rappel ↑, précision ↓. La courbe precision-recall montre tous les compromis possibles ; l'AUC-ROC résume la capacité de tri du modèle indépendamment du seuil.

Cross-validation : évaluer sans gaspiller

Avec peu de données, un seul split est un coup de dés. La validation croisée k-fold découpe en k blocs, entraîne k fois (chaque bloc sert une fois de test) et moyenne : estimation robuste + écart-type. Cas particulier vital : données temporelles → TimeSeriesSplit (on entraîne sur le passé, on valide sur le futur — jamais l'inverse).

Régression : les métriques en unités métier

MAE : erreur absolue moyenne — « je me trompe de 12 € en moyenne », lisible par le PO ;
RMSE : pénalise davantage les grosses erreurs — à surveiller si les gros ratés coûtent cher ;
R² : part de variance expliquée (1 = parfait, 0 = pas mieux que prédire la moyenne).

🐍 À toi de jouer

# L'accuracy qui ment : fraude à 2 % — matrice de confusion et métriques honnêtes
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score

rng = np.random.default_rng(9)
n = 5000
X = rng.normal(size=(n, 4))
y = ((X[:, 0] + X[:, 1] * 2 + rng.normal(0, 1, n)) > 3.2).astype(int)  # ~2 % positifs
print(f"taux de fraude : {y.mean():.1%}")

X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0)
m = LogisticRegression(class_weight="balanced").fit(X_tr, y_tr)  # gère le déséquilibre
proba = m.predict_proba(X_te)[:, 1]

naif = np.zeros_like(y_te)
print(f"\naccuracy du modèle 'jamais fraude' : {(naif == y_te).mean():.1%}  ← inutile !")

for seuil in [0.5, 0.3, 0.7]:
    pred = (proba > seuil).astype(int)
    vp, fp = ((pred==1)&(y_te==1)).sum(), ((pred==1)&(y_te==0)).sum()
    fn = ((pred==0)&(y_te==1)).sum()
    print(f"\nseuil {seuil} → précision {precision_score(y_te,pred):.2f} | "
          f"rappel {recall_score(y_te,pred):.2f} | F1 {f1_score(y_te,pred):.2f}"
          f"   (VP={vp} FP={fp} FN={fn})")
print("\n→ le seuil est un CURSEUR métier : fraudes ratées vs clients bloqués.")

🧩 Quiz1/4

Fraude à 0,5 % : pourquoi l'accuracy est-elle inutilisable ?

🃏 Flashcards1/6