Méthodes d'Ensembleintermédiaire

Bagging, Boosting & Stacking

“La sagesse des foules diverses — combiner des modèles imparfaits en quelque chose de plus fort qu'aucun individu”

Explication visuelle de tous les paradigmes d'ensemble — bagging réduit la variance, boosting réduit le biais, stacking combine via méta-apprenant.

45 min

11 diagrammes

6 Concepts Couverts

Prérequis

→Decision Trees

→Gradient Boosting

Concepts Couverts

Variance ReductionBias ReductionAdaBoostSAMMEMeta-learnerOOF Predictions

Précédent: Gradient Boosting : XGBoost, LightGBM, CatBoost Suivant: Classification Multi-classe OvA vs OvO

∑Formules Clés

Biais-Variance de l'Ensemble

La variance de l'ensemble se réduit en abaissant la corrélation ρ entre les modèles — diversité = réduction de la variance

Poids AdaBoost

Poids plus élevé pour les apprenants faibles plus précis — les apprenants faibles avec une erreur faible dominent l'ensemble

Méta-Entrée de l'Empilement

Prédictions hors-du-pli des modèles de base alimentent le méta-apprenant — la seule entrée correcte pour l'empilement

▶Simulation Interactive

Loading visualization…

⬡Architecture du Modèle

Loading visualization…

🎯

Pourquoi les Ensembles Gagnent Kaggle

motivation

La meilleure solution de presque chaque compétition Kaggle utilise l'ensemblage. Les modèles individuels ont des erreurs irréductibles — certains échantillons sont difficiles pour les modèles arborescents, d'autres pour les réseaux de neurones. En combinant des prédictions de modèles divers, les erreurs s'annulent. Le résultat bat systématiquement tout modèle individuel — souvent de 1-3% d'AUC.

💡

Les Trois Paradigmes d'Ensemble

intuition

Bagging (Bootstrap AGGregating) : entraîner K modèles sur K sous-ensembles aléatoires → moyenne/vote. Réduit la variance. La forêt aléatoire est du bagging. Boosting : entraîner K modèles séquentiellement, chacun corrigeant les erreurs du précédent → combinaison pondérée. Réduit le biais. XGBoost est du boosting. Stacking : entraîner K modèles de base divers, utiliser leurs prédictions comme caractéristiques pour un méta-apprenant.

Idée clé : les ensembles fonctionnent parce que les modèles sont divers. Un ensemble bagging de modèles identiques a exactement les mêmes performances qu'un seul modèle. Diversité = décorrélation = réduction de variance.

⚙️

Empilement avec Prédictions Hors-Pli

algorithm

Définir K modèles de base divers (LightGBM, XGBoost, CatBoost, réseau de neurones, etc.)

Pour chaque modèle de base, exécuter une validation croisée 5-plis

Collecter les prédictions hors-pli (OOF) — forme une colonne dans la matrice de méta-caractéristiques

Empiler K colonnes pour former la matrice de méta-caractéristiques Ñ ∈ ℝ^{n×K}

Entraîner le méta-apprenant (Régression Logistique ou LightGBM) sur Ñ avec la cible y

Pour le test : moyenner les prédictions des modèles de base sur les plis, alimenter le méta-apprenant

</>

Implémentation de l'Empilement en Production

code

python25 lines

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score

def empilement_oof(modeles, X_entr, y_entr, X_test, n_plis=class="tok-num">5):
    class="tok-str">"""Renvoie les prédictions OOF + prédictions test pour tous les modèles."""
    skf = StratifiedKFold(n_splits=n_plis, shuffle=True, random_state=class="tok-num">42)
    preds_oof  = np.zeros((len(X_entr), len(modeles)))
    preds_test = np.zeros((len(X_test), len(modeles)))

    for idx_m, modele in enumerate(modeles):
        preds_test_plis = np.zeros((len(X_test), n_plis))
        for idx_p, (tr, val) in enumerate(skf.split(X_entr, y_entr)):
            modele.fit(X_entr[tr], y_entr[tr])
            preds_oof[val, idx_m] = modele.predict_proba(X_entr[val])[:,class="tok-num">1]
            preds_test_plis[:, idx_p] = modele.predict_proba(X_test)[:,class="tok-num">1]
        preds_test[:, idx_m] = preds_test_plis.mean(axis=class="tok-num">1)
        print(fclass="tok-str">"Modèle {idx_m} AUC OOF: {roc_auc_score(y_entr, preds_oof[:,idx_m]):.4f}")

    class="tok-comment"># Méta-apprenant sur les prédictions OOF
    meta = LogisticRegression(C=class="tok-num">0.1)
    meta.fit(preds_oof, y_entr)
    preds_finales = meta.predict_proba(preds_test)[:,class="tok-num">1]
    return preds_finales, meta.coef_

?Vérification des Connaissances

La progression est sauvegardée dans votre navigateur — aucun compte requis.

Gradient Boosting : XGBoost, LightGBM, CatBoost

Classification Multi-classe OvA vs OvO

Besoin d'un ingénieur IA ou data scientist ?

Je conçois des modèles ML sur mesure, des agents IA, de la vision par ordinateur et de l'automatisation — de l'idée à la production.

Me contacter Voir les services