Gradient Boosting : Apprendre de ses Erreurs pour Atteindre l’Excellence

1 Introduction

Après avoir exploré la puissance de la coopération parallèle avec les Forêts Aléatoires, nous changeons radicalement de philosophie. Bienvenue dans le monde du Boosting, où les modèles ne sont pas des experts indépendants, mais des apprentis qui apprennent séquentiellement les uns des autres pour construire ensemble un “super-modèle”.

2 Changement de Paradigme : De la Coopération à la Correction 🚶‍♂️→🏃‍♂️→🚀

Contrairement au Bagging qui vise à réduire la variance, le Boosting s’attaque principalement au biais. L’idée n’est pas de moyenner de nombreux modèles complexes, mais de construire un modèle final puissant en additionnant les contributions de nombreux modèles très simples (souvent des arbres de décision avec une ou deux profondeurs, appelés “stumps”).

La philosophie est la suivante : 1. On commence avec un premier modèle très simple qui fait des erreurs. 2. On entraîne un deuxième modèle, non pas sur les données brutes, mais en lui demandant de corriger les erreurs du premier. 3. On entraîne un troisième modèle pour corriger les erreurs restantes de l’ensemble des deux premiers. 4. … et ainsi de suite. Chaque nouveau modèle est un “spécialiste des faiblesses” de l’ensemble des modèles qui le précèdent.

3 Le Gradient Boosting : Une Généralisation Puissante 🧠

Si des algorithmes comme AdaBoost modifient les poids des observations pour se concentrer sur les erreurs, le Gradient Boosting adopte une approche plus directe et plus générale.

L’idée maîtresse est que chaque nouvel arbre est entraîné à prédire les erreurs résiduelles de l’ensemble des arbres précédents.

Imaginons un problème de régression simple où l’on veut prédire \(y\) :

1. Initialisation : On commence par une prédiction très simple, généralement la moyenne de la variable cible : \(F_0(x) = \bar{y}\). Cette première prédiction a évidemment une erreur.

2. Itération 1 :

   • On calcule les erreurs (les résidus) : \(r_1 = y - F_0(x)\).
   • On entraîne un premier arbre de décision faible (\(h_1\)) pour qu’il apprenne à prédire ces résidus \(r_1\).
   • On met à jour notre modèle global : \(F_1(x) = F_0(x) + \nu \cdot h_1(x)\).

3. Itération 2 :

   • On calcule les nouveaux résidus : \(r_2 = y - F_1(x)\).
   • On entraîne un deuxième arbre faible (\(h_2\)) pour qu’il apprenne à prédire ces nouveaux résidus \(r_2\).
   • On met à jour le modèle global : \(F_2(x) = F_1(x) + \nu \cdot h_2(x)\).

On répète ce processus \(M\) fois. Le modèle final est une somme additive :

\[ F_M(x) = \sum_{m=0}^{M} \nu \cdot h_m(x) \]

3.1 Le Rôle Crucial du Taux d’Apprentissage (Learning Rate)

Le paramètre \(\nu\) (prononcé “nu”) est le taux d’apprentissage (learning rate). C’est un facteur (généralement petit, ex: 0.1) qui pondère la contribution de chaque nouvel arbre. Il joue un rôle de régularisation essentiel :

• En ralentissant l’apprentissage, on empêche le modèle de corriger trop brutalement ses erreurs et de tomber dans le sur-apprentissage.
• Un learning_rate plus faible nécessite un plus grand nombre d’arbres (n_estimators) pour atteindre une bonne performance, mais le modèle final sera généralement plus robuste.

---

4 Les Champions du Gradient Boosting : XGBoost, LightGBM, CatBoost 🏆

Le Gradient Boosting est si puissant qu’il a donné naissance à des bibliothèques ultra-optimisées qui dominent les compétitions de Machine Learning sur données tabulaires.

4.1 XGBoost (eXtreme Gradient Boosting) : Le Roi de la Régularisation

L’innovation majeure de XGBoost est d’intégrer la régularisation directement dans sa fonction objectif. Au lieu de simplement minimiser l’erreur, il minimise une fonction qui pénalise aussi la complexité des arbres.

La fonction objectif à minimiser pour construire le \(t\)-ième arbre est : \[ \text{Obj}^{(t)} = \sum_{i=1}^{n} l(y_i, \hat{y}_i^{(t-1)} + f_t(x_i)) + \Omega(f_t) \] où \(l\) est la fonction de perte (ex: erreur quadratique) et \(\Omega(f_t)\) est le terme de régularisation.

Ce terme de régularisation est la clé : \[ \Omega(f_t) = \gamma T + \dfrac{1}{2}\lambda \sum_{j=1}^{T} w_j^2 \]

• \(T\) est le nombre de feuilles dans l’arbre. Le paramètre \(\gamma\) contrôle la pénalité sur le nombre de feuilles, agissant comme un mécanisme d’élagage.
• \(w_j\) est le score (ou poids) de la feuille \(j\). Le paramètre \(\lambda\) applique une régularisation L2 sur ces poids, ce qui empêche les prédictions d’être trop extrêmes et rend le modèle plus stable.

En bref, XGBoost ne cherche pas seulement à bien prédire, il cherche à le faire avec les arbres les plus simples possible.

4.2 LightGBM (Light Gradient Boosting Machine) : Le Champion de la Vitesse

Développé par Microsoft, LightGBM se concentre sur l’efficacité et la vitesse d’entraînement, souvent sans compromis sur la performance. Il y parvient grâce à deux techniques principales :

1. Gradient-based One-Side Sampling (GOSS) : L’idée est que les observations avec de petits gradients (celles qui sont déjà bien prédites) contribuent peu à l’apprentissage. GOSS conserve toutes les observations avec de grands gradients (les “mauvais élèves”) et échantillonne aléatoirement une petite partie de celles avec de faibles gradients. Cela accélère considérablement la recherche de la meilleure division.
2. Exclusive Feature Bundling (EFB) : Dans les jeux de données à haute dimensionnalité (souvent sparse), de nombreuses variables sont mutuellement exclusives (par exemple, elles ne prennent jamais de valeurs non nulles simultanément). EFB regroupe intelligemment ces variables en une seule, réduisant le nombre de caractéristiques à analyser.

De plus, LightGBM utilise une stratégie de croissance d’arbre leaf-wise (par la feuille), contrairement à la croissance level-wise (par niveau) de XGBoost. Il choisit de développer la feuille qui promet la plus grande réduction de perte, ce qui converge plus rapidement vers un bon modèle, mais peut être plus sujet au surapprentissage sur de petits jeux de données.

4.3 CatBoost (Categorical Boosting) : Le Spécialiste des Données Catégorielles

Développé par Yandex, CatBoost excelle dans un domaine où les autres algorithmes nécessitent un pré-traitement minutieux : les variables catégorielles.

Son innovation majeure est une méthode de target encoding améliorée appelée Ordered Boosting. Le target encoding classique (remplacer une catégorie par la moyenne de la variable cible pour cette catégorie) est sujet à la “fuite de la cible” (target leakage), car l’information de la cible d’une observation est utilisée pour créer une de ses propres caractéristiques.

CatBoost résout ce problème en calculant les statistiques de manière ordonnée. Pour chaque observation, il calcule la statistique de la cible en utilisant uniquement les observations qui la précèdent dans une permutation aléatoire du jeu de données. Cela garantit que l’information de la cible ne “fuit” pas, rendant l’encodage beaucoup plus robuste.

CatBoost utilise également des arbres de décision symétriques (ou “oblivious”), où le même critère de division est appliqué à tous les nœuds d’un même niveau. Ces arbres sont moins complexes, plus rapides à entraîner et agissent comme une forme de régularisation naturelle.

---

5 Atelier Pratique : Gradient Boosting en Action avec Scikit-learn

Utilisons l’implémentation de base de Scikit-learn pour voir le Gradient Boosting en action sur le jeu de données wine.

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score, classification_report

# 1. Charger les données
wine = load_wine()
X, y = wine.data, wine.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

# 2. Entraîner le modèle Gradient Boosting
# Les hyperparamètres clés sont :
# - n_estimators : le nombre d'arbres séquentiels
# - learning_rate : le poids de la contribution de chaque arbre
# - max_depth : la profondeur maximale de chaque arbre faible
gb_clf = GradientBoostingClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3,
    random_state=42
)
gb_clf.fit(X_train, y_train)

# 3. Évaluer la performance
y_pred_gb = gb_clf.predict(X_test)
acc_gb = accuracy_score(y_test, y_pred_gb)

print(f"--- Performance du Gradient Boosting ---")
print(f"Accuracy: {acc_gb:.4f}\n")
print(classification_report(y_test, y_pred_gb, target_names=wine.target_names))

--- Performance du Gradient Boosting ---
Accuracy: 0.9630

              precision    recall  f1-score   support

     class_0       1.00      0.89      0.94        18
     class_1       0.91      1.00      0.95        21
     class_2       1.00      1.00      1.00        15

    accuracy                           0.96        54
   macro avg       0.97      0.96      0.97        54
weighted avg       0.97      0.96      0.96        54

Analyse : Le modèle est déjà très performant. En pratique, la clé pour en extraire le maximum est de régler finement les hyperparamètres, notamment le couple learning_rate et n_estimators. Un learning_rate plus bas (ex: 0.01) demanderait plus d’n_estimators (ex: 500 ou 1000) pour converger, mais produirait souvent un modèle plus généralisable.

6 Conclusion : La Quête de la Performance Maximale

Le Boosting, et en particulier ses implémentations modernes comme XGBoost, LightGBM et CatBoost, est une technique d’une puissance redoutable. En construisant un modèle fort à partir d’une séquence de modèles faibles qui se corrigent mutuellement, il est capable d’atteindre des niveaux de performance que peu d’autres algorithmes peuvent égaler sur des données structurées.

Maintenant que nous avons exploré les deux grandes philosophies ensemblistes, il est temps de les mettre face à face. Dans notre prochain et dernier article, nous organiserons le duel : Forêt Aléatoire contre Gradient Boosting. Lequel choisir, et quand ?

---

7 Exercices

Exercise 1  

Question 1

Quelle est la principale différence de philosophie entre le Bagging et le Boosting ?

1. Le Bagging réduit le biais, le Boosting réduit la variance.
2. Le Bagging entraîne les modèles en séquence, le Boosting en parallèle.
3. Le Bagging vise à réduire la variance en moyennant des modèles indépendants, tandis que le Boosting vise à réduire le biais en construisant des modèles séquentiellement.
4. Les deux méthodes sont identiques, seul le nom change.

Question 2

Dans l’algorithme du Gradient Boosting pour la régression, que cherche à prédire chaque nouvel arbre de décision faible ?

1. La variable cible originale, \(y\).
2. Les erreurs résiduelles de l’ensemble des modèles précédents.
3. Les poids des observations mal classées.
4. La moyenne de la variable cible.

Question 3

Quel est le rôle du paramètre learning_rate (taux d’apprentissage) ?

1. Il détermine le nombre total d’arbres à construire.
2. Il contrôle la profondeur maximale de chaque arbre.
3. Il pondère la contribution de chaque nouvel arbre, agissant comme un mécanisme de régularisation pour éviter le surapprentissage.
4. Il accélère la vitesse de calcul en ignorant certaines observations.

Question 4

Quelle est l’innovation majeure de XGBoost qui le distingue du Gradient Boosting standard ?

1. Sa capacité à gérer les variables catégorielles sans pré-traitement.
2. L’intégration d’une pénalité de régularisation (L1/L2) directement dans sa fonction objectif pour contrôler la complexité des arbres.
3. L’utilisation d’une croissance d’arbre “leaf-wise” pour une plus grande vitesse.
4. Le fait qu’il soit exclusivement écrit en Python.

Question 5

Quel algorithme est particulièrement réputé pour sa vitesse d’entraînement grâce à des techniques comme GOSS et EFB ?

1. XGBoost
2. CatBoost
3. LightGBM
4. GradientBoostingClassifier de Scikit-learn

Question 6

Quelle est la spécialité de l’algorithme CatBoost ?

1. La régularisation extrême pour éviter tout surapprentissage.
2. La vitesse d’entraînement sur de très petits jeux de données.
3. Une gestion native et robuste des variables catégorielles grâce à l’Ordered Boosting.
4. La création d’arbres de décision très profonds et complexes.

Question 7

Si vous diminuez le learning_rate d’un modèle de Gradient Boosting, comment devriez-vous ajuster le n_estimators pour potentiellement obtenir un meilleur modèle ?

1. Le diminuer également.
2. Le laisser inchangé.
3. L’augmenter.
4. Le learning_rate et le n_estimators ne sont pas liés.

Question 8

La croissance d’arbre “leaf-wise” (par la feuille), utilisée par LightGBM, est généralement :

1. Plus lente mais plus précise que la croissance “level-wise” (par niveau).
2. Plus rapide mais peut être plus sujette au surapprentissage sur de petits jeux de données.
3. La seule méthode de croissance utilisée par tous les algorithmes de boosting.
4. Moins efficace pour réduire la perte du modèle.

Question 9

Dans l’équation de la fonction objectif de XGBoost, que représente le terme \(\gamma T\) ?

1. Une pénalité sur le poids des feuilles pour éviter les prédictions extrêmes.
2. Le taux d’apprentissage du modèle.
3. Une pénalité sur le nombre de feuilles (\(T\)) pour encourager des arbres plus simples.
4. L’erreur de classification du modèle.

Question 10

Le problème de “target leakage” (fuite de la cible) est un risque associé à certaines méthodes d’encodage des variables catégorielles. Quel algorithme a été spécifiquement conçu pour contrer ce problème ?

1. XGBoost avec son paramètre tree_method='hist'.
2. LightGBM avec sa technique EFB.
3. CatBoost avec sa technique d’Ordered Boosting.
4. Tous les algorithmes de boosting gèrent ce problème de la même manière.

Question 11

Quel est le but principal de la technique de Boosting ?

1. Réduire la variance de modèles à forte variance.
2. Réduire le biais de modèles à fort biais (modèles faibles).
3. Rendre les modèles plus interprétables.
4. Entraîner des modèles en parallèle pour un calcul plus rapide.

Question 12

Comment la prédiction finale est-elle construite dans un modèle de Gradient Boosting ?

1. Par un vote majoritaire de tous les arbres.
2. En faisant la moyenne des prédictions de tous les arbres.
3. En additionnant séquentiellement les prédictions d’un modèle initial et de tous les arbres faibles suivants, pondérées par le taux d’apprentissage.
4. En sélectionnant la prédiction du meilleur arbre de l’ensemble.

Question 13

Qu’est-ce qu’un “stump” (ou souche) dans le contexte des algorithmes de Boosting ?

1. Un arbre de décision très complexe et profond.
2. Un arbre de décision avec une seule division (profondeur de 1).
3. La prédiction initiale du modèle (par exemple, la moyenne de la cible).
4. Une observation qui est très difficile à classer correctement.

Question 14

Dans la fonction objectif de XGBoost, quel est le rôle du terme \(\frac{1}{2}\lambda \sum_{j=1}^{T} w_j^2\) ?

1. Il pénalise le nombre d’arbres dans le modèle.
2. Il pénalise la profondeur des arbres.
3. C’est un terme de régularisation L2 sur les poids des feuilles (\(w_j\)) pour éviter des prédictions trop extrêmes.
4. C’est le taux d’apprentissage du modèle.

Question 15

Quelle est la caractéristique principale des “arbres symétriques” (oblivious trees) utilisés par CatBoost ?

1. Ils ignorent un sous-ensemble aléatoire de variables à chaque division.
2. Ils utilisent le même critère de division (même variable et même seuil) pour tous les nœuds situés à la même profondeur.
3. Ils ne peuvent traiter que des données numériques.
4. Ils sont toujours développés jusqu’à leur profondeur maximale possible.

Question 16

Pourquoi les algorithmes de Boosting utilisent-ils généralement des “apprenants faibles” (weak learners) comme des arbres de décision peu profonds ?

1. Parce que les apprenants faibles sont plus rapides à entraîner.
2. Parce qu’un apprenant fort (arbre profond) sur-apprendrait dès la première étape, ne laissant pas d’erreurs à corriger pour les arbres suivants.
3. Parce que les apprenants faibles sont plus faciles à interpréter.
4. Parce que les apprenants faibles nécessitent moins de mémoire.

Question 17

Le terme “Gradient” dans “Gradient Boosting” fait référence à :

1. La vitesse à laquelle le modèle apprend.
2. L’utilisation d’une approche de descente de gradient pour minimiser la fonction de perte en ajoutant séquentiellement de nouveaux arbres.
3. La méthode de sampling GOSS (Gradient-based One-Side Sampling) de LightGBM.
4. Le fait que les erreurs du modèle diminuent de manière linéaire.

Question 18

Pour quel type de données les algorithmes comme XGBoost, LightGBM et CatBoost sont-ils le plus souvent considérés comme l’état de l’art ?

1. Les données d’images.
2. Les données textuelles (NLP).
3. Les données structurées ou tabulaires.
4. Les données audio.

Question 19

Quelle est une stratégie de réglage courante et efficace pour un modèle de Gradient Boosting ?

1. Utiliser le learning_rate le plus élevé possible pour converger rapidement.
2. Fixer un learning_rate faible (ex: 0.01-0.1) et trouver le n_estimators optimal, souvent à l’aide de l’early stopping.
3. Se concentrer uniquement sur l’optimisation de la profondeur des arbres (max_depth).
4. Utiliser un très grand nombre d’arbres (n_estimators) avec un learning_rate élevé.

Question 20

Outre sa fonction objectif régularisée, quel est un autre avantage pratique majeur de XGBoost ?

1. Il ne nécessite aucun réglage d’hyperparamètres.
2. Il est écrit exclusivement en Python, ce qui le rend facile à modifier.
3. Son implémentation est hautement optimisée, parallélisable, et il peut gérer nativement les valeurs manquantes.
4. Il est garanti d’être plus rapide que LightGBM sur tous les jeux de données.