0Pricing
Learn AI with Python · Leçon

Arbres de décision : théorie et implémentation

Impureté de Gini, gain d’information, profondeur de l’arbre, surapprentissage — sklearn DecisionTreeClassifier.

Arbres de décision : théorie et implémentation est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Qu’est-ce qu’un arbre de décision

Un arbre de décision divise les données en branches selon les valeurs des caractéristiques, en posant des questions auxquelles on répond par oui ou non jusqu’à parvenir à une prédiction dans un nœud feuille.

Chaque nœud interne teste une caractéristique, chaque branche représente un résultat et chaque feuille attribue une classe. Les arbres sont faciles à interpréter, car vous pouvez suivre le chemin des décisions.

Impureté de Gini

L’impureté de Gini mesure à quel point les classes sont mélangées dans un nœud. Un nœud pur, qui ne contient qu’une seule classe, a une impureté de Gini égale à 0.

La formule est Gini = 1 - sum(p_i^2), où p_i est la proportion de la classe i. L’arbre choisit les séparations qui réduisent le plus l’impureté.

import numpy as np

def gini(labels):
    classes, counts = np.unique(labels, return_counts=True)
    probs = counts / counts.sum()
    return 1 - np.sum(probs ** 2)

print(gini([0, 0, 1, 1]))   # 0.5 (max mix)
print(gini([0, 0, 0, 0]))   # 0.0 (pure)

Gain d’information et entropie

Un autre critère de séparation est le gain d’information, fondé sur l’entropie. L’entropie est -sum(p_i * log2(p_i)).

Gain d’information = entropie du parent − entropie pondérée des enfants. Gini et entropy produisent généralement des arbres similaires : Gini est légèrement plus rapide à calculer.

import numpy as np

def entropy(labels):
    _, counts = np.unique(labels, return_counts=True)
    p = counts / counts.sum()
    return -np.sum(p * np.log2(p))

print(entropy([0, 0, 1, 1]))   # 1.0
print(entropy([0, 0, 0, 1]))   # ~0.81

Entraîner un DecisionTreeClassifier

Scikit-learn fournit DecisionTreeClassifier. Vous choisissez le critère de séparation avec le paramètre criterion (gini ou entropy).

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)

clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))

Surapprentissage et max_depth

Un arbre sans contrainte grandit jusqu’à ce que chaque feuille soit pure, en mémorisant le bruit. Il surapprend.

Le paramètre max_depth limite la profondeur maximale de l’arbre et l’oblige à généraliser. Une profondeur plus faible produit un modèle plus simple et moins de surapprentissage.

from sklearn.tree import DecisionTreeClassifier

shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training set

Autres paramètres de pré-élagage

En plus de max_depth, vous pouvez contrôler la croissance avec :

  • min_samples_split : nombre minimal d’échantillons pour diviser un nœud
  • min_samples_leaf : nombre minimal d’échantillons dans une feuille
  • max_leaf_nodes : limite du nombre total de feuilles

Ces paramètres réduisent tous la variance et combattent le surapprentissage.

from sklearn.tree import DecisionTreeClassifier

clf = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=0,
)

Visualiser avec plot_tree

plot_tree dessine l’arbre complet afin que vous puissiez lire chaque séparation, la valeur de Gini et la répartition des classes dans chaque nœud.

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)

plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()

Importance des caractéristiques

Après l’entraînement, feature_importances_ indique dans quelle mesure chaque caractéristique a réduit l’impureté sur l’ensemble des séparations. La somme des valeurs est égale à 1.0.

C’est un moyen rapide de classer les entrées qui comptent le plus pour le modèle.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)

for name, imp in zip(data.feature_names, clf.feature_importances_):
    print(f"{name}: {imp:.3f}")

Élagage selon la complexité-coût (ccp_alpha)

Le post-élagage fait d’abord pousser un arbre complet, puis en supprime les branches faibles. Le paramètre ccp_alpha contrôle l’intensité de l’élagage : une valeur alpha plus élevée supprime davantage de nœuds.

Utilisez cost_complexity_pruning_path pour trouver des valeurs alpha candidates.

from sklearn.tree import DecisionTreeClassifier

base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas

pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)

Choisir la meilleure valeur alpha

Pour choisir ccp_alpha, entraînez un arbre pour chaque valeur alpha candidate et comparez leur exactitude sur l’ensemble de validation. La meilleure valeur alpha établit un équilibre entre exactitude et simplicité.

from sklearn.tree import DecisionTreeClassifier

scores = []
for a in alphas:
    t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
    t.fit(Xtr, ytr)
    scores.append((a, t.score(Xte, yte)))

best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])

Forces et faiblesses

Avantages : interprétable, aucune mise à l’échelle nécessaire, gère les frontières non linéaires et les types de données mixtes.

Inconvénients : variance élevée (de petites modifications des données peuvent inverser l’arbre), tendance au surapprentissage et séparations alignées sur les axes uniquement. Ces faiblesses motivent les méthodes d’ensemble comme les forêts aléatoires.

Vérification rapide

Vérifiez votre compréhension des concepts liés aux arbres de décision.

Récapitulatif

Récapitulatif : les arbres de décision divisent les données selon l’impureté de Gini ou le gain d’information. Contrôlez le surapprentissage avec le pré-élagage (max_depth, min_samples_leaf) ou le post-élagage (ccp_alpha). Examinez les modèles avec plot_tree et feature_importances_. Leur variance élevée motive les méthodes d’ensemble.

Questions Fréquemment Posées

La leçon « Arbres de décision : théorie et implémentation » est-elle gratuite ?

Oui — le texte complet de « Arbres de décision : théorie et implémentation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Arbres de décision : théorie et implémentation » ?

Impureté de Gini, gain d’information, profondeur de l’arbre, surapprentissage — sklearn DecisionTreeClassifier. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Arbres de décision : théorie et implémentation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Arbres de décision : théorie et implémentation
  2. Forêts aléatoires et bagging
  3. Gradient boosting : GBM et XGBoost
  4. LightGBM et CatBoost
← Retour à Learn AI with Python