0Pricing
R Academy · Leçon

Boosting de gradient avec xgboost

Configurez les paramètres de xgboost, l’arrêt anticipé et les calendriers de taux d’apprentissage.

Boosting de gradient avec xgboost est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Qu’est-ce que le gradient boosting ?

Le gradient boosting construit un ensemble de manière séquentielle. Chaque nouvel arbre corrige les erreurs résiduelles de l’ensemble précédent en s’ajustant au gradient négatif de la fonction de perte. Contrairement aux forêts aléatoires (arbres construits en parallèle), le boosting construit les arbres un par un, chacun apprenant des erreurs du précédent.

library(xgboost)

# XGBoost expects data in a special matrix format
# We'll build a simple example step by step
cat('XGBoost version:', packageVersion('xgboost'))

# Key concept: each tree reduces the ensemble error
# Final prediction = sum of all tree predictions

xgb.DMatrix()

xgb.DMatrix(data, label) est le format de données interne optimisé de XGBoost. Il stocke ensemble la matrice des caractéristiques et le vecteur d’étiquettes, ce qui permet des calculs rapides et économes en mémoire. Convertissez toujours vos données en DMatrix avant l’entraînement.

library(xgboost)
library(MASS)

X_train <- as.matrix(Boston[1:400, -14])  # features
y_train <- Boston[1:400, 14]              # medv (target)

X_test  <- as.matrix(Boston[401:506, -14])
y_test  <- Boston[401:506, 14]

dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

cat('DMatrix rows:', nrow(dtrain))

xgboost() — Entraînement de base

xgboost(data, nrounds, eta, max_depth, objective) entraîne le modèle. Paramètres principaux : eta (taux d’apprentissage, plus petit = plus robuste, mais plus lent), max_depth (profondeur des arbres, contrôle la complexité du modèle) et nrounds (nombre d’arbres).

params <- list(
  objective  = 'reg:squarederror',
  eta        = 0.1,     # learning rate
  max_depth  = 6,       # tree depth
  subsample  = 0.8,     # row subsampling
  colsample_bytree = 0.8  # column subsampling
)

set.seed(42)
model <- xgboost(
  data    = dtrain,
  params  = params,
  nrounds = 100,
  verbose = 0
)

cat('Model trained with', model$niter, 'rounds')

Watchlist — Surveiller la perte de validation

L’argument watchlist accepte une liste nommée d’objets DMatrix. XGBoost évalue et affiche la perte sur chaque jeu de données indiqué après chaque tour de boosting. Utilisez-le pour suivre la perte d’entraînement par rapport à la perte de validation et détecter le début d’un surajustement.

watchlist <- list(train = dtrain, eval = dtest)

model <- xgb.train(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  watchlist = watchlist,
  verbose   = 1
)

# The log shows train-rmse and eval-rmse per round
# Watch for eval-rmse increasing (overfitting signal)

early_stopping_rounds

early_stopping_rounds = 20 arrête l’entraînement si la mesure de validation ne s’est pas améliorée pendant 20 tours consécutifs. Cela trouve automatiquement le nombre optimal d’arbres et évite à la fois le sous-ajustement et le surajustement sans réglage manuel exhaustif.

model <- xgb.train(
  params              = params,
  data                = dtrain,
  nrounds             = 1000,      # max rounds
  watchlist           = list(train = dtrain, eval = dtest),
  early_stopping_rounds = 20,      # stop if no improvement
  print_every_n       = 50,
  verbose             = 1
)

cat('Best iteration:', model$best_iteration)
cat('Best eval RMSE:', model$best_score)

Classification binaire

Pour une classification binaire, utilisez objective = 'binary:logistic', qui produit des probabilités prédites. L’étiquette doit être une valeur numérique 0/1. Évaluez le modèle avec l’AUC ou la log-perte au moyen du paramètre eval_metric.

# Binary classification example
library(MASS)
Pima <- MASS::Pima.tr

X_cl <- as.matrix(Pima[, -8])
y_cl <- as.numeric(Pima$type) - 1  # factor to 0/1

dt_cl <- xgb.DMatrix(data = X_cl, label = y_cl)

mod_cl <- xgboost(
  data       = dt_cl,
  objective  = 'binary:logistic',
  eval_metric = 'auc',
  eta        = 0.05,
  max_depth  = 4,
  nrounds    = 100,
  verbose    = 0
)

Prédictions

predict(model, dtest) renvoie les valeurs prédites brutes — des probabilités pour la classification ou des prédictions à valeurs réelles pour la régression. Appliquez un seuil de 0,5 pour convertir les probabilités en étiquettes de classes dans les tâches de classification.

# Regression predictions
reg_preds <- predict(model, dtest)
rmse <- sqrt(mean((reg_preds - y_test)^2))
cat('Test RMSE:', round(rmse, 3))

# Classification predictions
prob_preds  <- predict(mod_cl, dt_cl)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
accuracy <- mean(class_preds == y_cl)
cat('Training Accuracy:', round(accuracy, 3))

xgb.cv() — Validation croisée

xgb.cv(params, data, nrounds, nfold) exécute une validation croisée en k plis dans XGBoost. Cette méthode est plus rapide que l’utilisation de rsample, car XGBoost gère les plis en interne. La sortie affiche la moyenne et l’écart-type SD de la mesure à chaque tour.

cv_result <- xgb.cv(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  nfold     = 5,
  early_stopping_rounds = 15,
  print_every_n = 20,
  verbose   = 1
)

# Best nrounds from CV
best_nrounds <- cv_result$best_iteration
cat('Optimal nrounds:', best_nrounds)

# CV RMSE at best iteration
cat('CV RMSE:', cv_result$evaluation_log[best_nrounds, 'test_rmse_mean'][[1]])

Hyperparamètres principaux

Les hyperparamètres XGBoost les plus déterminants :

  • eta : taux d’apprentissage (0,01 à 0,3). Une valeur plus faible nécessite davantage d’arbres et offre une meilleure robustesse.
  • max_depth : profondeur des arbres (3 à 10). Une valeur plus élevée produit un modèle plus complexe, qui se surajuste plus rapidement.
  • subsample : fraction de lignes par arbre (0,5 à 1,0). Réduit le surajustement.
  • colsample_bytree : fraction de caractéristiques par arbre (0,5 à 1,0).
  • lambda : régularisation L2 des poids des feuilles.
  • alpha : régularisation L1 des poids des feuilles.
params_tuned <- list(
  objective         = 'reg:squarederror',
  eta               = 0.05,
  max_depth         = 5,
  subsample         = 0.75,
  colsample_bytree  = 0.75,
  lambda            = 1.0,    # L2 regularization
  alpha             = 0.1,    # L1 regularization
  min_child_weight  = 3       # min samples in leaf
)

model_tuned <- xgboost(
  data = dtrain, params = params_tuned,
  nrounds = best_nrounds, verbose = 0
)

Enregistrer et charger les modèles

Les modèles XGBoost peuvent être enregistrés sur le disque au format binaire avec xgb.save(model, 'model.xgb'), puis rechargés avec xgb.load('model.xgb'). Il s’agit du format recommandé pour le déploiement en production, car il garantit une reproductibilité exacte au niveau des bits.

# Save model
xgb.save(model, '/tmp/xgb_boston.xgb')

# Reload and predict
loaded_model <- xgb.load('/tmp/xgb_boston.xgb')
new_preds <- predict(loaded_model, dtest)

# Verify predictions match
all.equal(reg_preds, new_preds)  # TRUE

Classification multiclasse

Pour les problèmes multiclasse, utilisez objective = 'multi:softprob' et définissez num_class sur le nombre de classes. Les étiquettes doivent être des entiers indexés à partir de 0. La sortie est une matrice de probabilités pour chaque classe.

X_mc <- as.matrix(iris[, -5])
y_mc <- as.integer(iris$Species) - 1  # 0, 1, 2

dt_mc <- xgb.DMatrix(data = X_mc, label = y_mc)

params_mc <- list(
  objective  = 'multi:softprob',
  num_class  = 3,
  eta        = 0.1,
  max_depth  = 3
)

mod_mc <- xgboost(
  data = dt_mc, params = params_mc,
  nrounds = 50, verbose = 0
)

# Predictions: matrix of shape (n, num_class)
prob_matrix <- matrix(predict(mod_mc, dt_mc), ncol = 3, byrow = TRUE)
head(prob_matrix)

Vérification rapide

Quel est l’objectif de définir early_stopping_rounds = 20 dans xgb.train() ?

Récapitulatif de XGBoost

Points clés du gradient boosting avec XGBoost :

  • xgb.DMatrix(data, label) crée le format de données optimisé de XGBoost.
  • Paramètres principaux : eta (taux d’apprentissage), max_depth, subsample et colsample_bytree.
  • watchlist surveille la perte d’entraînement et de validation à chaque tour.
  • early_stopping_rounds trouve automatiquement le nombre optimal d’arbres.
  • xgb.cv() exécute une validation CV en k plis dans XGBoost pour rechercher rapidement les hyperparamètres.
  • Utilisez objective = 'binary:logistic' pour le binaire et 'multi:softprob' pour le multiclasse.
  • Enregistrez et chargez les modèles avec xgb.save() / xgb.load().
# Production XGBoost pipeline
dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

params <- list(objective = 'reg:squarederror',
               eta = 0.05, max_depth = 5, subsample = 0.8)

cv  <- xgb.cv(params, dtrain, nrounds = 500, nfold = 5,
              early_stopping_rounds = 20, verbose = 0)

model <- xgboost(data = dtrain, params = params,
                 nrounds = cv$best_iteration, verbose = 0)

preds <- predict(model, dtest)
cat('RMSE:', sqrt(mean((preds - y_test)^2)))

Questions Fréquemment Posées

La leçon « Boosting de gradient avec xgboost » est-elle gratuite ?

Oui — le texte complet de « Boosting de gradient avec xgboost » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Boosting de gradient avec xgboost » ?

Configurez les paramètres de xgboost, l’arrêt anticipé et les calendriers de taux d’apprentissage. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Boosting de gradient avec xgboost » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Arbres de décision : fondement des ensembles
  2. Forêts aléatoires avec ranger
  3. Boosting de gradient avec xgboost
  4. Importance des caractéristiques et interprétation des modèles
← Retour à R Academy