Arbre de Décision (Régression) : Guide complet — Principes, Exemples et Implémentation Python
Résumé
L’arbre de décision régression est une méthode d’apprentissage supervisé qui partitionne récursivement l’espace des caractéristiques en régions disjointes, puis attribue à chaque région la moyenne des valeurs cibles des points d’entraînement qui y tombent. Contrairement à l’arbre de classification qui utilise l’entropie ou l’indice de Gini, l’arbre de régression s’appuie sur la réduction de la variance (ou l’erreur quadratique moyenne, MSE) pour choisir ses points de coupure. Cette approche produit une fonction en escalier, capable de capturer des relations non linéaires complexes sans hypothèse de distribution préalable. Ce guide couvre le principe mathématique, l’intuition géométrique, l’implémentation Python avec scikit-learn, les hyperparamètres clés et les cas d’usage concrets.
Principe mathématique
Données et objectif
On dispose d’un jeu d’entraînement {(x₁, y₁), …, (xₙ, yₙ)} où xᵢ est un vecteur de caractéristiques et yᵢ est une cible continue. L’objectif est de construire une fonction f(x) qui approxime y avec une erreur quadratique minimale.
Critère MSE (Mean Squared Error)
L’algorithme CART (Classification And Regression Trees) évalue chaque split potentiel selon la réduction de l’erreur quadratique moyenne :
MSE(S) = (1 / |S|) × Σᵢ∈ₛ (yᵢ – y̅_S)²
où y̅_S est la moyenne des cibles dans le sous-ensemble S.
Choix du meilleur split
Pour chaque caractéristique j et chaque seuil s candidat, on divise le nœud courant en deux sous-ensembles :
- S_gauche = {i | x_ij ≤ s}
- S_droite = {i | x_ij > s}
Le coût du split est la somme pondérée des MSE des deux enfants :
Coût(S_gauche, S_droite) = (|S_gauche| / |S|) × MSE(S_gauche) + (|S_droite| / |S|) × MSE(S_droite)
L’algorithme teste systématiquement toutes les variables et tous les seuils uniques observés, puis retient le couple (j, s) qui minimise ce coût. Cette stratégie gloutonne garantit une réduction locale maximale de la variance à chaque étape.
Prédiction d’une feuille
Une fois la feuille terminale atteinte, la prédiction est simplement :
f(x) = y̅_feuille = (1 / |S_feuille|) × Σ des yᵢ dans la feuille
Cette moyenne constitue l’estimateur non biaisé de la cible dans la région couverte par la feuille.
Complexité et arrêt
La construction de l’arbre se poursuit jusqu’à ce qu’un critère d’arrêt soit atteint : profondeur maximale, nombre minimal d’échantillons dans un nœud, ou réduction de MSE insuffisante. Sans régularisation, l’arbre peut croître jusqu’à ce que chaque feuille contienne un seul échantillon, ce qui correspond à un surapprentissage parfait (MSE nul sur l’entraînement, performance catastrophique sur les nouvelles données).
Intuition géométrique
L’arbre comme partition de l’espace
Imaginez que l’on dispose d’un nuage de points en deux dimensions, avec une variable cible continue. L’arbre de décision régression découpe cet espace par des droites parallèles aux axes. Chaque coupe est une question binaire du type « La caractéristique X₁ est-elle inférieure à 3,7 ? ». Le résultat est un pavage rectangulaire de l’espace des entrées.
Chaque feuille = moyenne locale
Dans chaque rectangle terminal, l’arbre prédit la moyenne des y des points d’entraînement qui s’y trouvent. Graphiquement, cela revient à remplacer le nuage de points par une surface en marches d’escalier : plate dans chaque région, avec des discontinuités aux frontières des feuilles.
Profondeur vs. granularity
- Arbre peu profond (max_depth = 2-3) : quelques grandes régions, prédictions lissées, biais élevé mais variance faible.
- Arbre profond (max_depth = 10+) : de nombreuses petites régions, prédictions très fines, biais faible mais risque de surapprentissage.
Le paradoxe fondamental est le suivant : un arbre trop simple ne capture pas les variations locales des données, tandis qu’un arbre trop complexe apprend le bruit. L’élagage (pruning) cherche le point d’équilibre entre ces deux extrêmes.
Analogie avec les histogrammes
L’arbre de régression en une dimension est conceptuellement proche d’un histogramme adaptatif : au lieu de diviser l’axe en bins de largeur fixe, l’algorithme place les coupures là où la variance intra-bin est maximale. En multidimensionnel, cette idée se généralise en découpant selon différentes variables à chaque niveau.
Implémentation Python avec scikit-learn
Exemple fondamental : sinusoïde bruitée
import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
# Génération de données : sinusoïde avec bruit gaussien
rng = np.random.RandomState(42)
X = np.sort(5 * rng.rand(200, 1), axis=0)
y = np.sin(X).ravel() + 0.3 * rng.randn(200)
# Division entraînement / test
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
# Ajustement de l'arbre de régression
regressor = DecisionTreeRegressor(max_depth=4, random_state=42)
regressor.fit(X_train, y_train)
# Prédictions et évaluation
train_score = regressor.score(X_train, y_train)
test_score = regressor.score(X_test, y_test)
print(f"R² entraînement : {train_score:.4f}")
print(f"R² test : {test_score:.4f}")
Visualisation de l’impact de la profondeur
# Comparaison de plusieurs profondeurs
plt.figure(figsize=(14, 6))
X_plot = np.linspace(0, 5, 500).reshape(-1, 1)
for i, depth in enumerate([1, 2, 4, 10], 1):
model = DecisionTreeRegressor(max_depth=depth, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_plot)
plt.subplot(2, 2, i)
plt.scatter(X_train, y_train, c="darkorange", alpha=0.4, label="Données")
plt.plot(X_plot, y_pred, c="navy", linewidth=2, label=f"max_depth={depth}")
plt.title(f"Profondeur = {depth} (R²={model.score(X_test, y_test):.3f})")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.tight_layout()
plt.savefig("arbre_regression_depth_comparison.png", dpi=150)
plt.close()
Les résultats illustrent parfaitement le compromis biais-variance :
- max_depth = 1 : une seule coupure, le modèle est un escalier à deux marches. Il sous-ajuste massivement et ne capture pas la courbe sinusoïdale.
- max_depth = 2 : trois marches approximatives. Le modèle commence à suivre la tendance générale mais manque les détails.
- max_depth = 4 : seize marches. L’ajustement est bon, le R² test est proche du R² entraînement. C’est souvent la zone optimale.
- max_depth = 10 : l’arbre a jusqu’à 1024 feuilles possibles. Le modèle épouse le bruit, créant un escalier irrégulier avec de nombreuses marches parasites. Le R² entraînement approche 1.0, mais le R² test chute, signe de surapprentissage.
Élagage par coût-complexité (CCP)
from sklearn.tree import DecisionTreeRegressor
# Ajustement de l'arbre complet sans restriction
regressor_full = DecisionTreeRegressor(random_state=42)
regressor_full.fit(X_train, y_train)
# Extraction du chemin de régularisation CCP
path = regressor_full.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas = path.ccp_alphas
# Entraînement d'une série d'arbres élagués
models = []
for alpha in ccp_alphas[:-1]:
clf = DecisionTreeRegressor(ccp_alpha=alpha, random_state=42)
clf.fit(X_train, y_train)
models.append((alpha, clf))
# Sélection du meilleur alpha selon le score test
best_alpha, best_model = max(models, key=lambda m: m[1].score(X_test, y_test))
print(f"Meilleur ccp_alpha : {best_alpha:.6f}")
print(f"R² test du modèle élagué : {best_model.score(X_test, y_test):.4f}")
print(f"Nombre de feuilles : {best_model.get_n_leaves()}")
print(f"Profondeur effective : {best_model.get_depth()}")
L’élagage CCP est préférable à la limitation directe de max_depth car il opère un compromis optimal entre complexité (nombre de feuilles) et performance sur les données d’entraînement, selon un critère mathématiquement fondé.
Hyperparamètres clés
criterion
"squared_error"(par défaut) : minimise la variance intra-feuilles (MSE)."friedman_mse": variante proposée par Jerome Friedman. Peut donner de meilleurs splits dans certains cas."absolute_error": minimise la MAE. Plus robuste aux valeurs aberrantes."poisson": pour des comptes non négatifs suivant une loi de Poisson. Utile en actuariat.
max_depth
La profondeur maximale contrôle directement la capacité expressive du modèle. Un arbre de profondeur d peut avoir jusqu’à 2ᵈ feuilles. En pratique, des valeurs entre 3 et 8 sont fréquemment optimales. Au-delà de 15, le surapprentissage devient quasiment inévitable sans d’autres mécanismes de régularisation.
min_samples_split
Le nombre minimum d’échantillons requis pour diviser un nœud interne. La valeur par défaut est 2. Augmenter ce paramètre (à 5, 10 ou 20) réduit la complexité en empêchant les splits sur des sous-ensembles trop petits.
min_samples_leaf
Le nombre minimum d’échantillons que doit contenir chaque feuille terminale. C’est l’un des hyperparamètres les plus efficaces pour contrôler le surapprentissage. Une valeur de 5 à 10 est un bon point de départ.
max_features
Le nombre de caractéristiques considérées à chaque split. Par défaut, toutes les variables sont examinées. Réduire ce nombre introduit de l’aléa, utilisé dans les forêts aléatoires.
ccp_alpha
Le paramètre de régularisation pour l’élagage par coût-complexité. Chaque feuille ajoutée coûte ccp_alpha en pénalité. La validation croisée sur une grille de valeurs logarithmiques est la méthode recommandée pour sélectionner ce paramètre.
Avantages et limites
Avantages de l’arbre de décision régression
- Aucune hypothèse de distribution : l’algorithme ne présume ni linéarité, ni normalité des résidus, ni homoscédasticité. Il s’adapte à la forme des données.
- Invariance aux transformations monotones : appliquer un logarithme ou un rang à une variable n’affecte pas les coupures possibles, car seul l’ordre des valeurs compte.
- Gestion native des variables mixtes : variables numériques et catégorielles cohabitent sans encodage préalable.
- Interprétabilité : la structure en arbre est lisible par un humain, contrairement aux réseaux de neurones profonds.
- Rapidité d’inférence : une prédiction ne requiert que d comparaisons, où d est la profondeur. C’est extrêmement rapide en production.
- Robustesse aux valeurs manquantes : scikit-learn gère nativement les NaN depuis la version 1.1.
Limites de l’arbre de décision régression
- Instabilité : une légère modification des données peut produire un arbre radicalement différent. C’est la raison d’être du bagging et des forêts aléatoires.
- Sous-ajustement des tendances linéaires : un arbre approxime une droite par un escalier. Pour des relations linéaires, une régression linéaire est plus efficace.
- Extrapolation impossible : l’arbre ne peut pas prédire en dehors de la plage observée à l’entraînement.
- Difficulté avec les corrélations diagonales : les coupures parallèles aux axes nécessitent de nombreux splits pour approximer une frontière oblique.
- Biais vers les variables à nombreuses modalités : une variable continue avec beaucoup de valeurs a plus de candidats de split, faussant la sélection.
- Prédictions en escalier : la fonction de décision est discontinue, ce qui peut être non physique (température, pression).
4 cas d’usage concrets
Cas 1 — Estimation immobilière
Un arbre de régression peut estimer le prix d’un bien immobilier à partir de sa superficie, du nombre de pièces, de l’année de construction, du quartier et de la distance aux transports. La structure en arbre produit des règles explicites : par exemple, « Surface > 80m² ET quartier centre ET année > 2000 → prix moyen = 450 000 euros ». Cette transparence est un atout majeur face aux acquéreurs et aux régulateurs. Pour améliorer la précision, on combine généralement plusieurs arbres dans un Gradient Boosting (XGBoost, LightGBM).
Cas 2 — Prévision de la demande énergétique
Les gestionnaires de réseau électrique prévoient la consommation horaire en fonction de la température extérieure, du jour de la semaine, de l’heure et des jours fériés. L’arbre de régression capture naturellement les effets de seuil : par exemple, la consommation explose en dessous de 5°C (chauffage) et au-dessus de 30°C (climatisation). Ces transitions brusques sont idéalement modélisées par des coupures d’arbre. La prédiction rapide permet un ajustement en temps réel de la production.
Cas 3 — Évaluation du risque crédit
En scoring crédit, l’arbre de régression évalue la probabilité de défaut d’un emprunteur en fonction de son revenu, de son endettement, de son historique de paiement et de l’ancienneté dans l’emploi. Les règles de décision issues de l’arbre sont directement exploitables pour justifier un refus de prêt, ce qui est une exigence réglementaire dans de nombreuses juridictions (droit à l’explication RGPD en Europe).
Cas 4 — Calibration de capteurs industriels
Dans l’industrie, les capteurs bon marché présentent des distorsions non linéaires par rapport aux capteurs de référence. Un arbre de régression entraîné sur des paires (mesure capteur bon marché, mesure capteur référence) apprend une fonction de correction par morceaux. Chaque feuille correspond à un intervalle de valeurs brutes, et la prédiction est le biais moyen dans cet intervalle. Cette approche est simple, déterministe et déployable dans des microcontrôleurs embarqués à ressources limitées.
Voir aussi
- Maîtrisez le Mahjong avec Python : Guide Complet pour Développeurs et Enthousiastes
- Maîtriser les Graphes en Grille avec Python : Guide Complet et Astuces d’Optimisation
