— factory / algos ML / apprentissage supervisé

ALGORITHME XGBOOST.

Des centaines de petits arbres de décision construits l'un après l'autre, chacun corrigeant les erreurs laissées par les précédents. Sur des données en tableau, c'est souvent le modèle le plus précis disponible, à condition de prendre le temps de le régler.

ClassificationRégressionDonnées tabulairesEnsemble / boostingNiveau : intermédiaire

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceSouvent le meilleur score sur des données en tableau

InterprétabilitéImportance des variables oui, détail client par client avec SHAP

VitesseTrès optimisé, mais les arbres se construisent l'un après l'autre

Facilité de réglagePas, profondeur et arrêt précoce à régler, défauts rarement optimaux

Tolérance aux données brutesGère les valeurs manquantes, pas de normalisation, catégories natives possibles

EN 30 SECONDES

Un élève qui révise en ne refaisant que les exercices qu'il a ratés. Chaque nouvel arbre ne travaille que sur ce que les précédents ont mal prédit.

1. Un premier arbre modeste

On part d'une prédiction de base, proche du taux moyen de churn, et on ajoute un arbre peu profond. Il capte les grandes tendances et se trompe encore sur beaucoup de clients.

2. Chaque arbre corrige le précédent

L'arbre suivant vise les erreurs restantes (le gradient de l'erreur, d'où le nom gradient boosting). Sa correction est multipliée par un petit facteur, le taux d'apprentissage, pour avancer à petits pas.

3. On s'arrête à temps

Sur des clients mis de côté, on suit l'erreur à chaque arbre ajouté. Quand elle ne baisse plus, on arrête (early stopping). Les corrections de tous les arbres s'additionnent, puis sont converties en probabilité.

LE CAS MÉTIER

churn · télécom / énergie / assurance

EN ENTRÉE

Une ligne par client

Ancienneté, nombre d'appels au support, montant mensuel, type de contrat, incidents des 3 derniers mois. Et la colonne à prédire : le client est-il parti ?

EN SORTIE

Un score de 0 à 100 %

Chaque client reçoit une probabilité de départ. Bien réglé, XGBoost classe souvent les clients un peu mieux qu'une Random Forest : quelques partants de plus trouvés dans la liste d'appels.

CE QU'ON MESURE

L'AUC pour régler, le lift pour décider

L'AUC mesure si le modèle classe les partants avant les fidèles : c'est elle qui pilote l'arrêt précoce. Pour l'équipe fidélisation, on regarde la part de vrais partants dans le top 10 %, comparée au taux moyen.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Données en tableau où chaque point de précision a une valeur (churn, scoring, prévision de demande)
Après une Random Forest, pour aller chercher quelques points de plus
Classe rare à détecter (résiliation, fraude), avec scale_pos_weight
Beaucoup de valeurs manquantes : XGBoost apprend de quel côté de chaque seuil les envoyer

NON

Quelques centaines de lignes seulement : le surapprentissage guette, préférer une régression logistique
Pas de temps pour régler ni de données de validation : une Random Forest fait presque aussi bien sans effort
Décision à justifier devant un régulateur : régression logistique, ou XGBoost accompagné de SHAP
Images, texte, son : c'est le terrain du deep learning

LES 4 RÉGLAGES QUI COMPTENT

Contrairement à la Random Forest, les valeurs par défaut sont rarement les meilleures. Noms donnés pour R (xgb.train) et Python (XGBClassifier).

eta / learning_rate

Taille du pas de chaque correction. 0,3 par défaut, souvent trop. Entre 0,01 et 0,1, le modèle est plus précis mais demande plus d'arbres. On le fixe, et l'arrêt précoce choisit le nombre d'arbres.

nrounds / n_estimators + early_stopping_rounds

Nombre maximal d'arbres. On le met large (1 000) et on arrête quand le score sur les données de validation ne progresse plus depuis 50 tours. Sans arrêt précoce, trop d'arbres mènent au surapprentissage.

max_depth

Profondeur de chaque arbre, 6 par défaut. Entre 3 et 6 en général. Des arbres plus profonds captent davantage d'interactions entre variables, et surapprennent plus vite.

scale_pos_weight

Poids de la classe à détecter quand elle est rare. Valeur usuelle : nombre de négatifs divisé par nombre de positifs, environ 3,5 pour 22 % de churn. Les scores ne sont alors plus des probabilités fiables, seulement un classement.

LE CODE MINIMAL

jeu d'exemple : clients_churn.csv ↓

# Churn clients : XGBoost en R
library(xgboost)

clients <- read.csv("clients_churn.csv")
# Matrice numérique : le contrat est encodé en indicatrices 0/1
X <- model.matrix(~ anciennete + appels_support + montant + contrat + incidents_3m, data = clients)[, -1]
y <- clients$churn

# 60 % apprentissage, 20 % validation (arrêt précoce), 20 % test
set.seed(42)
groupe <- sample(c("fit", "valid", "test"), nrow(X), replace = TRUE, prob = c(0.6, 0.2, 0.2))
dfit <- xgb.DMatrix(X[groupe == "fit", ], label = y[groupe == "fit"])
dvalid <- xgb.DMatrix(X[groupe == "valid", ], label = y[groupe == "valid"])

params <- list(objective = "binary:logistic", eval_metric = "auc",
               eta = 0.05, max_depth = 4, subsample = 0.8)
modele <- xgb.train(params = params, data = dfit, nrounds = 1000, evals = list(valid = dvalid),
                    early_stopping_rounds = 50, verbose = 0)

# Score de départ sur les clients jamais vus
proba <- predict(modele, X[groupe == "test", ])
churn_test <- y[groupe == "test"]
top <- proba >= quantile(proba, 0.9)
cat("Taux de churn top 10 % :", round(mean(churn_test[top]), 2), "\n")
cat("Taux de churn moyen   :", round(mean(churn_test), 2), "\n")
print(xgb.importance(model = modele))

# Churn clients : XGBoost en Python
import pandas as pd
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

clients = pd.read_csv("clients_churn.csv")
X = pd.get_dummies(clients[["anciennete", "appels_support", "montant", "contrat", "incidents_3m"]], dtype=int)
y = clients["churn"]

# 60 % apprentissage, 20 % validation (arrêt précoce), 20 % test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_fit, X_valid, y_fit, y_valid = train_test_split(X_train, y_train, test_size=0.25, random_state=42)

modele = XGBClassifier(n_estimators=1000, learning_rate=0.05, max_depth=4, subsample=0.8,
                       eval_metric="auc", early_stopping_rounds=50, random_state=42)
modele.fit(X_fit, y_fit, eval_set=[(X_valid, y_valid)], verbose=False)
print("Arbres retenus :", modele.best_iteration + 1)

# Score de départ sur les clients jamais vus
proba = modele.predict_proba(X_test)[:, 1]
top = proba >= pd.Series(proba).quantile(0.9)
print("AUC test :", round(roc_auc_score(y_test, proba), 3))
print("Taux de churn top 10 % :", round(y_test[top].mean(), 2), "| moyen :", round(y_test.mean(), 2))
print(pd.Series(modele.feature_importances_, index=X.columns).sort_values(ascending=False).round(3))

QUESTIONS FRÉQUENTES

Quelle différence entre XGBoost et Random Forest ?

La Random Forest entraîne ses arbres indépendamment, sur des échantillons différents, puis fait voter. XGBoost les construit l'un après l'autre, chacun corrigeant les erreurs des précédents. XGBoost est souvent un peu plus précis, mais il surapprend plus facilement et demande des réglages.

Quelle différence entre XGBoost et gradient boosting ?

Le gradient boosting est la méthode. XGBoost en est une implémentation optimisée : régularisation des arbres, gestion native des valeurs manquantes, calcul parallèle des découpages. LightGBM et CatBoost sont d'autres implémentations de la même idée.

Comment éviter le surapprentissage avec XGBoost ?

D'abord l'arrêt précoce sur des données de validation. Ensuite un taux d'apprentissage plus faible, des arbres moins profonds et un sous-échantillonnage des lignes (subsample) ou des variables (colsample_bytree). La performance se juge toujours sur des données que le modèle n'a jamais vues.