Méthodes d’ensemble

The three most important things in real estate are: location, location, location. The three most important things in machine learning are: ensemble, ensemble, ensemble.

Adaptation libre d’un adage attribué à la communauté Kaggle

Les méthodes d’ensemble reposent sur une idée simple et puissante : combiner les prédictions de plusieurs modèles pour obtenir un modèle plus performant que chacun pris individuellement. Ce principe, parfois appelé sagesse des foules (wisdom of crowds), est l’un des résultats les plus robustes de l’apprentissage automatique. Ce chapitre couvre les grandes familles d’ensemble — bagging, boosting et stacking — ainsi que leurs implémentations les plus utilisées en pratique.

Introduction

La sagesse des foules

En 1906, le statisticien Francis Galton observa que la médiane des estimations d’un groupe de personnes cherchant à deviner le poids d’un boeuf était remarquablement proche de la valeur réelle — plus proche que la plupart des estimations individuelles, y compris celles des experts. Ce phénomène, formalisé bien plus tard sous le nom de sagesse des foules, repose sur deux conditions :

1. Diversité : les erreurs individuelles doivent être suffisamment différentes les unes des autres.

2. Indépendance : les estimations ne doivent pas être trop corrélées.

En apprentissage automatique, on retrouve exactement ces deux ingrédients. Un apprenant faible (weak learner) est un modèle dont la performance est à peine meilleure que le hasard. La théorie montre qu’en combinant un nombre suffisant d’apprenants faibles diversifiés, on peut obtenir un apprenant fort (strong learner) dont l’erreur est arbitrairement faible.

Définition 99 (Méthode d’ensemble)

Soit \(h_1, h_2, \ldots, h_M\) un ensemble de \(M\) modèles de base (base learners). Une méthode d’ensemble construit un modèle combiné \(H\) tel que

\[H(\mathbf{x}) = \mathcal{C}\big(h_1(\mathbf{x}), h_2(\mathbf{x}), \ldots, h_M(\mathbf{x})\big)\]

où \(\mathcal{C}\) est une fonction de combinaison (vote majoritaire, moyenne, moyenne pondérée, méta-modèle, etc.).

Remarque 95

La combinaison n’est bénéfique que si les modèles de base commettent des erreurs sur des exemples différents. Si tous les modèles se trompent sur les mêmes exemples, la combinaison n’apporte rien. C’est pourquoi les méthodes d’ensemble cherchent à maximiser la diversité entre les modèles de base.

Décomposition biais-variance

Pour comprendre pourquoi les ensembles fonctionnent, il est utile de rappeler la décomposition biais-variance. Pour une fonction cible \(f\) et un modèle \(\hat{f}\) appris sur un échantillon d’entraînement, l’erreur quadratique moyenne en un point \(\mathbf{x}\) se décompose en

\[\mathbb{E}\left[(f(\mathbf{x}) - \hat{f}(\mathbf{x}))^2\right] = \underbrace{\text{Biais}^2(\hat{f}(\mathbf{x}))}_{\text{erreur systématique}} + \underbrace{\text{Var}(\hat{f}(\mathbf{x}))}_{\text{instabilité}} + \underbrace{\sigma^2}_{\text{bruit irréductible}}\]

Le bagging réduit principalement la variance, tandis que le boosting réduit principalement le biais. C’est ce qui explique leurs comportements complémentaires.

Bagging

Bootstrap Aggregating

Le bagging (Bootstrap Aggregating), introduit par Leo Breiman en 1996, est la méthode d’ensemble la plus intuitive. L’idée est de créer de la diversité en entraînant chaque modèle de base sur un sous-ensemble différent des données, obtenu par échantillonnage bootstrap.

Définition 100 (Bootstrap)

Soit \(\mathcal{D} = \{(\mathbf{x}_1, y_1), \ldots, (\mathbf{x}_n, y_n)\}\) un jeu de données de taille \(n\). Un échantillon bootstrap \(\mathcal{D}^*\) est obtenu en tirant \(n\) observations avec remise dans \(\mathcal{D}\). En moyenne, chaque échantillon bootstrap contient environ \(1 - (1 - 1/n)^n \approx 1 - 1/e \approx 63{,}2\%\) des observations originales.

Définition 101 (Bagging)

Le bagging (Bootstrap Aggregating) procède comme suit :

1. Générer \(M\) échantillons bootstrap \(\mathcal{D}_1^*, \ldots, \mathcal{D}_M^*\) à partir de \(\mathcal{D}\).

2. Entraîner un modèle de base \(h_m\) sur chaque \(\mathcal{D}_m^*\).

3. Combiner les prédictions :

   • Régression : \(H(\mathbf{x}) = \frac{1}{M} \sum_{m=1}^M h_m(\mathbf{x})\) (moyenne)

   • Classification : \(H(\mathbf{x}) = \arg\max_c \sum_{m=1}^M \mathbb{1}[h_m(\mathbf{x}) = c]\) (vote majoritaire)

Réduction de la variance

Le résultat fondamental du bagging est que la moyenne de modèles réduit la variance sans augmenter le biais.

Proposition 23 (Réduction de variance par moyennage)

Soient \(h_1, \ldots, h_M\) des modèles de base identiquement distribués, de variance \(\sigma^2\) et de corrélation par paires \(\rho\). La variance de la moyenne \(\bar{h} = \frac{1}{M}\sum_{m=1}^M h_m\) vaut

\[\text{Var}(\bar{h}) = \rho \sigma^2 + \frac{1 - \rho}{M} \sigma^2\]

Proof. Calculons la variance de la moyenne :

\[\text{Var}\left(\frac{1}{M}\sum_{m=1}^M h_m\right) = \frac{1}{M^2} \sum_{m=1}^M \sum_{m'=1}^M \text{Cov}(h_m, h_{m'})\]

Les termes diagonaux (\(m = m'\)) contribuent \(\frac{1}{M^2} \cdot M \cdot \sigma^2 = \frac{\sigma^2}{M}\).

Les termes hors diagonale (\(m \neq m'\)) contribuent \(\frac{1}{M^2} \cdot M(M-1) \cdot \rho\sigma^2\).

En sommant :

\[\text{Var}(\bar{h}) = \frac{\sigma^2}{M} + \frac{M-1}{M} \rho \sigma^2 = \rho\sigma^2 + \frac{1-\rho}{M}\sigma^2\]

Lorsque \(M \to \infty\), la variance converge vers \(\rho\sigma^2\). La réduction est donc limitée par la corrélation \(\rho\) entre les modèles. C’est pourquoi il est crucial de maximiser la diversité (minimiser \(\rho\)).

Remarque 96

Si les modèles étaient parfaitement indépendants (\(\rho = 0\)), la variance décroîtrait en \(\sigma^2/M\). En pratique, les échantillons bootstrap sont corrélés (ils partagent environ 63 % des données), donc \(\rho > 0\) et la réduction de variance est plus modeste. Les forêts aléatoires, que nous verrons ensuite, introduisent une source supplémentaire de diversité pour réduire davantage \(\rho\).

Show code cell source

Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.model_selection import cross_val_score

X, y = make_classification(n_samples=500, n_features=20,
                            n_informative=10, random_state=42)

# Arbre seul
tree = DecisionTreeClassifier(random_state=42)
score_tree = cross_val_score(tree, X, y, cv=10, scoring='accuracy')

# Bagging d'arbres
bagging = BaggingClassifier(estimator=DecisionTreeClassifier(),
                             n_estimators=100, random_state=42)
score_bag = cross_val_score(bagging, X, y, cv=10, scoring='accuracy')

print(f"Arbre seul     — Accuracy : {score_tree.mean():.3f} (+/- {score_tree.std():.3f})")
print(f"Bagging (100)  — Accuracy : {score_bag.mean():.3f} (+/- {score_bag.std():.3f})")

Arbre seul     — Accuracy : 0.820 (+/- 0.056)
Bagging (100)  — Accuracy : 0.870 (+/- 0.065)

Forêts aléatoires

Principe

La forêt aléatoire (Random Forest), proposée par Breiman en 2001, est une extension du bagging qui ajoute une deuxième source de diversité : à chaque noeud de chaque arbre, seul un sous-ensemble aléatoire de features est considéré pour le split.

Définition 102 (Forêt aléatoire)

Une forêt aléatoire est un ensemble de \(M\) arbres de décision \(\{h_m\}_{m=1}^M\) construits comme suit :

1. Pour chaque arbre \(m\), tirer un échantillon bootstrap \(\mathcal{D}_m^*\) de taille \(n\).

2. À chaque noeud de l’arbre, sélectionner aléatoirement \(q\) features parmi les \(p\) disponibles, et choisir le meilleur split parmi ces \(q\) features uniquement.

3. Développer l’arbre sans élagage (profondeur maximale).

La prédiction est obtenue par vote majoritaire (classification) ou par moyenne (régression).

Les valeurs typiques de \(q\) sont \(q = \lfloor\sqrt{p}\rfloor\) pour la classification et \(q = \lfloor p/3 \rfloor\) pour la régression.

Remarque 97

La restriction du nombre de features candidates à chaque noeud réduit la corrélation \(\rho\) entre les arbres. Avec le bagging simple, tous les arbres tendent à utiliser les mêmes features dominantes et produisent des prédictions similaires. En limitant le choix à \(q \ll p\) features, on force les arbres à exploiter des aspects différents des données, ce qui diminue \(\rho\) et donc la variance de l’ensemble.

Score OOB

Définition 103 (Score Out-of-Bag)

Chaque échantillon bootstrap \(\mathcal{D}_m^*\) omet environ 36,8 % des observations originales. Ces observations hors du sac (out-of-bag, OOB) constituent un jeu de validation naturel pour l’arbre \(h_m\). Le score OOB est calculé en prédisant chaque observation \(\mathbf{x}_i\) uniquement avec les arbres pour lesquels \(\mathbf{x}_i\) n’a pas été utilisée lors de l’entraînement :

\[\hat{y}_i^{\text{OOB}} = \mathcal{C}\big(\{h_m(\mathbf{x}_i) : i \notin \mathcal{D}_m^*\}\big)\]

Le score OOB fournit une estimation non biaisée de l’erreur de généralisation, sans nécessiter de jeu de validation séparé.

Importance des features

Définition 104 (Importance par impureté (MDI))

L”importance par diminution d’impureté (Mean Decrease in Impurity, MDI) d’une feature \(j\) est la somme pondérée des diminutions d’impureté (Gini ou entropie) causées par les splits sur \(j\), moyennée sur tous les arbres :

\[\text{MDI}(j) = \frac{1}{M} \sum_{m=1}^M \sum_{t \in \mathcal{T}_m} \mathbb{1}[v(t) = j] \cdot \Delta I(t)\]

où \(\mathcal{T}_m\) est l’ensemble des noeuds de l’arbre \(m\), \(v(t)\) est la feature utilisée au noeud \(t\), et \(\Delta I(t)\) est la diminution d’impureté au noeud \(t\).

Remarque 98

L’importance MDI est biaisée en faveur des features à haute cardinalité (beaucoup de valeurs distinctes) et des features numériques. L’importance par permutation (Mean Decrease in Accuracy, MDA), qui mesure la perte de performance lorsqu’on permute aléatoirement les valeurs d’une feature, est un indicateur plus fiable mais plus coûteux à calculer.

Show code cell source

Hide code cell source

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt
import numpy as np

# Données avec des features informatives et du bruit
X, y = make_classification(n_samples=1000, n_features=15,
                            n_informative=5, n_redundant=3,
                            random_state=42)

feature_names = [f"x{i}" for i in range(X.shape[1])]

rf = RandomForestClassifier(n_estimators=200, oob_score=True, random_state=42)
rf.fit(X, y)

print(f"Score OOB : {rf.oob_score_:.3f}")

# Importance MDI
importances = rf.feature_importances_
indices = np.argsort(importances)[::-1]

fig, ax = plt.subplots(figsize=(10, 5))
ax.bar(range(X.shape[1]), importances[indices], color='steelblue', edgecolor='black')
ax.set_xticks(range(X.shape[1]))
ax.set_xticklabels([feature_names[i] for i in indices], rotation=45)
ax.set_title("Importance des features (MDI) — Random Forest")
ax.set_ylabel("Importance")
plt.tight_layout()
plt.show()

Score OOB : 0.934

Show code cell source

Hide code cell source

from sklearn.inspection import permutation_importance

# Importance par permutation (plus fiable)
perm_imp = permutation_importance(rf, X, y, n_repeats=20, random_state=42)

sorted_idx = perm_imp.importances_mean.argsort()[::-1]

fig, ax = plt.subplots(figsize=(10, 5))
ax.boxplot([perm_imp.importances[i] for i in sorted_idx],
           vert=True, tick_labels=[feature_names[i] for i in sorted_idx])
ax.set_title("Importance des features (permutation) — Random Forest")
ax.set_ylabel("Diminution de l'accuracy")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Boosting

Principe

Le boosting adopte une stratégie radicalement différente du bagging : au lieu d’entraîner les modèles de base en parallèle et de les moyenner, il les entraîne séquentiellement, chaque nouveau modèle se concentrant sur les erreurs commises par les précédents.

Définition 105 (Boosting)

Le boosting construit un ensemble additif de modèles de base :

\[H_M(\mathbf{x}) = \sum_{m=1}^M \alpha_m h_m(\mathbf{x})\]

où chaque \(h_m\) est ajusté pour corriger les erreurs résiduelles de \(H_{m-1}\), et \(\alpha_m\) est le poids (ou le taux d’apprentissage) associé au modèle \(m\).

Remarque 99

Le bagging réduit la variance en moyennant des modèles instables (arbres profonds). Le boosting réduit le biais en combinant des modèles très simples (arbres peu profonds, appelés stumps). En pratique, le boosting est plus susceptible de surapprendre si le nombre d’itérations est trop élevé ou si les données sont bruitées.

AdaBoost

Algorithme

L’algorithme AdaBoost (Adaptive Boosting), proposé par Freund et Schapire en 1997, est le premier algorithme de boosting pratiquement efficace. Il maintient une distribution de poids sur les exemples d’entraînement et augmente le poids des exemples mal classés à chaque itération.

Définition 106 (AdaBoost)

Soit \(\mathcal{D} = \{(\mathbf{x}_i, y_i)\}_{i=1}^n\) avec \(y_i \in \{-1, +1\}\).

Initialisation : \(w_i^{(1)} = 1/n\) pour tout \(i\).

Pour \(m = 1, \ldots, M\) :

1. Entraîner un apprenant faible \(h_m\) sur \(\mathcal{D}\) pondéré par \(\mathbf{w}^{(m)}\).

2. Calculer l’erreur pondérée :

   \[\varepsilon_m = \sum_{i=1}^n w_i^{(m)} \mathbb{1}[h_m(\mathbf{x}_i) \neq y_i]\]

3. Calculer le coefficient du modèle :

   \[\alpha_m = \frac{1}{2} \ln\left(\frac{1 - \varepsilon_m}{\varepsilon_m}\right)\]

4. Mettre à jour les poids :

   \[w_i^{(m+1)} = \frac{w_i^{(m)} \exp\left(-\alpha_m y_i h_m(\mathbf{x}_i)\right)}{Z_m}\]

   où \(Z_m\) est un facteur de normalisation tel que \(\sum_i w_i^{(m+1)} = 1\).

Prédiction : \(H(\mathbf{x}) = \text{sign}\left(\sum_{m=1}^M \alpha_m h_m(\mathbf{x})\right)\)

Remarque 100

Le coefficient \(\alpha_m\) est d’autant plus grand que l’erreur \(\varepsilon_m\) est faible. Un classifieur parfait (\(\varepsilon_m = 0\)) reçoit un poids infini ; un classifieur aléatoire (\(\varepsilon_m = 0{,}5\)) reçoit un poids nul. Si \(\varepsilon_m > 0{,}5\), l’algorithme s’arrête (le classifieur est pire que le hasard).

La mise à jour des poids augmente le poids des exemples mal classés (car \(y_i h_m(\mathbf{x}_i) = -1\) pour un exemple mal classé, donc \(\exp(-\alpha_m \cdot (-1)) = \exp(\alpha_m) > 1\)) et diminue celui des exemples bien classés. Ainsi, le prochain classifieur se concentre sur les exemples difficiles.

Proposition 24 (Borne sur l’erreur d’entraînement d’AdaBoost)

L’erreur d’entraînement de l’ensemble AdaBoost après \(M\) itérations est bornée par

\[\frac{1}{n} \sum_{i=1}^n \mathbb{1}[H(\mathbf{x}_i) \neq y_i] \leq \prod_{m=1}^M 2\sqrt{\varepsilon_m(1 - \varepsilon_m)}\]

Si chaque classifieur faible atteint \(\varepsilon_m \leq 1/2 - \gamma\) pour un \(\gamma > 0\), alors l’erreur d’entraînement décroît exponentiellement en \(\exp(-2M\gamma^2)\).

Show code cell source

Hide code cell source

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score, learning_curve
import numpy as np
import matplotlib.pyplot as plt

X, y = make_classification(n_samples=500, n_features=20,
                            n_informative=10, random_state=42)

ada = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=200,
    learning_rate=0.5,
    random_state=42,
)

scores = cross_val_score(ada, X, y, cv=10, scoring='accuracy')
print(f"AdaBoost — Accuracy : {scores.mean():.3f} (+/- {scores.std():.3f})")

# Erreur en fonction du nombre d'estimateurs
ada.fit(X, y)
staged_scores = [np.mean(y == pred) for pred in ada.staged_predict(X)]

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(range(1, len(staged_scores) + 1), staged_scores, color='darkorange')
ax.set_xlabel("Nombre d'estimateurs")
ax.set_ylabel("Accuracy (entraînement)")
ax.set_title("AdaBoost — Convergence de l'accuracy")
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

AdaBoost — Accuracy : 0.800 (+/- 0.044)

Gradient Boosting

Descente de gradient dans l’espace des fonctions

Le Gradient Boosting, formalisé par Friedman en 2001, généralise le boosting à n’importe quelle fonction de perte différentiable. Au lieu de manipuler des poids sur les exemples comme AdaBoost, il ajuste chaque nouveau modèle sur les résidus négatifs du gradient de la fonction de perte.

Définition 107 (Gradient Boosting)

Soit \(L(y, F(\mathbf{x}))\) une fonction de perte différentiable. Le Gradient Boosting construit un modèle additif \(F_M(\mathbf{x}) = \sum_{m=0}^M \eta \cdot h_m(\mathbf{x})\) comme suit :

Initialisation : \(F_0(\mathbf{x}) = \arg\min_c \sum_{i=1}^n L(y_i, c)\)

Pour \(m = 1, \ldots, M\) :

1. Calculer les pseudo-résidus (gradient négatif) :

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

2. Ajuster un modèle de base \(h_m\) sur les pseudo-résidus : \(h_m \leftarrow \text{fit}(\mathbf{X}, \mathbf{r}_m)\).

3. Mettre à jour :

   \[F_m(\mathbf{x}) = F_{m-1}(\mathbf{x}) + \eta \cdot h_m(\mathbf{x})\]

   où \(\eta \in (0, 1]\) est le taux d’apprentissage (learning rate).

Remarque 101

L’interprétation est élégante : à chaque itération, on effectue un pas de descente de gradient, non pas dans l’espace des paramètres comme d’habitude, mais dans l”espace des fonctions. Le pseudo-résidu \(r_{im}\) indique la direction dans laquelle la prédiction pour \(\mathbf{x}_i\) devrait être ajustée pour réduire la perte. Le nouveau modèle \(h_m\) approxime cette direction.

Fonctions de perte

Définition 108 (Fonctions de perte courantes)

Tâche	Nom	\(L(y, F)\)	Pseudo-résidu \(r_i\)
Régression	Erreur quadratique	\(\frac{1}{2}(y - F)^2\)	\(y_i - F(\mathbf{x}_i)\)
Régression	Erreur absolue	\(\lvert y - F \rvert\)	\(\text{sign}(y_i - F(\mathbf{x}_i))\)
Régression	Huber	Quadratique si \(\lvert r \rvert \leq \delta\), linéaire sinon	Hybride
Classification	Log-loss (binaire)	\(\ln(1 + e^{-yF})\)	\(y_i - \sigma(F(\mathbf{x}_i))\)

Pour la perte quadratique, les pseudo-résidus sont simplement les résidus ordinaires \(y_i - F_{m-1}(\mathbf{x}_i)\), ce qui donne une interprétation intuitive : chaque arbre prédit les erreurs des arbres précédents.

Remarque 102

Le taux d’apprentissage \(\eta\) (typiquement 0,01 à 0,3) joue un rôle de régularisation : un \(\eta\) faible nécessite plus d’arbres mais réduit l’overfitting. Il existe un compromis entre \(\eta\) et \(M\) : diminuer \(\eta\) d’un facteur 10 nécessite environ 10 fois plus d’arbres pour atteindre la même performance. En pratique, on fixe \(\eta\) petit et on utilise un early stopping pour déterminer \(M\).

Show code cell source

Hide code cell source

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = make_classification(n_samples=500, n_features=20,
                            n_informative=10, random_state=42)

gb = GradientBoostingClassifier(
    n_estimators=200,
    learning_rate=0.1,
    max_depth=3,
    random_state=42,
)

scores = cross_val_score(gb, X, y, cv=10, scoring='accuracy')
print(f"Gradient Boosting — Accuracy : {scores.mean():.3f} (+/- {scores.std():.3f})")

# Visualisation de la convergence
gb.fit(X, y)

train_scores = [np.mean(y == pred) for pred in gb.staged_predict(X)]

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(range(1, len(train_scores) + 1), train_scores, label='Entraînement',
        color='steelblue')
ax.set_xlabel("Nombre d'estimateurs")
ax.set_ylabel("Accuracy")
ax.set_title("Gradient Boosting — Convergence")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Gradient Boosting — Accuracy : 0.898 (+/- 0.060)

Régularisation du Gradient Boosting

Proposition 25 (Techniques de régularisation)

Le Gradient Boosting dispose de plusieurs leviers de régularisation :

1. Taux d’apprentissage \(\eta\) : réduit la contribution de chaque arbre.

2. Sous-échantillonnage (subsample) : chaque arbre est entraîné sur une fraction \(s < 1\) des données (sans remise). On parle alors de Stochastic Gradient Boosting.

3. Profondeur maximale (max_depth) : limite la complexité de chaque arbre (typiquement 3 à 8).

4. Nombre minimal d’exemples par feuille (min_samples_leaf).

5. Early stopping : arrêter l’entraînement lorsque la performance sur un jeu de validation cesse de s’améliorer.

XGBoost et LightGBM

Les implémentations industrielles du gradient boosting ont considérablement amélioré la vitesse et les performances par rapport à l’implémentation de base de Scikit-learn.

XGBoost

Définition 109 (XGBoost)

XGBoost (eXtreme Gradient Boosting, Chen & Guestrin, 2016) est une implémentation optimisée du gradient boosting qui introduit :

1. Régularisation L1 et L2 sur les poids des feuilles :

   \[\Omega(h) = \gamma T + \frac{1}{2}\lambda \sum_{j=1}^T w_j^2 + \alpha \sum_{j=1}^T |w_j|\]

   où \(T\) est le nombre de feuilles et \(w_j\) est le poids de la feuille \(j\).

2. Approximation de Taylor au second ordre de la fonction de perte, utilisant à la fois le gradient \(g_i\) et le hessien \(h_i\) pour un choix de split plus précis.

3. Algorithme de split approché (approximate greedy algorithm) basé sur des quantiles pondérés, réduisant la complexité de \(O(n \cdot p)\) à \(O(n \cdot q)\) où \(q \ll n\) est le nombre de candidats.

4. Gestion native des valeurs manquantes : l’algorithme apprend automatiquement la direction optimale pour les valeurs manquantes à chaque noeud.

LightGBM

Définition 110 (LightGBM)

LightGBM (Light Gradient Boosting Machine, Ke et al., 2017) introduit deux innovations majeures :

1. GOSS (Gradient-based One-Side Sampling) : échantillonnage conservant tous les exemples à fort gradient (mal prédits) et sous-échantillonnant les exemples à faible gradient. Cela accélère l’entraînement sans perte significative de performance.

2. EFB (Exclusive Feature Bundling) : regroupement des features mutuellement exclusives (rarement non nulles simultanément) pour réduire la dimensionnalité effective.

3. Croissance par feuille (leaf-wise) au lieu de la croissance par niveau (level-wise) : LightGBM développe la feuille qui réduit le plus la perte, ce qui produit des arbres asymétriques mais plus efficaces.

Remarque 103

En résumé, les différences principales sont :

Aspect	XGBoost	LightGBM
Stratégie de croissance	Par niveau (défaut)	Par feuille
Vitesse	Rapide	Très rapide
Gestion des catégorielles	Nécessite encodage	Support natif
Parallélisme	Par feature	Par données
Mémoire	Modérée	Faible

En pratique, LightGBM est souvent préféré pour les grands jeux de données en raison de sa vitesse supérieure. XGBoost reste un choix solide et très populaire, notamment dans les compétitions Kaggle.

Show code cell source

Hide code cell source

from sklearn.ensemble import GradientBoostingClassifier, HistGradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = make_classification(n_samples=1000, n_features=20,
                            n_informative=10, random_state=42)

# HistGradientBoosting (inspiré de LightGBM, intégré à sklearn)
hgb = HistGradientBoostingClassifier(
    max_iter=200,
    learning_rate=0.1,
    max_depth=6,
    random_state=42,
)

scores_hgb = cross_val_score(hgb, X, y, cv=10, scoring='accuracy')
print(f"HistGradientBoosting — Accuracy : {scores_hgb.mean():.3f} (+/- {scores_hgb.std():.3f})")

HistGradientBoosting — Accuracy : 0.938 (+/- 0.027)

Remarque 104

Scikit-learn propose HistGradientBoostingClassifier et HistGradientBoostingRegressor, directement inspirés de LightGBM. Ces estimateurs utilisent des histogrammes pour discrétiser les features, ce qui les rend bien plus rapides que GradientBoostingClassifier sur les grands jeux de données (\(n > 10\,000\)). Ils supportent également les valeurs manquantes nativement.

Show code cell source

Hide code cell source

# Si xgboost et lightgbm sont installés, on peut les comparer directement
try:
    import xgboost as xgb
    import lightgbm as lgb

    xgb_clf = xgb.XGBClassifier(
        n_estimators=200, learning_rate=0.1, max_depth=6,
        eval_metric='logloss', random_state=42,
    )
    lgb_clf = lgb.LGBMClassifier(
        n_estimators=200, learning_rate=0.1, max_depth=6,
        random_state=42, verbose=-1,
    )

    import pandas as pd
    X_df = pd.DataFrame(X, columns=[f"f{i}" for i in range(X.shape[1])])

    scores_xgb = cross_val_score(xgb_clf, X_df, y, cv=10, scoring='accuracy')
    scores_lgb = cross_val_score(lgb_clf, X_df, y, cv=10, scoring='accuracy')

    print(f"XGBoost  — Accuracy : {scores_xgb.mean():.3f} (+/- {scores_xgb.std():.3f})")
    print(f"LightGBM — Accuracy : {scores_lgb.mean():.3f} (+/- {scores_lgb.std():.3f})")
except ImportError:
    print("xgboost et/ou lightgbm non installé(s). "
          "Installer avec : pip install xgboost lightgbm")

XGBoost  — Accuracy : 0.931 (+/- 0.028)
LightGBM — Accuracy : 0.936 (+/- 0.031)

Stacking

Principe du méta-apprentissage

Le stacking (stacked generalization), introduit par Wolpert en 1992, combine des modèles hétérogènes à l’aide d’un méta-modèle qui apprend à optimiser la combinaison.

Définition 111 (Stacking)

Le stacking à deux niveaux procède comme suit :

Niveau 0 (modèles de base) : Soit \(h_1, \ldots, h_M\) des modèles de base de types éventuellement différents. On obtient les prédictions de chaque modèle par validation croisée :

\[\hat{y}_i^{(m)} = h_m^{(-i)}(\mathbf{x}_i) \quad \text{pour } i = 1, \ldots, n\]

où \(h_m^{(-i)}\) désigne le modèle \(h_m\) entraîné sur les données excluant \(\mathbf{x}_i\) (en pratique, via \(k\)-fold CV).

Niveau 1 (méta-modèle) : On construit une matrice de méta-features \(\mathbf{Z} \in \mathbb{R}^{n \times M}\) où \(Z_{im} = \hat{y}_i^{(m)}\), puis on entraîne un méta-modèle \(g\) :

\[H(\mathbf{x}) = g\big(\hat{y}^{(1)}(\mathbf{x}), \ldots, \hat{y}^{(M)}(\mathbf{x})\big)\]

Le méta-modèle apprend les forces et faiblesses de chaque modèle de base et pondère leurs contributions de manière optimale.

Remarque 105

Il est crucial que les prédictions du niveau 0 soient obtenues par validation croisée et non par prédiction sur les données d’entraînement, sinon le méta-modèle apprend simplement à faire confiance aux modèles qui surapprennent le plus. Le méta-modèle est généralement un modèle simple (régression logistique, régression linéaire) pour éviter le surajustement au niveau 1.

Show code cell source

Hide code cell source

from sklearn.ensemble import (RandomForestClassifier, GradientBoostingClassifier,
                               StackingClassifier)
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

X, y = make_classification(n_samples=500, n_features=20,
                            n_informative=10, random_state=42)

# Modèles de base
estimators = [
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42)),
    ('svc', SVC(probability=True, random_state=42)),
]

# Stacking avec méta-modèle logistique
stacking = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(max_iter=1000),
    cv=5,
)

scores_stack = cross_val_score(stacking, X, y, cv=5, scoring='accuracy')
print(f"Stacking — Accuracy : {scores_stack.mean():.3f} (+/- {scores_stack.std():.3f})")

# Comparaison avec les modèles individuels
for name, est in estimators:
    s = cross_val_score(est, X, y, cv=5, scoring='accuracy')
    print(f"  {name:>4s}   — Accuracy : {s.mean():.3f} (+/- {s.std():.3f})")

Stacking — Accuracy : 0.930 (+/- 0.028)

    rf   — Accuracy : 0.882 (+/- 0.031)

    gb   — Accuracy : 0.888 (+/- 0.044)
   svc   — Accuracy : 0.936 (+/- 0.027)

Comparaison pratique

Quand utiliser quoi ?

Proposition 26 (Guide de choix des méthodes d’ensemble)

Méthode	Forces	Faiblesses	Usage typique
Bagging	Réduit la variance, parallélisable	Ne réduit pas le biais	Modèles instables (arbres profonds)
Random Forest	Robuste, peu d’hyperparamètres, OOB	Moins performant que le boosting sur données tabulaires	Référence (baseline) solide
AdaBoost	Simple, borne théorique	Sensible au bruit, pas de contrôle de la perte	Classification binaire
Gradient Boosting	Flexible (choix de la perte), performant	Lent, séquentiel, hyperparamètres à régler	Données tabulaires, compétitions
XGBoost / LightGBM	Très rapide, régularisé, gère les NaN	Plus d’hyperparamètres	Production, grands jeux de données
Stacking	Combine des modèles hétérogènes	Coûteux, risque d’overfitting	Compétitions, derniers % de performance

Comparaison sur un jeu de données

Show code cell source

Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import (BaggingClassifier, RandomForestClassifier,
                               AdaBoostClassifier, GradientBoostingClassifier,
                               HistGradientBoostingClassifier,
                               StackingClassifier)
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
import time

# Jeu de données
X, y = make_classification(n_samples=300, n_features=20,
                            n_informative=10, n_redundant=5,
                            random_state=42)

# Modèles à comparer
models = {
    'Arbre seul': DecisionTreeClassifier(random_state=42),
    'Bagging': BaggingClassifier(n_estimators=30, random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=30, random_state=42),
    'AdaBoost': AdaBoostClassifier(n_estimators=30, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(n_estimators=30, random_state=42),
    'HistGradientBoosting': HistGradientBoostingClassifier(max_iter=30, random_state=42),
}

results = {}
for name, model in models.items():
    t0 = time.time()
    scores = cross_val_score(model, X, y, cv=3, scoring='accuracy')
    elapsed = time.time() - t0
    results[name] = {
        'mean': scores.mean(),
        'std': scores.std(),
        'time': elapsed,
    }
    print(f"{name:>25s} — Accuracy : {scores.mean():.3f} "
          f"(+/- {scores.std():.3f}) [{elapsed:.2f}s]")

               Arbre seul — Accuracy : 0.743 (+/- 0.029) [0.01s]

                  Bagging — Accuracy : 0.830 (+/- 0.041) [0.22s]
            Random Forest — Accuracy : 0.843 (+/- 0.026) [0.13s]

                 AdaBoost — Accuracy : 0.837 (+/- 0.009) [0.15s]
        Gradient Boosting — Accuracy : 0.823 (+/- 0.056) [0.15s]

     HistGradientBoosting — Accuracy : 0.847 (+/- 0.025) [0.12s]

Show code cell source

Hide code cell source

# Visualisation comparative
names = list(results.keys())
means = [results[n]['mean'] for n in names]
stds = [results[n]['std'] for n in names]

fig, ax = plt.subplots(figsize=(10, 5))
colors = ['#d62728', '#1f77b4', '#2ca02c', '#ff7f0e', '#9467bd', '#8c564b']
bars = ax.barh(range(len(names)), means, xerr=stds, color=colors,
               edgecolor='black', capsize=3)
ax.set_yticks(range(len(names)))
ax.set_yticklabels(names)
ax.set_xlabel('Accuracy (validation croisée)')
ax.set_title('Comparaison des méthodes d\'ensemble')
ax.set_xlim(0.75, 1.0)
ax.grid(True, axis='x', alpha=0.3)

for i, (m, s) in enumerate(zip(means, stds)):
    ax.text(m + s + 0.005, i, f'{m:.3f}', va='center', fontsize=9)

plt.tight_layout()
plt.show()

Show code cell source

Hide code cell source

# Feature importances comparées : Random Forest vs Gradient Boosting
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
import numpy as np
import matplotlib.pyplot as plt

X, y = make_classification(n_samples=1000, n_features=15,
                            n_informative=5, n_redundant=3,
                            random_state=42)
feature_names = [f"x{i}" for i in range(X.shape[1])]

rf = RandomForestClassifier(n_estimators=200, random_state=42)
gb = GradientBoostingClassifier(n_estimators=200, random_state=42)

rf.fit(X, y)
gb.fit(X, y)

fig, axes = plt.subplots(2, 1, figsize=(9, 9))

for ax, model, title in zip(axes, [rf, gb], ['Random Forest', 'Gradient Boosting']):
    importances = model.feature_importances_
    indices = np.argsort(importances)[::-1]
    ax.bar(range(len(importances)), importances[indices],
           color='steelblue', edgecolor='black')
    ax.set_xticks(range(len(importances)))
    ax.set_xticklabels([feature_names[i] for i in indices], rotation=45)
    ax.set_title(f'Importance des features — {title}')
    ax.set_ylabel('Importance (MDI)')

plt.tight_layout()
plt.show()

Résumé

Les méthodes d’ensemble sont parmi les outils les plus puissants de l’apprentissage automatique. Elles reposent sur le principe fondamental que la combinaison de modèles diversifiés surpasse les modèles individuels.

Famille	Principe	Réduit	Exemples
Bagging	Moyennage de modèles entraînés sur des bootstraps	Variance	Random Forest
Boosting	Correction séquentielle des erreurs	Biais	AdaBoost, Gradient Boosting, XGBoost, LightGBM
Stacking	Méta-modèle sur les prédictions de base	Biais + Variance	StackingClassifier

Remarque 106

Sur les données tabulaires, les méthodes de gradient boosting (XGBoost, LightGBM, CatBoost) dominent les benchmarks et les compétitions depuis des années. La forêt aléatoire reste un excellent choix par défaut en raison de sa robustesse et de sa simplicité. Le stacking permet de grappiller les derniers points de performance, au prix d’une complexité accrue. Enfin, il est crucial de rappeler que le choix du modèle importe souvent moins que la qualité des données et du prétraitement : un gradient boosting sur des features mal construites sera surpassé par un simple arbre sur des features bien conçues.