Plusieurs modèles différents prédisent la même chose, puis un dernier modèle apprend à combiner leurs prédictions. Le méta-modèle découvre à quel modèle se fier et dans quelle mesure. C'est la technique des compétitions de data science pour gagner les derniers points de performance.
Un directeur commercial consulte trois analystes avant chaque prévision. Avec le temps, il apprend que l'un est fiable sur les petits clients, l'autre sur les grands comptes, et pondère leurs avis en conséquence.
Par exemple une régression logistique, une Random Forest et un boosting. Ils doivent être différents : trois modèles qui font les mêmes erreurs n'apportent rien à combiner.
Par validation croisée, chaque client reçoit une prédiction de chaque modèle faite sans l'avoir vu. Sans cette précaution, le méta-modèle apprendrait à faire confiance au modèle qui a le mieux récité ses données d'entraînement.
Une régression logistique, en général, prend ces prédictions en entrée et la vraie réponse en sortie. Ses coefficients disent quel poids donner à chaque modèle de base.
Les données clients habituelles : ancienneté, appels au support, montant, contrat, incidents. L'équipe dispose déjà d'une régression logistique, d'une forêt aléatoire et d'un boosting, qui ne classent pas les clients tout à fait de la même façon.
Chaque client reçoit une probabilité de départ issue du méta-modèle. Ses poids indiquent la contribution de chaque modèle : dans la version Python, la logistique et le boosting pèsent plus que la forêt.
Sur le jeu d'exemple, l'AUC du stacking (0,759) égale à peine la régression logistique seule (0,758). Un gain de cette taille ne justifie pas trois modèles à maintenir. Le stacking paie quand les modèles de base sont bons et vraiment différents.
Le stacking a peu de paramètres propres, mais chaque choix de conception pèse. Noms donnés pour R (SuperLearner) et Python (StackingClassifier).
Les modèles de base. Mieux vaut trois modèles de natures différentes (linéaire, forêt, boosting) que cinq variantes du même. En R, chaque modèle est une fonction « SL.* » ; create.Learner en crée des variantes réglées.
Le nombre de plis de la validation croisée qui produit les prédictions hors échantillon, 5 en général. C'est la garantie que le méta-modèle ne voit pas des prédictions trop optimistes.
Le méta-modèle. SuperLearner calcule par défaut des poids positifs qui somment à 1 (méthode NNLS). scikit-learn utilise par défaut une régression logistique. Un méta-modèle simple limite le surapprentissage.
Donne aussi les variables d'origine au méta-modèle, en plus des prédictions. Rarement utile, sauf si l'efficacité de chaque modèle dépend clairement d'un segment de clients.
# Churn clients : Stacking en R
library(SuperLearner)
clients <- read.csv("clients_churn.csv")
X <- data.frame(model.matrix(~ anciennete + appels_support + montant + contrat + incidents_3m,
data = clients)[, -1])
y <- clients$churn
set.seed(42)
idx <- sample(nrow(X), round(0.7 * nrow(X)))
# Boosting raccourci : 500 arbres au lieu des 10 000 prévus par défaut dans SL.gbm
gbm_court <- create.Learner("SL.gbm", params = list(gbm.trees = 500, shrinkage = 0.05))
# Trois modèles de base ; leurs poids sont appris sur des prédictions hors échantillon (5 plis)
sl <- SuperLearner(Y = y[idx], X = X[idx, ], family = binomial(),
SL.library = c("SL.glm", "SL.ranger", gbm_court$names), cvControl = list(V = 5))
print(sl) # risque en validation croisée et poids de chaque modèle
# AUC sur les clients jamais vus (formule des rangs) : chaque modèle, puis la combinaison
pred <- predict(sl, X[-idx, ])
auc <- function(p, yy) (sum(rank(p)[yy == 1]) - sum(yy == 1) * (sum(yy == 1) + 1) / 2) /
(sum(yy == 1) * sum(yy == 0))
print(round(apply(pred$library.predict, 2, auc, yy = y[-idx]), 3))
cat("AUC stacking :", round(auc(pred$pred[, 1], y[-idx]), 3), "\n")# Churn clients : Stacking en Python
import pandas as pd
from sklearn.ensemble import StackingClassifier, RandomForestClassifier, HistGradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
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"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
# Trois modèles de base, de natures différentes
base = [("logit", make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))),
("foret", RandomForestClassifier(n_estimators=300, min_samples_leaf=5, random_state=42)),
("boosting", HistGradientBoostingClassifier(learning_rate=0.05, max_depth=3, random_state=42))]
# Le méta-modèle apprend sur des prédictions hors échantillon (validation croisée à 5 plis)
stack = StackingClassifier(estimators=base, final_estimator=LogisticRegression(), cv=5)
stack.fit(X_train, y_train)
# AUC sur les clients jamais vus : chaque modèle seul, puis la combinaison
for nom, modele in stack.named_estimators_.items():
print(nom, round(roc_auc_score(y_test, modele.predict_proba(X_test)[:, 1]), 3))
print("stacking", round(roc_auc_score(y_test, stack.predict_proba(X_test)[:, 1]), 3))
print(pd.Series(stack.final_estimator_.coef_[0], index=list(stack.named_estimators_)).round(2))Le bagging entraîne le même modèle sur des tirages différents et fait la moyenne. Le boosting enchaîne des modèles qui corrigent les erreurs des précédents. Le stacking combine des modèles de natures différentes grâce à un méta-modèle entraîné sur leurs prédictions.
Si le méta-modèle apprend sur des prédictions faites sur les données d'entraînement, il favorise le modèle qui les a le mieux mémorisées, souvent une forêt très profonde. La validation croisée produit pour chaque ligne une prédiction faite sans l'avoir vue, comme en production.
Rarement comme premier réflexe. Le gain est souvent de quelques millièmes d'AUC, pour plusieurs modèles à surveiller et réentraîner. Il se justifie quand ce gain a une valeur chiffrée claire, par exemple sur un score qui pilote des millions d'euros de décisions.
Fait voter les modèles à égalité, sans méta-modèle. Moins de risque de surapprentissage, souvent presque aussi bon.
Voir la fiche → l'ingrédient cléC'est elle qui fournit des prédictions honnêtes au méta-modèle. Sans elle, le stacking surapprend.
Voir la fiche → le méta-modèle usuelSouvent utilisée au second étage : ses coefficients se lisent comme des poids donnés à chaque modèle.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus