Tutoriel sur le modélisation par ensembles : explorez les techniques d’ensemble learning

Les modèles d’apprentissage automatique ne ressemblent pas aux solutions logicielles traditionnelles.  Ils nécessitent des mises à jour régulières à mesure que de nouvelles données sont disponibles pour fournir des prédictions fiables et précises. Dans des cas d’usage complexes et sensibles, s’appuyer sur un seul modèle peut ne pas suffire à obtenir un résultat optimal ; c’est là que le modélisation par ensembles peut faire la différence. 

Ce tutoriel conceptuel explique ce qu’est le modélisation par ensembles en apprentissage automatique et comment il peut améliorer les performances globales de vos modèles. Nous passerons ensuite en revue diverses méthodes d’ensemble avant d’illustrer un cas réel via une implémentation pas à pas avec Python.

Notre tutoriel Ensemble Learning in R with SuperLearner explique comment doper vos résultats en apprentissage automatique grâce à l’approche par ensembles avec le package SuperLearner en R.

Les modèles d’ensemble en apprentissage automatique

Imaginons un directeur musical qui participe à un concours international.  Il a accès à une grande variété de musicien·ne·s aux expertises différentes :

• Des musicien·ne·s classiques capables de composer des pièces traditionnelles.
• Des musicien·ne·s électro expert·e·s des instruments électroniques.
• Des jazzmen et jazzwomen avec un grand sens de l’improvisation.
• Des solistes capables d’exécuter des solos complexes et de mettre en valeur leur technique.

Face à ce large éventail de talents et de parcours, le directeur peut les réunir pour créer une performance unique et mémorable.

Pensez aux modèles d’ensemble comme à un orchestre : chacun maîtrise un instrument spécifique (piano, trompette, percussions, etc.). L’assemblage de ces compétences crée une mélodie harmonieuse. 

L’ensemble learning repose sur la même logique : 

il combine plusieurs algorithmes afin d’obtenir une performance prédictive supérieure à celle d’un seul modèle. Il n’y a pas de nombre prédéfini de modèles à utiliser ; selon les objectifs métier, certains cas nécessiteront plus de modèles que d’autres.

L’erreur de modèle et sa réduction avec les ensembles

L’erreur d’un modèle peut se décomposer mathématiquement en trois composantes :

Biais + Variance + Erreur irréductible

Pourquoi est-ce important ici ? Pour comprendre le fonctionnement d’un modèle d’ensemble, il faut d’abord savoir d’où viennent les erreurs du modèle. 

Regardons ces erreurs :

Erreur de biais 

Elle mesure, en moyenne, à quel point les valeurs prédites s’écartent de la valeur réelle. Un biais élevé indique un modèle sous-performant qui passe à côté de tendances essentielles.

Variance

À l’inverse, la variance quantifie l’écart entre des prédictions réalisées sur une même observation. Un modèle à forte variance sur‑ajuste l’échantillon d’entraînement et généralise mal au‑delà. Le schéma suivant aide à visualiser cela (le point rouge est la vraie valeur, les points bleus sont les prédictions) : 

En général, plus vous augmentez la complexité du modèle, plus l’erreur diminue grâce à une baisse du biais. Mais seulement jusqu’à un certain point : au‑delà, le modèle finit par sur‑ajuster et souffrir d’une variance élevée.

Maintenant que vous maîtrisez les bases de l’ensemble learning, voyons les différentes techniques disponibles :

Types de méthodes d’ensemble

Il existe plusieurs méthodes d’ensemble, chacune avec ses atouts et ses limites. Cette section vous aide à choisir la bonne approche selon vos besoins. 

Avant d’entrer dans le détail, clarifions les notions de méta‑apprenants et d’apprenants de base pour faciliter la suite. 

• Apprenants de base : premier niveau d’une architecture d’ensemble, chacun est entraîné pour produire ses propres prédictions. 
• Méta‑apprenants : second niveau, ils sont entraînés sur les sorties des apprenants de base. 

Bagging

Le bagging, pour bootstrap aggregating, est proche de la forêt aléatoire, mais utilise tous les prédicteurs, tandis que la forêt aléatoire n’en sélectionne qu’un sous‑ensemble à chaque arbre.  

Avec le bagging, un échantillon aléatoire du jeu d’entraînement est tiré avec remise, ce qui autorise la duplication d’observations. Les étapes clés sont :

• Générer plusieurs rééchantillonnages bootstrap.
• Exécuter un algorithme sur chaque rééchantillonnage pour prédire.
• Combiner les prédictions en faisant la moyenne (régression) ou en prenant le vote majoritaire (classification).

Le bagging présente plusieurs avantages et inconvénients pour la classification comme pour la régression.

Avantages

• Le processus de modélisation est simple, ne requiert pas de concepts mathématiques avancés et gère les valeurs manquantes.
• Le package scikit-learn facilite l’implémentation : il contient tous les modules pour agréger les prédictions des apprenants de base. 
• Il réduit fortement la variance des classifieurs à forte variance, utile avec des données haute dimension en améliorant la généralisation.
• Le bagging fournit une estimation non biaisée de l’erreur « out‑of‑bag », correspondant à la perte moyenne de l’ensemble des classifieurs.

Inconvénients

• Il est coûteux en calcul car il mobilise plusieurs modèles.
• La moyenne des prédictions complique l’interprétation du résultat final.

Boosting

Le boosting adopte une approche séquentielle : la prédiction du modèle courant est transmise au suivant. Chaque modèle se concentre itérativement sur les observations mal classées par ses prédécesseurs. Le processus général est illustré ci‑dessous : 

Avantages

• Comme le bagging, le boosting est facile à comprendre et à mettre en œuvre. Il ne nécessite pas de prétraitement spécifique et gère les valeurs manquantes.
• Il réduit efficacement le biais. 
• Pendant l’entraînement, les algorithmes de boosting privilégient les variables qui améliorent la précision globale, ce qui réduit la dimensionnalité et donc le temps de calcul. 

Inconvénients

• L’approche séquentielle amène les modèles suivants à corriger les erreurs des précédents, rendant l’ensemble sensible aux valeurs aberrantes.
• Pour la même raison, le boosting se scale moins bien.

Stacking

Le stacking est assez proche du boosting. Les prédictions des apprenants de base sont empilées et servent d’entrées au méta‑apprenant, qui produit des prédictions plus robustes. Le méta‑apprenant est ensuite utilisé pour la prédiction finale. Bagging et boosting utilisent en général des apprenants homogènes, tandis que le stacking privilégie des apprenants hétérogènes. 

Avantages

• Il exploite les forces de plusieurs modèles performants, en classification comme en régression.
• Comme les autres ensembles, le stacking permet souvent d’obtenir un modèle plus précis que chaque modèle pris isolément.

Inconvénients

• Recourir à des modèles de base complexes peut accroître le risque de sur‑ajustement.
• La superposition de niveaux d’entraînement peut rendre l’architecture complexe à mettre en place.

Blending 

Le blending est similaire au stacking. Les données sont séparées en apprentissage, validation (hold‑out) et test. Les méta‑apprenants sont entraînés sur les données d’apprentissage, puis leurs prédictions sont combinées avec les données de validation pour construire le méta‑modèle final, qui utilise ensuite les données de test pour la prédiction finale.

Avantages

• Comme le stacking et d’autres méthodes d’ensemble, le blending peut souvent améliorer la performance finale. 
• Cette technique a permis de remporter de nombreuses compétitions. 

Inconvénients

• Découper les données selon l’architecture de blending réduit la quantité disponible pour entraîner les modèles de base, ce qui peut dégrader les performances.
• Comme pour d’autres ensembles, l’interprétabilité diminue avec la complexité, rendant l’extraction d’insights métier plus difficile.

Voting

Avec le voting, plusieurs modèles sont entraînés indépendamment et leurs prédictions sont combinées pour une prédiction finale via un vote dur, mou ou pondéré :

• En vote dur, la prédiction finale est la classe la plus fréquente parmi tous les modèles.  
• En vote mou, chaque modèle renvoie une distribution de probabilités plutôt qu’une prédiction binaire, et la classe au score moyen le plus élevé est retenue. 
• Enfin, en vote pondéré, on suppose que certains modèles sont plus compétents que d’autres et on leur attribue un poids plus important dans l’agrégation.

Avantages

• L’architecture de vote est plus simple à implémenter que le stacking ou le blending et ne requiert pas de réglages complexes. 
• L’utilisation de plusieurs apprenants de base la rend moins sensible à l’influence d’un modèle isolé, d’où des prédictions plus stables et fiables.

Inconvénients

• Gérer des prédictions conflictuelles entre modèles peut être délicat et compliquer la décision finale.
• Ajouter des modèles ne conduit pas nécessairement à de meilleures performances.

Cascading 

Le cascading reprend l’idée du stacking mais avec un seul modèle par couche. Le premier modèle est entraîné sur l’ensemble des données d’apprentissage, le suivant sur la sortie du précédent, etc. L’objectif est de capter des motifs complexes dans les données afin d’améliorer les prédictions.   

Avantages

• Chaque modèle est spécialisé sur la sortie du précédent, ce qui réduit le bruit.
• Plus robuste au sur‑ajustement et performant sur des données réelles.

Inconvénients

• La mise en œuvre peut être complexe car elle implique l’entraînement séquentiel de chaque modèle.  
• Trouver l’architecture optimale peut demander beaucoup d’expérimentations et de réglages.

Aperçu des algorithmes d’ensemble

Après les types de modèles d’ensemble, passons à un aperçu de quelques algorithmes populaires. 

Random Forest

Random Forest est largement utilisée pour des tâches de classification et de régression. Une forêt aléatoire regroupe de nombreux arbres de décision entraînés par bagging. La prédiction finale est la moyenne (ou le vote) des prédictions individuelles. 

La taille des nœuds, le nombre d’arbres et le nombre de variables échantillonnées sont les trois hyperparamètres principaux à régler avant l’entraînement. 

Et l’aléa dans « random forest » ?

Le « feature bagging », ou aléatoire des variables, crée un échantillon aléatoire de caractéristiques pour réduire la corrélation entre arbres. Cela distingue les forêts aléatoires des arbres de décision classiques qui évaluent toutes les coupures possibles, quand les forêts n’en considèrent qu’un sous‑ensemble. À lire dans notre tutoriel sur la classification avec random forest. 

XGBoost

L’« Extreme Gradient Boosting », ou XGBoost, s’applique à la classification et à la régression. Conçu pour être très efficace et scalable, il implémente le cadre des arbres de décision en gradient boosting. 

Il convient aux jeux de données à grande échelle et est compatible avec les principaux environnements distribués comme Hadoop, MPI (Message Passing Inference) et SGI (Sun Grid Engine). Pour en savoir plus, consultez notre tutoriel XGBoost. 

AdaBoost

« Adaptive Boosting », ou AdaBoost, est l’un des premiers classifieurs d’ensemble à succès pour la classification binaire. Il est « adaptatif » car des poids sont réaffectés à chaque instance, en augmentant ceux des observations mal classées. Lisez notre tutoriel AdaBoost Classification in Python pour en savoir plus. 

Implémentation pas à pas de modèles d’ensemble 

Maintenant que vous comprenez le principe du modélisation par ensembles et le fonctionnement de certains modèles, passons à l’implémentation technique avec Python. 

Préparer l’environnement 

Commencez par installer Python sur votre ordinateur, ainsi que les bibliothèques suivantes :

• pandas pour charger les DataFrames. 
• scikit-learn pour utiliser les algorithmes d’apprentissage automatique existants.
• seaborn et matplotlib pour la visualisation.

Vous pouvez installer ces bibliothèques avec pip, le gestionnaire de packages Python :

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Pour illustrer le cas d’usage, nous utiliserons les données de prêts disponibles sur DataLab. Le code de ce tutoriel est aussi disponible sur DataLab dans ce workbook ; vous pouvez en créer une copie, l’éditer et exécuter le code dans votre navigateur sans rien installer en local.

Comprendre les données

Le jeu de données contient 9 500 prêts avec des informations sur la structure du prêt, l’emprunteur, et l’indicateur de remboursement intégral, porté par la colonne not.fully.paid. Les cinq premières lignes sont affichées ci‑dessous : 

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

L’appel à la fonction info() renvoie les informations suivantes utiles sur les données : 

• 9 578 lignes (de 0 à 9 577) et 14 colonnes de types numériques, sauf purpose de type object, qui décrit textuellement le motif du prêt. 
• Le libellé non-null pour chaque colonne indique l’absence de valeurs manquantes dans ces colonnes. 

loan_data.info()

On observe un fort déséquilibre : beaucoup plus d’observations en classe 0 (8 045) qu’en classe 1 (1 533).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Utiliser un jeu aussi déséquilibré pour l’entraînement dégrade la performance globale. 

Une façon d’y remédier est la sous‑échantillonnage : on réduit le nombre d’observations de la classe majoritaire (classe 0) pour obtenir autant d’observations en classe 0 qu’en classe 1. Le processus est le suivant :

• Récupérer d’abord le nombre d’observations de classe 1.

• Sélectionner N observations aléatoires de classe 0, où N est la taille du DataFrame de classe 1.

• Concaténer les deux DataFrames obtenus.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

Le tutoriel Diving Deep with Imbalanced Data propose d’autres techniques pour gérer les jeux de données déséquilibrés. 

Après sous‑échantillonnage, on obtient : 

• Au total 3 066 observations et 14 colonnes. 

La distribution équilibrée finale est illustrée ci‑dessous.

Préparer les données pour l’entraînement 

En examinant le jeu de données, on constate que toutes les variables n’ont pas la même échelle, et certains modèles (comme KNN) y sont sensibles. On peut résoudre ce problème en normalisant les variables sur une même plage à l’aide du module MinMaxScaler (ici, entre 0 et 1).

Par simplicité, nous retirerons également la colonne purpose, qui nécessiterait un prétraitement supplémentaire. 

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Retirer la colonne 'purpose' et préparer les données
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Comme pour toute tâche prédictive, nous divisons les données en ensembles d’entraînement et de test. Ici, 67 % pour l’entraînement et 33 % pour le test.  

• Le paramètre random_state est initialisé (2023 ici) pour garantir la reproductibilité. 

stratify garantit une répartition homogène de la cible y dans les ensembles d’entraînement et de test.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Tous les modèles suivront la même séquence : entraînement sur le jeu d’entraînement, prédictions sur le jeu de test, puis évaluation des performances. 

Modèle de bagging 

La Random Forest est notre modèle de bagging dans cette section. Nous utiliserons les paramètres par défaut pour la simplicité.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Définir le modèle
random_forest_model = RandomForestClassifier()
# Entraîner le modèle
random_forest_model.fit(X_train, y_train)

Après l’entraînement, nous évaluons la performance avec la fonction accuracy_score : 

# Prédire
y_pred = random_forest_model.predict(X_test)

# Mesurer la performance
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

Cette instruction print renvoie 0,6156, soit 61,56 %.

Comparons maintenant ce score à celui obtenu avec une approche d’agrégation par blending.

Modèle de blending 

Pour le blending, nous utiliserons deux modèles de base : un arbre de décision et un classifieur des plus proches voisins. Un modèle de régression logistique produit la prédiction finale.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

Les données d’entraînement initiales sont scindées en un nouvel ensemble d’entraînement et un ensemble de validation. Les modèles de base sont entraînés sur l’ensemble d’entraînement. 

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)

Deux DataFrames sont ensuite créés à partir des prédictions de ces modèles de base :

• Un premier avec les prédictions sur les données de validation, concaténées aux variables d’origine.
• Un second avec les prédictions sur les données de test, concaténées aux variables d’origine.

# Modèle Arbre de décision
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# Modèle KNN
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

Le modèle final de régression logistique est entraîné sur les données de validation concaténées et évalué sur les données de test concaténées. 

x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Modèle de régression logistique
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)

La méthode .score() calcule par défaut la précision (accuracy) sans nécessiter d’extraire manuellement les prédictions. 

Le score obtenu est 0,6383 (63,83 %), soit environ 2 % de mieux que la random forest initiale : le blending offre ici la meilleure performance.

Nos cours Ensemble Methods in Python et Machine Learning with Tree-Based Models in R sont d’excellents compléments pour progresser en apprentissage automatique et approfondir l’univers des méthodes de classification par ensembles, respectivement en Python et en R.

Conclusion

Nous avons passé en revue les principales approches de modélisation par ensembles, avec leurs caractéristiques, avantages et limites. Nous avons aussi présenté brièvement quelques algorithmes phares comme Random Forest, AdaBoost, XGBoost, les arbres en gradient boosting et les machines de gradient boosting. 

Lorsque vous concevez des modèles d’ensemble, gardez à l’esprit leurs points forts et leurs contraintes pour en tirer des insights métier pertinents.

FAQ

Quelle est la différence entre apprenants homogènes et hétérogènes ?

Les apprenants homogènes utilisent des algorithmes et hyperparamètres similaires. Une forêt aléatoire peut être vue comme un ensemble d’apprenants homogènes. 

Les apprenants hétérogènes, au contraire, reposent sur des algorithmes et hyperparamètres différents. Une Random Forest, un réseau de neurones et un KNN peuvent constituer un ensemble hétérogène.

Quels sont les avantages des modèles d’ensemble par rapport aux modèles uniques ?

Les ensembles permettent souvent de meilleures prédictions qu’un modèle pris isolément.

Quelle est la principale limite des modèles d’ensemble ?

Ils souffrent souvent d’un manque d’interprétabilité : les connaissances apprises sont difficiles à expliquer aux utilisateurs finaux.

Quand éviter d’utiliser des modèles d’ensemble ?

Évitez‑les notamment lorsque vous avez besoin d’une forte interprétabilité, que les données sont limitées, qu’il existe des contraintes temps réel ou des coûts de calcul élevés.  

Quels sont les différents types de méthodes d’ensemble en apprentissage automatique ?

Bagging, boosting, stacking, voting, blending et cascading sont les principaux types de méthodes d’ensemble.