Le problème
Un recruteur regarde une fiche de joueur sans la ligne « poste » et devine en quelques secondes : « grand, lourd, beaucoup de rebonds, peu de passes… c'est un pivot ». Il ne fait pas un calcul. Il enchaîne des questions. « Est-il grand ? Plutôt costaud ? Distribue-t-il le jeu ou protège-t-il le cercle ? » De fil en aiguille, il tombe sur meneur, arrière, ailier, ailier fort ou pivot.
La question de ce module : peut-on apprendre à une machine ce flair de recruteur ? On a 413 joueurs d'une saison NBA, avec leur physique (taille, poids) et leurs stats par match (rebonds, passes, contres, tirs à 3 points, points). On cache la colonne « poste » et on demande au modèle de la retrouver. Pas par une formule abstraite : par une cascade de questions oui/non, exactement comme le recruteur. C'est le rôle du decision tree, notre premier modèle non linéaire, et le plus lisible de tous.
Le concept (et ce que tu vas gagner)
Un decision tree (arbre de décision) prédit en posant une suite de questions sur les variables, jusqu'à une réponse. Pas de droite, pas de coefficient à interpréter : un organigramme que tu peux lire à voix haute.
À la fin de ce module, tu sauras :
- lire un arbre entraîné et expliquer chacune de ses décisions à un entraîneur,
- comprendre comment l'arbre choisit ses questions (l'impureté, Gini et entropie, et d'où vient ce calcul),
- diagnostiquer le sur-apprentissage d'un arbre trop profond à partir de l'écart entraînement/test,
- régler les deux boutons qui comptent (
max_depth,ccp_alpha) et élaguer un arbre par validation croisée, - savoir quand un arbre bat un modèle linéaire et quand c'est l'inverse.
C'est aussi la brique de base des deux modules suivants (random forest, boosting), donc autant la comprendre vraiment.
La théorie en profondeur
L'intuition : découper l'espace en boîtes
Une régression trace une droite (ou un plan) à travers les données. Un arbre fait tout autre chose : il découpe l'espace en boîtes par des seuils successifs. « Taille au-dessus de 78,5 pouces ? » coupe le plan des joueurs en deux. Dans la moitié des grands, on recoupe selon le poids. Dans la moitié des petits, selon autre chose. À chaque coupure, on obtient des rectangles de plus en plus petits, et chaque rectangle reçoit une étiquette : le poste majoritaire des joueurs qui y tombent.
C'est ce découpage par seuils qui rend l'arbre non linéaire : la frontière entre deux postes n'est pas une droite, c'est un escalier de rectangles. L'arbre peut donc capturer des règles qu'une droite rate, du genre « grand ET lourd → pivot, mais grand ET léger → ailier fort ».
Le vocabulaire tient en trois mots : un nœud est une question, une branche est une réponse, une feuille est une boîte finale qui donne la prédiction.
La clé : comment l'arbre choisit ses questions
Pourquoi commencer par la taille plutôt que par les points ? L'arbre ne choisit pas au hasard. À chaque nœud, il teste toutes les coupures possibles sur toutes les variables (« taille ≤ 74 ? », « taille ≤ 78 ? », « poids ≤ 200 ? »…) et garde celle qui rend les deux groupes enfants les plus purs, c'est-à-dire les plus homogènes en poste.
Pour mesurer ce « désordre », on utilise l'impureté. La plus courante est l'indice de Gini. Pour un groupe où la classe k représente une proportion p_k, l'indice de Gini vaut :
Gini = 1 − Σ p_k²
D'où vient cette formule ? Imagine que tu tires un joueur au hasard dans le groupe, puis que tu devines son poste en piochant une étiquette au hasard selon les proportions du groupe. La probabilité de te tromper est exactement 1 − Σ p_k². Un groupe 100 % pivots a Gini = 1 − 1² = 0 : impossible de se tromper, pureté parfaite. Un groupe partagé en cinq postes égaux a Gini = 1 − 5 × (1/5)² = 0,8 : désordre maximal. L'impureté, c'est donc le taux d'erreur d'un devineur naïf.
L'entropie (−Σ p_k log₂ p_k) raconte la même histoire en mesurant la quantité d'information manquante. En pratique, Gini et entropie donnent des arbres quasi identiques ; Gini est juste un peu plus rapide à calculer.
L'arbre choisit, à chaque nœud, la coupure qui maximise le gain : l'impureté du parent moins la moyenne pondérée de l'impureté des enfants. Sur nos données d'entraînement, l'impureté de départ vaut 0,795 (les cinq postes sont presque équilibrés). La première coupure sur la taille (≤ 78,5 pouces) descend l'impureté moyenne à 0,662, soit un gain de 0,133. Aucune autre coupure ne fait mieux : voilà pourquoi la taille passe en premier. Elle sépare nettement les grands des petits, et c'est l'information la plus discriminante.
La construction récursive : l'algorithme CART
Une fois la première coupure trouvée, on recommence le même travail sur chacun des deux groupes enfants, puis sur leurs enfants, et ainsi de suite. C'est une construction récursive : la même règle (chercher la coupure au plus fort gain) appliquée encore et encore, sur des groupes de plus en plus petits, jusqu'à une condition d'arrêt (groupe pur, profondeur atteinte, trop peu de joueurs). L'algorithme qui fait ça dans scikit-learn s'appelle CART (Classification And Regression Trees). Deux traits à retenir. Il est binaire : chaque question a exactement deux réponses, oui ou non, jamais trois branches d'un coup. Et il est glouton (greedy) : à chaque nœud il prend la meilleure coupure du moment, sans se demander si une coupure un peu moins bonne maintenant ouvrirait de meilleures coupures plus bas. Cette myopie le rend rapide, mais elle explique aussi pourquoi un arbre n'est jamais garanti optimal, et pourquoi il est sensible : un petit changement dans les données peut faire basculer une coupure du haut, et tout l'arbre en dessous avec elle.
Le bouton qui compte : la profondeur
Un arbre peu profond pose peu de questions : modèle simple, peu de boîtes, frontières grossières. Un arbre profond pose beaucoup de questions, jusqu'à isoler chaque joueur d'entraînement dans sa propre boîte. À ce stade, il ne généralise plus, il mémorise.
La profondeur (max_depth) est le bouton principal de la flexibilité, donc du sur-apprentissage. Tu retrouves ici le compromis biais-variance du module de généralisation, en version arbre : trop peu profond, l'arbre sous-apprend (biais élevé) ; trop profond, il sur-apprend (variance élevée). Sur nos données, profondeur 1 plafonne à 41 % en test (trop simple), profondeur illimitée atteint 100 % en entraînement mais seulement 53 % en test (il a appris le bruit). Le bon réglage se trouve au milieu, et on ne le devine pas : on le mesure par validation croisée.
Diagnostics : élagage, importance, matrice de confusion
Trois outils permettent de juger la santé d'un arbre.
L'élagage (pruning) coupe les branches qui n'apportent presque rien. Plutôt que de fixer max_depth à la main, on laisse l'arbre pousser puis on le taille avec ccp_alpha : plus ce paramètre est grand, plus on coupe. Sur nos données, l'arbre brut a 94 feuilles ; après élagage par validation croisée, il tombe à 8 feuilles pour une performance de test équivalente. Un arbre dix fois plus simple, donc dix fois plus lisible, sans rien perdre.
L'importance des variables dit quelles variables l'arbre utilise vraiment pour réduire l'impureté. Ici, la taille pèse 0,61 et le poids 0,24 : à elles deux, elles font 85 % du travail. Les points, les passes, les contres complètent à la marge. C'est cohérent avec le métier : le poste se devine d'abord au physique.
La matrice de confusion montre où l'arbre se trompe, pas juste combien de fois. Et son verdict est instructif : l'arbre confond surtout pivots et ailiers forts, et meneurs avec arrières. Ce ne sont pas des erreurs bêtes, ce sont les frontières réellement floues du basket moderne.
Pièges à connaître
- L'instabilité. Change quelques joueurs d'entraînement et l'arbre peut choisir une autre première coupure, donc une structure très différente. Un seul arbre est fragile. C'est précisément ce que le random forest corrigera au module suivant.
- L'importance biaisée. L'importance par impureté favorise les variables à beaucoup de valeurs distinctes. À garder en tête (on verra une mesure plus honnête plus tard).
- L'illusion du 100 %. Un arbre qui réussit parfaitement sur l'entraînement n'a rien prouvé : c'est le signal d'alarme du sur-apprentissage, pas un trophée.
- Pas d'extrapolation. L'arbre prédit par boîtes ; hors de la plage des données vues, il répète la dernière feuille. Il ne prolonge pas une tendance comme une droite.
Le code
On charge les joueurs, on cache le poste, et on entraîne un petit arbre lisible. Le poste est la cible (y) ; le physique et les stats sont les variables (X). On fixe random_state=42 partout pour des résultats reproductibles.
Lis l'arbre comme un recruteur. Première question : la taille. Petit (≤ 74 pouces) → meneur (PG) ; un peu plus grand → arrière (SG). Grand (> 78,5 pouces) → on tranche au poids : léger → ailier fort (PF), lourd → pivot (C). L'arbre a retrouvé seul la logique « grand et lourd = pivot », et tu peux la lire en clair, sans une seule formule. C'est l'atout numéro un des arbres : tu vois pourquoi il décide.
Maintenant, vérifions le calcul d'impureté à la main, pour comprendre pourquoi la taille passe en premier.
On retrouve à la main ce que sklearn calcule à l'intérieur : la coupure sur la taille fait chuter l'impureté de 0,795 à 0,662, un gain de 0,133. C'est la meilleure première question possible.
Passons au diagnostic du sur-apprentissage. On fait varier la profondeur et on regarde l'écart entraînement/test, doublé d'une validation croisée à 5 plis pour un verdict honnête.
Le motif est net. L'exactitude d'entraînement grimpe jusqu'à 1,000, mais le test stagne autour de 0,53 et la validation croisée plafonne dès la profondeur 3 (0,579) avant de redescendre. L'écart qui se creuse entre la courbe d'entraînement et les deux autres, c'est la signature visuelle du sur-apprentissage. Conclusion : inutile d'aller au-delà d'une profondeur de 3 ou 4.
Plutôt que de fixer la profondeur au jugé, laissons l'arbre pousser puis élaguons-le proprement avec ccp_alpha, réglé par validation croisée.
L'arbre brut a 94 feuilles ; l'arbre élagué tombe à 8 feuilles (profondeur 4) pour une performance de test équivalente. On a divisé sa taille par dix sans rien perdre, et il est redevenu lisible. C'est tout l'intérêt de l'élagage : la simplicité gratuite.
La visualisation forte du module : les régions de décision. On entraîne un arbre sur deux variables seulement (taille et poids) pour pouvoir dessiner les boîtes qu'il découpe, et voir les joueurs réels tomber dedans.
Tu vois clairement les rectangles, séparés par des frontières en escalier, jamais en diagonale : c'est la signature d'un arbre. Les meneurs occupent le coin « petit et léger », les pivots le coin « grand et lourd ». Et tu vois aussi le chevauchement réel : au centre, les postes se mélangent, et aucune boîte ne les sépare proprement.
Pour finir, deux diagnostics côte à côte : où l'arbre se trompe (matrice de confusion) et comment il se compare à un modèle linéaire (régression logistique).
Deux enseignements. D'abord, la matrice de confusion confirme le « positionless » : l'arbre confond pivots (C) et ailiers forts (PF), meneurs (PG) et arrières (SG). Ses erreurs sont les frontières floues du jeu, pas du bruit. Ensuite, sur ces données, la régression logistique (0,653 en test) bat l'arbre (0,532). Sans surprise : la séparation des postes est largement monotone (plus grand → plutôt intérieur), terrain de jeu idéal d'un modèle linéaire. L'arbre est plus lisible, mais un seul arbre n'est pas le plus précis. Retiens cette leçon : un arbre seul gagne en clarté, pas toujours en exactitude. Les deux prochains modules corrigent ça en assemblant beaucoup d'arbres.
À toi de jouer
Reprends l'arbre du cell-01 et tente d'améliorer la séparation entre pivots et ailiers forts sans toucher au physique. Ajoute ou enlève des stats de jeu dans feats (par exemple, garde blk_pg, orb_pg, fg3_pg qui distinguent un protecteur de cercle d'un ailier qui shoote de loin), relance la matrice de confusion du cell-06, et regarde si la case C/PF se vide. Question bonus : avec criterion='entropy' au lieu de Gini, l'arbre change-t-il beaucoup ? Compare l'exactitude test et la première coupure.
Conclusion
Ce que tu as appris
- Un decision tree prédit par une cascade de questions oui/non (nœuds, branches, feuilles) et découpe l'espace en boîtes : c'est un modèle non linéaire et lisible.
- Il choisit ses coupures pour réduire l'impureté (Gini =
1 − Σ p_k², le taux d'erreur d'un devineur naïf, ou l'entropie), en gardant à chaque nœud la question au plus fort gain. - La profondeur règle la flexibilité : trop faible, l'arbre sous-apprend ; trop forte, il mémorise (train
1,000, test en chute). On la cale par validation croisée. - L'élagage (
ccp_alpha) simplifie l'arbre sans perte : de 94 à 8 feuilles ici. - Tu sais lire les diagnostics : importance des variables (taille + poids = 85 %), matrice de confusion (où l'arbre se trompe), comparaison avec un modèle linéaire.
Ce que ça change pour le basket
Les arbres sont prisés en scouting et en aide à la décision parce qu'ils sont exploitables. Un modèle qui dit « si la taille dépasse X et le poids Y, alors profil intérieur » se discute avec un entraîneur : il comprend la règle, peut la contester, l'affiner. Là où une régression livre des coefficients abstraits, l'arbre livre un organigramme qu'on peut afficher au tableau. Et la matrice de confusion raconte une vraie histoire de basket : le jeu moderne a effacé les frontières entre les postes.
Ce qui vient ensuite
Un seul arbre est lisible mais fragile : change quelques joueurs et sa structure bascule. La parade ? En faire voter des centaines. Le prochain module construit un random forest, où une foule d'arbres imparfaits, chacun entraîné sur un échantillon différent, bat de loin l'arbre solitaire. On verra exactement pourquoi la moyenne de modèles instables devient stable.