Ensembles : pourquoi une forêt bat un seul arbre

Demandez à une seule personne combien de bonbons contient un grand bocal, et son estimation sera peut-être très loin du compte. Demandez à quelques centaines de personnes et faites la moyenne de leurs estimations : le résultat est souvent étonnamment proche. Aucun des participants n’est devenu plus malin. Leurs erreurs allaient simplement dans des directions différentes et se sont annulées. Peut-on construire un modèle de la même façon, à partir de beaucoup de modèles médiocres ?

À vous de jouer

• Commencez avec le curseur du nombre d’arbres sur un et comparez la forêt à l’arbre unique. Avec un seul arbre, la « forêt » n’est qu’un arbre rendu aléatoire.
• Montez progressivement le nombre d’arbres et observez l’exactitude de test de la forêt. Repérez où elle cesse de s’améliorer nettement.
• Continuez d’augmenter le nombre d’arbres. L’exactitude de la forêt se met-elle à baisser, comme celle de l’arbre profond dans la leçon 9, ou se stabilise-t-elle ?
• Comparez l’arbre unique et la grande forêt. Auquel confieriez-vous un cas que vous n’avez jamais vu ?

L’idée en quelques mots

Voyons maintenant ce que vous venez de manipuler, en termes simples.

Un ensemble est un modèle fait de nombreux modèles dont on combine les prédictions, par vote pour des catégories ou par moyenne pour des nombres. L’ensemble le plus célèbre est la forêt aléatoire (random forest), présentée par Leo Breiman en 2001 : un grand nombre d’arbres de décision, chacun poussé un peu différemment, qui votent ensemble.

La leçon 9 s’est terminée sur une faiblesse des arbres : un petit changement dans les données peut produire un arbre complètement différent. Un arbre profond isolé est comme un parieur trop sûr de lui – vif, mais imprévisible. Une forêt transforme ce comportement imprévisible en atout. Si chaque arbre fait des erreurs différentes, le vote majoritaire a raison plus souvent qu’un arbre typique.

Pourquoi ça marche

Le mot clé est différentes. Faire la moyenne de modèles identiques ne change rien ; leurs erreurs sont les mêmes. Une forêt aléatoire rend ses arbres différents de deux façons. D’abord, chaque arbre est entraîné sur un échantillon bootstrap : des lignes tirées au hasard dans le jeu d’entraînement avec remise, si bien que chaque arbre voit un jeu de données légèrement différent, où certaines lignes sont répétées et d’autres absentes. Cette idée s’appelle le bagging. Ensuite, à chaque division, un arbre ne peut choisir que parmi un sous-ensemble aléatoire des variables, pour que tous les arbres ne s’appuient pas sur la même variable la plus forte.

La statistique nous dit combien cela aide. Si l’erreur de chaque arbre a une variance σ² et que les erreurs de deux arbres quelconques ont une corrélation ρ, la moyenne de n arbres a pour variance

ρ·σ² + (1 − ρ)·σ² / n

Le second terme diminue quand on ajoute des arbres et disparaît pour un grand n. Le premier, non : c’est la part de l’erreur que tous les arbres partagent. Voilà pourquoi le hasard compte. Moins les arbres se ressemblent (plus ρ est petit), plus la forêt y gagne – et c’est aussi pourquoi ajouter des arbres au-delà d’un certain point n’apporte presque plus rien.

Conséquence agréable : ajouter des arbres ne fait pas apprendre davantage par cœur à la forêt. Chaque nouvel arbre rejoint simplement le vote, et les prédictions de la forêt se stabilisent au lieu de s’emballer. Le prix de plus d’arbres, c’est du temps de calcul, pas du surapprentissage.

Il existe une seconde grande famille d’ensembles, le boosting, qui fonctionne à l’inverse : au lieu d’arbres indépendants qui votent, il construit de petits arbres l’un après l’autre, chacun corrigeant les erreurs des précédents. Les arbres à gradient boosting gagnent souvent sur les données tabulaires, y compris dans de nombreuses compétitions Kaggle.

Erreur fréquente

Un ensemble ne peut pas créer une information absente des variables. Si chaque arbre est trompé de la même façon – par exemple par une variable qui laisse fuir la réponse, ou par des données qui ne représentent pas les personnes pour qui l’on prédit –, le vote ne fait que répéter la même erreur avec plus d’assurance. Le terme corrélé de la formule, c’est exactement cette erreur partagée. Autre erreur : croire que plus d’arbres aident toujours ; une fois les gains aplatis, les arbres supplémentaires ne coûtent que du temps. Enfin, une forêt est bien plus difficile à lire qu’un arbre unique ; vous échangez l’organigramme contre de l’exactitude.

Les arbres et les forêts découpent l’espace des variables en boîtes. Dans la prochaine leçon, nous rencontrons un modèle qui courbe au contraire sa frontière en douceur : le réseau de neurones.

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("data/raw/titanic.csv")
X = pd.DataFrame({"female": (df["sex"] == "female").astype(int)}).join(df[["pclass", "age", "sibsp", "parch", "fare"]])
Xtr, Xte, ytr, yte = train_test_split(X, df["survived"], test_size=0.3, stratify=df["survived"], random_state=1)
Xtr, Xte = Xtr.fillna({"age": Xtr["age"].median()}), Xte.fillna({"age": Xtr["age"].median()})  # médiane d'entraînement pour les deux
tree = DecisionTreeClassifier(random_state=0).fit(Xtr, ytr)
print(f"one full tree: test {tree.score(Xte, yte):.3f}")
for n in (1, 10, 100, 500):
    forest = RandomForestClassifier(n_estimators=n, max_features=2, random_state=0).fit(Xtr, ytr)
    print(f"forest of {n:3d}: test {forest.score(Xte, yte):.3f}")
oob = RandomForestClassifier(n_estimators=500, max_features=2, oob_score=True, random_state=0).fit(Xtr, ytr)
print(f"out-of-bag estimate (500 trees, training rows only): {oob.oob_score_:.3f}")

one full tree: test 0.780
forest of   1: test 0.754
forest of  10: test 0.806
forest of 100: test 0.802
forest of 500: test 0.802
out-of-bag estimate (500 trees, training rows only): 0.809