R Academy · Leçon

Arbres de décision : fondement des ensembles

Construisez et visualisez des arbres de décision avec rpart et comprenez le compromis biais-variance.

Arbres de décision : fondement des ensembles est une leçon R Academy 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 R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Comment les arbres de décision se divisent

Un arbre de décision partitionne récursivement l'espace des variables en régions rectangulaires. À chaque nœud, l'algorithme examine toutes les variables et tous les points de séparation possibles afin de trouver la séparation qui distingue le mieux la variable cible. Le résultat est un arbre de règles si-alors.

library(rpart)

# Fit a classification tree
tree <- rpart(
  Species ~ .,
  data   = iris,
  method = 'class'  # use 'anova' for regression
)

print(tree)

Critères de séparation : GINI ou entropie

Le critère de séparation mesure l'impureté d'un nœud. L'impureté de GINI mesure la probabilité de mal classer un élément choisi au hasard. L'entropie (gain d'information) mesure la réduction du désordre informationnel. Les deux critères produisent généralement des arbres similaires ; GINI est plus rapide à calculer et constitue la valeur par défaut de rpart.

# Default: Gini impurity (parms = list(split = 'gini'))
tree_gini <- rpart(Species ~ ., data = iris, method = 'class')

# Using information gain (entropy)
tree_entropy <- rpart(
  Species ~ ., data = iris, method = 'class',
  parms = list(split = 'information')
)

cat('Gini root split:', tree_gini$frame$var[1])
cat('Entropy root split:', tree_entropy$frame$var[1])

printcp() — Tableau de complexité

printcp(tree) affiche le tableau des paramètres de complexité (CP). Chaque ligne indique la taille de l’arbre (nombre de divisions), son erreur relative sur les données d’entraînement et son erreur validée par validation croisée (xerror). Le tableau des CP sert à trouver le niveau optimal d’élagage.

tree <- rpart(medv ~ ., data = MASS::Boston, method = 'anova',
              control = rpart.control(minsplit = 5, cp = 0.001))

printcp(tree)

# Identify the CP with minimum cross-validated error
best_cp <- tree$cptable[
  which.min(tree$cptable[, 'xerror']),
  'CP'
]
cat('Best CP:', best_cp)

prune() — Élaguer l’arbre

prune(tree, cp) élague l’arbre jusqu’au niveau de complexité indiqué par cp. L’élagage évite le surajustement en supprimant les branches qui apportent peu de valeur prédictive. L’approche standard consiste à trouver le CP qui minimise l’erreur de CV, puis à effectuer l’élagage.

best_cp <- tree$cptable[
  which.min(tree$cptable[, 'xerror']), 'CP'
]

pruned_tree <- prune(tree, cp = best_cp)

cat('Original tree nodes:', nrow(tree$frame))
cat('Pruned tree nodes:', nrow(pruned_tree$frame))

rpart.plot() — Visualiser l’arbre

rpart.plot(tree), issu du package rpart.plot, produit une visualisation claire et en couleurs de l’arbre de décision. Chaque nœud interne affiche la règle de division, tandis que chaque feuille affiche la classe prédite et la proportion d’échantillons d’entraînement.

library(rpart.plot)

tree <- rpart(Species ~ ., data = iris, method = 'class')
pruned <- prune(tree, cp = 0.02)

rpart.plot(
  pruned,
  type   = 4,     # split labels on branches
  extra  = 104,   # show class + probability
  fallen.leaves = TRUE
)

Compromis biais-variance

Un arbre profond et non élagué présente un faible biais (il s’ajuste presque parfaitement aux données d’entraînement), mais une variance élevée (de petites modifications des données produisent des arbres très différents). Un arbre peu profond ou élagué présente un biais plus élevé, mais une variance plus faible. L’arbre optimal équilibre ces deux sources d’erreur.

Les méthodes d’ensemble comme les forêts aléatoires et le boosting s’attaquent directement à ce compromis.

# Deep tree = low bias, high variance (overfits)
deep_tree <- rpart(medv ~ ., data = MASS::Boston,
                   control = rpart.control(minsplit = 2, cp = 0))

# Shallow tree = high bias, low variance (underfits)
shallow_tree <- rpart(medv ~ ., data = MASS::Boston,
                      control = rpart.control(maxdepth = 2))

cat('Deep nodes:', nrow(deep_tree$frame))
cat('Shallow nodes:', nrow(shallow_tree$frame))

Surajustement d’un arbre de décision

Un arbre non élagué peut atteindre une erreur d’entraînement nulle en mémorisant chaque exemple d’entraînement. Lorsque le même arbre est évalué sur des données inédites, ses performances s’effondrent. Il s’agit de l’exemple classique de surajustement en apprentissage supervisé.

set.seed(42)
train_idx <- sample(nrow(MASS::Boston), 400)
train_bos <- MASS::Boston[train_idx, ]
test_bos  <- MASS::Boston[-train_idx, ]

# Fully grown tree
full <- rpart(medv ~ ., data = train_bos,
              control = rpart.control(cp = 0, minsplit = 2))

train_pred <- predict(full, train_bos)
test_pred  <- predict(full, test_bos)

cat('Train RMSE:', sqrt(mean((train_pred - train_bos$medv)^2)))
cat('Test  RMSE:', sqrt(mean((test_pred  - test_bos$medv)^2)))

Importance des variables avec rpart

rpart enregistre variable.importance pour chaque variable prédictive : l’amélioration totale du critère de division attribuable à cette variable pour l’ensemble des divisions. Cela fournit une indication rapide des caractéristiques qui déterminent les décisions du modèle.

tree <- rpart(medv ~ ., data = MASS::Boston, method = 'anova')

# Variable importance (sorted)
imp <- sort(tree$variable.importance, decreasing = TRUE)
print(imp)

# Quick barplot
barplot(imp, las = 2, main = 'Variable Importance',
        col = 'steelblue', cex.names = 0.8)

Des arbres aux ensembles

Un seul arbre de décision est instable : rééchantillonner les données produit des arbres très différents. Les méthodes d’ensemble exploitent cette instabilité :

Bagging / forêts aléatoires : faire la moyenne des prédictions de nombreux arbres entraînés sur des échantillons bootstrap.
Boosting : construire les arbres successivement, chacun corrigeant les erreurs de l’arbre précédent.
Les deux méthodes réduisent la variance tout en conservant la puissance d’expression des arbres.

# Demonstrating instability of a single tree
set.seed(1); t1 <- rpart(medv ~ ., data = MASS::Boston[sample(506, 400), ])
set.seed(2); t2 <- rpart(medv ~ ., data = MASS::Boston[sample(506, 400), ])

# Root split may differ between trees
cat('Tree 1 root split:', t1$frame$var[1])
cat('Tree 2 root split:', t2$frame$var[1])

Paramètres de contrôle de rpart

rpart.control() régit la croissance de l’arbre. Paramètres principaux : cp (pénalité de complexité), minsplit (nombre minimal d’observations pour tenter une division), minbucket (taille minimale d’une feuille) et maxdepth. Il est essentiel de les comprendre pour régler les modèles fondés sur des arbres.

ctrl <- rpart.control(
  cp        = 0.005,  # complexity penalty
  minsplit  = 20,     # min obs to try a split
  minbucket = 7,      # min obs in any leaf
  maxdepth  = 10      # max tree depth
)

tree <- rpart(medv ~ ., data = MASS::Boston,
              method = 'anova', control = ctrl)

printcp(tree)

Évaluer les performances de l’arbre

Après l’élagage, évaluez l’arbre sur l’ensemble de test mis de côté. Pour une régression, calculez la RMSE et le R au carré ; pour une classification, calculez l’exactitude et la matrice de confusion. Comparez ces mesures à celles de modèles de référence afin de comprendre la valeur apportée par un arbre unique.

pruned_tree <- prune(tree, cp = best_cp)

test_pred <- predict(pruned_tree, newdata = test_bos)

rmse <- sqrt(mean((test_pred - test_bos$medv)^2))
ss_res <- sum((test_pred - test_bos$medv)^2)
ss_tot <- sum((test_bos$medv - mean(test_bos$medv))^2)
r2 <- 1 - ss_res / ss_tot

cat('RMSE:', round(rmse, 3))
cat('R2:', round(r2, 3))

Vérification rapide

Quelle affirmation décrit le mieux l’objectif de l’appel à prune(tree, cp = best_cp) ?

Récapitulatif des arbres de décision

Points clés des arbres de décision — Fondement des ensembles :

Les arbres partitionnent récursivement l’espace des caractéristiques ; les divisions utilisent les critères de Gini ou d’entropie.
rpart(y ~ ., data, method) ajuste l’arbre ; printcp() affiche le tableau de complexité.
Trouvez le CP associé à l’erreur validée par validation croisée minimale, puis utilisez prune(tree, cp).
rpart.plot() visualise la structure de l’arbre.
Les arbres profonds se surajustent (faible biais, variance élevée) ; les arbres peu profonds sous-ajustent les données.
tree$variable.importance classe les variables prédictives selon leur amélioration totale des divisions.
Les méthodes d’ensemble (forêts aléatoires, boosting) surmontent l’instabilité d’un arbre unique.

# Standard rpart workflow
tree <- rpart(y ~ ., data = train, method = 'anova',
              control = rpart.control(cp = 0.001))

best_cp <- tree$cptable[which.min(tree$cptable[, 'xerror']), 'CP']
pruned  <- prune(tree, cp = best_cp)

test_pred <- predict(pruned, newdata = test)
rmse <- sqrt(mean((test_pred - test$y)^2))
cat('Pruned Tree RMSE:', rmse)

Questions Fréquemment Posées

La leçon « Arbres de décision : fondement des ensembles » est-elle gratuite ?

Oui — le texte complet de « Arbres de décision : fondement des ensembles » 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 R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Arbres de décision : fondement des ensembles » ?

Construisez et visualisez des arbres de décision avec rpart et comprenez le compromis biais-variance. Tu pratiques R Academy 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 R Academy ?

Aucune expérience préalable n'est requise. R Academy 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 : fondement des ensembles » ?

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 R Academy ?

Oui. Chaque leçon R Academy 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

Arbres de décision : fondement des ensembles
Forêts aléatoires avec ranger
Boosting de gradient avec xgboost
Importance des caractéristiques et interprétation des modèles

← Retour à R Academy