Septième module du challenge #100JoursDeML, le plus dense — et pour cause : sur les données tabulaires d'entreprise, les modèles à base d'arbres restent aujourd'hui ce qui se fait de mieux, souvent devant le deep learning. Chaque leçon est détaillée ci-dessous avec sa vidéo.

📥 La checklist offerte du challenge
Recevez le PDF avec les 100 leçons à cocher et suivez votre progression jour après jour.

Télécharger la checklist →

Leçon 1 — Les bases de l'arbre de décision

Un arbre de décision prédit en enchaînant des questions binaires sur les variables (« revenu > 30 000 € ? »), jusqu'à une feuille qui donne la prédiction. À chaque nœud, l'algorithme choisit la découpe qui rend les groupes les plus « purs » possibles — pureté mesurée par l'indice de Gini ou l'entropie en classification, la variance en régression. Interprétable et visualisable, l'arbre ne demande ni standardisation ni traitement des variables catégorielles complexe.

Leçon 2 — Construire un arbre performant

Laissé libre, un arbre pousse jusqu'à mémoriser chaque observation : overfitting garanti. Les garde-fous : limiter la profondeur maximale, imposer un minimum d'observations par feuille, ou élaguer (pruning) après coup. La leçon détaille ces hyperparamètres et leur réglage par validation croisée.

Leçon 3 — Un arbre de classification en Python

Guide pratique complet avec scikit-learn : entraîner un DecisionTreeClassifier, visualiser l'arbre obtenu, lire les règles de décision et mesurer l'importance des variables.

from sklearn.tree import DecisionTreeClassifier, plot_tree

arbre = DecisionTreeClassifier(max_depth=4).fit(X_train, y_train)
plot_tree(arbre, feature_names=X.columns, filled=True)  # l'arbre se dessine

Leçon 4 — Un arbre de régression pour prédire les prix immobiliers

Même mécanique, cible numérique : chaque feuille prédit la moyenne des observations qu'elle contient, et les découpes minimisent la variance intra-feuille. Cas pratique de bout en bout sur des prix de l'immobilier.

Leçon 5 — L'intuition des forêts aléatoires

Un arbre seul est instable : changez quelques données, l'arbre change du tout au tout. La forêt aléatoire (random forest) fait voter des centaines d'arbres, chacun entraîné sur un échantillon bootstrap (tirage avec remise) et, à chaque nœud, sur un sous-ensemble aléatoire de variables — cette double dose de hasard décorrèle les arbres, et la moyenne de modèles décorrélés est bien meilleure que chacun d'eux. C'est la sagesse des foules appliquée au machine learning.

Leçon 6 — Régler une forêt : nombre d'arbres et de variables

Les deux hyperparamètres majeurs : le nombre d'arbres (plus il y en a, mieux c'est — jusqu'à un plateau où l'on ne gagne plus que du temps de calcul) et le nombre de variables candidates à chaque nœud (le curseur qui contrôle la décorrélation). La leçon donne les valeurs de départ raisonnables et la démarche de réglage.

Leçon 7 — Random forest en Python : classification

Tutoriel pratique : RandomForestClassifier, le score out-of-bag (une validation gratuite grâce aux observations non tirées dans chaque bootstrap) et l'importance des variables — l'un des grands atouts des forêts pour expliquer un modèle aux métiers.

from sklearn.ensemble import RandomForestClassifier

foret = RandomForestClassifier(n_estimators=300, oob_score=True, random_state=42)
foret.fit(X_train, y_train)
print(foret.oob_score_)  # validation gratuite out-of-bag
pd.Series(foret.feature_importances_, index=X.columns).sort_values().plot.barh()

Leçon 8 — Random forest en Python : régression

Le pendant régression, avec l'évaluation par les métriques du Module 5 (RMSE, MAE, R²) et la comparaison avec l'arbre seul — la démonstration chiffrée de l'apport de l'ensemble.

Leçon 9 — Bagging, boosting et stacking démystifiés

La carte de l'ensemble learning — combiner plusieurs modèles « faibles » pour en faire un fort. Le bagging entraîne en parallèle sur des échantillons bootstrap et agrège les votes (il réduit la variance). Le boosting entraîne en séquence, chaque modèle corrigeant les erreurs du précédent (il réduit le biais). Le stacking empile : un méta-modèle apprend à combiner les prédictions des autres.

Leçon 10 — AdaBoost : le boosting fondateur

AdaBoost (Adaptive Boosting) attribue un poids à chaque observation : à chaque itération, les observations mal classées voient leur poids augmenter, forçant le modèle suivant à s'y concentrer. Le vote final pondère chaque modèle selon sa performance. Simple, élégant, et historiquement le premier boosting à succès.

Leçon 11 — AdaBoost en pratique avec Python

Implémentation avec scikit-learn : choix du modèle de base, nombre d'itérations, taux d'apprentissage, et lecture de l'évolution de l'erreur au fil des itérations.

Leçon 12 — Comprendre le gradient boosting

Le gradient boosting généralise AdaBoost : chaque nouvel arbre apprend à prédire les erreurs résiduelles de l'ensemble courant, en descendant le gradient de la fonction de coût — d'où le nom. Le taux d'apprentissage (learning rate) contrôle la contribution de chaque arbre : plus il est petit, plus il faut d'arbres, mais meilleur est le résultat.

Leçon 13 — XGBoost vs LightGBM vs CatBoost

Les trois implémentations qui dominent le gradient boosting moderne. XGBoost : la référence des compétitions, régularisée et hautement optimisée. LightGBM (Microsoft) : le plus rapide sur gros volumes, grâce à sa croissance d'arbre par feuille. CatBoost (Yandex) : gestion native des variables catégorielles, excellent sans réglage. La leçon compare leurs forces, faiblesses et cas d'usage.

Leçon 14 — Leur comparaison chiffrée en Python

Benchmark pratique des trois bibliothèques sur un même jeu de données : installation, API, temps d'entraînement, performances — et la méthode pour reproduire cette comparaison sur vos données, seule réponse définitive.

from xgboost import XGBClassifier

xgb = XGBClassifier(n_estimators=500, learning_rate=0.05, max_depth=5,
                    early_stopping_rounds=30, eval_metric="auc")
xgb.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False)

Leçon 15 — Les modèles ensemblistes pour la régression

XGBoost, CatBoost, LightGBM et AdaBoost appliqués à un problème de régression de bout en bout — la preuve que le boosting n'est pas réservé à la classification.

Leçon 16 — L'ensemble learning en 5 points clés

La synthèse du module : quand préférer bagging ou boosting, les pièges (le boosting est plus sensible au bruit et aux outliers), et les réflexes de réglage.

💡 À retenir : dans la vraie vie comme en compétition Kaggle, un XGBoost bien réglé sur des données bien préparées bat presque toujours un réseau de neurones sur des données tabulaires. Investissez dans le preprocessing avant d'investir dans la complexité.

La suite

Complétez votre boîte à outils supervisée avec deux classiques au Module 8 : KNN et SVM.

Références

Breiman, L. et al. (1984), Classification and Regression Trees (CART) ; Breiman, L. (2001), « Random Forests », Machine Learning
Freund & Schapire (1997), AdaBoost, JCSS · Friedman (2001), « Greedy function approximation: a gradient boosting machine », Annals of Statistics
Chen & Guestrin (2016), « XGBoost: A scalable tree boosting system », KDD
Documentation XGBoost · LightGBM · CatBoost · scikit-learn : ensembles