En machine learning, il y a deux mondes. D'un côté, les réseaux de neurones, stars des médias, qui brillent sur les images, le texte et la voix. De l'autre, les données tabulaires : tes fichiers CSV, tes tableaux Excel, tes logs de ventes, tes historiques de commandes. Et là, surprise, les réseaux de neurones ne sont presque jamais la meilleure option. Le roi de cette catégorie s'appelle XGBoost, et il a remporté une bonne partie des compétitions Kaggle depuis sa sortie en 2014.
Pourquoi les arbres gagnent-ils sur les tableaux ? Parce que les données tabulaires sont hétérogènes : une colonne contient des âges, une autre des montants en euros, une troisième des codes catégoriels. Un réseau de neurones doit normaliser tout ça, et il a besoin de beaucoup d'exemples pour apprendre des frontières complexes. Un ensemble d'arbres, lui, découpe l'espace en règles simples du type « si le montant dépasse 500, alors ». C'est plus robuste, plus rapide, et ça marche avec quelques centaines de lignes.
XGBoost, pour eXtreme Gradient Boosting, construit son modèle en empilant des arbres de décision. Chaque nouvel arbre ne repart pas de zéro : il se concentre sur les erreurs du précédent. Imagine un prof qui corrige une copie, puis passe la copie à un collègue qui se focalise uniquement sur les fautes restantes, et ainsi de suite. Au bout de la chaîne, la somme des corrections donne une prédiction redoutablement précise. Le tout sans réglage interminable : les valeurs par défaut suffisent souvent à battre un réseau de neurones calibré pendant des heures.
Dans ce tutoriel, tu vas entraîner un modèle XGBoost sur un vrai jeu de données médicales, comprendre ce qu'il regarde, et activer l'arrêt anticipé pour ne pas perdre de temps. Vingt minutes, un terminal, zéro GPU.
Étape 1 — Installe les outils
Trois paquets suffisent. scikit-learn fournit le jeu de données et les utilitaires de découpage, pandas sert à manipuler les résultats, et XGBoost fait le gros du travail.
pip install xgboost scikit-learn pandasVérifie que tout est en place en important la bibliothèque dans un interpréteur Python. Si la ligne s'exécute sans erreur, tu es prêt.
import xgboost as xgbÉtape 2 — Charge et découpe les données
On utilise le jeu de données du cancer du sein, intégré à scikit-learn : 569 échantillons, 30 caractéristiques numériques (rayon de la tumeur, périmètre, texture, régularité du contour) et une étiquette binaire, tumeur bénigne ou maligne. Un cas d'usage parfait pour un modèle tabulaire, avec un enjeu concret que tout le monde comprend.
import xgboost as xgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
data = load_breast_cancer()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)On garde 20 % des données pour l'évaluation. Le modèle ne les verra jamais pendant l'entraînement, ce qui garantit une mesure honnête de ses performances : juger un élève sur un exercice qu'il a déjà corrigé ne prouve rien. Le paramètre random_state fixe le tirage pour que tes résultats soient reproductibles.
Étape 3 — Entraîne le modèle
La magie tient en quelques lignes. Trois hyperparamètres, pas plus : n_estimators fixe le nombre d'arbres de la forêt, max_depth leur profondeur maximale, learning_rate la vitesse d'apprentissage de chaque arbre.
model = xgb.XGBClassifier(
n_estimators=100,
max_depth=3,
learning_rate=0.1,
random_state=42,
)
model.fit(X_train, y_train)On pose ces valeurs explicitement pour savoir ce qu'on manipule, mais les réglages par défaut font déjà de l'excellent travail sur la plupart des jeux de données. Un learning_rate faible combiné à beaucoup d'arbres donne souvent un modèle plus fin, au prix d'un entraînement plus long.
Étape 4 — Évalue le résultat
from sklearn.metrics import accuracy_score
y_pred = model.predict(X_test)
print("Accuracy :", round(accuracy_score(y_test, y_pred), 4))Sur ces données, tu obtiens une accuracy autour de 0,95 : le modèle classe correctement 95 % des tumeurs qu'il n'a jamais vues. Sans GPU, sans fine-tuning, en moins d'une seconde d'entraînement. Pour creuser, remplace accuracy_score par classification_report et tu verras la précision et le rappel pour chaque classe, bénigne et maligne.
Étape 5 — Regarde ce que le modèle regarde
Le grand avantage de XGBoost sur les réseaux de neurones, c'est l'interprétabilité. Tu peux savoir exactement quelles caractéristiques pèsent le plus dans la décision, au lieu de contempler une boîte noire.
import pandas as pd
importances = model.feature_importances_
feat = pd.Series(importances, index=data.feature_names)
feat = feat.sort_values(ascending=False)
print(feat.head(5))Des caractéristiques comme mean concave points ou worst perimeter dominent le classement. Le modèle a donc appris que la forme et le contour de la tumeur sont les signaux les plus discriminants, ce qui colle à ce que savent les médecins. C'est rassurant, et c'est exactement le genre d'indice qu'un réseau de neurones t'offrirait beaucoup moins facilement.
Étape 6 — Active l'arrêt anticipé
XGBoost peut empiler des arbres presque indéfiniment. Passé un certain point, chaque arbre supplémentaire sur-ajuste les données d'entraînement au lieu de généraliser : il mémorise le bruit plutôt que d'apprendre la structure. L'arrêt anticipé coupe la partie dès que ça ne progresse plus.
model2 = xgb.XGBClassifier(
n_estimators=1000,
max_depth=3,
learning_rate=0.1,
eval_metric="logloss",
early_stopping_rounds=10,
random_state=42,
)
model2.fit(
X_train, y_train,
eval_set=[(X_test, y_test)],
verbose=False,
)
print("Arbres retenus :", model2.best_iteration + 1)On autorise jusqu'à 1000 arbres, mais on s'arrête dès que la performance sur l'ensemble de validation ne s'améliore plus pendant 10 tours. Résultat : le modèle retient quelques dizaines d'arbres au lieu de mille, pour une accuracy identique et un entraînement plus rapide.
Conclusion
XGBoost est l'outil à sortir dès que tes données tiennent dans un tableau. Il est rapide, interprétable, et ses réglages par défaut te placent déjà devant la plupart des alternatives. Les réseaux de neurones gardent le monopole des images et du langage, mais pour le reste, le gradient boosting reste roi.
Pour aller plus loin : joue sur learning_rate et max_depth pour affiner tes modèles, explore les importances sur tes propres données, et surtout essaie XGBRegressor quand tu veux prédire un nombre, comme un chiffre d'affaires ou un délai de livraison, au lieu d'une catégorie. Tes prochains modèles n'ont aucune excuse pour être médiocres.
