#arbres-de-decision — Apprentissage supervisé

Un arbre qui découpe le plan en rectangles : Gini, entropie, profondeur, élagage — et le sur-apprentissage qu'on voit à l'œil nu.

Ce que tu vas manipuler

Bienvenue dans #arbres-de-decision. À gauche, le plan [-2, 2]² : 120 points d'entraînement (bleus et roses) et 60 points de validation (plus petits, translucides). À droite, un arbre réduit à une racine et deux feuilles : il a posé une seule question — x ≤ 0.88 ? — et le plan est coupé en deux rectangles, l'un déjà presque pur, l'autre encore mélangé. C'est le jeu des vingt questions appliqué à un nuage de points : choisir une variable et un seuil, séparer, recommencer dans chaque moitié. Chaque feuille vote pour sa classe majoritaire, et l'opacité de son rectangle dit à quel point elle est pure.
Ajoute un étage : /split. Chaque feuille encore impure pose à son tour sa propre question — deux questions en cascade, quatre rectangles au plus.
Encore un étage : /split. À profondeur 3, l'arbre pourrait aller jusqu'à huit feuilles, mais il s'arrête de lui-même partout où une feuille est déjà pure : plus rien à gagner.
Comment l'arbre choisit-il sa question ? Il essaie tous les seuils possibles sur x et sur y et garde celui qui fait le plus baisser l'impureté des deux moitiés. Deux mesures existent : l'indice de Gini (par défaut) et l'entropie. Compare : /critere entropie.
Laissons maintenant l'arbre grandir autant qu'il veut : /profondeur 8. Il coupera jusqu'à ce que chaque feuille soit pure — quitte à isoler un point tout seul.
Le remède classique : interdire les feuilles trop petites. /min-feuille 8 impose au moins huit points par feuille — une forme d'élagage préventif, décidé avant même de couper.
Changeons de terrain : /dataset damier. Quatre quadrants alternés, un XOR étalé : aucune droite ne sépare ces deux classes, une régression logistique y échoue complètement.
Dernier atout : un arbre se lit. Pose-lui une question : /predire 1 -1. Le point requête apparaît en jaune dans le plan et son chemin racine → feuille se surligne dans l'arbre, test après test.
À toi de jouer : /elaguer pour remonter d'un étage, /profondeur 2 pour voir le damier résolu en deux questions, /bruit 0.4 puis /profondeur 8 pour un sur-apprentissage spectaculaire, /graine 7 pour un autre tirage (un arbre glouton est instable — c'est la raison d'être des forêts aléatoires, qui moyennent des centaines d'arbres), /dataset blobs pour voir l'escalier approcher une diagonale, /reinit pour repartir. Prochaine étape : #knn, qui décide sans construire aucun modèle, puis #sur-apprentissage pour retrouver le même piège avec un réseau de neurones.

Commandes du canal

/profondeur <1..8> — Fixe la profondeur maximale de l'arbre, qui est recalculé.
/split — Ajoute un étage : profondeur maximale + 1.
/elaguer — Retire un étage : profondeur maximale − 1.
/critere <gini|entropie> — Choisit la mesure d'impureté : indice de Gini ou entropie.
/min-feuille <1..20> — Nombre minimal de points d'entraînement par feuille (élagage préventif).
/dataset <blobs|lunes|damier> — Change le jeu de données (train et validation régénérés).
/bruit <0..0.5> — Dispersion des points et proportion d'étiquettes erronées (jeux régénérés).
/graine <1..99> — Autre tirage aléatoire des points (même distribution).
/predire <x=-2..2> <y=-2..2> — Place un point requête et surligne son chemin racine → feuille.
/reinit — Revient à l'état initial : lunes, profondeur 1, Gini, sans requête.

Glossaire

Arbre de décision: Modèle qui classe un point en lui posant une suite de questions du type x ≤ seuil ?, de la racine jusqu'à une feuille. Chaque question coupe l'espace en deux : l'arbre découpe le plan en rectangles.
Nœud / feuille: Un nœud interne porte un test (variable + seuil) et deux enfants : oui à gauche, non à droite. Une feuille ne teste plus rien : elle prédit la classe majoritaire des points d'entraînement qu'elle contient.
Impureté de Gini: Mesure du mélange des classes dans un nœud : 1 − Σ p². Vaut 0 pour un nœud pur et 0,5 pour un mélange 50/50 à deux classes. C'est le critère par défaut de CART et de scikit-learn.
Entropie: Autre mesure du mélange : −Σ p·log₂ p, en bits. Vaut 0 pour un nœud pur et 1 bit pour un mélange 50/50. En pratique, Gini et entropie produisent des arbres très proches.
Gain d'information: Baisse d'impureté obtenue par une coupe : impureté du parent moins la moyenne pondérée de celle des deux enfants. À chaque nœud, l'algorithme glouton teste tous les seuils et garde celui de plus grand gain.
Profondeur: Nombre maximal de questions entre la racine et une feuille. Plus l'arbre est profond, plus il peut découper finement — et plus il risque de mémoriser le bruit. C'est l'hyperparamètre principal d'un arbre.
Élagage: Simplifier un arbre pour qu'il généralise mieux : soit en l'empêchant de grandir (profondeur maximale, nombre minimal de points par feuille — pré-élagage), soit en supprimant après coup les branches qui n'aident pas la validation (post-élagage).
Sur-apprentissage: Quand le modèle colle aux points d'entraînement au point d'en mémoriser les exceptions : exactitude d'entraînement proche de 100 %, validation qui stagne ou recule. Sur un arbre, il se voit : des rectangles minuscules autour de points isolés.
Forêt aléatoire: Ensemble de centaines d'arbres, chacun entraîné sur un rééchantillonnage des données et un sous-ensemble de variables, dont on moyenne les votes. Elle corrige le principal défaut de l'arbre seul : son instabilité.
Interprétabilité: Capacité à expliquer une prédiction en termes humains. Un arbre est interprétable par construction : le chemin racine → feuille est une liste de règles lisibles (« y ≤ −0.3 et x > 0.9 donc rose »).

Autres canaux du thème Apprentissage supervisé

#entrainement-live — Six algorithmes qui apprennent sous tes yeux, comme une vidéo : REC, timecode, sous-titres, métriques en direct. Regarder est gratuit ; toucher au modèle est Premium.
#regression-lineaire — Ajuster une droite : moindres carrés, résidus, MSE, R² et descente de gradient — la première brique de tout apprentissage supervisé.
#regression-logistique — Classer en deux catégories : sigmoïde, frontière de décision, seuil et log-loss — et pourquoi une droite ne suffit pas toujours.
#arbres-de-decision — Un arbre qui découpe le plan en rectangles : Gini, entropie, profondeur, élagage — et le sur-apprentissage qu'on voit à l'œil nu.
#knn — Les k plus proches voisins : classer par ressemblance, choisir k, changer de distance — et voir la frontière se lisser ou se déchirer.
#svm-marges — Machines à vecteurs de support : la plus large marge possible, le paramètre C, et le noyau RBF qui courbe la frontière.
#metriques-classification — Précision, rappel, F1, matrice de confusion, ROC et AUC : lire honnêtement un classifieur, surtout quand les classes sont déséquilibrées.