XGBoost : Tout savoir sur le Boosting

XGBoost (pour contraction de eXtreme Gradient Boosting), est un modèle de Machine Learning très populaire chez les Data Scientists. Ayant fait ses preuves en termes de performance et de vitesse, il a récemment dominé les hackathons et compétitions de Machine Learning, ainsi que les concours de Kaggle pour les données structurées ou tabulaires. Il est largement utilisé pour résoudre non seulement les problèmes de classification ou de régression, mais aussi sur des problématiques courantes d'entreprises tout en utilisant une quantité minimale de ressources.

Dans cet article, nous examinerons le concept de boosting et nous allons détailler le fonctionnement de l'algorithme XGBoost, en quoi son utilisation et ses applications sont variées ainsi que les moyens utiles pour l’optimiser.

Qu’est-ce qu’un apprentissage d’ensemble ?

L'apprentissage d'ensemble (ou Ensemble Learning) est un concept de Machine Learning dans lequel l’idée est de former plusieurs modèles utilisant le même algorithme d’apprentissage. Le terme ensemble fait référence à une combinaison de modèles individuels créant un modèle plus fort et plus puissant. Il s'agit de centaines ou de milliers d’apprenants avec un objectif commun fusionnés pour résoudre un problème.

À lire aussi : découvrez notre formation MLOps

Cette méthode permet d'accroître la performance et la stabilité du modèle, minimiser sa variance et parvenir à un niveau de précision bien supérieur à celui qui serait réalisé si on utilisait n’importe lequel de ces modèles pris séparément.

Il existe deux grandes méthodes ensemblistes.

Bagging : une méthode ensembliste parallèle

Le principe du bagging (aussi appelé bootstrap aggregating) consiste à :

1. Créer de nombreux sous-échantillons aléatoires de notre ensemble de données avec possibilité de sélectionner la même valeur plusieurs fois. Cela permettra de créer un jeu de données pour chaque modèle.
2. Chaque modèle ensuite est entraîné sur une portion aléatoire afin de recréer une prédiction.
3. Le résultat avec le plus de votes ( le plus fréquent) devient le résultat final de notre modèle. Dans le cas de régression, on prendra la moyenne des votes de tous les arbres.

Les modèles dans ce cas sont entraînés simultanément (en même temps). Ils fonctionnent individuellement et indépendamment les uns des autres. C'est le cas par exemple des Random Forest, une des applications phares du bagging.

Boosting : une méthode ensembliste séquentielle

Le boosting va produire des modèles qui sont très dépendants les uns des autres, contrairement au principe du bagging. En effet les modèles sont entraînés itérativement comme suit.

1. La première étape consiste à créer un premier modèle de base partir d'un algorithme choisi. Il est entraîné sur les données. Au début, on attribue des poids égaux à toutes les observations. À partir des résultats obtenus de ce modèle, si une observation est mal classée, cela augmente son poids.

1. Ensuite, un second modèle est construit pour tenter de corriger les erreurs présentes dans le premier modèle. Il est entraîné à l'aide des données pondérées obtenues dans la première étape. Cette procédure se poursuit et des modèles sont ajoutés jusqu’à ce que l’ensemble complet des données de formation soit prédit correctement ou que le nombre maximal de modèles soit ajouté.

1. Les prédictions du dernier modèle ajouté seront les prédictions globales pondérées fournies par les anciens modèles d’arbres.

Il existe plusieurs modèles qui se basent sur le principe de boosting avec différentes méthodes pour déterminer les poids. On peut citer en guise d'exemple : AdaBoost, LPBoost, XGBoost, GradientBoost, BrownBoost.

Gradient Boosting

Le boosting de gradient (Gradient Boosting) est un cas particulier de boosting où les erreurs sont minimisées par l’algorithme de descente de gradient. Pour mieux comprendre de quoi il s'agit, on prendra un exemple.

On souhaite construire un boosting sur des arbres de décision : nous allons donc choisir une faible profondeur pour qu'ils ne soient pas trop complexes (une profondeur de 3 par exemple).

L'arbre de décision n'étant pas très profond, deux choses vont se produire :

• Sur quelques observations, les prédictions \(\hat{y}\) sont proches des réponses \(y\), et donc les résidus pour ces observations \(y-\hat{y}\) sont faibles.
• À l'inverse, pour les autres, les prédictions \(\hat{y}\) sont éloignées des réponses \(y\), et donc les résidus pour ces observations \(y-\hat{y}\) sont élevés.

En pratique, on aimerait donc corriger les prédictions pour lesquelles les résidus sont élevés, et ne pas toucher à celles dont les résidus sont faibles. Autrement dit, on ne veut corriger que pour les observations qui ont été mal prédites. Et c'est justement ce que va faire le prochain arbre de décision : il va compenser les erreurs commises précédemment sans détériorer les prédictions qui ont été justes.

Comment va-t-il faire pour corriger ?

La réponse est simple : nous allons changer en cours de route la base d'apprentissage. Plutôt que de prédire \(y\), le second arbre doit prédire \(y-\hat{y}\) , car en faisant la somme de la prédiction précédente plus celle du second arbre, on devrait obtenir la réponse \(y\).

Par contre, si la prédiction était déjà correcte, alors \(y-\hat{y} \approx 0\) , et donc le second arbre va prédire une très petite valeur, ce qui ne modifiera pas la valeur déjà prédite.

En répétant l'opération des dizaines de fois, le \(n+1\)-ème arbre va corriger les erreurs du n-ème arbre, ce qui explique cette relation de récurrence entre les modèles.

XGBoost, comment ça marche ?

XGBoost (ou contraction de eXtreme Gradient Boosting) est un modèle de machine Learning basé sur l'apprentissage d'ensemble séquentiel et les arbres de décision. Comme son nom l'indique, il utilise le boosting de gradient.

Détaillons le fonctionnement de l'algorithme se cachant derrière ce modèle. Considérons un classifieur faible initial \(f_0\). Après l'avoir optimisé, la méthode de boosting cherche à construire un nouveau classifieur faible \(f_1\) à partir de \(f_0\) en introduction un terme de résidu\(h\) :

De sorte que \(f_1\) soit plus performant que \(f_0\). On répétant l'opération un certain nombre de fois, disons p, on construit un classifieur final \(F\) complexe qui est une combinaison linéaire des \(f_i\), où chacun des \(f_i\) est associé à un poids \(\alpha_i\) :

Le Gradient Boosting est une technique particulièrement puissante dans le cas où la fonction de perte (mesure d'écart entre les valeurs théoriques et les valeurs prédites) est différentiable (ce qui est notre cas pour une fonction de perte quadratique). Le principe est le suivant :

• On commence par initialiser le modèle avec une valeur constante \(f_0(x)\).
• Ensuite, pour chaque itération (\(1 \leq m \leq M\)), on calcule les pseudo-résidus :

Ces pseudos-résidus permettent en réalité de s'approcher au plus possible de la solution optimale. L'intérêt du nouveau modèle est donc de capter les observations qui n'ont pas été correctement prédites par les classifieurs précédents.

• Un classifieur faible \(h_m\) est calibré sur les données \(x_{i}\) (variables explicatives) et \(r_{im}\) (réponses).
• On détermine un poids associé à ce classifieur faible.

• On met à jour le modèle.

Avec \(\eta\) le taux d'apprentissage, permettant d'éviter un éventuel sur-apprentissage (principe de régularisation).

Cet algorithme, appliqué au cas des arbres de régression et de classification, s'appelle donc le Gradient Tree Boosting

Optimisation du XGBoost

L'implémentation algorithmique de XGBoost requiert un certain nombre d'hyperparamètres qui peuvent être distingués selon :

• les hyperparamètres liés au calcul numérique, dont les exécutions asynchrones ;
• les hyperparamètres des arbres, tels que la profondeur maximale ou le nombre d'observations minimal dans un nœud ;
• les hyperparamètres propres à l'optimisation, comme le taux d'apprentissage ou la fonction objectif.

les hyperparamètres du XGBoost ne se calibrent pas tous en même temps. En effet, non seulement avec le grand nombre d'hyperparamètres mais aussi parce que l'apprentissage d'un XGBoost est plus long que les autres modèles de Machine Learning, les temps de calculs seraient phénoménaux. À la place, les Data Scientist ont développé une méthode qui n'en reste pas moins efficace.

1. Tout d'abord, on fixe un taux d'apprentissage learning_rate assez élevé (entre \(0.1\) et \(1\)) .Chaque nouvel arbre est multiplié par le taux d'apprentissage : plus ce taux est faible, plus la convergence vers un optimal sera lente. À l'inverse, un taux trop élevé empêchera le modèle de converger vers un optimal et sera moins précis dans ses prédictions. On fixera de même un nombre d'arbres plus ou moins important en fonction de la complexité des données.
2. Les prochains hyperparamètres qui ont une forte influence sur les performances concernent la structure des arbres : max_depth (désigne la profondeur maximale d'un arbre) et min_child_weight(fournit un seuil minimal quant au nombre d'individus présents dans un nœud). La meilleure méthode consiste à effectuer une recherche par grille sur ces deux hyperparamètres avec une grille relativement petite (environ une vingtaine de points).

3. Ensuite, le coefficient gamma pour régulariser les profondeurs des arbres Plus cet hyperparamètre a une valeur élevée, plus la pénalisation empêche de construire des arbres trop profonds si l'apport en performance n'est pas aussi élevé. Il peut être optimisé avec une recherche par grille simple. Habituellement, on teste avec les valeurs \(\gamma \in [0, +\infty[\).

4. Les hyperparamètres d'échantillonnage colsample_bytree (un ratio d'échantillonnage aléatoire sur les variables à chaque construction d'un arbre ) et subsample (un ratio situé entre 0 et 1 sélectionnant aléatoirement des observations à chaque itération pour entraîner un nouvel arbre) peuvent à leur tour être optimisés par une recherche par grille. Notons qu'il n'est souvent pas utile de tester pour des valeurs inférieures à 50%.

5. Enfin, en présence de données peu volumineuses, il ne reste plus qu'à réduire le taux d'apprentissage learning_rate (0.01 puis 0.001) tout en augmentant le nombre d'arbres (n_estimators) avec les hyper-paramètres optimisés des étapes précédentes. Il est fréquent d'utiliser un early stopping dans cette dernière étape lorsque l'on ne sait pas exactement combien d'arbres utiliser. Dans notre cas, puisque nos données sont assez volumineuses (500k lignes), nous n'avons pas le luxe de pouvoir inférer sur ces valeurs.

À lire aussi : découvrez notre formation MLOps

Cette méthode, bien que longue en pratique, permet d'obtenir les meilleures performances pour le XGBoost.

Quand utiliser XGBoost ?

Comme évoqué précédemment, XGBoost est un algorithme de choix dans de nombreuses situations. Il intervient alors pour des besoins très différents.

• Lorsqu’il s’agit de données structurées/tabulaires de petite à moyenne taille, l'algorithme XGBoost est considéré comme le meilleur de sa catégorie à l’heure actuelle. Grâce à son principe d'auto amélioration séquentielle, il peut être utilisé pour résoudre des problèmes de régression, de classification et même de classement .
• Il faut éviter de choisir ce modèle pour résoudre de problèmes de Computer Vision, NLP, extrapolation de données ou dans les cas où le nombre de catégories est largement plus important que le nombre d'observations.
• Comme pour tous les autres algorithmes basés sur des arbres de décision, il faut faire attention à l’overfitting (sur-apprentissage). Pour cela XGBoost n'est pas le meilleur dans le cas de jeux de données très volumineux. Cela peut être corrigé grâce à des méthodes pour éviter le sur-apprentissage, par exemple on peut limiter la taille des arbres (max_depth) ou bien construire les modèles sur des échantillons du jeu de données de base (on appelle ça stochastic gradient boosting).

Même si le boosting peut accroître sa précision et bien qu'il soit le modèle le plus performant du Machine Learning aujourd'hui, ce modèle sacrifie l’intelligibilité et l’intelligibilité. Il se comporte comme une boite noire, cela est dû principalement à sa composition de plusieurs arbres décisionnels.