Stacking : Empilement de Modèles pour des Prédictions Supérieures

Résumé

Le Stacking (ou Staked Generalization, aussi appelé empilement de modèles) est une technique d’apprentissage ensembliste avancée qui combine les prédictions de plusieurs modèles de base (appelés modèles de niveau zéro) à l’aide d’un méta-modèle (ou modèle de niveau un). Contrairement au Bagging qui utilise le même algorithme sur des sous-échantillons, ou au Boosting qui corrige séquentiellement les erreurs, le Stacking exploite la diversité algorithmique : chaque modèle de base apprend à sa manière, et le méta-modèle apprend à pondérer intelligemment leurs contributions. Cette approche atteint souvent des performances supérieures à n’importe quel modèle individuel, au prix d’une complexité computationnelle accrue.

Principe Mathématique du Stacking

Le Stacking fonctionne en deux niveaux hiérarchiques distincts, chacun ayant un rôle précis dans la chaîne de prédiction.

Niveau 0 : K Modèles de Base

Supposons que nous disposions d’un jeu d’entraînement $\mathcal{D} = {(x_i, y_i)}_{i=1}^{n}$ avec $n$ observations. Nous sélectionnons $K$ modèles de base différents :

$$h_1, h_2, …, h_K$$

Chaque modèle $h_k$ est un algorithme distinct — par exemple une Forêt Aléatoire, une SVM, une Régression Logistique, un Naive Bayes, ou un Gradient Boosting. Chaque modèle est entraîné (potentiellement avec des hyperparamètres différents) sur l’ensemble d’entraînement.

Le point crucial du Stacking est que les prédictions hors-échantillon (out-of-fold) de chaque modèle sont utilisées pour construire un nouveau jeu de données de niveau 1. Cela évite le surapprentissage qui se produirait si on utilisait les prédictions sur les données d’entraînement elles-mêmes.

Validation Croisée pour les Prédictions Out-of-Fold

Pour construire les méta-features sans fuite de données, on procède ainsi :

1. On divise $\mathcal{D}$ en $J$ plis (folds) $\mathcal{F}_1, \mathcal{F}_2, …, \mathcal{F}_J$.
2. Pour chaque pli $j$ et chaque modèle $h_k$ :
   – On entraîne $h_k$ sur $\mathcal{D} \setminus \mathcal{F}_j$ (toutes les données sauf le pli $j$).
   – On prédit sur $\mathcal{F}_j$ uniquement.
3. On concatène toutes les prédictions hors-échantillon pour former les méta-features.

Mathématiquement, pour chaque observation $x_i$, on obtient un vecteur de méta-features :

$$z_i = [h_1^{-i}(x_i), h_2^{-i}(x_i), …, h_K^{-i}(x_i)]$$

où $h_k^{-i}$ désigne le modèle $h_k$ entraîné sans l’observation $i$. Ce vecteur $z_i \in \mathbb{R}^K$ capture la manière dont chaque modèle de base a vu l’observation $x_i$.

Niveau 1 : Le Méta-Modèle

Le méta-modèle $g$ est ensuite entraîné sur l’ensemble transformé ${(z_i, y_i)}_{i=1}^{n}$ :

$$\hat{y} = g(z_i) = g(h_1^{-i}(x_i), h_2^{-i}(x_i), …, h_K^{-i}(x_i))$$

Le rôle du méta-modèle est d’apprendre la combinaison optimale des prédictions des modèles de base. Il découvre que dans certaines régions de l’espace, le modèle $h_1$ est plus fiable, tandis qu’ailleurs c’est $h_2$ qui performe le mieux. Cette pondération adaptative est bien plus puissante qu’une simple moyenne ou une pondération fixe.

En classification, les méta-features peuvent être soit les étiquettes prédites (discrètes), soit les probabilités prédites (continues). Utiliser les probabilités est généralement plus informatif, car le méta-modèle dispose alors d’une mesure de confiance pour chaque prédiction.

En Prédiction

Lors de la phase de test, une nouvelle observation $x_{\text{new}}$ traverse d’abord tous les modèles de base :

$$z_{\text{new}} = [h_1(x_{\text{new}}), h_2(x_{\text{new}}), …, h_K(x_{\text{new}})]$$

Puis le méta-modèle produit la prédiction finale :

$$\hat{y}{\text{new}} = g(z)$$}

Intuition : Le Jury d’un Télé-Crochet

Imaginez un jury de télé-crochet musical, avec plusieurs juges aux profils très différents. Chaque juge évalue les candidats selon ses propres critères :

• Le juge musicien classique (notre Forêt Aléatoire) : il note la technique, la justesse vocale, la maîtrise du rythme. Il est excellent pour évaluer la solidité technique mais parfois trop rigide.
• Le juge auteur-compositeur (notre SVM à noyau RBF) : il est sensible aux subtilités, aux nuances, à l’originalité. Il détecte des patterns complexes que d’autres manquent, mais peut être capricieux sur des données trop bruyantes.
• Le juge producteur de hits (notre Naive Bayes) : il va droit au but, se concentre sur quelques indicateurs clés. Parfois simpliste, mais étonnamment efficace et rapide.

Maintenant, imaginez un chef du jury (notre Régression Logistique en tant que méta-modèle). Ce chef n’écoute pas les candidats directement — il regarde les notes des trois juges et apprend d’expérience :

• « Quand le juge classique donne 8/10 et le compositeur 9/10, c’est presque toujours un excellent candidat. »
• « Le producteur se trompe souvent quand le compositeur est très enthousiaste mais que le classique est mitigé. »
• « Si les trois sont d’accord, je suis confiant à 95 %. »

C’est exactement cela, le Stacking : le méta-modèle n’est pas un simple calculateur de moyenne. C’est un stratège qui apprend les forces et faiblesses de chaque modèle et compose avec intelligence pour prendre la meilleure décision possible.

Implémentation Python avec Scikit-Learn

Scikit-learn fournit StackingClassifier (pour la classification) et StackingRegressor (pour la régression) depuis la version 0.22. Voici une implémentation complète et commentée.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_classification
from sklearn.ensemble import (
    RandomForestClassifier,
    StackingClassifier,
    VotingClassifier,
)
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

# 1. Génération du jeu de données synthétique
X, y = make_classification(
    n_samples=5000,
    n_features=20,
    n_informative=15,
    n_redundant=3,
    n_classes=2,
    random_state=42,
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 2. Définition des modèles de base (niveau 0)
estimators = [
    (
        "rf",
        RandomForestClassifier(n_estimators=200, max_depth=12, random_state=42),
    ),
    (
        "svm",
        make_pipeline(StandardScaler(), SVC(probability=True, random_state=42)),
    ),
    ("nb", GaussianNB()),
]

# 3. Création du StackingClassifier
stacking_clf = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(max_iter=1000, random_state=42),
    cv=5,  # Validation croisée à 5 plis pour les prédictions out-of-fold
    n_jobs=-1,  # Parallélisation sur tous les cœurs
    passthrough=False,  # On n'ajoute pas les features d'origine au méta-modèle
)

# 4. Entraînement et évaluation
stacking_clf.fit(X_train, y_train)
y_pred = stacking_clf.predict(X_test)

print("=== Stacking Classifier ===")
print(f"Précision test : {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred))

# 5. Comparaison avec les modèles individuels
print("\n=== Comparaison des modèles individuels ===")
for name, estimator in estimators:
    estimator.fit(X_train, y_train)
    y_pred_i = estimator.predict(X_test)
    acc_i = accuracy_score(y_test, y_pred_i)
    print(f"{name}: {acc_i:.4f}")

# 6. Validation croisée
cv_scores = cross_val_score(stacking_clf, X_train, y_train, cv=5, scoring="accuracy")
print(f"\nValidation croisée 5 plis : {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

# 7. Analyse des poids du méta-modèle
meta_weights = stacking_clf.final_estimator_.coef_[0]
for (name, _), weight in zip(estimators, meta_weights):
    print(f"Poids du méta-modèle pour {name}: {weight:.4f}")

Comparaison des Approches Ensemblistes

Il est instructif de comparer le Stacking avec deux autres techniques ensemblistes populaires :

# VotingClassifier (moyenne pondérée simple)
voting_clf = VotingClassifier(
    estimators=estimators, voting="soft"  # soft = moyenne des probabilités
)

# Comparaison complète
modeles = {
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=42),
    "Voting (Soft)": voting_clf,
    "Stacking": stacking_clf,
}

for nom, modele in modeles.items():
    scores = cross_val_score(modele, X, y, cv=5, scoring="accuracy")
    print(f"{nom}: {scores.mean():.4f} (+/- {scores.std():.4f})")

En général, le Stacking surpasse le Voting car il apprend des pondérations adaptatives au lieu d’utiliser une moyenne fixe. Et il surpasse souvent les modèles individuels car il exploite la complémentarité entre algorithmes.

Hyperparamètres Clés du StackingClassifier

La configuration du Stacking est cruciale pour obtenir de bonnes performances. Voici les hyperparamètres principaux à maîtriser.

estimators

C’est la liste des modèles de base (niveau 0). Le choix de ces modèles est le facteur le plus important :

• Diversité avant tout : utilisez des algorithmes fondamentalement différents (arbres, modèles linéaires, SVM, Bayésien). Trois Random Forest différentes n’apporteront pas beaucoup plus de valeur qu’une seule.
• Qualité minimale : chaque modèle doit être au moins raisonnablement performant. Un modèle catastrophique peut nuire au méta-modèle.
• 3 à 7 modèles est un bon intervalle. Trop peu = pas assez de diversité. Trop beaucoup = risque de surapprentissage et explosion computationnelle.

final_estimator

Le méta-modèle (niveau 1). Par défaut, c’est LogisticRegression, et c’est généralement un excellent choix :

• Logistic Regression : simple, interprétable, rapide. Ses coefficients révèlent l’importance relative de chaque modèle de base.
• Linear Regression : alternative en régression.
• Random Forest ou Gradient Boosting comme méta-modèle : possible pour capturer des interactions non-linéaires entre les prédictions, mais attention au surapprentissage.
• La règle pratique : un méta-modèle simple suffit souvent. Si les modèles de base sont déjà complexes, un méta-modèle complexe risque de surapprendre sur leurs prédictions.

cv

Le nombre de plis de validation croisée pour générer les prédictions out-of-fold :

• cv=5 : bon compromis par défaut.
• cv=10 : plus robuste mais plus lent.
• cv=3 : plus rapide, utile pour l’exploration initiale.
• Plus le jeu de données est petit, plus il faut de plis pour que chaque modèle de niveau 0 ait suffisamment de données d’entraînement.

n_jobs

Contrôle le parallélisme :

• n_jobs=-1 : utilise tous les cœurs disponibles.
• n_jobs=1 : exécution séquentielle (utile pour le débogage).
• Le Stacking est intrinsèquement parallélisable car les modèles de base sont indépendants.

passthrough

Cet hyperparamètre détermine si les features d’origine sont ajoutées aux méta-features :

• passthrough=False (défaut) : le méta-modèle ne voit que les prédictions des modèles de base.
• passthrough=True : le méta-modèle voit à la fois les prédictions des modèles de base et les features brutes d’origine. Cela peut être utile si les modèles de base ne capturent pas toute l’information, mais augmente le risque de surapprentissage et la dimensionnalité.

Avantages et Limites du Stacking

Avantages

1. Performance supérieure : le Stacking atteint systématiquement des scores plus élevés que les modèles individuels, car il exploite la complémentarité algorithmique. Dans les compétitions Kaggle, les ensembles empilés dominent régulièrement les classements.
2. Robustesse accrue : en combinant des modèles aux biais et variances différents, le Stacking réduit à la fois le biais (grâce à la diversité des algorithmes) et la variance (grâce à l’agrégation). C’est l’un des rares cas où on améliore les deux simultanément.
3. Flexibilité totale : vous pouvez mélanger n’importe quels algorithmes — Random Forest, SVM, réseaux de neurones, Naive Bayes, KNN, XGBoost. Aucune restriction sur la nature des modèles de base.
4. Adaptativité spatiale : contrairement au Voting qui pondère de manière uniforme, le méta-modèle apprend que tel modèle est meilleur dans telle région de l’espace des features. C’est une intelligence de second ordre.
5. Interprétabilité partielle : les coefficients du méta-modèle (s’il s’agit d’un modèle linéaire) renseignent sur l’importance relative de chaque modèle de base, offrant un aperçu utile sur la dynamique de l’ensemble.

Limites

1. Complexité computationnelle : entraîner $K$ modèles avec validation croisée signifie $K \times J$ entraînements (où $J$ est le nombre de plis). Pour 5 modèles et 5 plis, c’est 25 entraînements. C’est significativement plus lent qu’un modèle unique.
2. Risque de surapprentissage du méta-modèle : si les modèles de base sont trop corrélés ou si le méta-modèle est trop complexe, l’ensemble peut surapprendre. Une validation croisée rigoureuse est indispensable.
3. Difficulté d’interprétation globale : bien que les poids du méta-modèle soient lisibles, comprendre pourquoi l’ensemble a pris une décision spécifique reste complexe — c’est un modèle « boîte noire » de second ordre.
4. Maintenance en production : en production, il faut déployer et maintenir $K+1$ modèles. La latence de prédiction est celle du modèle de base le plus lent, plus celle du méta-modèle.
5. Sensibilité à la qualité des modèles de base : si tous les modèles de base partagent le même biais systémique (par exemple, tous échouent sur les mêmes types d’observations), le Stacking ne pourra pas corriger ce biais.

4 Cas d’Usage Concrets

1. Compétitions de Machine Learning (Kaggle)

Le Stacking est une arme classique des compétitions. Les meilleurs participants construisent souvent des ensembles de 5 à 15 modèles hétérogènes (XGBoost, LightGBM, CatBoost, réseaux de neurones, modèles linéaires régularisés) et les empilent via un méta-modèle. L’idée est simple : chaque algorithme a ses angles morts, et les combiner les comble mutuellement. Les victoires sur les plateformes compétitives reposent fréquemment sur des architectures de Stacking à plusieurs niveaux (meta-stacking où le méta-modèle est lui-même empilé).

2. Diagnostic Médical Assisté

Dans le domaine médical, la fiabilité est primordiale. Un Stacking peut combiner :

• Un modèle basé sur les données tabulaires (bilans sanguins, antécédents)
• Un modèle de vision par ordinateur (analyse de radiographies ou d’IRM)
• Un modèle de traitement du langage (analyse des comptes-rendus médicaux)

Chaque modèle apporte une perspective complémentaire. Le méta-modèle apprend à faire confiance davantage au modèle d’imagerie pour les pathologies visuellement évidentes, et au modèle textuel pour les diagnostics complexes nécessitant une analyse des symptômes décrits. En médecine, ne rien manquer est souvent plus important que maximiser la précision globale — le Stacking permet de configurer le méta-modèle pour favoriser le rappel.

3. Détection de Fraude Financière

La détection de fraude présente un déséquilibre de classes extrême (moins de 1 % de transactions frauduleuses). Un Stacking peut ici combiner :

• Un Isolation Forest pour détecter les anomalies
• Un XGBoost pondéré pour la classification déséquilibrée
• Un réseau de neurones pour capturer des patterns temporels complexes

Le méta-modèle apprend à pondérer dynamiquement ces signaux : quand l’Isolation Forest détecte une anomalie ET que le XGBoost la classe comme fraude, la confiance est maximale. Quand seul le réseau de neurones est alerté, le méta-modèle peut modérer sa réponse. Cette approche réduit les faux positifs tout en maintenant un taux de détection élevé.

4. Prédiction de Churn (Attrition Client)

Les entreprises télécoms et SaaS luttent contre l’attrition. Un Stacking peut assembler :

• Un modèle basé sur l’historique d’utilisation (fréquence, durée, fonctionnalités utilisées)
• Un modèle basé sur le service client (nombre de réclamations, satisfaction, temps de résolution)
• Un modèle basé sur les données démographiques et contractuelles (ancienneté, forfait, prix)

Le méta-modèle découvre des interactions subtiles : par exemple, un client anciennement satisfait qui commence à réduire son utilisation ET a récemment contacté le service client présente un risque très élevé, même si chaque modèle individuellement ne le signale que modérément.

Bonnes Pratiques pour le Stacking

1. Vérifiez la corrélation des erreurs : utilisez une matrice de corrélation des prédictions entre modèles de base. Si deux modèles sont corrélés à plus de 0,9, l’un d’eux est probablement redondant.
2. Commencez simple : débutez avec 3 modèles très différents et une Régression Logistique comme méta-modèle. Ajoutez de la complexité uniquement si les gains le justifient.
3. Gardez un jeu de validation strict : ne réutilisez jamais les données de validation croisée du niveau 0 pour évaluer les performances finales. Prévoyez un jeu de test totalement indépendant.
4. Surveillez le temps d’entraînement : le Stacking peut être très long. Utilisez n_jobs=-1 et considérez des modèles de base rapides si le temps est une contrainte.
5. Envisagez le passthrough=True avec prudence : cela peut améliorer les performances mais augmente significativement la dimensionnalité et le risque de surapprentissage.

Conclusion

Le Stacking représente l’un des sommets de l’apprentissage ensembliste. En empilant intelligemment des modèles hétérogènes via un méta-modèle entraîné sur des prédictions out-of-fold, il exploite la diversité algorithmique pour atteindre des performances souvent inégalées. Bien qu’il soit plus complexe et plus lent qu’un modèle unique, ses gains en précision, robustesse et adaptativité en font un outil indispensable dans la boîte à outils du data scientist.

Que vous prépariez une compétition Kaggle, un système de diagnostic médical, ou un modèle de prédiction de churn, le Stacking offre une méthodologie rigoureuse pour tirer le meilleur de vos algorithmes — et faire en sorte que le tout soit véritablement supérieur à la somme des parties.

Voir Aussi

• Calculer la Surface Minimale d’un Polygone Convexe en Grille avec Python
• Calcul des Sommes des Carrés des Diviseurs Unitaires en Python : Guide Complet et Code Optimisé