Random Forests: Ensemble Power for Classification

1. L'idée de base : la sagesse de la foule

L'intuition derrière les forêts aléatoires est simple : si vous posez une question complexe à un seul expert, sa réponse peut être biaisée ou incorrecte. Mais si vous posez la même question à un grand groupe d'experts diversifiés et que vous combinez leurs réponses, la décision collective sera probablement bien meilleure.

Une forêt aléatoire applique ce principe aux arbres de décision. Au lieu de se fier à un seul arbre qui pourrait avoir "surappris", on en construit des centaines (voire des milliers) et on les fait "voter" pour la prédiction finale. Mais pour que cela fonctionne, les arbres doivent être différents les uns des autres. Comment y parvenir ? La réponse se trouve dans le mot "aléatoire". L'algorithme introduit deux sources de hasard.

La vidéo suivante de StatQuest, l'une des meilleures ressources pour l'intuition en machine learning, décompose ce processus de manière très visuelle.

Pour résumer les deux mécanismes clés :

1. Bootstrap (échantillonnage de données) : Pour chaque arbre que nous voulons construire, nous ne lui donnons pas l'ensemble des données d'entraînement original. À la place, nous créons un nouvel ensemble de données de la même taille en tirant des échantillons au hasard avec remise. Cela signifie que certaines données originales peuvent apparaître plusieurs fois dans ce nouvel ensemble, tandis que d'autres peuvent ne pas y apparaître du tout. Chaque arbre est donc entraîné sur une version légèrement différente des données.

2. Randomisation des caractéristiques : Lorsque chaque arbre est construit, à chaque fois qu'il doit décider comment diviser un nœud, il ne regarde pas toutes les caractéristiques disponibles. Il en sélectionne un sous-ensemble aléatoire (par exemple, 3 caractéristiques sur 10) et ne cherche la meilleure division que parmi celles-ci. Cela empêche les arbres de toujours se baser sur les mêmes caractéristiques les plus prédictives et les force à explorer d'autres relations dans les données.

Ces deux types de hasard garantissent que les arbres de la forêt sont très différents les uns des autres.

2. Du Bootstrap à l'agrégation (Bagging)

Le processus qui combine le bootstrap et l'agrégation des prédictions s'appelle le Bagging, un acronyme pour Bootstrap Aggregating.

L'article suivant renforce ces concepts avec des explications textuelles claires.

Pour une explication en arabe qui couvre les mêmes concepts, la vidéo suivante est une excellente ressource.

3. Arbre de décision vs Forêt aléatoire : le compromis

Maintenant que nous comprenons le fonctionnement des forêts aléatoires, comparons-les directement aux arbres de décision.

L'article suivant propose un tableau comparatif très utile que je vous invite à étudier.

4. Entraîner une forêt aléatoire avec Scikit-learn

Heureusement, Scikit-learn rend l'entraînement d'une forêt aléatoire aussi simple que celui d'un arbre de décision. L'objet que nous utiliserons est RandomForestClassifier.

Avant de coder, il est utile de connaître ses principaux hyperparamètres. La plupart sont les mêmes que pour DecisionTreeClassifier (comme max_depth), mais il y en a un de nouveau et de très important.

Voici comment l'implémenter en Python. Nous utiliserons le même jeu de données sur le cancer du sein que dans la leçon précédente pour pouvoir comparer.

# 1. Importer les bibliothèques
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score




# 2. Charger les données
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target




# 3. Séparer les données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)




# 4. Entraîner un arbre de décision simple (rappel de la leçon précédente)
dt_classifier = DecisionTreeClassifier(random_state=42)
dt_classifier.fit(X_train, y_train)
y_pred_dt = dt_classifier.predict(X_test)
accuracy_dt = accuracy_score(y_test, y_pred_dt)
print(f"Précision de l'arbre de décision unique : {accuracy_dt:.4f}")




# 5. Entraîner une forêt aléatoire
# n_estimators=100 signifie que nous construisons 100 arbres
rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.fit(X_train, y_train)
y_pred_rf = rf_classifier.predict(X_test)
accuracy_rf = accuracy_score(y_test, y_pred_rf)
print(f"Précision de la forêt aléatoire : {accuracy_rf:.4f}")

En exécutant ce code, vous devriez constater que la précision de la forêt aléatoire est supérieure à celle de l'arbre de décision unique. L'arbre unique, sans limite de profondeur, a probablement surappris les données d'entraînement, tandis que la forêt aléatoire, grâce à l'agrégation, a mieux généralisé.

Tout comme un arbre de décision, une forêt aléatoire peut aussi vous donner une estimation de l'importance des caractéristiques (rf_classifier.feature_importances_). Cet indicateur est généralement plus fiable car il est moyenné sur tous les arbres de la forêt.

Conclusion

Dans cette leçon, nous avons fait un grand pas en avant en passant d'un modèle unique à un ensemble de modèles. Les forêts aléatoires sont l'un des algorithmes les plus populaires et les plus efficaces en machine learning classique.

Points clés à retenir :

• Une forêt aléatoire est un ensemble (ou une collection) de plusieurs arbres de décision.
• Elle surmonte le problème de surapprentissage des arbres uniques en introduisant du hasard de deux manières :
  1. Bootstrap : chaque arbre est entraîné sur un échantillon aléatoire (avec remise) des données.
  2. Randomisation des caractéristiques : chaque division de nœud ne considère qu'un sous-ensemble aléatoire de caractéristiques.
• La prédiction finale est obtenue par vote majoritaire (en classification) parmi tous les arbres. Ce processus est appelé Bagging.
• Le principal avantage est une précision et une robustesse accrues. L'inconvénient est une perte d'interprétabilité et un coût de calcul plus élevé.

Maintenant que vous savez entraîner des modèles puissants comme les forêts aléatoires, une question se pose : comment choisir les meilleurs hyperparamètres (comme n_estimators ou max_depth) ? Dans la prochaine leçon, nous aborderons les techniques de validation croisée (k-fold cross-validation) et de recherche en grille (GridSearchCV), qui nous permettent d'optimiser méthodiquement nos modèles pour obtenir les meilleures performances possibles.