Évaluation et sélection de modèles

Tous les modèles sont faux, mais certains sont utiles.

George E. P. Box

Un modèle d’apprentissage automatique n’a de valeur que s’il généralise : sa capacité à produire des prédictions fiables sur des données qu’il n’a jamais vues est le critère fondamental de sa qualité. Un modèle qui restitue parfaitement les données d’entraînement mais échoue sur de nouvelles observations est inutile en pratique. Ce chapitre traite des outils théoriques et pratiques permettant d’évaluer honnêtement la performance d’un modèle, de diagnostiquer ses faiblesses, de régler ses hyperparamètres et, in fine, de choisir le meilleur modèle parmi plusieurs candidats.

Show code cell source

Hide code cell source

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import make_classification, make_regression, load_digits
from sklearn.model_selection import (
    train_test_split, cross_val_score, KFold, StratifiedKFold,
    LeaveOneOut, learning_curve, GridSearchCV, RandomizedSearchCV,
    cross_validate
)
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.linear_model import Ridge, LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, make_scorer

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)
np.random.seed(42)

Introduction : la généralisation

L’objectif de l’apprentissage supervisé est de trouver une fonction \(\hat{f}\) qui, à partir d’une entrée \(\mathbf{x}\), prédit une sortie \(y\) aussi fidèlement que possible. On dispose d’un ensemble d’entraînement \(\mathcal{D}_{\text{train}} = \{(\mathbf{x}_i, y_i)\}_{i=1}^n\) tiré d’une distribution inconnue \(P(\mathbf{x}, y)\). La qualité de \(\hat{f}\) se mesure par le risque réel (ou erreur de généralisation) :

Définition 123 (Risque réel)

Le risque réel (true risk) d’un modèle \(\hat{f}\) relativement à une fonction de perte \(L\) est

\[R(\hat{f}) = \mathbb{E}_{(\mathbf{x}, y) \sim P}\left[L(y, \hat{f}(\mathbf{x}))\right]\]

Ce risque est inaccessible en pratique puisqu’il nécessite la connaissance de la distribution \(P\).

Le risque empirique calculé sur les données d’entraînement est un estimateur biaisé du risque réel : le modèle a été ajusté pour minimiser précisément cette quantité, ce qui le conduit à sous-estimer l’erreur réelle. Toute la problématique de l’évaluation consiste à estimer le risque réel de façon fiable, sans tricher.

Remarque 117

L’erreur d’entraînement (training error) est presque toujours inférieure à l’erreur de généralisation. L’écart entre les deux est une signature du surapprentissage (overfitting). Un bon protocole d’évaluation doit mettre en évidence cet écart.

Compromis biais-variance

Décomposition formelle

Considérons un problème de régression avec le modèle vrai \(y = f(\mathbf{x}) + \varepsilon\), où \(\varepsilon\) est un bruit irréductible de moyenne nulle et de variance \(\sigma^2\). Si l’on entraîne un modèle \(\hat{f}_{\mathcal{D}}\) sur un jeu de données \(\mathcal{D}\) tiré aléatoirement, l’erreur quadratique moyenne en un point \(\mathbf{x}_0\) se décompose comme suit.

Proposition 32 (Décomposition biais-variance)

Pour tout point \(\mathbf{x}_0\), l’erreur quadratique moyenne du modèle \(\hat{f}_{\mathcal{D}}\) se décompose en

\[\mathbb{E}_{\mathcal{D}}\left[(y_0 - \hat{f}_{\mathcal{D}}(\mathbf{x}_0))^2\right] = \underbrace{\left(f(\mathbf{x}_0) - \mathbb{E}_{\mathcal{D}}[\hat{f}_{\mathcal{D}}(\mathbf{x}_0)]\right)^2}_{\text{Biais}^2} + \underbrace{\mathbb{E}_{\mathcal{D}}\left[(\hat{f}_{\mathcal{D}}(\mathbf{x}_0) - \mathbb{E}_{\mathcal{D}}[\hat{f}_{\mathcal{D}}(\mathbf{x}_0)])^2\right]}_{\text{Variance}} + \underbrace{\sigma^2}_{\text{Bruit}}\]

soit, en notation compacte :

\[\text{MSE} = \text{Biais}^2 + \text{Variance} + \text{Bruit irréductible}\]

Chacun de ces trois termes a une interprétation précise :

• Le biais mesure l’erreur systématique : c’est l’écart entre la vraie fonction \(f\) et la prédiction moyenne du modèle sur tous les jeux d’entraînement possibles. Un biais élevé signifie que le modèle est trop simple pour capturer la structure des données.

• La variance mesure la sensibilité du modèle au jeu d’entraînement particulier utilisé. Une variance élevée signifie que le modèle s’adapte trop aux fluctuations aléatoires de \(\mathcal{D}\).

• Le bruit irréductible est la part d’erreur due à la variabilité intrinsèque des données, que nul modèle ne peut éliminer.

Remarque 118

Le compromis biais-variance est un dilemme fondamental : augmenter la complexité d’un modèle réduit le biais mais augmente la variance, et réciproquement. L’objectif est de trouver le point d’équilibre qui minimise l’erreur totale de généralisation.

Sous-apprentissage et surapprentissage

Définition 124 (Sous-apprentissage et surapprentissage)

• Le sous-apprentissage (underfitting) se produit lorsque le modèle est trop simple pour capturer la structure des données. Il se manifeste par un biais élevé : l’erreur d’entraînement et l’erreur de validation sont toutes deux élevées.

• Le surapprentissage (overfitting) se produit lorsque le modèle est trop complexe et mémorise le bruit des données d’entraînement. Il se manifeste par une variance élevée : l’erreur d’entraînement est faible mais l’erreur de validation est élevée.

Illustrons ce compromis avec un problème de régression polynomiale.

Show code cell source

Hide code cell source

# Données synthétiques : fonction sinusoïdale bruitée
rng = np.random.RandomState(0)
n = 30
X_demo = np.sort(rng.uniform(0, 1, n))
y_demo = np.sin(2 * np.pi * X_demo) + rng.normal(0, 0.3, n)
X_plot = np.linspace(0, 1, 200)

fig, axes = plt.subplots(1, 3, figsize=(15, 4), sharey=True)
degrees = [1, 4, 15]
titles = ["Sous-apprentissage\n(degré 1, biais élevé)",
          "Bon compromis\n(degré 4)",
          "Surapprentissage\n(degré 15, variance élevée)"]

for ax, d, title in zip(axes, degrees, titles):
    coeffs = np.polyfit(X_demo, y_demo, d)
    y_pred = np.polyval(coeffs, X_plot)
    ax.scatter(X_demo, y_demo, s=20, alpha=0.7, label="Données")
    ax.plot(X_plot, np.sin(2 * np.pi * X_plot), '--', color='gray',
            label="Vraie fonction", alpha=0.6)
    ax.plot(X_plot, y_pred, color='C1', label=f"Polynôme degré {d}")
    ax.set_title(title, fontsize=11)
    ax.set_ylim(-2, 2)
    ax.legend(fontsize=8)

fig.suptitle("Compromis biais-variance", fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

Validation croisée

La validation croisée (cross-validation, CV) est la méthode standard pour estimer l’erreur de généralisation d’un modèle sans gaspiller de données. Plutôt que de réserver un unique ensemble de test, elle fait tourner les rôles entre entraînement et validation.

Holdout (train/test split)

La méthode la plus simple consiste à partitionner les données en deux sous-ensembles : un ensemble d’entraînement et un ensemble de test.

Définition 125 (Holdout)

Soit \(\mathcal{D} = \{(\mathbf{x}_i, y_i)\}_{i=1}^n\). Le holdout partitionne \(\mathcal{D}\) en

\[\mathcal{D} = \mathcal{D}_{\text{train}} \cup \mathcal{D}_{\text{test}}, \quad \mathcal{D}_{\text{train}} \cap \mathcal{D}_{\text{test}} = \emptyset\]

typiquement avec \(|\mathcal{D}_{\text{train}}| \approx 0{,}8 \cdot n\) et \(|\mathcal{D}_{\text{test}}| \approx 0{,}2 \cdot n\). L’erreur de généralisation est estimée par

\[\hat{R} = \frac{1}{|\mathcal{D}_{\text{test}}|} \sum_{(\mathbf{x}, y) \in \mathcal{D}_{\text{test}}} L(y, \hat{f}(\mathbf{x}))\]

Remarque 119

Le holdout est simple mais présente deux inconvénients majeurs : (1) l’estimation dépend fortement de la partition choisie, et (2) les données de test sont « gaspillées » — elles ne servent pas à l’entraînement. Ces deux problèmes sont particulièrement critiques lorsque \(n\) est petit.

Validation croisée à \(k\) plis

Définition 126 (Validation croisée à \(k\) plis)

La validation croisée à \(k\) plis (\(k\)-fold cross-validation) partitionne \(\mathcal{D}\) en \(k\) sous-ensembles (ou plis) de taille approximativement égale \(\mathcal{D}_1, \ldots, \mathcal{D}_k\). Pour chaque pli \(j \in \{1, \ldots, k\}\) :

1. Le modèle est entraîné sur \(\mathcal{D} \setminus \mathcal{D}_j\) (tous les plis sauf le \(j\)-ème).

2. Il est évalué sur \(\mathcal{D}_j\).

L’estimateur de l’erreur de généralisation est la moyenne des erreurs sur les \(k\) plis :

\[\hat{R}_{\text{CV}} = \frac{1}{k} \sum_{j=1}^k \hat{R}_j = \frac{1}{k} \sum_{j=1}^k \frac{1}{|\mathcal{D}_j|} \sum_{(\mathbf{x}, y) \in \mathcal{D}_j} L(y, \hat{f}_j(\mathbf{x}))\]

où \(\hat{f}_j\) est le modèle entraîné sans le pli \(j\).

Le choix de \(k\) est un compromis :

• \(k\) petit (par ex. 5) : entraînement rapide mais estimation plus variable, chaque modèle n’utilise que \((k-1)/k\) des données.

• \(k\) grand (par ex. 10 ou \(n\)) : estimation moins biaisée mais plus coûteuse et potentiellement plus variable.

• Le choix \(k = 5\) ou \(k = 10\) est le plus courant et recommandé dans la littérature.

Show code cell source

Hide code cell source

# Illustration de la validation croisée à 5 plis
from sklearn.datasets import load_iris

X_iris, y_iris = load_iris(return_X_y=True)

# Holdout simple
X_tr, X_te, y_tr, y_te = train_test_split(X_iris, y_iris,
                                           test_size=0.2, random_state=42)
clf_ho = LogisticRegression(max_iter=200, random_state=42)
clf_ho.fit(X_tr, y_tr)
print(f"Holdout — Accuracy test : {clf_ho.score(X_te, y_te):.4f}")

# 5-Fold CV
clf_cv = LogisticRegression(max_iter=200, random_state=42)
scores_5 = cross_val_score(clf_cv, X_iris, y_iris, cv=5, scoring='accuracy')
print(f"5-Fold CV — Accuracy : {scores_5.mean():.4f} ± {scores_5.std():.4f}")
print(f"  Scores par pli : {scores_5.round(4)}")

# 10-Fold CV
scores_10 = cross_val_score(clf_cv, X_iris, y_iris, cv=10, scoring='accuracy')
print(f"10-Fold CV — Accuracy : {scores_10.mean():.4f} ± {scores_10.std():.4f}")

Holdout — Accuracy test : 1.0000
5-Fold CV — Accuracy : 0.9733 ± 0.0249
  Scores par pli : [0.9667 1.     0.9333 0.9667 1.    ]

10-Fold CV — Accuracy : 0.9733 ± 0.0327

Validation croisée stratifiée

Définition 127 (Validation croisée stratifiée)

La validation croisée stratifiée (stratified \(k\)-fold CV) construit les \(k\) plis de sorte que chaque pli conserve la même proportion de chaque classe que l’ensemble complet. Si la classe \(c\) représente une fraction \(p_c\) de l’ensemble total, chaque pli contiendra environ \(p_c \cdot |\mathcal{D}_j|\) exemples de la classe \(c\).

Remarque 120

La stratification est essentielle lorsque les classes sont déséquilibrées. Sans stratification, un pli pourrait ne contenir aucun exemple d’une classe minoritaire, rendant l’évaluation sur ce pli non représentative. Scikit-learn utilise la stratification par défaut dans cross_val_score pour les problèmes de classification.

Show code cell source

Hide code cell source

# Comparaison KFold vs StratifiedKFold sur un jeu déséquilibré
X_imb, y_imb = make_classification(n_samples=200, n_features=10,
                                   weights=[0.9, 0.1], random_state=42)
print(f"Distribution des classes : {np.bincount(y_imb)}")

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

print("\nKFold — Distribution par pli :")
for i, (_, test_idx) in enumerate(kf.split(X_imb)):
    print(f"  Pli {i+1} : {np.bincount(y_imb[test_idx])}")

print("\nStratifiedKFold — Distribution par pli :")
for i, (_, test_idx) in enumerate(skf.split(X_imb, y_imb)):
    print(f"  Pli {i+1} : {np.bincount(y_imb[test_idx])}")

Distribution des classes : [180  20]

KFold — Distribution par pli :
  Pli 1 : [34  6]
  Pli 2 : [37  3]
  Pli 3 : [36  4]
  Pli 4 : [36  4]
  Pli 5 : [37  3]

StratifiedKFold — Distribution par pli :
  Pli 1 : [36  4]
  Pli 2 : [36  4]
  Pli 3 : [36  4]
  Pli 4 : [36  4]
  Pli 5 : [36  4]

Leave-One-Out (LOO)

Définition 128 (Leave-One-Out)

Le Leave-One-Out (LOO) est le cas particulier de la validation croisée à \(k\) plis avec \(k = n\). À chaque itération, un seul exemple sert d’ensemble de test et les \(n - 1\) restants servent d’entraînement :

\[\hat{R}_{\text{LOO}} = \frac{1}{n} \sum_{i=1}^n L(y_i, \hat{f}_{-i}(\mathbf{x}_i))\]

où \(\hat{f}_{-i}\) est le modèle entraîné sur \(\mathcal{D} \setminus \{(\mathbf{x}_i, y_i)\}\).

Remarque 121

Le LOO fournit un estimateur quasi non biaisé du risque réel, mais sa variance est élevée car les \(n\) ensembles d’entraînement sont presque identiques (ils partagent \(n - 2\) exemples). De plus, il est très coûteux en calcul : il requiert \(n\) entraînements du modèle. En pratique, le LOO est rarement utilisé sauf lorsque \(n\) est très petit (quelques dizaines d’observations).

Show code cell source

Hide code cell source

# Leave-One-Out sur un petit jeu de données
from sklearn.datasets import load_wine
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

X_wine, y_wine = load_wine(return_X_y=True)
clf_loo = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000, random_state=42))

loo = LeaveOneOut()
scores_loo = cross_val_score(clf_loo, X_wine, y_wine, cv=loo, scoring='accuracy')
scores_10f = cross_val_score(clf_loo, X_wine, y_wine, cv=10, scoring='accuracy')

print(f"LOO ({len(scores_loo)} itérations) — Accuracy : {scores_loo.mean():.4f}")
print(f"10-Fold CV                — Accuracy : {scores_10f.mean():.4f} ± {scores_10f.std():.4f}")

LOO (178 itérations) — Accuracy : 0.9831
10-Fold CV                — Accuracy : 0.9833 ± 0.0255

Résumé des stratégies de validation

Proposition 33 (Guide de choix de la stratégie de validation)

Méthode	Biais	Variance	Coût	Usage recommandé
Holdout 80/20	Modéré	Élevée	Faible	\(n\) très grand (\(> 10^5\))
5-Fold CV	Modéré	Modérée	Modéré	Usage général
10-Fold CV	Faible	Modérée	Modéré	Usage général, estimation fine
Stratified \(k\)-Fold	Faible	Modérée	Modéré	Classes déséquilibrées
LOO	Très faible	Élevée	Très élevé	\(n\) très petit (\(< 50\))

En pratique, la validation croisée stratifiée à 5 ou 10 plis est le choix par défaut le plus robuste.

Courbes d’apprentissage

Les courbes d’apprentissage (learning curves) représentent l’erreur d’entraînement et l’erreur de validation en fonction de la taille de l’ensemble d’entraînement \(n\). Elles constituent un outil de diagnostic visuel puissant pour identifier le biais et la variance.

Définition 129 (Courbe d’apprentissage)

Soit \(\hat{R}_{\text{train}}(n)\) et \(\hat{R}_{\text{val}}(n)\) les erreurs d’entraînement et de validation lorsque le modèle est entraîné sur \(n\) exemples. La courbe d’apprentissage trace ces deux quantités en fonction de \(n\).

L’allure de ces courbes permet de diagnostiquer la nature du problème :

• Biais élevé (sous-apprentissage) : les deux courbes convergent vers une erreur élevée. Ajouter des données ne résoudra pas le problème ; il faut augmenter la complexité du modèle.

• Variance élevée (surapprentissage) : l’erreur d’entraînement est faible mais l’erreur de validation est nettement supérieure, avec un écart persistant. Ajouter des données peut aider ; sinon, il faut réduire la complexité du modèle ou régulariser.

• Bon compromis : les deux courbes convergent vers une erreur faible avec un écart réduit.

Show code cell source

Hide code cell source

# Courbes d'apprentissage : comparaison de trois modèles
X_lc, y_lc = make_classification(n_samples=1000, n_features=20,
                                  n_informative=10, n_redundant=5,
                                  random_state=42)

models = {
    "Régression logistique\n(biais potentiel)": LogisticRegression(max_iter=1000, random_state=42),
    "Random Forest\n(bon compromis)": RandomForestClassifier(n_estimators=50, max_depth=10, random_state=42),
    "Arbre profond\n(variance potentielle)": DecisionTreeClassifier(max_depth=None, random_state=42),
}

fig, axes = plt.subplots(1, 3, figsize=(16, 5), sharey=True)

for ax, (name, model) in zip(axes, models.items()):
    train_sizes, train_scores, val_scores = learning_curve(
        model, X_lc, y_lc,
        train_sizes=np.linspace(0.1, 1.0, 10),
        cv=5, scoring='accuracy', n_jobs=-1
    )

    train_mean = train_scores.mean(axis=1)
    train_std = train_scores.std(axis=1)
    val_mean = val_scores.mean(axis=1)
    val_std = val_scores.std(axis=1)

    ax.fill_between(train_sizes, train_mean - train_std,
                    train_mean + train_std, alpha=0.15, color='C0')
    ax.fill_between(train_sizes, val_mean - val_std,
                    val_mean + val_std, alpha=0.15, color='C1')
    ax.plot(train_sizes, train_mean, 'o-', color='C0',
            label='Entraînement', markersize=4)
    ax.plot(train_sizes, val_mean, 'o-', color='C1',
            label='Validation', markersize=4)
    ax.set_title(name, fontsize=11)
    ax.set_xlabel("Taille de l'ensemble d'entraînement")
    ax.legend(loc='lower right', fontsize=9)
    ax.set_ylim(0.5, 1.05)

axes[0].set_ylabel("Accuracy")
fig.suptitle("Courbes d'apprentissage", fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

Remarque 122

Les courbes d’apprentissage indiquent non seulement le type de problème (biais ou variance) mais aussi si l’acquisition de données supplémentaires serait bénéfique. Si les deux courbes ont convergé, collecter davantage de données ne changera rien : il faut modifier le modèle.

Recherche d’hyperparamètres

Les hyperparamètres sont les paramètres d’un modèle qui ne sont pas appris lors de l’entraînement mais fixés avant celui-ci (profondeur maximale d’un arbre, coefficient de régularisation \(C\), nombre de voisins \(k\), etc.). Leur choix a un impact considérable sur la performance du modèle.

Définition 130 (Hyperparamètre)

Un hyperparamètre \(\lambda \in \Lambda\) est un paramètre qui contrôle le processus d’apprentissage mais n’est pas optimisé par la procédure d’entraînement elle-même. L’objectif de la recherche d’hyperparamètres est de trouver

\[\lambda^* = \arg\min_{\lambda \in \Lambda} \hat{R}_{\text{CV}}(\hat{f}_\lambda)\]

c’est-à-dire l’hyperparamètre qui minimise l’erreur estimée par validation croisée.

Recherche par grille (GridSearchCV)

Définition 131 (Recherche par grille)

La recherche par grille (grid search) évalue toutes les combinaisons d’une grille d’hyperparamètres prédéfinie. Si l’on a \(p\) hyperparamètres avec respectivement \(n_1, n_2, \ldots, n_p\) valeurs candidates, le nombre total de combinaisons est

\[N = \prod_{i=1}^p n_i\]

Chaque combinaison est évaluée par validation croisée à \(k\) plis, soit \(N \times k\) entraînements au total.

Remarque 123

La recherche par grille souffre de la malédiction de la dimensionnalité : le nombre de combinaisons croît exponentiellement avec le nombre d’hyperparamètres. Pour 5 hyperparamètres avec 10 valeurs chacun, on obtient \(10^5 = 100\,000\) combinaisons. En pratique, la grille doit rester raisonnablement petite.

Show code cell source

Hide code cell source

# GridSearchCV sur un SVM avec le jeu digits
X_digits, y_digits = load_digits(return_X_y=True)
X_d_train, X_d_test, y_d_train, y_d_test = train_test_split(
    X_digits, y_digits, test_size=0.2, random_state=42, stratify=y_digits
)

# Grille d'hyperparamètres
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'gamma': ['scale', 0.001, 0.01, 0.1],
    'kernel': ['rbf']
}

grid_search = GridSearchCV(
    SVC(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    return_train_score=True
)
grid_search.fit(X_d_train, y_d_train)

print(f"Meilleurs hyperparamètres : {grid_search.best_params_}")
print(f"Meilleur score CV : {grid_search.best_score_:.4f}")
print(f"Score sur le test  : {grid_search.score(X_d_test, y_d_test):.4f}")

Meilleurs hyperparamètres : {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}
Meilleur score CV : 0.9896
Score sur le test  : 0.9917

Show code cell source

Hide code cell source

# Visualisation de la grille : heatmap des scores CV
results = pd.DataFrame(grid_search.cv_results_)

# Filtrer pour kernel='rbf' et créer le pivot
pivot = results.pivot_table(
    values='mean_test_score',
    index='param_gamma',
    columns='param_C'
)

fig, ax = plt.subplots(figsize=(8, 5))
sns.heatmap(pivot, annot=True, fmt='.3f', cmap='YlOrRd', ax=ax,
            cbar_kws={'label': 'Accuracy CV'})
ax.set_title("GridSearchCV — Accuracy par combinaison (C, gamma)", fontsize=12)
ax.set_xlabel("C")
ax.set_ylabel("gamma")
plt.tight_layout()
plt.show()

Recherche aléatoire (RandomizedSearchCV)

Définition 132 (Recherche aléatoire)

La recherche aléatoire (randomized search) échantillonne \(N\) combinaisons d’hyperparamètres aléatoirement à partir de distributions spécifiées par l’utilisateur, plutôt que d’explorer une grille exhaustive. Si \(\Lambda\) est l’espace des hyperparamètres et \(p(\lambda)\) la distribution d’échantillonnage :

\[\lambda_1, \ldots, \lambda_N \sim p(\lambda), \quad \lambda^* = \arg\min_{\lambda \in \{\lambda_1, \ldots, \lambda_N\}} \hat{R}_{\text{CV}}(\hat{f}_\lambda)\]

Proposition 34 (Avantage de la recherche aléatoire (Bergstra & Bengio, 2012))

Pour un budget de calcul fixe \(N\), la recherche aléatoire est souvent plus efficace que la recherche par grille car :

1. Elle explore un plus grand nombre de valeurs distinctes pour chaque hyperparamètre.

2. Si certains hyperparamètres sont plus importants que d’autres, la grille gaspille des évaluations sur les dimensions peu influentes.

3. Avec \(N\) tirages, la probabilité de trouver un point dans les \(5\,\%\) meilleurs de l’espace est \(1 - 0{,}95^N \approx 0{,}99\) pour \(N \geq 60\).

Show code cell source

Hide code cell source

from scipy.stats import loguniform, randint

# RandomizedSearchCV avec distributions continues
param_distributions = {
    'n_estimators': randint(50, 300),
    'max_depth': randint(3, 20),
    'min_samples_split': randint(2, 20),
    'min_samples_leaf': randint(1, 10),
    'max_features': ['sqrt', 'log2', None],
}

random_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions,
    n_iter=20,
    cv=3,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1,
    return_train_score=True
)
random_search.fit(X_d_train, y_d_train)

print(f"Meilleurs hyperparamètres : {random_search.best_params_}")
print(f"Meilleur score CV : {random_search.best_score_:.4f}")
print(f"Score sur le test  : {random_search.score(X_d_test, y_d_test):.4f}")

Meilleurs hyperparamètres : {'max_depth': 15, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 8, 'n_estimators': 58}
Meilleur score CV : 0.9569
Score sur le test  : 0.9667

Show code cell source

Hide code cell source

# Évolution du meilleur score au fil des itérations
results_rs = pd.DataFrame(random_search.cv_results_)
results_rs = results_rs.sort_values('mean_test_score', ascending=False)

# Score cumulé au fil des itérations (en ordre d'évaluation)
scores_iter = results_rs.sort_index()['mean_test_score'].values
best_so_far = np.maximum.accumulate(scores_iter)

fig, ax = plt.subplots(figsize=(9, 4))
ax.plot(range(1, len(best_so_far) + 1), best_so_far, 'o-', markersize=3,
        color='C0', label='Meilleur score cumulé')
ax.scatter(range(1, len(scores_iter) + 1), scores_iter, s=15, alpha=0.4,
           color='C1', label='Score par itération')
ax.set_xlabel("Numéro d'itération")
ax.set_ylabel("Accuracy CV")
ax.set_title("RandomizedSearchCV — Convergence", fontsize=12)
ax.legend()
plt.tight_layout()
plt.show()

Recherche bayésienne

Définition 133 (Optimisation bayésienne des hyperparamètres)

L”optimisation bayésienne modélise la fonction objectif \(f(\lambda) = \hat{R}_{\text{CV}}(\hat{f}_\lambda)\) par un modèle substitut (surrogate model), typiquement un processus gaussien ou un modèle de type Tree-structured Parzen Estimator (TPE). À chaque itération, le modèle substitut est utilisé pour choisir le prochain point \(\lambda\) à évaluer via une fonction d’acquisition (Expected Improvement, Upper Confidence Bound, etc.) qui équilibre exploration et exploitation.

Remarque 124

L’optimisation bayésienne est plus efficace que les recherches par grille ou aléatoire lorsque l’évaluation de \(f(\lambda)\) est coûteuse (entraînement long, grands jeux de données). Plusieurs bibliothèques implémentent cette approche :

• Optuna : framework flexible avec pruning automatique des essais peu prometteurs.

• scikit-optimize (skopt) : intégration avec scikit-learn via BayesSearchCV.

• Hyperopt : optimisation basée sur TPE.

L’installation se fait via pip install optuna ou pip install scikit-optimize.

Exemple 11 (Recherche bayésienne avec Optuna)

Voici un exemple de structure typique avec Optuna (non exécuté ici pour éviter la dépendance) :

import optuna

def objective(trial):
    C = trial.suggest_float('C', 1e-3, 1e3, log=True)
    gamma = trial.suggest_float('gamma', 1e-4, 1e1, log=True)
    clf = SVC(C=C, gamma=gamma, kernel='rbf')
    score = cross_val_score(clf, X_train, y_train, cv=5).mean()
    return score

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(study.best_params)

L’avantage d’Optuna est sa capacité à pruner les essais peu prometteurs dès les premières époques, économisant ainsi du temps de calcul.

Comparaison de modèles

Une fois plusieurs modèles entraînés et évalués par validation croisée, il est tentant de simplement choisir celui avec le meilleur score moyen. Cependant, les scores de CV sont des variables aléatoires : une différence observée peut être due au hasard. Des tests statistiques permettent de déterminer si les différences sont significatives.

Comparaison de deux modèles

Définition 134 (Test \(t\) apparié sur les plis)

Pour comparer deux modèles \(A\) et \(B\) évalués sur les mêmes \(k\) plis, on considère les différences de performance \(d_j = R_j^A - R_j^B\) pour \(j = 1, \ldots, k\). Sous l’hypothèse nulle \(H_0 : \mu_d = 0\) (les deux modèles ont la même performance), la statistique

\[t = \frac{\bar{d}}{s_d / \sqrt{k}}\]

suit approximativement une loi de Student à \(k - 1\) degrés de liberté, où \(\bar{d}\) et \(s_d\) sont la moyenne et l’écart-type des différences.

Remarque 125

Le test \(t\) apparié classique sous-estime la variance car les ensembles d’entraînement des différents plis se chevauchent. Le test \(t\) corrigé de Nadeau et Bengio (2003) corrige ce biais en ajustant la variance :

\[t_{\text{corr}} = \frac{\bar{d}}{\sqrt{\left(\frac{1}{k} + \frac{n_{\text{test}}}{n_{\text{train}}}\right) s_d^2}}\]

où \(n_{\text{test}}\) et \(n_{\text{train}}\) sont les tailles des ensembles de test et d’entraînement dans chaque pli.

Show code cell source

Hide code cell source

from scipy import stats

# Comparaison de plusieurs modèles sur le jeu digits
models_comp = {
    'Logistic Regression': LogisticRegression(max_iter=5000, random_state=42),
    'KNN (k=5)': KNeighborsClassifier(n_neighbors=5),
    'Decision Tree': DecisionTreeClassifier(max_depth=10, random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'SVM (RBF)': SVC(kernel='rbf', random_state=42),
}

cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)

results_comp = {}
for name, model in models_comp.items():
    scores = cross_val_score(model, X_digits, y_digits, cv=cv,
                             scoring='accuracy')
    results_comp[name] = scores
    print(f"{name:25s} : {scores.mean():.4f} ± {scores.std():.4f}")

Logistic Regression       : 0.9661 ± 0.0076
KNN (k=5)                 : 0.9861 ± 0.0109

Decision Tree             : 0.8648 ± 0.0251

Random Forest             : 0.9789 ± 0.0078

SVM (RBF)                 : 0.9889 ± 0.0071

Show code cell source

Hide code cell source

# Visualisation : boxplot des scores par modèle
fig, ax = plt.subplots(figsize=(10, 5))
df_results = pd.DataFrame(results_comp)
df_melted = df_results.melt(var_name='Modèle', value_name='Accuracy')
sns.boxplot(data=df_melted, x='Modèle', y='Accuracy', hue='Modèle', ax=ax, palette='Set2', legend=False)
ax.set_title("Comparaison de modèles — 10-Fold CV sur Digits", fontsize=12)
ax.tick_params(axis='x', rotation=20)
ax.set_ylim(0.85, 1.01)
plt.tight_layout()
plt.show()

Comparaison multiple

Définition 135 (Test de Friedman)

Le test de Friedman est un test non paramétrique utilisé pour comparer \(m\) modèles évalués sur \(k\) plis. Pour chaque pli, les modèles sont classés par rang. Sous l’hypothèse nulle (tous les modèles ont la même performance), la statistique de Friedman

\[\chi_F^2 = \frac{12k}{m(m+1)} \left[\sum_{j=1}^m R_j^2 - \frac{m(m+1)^2}{4}\right]\]

suit approximativement une loi \(\chi^2\) à \(m - 1\) degrés de liberté, où \(R_j\) est le rang moyen du modèle \(j\).

Remarque 126

Si le test de Friedman rejette \(H_0\), on procède à des comparaisons post-hoc pour identifier quelles paires de modèles diffèrent significativement. Le test de Nemenyi est le pendant non paramétrique du test de Tukey HSD. Deux modèles sont significativement différents si la différence de leurs rangs moyens dépasse la distance critique :

\[CD = q_\alpha \sqrt{\frac{m(m+1)}{6k}}\]

où \(q_\alpha\) est la valeur critique de la distribution de l’étendue studentisée.

Show code cell source

Hide code cell source

# Test de Friedman
scores_matrix = np.array(list(results_comp.values()))  # (m, k)
stat_friedman, p_friedman = stats.friedmanchisquare(*scores_matrix)
print(f"Test de Friedman : statistique = {stat_friedman:.2f}, p-value = {p_friedman:.4e}")

if p_friedman < 0.05:
    print("→ On rejette H0 : au moins un modèle diffère significativement.")
else:
    print("→ On ne rejette pas H0 : pas de différence significative détectée.")

Test de Friedman : statistique = 32.27, p-value = 1.6830e-06
→ On rejette H0 : au moins un modèle diffère significativement.

Show code cell source

Hide code cell source

# Tests post-hoc : Wilcoxon signé entre paires de modèles
model_names = list(results_comp.keys())
n_models = len(model_names)
pairwise_pvalues = np.ones((n_models, n_models))

for i in range(n_models):
    for j in range(i + 1, n_models):
        stat, pval = stats.wilcoxon(scores_matrix[i], scores_matrix[j])
        pairwise_pvalues[i, j] = pval
        pairwise_pvalues[j, i] = pval

df_pval = pd.DataFrame(pairwise_pvalues, index=model_names, columns=model_names)

fig, ax = plt.subplots(figsize=(8, 6))
mask = np.triu(np.ones_like(df_pval, dtype=bool), k=0)
sns.heatmap(df_pval, annot=True, fmt='.3f', cmap='RdYlGn', ax=ax,
            mask=mask, vmin=0, vmax=0.1,
            cbar_kws={'label': 'p-value (Wilcoxon)'})
ax.set_title("Tests par paires — p-values (Wilcoxon signé)", fontsize=12)
plt.tight_layout()
plt.show()

Remarque 127

Lorsqu’on effectue de multiples comparaisons, le risque de faux positifs augmente. Il faut appliquer une correction de Bonferroni ou une correction de Holm pour maintenir le taux d’erreur global au niveau souhaité. Avec \(m\) modèles, on effectue \(\binom{m}{2}\) comparaisons, et le seuil corrigé par Bonferroni est \(\alpha / \binom{m}{2}\).

Sélection de modèles : pipeline complet

Le problème de la fuite de données

Définition 136 (Fuite de données)

La fuite de données (data leakage) se produit lorsque de l’information provenant de l’ensemble de test influence le processus d’entraînement ou de sélection du modèle. Les formes les plus courantes sont :

• Prétraitement (scaling, imputation) ajusté sur l’ensemble complet avant la séparation train/test.

• Sélection d’hyperparamètres évaluée sur les mêmes données que l’évaluation finale.

• Sélection de features basée sur la cible avant la séparation.

Pour éviter la fuite de données lors de la sélection d’hyperparamètres, il faut utiliser la validation croisée imbriquée (nested cross-validation).

Validation croisée imbriquée

Définition 137 (Validation croisée imbriquée)

La validation croisée imbriquée (nested CV) utilise deux boucles de CV :

• La boucle externe (\(k_{\text{ext}}\) plis) estime la performance de généralisation du processus complet (sélection d’hyperparamètres + entraînement).

• La boucle interne (\(k_{\text{int}}\) plis) sélectionne les meilleurs hyperparamètres pour chaque pli externe.

Pour chaque pli externe \(j\) :

1. Séparer \(\mathcal{D}_{\text{train}}^{(j)}\) (entraînement) et \(\mathcal{D}_{\text{test}}^{(j)}\) (test).

2. Sur \(\mathcal{D}_{\text{train}}^{(j)}\), exécuter une recherche d’hyperparamètres par CV interne (\(k_{\text{int}}\) plis).

3. Réentraîner le modèle avec les meilleurs hyperparamètres sur \(\mathcal{D}_{\text{train}}^{(j)}\) complet.

4. Évaluer sur \(\mathcal{D}_{\text{test}}^{(j)}\).

Le score final est la moyenne des scores des \(k_{\text{ext}}\) plis externes.

Remarque 128

La CV imbriquée fournit une estimation non biaisée de la performance de généralisation du processus de sélection de modèle. Sans elle, la sélection d’hyperparamètres utilise (indirectement) les données de test via la CV, ce qui conduit à un optimisme de sélection (selection bias) : le score CV surestime légèrement la vraie performance.

Show code cell source

Hide code cell source

# Pipeline complet avec nested cross-validation
from sklearn.model_selection import cross_val_score

# Boucle externe
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# Boucle interne (intégrée dans GridSearchCV)
inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)

# Définition des pipelines candidats
pipelines = {
    'Logistic Regression': {
        'model': Pipeline([
            ('scaler', StandardScaler()),
            ('clf', LogisticRegression(max_iter=5000, random_state=42))
        ]),
        'params': {'clf__C': [0.01, 0.1, 1, 10, 100]}
    },
    'Random Forest': {
        'model': Pipeline([
            ('clf', RandomForestClassifier(random_state=42))
        ]),
        'params': {
            'clf__n_estimators': [50, 100, 200],
            'clf__max_depth': [5, 10, 20, None]
        }
    },
    'SVM': {
        'model': Pipeline([
            ('scaler', StandardScaler()),
            ('clf', SVC(random_state=42))
        ]),
        'params': {
            'clf__C': [0.1, 1, 10],
            'clf__gamma': ['scale', 0.01, 0.1]
        }
    },
}

print("Nested Cross-Validation (5 plis externes × 3 plis internes)")
print("=" * 60)

nested_scores = {}
for name, config in pipelines.items():
    # GridSearchCV = boucle interne
    gs = GridSearchCV(
        config['model'],
        config['params'],
        cv=inner_cv,
        scoring='accuracy',
        n_jobs=-1
    )
    # cross_val_score = boucle externe
    scores = cross_val_score(gs, X_digits, y_digits,
                             cv=outer_cv, scoring='accuracy')
    nested_scores[name] = scores
    print(f"{name:25s} : {scores.mean():.4f} ± {scores.std():.4f}  "
          f"(plis : {scores.round(4)})")

Nested Cross-Validation (5 plis externes × 3 plis internes)
============================================================

Logistic Regression       : 0.9711 ± 0.0037  (plis : [0.9694 0.9667 0.9777 0.9721 0.9694])

Random Forest             : 0.9783 ± 0.0054  (plis : [0.9861 0.975  0.9721 0.9833 0.9749])

SVM                       : 0.9850 ± 0.0060  (plis : [0.9778 0.9944 0.9889 0.9833 0.9805])

Show code cell source

Hide code cell source

# Comparaison : score CV simple vs nested CV
print("\nComparaison : CV simple vs Nested CV")
print("=" * 60)

for name, config in pipelines.items():
    # CV simple (optimiste)
    gs_simple = GridSearchCV(
        config['model'], config['params'],
        cv=5, scoring='accuracy', n_jobs=-1
    )
    gs_simple.fit(X_digits, y_digits)
    cv_simple = gs_simple.best_score_

    # Nested CV (non biaisé)
    cv_nested = nested_scores[name].mean()

    print(f"{name:25s} : CV simple = {cv_simple:.4f}, "
          f"Nested CV = {cv_nested:.4f}, "
          f"Δ = {cv_simple - cv_nested:+.4f}")

Comparaison : CV simple vs Nested CV
============================================================

Logistic Regression       : CV simple = 0.9254, Nested CV = 0.9711, Δ = -0.0456

Random Forest             : CV simple = 0.9410, Nested CV = 0.9783, Δ = -0.0373

SVM                       : CV simple = 0.9560, Nested CV = 0.9850, Δ = -0.0289

Show code cell source

Hide code cell source

# Visualisation finale : comparaison des modèles avec nested CV
fig, ax = plt.subplots(figsize=(8, 5))
df_nested = pd.DataFrame(nested_scores)
df_nested_melted = df_nested.melt(var_name='Modèle', value_name='Accuracy')
sns.boxplot(data=df_nested_melted, x='Modèle', y='Accuracy',
            hue='Modèle', ax=ax, palette='Set2', legend=False)
ax.set_title("Sélection de modèles — Nested Cross-Validation", fontsize=12)
ax.set_ylim(0.9, 1.01)
plt.tight_layout()
plt.show()

Pipeline de sélection complet

Proposition 35 (Protocole de sélection de modèles)

Un protocole rigoureux de sélection de modèles suit les étapes suivantes :

1. Séparation initiale : réserver un ensemble de test final (holdout) qui ne sera utilisé qu’une seule fois, à la toute fin.

2. Définition des candidats : identifier les familles de modèles et leurs espaces d’hyperparamètres.

3. Nested CV : pour chaque candidat, estimer la performance de généralisation par validation croisée imbriquée sur l’ensemble d’entraînement.

4. Sélection : choisir le modèle (famille + stratégie de recherche d’hyperparamètres) ayant le meilleur score nested CV.

5. Réentraînement final : réentraîner le modèle sélectionné (avec recherche d’hyperparamètres par CV) sur l’intégralité de l’ensemble d’entraînement.

6. Évaluation finale : évaluer une unique fois sur l’ensemble de test réservé. Ce score est l’estimation la plus honnête de la performance en production.

Ce protocole garantit qu’aucune information de l’ensemble de test n’a influencé les décisions de modélisation.

Show code cell source

Hide code cell source

# Protocole complet : de la sélection à l'évaluation finale
from sklearn.metrics import classification_report

# 1. Séparation initiale
X_train_final, X_test_final, y_train_final, y_test_final = train_test_split(
    X_digits, y_digits, test_size=0.15, random_state=42, stratify=y_digits
)
print(f"Ensemble d'entraînement : {X_train_final.shape[0]} exemples")
print(f"Ensemble de test final  : {X_test_final.shape[0]} exemples")

# 2-4. Le meilleur modèle est SVM d'après la nested CV (illustratif)
best_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', SVC(random_state=42))
])
best_params = {
    'clf__C': [0.1, 1, 10, 100],
    'clf__gamma': ['scale', 0.001, 0.01, 0.1]
}

# 5. Réentraînement avec recherche d'hyperparamètres
final_search = GridSearchCV(
    best_pipeline, best_params,
    cv=StratifiedKFold(5, shuffle=True, random_state=42),
    scoring='accuracy', n_jobs=-1
)
final_search.fit(X_train_final, y_train_final)

print(f"\nMeilleurs hyperparamètres : {final_search.best_params_}")
print(f"Score CV interne : {final_search.best_score_:.4f}")

# 6. Évaluation finale (une seule fois !)
y_pred_final = final_search.predict(X_test_final)
print(f"\n{'='*50}")
print(f"SCORE FINAL SUR LE TEST : {accuracy_score(y_test_final, y_pred_final):.4f}")
print(f"{'='*50}")

Ensemble d'entraînement : 1527 exemples
Ensemble de test final  : 270 exemples

Meilleurs hyperparamètres : {'clf__C': 1, 'clf__gamma': 'scale'}
Score CV interne : 0.9830

==================================================
SCORE FINAL SUR LE TEST : 0.9667
==================================================

Résumé

Ce chapitre a couvert les outils essentiels pour évaluer et sélectionner des modèles d’apprentissage automatique de manière rigoureuse :

• La décomposition biais-variance fournit le cadre théorique : l’erreur de généralisation est la somme du biais au carré, de la variance et du bruit irréductible. Le choix de la complexité du modèle est un compromis entre ces deux premiers termes.

• La validation croisée (holdout, \(k\)-fold, stratifiée, LOO) estime l’erreur de généralisation sans gaspiller de données. La CV stratifiée à 5 ou 10 plis est le choix par défaut.

• Les courbes d’apprentissage diagnostiquent visuellement le biais et la variance en traçant les erreurs d’entraînement et de validation en fonction de la taille des données.

• La recherche d’hyperparamètres (grille, aléatoire, bayésienne) optimise les paramètres non appris du modèle. La recherche aléatoire est souvent préférable à la grille pour un budget fixe.

• La comparaison statistique de modèles (test \(t\) apparié, test de Friedman, test de Nemenyi) garantit que les différences observées ne sont pas dues au hasard.

• La validation croisée imbriquée fournit une estimation non biaisée de la performance du processus complet de sélection de modèle, évitant la fuite de données.

Remarque 129

L’évaluation n’est pas une étape finale mais un processus itératif. Les résultats de l’évaluation guident le choix du modèle, du prétraitement et des hyperparamètres. Un bon praticien consacre autant de soin à l’évaluation qu’à la modélisation elle-même.