Aller au contenu
Data science

Les méthodes d'ensemble : forêts et boosting

⏱ 1 h

Prérequis : Les arbres de décision · Sous-apprentissage et surapprentissage

À la fin de ce chapitre, vous saurez :
  • expliquer pourquoi un vote de modèles peut battre chaque modèle ;
  • décrire le bagging et la forêt aléatoire, et pourquoi elle rend ses arbres différents ;
  • décrire le principe du gradient boosting ;
  • choisir entre forêt et boosting et régler leurs hyperparamètres principaux.

En 1906, le statisticien Francis Galton observe un concours où 800 visiteurs d’une foire estiment le poids d’un bœuf. Aucun ne trouve le bon poids, mais la moyenne des estimations tombe à moins de 1 % de la vérité. Les erreurs individuelles, dans un sens ou dans l’autre, se compensent.

Les méthodes d’ensemble appliquent cette idée aux modèles : on en entraîne beaucoup, et on combine leurs prédictions. Mais à une condition, que le widget met en évidence :

  • Avec des modèles indépendants, même médiocres (60 % chacun), le vote de 100 modèles dépasse 97 %.
  • Dès que les modèles se trompent ensemble (erreurs corrélées), le gain s’effondre : 100 copies du même modèle votent comme un seul.
  • Des modèles pires que le hasard empirent en votant.

Tout l’art est donc de fabriquer des modèles à la fois bons et différents.

Les arbres sont des candidats idéaux : rapides, souples, mais instables. Un petit changement des données produit un arbre très différent. Le bagging (bootstrap aggregating) exploite cette instabilité :

  1. on tire au hasard, avec remise, nn exemples parmi les nn d’entraînement (un échantillon bootstrap, où certains exemples apparaissent plusieurs fois et d’autres jamais) ;
  2. on entraîne un arbre profond sur cet échantillon ;
  3. on recommence des centaines de fois ;
  4. on fait voter les arbres (en régression, on fait la moyenne de leurs prédictions : voir Les modèles non linéaires en régression).

La forêt aléatoire ajoute un second hasard : à chaque nœud, l’arbre ne peut choisir sa question que parmi un tirage de quelques variables (souvent p\sqrt{p}). Cela empêche tous les arbres de commencer par la même variable dominante, et les rend encore plus différents.

Chaque arbre surapprend, mais leurs erreurs sont en partie indépendantes : le vote garde le signal et moyenne le bruit. Ajouter des arbres ne fait pas surapprendre ; cela coûte seulement du temps de calcul.

🔬Une forêt qui grandit

Regardez la forêt s’agrandir arbre par arbre : la frontière en escalier d’un arbre seul devient de plus en plus lisse, et la précision se stabilise.

→

Le boosting combine aussi beaucoup d’arbres, mais à la chaîne plutôt qu’en parallèle. Chaque nouvel arbre, volontairement petit (profondeur 1 à 5), se concentre sur ce que les précédents ratent encore :

  1. on part d’une prédiction simple (la moyenne, ou la proportion de chaque classe) ;
  2. on calcule les résidus : ce qui reste à corriger ;
  3. un petit arbre apprend à prédire ces résidus ;
  4. on ajoute sa correction, multipliée par un taux d’apprentissage (souvent 0,05 à 0,3) ;
  5. on recommence.

C’est une descente de gradient… où chaque pas est un arbre : d’où le nom de gradient boosting. Ses implémentations rapides (XGBoost, LightGBM, CatBoost, et HistGradientBoostingClassifier dans scikit-learn) dominent les compétitions sur les données tabulaires.

Contrairement à la forêt, le boosting peut surapprendre si on ajoute trop d’arbres : on règle leur nombre par validation croisée, ou par arrêt précoce.

🔬Le boosting étape par étape

Les cercles autour des points montrent ce qui reste à corriger : ils rétrécissent à mesure que les arbres s’ajoutent.

→
Forêt aléatoire Gradient boosting
construction arbres indépendants, en parallèle arbres à la chaîne, chacun corrige les précédents
arbres profonds petits
ce qu’elle réduit surtout la variance le biais
surapprentissage avec plus d’arbres non oui (régler le nombre d’arbres)
réglages peu sensibles, bons par défaut plus délicats (taux, profondeur, nombre d’arbres)
performance très bonne souvent la meilleure sur données tabulaires

En pratique : une forêt aléatoire est un excellent premier modèle, robuste et presque sans réglage ; le gradient boosting, bien réglé, va souvent un peu plus loin.

🎓 Pour aller plus loin : pourquoi le bagging réduit la variance

Soient BB modèles dont les prédictions ont chacune une variance σ2\sigma^2 et une corrélation deux à deux ρ\rho. La variance de leur moyenne vaut

Var⁡ ⁣(1B∑b=1Bfb)=ρ σ2+1−ρB σ2.\operatorname{Var}\!\Big(\frac{1}{B}\sum_{b=1}^{B} f_b\Big) = \rho\,\sigma^2 + \frac{1 - \rho}{B}\,\sigma^2 .

Quand BB grandit, le second terme disparaît, mais le premier reste : la corrélation ρ\rho fixe un plancher. Le tirage des variables de la forêt aléatoire sert précisément à réduire ρ\rho, au prix d’arbres individuellement un peu moins bons.

Le boosting, lui, minimise une perte LL en ajoutant des fonctions : Fm(x)=Fm−1(x)+ν hm(x)F_m(x) = F_{m-1}(x) + \nu\, h_m(x), où hmh_m est un arbre ajusté sur les pseudo-résidus ri=−∂L(yi,F(xi))/∂F(xi)r_i = -\partial L(y_i, F(x_i)) / \partial F(x_i), c’est-à-dire l’opposé du gradient de la perte par rapport à la prédiction. Pour la MSE, ce sont exactement les résidus yi−Fm−1(xi)y_i - F_{m-1}(x_i).

Bonus du bagging : chaque exemple est absent d’environ (1−1/n)n≈37 %(1 - 1/n)^n \approx 37\,\% des échantillons bootstrap. Les arbres qui ne l’ont pas vu peuvent le prédire : c’est l’erreur hors du sac (out-of-bag, oob_score=True), une validation gratuite.

from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
foret = RandomForestClassifier(n_estimators=300, max_features="sqrt", oob_score=True, random_state=0)
boost = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=300, early_stopping=True, random_state=0)

✅ Vérifiez vos acquis

1. Pourquoi 100 copies identiques du même arbre ne font pas mieux qu'un seul arbre ?
2. Dans une forêt aléatoire, à quoi sert le tirage d'un sous-ensemble de variables à chaque nœud ?
3. On passe d'une forêt de 100 à 1 000 arbres. Que se passe-t-il le plus probablement ?
4. Dans le gradient boosting, que prédit chaque nouvel arbre ?
5. Quel modèle peut surapprendre si on augmente trop le nombre d'arbres ?