Gradient boosting en R : xgboost avec tidymodels

Q: Comment faire du gradient boosting en R ?

Utilisez xgboost. La façon moderne, c’est tidymodels : boost_tree(trees = 150, tree_depth = tune(), learn_rate = tune()) |> set_engine("xgboost") |> set_mode("classification") à l’intérieur d’un workflow avec step_dummy(), réglé par tune_grid() sur des plis de validation croisée. La façon directe, c’est xgboost::xgb.train() (ou xgboost()) sur un xgb.DMatrix numérique, en fixant objective, eta, max_depth et nrounds. Les deux construisent les arbres séquentiellement, chacun corrigeant les erreurs des arbres précédents.

Q: Comment utiliser xgboost en R ?

xgboost a besoin d’une matrice numérique et d’une issue numérique. Construisez-les avec model.matrix(y ~ ., data)[, -1] et ifelse(y == "pos", 1, 0), enveloppez-les dans xgb.DMatrix(), puis appelez xgb.train() avec params = list(objective = "binary:logistic", eta = 0.05, max_depth = 3) et un nrounds. Ajoutez early_stopping_rounds avec une liste de surveillance evals pour arrêter automatiquement quand l’erreur de validation cesse de s’améliorer. Ou pilotez-le via tidymodels avec parsnip::boost_tree() |> set_engine("xgboost").

Q: Quelle est la différence entre le boosting et la random forest ?

Une random forest fait pousser de nombreux arbres profonds et indépendants en parallèle et en fait la moyenne (bagging) — robuste et difficile à surajuster. Le boosting fait pousser des arbres peu profonds séquentiellement, chacun ajusté sur les erreurs que l’ensemble commet encore, et les additionne avec un petit taux d’apprentissage. Le boosting est souvent plus précis sur données tabulaires mais exige plus de réglage et peut surajuster s’il tourne trop longtemps ; la random forest fonctionne bien clé en main. Voir random forest pour le contraste.

Q: Quels sont les principaux paramètres de réglage d’xgboost ?

Les trois qui comptent le plus sont trees (nrounds — le nombre de tours de boosting), learn_rate (eta — le rétrécissement appliqué à chaque arbre), et tree_depth (max_depth — la complexité de chaque arbre). Un taux d’apprentissage plus petit exige plus d’arbres (le compromis central). Réglez learn_rate et tree_depth par validation croisée et utilisez l’arrêt précoce pour choisir automatiquement le nombre d’arbres. D’autres paramètres (min_n, mtry/sous-échantillonnage des colonnes, loss_reduction) affinent davantage.

Q: xgboost est-il la même chose que gbm en R ?

Les deux ajustent des arbres à gradient boosting, mais xgboost (« extreme gradient boosting ») est plus rapide, ajoute une régularisation explicite et un sous-échantillonnage stochastique des lignes/colonnes, et est la référence moderne par défaut. Le plus ancien package gbm implémente les machines à gradient boosting classiques ; il fonctionne encore mais est largement supplanté par xgboost (et lightgbm). Dans tidymodels, les deux sont des moteurs pour boost_tree() — il suffit d’échanger set_engine("xgboost") pour des moteurs de style set_engine("gbm") là où ils sont disponibles.

Faire pousser les arbres en séquence, chacun corrigeant les erreurs du précédent — réglé honnêtement par validation croisée

Un guide pratique du gradient boosting en R avec xgboost. Découvrez comment le boosting construit les arbres séquentiellement — chaque nouvel arbre corrigeant les erreurs des précédents — et en quoi cela diffère des arbres parallèles et indépendants d’une random forest. Réglez les paramètres clés (nombre d’arbres, taux d’apprentissage, profondeur des arbres) par validation croisée, lisez l’importance des variables, et évaluez l’exactitude et l’AUC ROC. Traité de deux façons — le workflow tidymodels moderne avec parsnip + xgboost, et la voie directe xgboost::xgboost — sur les données PimaIndiansDiabetes2, avec une note sur la régression sur Boston.

Date de publication

25 juin 2026

Modifié

7 juillet 2026

Points clés

Le gradient boosting construit un ensemble d’arbres de décision séquentiellement : chaque nouvel arbre est ajusté sur les erreurs (résidus) que l’ensemble courant commet encore, de sorte que chaque arbre corrige ses prédécesseurs. Additionnez assez de petites corrections et vous obtenez un modèle très précis.
C’est l’opposé d’une random forest, qui fait pousser de nombreux arbres profonds et indépendants en parallèle et en fait la moyenne. Le boosting fait pousser des arbres peu profonds un par un, chacun dépendant du précédent. Le boosting l’emporte souvent en exactitude ; la random forest est plus difficile à surajuster et plus facile à régler.
xgboost (« extreme gradient boosting ») est l’implémentation la plus utilisée — rapide, régularisée, et la gagnante par défaut d’innombrables compétitions. Elle exige une matrice numérique, alors encodez les facteurs avec step_dummy() (tidymodels) ou model.matrix() (voie directe).
Les trois paramètres qui comptent : trees (combien de tours de boosting), learn_rate (le rétrécissement — l’ampleur du pas de chaque arbre), et tree_depth (la complexité de chaque arbre). Un petit taux d’apprentissage exige plus d’arbres — le compromis central. Utilisez l’arrêt précoce pour trouver automatiquement le bon nombre d’arbres.
Réglez de deux façons, même idée : le workflow tidymodels moderne (boost_tree(trees =, tree_depth = tune(), learn_rate = tune()) |> set_engine("xgboost")) validé croisé par tune_grid(), ou l’appel direct xgboost::xgboost(). Lisez l’importance des variables pour voir quels prédicteurs pilotent le modèle.
Sur les données de diabète Pima, le modèle boosté atteint environ 80 % d’exactitude — compétitif avec les autres classifieurs, glucose, mass (IMC) et age portant l’essentiel du signal.

Introduction

Vous avez un jeu de données clinique et une issue oui/non à prédire — un patient est-il positif au diabète ? — à partir d’une poignée de mesures (glucose, IMC, âge, grossesses, etc.). Un seul arbre de décision est facile à lire mais rarement assez précis ; une random forest corrige cela en faisant la moyenne de centaines d’arbres indépendants. Le gradient boosting est l’autre grande idée d’ensemble — et souvent la plus précise de toutes.

L’intuition est simple et mérite d’être retenue. Le boosting fait pousser les arbres un par un, et chaque nouvel arbre est entraîné à corriger les erreurs que le modèle a commises jusqu’ici. L’arbre 1 fait une prédiction grossière ; l’arbre 2 regarde où l’arbre 1 s’est trompé et rapièce ces erreurs ; l’arbre 3 rapièce ce qui ne va toujours pas, et ainsi de suite. Chaque arbre est rétréci par un petit taux d’apprentissage avant d’être ajouté, de sorte que le modèle s’améliore par de nombreux petits pas prudents plutôt que par quelques pas téméraires. Additionnez des centaines de ces corrections et l’ensemble devient un prédicteur très puissant.

Cette recette séquentielle et correctrice d’erreurs est toute la différence avec une random forest, qui fait pousser ses arbres en parallèle et indépendamment puis en fait la moyenne. Les arbres du boosting dépendent les uns des autres ; ceux de la forêt non. Le gain est l’exactitude — le gradient boosting domine régulièrement les tableaux de référence — mais le coût est la prudence : parce qu’il continue d’ajuster les résidus, le boosting peut surajuster si vous le laissez tourner trop longtemps ou avancer trop vite, donc le réglage compte.

Cette leçon enseigne le gradient boosting avec xgboost — extreme gradient boosting, l’implémentation rapide et régularisée devenue la référence par défaut. Nous le traitons de deux façons : le workflow tidymodels moderne (parsnip + xgboost) et la voie directe xgboost::xgboost(). Nous classons le diabète sur les données PimaIndiansDiabetes2, lisons l’importance des variables, et terminons par une note sur la régression (prédire une issue continue) sur les données immobilières Boston.

Quand y recourir

Recourez au gradient boosting quand vous voulez une exactitude prédictive maximale sur des données tabulaires et que vous êtes prêt à régler quelques paramètres pour l’obtenir — c’est généralement le modèle clé en main le plus puissant pour les données structurées. Préférez une random forest quand vous voulez un modèle solide presque sans réglage et avec peu de risque de surajustement, ou un seul arbre de décision quand il vous faut un modèle qu’un humain peut lire de haut en bas.

Les données

Nous utilisons le jeu de données PimaIndiansDiabetes2 du package mlbench : 768 femmes d’origine Pima amérindienne, avec pour but de prédire 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, fonction pedigree du diabète, et age.

Cette version comporte des valeurs manquantes (enregistrées comme NA là où une mesure est invraisemblable, p. ex. un glucose nul). Suivant l’analyse source, nous supprimons les lignes avec NA, ce qui laisse 392 enregistrements complets. Nous séparons ensuite 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), stratifié sur diabetes afin que les deux jeux conservent le même équilibre positif/négatif, avec une graine pour la reproductibilité :

library(rsample)
data("PimaIndiansDiabetes2", package = "mlbench")

# Drop rows with missing measurements (keeps the example simple and reproducible)
pima <- 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

# Class balance is preserved by the stratified split
prop.table(table(train_data$diabetes))


      neg       pos 
0.6677316 0.3322684

head(pima, 4)

  pregnant glucose pressure triceps insulin mass pedigree age diabetes
4        1      89       66      23      94 28.1    0.167  21      neg
5        0     137       40      35     168 43.1    2.288  33      pos
7        3      78       50      32      88 31.0    0.248  26      pos
9        2     197       70      45     543 30.5    0.158  53      pos

Environ 313 patients pour apprendre, 79 mis de côté pour faire le juge, et 8 prédicteurs. Environ un tiers des patients sont positifs au diabète — un problème de classification modérément déséquilibré mais exploitable, le même que celui utilisé dans toute la série classification.

Le workflow tidymodels : un classifieur boosté

Dans tidymodels, la spécification du modèle est parsnip::boost_tree() avec set_engine("xgboost"). Les arguments correspondent directement aux paramètres de réglage du boosting :

trees — le nombre de tours de boosting (combien d’arbres sont poussés et ajoutés en séquence).
learn_rate — le rétrécissement (le eta d’xgboost) : la contribution de chaque arbre est multipliée par ce facteur avant d’être ajoutée. Plus petit = plus prudent, mais exige plus d’arbres.
tree_depth — jusqu’où chaque arbre peut pousser (sa complexité). Le boosting utilise des arbres peu profonds (souvent de profondeur 1–6) ; c’est la séquence qui fournit la complexité, pas l’arbre individuel.

Une chose sur laquelle xgboost insiste : les prédicteurs doivent être numériques. Une recipe s’en charge avec step_dummy(), qui encode en one-hot tout prédicteur facteur (les prédicteurs Pima sont déjà numériques, donc c’est une opération sans effet ici, mais c’est l’habitude à garder).

Régler le modèle par validation croisée

Nous ne devinons pas les paramètres — nous laissons la validation croisée les choisir. Nous fixons trees = 150 (modeste, pour que l’exemple se rende rapidement) et réglons les deux qui comptent le plus, tree_depth et learn_rate, sur une petite grille évaluée par validation croisée à 10 plis sur le jeu d’entraînement. Nous évaluons par l’AUC ROC (une mesure sans seuil de la qualité avec laquelle le modèle classe les positifs au-dessus des négatifs) et l’exactitude :

library(rsample)
library(recipes)
library(parsnip)
library(workflows)
library(tune)
library(dials)
library(yardstick)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

# xgboost needs numeric predictors — step_dummy() one-hot-encodes any factors
rec <- recipe(diabetes ~ ., data = train_data) |>
  step_dummy(all_nominal_predictors())

# Boosted trees: fix the number of trees, tune depth and learning rate
xgb_spec <- boost_tree(
  trees      = 150,
  tree_depth = tune(),
  learn_rate = tune()
) |>
  set_engine("xgboost") |>
  set_mode("classification")

xgb_wf <- workflow() |>
  add_recipe(rec) |>
  add_model(xgb_spec)

# A small, deliberate grid: 3 depths x 3 learning rates = 9 candidates
xgb_grid <- expand.grid(
  tree_depth = c(2, 3, 4),
  learn_rate = c(0.01, 0.05, 0.1)
)

set.seed(123)
folds <- vfold_cv(train_data, v = 10, strata = diabetes)

set.seed(123)
xgb_tuned <- tune_grid(
  xgb_wf, resamples = folds, grid = xgb_grid,
  metrics = metric_set(roc_auc, accuracy)
)

# The (depth, learn_rate) combination with the best cross-validated ROC AUC
best_params <- select_best(xgb_tuned, metric = "roc_auc")
best_params

# A tibble: 1 × 3
  tree_depth learn_rate .config        
       <dbl>      <dbl> <chr>          
1          2       0.05 pre0_mod2_post0

tune_grid() a validé croisé chaque combinaison profondeur × taux d’apprentissage ; select_best() renvoie celle ayant la meilleure performance en validation croisée. Une profondeur modeste associée à un taux d’apprentissage faible à modéré est typique — des arbres peu profonds avançant à pas prudents, exactement la recette du boosting.

La surface de réglage : comment les paramètres interagissent

Le graphique le plus instructif est l’AUC validée croisée en fonction du taux d’apprentissage, une courbe par profondeur d’arbre. Il rend visible en une seule image le compromis central du boosting :

library(ggplot2)

# Collect the CV AUC for every (depth, learn_rate) candidate
xgb_metrics <- collect_metrics(xgb_tuned)
auc_grid    <- subset(xgb_metrics, .metric == "roc_auc")
auc_grid$tree_depth <- factor(auc_grid$tree_depth)

ggplot(auc_grid, aes(x = learn_rate, y = mean, colour = tree_depth)) +
  geom_line(linewidth = 1) +
  geom_point(size = 2) +
  scale_x_log10() +
  scale_colour_manual(values = c("#3a86d4", "#8338ec", "#fb5607")) +
  labs(
    x = "Learning rate (log scale)",
    y = "Cross-validated ROC AUC",
    colour = "Tree depth",
    title = "Tuning xgboost: learning rate vs tree depth",
    subtitle = "At a fixed 150 trees, a learning rate that is too small under-trains the model"
  ) +
  theme_minimal()

Cross-validated ROC AUC plotted against the learning rate for an xgboost classifier on the Pima diabetes data, with one coloured line per tree depth. A very small learning rate underperforms at a fixed number of trees, AUC rises as the learning rate increases, and the three depths track closely.

Lisez-le de gauche à droite. À un taux d’apprentissage très petit (extrême gauche), chaque arbre ne fait qu’effleurer le modèle, donc avec seulement 150 arbres l’ensemble n’a pas fini d’apprendre — l’AUC est plus basse. À mesure que le taux d’apprentissage croît, chaque pas est plus grand et le budget fixe d’arbres mène le modèle plus loin, donc l’AUC monte. Les trois courbes de profondeur se suivent de près ici, ce qui vous dit que la profondeur compte moins que l’équilibre taux d’apprentissage × arbres sur ces données. C’est le paramètre qui définit le boosting : un learn_rate plus petit est plus sûr contre le surajustement mais exige plus d’arbres pour atteindre le même endroit — vous échangez l’un contre l’autre.

Pourquoi taux d’apprentissage et arbres s’échangent

Chaque tour de boosting ajoute learn_rate × (nouvel arbre) au modèle. Divisez le taux d’apprentissage par deux et chaque pas est deux fois plus petit, donc il vous faut environ deux fois plus d’arbres pour parcourir la même distance. Un taux d’apprentissage minuscule (disons 0.01) avec beaucoup d’arbres généralise généralement le mieux, mais coûte du calcul. Un taux plus grand entraîne plus vite mais risque de dépasser et de surajuster. L’arrêt précoce (à suivre) laisse les données choisir le nombre d’arbres pour vous, de sorte que vous pouvez fixer un petit taux d’apprentissage sans vous soucier de deviner trees.

Finaliser et évaluer sur le jeu de test

Nous prenons les meilleurs paramètres, finalisons le workflow, et appelons 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(dials)
library(yardstick)
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) |> step_dummy(all_nominal_predictors())
xgb_spec <- boost_tree(trees = 150, tree_depth = tune(), learn_rate = tune()) |>
  set_engine("xgboost") |> set_mode("classification")
xgb_wf   <- workflow() |> add_recipe(rec) |> add_model(xgb_spec)

xgb_grid <- expand.grid(tree_depth = c(2, 3, 4), learn_rate = c(0.01, 0.05, 0.1))
set.seed(123); folds <- vfold_cv(train_data, v = 10, strata = diabetes)
set.seed(123)
xgb_tuned <- tune_grid(xgb_wf, resamples = folds, grid = xgb_grid,
                       metrics = metric_set(roc_auc, accuracy))
best_params <- select_best(xgb_tuned, metric = "roc_auc")

# Finalize with the chosen knobs, fit on train, score ONCE on test
final_fit <- finalize_workflow(xgb_wf, best_params) |> last_fit(split)
collect_metrics(final_fit)

# A tibble: 3 × 4
  .metric     .estimator .estimate .config        
  <chr>       <chr>          <dbl> <chr>          
1 accuracy    binary         0.797 pre0_mod0_post0
2 roc_auc     binary         0.819 pre0_mod0_post0
3 brier_class binary         0.158 pre0_mod0_post0

Lisez les chiffres (la performance honnête, hors échantillon, du modèle) :

Exactitude ≈ 0.80 — le modèle boosté donne le bon verdict sur le diabète environ 80 % du temps sur des patients qu’il n’a jamais vus pendant l’ajustement — compétitif avec (et légèrement devant) les autres classifieurs de la série. Lisez-la conjointement à l’AUC, car l’exactitude peut flatter un modèle sur une issue déséquilibrée.
AUC ROC ≈ 0.82 — la probabilité que le modèle attribue un score plus élevé à un positif aléatoire qu’à un négatif aléatoire. 0.5 est un tirage à pile ou face, 1.0 est parfait ; 0.82 est un bon classifieur. Parce que l’AUC est sans seuil, elle juge le classement du modèle, pas une coupure arbitraire à 0.5. Pour la matrice de confusion complète et la courbe ROC, voir évaluation des modèles de classification.

Importance des variables : sur quoi le modèle s’appuie

Un ensemble boosté de 150 arbres n’est pas quelque chose que vous lisez arbre par arbre — mais vous pouvez demander quels prédicteurs il a le plus exploités. L’importance des variables agrège, sur tous les arbres, combien chaque prédicteur a amélioré les divisions où il est apparu. Le package vip la lit directement depuis le modèle xgboost ajusté :

library(vip)

# Pull the fitted xgboost model out of the finalized workflow and rank predictors
final_model <- extract_fit_parsnip(final_fit$.workflow[[1]])

vip(final_model, num_features = 8, geom = "col",
    aesthetics = list(fill = "#3a86d4")) +
  labs(title = "Which predictors drive the boosted model?",
       subtitle = "xgboost gain importance, Pima diabetes classifier") +
  theme_minimal()

Horizontal bar chart of xgboost variable importance on the Pima diabetes data: glucose has by far the longest bar, followed by body mass index, age and the diabetes pedigree function, with pregnancies, blood pressure, insulin and triceps shorter — the predictors the boosted trees split on most.

Le classement correspond à l’histoire clinique : glucose domine — sans surprise pour un modèle de diabète — suivi de mass (IMC), age et la fonction pedigree du diabète. Les prédicteurs restants contribuent moins. C’est le même type d’éclairage qu’offre une random forest, et un contrôle de bon sens utile montrant que le modèle a appris quelque chose de sensé plutôt que d’ajuster du bruit. Pour l’importance agnostique au modèle et basée sur les permutations, qui fonctionne sur n’importe quel modèle, voir importance des variables.

La voie directe : xgboost::xgboost

Beaucoup d’utilisateurs de R rencontrent le boosting via xgboost directement, sans tidymodels. Le package travaille sur une matrice numérique et une issue numérique, donc vous encodez vous-même les prédicteurs et l’étiquette 0/1. Cette voie vaut la peine d’être connue car elle expose les propres arguments d’xgboost — nrounds (= trees), eta (= learn_rate), max_depth (= tree_depth) — et l’arrêt précoce intégré :

library(xgboost)
library(rsample)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)
test_data  <- testing(split)

# xgboost wants a numeric predictor matrix + a 0/1 outcome
x_train <- model.matrix(diabetes ~ ., train_data)[, -1]
y_train <- ifelse(train_data$diabetes == "pos", 1, 0)
x_test  <- model.matrix(diabetes ~ ., test_data)[, -1]
y_test  <- ifelse(test_data$diabetes == "pos", 1, 0)

dtrain <- xgb.DMatrix(data = x_train, label = y_train)
dtest  <- xgb.DMatrix(data = x_test,  label = y_test)

# Train with a small learning rate; early stopping picks the number of trees.
# `evals` is a named list of xgb.DMatrix to watch; early stopping monitors the last one.
set.seed(123)
xgb_model <- xgb.train(
  params    = list(objective = "binary:logistic", eval_metric = "error",
                   eta = 0.05, max_depth = 3),
  data      = dtrain,
  nrounds   = 300,
  evals     = list(train = dtrain, test = dtest),
  early_stopping_rounds = 20,
  verbose   = 0
)

# How many trees early stopping actually kept (the best round)
best_nrounds <- as.integer(xgb.attr(xgb_model, "best_iteration"))

# Accuracy on the held-out test set at the 0.5 probability cutoff
prob <- predict(xgb_model, dtest)
pred <- ifelse(prob > 0.5, 1, 0)
c(best_nrounds = best_nrounds,
  accuracy     = mean(pred == y_test))

best_nrounds     accuracy 
   12.000000     0.835443

Trois choses à remarquer. D’abord, les noms d’arguments sont ceux d’xgboost (eta, max_depth, nrounds) — les mêmes paramètres que parsnip a renommés learn_rate, tree_depth, trees. Ensuite, l’arrêt précoce : nous passons une liste nommée de matrices à surveiller via evals (la dernière, test, est celle que l’arrêt précoce surveille), demandons jusqu’à 300 tours, et early_stopping_rounds = 20 stoppe l’entraînement dès que l’erreur de test cesse de s’améliorer pendant 20 tours consécutifs. Le meilleur tour est stocké sur le modèle — lisez-le avec xgb.attr(xgb_model, "best_iteration"), qui rapporte ici les best_nrounds arbres que le modèle a effectivement conservés (bien moins que le plafond de 300). C’est ainsi que vous laissez les données choisir trees au lieu de deviner. Enfin, l’exactitude tombe dans la même fourchette de 0.7 élevé / 0.8 bas que le modèle tidymodels — le même algorithme, une porte d’entrée différente.

Les mathématiques derrière le boosting (facultatif)

Le gradient boosting construit le modèle comme une somme d’arbres, ajoutés un par un. On part d’une prédiction constante $F_0$ (p. ex. le log-odds global). À l’étape $m$, le modèle courant est $F_{m-1}$. On calcule les résidus — le gradient de la perte par rapport aux prédictions courantes :

\[ r_{im} = -\left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]_{F = F_{m-1}} , \]

puis on ajuste un petit arbre de décision $h_m$ sur ces résidus et on ajoute une version rétrécie de celui-ci au modèle :

\[ F_m = F_{m-1} + \nu \, h_m , \]

où $\nu$ est le taux d’apprentissage (entre 0 et 1). Chaque arbre corrige ce sur quoi l’ensemble se trompe encore ; le taux d’apprentissage $\nu$ garde chaque correction petite afin que le modèle s’améliore par de nombreux pas prudents. Après $B$ tours, la prédiction est

\[ F_B = F_0 + \nu \sum_{m=1}^{B} h_m . \]

Pour une perte d’erreur quadratique, le résidu $r_{im}$ est simplement le résidu ordinaire $y_i - F_{m-1}(x_i)$ — littéralement « ajustez l’arbre suivant sur ce qui reste ». Pour la classification, la perte est la déviance logistique, et les résidus sont le gradient de cette perte, mais la recette est identique. xgboost (« extreme » gradient boosting) ajoute deux raffinements : un terme de régularisation explicite sur la complexité des arbres, et un sous-échantillonnage stochastique des lignes et des colonnes à chaque tour (comme une random forest) pour la vitesse et la robustesse. Plus $\nu$ est petit, plus $B$ doit être grand — le compromis taux d’apprentissage × arbres, en une seule équation.

Régression : booster une issue continue

Le boosting gère la régression (une issue continue) avec la même machinerie — seuls le mode et la métrique changent. Nous passons aux données immobilières Boston de MASS et prédisons la valeur médiane des logements medv. Le changement côté tidymodels tient en une ligne : set_mode("regression") au lieu de "classification", et l’évaluation par RMSE (la taille moyenne de l’erreur de prédiction, dans les unités de l’issue) au lieu de l’AUC :

library(rsample)
library(recipes)
library(parsnip)
library(workflows)
library(tune)
library(yardstick)
data("Boston", package = "MASS")

set.seed(123)
bsplit     <- initial_split(Boston, prop = 0.80)
btrain     <- training(bsplit)

# Same workflow, regression mode; xgboost predictors are already numeric here
brec  <- recipe(medv ~ ., data = btrain)
bspec <- boost_tree(trees = 150, tree_depth = tune(), learn_rate = tune()) |>
  set_engine("xgboost") |> set_mode("regression")
bwf   <- workflow() |> add_recipe(brec) |> add_model(bspec)

bgrid <- expand.grid(tree_depth = c(2, 3, 4), learn_rate = c(0.05, 0.1, 0.3))
set.seed(123); bfolds <- vfold_cv(btrain, v = 10)
set.seed(123)
btuned <- tune_grid(bwf, resamples = bfolds, grid = bgrid,
                    metrics = metric_set(rmse, rsq))
bbest  <- select_best(btuned, metric = "rmse")

# Finalize and score once on the held-out test set
bfinal <- finalize_workflow(bwf, bbest) |> last_fit(bsplit)
collect_metrics(bfinal)

# A tibble: 2 × 4
  .metric .estimator .estimate .config        
  <chr>   <chr>          <dbl> <chr>          
1 rmse    standard       3.81  pre0_mod0_post0
2 rsq     standard       0.833 pre0_mod0_post0

Lisez-le : le RMSE ≈ 3.8 est l’erreur de prédiction typique en milliers de dollars (les unités de medv) — les prédictions de valeur médiane du modèle sont décalées d’environ $3,800 en moyenne, ce qui est solide pour ce jeu de données. Le R² (rsq) ≈ 0.83 est la part de la variance de la valeur des logements que le modèle explique ; au-dessus de 0.8 est excellent. Tout le reste — la séparation, la recipe, le réglage, le last_fit() — est exactement le workflow de classification avec set_mode("regression"). C’est tout l’intérêt de la colonne vertébrale tidymodels : un seul workflow, deux types d’issue.

Boosting versus random forest : quel ensemble ?

Les deux construisent une forêt d’arbres, mais la manière de la construire fait toute la différence — et elle dicte quand recourir à chacun :

	Random forest	Gradient boosting (xgboost)
Comment les arbres poussent	En parallèle, indépendamment	Séquentiellement, chacun corrigeant le précédent
Profondeur des arbres	Arbres profonds (biais faible, variance élevée)	Arbres peu profonds (la séquence ajoute de la profondeur)
Comment ils se combinent	Moyenne des arbres (bagging)	Addition d’arbres rétrécis (boosting)
Risque de surajustement	Faible — plus d’arbres nuit rarement	Plus élevé — trop d’arbres peut surajuster
Effort de réglage	Faible (fonctionne souvent clé en main)	Plus (taux d’apprentissage × arbres, profondeur)
Exactitude typique	Très bonne	Souvent la meilleure sur données tabulaires

La règle pratique : essayez d’abord une random forest pour une référence solide presque sans réglage ; recourez au gradient boosting quand vous voulez gagner les derniers points d’exactitude et que vous êtes prêt à régler. Parce que le boosting continue d’ajuster les résidus, il peut surajuster — donc réglez toujours le taux d’apprentissage, utilisez l’arrêt précoce pour le nombre d’arbres, et jugez sur un jeu de test mis de côté. Voir random forest pour le versant parallèle, moyenne-des-arbres de l’histoire.

🟢 Avec un agent IA

Vous avez un jeu de données tabulaire et voulez le modèle le plus précis que vous puissiez régler ? Demandez à Prova « ajuste un modèle xgboost sur ces données, règle le taux d’apprentissage et la profondeur des arbres par validation croisée, et montre-moi l’importance des variables » — elle répond avec du code tidymodels + xgboost que vous pouvez exécuter sur vos propres données, puis vous aide à lire la surface de réglage, à mettre en place l’arrêt précoce, et à le comparer à une random forest. The runtime is the judge. Ask Prova →

Problèmes courants

xgboost échoue sur un prédicteur non numérique. xgboost n’accepte qu’une matrice numérique. Dans une recipe tidymodels, ajoutez step_dummy(all_nominal_predictors()) pour encoder en one-hot les facteurs ; dans la voie directe, construisez la matrice avec model.matrix(y ~ ., data)[, -1]. Une colonne caractère ou facteur oubliée est la cause la plus fréquente d’une erreur xgboost obscure.
Le modèle surajuste — excellent à l’entraînement, médiocre au test. C’est le mode d’échec emblématique du boosting. Baissez le learn_rate, plafonnez la tree_depth (arbres peu profonds), et utilisez l’arrêt précoce (early_stopping_rounds) pour que le nombre d’arbres soit choisi par l’erreur de validation plutôt que deviné.
Vous avez mis un taux d’apprentissage minuscule et l’exactitude a chuté. Un petit learn_rate exige plus d’arbres pour atteindre le même endroit. Si vous divisez le taux par deux, doublez à peu près trees — ou utilisez l’arrêt précoce et laissez les données décider.
Deux exécutions donnent des résultats légèrement différents. xgboost sous-échantillonne les lignes et les colonnes, et les plis de validation croisée sont aléatoires. Appelez set.seed() avant vfold_cv() et avant l’entraînement pour un résultat reproductible.
L’issue doit être un facteur pour la classification. Le set_mode("classification") de parsnip attend une issue facteur ; dans la voie directe xgboost, codez l’étiquette en 0/1 avec ifelse() et utilisez objective = "binary:logistic".

Questions fréquentes

Comment faire du gradient boosting en R ?

Utilisez xgboost. La façon moderne, c’est tidymodels : boost_tree(trees = 150, tree_depth = tune(), learn_rate = tune()) |> set_engine("xgboost") |> set_mode("classification") à l’intérieur d’un workflow avec step_dummy(), réglé par tune_grid() sur des plis de validation croisée. La façon directe, c’est xgboost::xgb.train() (ou xgboost()) sur un xgb.DMatrix numérique, en fixant objective, eta, max_depth et nrounds. Les deux construisent les arbres séquentiellement, chacun corrigeant les erreurs des arbres précédents.

Comment utiliser xgboost en R ?

xgboost a besoin d’une matrice numérique et d’une issue numérique. Construisez-les avec model.matrix(y ~ ., data)[, -1] et ifelse(y == "pos", 1, 0), enveloppez-les dans xgb.DMatrix(), puis appelez xgb.train() avec params = list(objective = "binary:logistic", eta = 0.05, max_depth = 3) et un nrounds. Ajoutez early_stopping_rounds avec une liste de surveillance evals pour arrêter automatiquement quand l’erreur de validation cesse de s’améliorer. Ou pilotez-le via tidymodels avec parsnip::boost_tree() |> set_engine("xgboost").

Quelle est la différence entre le boosting et la random forest ?

Une random forest fait pousser de nombreux arbres profonds et indépendants en parallèle et en fait la moyenne (bagging) — robuste et difficile à surajuster. Le boosting fait pousser des arbres peu profonds séquentiellement, chacun ajusté sur les erreurs que l’ensemble commet encore, et les additionne avec un petit taux d’apprentissage. Le boosting est souvent plus précis sur données tabulaires mais exige plus de réglage et peut surajuster s’il tourne trop longtemps ; la random forest fonctionne bien clé en main. Voir random forest pour le contraste.

Quels sont les principaux paramètres de réglage d’xgboost ?

Les trois qui comptent le plus sont trees (nrounds — le nombre de tours de boosting), learn_rate (eta — le rétrécissement appliqué à chaque arbre), et tree_depth (max_depth — la complexité de chaque arbre). Un taux d’apprentissage plus petit exige plus d’arbres (le compromis central). Réglez learn_rate et tree_depth par validation croisée et utilisez l’arrêt précoce pour choisir automatiquement le nombre d’arbres. D’autres paramètres (min_n, mtry/sous-échantillonnage des colonnes, loss_reduction) affinent davantage.

xgboost est-il la même chose que gbm en R ?

Les deux ajustent des arbres à gradient boosting, mais xgboost (« extreme gradient boosting ») est plus rapide, ajoute une régularisation explicite et un sous-échantillonnage stochastique des lignes/colonnes, et est la référence moderne par défaut. Le plus ancien package gbm implémente les machines à gradient boosting classiques ; il fonctionne encore mais est largement supplanté par xgboost (et lightgbm). Dans tidymodels, les deux sont des moteurs pour boost_tree() — il suffit d’échanger set_engine("xgboost") pour des moteurs de style set_engine("gbm") là où ils sont disponibles.

Testez vos connaissances

Exercice : baisser le taux d’apprentissage et ajouter l’arrêt précoce

À l’aide des données PimaIndiansDiabetes2 (mlbench, avec na.omit()), ajustez un classifieur xgboost par la voie directe : séparez 80/20 stratifié sur diabetes, construisez les matrices numériques, et entraînez avec un petit taux d’apprentissage (eta = 0.01) et jusqu’à 500 tours, en utilisant early_stopping_rounds = 30 avec une liste de surveillance evals de test. Combien d’arbres l’arrêt précoce conserve-t-il, et comment l’exactitude de test se compare-t-elle à celle du modèle eta = 0.05 de la leçon ?

Indice

Réutilisez le code de la voie directe, changez eta en 0.01, montez nrounds à 500, et fixez early_stopping_rounds = 30. Le nombre d’arbres conservé est xgb.attr(m, "best_iteration"). Un taux d’apprentissage plus petit exige plus d’arbres, donc attendez-vous à un compte conservé plus grand qu’à eta = 0.05.

Solution

library(xgboost); library(rsample)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split); test_data <- testing(split)

x_train <- model.matrix(diabetes ~ ., train_data)[, -1]
y_train <- ifelse(train_data$diabetes == "pos", 1, 0)
x_test  <- model.matrix(diabetes ~ ., test_data)[, -1]
y_test  <- ifelse(test_data$diabetes == "pos", 1, 0)
dtrain  <- xgb.DMatrix(x_train, label = y_train)
dtest   <- xgb.DMatrix(x_test,  label = y_test)

set.seed(123)
m <- xgb.train(
  params = list(objective = "binary:logistic", eval_metric = "error",
                eta = 0.01, max_depth = 3),
  data = dtrain, nrounds = 500,
  evals = list(test = dtest), early_stopping_rounds = 30, verbose = 0)

best_nrounds <- as.integer(xgb.attr(m, "best_iteration"))
pred <- ifelse(predict(m, dtest) > 0.5, 1, 0)
c(best_nrounds = best_nrounds, accuracy = mean(pred == y_test))

L’arrêt précoce conserve plus d’arbres que l’exécution eta = 0.05 (le pas plus petit a besoin de plus de tours pour atteindre le même endroit), et l’exactitude de test tombe dans le même voisinage (0.7 élevé à 0.8 bas). La leçon : un petit taux d’apprentissage assorti d’un arrêt précoce est une valeur par défaut robuste — vous n’avez pas à deviner le nombre d’arbres.

Vérification rapide. Vous entraînez un modèle xgboost et remarquez qu’il atteint 0.99 d’exactitude sur le jeu d’entraînement mais seulement 0.70 sur le jeu de test. Quels deux paramètres viseriez-vous en premier, et dans quelle direction ?

Afficher la réponse

Cet écart est du surajustement — les arbres boostés ont mémorisé les données d’entraînement. Visez le learn_rate (baissez-le, pour que chaque arbre fasse un pas plus petit et plus prudent) et le nombre de trees (réduisez-le, ou mieux, laissez l’arrêt précoce le choisir à partir de l’erreur de validation). Plafonner la tree_depth (des arbres moins profonds) aide aussi. L’exactitude du boosting vient de nombreuses petites corrections ; le surajustement vient de corrections trop nombreuses ou trop grandes.

Conclusion

Vous avez construit le gradient boosting de bout en bout sur les données PimaIndiansDiabetes2 avec xgboost. L’idée centrale, ce sont des arbres séquentiels et correcteurs d’erreurs : chaque nouvel arbre est ajusté sur les résidus que l’ensemble commet encore, rétréci par le taux d’apprentissage, et ajouté — l’opposé des arbres parallèles, indépendants et moyennés d’une random forest. Vous avez réglé les paramètres qui comptent (tree_depth et learn_rate, avec trees et l’arrêt précoce) honnêtement par validation croisée — à la fois la façon moderne (boost_tree(... ) |> set_engine("xgboost") + tune_grid()) et la voie directe xgboost::xgb.train() — lu l’importance des variables, évalué l’exactitude et l’AUC ROC, et vu le même workflow faire de la régression sur les données Boston avec une seule ligne changée. La règle pratique : encodez les prédicteurs en numérique, fixez un petit taux d’apprentissage, laissez l’arrêt précoce choisir les arbres, et jugez sur des données mises de côté.

Ensuite, mettez cela en contraste avec l’ensemble parallèle dans random forest, ou lisez la matrice de confusion complète et la courbe ROC dans évaluation des modèles de classification.

Leçons connexes

Random forest — l’ensemble parallèle, moyenne-des-arbres que cette leçon met en contraste ; essayez-le d’abord pour une référence solide. · Arbres de décision — le seul arbre CART à partir duquel les deux ensembles sont construits. · Importance des variables — importance agnostique au modèle et par permutation pour n’importe quel modèle, au-delà du gain intégré d’xgboost. · Évaluation des modèles de classification — matrice de confusion, ROC et AUC en profondeur. · Construire des modèles avec tidymodels — le workflow séparation → recipe → réglage → finalisation que cette leçon réutilise.
Pour aller plus loin : random forest · arbres de décision · importance des variables · évaluation des modèles de classification · construire des modèles avec tidymodels. · Apprentissage statistique — la série complète. · Machine Learning — le pilier.

Vous préférez un livre ? Machine Learning Essentials est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.

Obtenir le livre (PDF) →Les leçons restent gratuites en ligne.

Cette page vous a-t-elle été utile ?

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.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Prêt à passer à la vitesse supérieure ?

Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

Note

Cette leçon est reproductible : chaque métrique, chaque classement et chaque 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 : boosting.)
Chen, T., & Guestrin, C. (2016). XGBoost: A Scalable Tree Boosting System. Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. (Le package xgboost.)
Friedman, J. H. (2001). Greedy Function Approximation: A Gradient Boosting Machine. Annals of Statistics, 29(5).
Kuhn, M., & Silge, J. Tidy Modeling with R. Gratuit en ligne (CC BY-NC-SA).

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Gradient boosting en R : xgboost avec tidymodels},
  date = {2026-06-25},
  url = {https://www.datanovia.com/learn/machine-learning/statistical-learning/gradient-boosting},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Gradient boosting en R : xgboost avec tidymodels.” 2026. June 25. https://www.datanovia.com/learn/machine-learning/statistical-learning/gradient-boosting.