Bagging vient de bootstrap aggregating : on entraîne le même modèle sur de nombreux tirages avec remise des données, puis on fait voter ou on moyenne. Proposé par Leo Breiman en 1996, il stabilise les modèles nerveux comme les arbres de décision. La Random Forest en est le prolongement le plus connu.
Demander une estimation à 200 experts qui ont chacun étudié un échantillon différent des dossiers, puis retenir la moyenne de leurs avis.
Chaque tirage a la même taille que les données d'origine. Certaines lignes apparaissent plusieurs fois, environ un tiers n'apparaît pas.
Le plus souvent un arbre de décision profond, précis mais instable. Chaque arbre est un peu différent puisqu'il a vu des données différentes.
Moyenne des prédictions en régression, vote majoritaire en classification. Les erreurs propres à chaque arbre se compensent en partie.
Surface, budget publicitaire, nombre de concurrents, zone et chiffre d'affaires annuel. L'objectif : prévoir le CA de chaque magasin pour répartir les objectifs et les budgets.
Sur le jeu d'exemple, l'erreur moyenne passe de 94 k€ pour un arbre seul à 78 k€ avec 200 arbres en bagging. La prévision ne dépend plus des quelques magasins tombés d'un côté ou de l'autre d'un seuil.
L'erreur moyenne en k€ se lit directement. Les magasins laissés de côté par chaque tirage (out-of-bag) fournissent une estimation gratuite de l'erreur, sans jeu de test : ici, un R² out-of-bag proche de 0,9.
Noms donnés pour R (ipred) et Python (scikit-learn).
Nombre de modèles. L'erreur baisse puis se stabilise ; au-delà de 100 à 200, le gain est faible.
Des arbres profonds par défaut. Le bagging aide surtout les modèles instables : un arbre non élagué en profite beaucoup, une régression linéaire presque pas.
Taille de chaque tirage. Égale à la base par défaut ; la réduire accélère l'entraînement et rend les modèles plus différents entre eux.
# Prévision du CA magasin : bagging d'arbres en R
library(rpart)
library(ipred)
magasins <- read.csv("magasins.csv")
magasins$zone <- factor(magasins$zone)
set.seed(42)
idx <- sample(nrow(magasins), 300)
train <- magasins[idx, ]
test <- magasins[-idx, ]
# Un seul arbre profond : précis sur l'entraînement, instable sur le reste
arbre <- rpart(ca_k ~ surface_m2 + budget_pub_k + nb_concurrents + zone, data = train,
control = rpart.control(cp = 0, minsplit = 2))
cat("Arbre seul, erreur moyenne (k€) :", round(mean(abs(predict(arbre, test) - test$ca_k)), 1), "\n")
# 200 arbres, chacun sur un tirage avec remise des magasins, puis moyenne
modele <- bagging(ca_k ~ surface_m2 + budget_pub_k + nb_concurrents + zone, data = train,
nbagg = 200, coob = TRUE)
cat("Bagging, erreur moyenne (k€) :", round(mean(abs(predict(modele, test) - test$ca_k)), 1), "\n")
cat("Erreur out-of-bag (RMSE, k€) :", round(modele$err, 1), "\n")# Prévision du CA magasin : bagging d'arbres en Python
import pandas as pd
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
magasins = pd.read_csv("magasins.csv")
X = pd.get_dummies(magasins[["surface_m2", "budget_pub_k", "nb_concurrents", "zone"]], dtype=float)
y = magasins["ca_k"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Un seul arbre profond : précis sur l'entraînement, instable sur le reste
arbre = DecisionTreeRegressor(random_state=42).fit(X_train, y_train)
print("Arbre seul, erreur moyenne (k€) :", round(mean_absolute_error(y_test, arbre.predict(X_test)), 1))
# 200 arbres, chacun sur un tirage avec remise des magasins, puis moyenne
bagging = BaggingRegressor(DecisionTreeRegressor(), n_estimators=200, oob_score=True, random_state=42)
bagging.fit(X_train, y_train)
print("Bagging, erreur moyenne (k€) :", round(mean_absolute_error(y_test, bagging.predict(X_test)), 1))
print("R² out-of-bag (sans jeu de test) :", round(bagging.oob_score_, 3))Le bagging entraîne des modèles indépendants sur des tirages différents et fait la moyenne : il réduit la variance. Le boosting entraîne les modèles en série, chacun concentré sur les erreurs du précédent : il réduit le biais. Le bagging est plus robuste, le boosting souvent plus précis.
La Random Forest est un bagging d'arbres avec un hasard supplémentaire : à chaque découpage, l'arbre ne choisit que parmi quelques variables tirées au sort. Les arbres sont moins corrélés entre eux, et la moyenne est en général meilleure.
Chaque tirage avec remise laisse de côté environ un tiers des lignes. On prédit chaque ligne avec les seuls modèles qui ne l'ont pas vue, et on compare au réel. On obtient une estimation de l'erreur proche de celle d'une validation croisée, sans calcul supplémentaire.
Ajoute un tirage au hasard des variables à chaque découpage : des arbres plus différents, un vote plus efficace.
Voir la fiche → la brique de baseLisible mais instable. Le bagging corrige ce défaut.
Voir la fiche → l'autre famille d'ensemblesLes modèles sont entraînés en série, chacun sur les erreurs du précédent. Réduit le biais plutôt que la variance.
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