Accueil › Glossaire › Random Forest

Random Forest (Forêt Aléatoire)

Random Forest est un algorithme d’ensemble qui entraîne un grand nombre d’arbres de décision sur des sous-échantillons aléatoires des données, puis agrège leurs prédictions (vote majoritaire en classification, moyenne en régression) pour produire un modèle robuste et précis.

Inventé par Leo Breiman en 2001, Random Forest est l’un des algorithmes les plus utilisés en machine learning grâce à son excellent compromis entre performance, facilité d’utilisation et interprétabilité. Il fonctionne aussi bien en classification qu’en régression, gère naturellement les features numériques et catégorielles, nécessite peu de prétraitement, et fournit nativement une mesure d’importance des features. C’est souvent le premier modèle non linéaire à essayer après une baseline linéaire.

Comment fonctionne Random Forest

Le bagging : la fondation

Random Forest repose sur le bagging (Bootstrap Aggregating). Chaque arbre est entraîné sur un sous-échantillon bootstrap des données : on tire aléatoirement N observations avec remplacement (certaines apparaissent plusieurs fois, d’autres pas du tout). En moyenne, chaque arbre voit environ 63,2 % des données originales. Les ~36,8 % restantes (échantillons « out-of-bag », OOB) servent d’ensemble de validation interne.

La randomisation des features : la clé

La différence entre Random Forest et un simple bagging d’arbres est la sélection aléatoire des features. À chaque noeud de chaque arbre, seul un sous-ensemble aléatoire de features est considéré pour le split. Cela force les arbres à être différents les uns des autres (décorrélés), ce qui améliore la diversité de l’ensemble et réduit la variance des prédictions.

Le nombre de features considérées à chaque split est contrôlé par max_features. Les valeurs par défaut de scikit-learn sont 'sqrt' (racine carrée du nombre total de features) pour la classification et 1.0 (toutes les features) pour la régression.

L’agrégation des prédictions

En classification, chaque arbre vote pour une classe. La classe qui reçoit le plus de votes gagne (vote majoritaire). En régression, chaque arbre produit une valeur. La prédiction finale est la moyenne de toutes les valeurs.

Cette agrégation de centaines d’arbres imparfaits produit un modèle beaucoup plus stable et précis que n’importe quel arbre individuel. C’est le principe de la « sagesse des foules » appliqué aux modèles de ML.

Les hyperparamètres clés

Random Forest en Python avec scikit-learn

Classification

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report

# Charger les données
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# Entraîner le modèle
rf = RandomForestClassifier(n_estimators=200, max_depth=20,
                             random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)

# Évaluation
print(f"Score test : {rf.score(X_test, y_test):.4f}")
print(f"Score OOB : {rf.oob_score_:.4f}" if hasattr(rf, 'oob_score_') else "")
print(classification_report(y_test, rf.predict(X_test)))

Régression

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

rf_reg = RandomForestRegressor(n_estimators=200, max_depth=15,
                                random_state=42, n_jobs=-1)
rf_reg.fit(X_train, y_train)

y_pred = rf_reg.predict(X_test)
print(f"R² : {r2_score(y_test, y_pred):.4f}")
print(f"RMSE : {np.sqrt(mean_squared_error(y_test, y_pred)):.4f}")

L’importance des features : la force de Random Forest

L’une des raisons majeures d’utiliser Random Forest est sa capacité native à mesurer l’importance des features. Trois méthodes existent.

Importance par impureté (Gini importance)

Calculée pendant l’entraînement, gratuitement. Pour chaque feature, on mesure combien elle réduit en moyenne l’impureté (Gini pour la classification, variance pour la régression) à chaque split. C’est l’attribut .feature_importances_ de scikit-learn.

import pandas as pd
import matplotlib.pyplot as plt

# Importance Gini
importances = rf.feature_importances_
feature_names = load_breast_cancer().feature_names

feat_imp = pd.Series(importances, index=feature_names)
feat_imp.nlargest(10).plot(kind='barh', color='#7c3aed')
plt.xlabel('Gini Importance')
plt.title('Top 10 features (Gini)')
plt.tight_layout()
plt.show()

Permutation importance

Plus fiable que la Gini importance. On mélange aléatoirement les valeurs d’une feature et on mesure la baisse de performance du modèle. Si la performance chute fortement, la feature est importante. Calculée sur le jeu de test, elle est insensible aux biais de la Gini importance.

from sklearn.inspection import permutation_importance

result = permutation_importance(rf, X_test, y_test,
                                 n_repeats=10, random_state=42,
                                 n_jobs=-1)

perm_imp = pd.Series(result.importances_mean,
                      index=feature_names)
perm_imp.nlargest(10).plot(kind='barh', color='#f97316')
plt.xlabel('Mean Accuracy Decrease')
plt.title('Top 10 features (Permutation)')
plt.tight_layout()
plt.show()

SHAP values

Les valeurs SHAP (SHapley Additive exPlanations) quantifient la contribution de chaque feature à chaque prédiction individuelle. C’est la méthode la plus complète et la plus rigoureuse, mais aussi la plus coûteuse en calcul. Particulièrement utile pour l’explicabilité du modèle.

Le score Out-of-Bag (OOB)

Grâce au bootstrap, chaque arbre n’a pas vu ~36,8 % des données. Random Forest peut utiliser ces échantillons non vus pour estimer la performance du modèle sans jeu de validation séparé. C’est le score OOB, activé avec oob_score=True.

rf = RandomForestClassifier(n_estimators=200, oob_score=True,
                             random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)
print(f"Score OOB : {rf.oob_score_:.4f}")

Le score OOB est une estimation honnête de la performance de généralisation, similaire à une validation croisée mais gratuite en calcul. Il est particulièrement utile pour estimer rapidement si le modèle overfitte.

Random Forest vs Gradient Boosting

En résumé : Random Forest est le meilleur choix quand vous voulez un modèle performant rapidement, sans passer des heures à tuner des hyperparamètres. XGBoost/LightGBM sont le choix quand vous cherchez la performance maximale et êtes prêt à investir dans le tuning.

Pourquoi Random Forest est si populaire

Peu de prétraitement : pas besoin de normaliser les features (les arbres sont invariants aux transformations monotones). Gère les features numériques et catégorielles (avec encodage). Supporte nativement les valeurs manquantes (scikit-learn 1.8).

Robustesse : résistant aux outliers (les arbres les isolent naturellement), peu sensible aux hyperparamètres (fonctionne bien avec les défauts), et le risque d’overfitting diminue (ou stagne) quand on augmente le nombre d’arbres.

Interprétabilité : feature importance native, possibilité d’inspecter les arbres individuels, compatible avec SHAP et LIME pour l’explicabilité.

Polyvalence : classification, régression, feature selection, détection d’anomalies (via Isolation Forest, un cousin), et estimation de l’incertitude (via la variance entre les arbres).

Limites de Random Forest

Performance inférieure au gradient boosting : sur la plupart des datasets tabulaires, XGBoost/LightGBM surpassent Random Forest de quelques points de pourcentage après tuning. La différence est souvent faible, mais elle existe.

Mémoire et vitesse : une forêt de 500 arbres profonds consomme beaucoup de mémoire et peut être lente en inférence. Pour la production, envisagez de limiter la profondeur ou d’utiliser HistGradientBoostingClassifier (natif scikit-learn, beaucoup plus rapide).

Extrapolation impossible : un Random Forest ne peut pas prédire en dehors de la plage des données d’entraînement. Si la cible est un prix qui a augmenté de 20 % depuis l’entraînement, le modèle ne pourra pas capter cette tendance. Les modèles linéaires n’ont pas ce problème.

Données de très haute dimension avec peu d’échantillons : quand d >> n (beaucoup plus de features que d’observations), Random Forest peut overfitter malgré le bagging. Une réduction de dimensionnalité ou une sélection de features en amont est recommandée.

Verdict

Random Forest est le couteau suisse du ML tabulaire. Pas toujours le meilleur modèle absolu, mais presque toujours dans le top 3, et de loin le plus facile à déployer. C’est le modèle que tout data scientist devrait essayer en premier après une baseline linéaire : il établit un plancher de performance élevé avec un minimum d’effort.

Notre recommandation : commencez par Random Forest avec les défauts de scikit-learn (200-500 arbres), examinez les feature importances, puis décidez si le gain potentiel de XGBoost/LightGBM justifie le temps de tuning supplémentaire. Dans de nombreux cas industriels, la réponse est non.