Accueil › Glossaire › XGBoost

XGBoost (eXtreme Gradient Boosting)

XGBoost est une implémentation optimisée du gradient boosting qui construit séquentiellement des arbres de décision, chaque nouvel arbre corrigeant les erreurs résiduelles des précédents, pour produire un modèle d’ensemble hautement performant sur les données tabulaires.

Créé par Tianqi Chen en 2014, XGBoost est rapidement devenu l’algorithme le plus utilisé sur Kaggle et dans l’industrie pour la classification et la régression sur données structurées. Son succès repose sur trois piliers : des performances prédictives de premier plan, des optimisations système (parallélisation, gestion de cache, traitement des données creuses) qui le rendent rapide même sur de grands datasets, et une régularisation intégrée (L1, L2) qui limite l’overfitting.

Comment fonctionne XGBoost

Le gradient boosting en bref

Le gradient boosting construit un modèle de manière additive et séquentielle. Chaque arbre est entraîné pour prédire les résidus (erreurs) du modèle combiné précédent. L’idée : au lieu de construire un seul gros modèle, on empile des centaines de petits modèles (arbres peu profonds, appelés « weak learners »), chacun corrigeant un peu les erreurs des précédents.

La prédiction finale est la somme pondérée des prédictions de tous les arbres : ŷ = Σ fₖ(x), où chaque fₖ est un arbre de décision.

Ce qui rend XGBoost « eXtreme »

Approximation de Taylor d’ordre 2 : XGBoost utilise la dérivée première et seconde (hessienne) de la fonction de perte pour optimiser les splits. Cela rend l’algorithme plus précis et plus rapide que le gradient boosting classique qui n’utilise que le gradient.

Régularisation intégrée : la fonction objectif inclut des termes de pénalité L1 (sur les poids des feuilles, paramètre reg_alpha) et L2 (paramètre reg_lambda), plus un terme de complexité sur le nombre de feuilles (paramètre gamma). Cela réduit l’overfitting sans nécessiter d’intervention externe.

Pruning par gain : au lieu d’arrêter la croissance d’un arbre tôt (pre-pruning comme dans Random Forest), XGBoost fait croître l’arbre jusqu’à max_depth puis élague les branches qui n’apportent pas un gain suffisant (post-pruning). Cela évite de manquer des splits utiles qui apparaissent après un split intermédiaire négatif.

Optimisations système : parallélisation du calcul des splits (pas des arbres, qui sont séquentiels), tri par blocs pour réutiliser les indices, gestion intelligente du cache CPU, et support natif des données creuses (sparse).

Les hyperparamètres clés

XGBoost a de nombreux hyperparamètres. Les 5 plus importants à tuner en priorité sont les suivants.

Paramètres de régularisation

reg_lambda (L2, défaut : 1) : pénalité sur les poids des feuilles. Augmenter pour réduire l’overfitting. reg_alpha (L1, défaut : 0) : favorise la parcimonie (certains poids à zéro). gamma (min_split_loss, défaut : 0) : gain minimum requis pour qu’un split soit effectué. Plus élevé = arbres plus conservateurs.

min_child_weight

Somme minimale des hessiens dans un noeud enfant pour qu’un split soit autorisé. C’est un puissant levier anti-overfitting, l’équivalent conceptuel de min_samples_leaf pour Random Forest. Valeurs typiques : 1 à 10.

XGBoost en Python

Installation

pip install xgboost

Classification

from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.datasets import load_breast_cancer

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

model = XGBClassifier(
    n_estimators=300,
    learning_rate=0.1,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric='logloss',
    random_state=42
)

model.fit(X_train, y_train,
          eval_set=[(X_test, y_test)],
          verbose=False)

y_pred = model.predict(X_test)
y_proba = model.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC-ROC : {roc_auc_score(y_test, y_proba):.4f}")

Early stopping : la technique indispensable

L’early stopping arrête l’entraînement quand la performance sur un jeu de validation ne s’améliore plus. C’est la manière standard d’utiliser XGBoost : fixez un n_estimators élevé et laissez l’early stopping trouver le nombre optimal d’arbres.

model = XGBClassifier(
    n_estimators=2000,       # nombre max élevé
    learning_rate=0.05,      # learning rate bas
    max_depth=6,
    early_stopping_rounds=50,  # arrêter après 50 rounds sans amélioration
    eval_metric='logloss',
    random_state=42
)

model.fit(X_train, y_train,
          eval_set=[(X_test, y_test)],
          verbose=False)

print(f"Meilleur nombre d'arbres : {model.best_iteration}")
print(f"Meilleur score : {model.best_score:.4f}")

Tuning avec Optuna

import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        'n_estimators': 500,
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3),
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
        'subsample': trial.suggest_float('subsample', 0.6, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'reg_lambda': trial.suggest_float('reg_lambda', 0.1, 10.0, log=True),
        'eval_metric': 'logloss',
        'random_state': 42
    }
    model = XGBClassifier(**params)
    scores = cross_val_score(model, X_train, y_train,
                            cv=5, scoring='roc_auc')
    return scores.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(f"Meilleurs paramètres : {study.best_params}")

Feature importance dans XGBoost

XGBoost fournit trois types d’importance des features :

Gain (défaut) : amélioration moyenne du gain quand la feature est utilisée pour un split. C’est la plus informative mais peut être biaisée vers les features à haute cardinalité.

Weight (fréquence) : nombre de fois que la feature est utilisée pour un split dans tous les arbres. Simple mais ne dit rien sur la qualité des splits.

Cover : nombre moyen d’observations affectées par les splits utilisant cette feature.

Comme pour Random Forest, la permutation importance et les valeurs SHAP sont des alternatives plus fiables, surtout pour l’explicabilité en production.

XGBoost vs LightGBM vs CatBoost

En pratique, les trois algorithmes produisent des performances très similaires après tuning. LightGBM est souvent plus rapide sur les grands datasets. CatBoost excelle sur les données avec beaucoup de features catégorielles. XGBoost reste le plus populaire et le mieux documenté. La recommandation : essayez les trois et gardez le meilleur sur votre dataset spécifique.

Applications de XGBoost

Compétitions Kaggle : XGBoost a dominé les compétitions de ML sur données tabulaires pendant des années. Il est présent dans la grande majorité des solutions gagnantes.

Scoring de crédit et finance : prédiction de défaut de paiement, scoring de risque, détection de fraude. La régularisation intégrée et la gestion des données manquantes en font un choix naturel.

Marketing et prédiction de churn : prédiction de la probabilité qu’un client quitte un service. L’importance des features aide à comprendre les facteurs de désabonnement.

Santé : diagnostic assisté, prédiction de réadmission hospitalière, scoring de risque de maladie. L’interprétabilité via SHAP est essentielle dans ce domaine régulé.

Systèmes de recommandation : scoring de candidats items pour le ranking. XGBoost supporte nativement les tâches de learning-to-rank.

Limites de XGBoost

Tuning nécessaire : contrairement à Random Forest qui fonctionne bien « out of the box », XGBoost nécessite un tuning soigneux des hyperparamètres pour atteindre son plein potentiel. Sans tuning, il peut sous-performer un Random Forest bien configuré.

Risque d’overfitting : le boosting séquentiel peut overfitter si le learning rate est trop élevé ou si le nombre d’arbres est trop grand sans early stopping. C’est le piège principal pour les débutants.

Pas d’extrapolation : comme tous les modèles à base d’arbres, XGBoost ne peut pas prédire en dehors de la plage des données d’entraînement. Si la tendance future dépasse les valeurs historiques, le modèle saturera.

Données non structurées : XGBoost est conçu pour les données tabulaires. Pour les images, le texte ou l’audio, les réseaux de neurones (CNN, Transformers) sont nettement supérieurs.

Verdict

XGBoost est l’algorithme de référence pour la performance maximale sur les données tabulaires. Si vous participez à une compétition Kaggle, construisez un modèle de scoring en production, ou cherchez le meilleur modèle possible sur des données structurées, XGBoost (ou son cousin LightGBM) est votre meilleur choix.

Le workflow recommandé : commencez par un Random Forest comme baseline (rapide, pas de tuning). Si vous avez besoin de quelques points de performance supplémentaires, passez à XGBoost avec early stopping et tuning Optuna. Dans la majorité des cas industriels, la différence entre Random Forest et XGBoost tuné est de 1 à 3 points de pourcentage, ce qui peut justifier ou non l’investissement en temps de tuning selon le contexte.