Introduction à l'intelligence artificielle: comprendre le Machine Learning

Auteur: Mohamed CHINY Durée necessaire pour le cours de Introduction à l'intelligence artificielle: comprendre le Machine Learning Niveau recommandé pour le cours de Introduction à l'intelligence artificielle: comprendre le Machine Learning Supports vidéo non disponibles pour ce cours Exercices de renforcement non disponibles pour ce cours Quiz non disponibles pour ce cours

Page 18: Le Boosting: principe et mise en pratique avec XGBoost

Toutes les pages

Introduction à l'intelligence artificielle: comprendre le Machine Learning

Page 1
Intelligence artificielle: Définition, histoire et évolution
Page 2
Types d'apprentissage: supervisé, non supervisé et par renforcement
Page 3
Qu'est-ce qu'un dataset? Tout commence par les données
Page 4
Analyse exploratoire des données (EDA)
Page 5
Apprentissage supervisé - La régression
Page 6
Apprentissage supervisé - La classification
Page 7
Comment un modèle de Machine Learning apprend-il?
Page 8
Régression linéaire simple avec NumPy, scikit-learn et Matplotlib
Page 9
Régression linéaire multiple avec les DataFrames de Pandas
Page 10
Séparation du jeu de données en ensembles d'entraînement et de test
Page 11
Régression linéaire multiple avec découpage des données en train set et test set
Page 12
Classification supervisée avec la régression logistique
Page 13
Naive Bayes pour la classification: un modèle probabiliste génératif
Page 14
k-Nearest Neighbors (k-NN): Algorithme de classification non paramétrique basé sur les distances
Page 15
L'arbre de décision (decision tree): un outil puissant de classification
Page 16
Classification avec les Support Vector Machines (SVM)
Page 17
L'ensemble learning - Combiner plusieurs modèles pour une performance accrue
Page 18
Le Boosting: principe et mise en pratique avec XGBoost
Page 19
Random Forest, une application du Bagging en Ensemble Learning
Page 20
Le stacking: unir des modèles différents pour plus de performance
Page 21
La validation croisée: découper les données pour un meilleur apprentissage du modèle
Page 22
Recherche par grille avec validation croisée (GridSearchCV)

Implémenter le Boosting en Machine Learning

Le Boosting: transformer des apprenants faibles en modèles puissants

En machine learning, on distingue généralement deux grandes catégories de modèles:
  • Les apprenants faibles (weak learners): qui sont des modèles simples, rapides à entraîner mais dont la performance isolée reste limitée, comme par exemple des arbres de décision peu profonds
  • Les apprenants forts (strong learners): qui sont des modèles plus complexes capables de bien généraliser et d’obtenir de meilleures prédictions.

Comme on l'a vu dans le leçon précédente sur l'ensemble learning, le boosting est une approche assembliste qui vise précisément à combiner de nombreux apprenants faibles pour construire un apprenant fort. Son principe repose sur un entraînement séquentiel où chaque nouveau modèle corrige les erreurs des précédents en accordant davantage d’importance aux exemples mal prédits. Ainsi, en agrégeant ces modèles simples de manière intelligente, le boosting parvient à produire un modèle global beaucoup plus performant, illustrant la puissance de la collaboration entre plusieurs apprenants faibles pour rivaliser avec des modèles sophistiqués.

XGBoost: une référence incontournable du Boosting

En dépit de la présence de nombreux algorithmes d’apprentissage supervisé qui s'inscrivent dans l'approche du boosting, XGBoost s’est imposé comme l’un des plus performants et des plus utilisés dans la pratique du machine learning.

XGboost est une implémentation optimisée du Gradient Boosting, conçue pour être rapide, efficace et capable de traiter de grands volumes de données. Sa popularité tient non seulement à ses excellents résultats en termes de précision et de généralisation, mais aussi à sa flexibilité. En effet, XGBoost permet d’appliquer différents types de fonctions de perte et donne accès à de nombreux autres algorithmes dérivés ou améliorés, tels que LightGBM ou CatBoost qui s’inspirent de ses principes.

Grâce aux optimisations de XGboost (parallélisation, régularisation, gestion des valeurs manquantes...), il est devenu incontournable dans les compétitions de data science et dans les applications industrielles, offrant aux praticiens un outil puissant pour transformer des modèles faibles en modèles robustes et performants. C’est pour cette raison que nous allons traiter XGBoost dans cette leçon à travers un exemple pratique.
Bien que l'on traitera seulement le modèle XGBoost dans cette leçon, le code présenté pourra être facilement adapté pour implémenter les autres variantes du boosting, telles que Gradient Boosting, LightGBM ou CatBoost.

Application de XGBoost pour la classification sur le dataset Titanic

Contrairement à certains modèles de classification qui sont directement intégrés par défaut dans scikit-learn (comme les arbres de décision, les SVM ou les régressions logistiques), XGBoost est une bibliothèque externe spécialisée dans le boosting. Elle a été développée séparément pour offrir des performances optimisées et des fonctionnalités avancées. C’est pour cette raison qu’il est nécessaire de l’installer manuellement avant de pouvoir l’utiliser.

Pour installer le modèle XGboost on exécute cette instruction (ou plutôt cette commande):
!pip install xgboost
Dans Jupyter Notebook, le signe ! sert à exécuter une commande du système directement depuis une cellule (comme dans le terminal). Sans le !, Jupyter essaierait d’interpréter pip install xgboost comme du code Python, ce qui provoquerait une erreur.
Comme nous avons déjà étudié en détail le dataset Titanic ainsi que le pipeline nécessaire pour implémenter un modèle de classification, je présenterai directement le code complet et me concentrerai uniquement sur l’explication des éléments nouveaux, en l'occurrence ceux qui concernent l'utilisation du modèle XGBoost.

Je propose le code suivant:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import matplotlib.pyplot as plt
from xgboost import XGBClassifier

df = pd.read_csv("titanic.csv")

df = df[["Survived", "Pclass", "Sex", "Age", "SibSp", "Parch", "Fare"]].dropna()
df["Sex"] = df["Sex"].map({"male": 0, "female": 1})

X = df.drop("Survived", axis=1)
y = df["Survived"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Chargement et entraînement de XGBoost
clf = XGBClassifier(
   n_estimators=100,
   learning_rate=0.1,
   max_depth=3,
   random_state=42,
   use_label_encoder=False,
   eval_metric="logloss"
)

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Exactitude sur le jeu de test : {accuracy:.2f}")

cm = confusion_matrix(y_test, y_pred)
print(cm)

print(classification_report(y_test, y_pred))
         
Voyons la signification des hyperparamètres appliqués au modèle lors de sa création:
  • n_estimators=100: Nombre d’arbres de décision (ou itérations de boosting) que le modèle va construire. Plus ce nombre est élevé, plus le modèle peut être précis, mais il risque aussi de tomber dans l'overfitting.
  • learning_rate=0.1: Taux d’apprentissage du modèle. Une valeur plus petite (comme 0.01) rend l’apprentissage plus lent mais souvent plus robuste, tandis qu’une valeur plus grande accélère l’entraînement mais peut réduire la généralisation.
  • max_depth=3: Profondeur maximale des arbres de décision. Plus la profondeur est grande, plus le modèle peut capturer des relations complexes mais au risque d'overfitting.
  • random_state=42: Graine aléatoire pour assurer la reproductibilité des résultats. En fixant cette valeur on obtient toujours le même découpage train/test et le même modèle à chaque exécution.
  • use_label_encoder=False: Dans les versions récentes de XGBoost, l’ancien encodeur de labels est déprécié. Mettre ce paramètre à False évite les avertissements et utilise directement les labels fournis.
  • eval_metric="logloss": Métrique d’évaluation utilisée pendant l’entraînement. Ici, on utilise la logarithmic loss (logloss) adaptée aux problèmes de classification binaire. Elle mesure la différence entre les probabilités prédites et les vraies classes (plus la valeur est faible, meilleur est le modèle).

Un label encoder est une technique de prétraitement des données en machine learning qui sert à transformer des variables catégorielles en valeurs numériques. Nous aurons l'occasion de la voir en détail dans la leçon consacrée au preprocessing.
L'exécution du code produit ces résultats:
Exactitude sur le jeu de test : 0.80

[[ 74 13 ]
 [ 15 41 ]]
XGBoost rapport de performances sur le dataset Titanic      
Le modèle est globalement performant, mais il fait presque autant d’erreurs sur les survivants (15 faux négatifs) que sur les non‑survivants (13 faux positifs). Dans tous les cas, je vous laisse le soin de comparer les résultats obtenus en utilisant XGBoost avec les résultats obtenus en utilisant les modèles classiques vus précédemment.   
         
         
         
         
         
         
         
Page 18
Le Boosting: principe et mise en pratique avec XGBoost