Aller au contenu
Data science

Choisir un modèle : la démarche complète

⏱ 1 h + TP

Prérequis : Validation croisée et réglage des hyperparamètres · Plusieurs classes et classes déséquilibrées · Les SVM et les noyaux

À la fin de ce chapitre, vous saurez :
  • enchaîner les étapes d'un projet supervisé, de la question au modèle final ;
  • choisir une métrique et un modèle de référence avant d'entraîner ;
  • comparer plusieurs familles de modèles honnêtement ;
  • connaître le réglage de complexité de chaque famille.

Aucun modèle ne gagne sur tous les problèmes (c’est le théorème « pas de repas gratuit », no free lunch). La forêt aléatoire excelle sur des données tabulaires, le kNN sur de petits jeux bien mis à l’échelle, la régression logistique quand il faut expliquer chaque coefficient. On ne devine donc pas le bon modèle : on suit une démarche qui permet de le trouver, et de mesurer honnêtement ce qu’il vaut.

  1. Formuler la question. Que prédit-on, pour qui, et quelle décision en découle ? Régression (une valeur) ou classification (une classe) ? Quelle erreur coûte le plus cher ?
  2. Choisir la métrique, avant tout entraînement : MAE ou RMSE en régression ; rappel, précision, F1 ou AUC en classification. C’est elle qui guidera tous les choix.
  3. Mettre le test de côté, une fois pour toutes (stratifié en classification, chronologique pour des données temporelles, groupé si des exemples sont liés).
  4. Établir un modèle de référence : prédire la moyenne, ou la classe majoritaire. Tout modèle devra le battre nettement.
  5. Préparer les données dans un pipeline : imputation, encodage, mise à l’échelle. Le pipeline garantit que ces étapes apprennent sur l’entraînement seul, à chaque pli.
  6. Comparer plusieurs familles par validation croisée, avec leurs réglages par défaut : un modèle linéaire, un kNN, une forêt, un boosting, un SVM.
  7. Régler les hyperparamètres des deux ou trois meilleurs, par recherche aléatoire ou en grille, toujours par validation croisée.
  8. Évaluer une seule fois sur le test, puis analyser les erreurs : résidus, matrice de confusion, exemples les plus mal prédits. C’est souvent là qu’on trouve l’idée de la variable qui manquait.
from sklearn.model_selection import train_test_split, cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
from sklearn.svm import SVC
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)
candidats = {
"référence": DummyClassifier(strategy="most_frequent"),
"logistique": make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
"kNN": make_pipeline(StandardScaler(), KNeighborsClassifier()),
"forêt": RandomForestClassifier(n_estimators=300, random_state=0),
"boosting": HistGradientBoostingClassifier(random_state=0),
"SVM": make_pipeline(StandardScaler(), SVC()),
}
for nom, modele in candidats.items():
r = cross_validate(modele, X_train, y_train, cv=5, scoring="f1", return_train_score=True)
print(f"{nom:11s} validation {r['test_score'].mean():.3f} ± {r['test_score'].std():.3f}"
f" entraînement {r['train_score'].mean():.3f}")

Comparer le score d’entraînement et le score de validation de chaque modèle dit aussi dans quel sens le régler : un grand écart signale du surapprentissage (régulariser, simplifier) ; deux scores faibles et proches, du sous-apprentissage (un modèle plus souple, de meilleures variables).

🔬Comparer les familles dans le simulateur

La page « Comparer les modèles » (en classification, comme en régression) entraîne tous les modèles sur les mêmes données et affiche leurs frontières, leurs scores et leurs métriques côte à côte.

→

Chaque famille de modèles a son réglage de complexité. Le vocabulaire change ; la courbe en U, jamais.

Modèle Réglage Trop simple Trop complexe
Polynôme, Ridge degré, λ degré 1, λ grand degré 15, λ = 0
Régression logistique C (= 1/λ) C très petit C très grand, avec beaucoup de variables
k plus proches voisins k k très grand k = 1
Arbre de décision profondeur profondeur 1 profondeur illimitée
Forêt aléatoire profondeur des arbres arbres très courts (peu de risque : ajouter des arbres ne fait pas surapprendre)
Gradient boosting nombre d’arbres, taux d’apprentissage quelques arbres des centaines d’arbres sur peu de données
SVM, SVR à noyau RBF γ et C (et ε) γ petit, C petit γ grand, C grand
Réseau de neurones taille, époques trop peu de neurones trop d’époques sans régularisation

Pour le kNN, attention : la complexité diminue quand k augmente.

🔬kNN avec k = 1 sur les deux lunes

Une frontière déchiquetée qui entoure chaque point. Tracez la courbe de complexité, puis augmentez k.

→
🔬SVM avec γ = 100

Chaque point d’entraînement crée sa petite « île ». Balayez γ pour voir la précision de test chuter.

→
🔬Un arbre sans limite, avec 20 % d'étiquettes fausses

L’arbre isole chaque erreur d’annotation dans sa propre case. Comparez avec une profondeur de 3.

→
Situation Bon premier choix Pourquoi
données tabulaires, quelques milliers d’exemples ou plus boosting (HistGradientBoosting), forêt presque toujours parmi les meilleurs, peu de préparation
il faut expliquer chaque effet régression linéaire ou logistique coefficients lisibles
peu d’exemples, peu de variables SVM, kNN, modèle linéaire les modèles simples surapprennent moins
beaucoup de variables (textes, génomique) modèle linéaire régularisé, SVM linéaire, Bayes naïf rapides et robustes en grande dimension
images, sons, textes bruts réseaux de neurones (parties suivantes) ils apprennent eux-mêmes les bonnes variables
règles à faire valider par un expert arbre peu profond lisible comme un questionnaire

Le bon réflexe : commencer par un modèle simple (linéaire) et un modèle puissant (boosting). Si les deux font jeu égal, gardez le simple.

Le TP guidé « Trouver la bonne complexité » reprend la démarche sur un vrai jeu de données : constater le surapprentissage, tracer la courbe de complexité, choisir le réglage par validation croisée, puis l’évaluer une seule fois sur le test. À la fin, vous récupérez le notebook Jupyter de tout ce que vous avez fait.

🔬Les démos et TP guidés

Choisissez « Trouver la bonne complexité ».

→

✅ Vérifiez vos acquis

1. À quel moment choisit-on la métrique d'évaluation ?
2. Un boosting obtient F1 = 0,62 en validation ; prédire toujours la classe majoritaire donne F1 = 0. Une régression logistique obtient 0,61. Que retenir ?
3. Pourquoi mettre la mise à l'échelle dans un pipeline ?
4. Score d'entraînement 0,99, score de validation 0,74. Dans quel sens régler le modèle ?
5. Pour la forêt aléatoire, augmenter le nombre d'arbres…