La star des algorithmes de ML : XGBoost 1



Principe de XGBoost

Si vous ne connaissiez pas cet algorithme, il est temps d’y remédier car c’est une véritable star des compétitions de Machine Learning. Pour faire simple XGBoost (comme eXtreme Gradient Boosting) est une implémentation open source optimisée de l’algorithme d’arbres de boosting de gradient.

Mais qu’est-ce que le Boosting de Gradient ?

Le Boosting de Gradient est un algorithme d’apprentissage supervisé dont le principe et de combiner les résultats d’un ensemble de modèles plus simple et plus faibles afin de fournir une meilleur prédiction.

On parle d’ailleurs de méthode d’agrégation de modèles. L’idée est donc simple : au lieu d’utiliser un seul modèle, l’algorithme va en utiliser plusieurs qui serons ensuite combinés pour obtenir un seul résultat.

C’est avant tout une approche pragmatique qui permet donc de gérer des problèmes de régression comme de classification.

Pour décrire succinctement le principe, le l’algorithme travaille de manière séquentielle. Contrairement par exemple au Random Forest. cete façon de faire va le rendre plus lent bien sur mais il va surtout permettre à l’algorithme de s’améliorer par capitalisation par rapport aux exécutions précédentes. Il commence donc par construire un premier modèle qu’il va bien sur évaluer (on est bien sur de l’apprentissage supervisé). A partir de cette première évaluation, chaque individu va être alors pondérée en fonction de la performance de la prédiction. Etc.

XGBoost se comporte donc remarquablement dans les compétitions d’apprentissage automatique(Machine Learning), mais pas seulement grâce à son principe d’auto-amélioration séquentielle …

XGBoost inclut en effet un grand nombre d’hyperparamètres qui peuvent être modifiés et réglés à des fins d’amélioration !

Cette grande flexibilité fait donc de XGBoost un choix solide qui vous faut absolument essayer 😉

XGBoost par la pratique

Autre bonne (ou mauvaise) nouvelle : XGBoost ne fait pas partie de Scikit-Learn … mais s’intègre par contre parfaitement bien avec. Les exemples ci-dessous utilisent cette intégration, mais sachez que bien sur vous pouvez utiliser XGBoost sans avoir Scikit-Learn.

Nous allons récupérer et travailler sur notre bon vieux jeu de données du Titanic. Vous vous souvenez ? il s’agit de prédire si un passager va survivre … c’est donc un problème de classification binaire. Nous utiliserons donc évidemment XGBoost comme classifier.

from xgboost import XGBClassifier
from sklearn.preprocessing import MinMaxScaler
import pandas as pd
import xgboost as xgb
train = pd.read_csv("../titanic/data/train.csv")
test = pd.read_csv("../titanic/data/test.csv")

Évidemment on ne coupera pas à un peu de préparation de données, ce n’est pas l’objectif de cet article aussi on fera très simple ici. Voici une petite fonction Python qui préparera les jeux d’entraînement et de test :

def dataprep(data):
    sexe = pd.get_dummies(data['Sex'], prefix='sex')
    cabin = pd.get_dummies(data['Cabin'].fillna('X').str[0], prefix='Cabin')
    # Age
    age = data['Age'].fillna(data['Age'].mean())
    emb = pd.get_dummies(data['Embarked'], prefix='emb')
    # Prix du billet / Attention une donnée de test n'a pas de Prix !
    faresc = pd.DataFrame(MinMaxScaler().fit_transform(data[['Fare']].fillna(0)), columns = ['Prix'])
    # Classe
    pc = pd.DataFrame(MinMaxScaler().fit_transform(data[['Pclass']]), columns = ['Classe'])

    dp = data[['SibSp']].join(pc).join(sexe).join(emb).join(faresc).join(cabin).join(age)
    return dp

Préparons donc ces datasets et récupérons pour le jeu d’entraînement les étiquettes (labels) :

Xtrain = dataprep(train)
Xtest = dataprep(test)
y = train.Survived

Entraînons maintenant notre algorithme XGBoost. Pour les hyper-paramètres nous prendrons ceux par défaut.

boost = XGBClassifier()
boost.fit(Xtrain, y)
p_boost = boost.predict(Xtrain)
print ("Score Train -->", round(boost.score(Xtrain, y) *100,2), " %")

Hyper-Paramètres

Bien sur XGBoost est paramétrable, retrouvez la liste des hyper-paramètres sur le site directement https://xgboost.readthedocs.io/en/latest/parameter.html

Attention il va falloir gérer ces paramètres sur 3 niveaux :

  • Les paramètres généraux
  • Les paramètres du booster choisit (ceux ci dépendent des choix précédents)
  • Les paramètres d’apprentissage (régression et classification n’auront pas ici les mêmes entrées).

Voici un exemple d’affectation de paramètres à l’instanciation du classifier:

param = {}
param['booster'] = 'gbtree'
param['objective'] = 'binary:logistic'
param["eval_metric"] = "error"
param['eta'] = 0.3
param['gamma'] = 0
param['max_depth'] = 6
param['min_child_weight']=1
param['max_delta_step'] = 0
param['subsample']= 1
param['colsample_bytree']=1
param['silent'] = 1
param['seed'] = 0
param['base_score'] = 0.5

clf = xgb.XGBClassifier(params)

Evaluation

Outre les métriques que nous avons abordés dans l’évaluation d’algorithmes de classification, la librairie XGBoost founit quelques métriques intéressantes.

Graphique présentant les champs par degré d’importance :

xgb.plot_importance(boost)

Graphique présentant le résultat :

xgb.to_graphviz(boost, num_trees=2)

Sauvegarde et chargement de modèle

La librairie inclut aussi la possibilité de sauvegarder et recharger un modèle:

Sauvegarde d’un modèle entraîné :

boost._Booster.save_model('titanic.xbmodel')

Chargement d’un modèle sauvegardé :

boost = xgb.Booster({'nthread': 4}) boost.load_model('titanic.xbmodel')

Et sans Scikit-Learn ?

Comme je le disais plus haut on peut tout à fait utiliser XGBoost indépendamment de Scikit-Learn, voici les quelques différences :

import xgboost as xgb

dtrain = xgb.DMatrix(x_train,y_train)
param = {'boost':'linear',
         'learnin_rate':0.1,
         'max_depth': 5, 
         'objective': 'reg:linear',
          'eval_metric':'rmse'}
num_round = 100
bst = xgb.train(param, train, num_round)

preds = bst.predict(dtest)

Attention

Comme pour les autres algorithmes basés sur des arbres … attention à l’overfitting (sur apprentissage). Pour cela on reviendra aux bonnes vieilles recettes : limiter la taille des arbres (sans jeu de mots) mais aussi de construire et travailler sur des échantillons à partir du jeu de données initial.

Dans la même famille des algorithmes de boosting gradient, je vous invite aussi à lire mon article sur le CatBoost.

Comme d’habitude vous trouverez les sources de cet article dans GitHub.


A propos de Benoit Cayla

En plus d'être un spécialiste des données, j'aime passer le plus clair de mon temps à l'extérieur, à jardiner par exemple ou simplement à aller dans le bois avec mes enfants. J'aime aussi le VTT que je pratique chaque semaine avec mes amis. Quand je dois rester à l'intérieur, j'aime améliorer ma maison. Bricoler me permet ainsi de libérer ma créativité ;-). Si je n'ai rien à réparer ou créer, je passe mon temps libre à explorer les dernières avancées technologiques dans le monde de l'IA et du RPA.

Laissez un commentaire

Votre adresse de messagerie ne sera pas publiée.

deux × 5 =

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Commentaire sur “La star des algorithmes de ML : XGBoost