Régression par forêts aléatoires : le guide complet

Qu’est-ce que la régression par forêts aléatoires ?

La régression par forêts aléatoires est une technique d’ensemble qui construit plusieurs arbres de décision aléatoires et combine leurs sorties pour produire une prédiction continue. Plutôt que de s’appuyer sur un seul modèle, elle agrège les prédictions de nombreux arbres, généralement en prenant la moyenne de leurs résultats.

Pourquoi plusieurs arbres ? Un arbre de décision unique a tendance à surapprendre. Il capte le bruit en plus du signal, surtout avec des données réelles et désordonnées.

Bootstrap aggregating et aléa sur les variables

La force de la régression par forêts aléatoires vient de l’introduction d’aléa à chaque étape, puis de l’agrégation des résultats pour réduire la variance. Voyons ce mécanisme interne. 

Le bootstrap aggregating, ou bagging, entraîne chaque arbre sur un sous‑échantillon aléatoire des données. Cela introduit de la variété entre les arbres et réduit le risque de surapprentissage. 

L’aléa sur les variables ajoute une couche supplémentaire de diversité en sélectionnant un sous‑ensemble aléatoire de variables à chaque séparation. Ensemble, ces techniques stabilisent les prédictions et améliorent la généralisation.

Échantillonnage bootstrap et aléa sur les variables

Random Forest démarre par un échantillonnage bootstrap, également appelé bagging. Chaque arbre est entraîné sur un sous‑ensemble échantillonné aléatoirement du jeu de données initial. Les arbres apprennent ainsi des schémas différents au lieu de reproduire la même structure.

Un aléa sur les variables est également introduit. À chaque split, le modèle ne considère qu’un sous‑ensemble aléatoire de variables plutôt que l’ensemble disponible. Cela évite qu’une poignée de variables dominantes n’influence tous les arbres. 

Ensemble, le bagging et l’aléa sur les variables créent un ensemble d’arbres faiblement corrélés qui commettent des erreurs différentes ; combinées, leurs prédictions annulent le bruit et améliorent la précision globale.

Croissance des arbres et agrégation des prédictions

Chaque arbre de la forêt pousse en profondeur, souvent sans élagage. Cela permet au modèle de capturer des schémas complexes, des interactions et des relations non linéaires dans les données. 

Pris isolément, ces arbres peuvent surajuster, mais cet effet est atténué lorsque Random Forest agrège leurs sorties pour le résultat final.

Le compromis biais‑variance

La forêt aléatoire équilibre deux facteurs clés : la force des arbres individuels et la diversité de la forêt. 

Des arbres profonds ont un faible biais car ils collent de près aux données d’entraînement. En parallèle, l’aléa dans l’échantillonnage des données et la sélection des variables réduit la corrélation entre les arbres. En moyennant de nombreux arbres à faible biais et faiblement corrélés, le modèle réduit la variance globale sans accroître le biais.

Prétraitement des données et mise en œuvre

Passons à la pratique avec des techniques pour transformer des données brutes en un modèle Random Forest opérationnel.

Nettoyage des données et ingénierie des variables

La préparation des données pour les modèles Random Forest commence généralement par le traitement des variables catégorielles. 

• Pour les petites cardinalités, le one‑hot encoding fonctionne bien et reste fiable
• Pour les variables à forte cardinalité, le target encoding est souvent plus efficace, car il capte les signaux au niveau des catégories sans accroître fortement la dimension

Vient ensuite la gestion des données manquantes. L’approche dépend de la bibliothèque utilisée. Certaines implémentations gèrent les valeurs manquantes directement lors des splits, d’autres attendent que vous les imputiez. Dans la plupart des cas, une imputation simple par médiane ou mode suffit. Comme Random Forest ne repose pas sur des distributions strictes, ces méthodes directes tiennent bien en pratique.

Au final, l’impact le plus fort vient de l’ingénierie des variables. Par exemple, les variables de retard (lags) introduisent des dépendances temporelles, les agrégats glissants capturent des tendances locales, et les statistiques groupées encodent des schémas de plus haut niveau. Ces variables conçues enrichissent la représentation et améliorent la performance prédictive.

Pour aller plus loin, je vous recommande mon tutoriel Feature Engineering in Machine Learning.

Établir des bases de référence et des stratégies de découpage

Avant tout réglage, commencez par découper correctement les données. 

Pour des problèmes tabulaires classiques, cela signifie généralement séparer le jeu de données en entraînement, validation et test : le modèle est entraîné sur une partie, ajusté sur une autre, puis évalué sur une dernière partie intacte. 

Cette séparation est essentielle pour estimer fidèlement le comportement du modèle sur de nouvelles données.

Pour les séries temporelles, la stratégie change. Des splits aléatoires peuvent faire fuiter des informations futures vers le passé, ce qui embellit artificiellement les performances.

La validation glissante (walk‑forward) évite ce piège : on entraîne sur une première fenêtre temporelle, on valide sur la suivante, puis on avance pas à pas. L’évaluation reste ainsi alignée avec l’usage réel en production.

Écrire l’implémentation Python de bout en bout

L’implémentation suit un flux simple avec scikit‑learn : 

1. Importer le modèle
2. Découper les données
3. Entraîner l’estimateur
4. Générer les prédictions
5. Évaluer les résultats

En pratique, une configuration typique ressemble à ceci :

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, root_mean_squared_error
import matplotlib.pyplot as plt

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = RandomForestRegressor(random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
rmse = root_mean_squared_error(y_test, y_pred)

Une fois le modèle entraîné et évalué, l’étape suivante consiste à visualiser les valeurs prédites face aux valeurs réelles. 

Un nuage de points permet de repérer facilement un biais systématique, comme des prédictions qui surestiment ou sous‑estiment régulièrement la cible. Il aide aussi à révéler l’hétéroscédasticité, lorsque l’écart des erreurs s’accroît avec la valeur de la cible.

Réglage des hyperparamètres et évaluation

Après l’entraînement, l’étape suivante consiste à ajuster les paramètres clés et à évaluer la performance. Voici les techniques les plus utilisées :

Choisir et interpréter les métriques de régression

La racine de l’erreur quadratique moyenne (RMSE), l’erreur absolue moyenne (MAE) et le R² mesurent différemment la performance. 

• RMSE pénalise davantage les grandes erreurs car elle élève les résidus au carré. Utile lorsque les grosses erreurs sont coûteuses et doivent être minimisées
• MAE traite toutes les erreurs de manière égale, offrant une vision plus stable si les données contiennent des valeurs aberrantes ou si l’erreur moyenne importe plus que des pics occasionnels
• R² mesure la part de variance de la cible expliquée par le modèle ; cela aide à comparer l’ajustement global mais ne reflète pas directement l’erreur de prédiction

Au‑delà des métriques globales, l’analyse des erreurs apporte un éclairage plus fin. Les résidus, définis comme la différence entre valeurs réelles et prédites, doivent être examinés sur différentes tranches de données. 

Tracer les résidus en fonction des valeurs prédites ou des cibles réelles aide à révéler des schémas. Par exemple, si les erreurs augmentent avec la cible, cela indique une hétéroscédasticité. Si les prédictions se situent systématiquement au‑dessus ou en dessous de la diagonale, cela indique un biais systématique.

Segmenter les erreurs par groupes de variables ou par plages de cibles aide aussi à identifier les cas d’échec. Le modèle peut bien performer sur les valeurs intermédiaires mais peiner aux extrêmes, ou se comporter différemment selon les segments.

Utiliser l’évaluation out‑of‑bag (OOB)

Random Forest propose un mécanisme de validation intégré via les échantillons out‑of‑bag. Chaque arbre étant entraîné sur un échantillon bootstrap, une partie des données n’est pas vue à l’entraînement. Ces échantillons OOB servent à évaluer le modèle sans créer un jeu de validation séparé. C’est ce que mesure le score OOB.

Cependant, l’évaluation OOB ne suffit pas toujours. Pour la validation finale, notamment dans des contextes sensibles ou lorsqu’un risque de fuite existe, un jeu de test strictement mis de côté est indispensable. 

Prioriser les hyperparamètres clés à ajuster

Dans Random Forest, les paramètres max_features et n_estimators influencent le plus nettement les performances.

• max_features contrôle le nombre maximal de variables considérées à chaque split. Des valeurs plus faibles augmentent l’aléa et réduisent la corrélation entre les arbres, ce qui peut améliorer la généralisation. Des valeurs plus élevées renforcent les arbres mais les rendent plus similaires, augmentant potentiellement la variance. 

• n_estimators contrôle le nombre d’arbres de la forêt. L’augmenter améliore généralement la stabilité des prédictions, mais accroît aussi le temps de calcul. Au‑delà d’un certain point, les gains deviennent marginaux ; il est donc important d’identifier ce plateau.

Ces paramètres doivent être ajustés en validation croisée afin d’équilibrer complexité du modèle, temps d’entraînement et performance prédictive.

Importance des variables et interprétabilité

Les modèles Random Forest sont souvent perçus comme des boîtes noires, mais ils offrent plusieurs moyens de comprendre l’influence des variables. Voyons les plus importants.

Importance basée sur l’impureté

Random Forest calcule l’importance des variables via la diminution moyenne d’impureté (MDI). Chaque fois qu’une variable sert à scinder un nœud, le modèle mesure de combien cette scission réduit l’impureté, par exemple la variance en régression. Ces réductions sont cumulées sur tous les arbres pour donner un score reflétant la contribution d’une variable à l’amélioration des prédictions.

Cette méthode est rapide et intégrée, mais elle a des limites connues. La MDI favorise les variables continues ou les catégorielles avec de nombreuses modalités. Elles offrent plus de points de coupure potentiels, ce qui peut gonfler leur importance même si elles ne sont pas réellement plus prédictives.

Importance par permutation

L’importance par permutation mesure l’évolution des performances lorsque les valeurs d’une variable sont mélangées aléatoirement dans un jeu de données de validation. Si le mélange dégrade fortement la performance, la variable est importante. Si l’impact est faible, sa valeur prédictive est probablement limitée.

Cette approche reflète le comportement réel du modèle et est donc plus fiable pour l’analyse. 

Cependant, les variables corrélées compliquent l’interprétation. Lorsque deux variables portent une information similaire, permuter l’une peut peu impacter la performance car l’autre fournit toujours le signal. L’importance peut alors se répartir entre variables corrélées, d’où la nécessité d’une lecture prudente.

Valeurs SHAP

Les valeurs SHAP (Shapley Additive Explanations) expliquent la contribution de chaque variable à une prédiction individuelle. Elles attribuent à chaque variable une valeur représentant sa poussée au‑dessus ou en dessous d’une référence. 

Cette méthode sert souvent à expliquer les décisions du modèle et à instaurer la confiance. Pour un examen plus approfondi, consultez notre tutoriel SHAP Values in Machine Learning.

Limites et cas d’échec fréquents

La régression par forêts aléatoires est robuste dans de nombreux scénarios, mais elle présente des limites claires. Les comprendre aide à décider quand l’utiliser et quand changer d’approche.

Limites d’extrapolation et cas aux extrêmes

Random Forest ne peut pas extrapoler au‑delà de l’intervalle observé à l’entraînement. 

Chaque arbre prédit à partir de splits vus pendant l’entraînement ; la sortie finale est donc bornée par les valeurs cibles minimale et maximale observées. Si le modèle n’a vu que des cibles entre 10 et 100, il ne pourra pas prédire 120, même avec un signal d’entrée fort. C’est problématique pour des scénarios comme la prévision de croissance ou les systèmes pilotés par des tendances. 

Le modèle a aussi du mal avec des données éparses de très haute dimension, comme des représentations textuelles ou des vecteurs one‑hot de milliers de colonnes. Les arbres deviennent inefficaces et peinent à trouver des splits pertinents. Des solutions pratiques incluent 

• La réduction de dimension
• La sélection de variables
• L’utilisation de modèles adaptés aux entrées éparses, comme la régression Ridge

Compromis d’interprétabilité

Un arbre unique offre un chemin clair de l’entrée à la prédiction, donc facile à expliquer. Une forêt agrège des centaines d’arbres, ce qui rend les décisions individuelles plus difficiles à retracer.

Dans des environnements très réglementés, ce compromis compte. Si les explications doivent être simples et directement traçables, un arbre de décision unique ou un modèle linéaire peut être plus approprié. Si la performance prime et que les explications peuvent s’appuyer sur l’importance des variables ou SHAP, Random Forest reste une excellente option.

Contraintes de calcul, mémoire et latence

Random Forest évolue linéairement avec le nombre d’arbres et la taille des données. À mesure que les jeux de données grossissent, le temps d’entraînement et l’usage mémoire augmentent, chaque arbre devant être construit et stocké. De grandes forêts peuvent aussi ralentir l’inférence, puisqu’il faut agréger les sorties de tous les arbres.

En production, avec des contraintes strictes de latence ou de coûts, cela peut devenir un goulot d’étranglement. Réduire le nombre d’arbres, limiter la profondeur ou restreindre le nombre de variables par split aide à maîtriser les ressources, au prix d’un léger recul de précision pour un entraînement et des prédictions plus rapides.

Régression par forêts aléatoires vs alternatives : comment choisir

Vous vous demandez peut‑être si la régression par forêts aléatoires est adaptée à votre cas d’usage, ou quelle alternative considérer.

Construire un cadre de comparaison des modèles

Les cas d’usage varient, mais une approche aide toujours : comparez les performances de différents modèles (régression linéaire, support vector regression, gradient boosting, etc.) sur le même jeu de données, en parallèle du Random Forest Regressor. 

Concrètement, utilisez exactement les mêmes partitions d’entraînement, de validation et de test pour chaque modèle, puis évaluez‑les selon les mêmes métriques d’erreur et hypothèses métier.

Régression par forêts aléatoires vs régression linéaire et support vector regression

Random Forest et la régression linéaire répondent à des besoins très différents. La régression linéaire excelle lorsque la relation entre variables d’entrée et cible est surtout linéaire et que l’interprétation des coefficients est clé. C’est aussi le meilleur choix lorsque l’extrapolation stricte compte, car elle peut dépasser l’intervalle observé. 

À l’inverse, Random Forest gère mieux les schémas non linéaires, les interactions et des frontières irrégulières. C’est un outil plus puissant pour des systèmes complexes du monde réel, mais moins adapté aux prévisions très tendance‑dépendantes.

Le support vector regression (SVR) se situe dans un autre registre. Il peut bien performer sur de petits jeux de données, mais il est beaucoup plus sensible au redressement des variables et demande en général un réglage plus fin. Random Forest ne dépend pas d’entrées standardisées, ce qui le rend plus simple à utiliser sur des données tabulaires.

Le SVR peut être un excellent choix avec un jeu de données compact et un espace de variables limité, mais devient difficile à maintenir lorsque le volume, la complexité des variables ou la pression opérationnelle augmentent.

Régression par forêts aléatoires vs gradient boosting et arbre de décision unique

Random Forest construit les arbres indépendamment et moyenne leurs sorties. Le gradient boosting construit des arbres séquentiellement, où chaque nouvel arbre corrige les erreurs des précédents.

Les méthodes de gradient boosting, telles que XGBoost, atteignent généralement de meilleurs plafonds de précision, notamment sur données tabulaires structurées. Elles exigent toutefois plus de réglages et sont plus sensibles aux hyperparamètres. L’entraînement peut aussi être plus lent en raison de la nature séquentielle du boosting. Random Forest est plus simple à entraîner, plus stable par défaut et moins sensible à la configuration.

Comparé à un arbre de décision unique, Random Forest est bien plus stable et précis. Un arbre unique est facile à interpréter car chaque chemin de décision est traçable, mais il est très sensible aux petites variations des données. Random Forest réduit cette instabilité en moyennant de nombreux arbres, au prix d’une perte d’interprétabilité directe.

Résumé de la comparaison des modèles

Pour conclure

La régression par forêts aléatoires est un excellent modèle par défaut lorsque les données sont désordonnées, les relations non linéaires et que vous avez besoin d’une base solide sans prétraitement lourd. Elle gère des types de variables mixtes, capte les interactions et offre des performances stables avec un minimum de configuration.

Le flux de travail type suit une progression claire. Commencez par un prétraitement minimal et soignez la structuration des données. Construisez une base de référence avec un modèle Random Forest par défaut et évaluez‑la avec des métriques cohérentes. À partir de là, ajustez des hyperparamètres clés comme le nombre d’arbres et la stratégie d’échantillonnage des variables pour gagner en performance. 

Une fois le modèle stabilisé, passez à une évaluation approfondie : analyse des résidus, segmentation des erreurs et utilisation de SHAP pour expliquer les prédictions si nécessaire. 

Pour aller plus loin, et pratiquer pas à pas, découvrez ce cours Machine Learning with Tree-Based Models in Python.