Random Forest en R : bagging, importance des variables, OOB
Faites pousser une forêt d’arbres décorrélés, lisez l’erreur out-of-bag et classez les prédicteurs par importance — en classification comme en régression
Un guide pratique de la random forest en R, en classification et en régression. Comprenez le bagging (bootstrap aggregating) et l’astuce du sous-espace aléatoire qui décorrèle les arbres, lisez l’erreur out-of-bag (OOB) comme une validation gratuite, et classez les prédicteurs grâce au graphique signature d’importance des variables. Traité de deux façons — le workflow tidymodels moderne avec parsnip + ranger (réglage de mtry et min_n par validation croisée) et la voie classique randomForest + importance()/varImpPlot — sur les données PimaIndiansDiabetes2, avec une note de régression sur Boston.
Date de publication
25 juin 2026
Modifié
7 juillet 2026
AstucePoints clés
Le bagging (bootstrap aggregating) fait pousser de nombreux arbres, chacun sur un rééchantillon bootstrap différent des données, puis moyenne leurs prédictions (ou prend un vote majoritaire). Moyenner de nombreux arbres bruités transforme un arbre unique instable en un modèle stable et précis.
La random forest est un bagging avec une astuce supplémentaire : à chaque coupure, seul un sous-ensemble aléatoire de prédicteurs (mtry) est considéré. Cela décorrèle les arbres, de sorte que leur moyenne est encore plus resserrée — l’amélioration phare par rapport au bagging simple.
L’erreur out-of-bag (OOB) est une validation gratuite : chaque arbre laisse de côté environ un tiers des lignes (son échantillon out-of-bag), si bien que la forêt s’évalue elle-même sur des données mises de côté, sans boucle de CV séparée.
L’importance des variables est la sortie signature — un graphique classé des prédicteurs qui pilotent réellement la prédiction. L’importance par permutation (mélanger un prédicteur et observer la chute de précision) est celle digne de confiance.
Les boutons de réglage : mtry (prédicteurs par coupure — le cadran de décorrélation), trees (plus nombreux est plus sûr, avec des rendements décroissants) et min_n (taille minimale de nœud — plus grand = arbres plus simples). Réglez mtry/min_n par validation croisée.
Deux voies, même idée : le workflow tidymodels moderne (rand_forest(mtry = tune(), trees =, min_n = tune()) |> set_engine("ranger")) réglé par CV, ou le classique randomForest() + importance()/varImpPlot(). La random forest fonctionne aussi bien en classification qu’en régression.
Un arbre de décision unique est facile à lire mais instable : changez une poignée de lignes d’entraînement et l’arbre entier peut se réorganiser, et ses prédictions varient. Le remède n’est pas un meilleur arbre unique — c’est beaucoup d’arbres, combinés.
Le bagging (bootstrap aggregating) fait exactement cela : tirer de nombreux rééchantillons bootstrap des données d’entraînement, ajuster un arbre complet sur chacun, puis moyenner leurs prédictions (pour la régression) ou prendre un vote majoritaire (pour la classification). Chaque arbre individuel reste bruité, mais le bruit s’annule en grande partie dans la moyenne, et le modèle combiné est bien plus stable et précis que n’importe quel arbre unique.
La random forest affûte le bagging avec un ajout astucieux. Si quelques prédicteurs forts dominent, chaque arbre baggé aura tendance à se couper d’abord sur eux, de sorte que les arbres finissent corrélés — et moyenner des arbres corrélés n’aide guère. La random forest brise cette corrélation : à chaque coupure, elle n’offre à l’arbre qu’un sous-ensemble aléatoire des prédicteurs (de taille mtry) parmi lesquels choisir. Forcés d’utiliser différentes variables, les arbres se décorrèlent, et leur moyenne est plus resserrée encore. Cette seule idée — bagging + sous-ensembles aléatoires de variables par coupure — fait de la random forest l’un des modèles prêts à l’emploi les plus fiables en machine learning.
Cette leçon traite la random forest de bout en bout, de façon pratique : nous prédisons le diabète à partir de mesures cliniques, lisons l’erreur out-of-bag, produisons le graphique signature d’importance des variables, et réglons la forêt par validation croisée — de deux façons, le workflow tidymodels moderne avec parsnip + ranger, et la voie classique randomForest(). Nous concluons par un court exemple de régression. Pour l’étape suivante en puissance prédictive, voir le gradient boosting.
NoteQuand y recourir
Recourez à la random forest quand vous voulez un modèle prédictif puissant et sans tracas qui gère automatiquement les effets non linéaires et les interactions, ne demande presque aucun prétraitement (pas de mise à l’échelle, robuste aux valeurs aberrantes), et vous dit quels prédicteurs comptent. C’est un excellent choix par défaut, en classification comme en régression. Préférez un arbre de décision unique quand vous avez besoin d’un modèle qu’un humain peut lire de bout en bout ; recourez au gradient boosting quand vous voulez gagner un peu plus de précision et que vous êtes prêt à régler plus soigneusement.
Les données
Nous utilisons le jeu de données PimaIndiansDiabetes2 du package mlbench : 768 femmes d’origine Pima amérindienne, avec pour objectif de prédire le diabetes (une issue binaire pos/neg) à partir de huit prédicteurs cliniques — nombre de grossesses (pregnant), glucose plasmatique, pressure artérielle, épaisseur du pli cutané triceps, insulin sérique, indice de masse corporelle (mass), la fonction pedigree de diabète, et l’age.
Cette version comporte des valeurs manquantes (enregistrées en NA lorsqu’une mesure est implausible, p. ex. une insuline nulle). En suivant l’analyse source, nous supprimons les lignes incomplètes, ce qui laisse 392 enregistrements complets, puis nous découpons en un jeu d’entraînement (80 %, pour l’ajustement et le réglage) et un jeu de test (20 %, mis de côté pour juger honnêtement le modèle final). Nous stratifions sur diabetes afin que les deux jeux gardent le même équilibre positifs/négatifs, et fixons une graine pour la reproductibilité :
library(rsample)data("PimaIndiansDiabetes2", package ="mlbench")# Drop rows with missing measurementspima <-na.omit(PimaIndiansDiabetes2)set.seed(123)split <-initial_split(pima, prop =0.80, strata = diabetes)train_data <-training(split)test_data <-testing(split)c(complete =nrow(pima), train =nrow(train_data), test =nrow(test_data))
complete train test
392 313 79
# The stratified split preserves the class balanceprop.table(table(train_data$diabetes))
Donc 313 patients pour apprendre, 79 mis de côté pour jouer les juges, et 8 prédicteurs. Environ un tiers des patients sont diabétiques-positifs — un problème de classification modérément déséquilibré mais exploitable. Contrairement aux modèles pénalisés, la random forest n’a besoin d’aucune standardisation et se contente parfaitement des prédicteurs tels qu’ils sont.
La voie classique : randomForest, erreur OOB et importance
La plupart des utilisateurs de R découvrent la random forest via le package randomForest. C’est l’endroit le plus clair pour voir les deux idées qui définissent une forêt — l’erreur out-of-bag et l’importance des variables — donc nous commençons ici, puis montrons le workflow tidymodels.
Nous faisons pousser 500 arbres avec importance = TRUE (afin que la forêt suive à quel point chaque prédicteur compte). Imprimer l’objet ajusté nous livre l’erreur OOB gratuitement :
Call:
randomForest(formula = diabetes ~ ., data = train_data, ntree = 500, importance = TRUE)
Type of random forest: classification
Number of trees: 500
No. of variables tried at each split: 2
OOB estimate of error rate: 24.6%
Confusion matrix:
neg pos class.error
neg 178 31 0.1483254
pos 46 58 0.4423077
Lecture de la sortie :
Number of trees: 500 — la forêt a fait pousser 500 arbres, chacun sur son propre rééchantillon bootstrap des 313 lignes d’entraînement.
No. of variables tried at each split: 2 — c’est mtry. La valeur par défaut en classification est floor(sqrt(p)), donc avec 8 prédicteurs la forêt offre à chaque coupure un sous-ensemble aléatoire de 2 d’entre eux parmi lesquels choisir. Cette restriction aléatoire est l’astuce de décorrélation.
OOB estimate of error rate ≈ 24.6% — l’erreur out-of-bag. Chaque arbre a été construit sur un rééchantillon bootstrap qui, par hasard, a laissé de côté environ un tiers des lignes ; la forêt prédit ces lignes mises de côté à partir des arbres qui ne les ont jamais vues, et l’erreur sur ces lignes est une estimation de test honnête et intégrée — aucun jeu de validation ni boucle de CV séparés requis. Une erreur OOB d’environ 25 % signifie que la forêt classe correctement à peu près 75 % des patients inédits.
La matrice de confusion décompose l’erreur OOB par classe : la forêt est bien meilleure sur la classe négative (class.error ≈ 0.15) que sur la classe positive (≈ 0.44) — encore l’histoire de l’issue déséquilibrée, à garder en tête quand vous lisez la précision globale.
NoteL’erreur out-of-bag (OOB) — une validation gratuite
Parce que chaque rééchantillon bootstrap omet ~1/3 des lignes, chaque ligne est « out of bag » pour ~1/3 des arbres. Prédire chaque ligne à partir des seuls arbres qui ne l’ont jamais entraînée donne une estimation d’erreur sur données mises de côté sans coût supplémentaire. Pour les grandes forêts, l’erreur OOB est un substitut proche de la validation croisée, ce qui explique pourquoi la random forest a besoin de moins de rééchantillonnage explicite que la plupart des modèles.
L’évaluer sur le jeu de test
L’erreur OOB estime déjà la performance de test, mais confirmons-la sur le jeu de test intact de 20 % :
La précision de test est d’environ 0.75 — tout à fait conforme à l’estimation OOB (1 − 0.246 ≈ 0.75). La forêt généralise comme l’erreur OOB le promettait, ce qui est exactement ce qui fait de l’OOB un raccourci aussi utile.
L’importance des variables — la sortie signature
La raison phare d’ajuster une random forest (au-delà de la précision) est qu’elle vous dit quels prédicteurs comptent. Avec importance = TRUE, randomForest::importance() rapporte deux mesures :
library(rsample)library(randomForest)data("PimaIndiansDiabetes2", package ="mlbench")pima <-na.omit(PimaIndiansDiabetes2)set.seed(123)split <-initial_split(pima, prop =0.80, strata = diabetes)train_data <-training(split)set.seed(123)rf <-randomForest(diabetes ~ ., data = train_data, ntree =500, importance =TRUE)# Note the namespace: yardstick/vip also export import() helpers, so call it explicitlyround(randomForest::importance(rf), 2)
MeanDecreaseAccuracy — la chute moyenne de la précision out-of-bag de la forêt lorsque les valeurs de ce prédicteur sont mélangées au hasard (de sorte que son information est détruite). Une grande chute signifie que la forêt s’appuyait fortement dessus. C’est l’importance par permutation, calculée sur des données OOB mises de côté, et c’est la mesure digne de confiance.
MeanDecreaseGini — la réduction totale d’impureté de nœud (l’indice de Gini) issue des coupures sur cette variable, sommée sur tous les arbres. Elle est moins coûteuse mais calculée sur le jeu d’entraînement, donc elle peut être optimiste et biaisée en faveur des prédicteurs à forte cardinalité. Préférez MeanDecreaseAccuracy quand elles divergent.
glucose et age ressortent en tête — les deux prédicteurs sur lesquels la forêt s’appuie le plus, ce qui correspond à l’histoire clinique (le glucose plasmatique et l’âge sont les marqueurs de risque classiques du diabète). insulin suit.
La figure signature est le graphique d’importance des variables — un graphique à points classant les prédicteurs. Nous traçons la version d’importance par permutation (type = 1), celle à laquelle se fier :
library(rsample)library(randomForest)data("PimaIndiansDiabetes2", package ="mlbench")pima <-na.omit(PimaIndiansDiabetes2)set.seed(123)split <-initial_split(pima, prop =0.80, strata = diabetes)train_data <-training(split)set.seed(123)rf <-randomForest(diabetes ~ ., data = train_data, ntree =500, importance =TRUE)# type = 1 = permutation importance (mean decrease in accuracy) — the trustworthy onevarImpPlot(rf, type =1, pch =19, color ="#3a86d4",main ="Variable importance (Pima diabetes)")
Lisez le graphique de haut en bas : plus un prédicteur est situé à droite, plus la précision de la forêt chute quand vous le brouillez — c.-à-d. plus le modèle en dépend. glucose et age dominent ; pressure ne bouge guère l’aiguille. Cette seule image est ce qui fait de la random forest une favorite pour comprendre un jeu de données, et pas seulement le prédire. (Pour une importance agnostique au modèle qui fonctionne sur n’importe quel modèle — pas seulement les forêts — voir importance des variables.)
Le workflow tidymodels : régler la forêt par validation croisée
Les valeurs par défaut de randomForest sont bonnes, mais mtry et min_n méritent d’être réglés. tidymodels le fait proprement avec le moteur ranger (une implémentation rapide et moderne de la random forest). La seule chose qui change par rapport à n’importe quel autre modèle tidymodels est la spécification : rand_forest() avec les boutons marqués tune().
Nous gardons la forêt à un modeste nombre de 500 arbres, marquons mtry (prédicteurs par coupure) et min_n (taille minimale de nœud) pour le réglage, évaluons par ROC AUC et précision sur une validation croisée à 5 plis, sur une petite grille :
library(rsample)library(recipes)library(parsnip)library(workflows)library(tune)library(yardstick)library(ranger)data("PimaIndiansDiabetes2", package ="mlbench")pima <-na.omit(PimaIndiansDiabetes2)set.seed(123)split <-initial_split(pima, prop =0.80, strata = diabetes)train_data <-training(split)# No preprocessing needed — random forest handles raw predictorsrec <-recipe(diabetes ~ ., data = train_data)# mtry + min_n left to tune; trees fixed at 500; permutation importancerf_spec <-rand_forest(mtry =tune(), trees =500, min_n =tune()) |>set_engine("ranger", importance ="permutation") |>set_mode("classification")rf_wf <-workflow() |>add_recipe(rec) |>add_model(rf_spec)# 5-fold CV on the training set + a small explicit grid (keeps compute modest)set.seed(123)folds <-vfold_cv(train_data, v =5, strata = diabetes)grid <-expand.grid(mtry =c(2, 3, 4), min_n =c(2, 5, 10))set.seed(123)rf_tuned <-tune_grid( rf_wf, resamples = folds, grid = grid,metrics =metric_set(roc_auc, accuracy))# The mtry / min_n with the best cross-validated ROC AUCbest_rf <-select_best(rf_tuned, metric ="roc_auc")best_rf
tune_grid() a validé en croisé les neuf combinaisons mtry × min_n ; select_best() renvoie le gagnant. Ici un petit mtry est préféré — exactement l’idée du sous-espace aléatoire, puisqu’un mtry plus petit décorrèle davantage les arbres.
NoteLes trois boutons à connaître
mtry — combien de prédicteurs chaque coupure peut choisir. Un petit mtry décorrèle les arbres (tout l’intérêt de la random forest) ; un grand mtry les rend plus semblables (plus proche du bagging simple). Le bouton le plus important à régler.
trees — combien d’arbres. Plus nombreux n’est jamais pire pour la précision, juste plus lent ; l’erreur OOB se stabilise par un plateau, donc quelques centaines suffisent généralement (nous en utilisons 500).
min_n — le nombre minimal d’observations dans un nœud avant qu’il cesse de se couper. Un min_n plus grand = arbres plus simples, moins profonds (plus de régularisation) ; plus petit = arbres plus profonds qui ajustent plus fort.
Finaliser et évaluer sur le jeu de test
Nous finalisons le workflow avec les mtry/min_n choisis et last_fit() — ajuster sur toutes les données d’entraînement et évaluer une seule fois sur le jeu de test intact :
library(rsample)library(recipes)library(parsnip)library(workflows)library(tune)library(yardstick)library(ranger)data("PimaIndiansDiabetes2", package ="mlbench")pima <-na.omit(PimaIndiansDiabetes2)set.seed(123)split <-initial_split(pima, prop =0.80, strata = diabetes)train_data <-training(split)rec <-recipe(diabetes ~ ., data = train_data)rf_spec <-rand_forest(mtry =tune(), trees =500, min_n =tune()) |>set_engine("ranger", importance ="permutation") |>set_mode("classification")rf_wf <-workflow() |>add_recipe(rec) |>add_model(rf_spec)set.seed(123); folds <-vfold_cv(train_data, v =5, strata = diabetes)grid <-expand.grid(mtry =c(2, 3, 4), min_n =c(2, 5, 10))set.seed(123)rf_tuned <-tune_grid(rf_wf, resamples = folds, grid = grid,metrics =metric_set(roc_auc, accuracy))best_rf <-select_best(rf_tuned, metric ="roc_auc")# Fit on all the training data, score ONCE on the held-out test setfinal_fit <-finalize_workflow(rf_wf, best_rf) |>last_fit(split)collect_metrics(final_fit)
Lecture des chiffres (performance honnête, hors échantillon) :
Accuracy ≈ 0.76 — la forêt fait le bon appel diabète environ 76 % du temps sur des patients qu’elle n’a jamais vus, en accord à la fois avec l’estimation OOB et la précision de test de randomForest.
ROC AUC ≈ 0.82 — la probabilité que la forêt note un patient positif au hasard au-dessus d’un négatif au hasard. 0.5 est un tirage à pile ou face, 1.0 est parfait ; 0.82 est un classifieur solide. Comme l’AUC est indépendante du seuil, elle juge le classement du modèle plutôt qu’un seuil arbitraire de 0.5 — à lire conjointement avec la précision, surtout sur une issue déséquilibrée comme celle-ci.
La random forest fait aussi de la régression — prédire un nombre plutôt qu’une classe — et le workflow change à peine : set_mode("regression") (ou simplement une issue numérique dans randomForest), et l’erreur est mesurée par la RMSE au lieu de la précision. Nous prédisons la valeur médiane des logements (medv) sur le jeu de données Boston de MASS :
OOB R² ≈ 0.85 — sur ses échantillons out-of-bag intégrés, la forêt explique environ 85 % de la variation de la valeur des logements. (Le R² va de 0 → 1 ; plus haut est meilleur.)
Test RMSE ≈ 3.0 — sur le jeu de test mis de côté, une prédiction typique se trompe d’environ 3 000 $ (medv est en milliers de dollars). La RMSE est dans les unités propres de l’issue, donc elle est directement interprétable ; plus bas est meilleur.
Un ajustement solide sans réglage ni prétraitement — l’attrait quotidien de la random forest. La même importance par permutation/vip s’applique aussi aux forêts de régression, classant quels prédicteurs pilotent le prix.
NoteLe bagging et l’astuce du sous-espace aléatoire (optionnel)
Le bagging. À partir d’un jeu d’entraînement de n lignes, tirez B rééchantillons bootstrap (échantillonner n lignes avec remise), ajustez un arbre complet et non élagué sur chacun, et combinez. Pour la régression, moyennez les B prédictions ; pour la classification, prenez un vote majoritaire :
Un arbre profond unique a un biais faible mais une forte variance. Moyenner B arbres quasi indépendants conserve le biais mais réduit la variance d’environ un facteur B — si les arbres sont indépendants. Le hic : si la variance d’un arbre est σ² et que la corrélation par paires entre arbres est ρ, la variance de la moyenne est
Le second terme s’évanouit quand B grandit, mais le premier terme, ρσ², ne le fait pas — des arbres corrélés posent un plancher sur ce que le moyennage peut apporter.
L’astuce du sous-espace aléatoire. La random forest s’attaque directement à ce ρ. À chaque coupure, au lieu de considérer l’ensemble des p prédicteurs, elle offre à l’arbre un nouveau sous-ensemble aléatoire de taille m = mtry (souvent m ≈ √p en classification, p/3 en régression). Les prédicteurs forts ne peuvent plus dominer chaque arbre, donc les arbres utilisent différentes variables, leur corrélation par paires ρ baisse, et le plancher ρσ² baisse avec elle. C’est l’unique idée qui transforme le bagging en random forest : décorréler les arbres en cachant la plupart des prédicteurs à chaque coupure. Un mtry plus petit → ρ plus bas → plus de décorrélation (mais chaque arbre est un peu plus faible), ce qui est exactement le compromis que vous réglez.
🟢 Avec un agent IA
Vous avez un problème de classification ou de régression et voulez une base solide rapidement ? Demandez à Prova« ajuste une random forest à ces données, règle mtry par validation croisée, et montre-moi le graphique d’importance des variables » — elle répond avec du code tidymodels + ranger que vous pouvez exécuter sur vos propres données, puis vous aide à lire l’erreur OOB, le classement d’importance et la précision/AUC. The runtime is the judge.Ask Prova →
Problèmes courants
importance() renvoie la mauvaise chose ou échoue.randomForest, ranger, caret, yardstick et vip exportent tous un assistant importance/importance(), donc celui chargé en dernier masque les autres. Appelez-le avec le namespace — randomForest::importance(rf) — et pensez à ajuster avec importance = TRUE (classique) ou set_engine("ranger", importance = "permutation") (tidymodels), sinon il n’y a rien à rapporter.
L’importance est vide ou toute nulle. Vous avez oublié importance = TRUE dans randomForest(), ou importance = "permutation" (ou "impurity") dans le moteur ranger. Sans cela, la forêt ne suit pas l’importance.
MeanDecreaseGini et MeanDecreaseAccuracy divergent. L’importance de Gini est calculée sur le jeu d’entraînement et est biaisée en faveur des prédicteurs à forte cardinalité / continus ; la précision par permutation est calculée sur des données OOB mises de côté. Fiez-vous à MeanDecreaseAccuracy (permutation) quand elles entrent en conflit.
La forêt est lente. Réduisez trees (l’erreur OOB se stabilise généralement par un plateau dès quelques centaines), réduisez la grille de réglage, utilisez le moteur ranger (bien plus rapide que randomForest), ou réduisez le nombre de plis de CV. Régler une forêt sur une grande grille est la partie coûteuse — gardez la grille petite et centrée sur mtry.
Deux exécutions donnent des importances ou des taux d’erreur différents. Le rééchantillonnage bootstrap et les sous-ensembles aléatoires de variables sont aléatoires. Appelez set.seed() avant randomForest() / ranger() / vfold_cv() pour un résultat reproductible.
Questions fréquentes
NoteComment exécuter une random forest en R ?
Deux voies courantes. Classique :library(randomForest); randomForest(y ~ ., data = train, ntree = 500, importance = TRUE), puis predict() pour de nouvelles données et randomForest::importance() / varImpPlot() pour l’importance. Moderne (tidymodels) :rand_forest(mtry = tune(), trees = 500, min_n = tune()) |> set_engine("ranger") |> set_mode("classification") à l’intérieur d’un workflow(), réglé par tune_grid() avec vfold_cv(). La random forest n’a besoin d’aucune mise à l’échelle et gère automatiquement les effets non linéaires.
NoteComment construire un classifieur random forest en R ?
Définissez l’issue comme un facteur et appelez soit randomForest(class ~ ., data = train) (il détecte automatiquement la classification), soit, dans tidymodels, rand_forest(...) |> set_mode("classification") avec le moteur ranger. Lisez l’erreur OOB depuis l’objet imprimé (une estimation honnête de l’erreur de test), évaluez le jeu mis de côté avec predict(), et classez les prédicteurs avec le graphique d’importance des variables. Pour la ROC/AUC et la matrice de confusion, utilisez yardstick.
NoteComment faire de la régression random forest en R ?
Utilisez une issue numérique. Classique : randomForest(medv ~ ., data = train, ntree = 500) ou ranger(medv ~ ., data = train). tidymodels : rand_forest(...) |> set_engine("ranger") |> set_mode("regression"). L’erreur est mesurée par la RMSE (erreur typique dans les unités de l’issue) et la forêt rapporte un OOB R² gratuitement. Tout le reste — bagging, mtry, importance — est identique à la classification.
NoteComment lire un graphique d’importance des variables d’une random forest en R ?
Chaque prédicteur est classé selon combien il aide le modèle. L’importance par permutation (MeanDecreaseAccuracy, varImpPlot(rf, type = 1)) mesure la chute de précision out-of-bag quand ce prédicteur est mélangé au hasard — plus une variable est située à droite (ou en haut), plus la forêt s’appuie dessus. Elle est calculée sur des données mises de côté, donc fiez-vous-y plutôt qu’à MeanDecreaseGini (importance d’impureté), qui est calculée sur le jeu d’entraînement et peut être biaisée.
NoteQu’est-ce que le package ranger en R, et en quoi diffère-t-il de randomForest ?
ranger est une implémentation C++ rapide et économe en mémoire des random forests — souvent bien plus rapide que le package randomForest original sur les mêmes données, surtout avec beaucoup d’arbres ou de lignes. C’est le moteur par défaut de parsnip::rand_forest() dans tidymodels. Les modèles sont équivalents par l’esprit ; pour l’importance des variables, ajustez ranger avec importance = "permutation" (ou "impurity").
Testez vos connaissances
ImportantExercice : ajuster et régler une random forest sur les données Boston (régression)
En utilisant les données Boston (MASS), construisez un modèle de régression random forest à la manière tidymodels pour prédire medv. Découpez en 80/20 stratifié sur medv, réglez mtry et min_n par validation croisée à 5 plis sur la RMSE, finalisez, et rapportez la RMSE et le R² du jeu de test. Quels prédicteurs ressortent comme les plus importants ?
AstuceIndice
La forme est le workflow de classification avec deux changements : set_mode("regression") et évaluer avec metric_set(rmse, rsq) (RMSE/R² au lieu de précision/AUC). Vous aurez besoin de rsample, recipes, parsnip, workflows, tune, yardstick, et du moteur ranger. Pour l’importance, ajustez le modèle final avec set_engine("ranger", importance = "permutation") et extrayez-la avec vip::vip().
Vous obtiendrez une RMSE de test d’environ 3 (milliers de dollars) et un R² proche de 0.85 — un ajustement solide sans mise à l’échelle. Les prédicteurs les plus importants sont typiquement rm (nombre moyen de pièces) et lstat (% de population de statut inférieur) — les moteurs classiques du logement à Boston.
Vérification rapide. Le bagging moyenne de nombreux arbres et une random forest aussi. Quelle est la seule chose qu’une random forest fait que le bagging simple ne fait pas, et pourquoi cela aide-t-il ?
NoteAfficher la réponse
Une random forest ne considère qu’un sous-ensemble aléatoire de prédicteurs à chaque coupure (mtry), tandis que le bagging laisse chaque coupure voir tous les prédicteurs. Cela décorrèle les arbres : quand quelques prédicteurs forts domineraient sinon chaque arbre baggé (les rendant corrélés), la random forest force différents arbres à utiliser différentes variables. Moyenner des arbres décorrélés réduit la variance bien plus que moyenner des arbres corrélés — donc la forêt est plus précise que le bagging simple.
Conclusion
Vous avez construit une random forest de bout en bout sur les données PimaIndiansDiabetes2 : le bagging fait pousser de nombreux arbres sur des rééchantillons bootstrap et les moyenne, et la random forest ajoute l’astuce du sous-espace aléatoire — un sous-ensemble aléatoire de prédicteurs à chaque coupure — pour décorréler les arbres et resserrer la moyenne. Vous avez lu l’ erreur out-of-bag comme une validation gratuite, produit le graphique signature d’importance des variables (glucose et âge en tête), et réglé mtry/min_n par validation croisée — à la fois la voie classique randomForest() + importance()/varImpPlot() et le workflow moderne rand_forest() |> set_engine("ranger") — puis exécuté une forêt de régression sur Boston. La règle pratique : la random forest est un choix par défaut puissant et sans tracas pour la classification et la régression ; réglez mtry, lisez l’erreur OOB, et fiez-vous à l’importance par permutation.
Ensuite, poussez pour un peu plus de précision avec le gradient boosting, revisitez l’arbre unique dont elle est issue dans les arbres de décision, ou approfondissez l’explication du pourquoi un modèle prédit dans importance des variables.
Prouvez que vous savez le faire. Maîtrisez toute la série Apprentissage statistique en R — suivez votre parcours, construisez des projets et obtenez un certificat.
Cette leçon est reproductible : chaque taux d’erreur, métrique et figure a été produit par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.
Références
James, G., Witten, D., Hastie, T., & Tibshirani, R. (2014). An Introduction to Statistical Learning, with Applications in R. Springer. (Chapitre 8 — Tree-Based Methods : bagging, random forests et boosting.)
Breiman, L. (2001). Random Forests. Machine Learning, 45(1), 5–32.
Wright, M. N., & Ziegler, A. (2017). ranger: A Fast Implementation of Random Forests for High Dimensional Data in C++ and R. Journal of Statistical Software, 77(1). (Le paquet ranger.)
Kuhn, M., & Silge, J. Tidy Modeling with R. Gratuit en ligne (CC BY-NC-SA).
