Classifieur AdaBoost en Python

Ces dernières années, les algorithmes de boosting ont gagné en popularité dans les concours de data science et de machine learning. La plupart des lauréats s'appuient sur ces méthodes pour atteindre une haute précision. Ces compétitions offrent une plateforme mondiale pour apprendre, explorer et proposer des solutions à divers problèmes d'entreprises et d'administrations. Les algorithmes de boosting combinent plusieurs modèles peu précis (ou faibles) pour créer des modèles très précis (ou forts). Ils s'emploient dans des domaines variés tels que le crédit, l'assurance, le marketing et les ventes. Des algorithmes comme AdaBoost, Gradient Boosting et XGBoost sont largement utilisés pour remporter des compétitions de data science. Dans ce tutoriel, vous allez découvrir l'algorithme de boosting par ensembles AdaBoost. Nous couvrirons les points suivants :

• Approche d'apprentissage automatique par ensembles
  • Bagging
  • Boosting
  • Stacking
• Classifieur AdaBoost
• Comment fonctionne l'algorithme AdaBoost ?
• Construction d'un modèle en Python
• Avantages et inconvénients
• Conclusion

Approche d'apprentissage automatique par ensembles

Un ensemble est un modèle composite qui combine une série de classifieurs peu performants pour créer un classifieur amélioré. Chaque classifieur individuel vote, et l'étiquette finale est déterminée par un vote majoritaire. Les ensembles offrent en général une meilleure précision que chaque classifieur pris isolément. Les méthodes d'ensemble peuvent être parallélisées en répartissant chaque apprenant de base sur différentes machines. En somme, l'apprentissage par ensembles regroupe des méta-algorithmes qui combinent plusieurs méthodes de machine learning au sein d'un modèle prédictif unique pour accroître les performances. Les ensembles peuvent réduire la variance via le bagging, le biais via le boosting, ou améliorer les prédictions via le stacking.

1. Bagging (bootstrap aggregating) combine plusieurs apprenants afin de réduire la variance des estimations. Par exemple, une forêt aléatoire entraîne M arbres de décision : vous pouvez entraîner M arbres différents sur des sous-échantillons aléatoires des données et effectuer un vote pour la prédiction finale. Parmi les méthodes de bagging, on trouve Random Forest et Extra Trees.

2. Boosting regroupe des classifieurs faiblement précis pour créer un classifieur hautement précis. Un classifieur faible offre une précision à peine meilleure que le hasard. Un classifieur fort présente un taux d'erreur proche de 0. Les algorithmes de boosting mettent l'accent sur les erreurs de prédiction précédentes. Ils sont généralement moins sujets au surapprentissage. Les trois algorithmes suivants sont très prisés dans les compétitions de data science :

   • AdaBoost (Adaptive Boosting)
   • Gradient Tree Boosting
   • XGBoost

3. Stacking (ou empilement) est une technique d'ensemble qui combine les prédictions de plusieurs modèles de base pour créer un nouveau jeu de données. Ces nouvelles données servent ensuite d'entrée à un autre classifieur, chargé de résoudre le problème. Le stacking est souvent appelé blending.

Selon l'organisation des apprenants de base, on distingue deux familles : en parallèle, où les apprenants sont générés simultanément (par exemple Random Forest), et en séquentiel, où ils sont générés les uns après les autres (par exemple AdaBoost).

Selon le type d'apprenants de base, on distingue : les méthodes homogènes, qui utilisent le même type d'apprenant à chaque itération, et les méthodes hétérogènes, qui en utilisent de différents.

Classifieur AdaBoost

AdaBoost, pour Adaptive Boosting, est un classifieur par ensembles proposé par Yoav Freund et Robert Schapire en 1996. Il combine plusieurs classifieurs pour en augmenter la précision. AdaBoost est une méthode itérative : elle construit un classifieur fort en combinant plusieurs classifieurs faibles, de sorte à obtenir une grande exactitude. L'idée clé est d'ajuster les poids des classifieurs et des échantillons d'apprentissage à chaque itération pour favoriser la prédiction correcte des observations atypiques. Tout algorithme de machine learning pouvant accepter des poids sur l'ensemble d'entraînement peut servir d'apprenant de base. AdaBoost doit respecter deux conditions :

1. Le classifieur doit être entraîné de manière interactive sur des exemples pondérés.
2. À chaque itération, il cherche à bien ajuster ces exemples en minimisant l'erreur d'entraînement.

Comment fonctionne l'algorithme AdaBoost ?

Le fonctionnement se déroule en étapes :

1. Initialement, AdaBoost sélectionne aléatoirement un sous-ensemble d'entraînement.
2. Il entraîne le modèle de façon itérative, en choisissant l'ensemble d'entraînement en fonction des prédictions correctes ou non de l'itération précédente.
3. Il attribue un poids plus élevé aux observations mal classées, afin d'augmenter leur probabilité d'être correctement classées à l'itération suivante.
4. Il attribue également un poids au classifieur entraîné à chaque itération selon sa précision : plus il est précis, plus son poids est élevé.
5. Le processus se poursuit jusqu'à ce que l'ensemble d'entraînement soit parfaitement ajusté ou qu'on atteigne le nombre maximal d'estimateurs.
6. Pour prédire, on effectue un "vote" à travers l'ensemble des apprenants entraînés.

Construction d'un modèle en Python

Importer les bibliothèques nécessaires

Commençons par charger les bibliothèques requises.

# Load libraries
from sklearn.ensemble import AdaBoostClassifier
from sklearn import datasets
# Import train_test_split function
from sklearn.model_selection import train_test_split
#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics
Propulsé par

Chargement du jeu de données

Pour construire le modèle, nous allons utiliser le jeu de données IRIS, un classique de la classification multi-classes. Il comporte 4 variables (longueur et largeur du sépale, longueur et largeur du pétale) et une cible (le type de fleur). Trois espèces sont présentes : Setosa, Versicolour et Virginica. Le dataset est disponible dans la bibliothèque scikit-learn, ou téléchargeable depuis la UCI Machine Learning Library.

# Load data
iris = datasets.load_iris()
X = iris.data
y = iris.target
Propulsé par

Séparer le jeu de données

Pour évaluer les performances du modèle, il est recommandé de diviser les données en ensembles d'entraînement et de test.

Utilisons la fonction train_test_split(). Vous devez fournir trois paramètres : les variables explicatives, la cible et la taille de l'ensemble de test.

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training and 30% test
Propulsé par

Construire le modèle AdaBoost

Créons le modèle AdaBoost avec scikit-learn. Par défaut, AdaBoost utilise un DecisionTreeClassifier comme apprenant de base.

# Create adaboost classifer object
abc = AdaBoostClassifier(n_estimators=50,
                         learning_rate=1)
# Train Adaboost Classifer
model = abc.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = model.predict(X_test)
Propulsé par

"Les paramètres les plus importants sont base_estimator, n_estimators et learning_rate." (Adaboost Classifier, Chris Albon)

• base_estimator : apprenant faible utilisé pour entraîner le modèle. Par défaut, DecisionTreeClassifier est utilisé. Vous pouvez également spécifier d'autres algorithmes.
• n_estimators : nombre d'apprenants faibles entraînés de façon itérative.
• learning_rate : pondération appliquée aux apprenants faibles. La valeur par défaut est 1.

Évaluer le modèle

Estimons la capacité du classifieur à prédire correctement le type de fleurs.

La précision se calcule en comparant les valeurs réelles de l'ensemble de test et les valeurs prédites.

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Propulsé par

Accuracy: 0.8888888888888888
Propulsé par

Vous obtenez une précision de 88,88 %, ce qui est considéré comme bon.

Pour aller plus loin, vous pouvez aussi créer un modèle avec d'autres estimateurs de base.

Utiliser d'autres apprenants de base

Ici, j'utilise SVC comme estimateur de base. Vous pouvez choisir tout apprenant acceptant des poids d'échantillons, comme Decision Tree ou Support Vector Classifier.

# Load libraries
from sklearn.ensemble import AdaBoostClassifier

# Import Support Vector Classifier
from sklearn.svm import SVC
#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics
svc=SVC(probability=True, kernel='linear')

# Create adaboost classifer object
abc =AdaBoostClassifier(n_estimators=50, base_estimator=svc,learning_rate=1)

# Train Adaboost Classifer
model = abc.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = model.predict(X_test)


# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Propulsé par

Accuracy: 0.9555555555555556
Propulsé par

Vous obtenez ici un taux de classification de 95,56 %, un très bon résultat.

Dans cet exemple, l'estimateur de base SVC fournit une meilleure précision que l'arbre de décision.

Avantages

AdaBoost est simple à mettre en œuvre. Il corrige itérativement les erreurs des classifieurs faibles et améliore la précision en les combinant. Vous pouvez utiliser de nombreux classifieurs de base avec AdaBoost. Il n'est généralement pas enclin au surapprentissage : c'est ce que montrent les résultats expérimentaux, même s'il n'existe pas de raison théorique parfaitement établie.

Inconvénients

AdaBoost est sensible au bruit dans les données. Il est fortement affecté par les valeurs aberrantes, car il tente d'ajuster parfaitement chaque point. Il est également plus lent qu'XGBoost.

Conclusion

Félicitations, vous êtes arrivé au bout de ce tutoriel !

Vous avez découvert les approches par ensembles, l'algorithme AdaBoost, son fonctionnement, la construction et l'évaluation d'un modèle avec le package Python scikit-learn, ainsi que ses avantages et inconvénients.

Vos retours et questions sont les bienvenus. Posez-les en commentaire, et je ferai de mon mieux pour y répondre.

Pour approfondir le machine learning en Python, découvrez les cours DataCamp Extreme Gradient Boosting with XGBoost et Python Machine Learning: Scikit-Learn Tutorial.