~/teaching · machine learning · séance 6, mercredi 16 décembre 2026

Forêts aléatoires, gradient boosting et XGBoost, puis la comparaison honnête de deux modèles

Pourquoi moyenner des arbres marche, comment le boosting descend un gradient, et quand 0,01 d'AUC ne veut rien dire.

Sitraka Forler, Centrale Méditerranée

Révision 16 octobre 2026 · environ 17 minutes

Résumé

Ce deck est la séance 6 du cours de Machine Learning de Centrale Méditerranée (option DDEFI, 2026-2027). Il reprend là où les arbres de décision s'étaient arrêtés : un arbre profond colle à ses lignes d'entraînement et vacille partout ailleurs. La matinée corrige cette instabilité de deux façons opposées. Une forêt fait pousser beaucoup d'arbres côte à côte et en fait la moyenne ; le boosting les fait pousser l'un après l'autre, chacun chargé de réparer les erreurs laissées par ses prédécesseurs.

Chaque mécanisme est démontré au tableau puis vérifié sur de petits nombres : les 63,2 % de lignes d'un tirage bootstrap, la variance d'une moyenne d'arbres corrélés, le pseudo-résidu de la perte logistique, la valeur optimale d'une feuille et le gain d'une coupe dans XGBoost. La dernière partie pose la question que tout projet finit par rencontrer : le challenger bat la référence de 0,01 d'AUC, est-ce un résultat ou la chance des plis ? La validation croisée imbriquée et le test corrigé de Nadeau et Bengio y répondent.

Après lecture, vous savez expliquer pourquoi décorréler les arbres compte plus que d'en ajouter, lire une importance de variables sans vous faire piéger, écrire un gradient boosting en quelques lignes de Python et comparer deux modèles avec une règle fixée avant les résultats. L'exemple suivi est le jeu de données de défaut de crédit de Yeh et Lien (2009), utilisé dans tout le cours.

Les slides

Forêts, boosting et la comparaison honnête

Séance 6, mercredi 16 décembre 2026. Machine Learning, Centrale Méditerranée, option DDEFI, 2026-2027.

Ouvrir les slides (mot de passe donné par l'enseignant)

Le deck lui-même est chiffré pour les élèves du cours ; cette page le résume pour tous.

La page du cours · L'attention et le transformer, pas à pas

Plan du deck

Bootstrap et bagging. Rééchantillonner les lignes avec remise, et pourquoi une moyenne d'arbres instables a moins de variance.
Forêts aléatoires. Tirer les variables candidates à chaque nœud pour décorréler les arbres, l'erreur hors sac et les réglages qui comptent.
Importance des variables. Importance par l'impureté contre importance par permutation, et pourquoi la première est biaisée.
Gradient boosting. AdaBoost pour l'histoire, puis le boosting de Friedman comme descente de gradient sur les prédictions, calculé à la main sur trois points.
XGBoost et sa famille. Développement au second ordre, feuilles régularisées, histogrammes et valeurs manquantes, avec LightGBM et CatBoost en une slide.
TP : le boosting à la main. Un petit régresseur qui reproduit scikit-learn, et un XGBoost dont le nombre d'arbres est fixé par arrêt précoce.
La comparaison honnête. Validation croisée imbriquée, variance d'une validation croisée, test apparié corrigé et tests multiples.
La règle du champion. Écrire la règle de décision avant le tableau, lire les pires erreurs, et mettre un petit gain en balance avec son coût.

Le bagging : pourquoi une moyenne d'arbres a moins de variance

Si l'on entraîne beaucoup d'arbres sur des copies un peu différentes des données et qu'on fait leur moyenne, les écarts de chacun se compensent en partie, à condition qu'ils ne se trompent pas tous de la même façon.

L'erreur quadratique attendue d'un modèle se décompose en bruit, biais au carré et variance, c'est le compromis biais-variance (bias-variance trade-off). Un arbre profond et non élagué a peu de biais, parce qu'il suit les données de près, et beaucoup de variance : retirez quelques lignes, la première coupe change, et tout l'arbre avec elle. Breiman (1996) appelle ces procédures instables et montre que ce sont justement elles qui profitent de la moyenne. Une moyenne garde le biais de ses membres et ne travaille que sur la variance.

Pour tirer beaucoup d'arbres d'un seul jeu de données, le bagging (bootstrap aggregating) s'appuie sur le bootstrap d'Efron (1979) : tirer $n$ lignes avec remise parmi les $n$ lignes d'entraînement, entraîner un arbre profond sur ce tirage, recommencer $B$ fois et moyenner les prédictions. Une ligne donnée échappe à un tirage avec probabilité $1 - 1/n$ , donc aux $n$ tirages avec probabilité $(1 - 1/n)^n$ , qui tend vers $e^{-1}$ .

\Big(1 - \frac{1}{n}\Big)^{n} \longrightarrow e^{-1} \approx 0.368, \qquad 1 - e^{-1} \approx 0.632

(1)

Sur les 18 000 lignes d'entraînement du cours, chaque tirage contient donc environ 11 378 lignes distinctes, et les 36,8 % restantes sont hors sac pour cet arbre. La formule centrale de la section est la variance d'une moyenne de $B$ arbres, chacun de variance $\sigma^2$ , corrélés deux à deux avec un coefficient $\rho$ (Hastie, Tibshirani et Friedman, 2009, équation 15.1).

\operatorname{Var}\Big(\frac{1}{B}\sum_{b=1}^{B} \hat f_b(x)\Big) = \rho\,\sigma^{2} + \frac{1 - \rho}{B}\,\sigma^{2}

(2)

La démonstration est un comptage : la variance d'une somme est la somme de toutes les covariances, il y a $B$ termes diagonaux qui valent $\sigma^2$ et $B(B-1)$ termes croisés qui valent $\rho\sigma^2$ , le tout divisé par $B^2$ . Le second terme s'éteint quand on ajoute des arbres ; le premier, $\rho\sigma^2$ , est un plancher qu'aucun nombre d'arbres ne déplace.

**Tableau 1 :** Variance de la moyenne de $B$ arbres, avec $\sigma^2 = 1$ . Des arbres indépendants progressent sans fin ; des arbres corrélés plafonnent à $\rho$ .
Arbres $B$	$\rho = 0.3$	$\rho = 0.1$	$\rho = 0$
10	0,370	0,190	0,100
100	0,307	0,109	0,010
1 000	0,3007	0,1009	0,001

Vérification pour dix arbres avec $\rho = 0.3$ : dix termes diagonaux et quatre-vingt-dix termes croisés donnent $(10 + 90 \times 0.3)/100 = 0.37$ , comme $0.3 + 0.7/10$ . Passer de 100 à 1 000 arbres fait gagner 0,006 de variance ; ramener $\rho$ de 0,3 à 0,1 ferait gagner 0,2. La leçon pratique : décorréler d'abord.

Retour au sommaire.

Les forêts aléatoires : décorréler les arbres

Une forêt aléatoire, c'est le bagging plus une astuce : à chaque coupe, l'arbre ne peut choisir que parmi quelques variables tirées au hasard, si bien que les arbres cessent de se ressembler.

Dans les données de crédit, une variable domine, le statut de remboursement du dernier mois. Le bagging pur la place à la racine de presque tous les arbres, les arbres se ressemblent, $\rho$ est élevé et la variance bute sur son plancher. Les forêts aléatoires (random forests) de Breiman (2001) ne proposent à chaque nœud que $m$ variables tirées parmi $p$ . Avec le défaut de scikit-learn en classification, $m = \lfloor\sqrt{23}\rfloor = 4$ , la variable dominante n'est disponible à une racine donnée qu'environ 17 % du temps. Chaque arbre devient un peu moins bon, la forêt devient meilleure. Avec $m = p$ , on retrouve le bagging.

L'algorithme

Rééchantillonner. Pour chacun des $B$ arbres, tirer un échantillon bootstrap des lignes d'entraînement.
Faire pousser sans élaguer. À chaque nœud, tirer $m$ variables candidates et couper sur la meilleure ; laisser l'arbre profond pour que son biais reste faible.
Moyenner. Prédire par la moyenne des arbres ; scikit-learn moyenne les probabilités, la règle d'origine de Breiman prend un vote majoritaire.

Breiman démontre aussi que l'erreur de la forêt converge quand $B$ grandit : plus d'arbres coûtent du temps et de la mémoire, jamais de la précision. Le nombre d'arbres n'est donc pas un réglage qui surapprend ; on l'augmente jusqu'à ce que l'erreur hors sac (out-of-bag error) se stabilise. Cette erreur est une validation gratuite : chaque ligne est prédite uniquement par les arbres dont le tirage l'a manquée, soit environ 184 arbres sur 500.

\mathrm{Err}_{\mathrm{OOB}} = \frac{1}{n}\sum_{i=1}^{n} L\Big(y_i,\ \frac{1}{|\mathcal{B}_i|}\sum_{b \in \mathcal{B}_i} \hat f_b(x_i)\Big)

(3)

max_features agit sur $\rho$ et c'est en général le réglage le plus influent (Probst, Wright et Boulesteix, 2019).
min_samples_leaf lisse les probabilités : avec des feuilles d'une ligne, chaque arbre répond 0 ou 1.
n_estimators n'agit que sur le terme qui s'éteint ; on le fixe en regardant la courbe hors sac, on ne le règle pas.
Les probabilités d'une forêt évitent souvent 0 et 1 : vérifiez la courbe de fiabilité avant de les utiliser avec un seuil de décision.

Retour au sommaire.

Importance des variables : la MDI est biaisée, la permutation est honnête

Le score d'importance intégré à une forêt favorise les variables qui offrent beaucoup de seuils ; mieux vaut mélanger une colonne sur des données non vues et regarder de combien le score baisse.

La diminution moyenne de l'impureté (mean decrease in impurity, MDI), l'attribut feature_importances_ de scikit-learn, additionne les gains de Gini de toutes les coupes faites sur la variable $j$ , pondérés par la part $p(t)$ des lignes qui atteignent le nœud, puis moyenne sur les arbres. L'importance par permutation (permutation importance) pose une autre question : combien d'AUC de validation perd-on si l'on casse le lien entre $j$ et la cible en mélangeant sa colonne ?

\mathrm{MDI}(j) = \frac{1}{B}\sum_{b=1}^{B}\ \sum_{t \in b,\ v(t) = j} p(t)\,\Delta i(t)

(4)

\mathrm{PI}(j) = s - \frac{1}{R}\sum_{r=1}^{R} s_{r,j}

(5)

Dans l'illustration du deck, une AUC de validation de 0,780 tombe à 0,742, 0,748 et 0,745 sur trois mélanges de la variable de remboursement, soit une importance de $0.780 - 0.745 = 0.035$ . Strobl, Boulesteix, Zeileis et Hothorn (2007) ont expliqué pourquoi la MDI trompe. Une variable continue offre des milliers de seuils, et l'un d'eux sépare toujours un peu les classes par hasard ; une variable binaire n'a qu'un essai. La MDI est calculée sur les lignes d'entraînement, où le bas d'un arbre profond coupe sur du bruit et le compte comme un gain. Enfin, elle dit ce que l'arbre a utilisé, pas ce qui prédit. Dans une simulation montrée par le deck, une colonne de bruit pur arrive troisième selon la MDI et presque nulle selon la permutation.

Remarque (La limite de la permutation). Des variables corrélées se partagent le mérite : les six montants de facture mensuels se remplacent l'un l'autre, mélanger l'un d'eux coûte peu et chacun paraît inutile alors que le groupe compte. Permutez le groupe entier, ajoutez une colonne de bruit comme témoin, répétez une dizaine de mélanges et tenez pour nulle toute importance inférieure à deux écarts-types. Les valeurs SHAP prennent le relais à la séance suivante.

Retour au sommaire.

Le gradient boosting : une descente de gradient sur les prédictions

Le boosting construit les arbres l'un après l'autre, et chaque nouvel arbre est entraîné à corriger les erreurs que la somme des arbres précédents commet encore.

AdaBoost (Freund et Schapire, 1997) repondérait les points mal classés pour que l'apprenant faible suivant se concentre sur eux. Friedman, Hastie et Tibshirani (2000) l'ont relu comme un modèle additif ajusté pour une perte exponentielle, ce qui ouvrait la porte à n'importe quelle perte. Friedman (2001) a alors refondu le boosting comme la descente de gradient du cours, avec un changement d'inconnue : au lieu d'un vecteur de paramètres, l'inconnue est le vecteur des $n$ prédictions $F(x_i)$ . La direction de descente pour le client $i$ est le pseudo-résidu (pseudo-residual).

r_{im} = -\left[\frac{\partial L\big(y_i, F(x_i)\big)}{\partial F(x_i)}\right]_{F = F_{m-1}}

(6)

Un pas de descente brut ne dirait rien d'un client absent de l'entraînement : on ajuste donc un arbre de régression $h_m$ sur les $r_{im}$ et on l'ajoute avec un petit pas $\nu$ . Pour la perte carrée, le pseudo-résidu est l'erreur ordinaire $y - F$ . Pour la perte logistique, avec $p = \sigma(F)$ , la dérivation en chaîne et $\sigma' = p(1-p)$ donnent la surprise du modèle.

\frac{\partial L}{\partial F} = -y(1 - p) + (1 - y)\,p = p - y \quad\Longrightarrow\quad r = y - p

(7)

F_m = F_{m-1} + \nu\, h_m, \qquad F_M(x) = F_0 + \nu \sum_{m=1}^{M} h_m(x)

(8)

Exemple chiffré : trois points, des souches, ν = 0,5

Prenons les points $(1, 1)$ , $(2, 5)$ , $(3, 12)$ et la perte carrée. On part de la moyenne, $F_0 = 6$ , donc les premiers résidus valent $-5, -1, 6$ . Une souche (stump), un arbre à une seule coupe, compare la coupe à 1,5 (somme des carrés 24,5) à la coupe à 2,5 (somme 8) et garde 2,5, avec $-3$ à gauche et 6 à droite. On en ajoute la moitié. Au tour 2, les résidus valent $-3.5, 0.5, 3$ , et cette fois la coupe à 1,5 l'emporte (3,125 contre 8) : le deuxième arbre coupe là où le premier ne l'a pas fait, parce qu'il travaille sur ce qui reste.

**Tableau 2 :** Deux tours de gradient boosting à la main. Erreur quadratique moyenne : 20,67 avec $F_0$ , 7,17 avec $F_1$ , 2,57 avec $F_2$ .
$x$	$y$	$F_0$	$r_1$	$h_1$	$F_1$	$r_2$	$h_2$	$F_2$
1	1	6	−5	−3	4,5	−3,5	−3,5	2,75
2	5	6	−1	−3	4,5	0,5	1,75	5,375
3	12	6	6	6	9	3	1,75	9,875

Trois réglages vont ensemble. Un petit pas d'apprentissage (learning rate), ou rétrécissement (shrinkage), généralise mieux au prix de plus d'arbres : dans la simulation du deck, $\nu = 0.5$ atteint sa meilleure perte de validation après 5 arbres puis se dégrade, alors que $\nu = 0.05$ touche le fond à 87 arbres dans une vallée large. Les arbres restent courts, parce que la profondeur fixe l'ordre des interactions et que le boosting réduit le biais en additionnant des apprenants faibles, au lieu de réduire la variance en moyennant des forts : Hastie et al. recommandent 4 à 8 feuilles. Le nombre d'arbres devient alors un résultat de l'arrêt précoce (early stopping) sur un jeu de validation.

Retour au sommaire.

XGBoost : un pas de Newton par feuille

XGBoost, c'est le même boosting avec une meilleure approximation locale de la perte, une pénalité sur les feuilles, et une ingénierie qui le rend rapide et tolérant aux valeurs manquantes.

Chen et Guestrin (2016) remplacent la perte de chaque client par son développement de Taylor à l'ordre 2 autour du modèle courant, avec un gradient $g_i$ et une courbure $h_i$ (pour la perte logistique, $p_i - y_i$ et $p_i(1 - p_i)$ ), et ajoutent une pénalité $\gamma$ par feuille et $\lambda$ sur le carré des valeurs de feuille. Comme un arbre donne la même valeur $w_j$ à tous les clients de la feuille $j$ , l'objectif se découpe en une parabole par feuille, dont le minimum s'écrit en formule close.

\mathcal{L}^{(m)} \approx \sum_{j=1}^{T}\Big[G_j\, w_j + \tfrac12\,(H_j + \lambda)\, w_j^{2}\Big] + \gamma T, \qquad G_j = \sum_{i \in I_j} g_i,\ H_j = \sum_{i \in I_j} h_i

(9)

w_j^{\star} = -\frac{G_j}{H_j + \lambda}

(10)

\text{Gain} = \frac12\left[\frac{G_L^{2}}{H_L + \lambda} + \frac{G_R^{2}}{H_R + \lambda} - \frac{(G_L + G_R)^{2}}{H_L + H_R + \lambda}\right] - \gamma

(11)

Exemple chiffré : quatre clients, λ = 1, γ = 0

Gradients. Deux défauts prédits à 0,6 et 0,3, deux bons clients à 0,4 et 0,2 : $g = (-0.4, -0.7, 0.4, 0.2)$ et $h = (0.24, 0.21, 0.24, 0.16)$ .
Une feuille. $G = -0.5$ , $H = 0.85$ , donc $w^{\star} = 0.5/1.85 = 0.270$ : tout le monde monte un peu, parce que les deux défauts manqués pèsent plus.
Deux feuilles. Défauts à part : $w_L^{\star} = 1.1/1.45 = 0.759$ ; bons clients : $w_R^{\star} = -0.6/1.40 = -0.429$ , contre $-1.5$ sans $\lambda$ , ce qui montre comment la pénalité rétrécit les petites feuilles.
Gain. $\tfrac12(0.834 + 0.257 - 0.135) = 0.478$ , très au-dessus des 0,000 et 0,095 des deux coupes qui isolent un seul client. Avec $\gamma = 0.5$ , aucune coupe ne passerait : l'élagage est intégré à la croissance.

Pour la perte carrée, $h_i = 1$ et, sans $\lambda$ , la feuille optimale est la moyenne de ses résidus : on retrouve exactement la version de Friedman. Deux ajouts d'ingénierie comptent en pratique : des seuils cherchés sur des histogrammes de quantiles (256 cases par défaut) plutôt que sur chaque valeur, et une direction par défaut apprise pour les valeurs manquantes à chaque coupe. LightGBM (2017) fait pousser les arbres feuille par feuille pour gagner du temps ; CatBoost (2018) utilise des arbres symétriques et des statistiques de cible ordonnées pour les variables catégorielles. Une fois réglées, les trois bibliothèques arrivent en général près l'une de l'autre.

Retour au sommaire.

Validation croisée imbriquée : choisir dedans, mesurer dehors

Si l'on choisit les meilleurs réglages sur des plis puis qu'on annonce le score sur ces mêmes plis, on annonce le réglage le plus chanceux, pas la vraie qualité du modèle.

Supposons vingt réglages qui ont tous une vraie AUC de 0,770, chaque estimation par validation croisée portant un bruit d'écart-type 0,005. Garder le meilleur revient à garder le plus chanceux : le maximum de vingt tirages normaux se situe en moyenne 1,87 écart-type au-dessus de la moyenne, donc le score annoncé avoisine 0,779 pour un modèle qui vaut 0,770. Varma et Simon (2006), puis Cawley et Talbot (2010), ont montré que ce biais de sélection peut atteindre l'écart entre deux algorithmes.

La parade sépare le choix de la mesure. Une boucle externe découpe les données en cinq plis ; pour chacun, une validation croisée complète sur les quatre autres choisit les hyperparamètres, le gagnant est réentraîné sur ces quatre plis et noté une seule fois sur le pli mis de côté. C'est la validation croisée imbriquée (nested cross-validation). Les cinq scores mesurent la procédure « chercher, puis entraîner », pas un modèle figé. L'arrêt précoce est un réglage comme un autre et se fait dans la boucle interne.

from sklearn.model_selection import GridSearchCV, StratifiedKFold, cross_val_score

inner = StratifiedKFold(3, shuffle=True, random_state=1)   # pour choisir
outer = StratifiedKFold(5, shuffle=True, random_state=1)   # pour mesurer
search = GridSearchCV(model, grid, cv=inner, scoring="roc_auc")
scores = cross_val_score(search, X, y, cv=outer, scoring="roc_auc")
# cinq AUC honnetes ; refaire search.fit sur toutes les lignes pour le modele livre

Un second piège se cache dans la dispersion de ces scores. Avec cinq plis, deux jeux d'entraînement partagent 75 % de leurs lignes, donc les scores des plis sont corrélés. Leur moyenne a la même variance que la forêt : $\sigma^2/K$ plus un plancher de covariance $\gamma$ . Bengio et Grandvalet (2004) ont démontré qu'aucun estimateur sans biais de cette variance n'existe à partir d'une seule validation croisée. Avec $\sigma^2 = 1$ et $\gamma = 0.3$ , la vraie variance de la moyenne vaut 0,44 quand la formule naïve $s^2/K$ annonce 0,2.

\operatorname{Var}\big(\bar e\big) = \frac{\sigma^{2}}{K} + \frac{K - 1}{K}\,\gamma

(12)

Retour au sommaire.

Le test corrigé de Nadeau et Bengio

Comme les plis se recouvrent, le test t apparié habituel est beaucoup trop sûr de lui ; la correction élargit la barre d'erreur d'un facteur fixé à l'avance par la taille des plis.

Comme les deux modèles sont évalués sur des plis identiques, on raisonne sur leurs différences appariées $d_k$ (challenger moins référence), ce qui retire ce qui est propre à chaque pli. Dietterich (1998) a montré qu'un test t qui traite ces différences comme indépendantes rejette l'égalité bien trop souvent. Le test corrigé de Nadeau et Bengio (corrected resampled t-test), publié en 2003, remplace $1/J$ par $1/J + n_2/n_1$ , où $n_2/n_1$ est la taille du pli mesuré sur celle de la partie d'entraînement : $1/4$ avec cinq plis, $1/9$ avec dix. Bouckaert et Frank (2004) ont confirmé qu'il se comporte bien en validation croisée répétée.

t = \frac{\bar d}{\Big[\big(\tfrac{1}{J} + \tfrac{n_2}{n_1}\big)\, s^{2}\Big]^{1/2}}, \qquad t \sim \text{Student}(J - 1)

(13)

Exemple chiffré : boosting contre régression logistique sur cinq plis

Différences. Écarts d'AUC de 0,014, 0,002, 0,017, 0,006 et 0,011 (valeurs illustratives du deck) : moyenne $\bar d = 0.010$ , $s^2 = 3.65 \times 10^{-5}$ , $s = 0.00604$ .
Test naïf. Erreur type $\sqrt{s^2/5} = 0.00270$ , $t = 3.70$ , $p = 0.021$ avec 4 degrés de liberté : l'avance semble établie.
Correction. Facteur $1/5 + 1/4 = 0.45$ au lieu de 0,2 : l'erreur type grandit de moitié (variance fois 2,25) et passe à 0,00405.
Test corrigé. $t = 2.47$ , $p = 0.069$ . L'intervalle à 95 %, $0.010 \pm 2.776 \times 0.00405$ , va d'environ −0,001 à 0,021 et contient zéro : l'avance n'est pas établie.

Le tableau de comparaison illustratif du deck dit la même chose à plus grande échelle : avec trois graines fois cinq plis, un boosting en avance de 0,010 obtient un $p$ corrigé de 0,07 là où le test naïf aurait affiché 0,0008. Comparer trois challengers à une même référence ajoute un risque : si aucun ne gagne vraiment, la probabilité qu'au moins un test se déclenche vaut $1 - 0.95^3$ , soit 14,3 %. Ce sont les tests multiples (multiple testing) ; la borne de Bonferroni, $p < 0.05/3$ , tient sans aucune hypothèse d'indépendance.

Remarque (Écrire la règle avant le tableau). Avec quatre modèles, deux métriques et plusieurs seuils, il existe toujours un critère sous lequel le favori gagne (le « jardin des sentiers qui bifurquent » de Gelman et Loken). Le cours demande à chaque équipe un pré-enregistrement (preregistration) : déposer sa règle du champion, y compris le cas d'égalité, dans une issue horodatée avant de lancer la comparaison. Et un gain établi doit encore payer sa complexité : un score de crédit est un système à haut risque au sens de l'annexe III du règlement européen sur l'IA, un refus doit être expliqué, et une régression logistique calibrée coûte moins cher à justifier, servir et maintenir.

Retour au sommaire.

À retenir

Une moyenne de $B$ arbres a pour variance $\rho\sigma^2 + (1 - \rho)\sigma^2/B$ : ajouter des arbres n'efface que le second terme, baisser la corrélation abaisse le plancher.
Une forêt aléatoire, c'est le bagging plus un tirage des variables candidates à chaque nœud ; plus d'arbres ne surapprennent jamais, et l'erreur hors sac est un contrôle gratuit.
L'importance par l'impureté favorise les variables à nombreux seuils et se calcule sur l'entraînement ; utilisez la permutation sur la validation, avec une colonne de bruit comme témoin.
Le gradient boosting ajuste chaque arbre sur les pseudo-résidus $-\partial L/\partial F$ , qui valent $y - p$ en perte logistique ; petit pas, arbres courts et arrêt précoce.
La valeur de feuille $-G/(H + \lambda)$ de XGBoost est un pas de Newton régularisé, et le gain d'une coupe compare le score des enfants à celui du parent, moins $\gamma$ .
Choisir les hyperparamètres dans une boucle interne, mesurer dans une boucle externe ; puis comparer les modèles sur les différences appariées avec la correction de Nadeau et Bengio, selon une règle écrite d'avance.

Glossaire

compromis biais-variance (bias-variance trade-off): Décomposition de l'erreur attendue en bruit, biais au carré et variance ; la moyenne d'arbres n'agit que sur la variance.
bootstrap: Échantillon de $n$ lignes tirées avec remise parmi les $n$ lignes d'entraînement ; il contient environ 63,2 % de lignes distinctes.
forêts aléatoires (random forests): Bagging d'arbres profonds où chaque nœud ne peut couper que sur $m$ variables tirées au hasard parmi $p$ .
erreur hors sac (out-of-bag error): Erreur de chaque ligne prédite uniquement par les arbres qui ne l'ont pas vue dans leur tirage bootstrap.
diminution moyenne de l'impureté (mean decrease in impurity, MDI): Somme des gains d'impureté pondérés des coupes sur une variable, moyennée sur les arbres ; biaisée vers les variables à nombreux seuils.
importance par permutation (permutation importance): Perte de score de validation quand on mélange une colonne, ce qui casse son lien avec la cible en gardant sa distribution.
pseudo-résidu (pseudo-residual): Opposé de la dérivée de la perte par rapport à la prédiction courante, client par client ; la cible de l'arbre suivant.
pas d'apprentissage (learning rate): Facteur $\nu$ qui multiplie chaque nouvel arbre avant son ajout ; une petite valeur généralise mieux.
arrêt précoce (early stopping): Arrêter d'ajouter des arbres quand la perte de validation ne s'améliore plus pendant un nombre fixé de tours.
validation croisée imbriquée (nested cross-validation): Une validation croisée interne qui choisit les réglages dans chaque pli d'une validation croisée externe qui mesure.
test corrigé de Nadeau et Bengio (corrected resampled t-test): Test t apparié sur les différences par pli, dont le facteur $1/J$ devient $1/J + n_2/n_1$ (2003).
pré-enregistrement (preregistration): Écrire la règle de décision et la métrique avant de voir les résultats, pour que le choix ne suive pas les chiffres.

Les autres fiches du cours

Un résumé public par deck, dans l'ordre du cours.

IntroductionHivers de l'IA, emploi et méthode
OutilsKaggle, GitHub, Python : les outils
Séance 1Cadrage de projet et moindres carrés
Séance 2Vraisemblance et régression logistique
Séance 3Descente de gradient, ridge et lasso
Séance 4Seuil de décision et ML reproductible
DevoirUn modèle de référence défendable
Séance 5Noyaux, SVM et arbres de décision
Séance 6Forêts, boosting, comparaison honnête
Séance 7SHAP, équité, ACP et partitionnement
DevoirUn modèle champion documenté
Séance 8Réseaux de neurones, dérive, prédiction conforme
DevoirUn projet de machine learning livré
Séance 9Soutenir un projet de machine learning
RéférenceProjet de score de défaut de crédit
RéférenceRendements boursiers : XGBoost et sentiment
RéférenceLe code Python de chaque modèle
RéférenceDeep learning, l'essentiel
RéférenceDonnées ouvertes et projets par secteur
RéférenceManuel de l'expert data et IA
RéférenceData engineering, SRE et cloud
RéférencePanorama des modèles de machine learning

Toutes les fiches, en liste de lecture

L'attention et le transformer, pas à pas

À propos de ces fiches

Écrites par l'enseignant à partir des slides du deck, comme un résumé public : les idées clés, les formules et un exemple calculé. Les exercices, leurs corrigés, les contrôles et la notation restent dans le deck, pour les élèves du cours.

Révision : 16 octobre 2026.