0Pricing
R Academy · Lezione

Alberi decisionali: la base degli ensemble

Costruisca e visualizzi alberi decisionali con rpart e comprenda il compromesso bias-varianza

Alberi decisionali: la base degli ensemble è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Come vengono suddivisi i dati dagli alberi decisionali

Un albero decisionale suddivide ricorsivamente lo spazio delle feature in regioni rettangolari. A ogni nodo, l'algoritmo esamina tutte le feature e tutti i possibili punti di suddivisione per trovare quello che separa meglio la variabile target. Il risultato è un albero di regole if-else.

library(rpart)

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

print(tree)

Criteri di suddivisione: GINI ed entropia

Il criterio di suddivisione misura l'impurità di un nodo. L'impurità di Gini misura la probabilità di classificare erroneamente un elemento scelto casualmente. L'entropia, o guadagno informativo, misura la riduzione del disordine informativo. Entrambi producono generalmente alberi simili; Gini è più veloce da calcolare ed è il valore predefinito di 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() — Tabella della complessità

printcp(tree) stampa la tabella del parametro di complessità (CP). Ogni riga mostra la dimensione dell'albero (numero di split), l'errore relativo sui dati di training e l'errore convalidato tramite cross-validation (xerror). La tabella CP viene utilizzata per trovare il livello di potatura ottimale.

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() — Potatura dell'albero

prune(tree, cp) pota l'albero riportandolo al livello di complessità specificato da cp. La potatura previene l'overfitting eliminando i rami che offrono poco valore predittivo. L'approccio standard consiste nel trovare il valore di CP che minimizza l'errore di cross-validation e quindi potare l'albero.

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() — Visualizzazione dell'albero

rpart.plot(tree) del pacchetto rpart.plot produce una visualizzazione chiara e a colori dell'albero decisionale. Ogni nodo interno mostra la regola di split; ogni foglia mostra la classe prevista e la proporzione dei campioni di training.

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
)

Compromesso bias-varianza

Un albero profondo e non potato ha bias basso (si adatta quasi perfettamente ai dati di training), ma varianza elevata (piccole variazioni nei dati producono alberi molto diversi). Un albero poco profondo o potato ha un bias maggiore, ma una varianza inferiore. L'albero ottimale bilancia queste due fonti di errore.

I metodi ensemble, come le random forest e il boosting, affrontano direttamente questo compromesso.

# 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))

Overfitting di un albero decisionale

Un albero non potato può ottenere un errore di training pari a zero memorizzando ogni esempio di training. Quando lo stesso albero viene valutato su dati non osservati, le prestazioni crollano. Questo è l'esempio canonico di overfitting nell'apprendimento supervisionato.

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)))

Importanza delle variabili con rpart

rpart registra variable.importance per ogni predittore: il miglioramento totale del criterio di split attribuibile a quella variabile in tutti gli split. Questo fornisce una rapida indicazione delle feature che determinano le decisioni del modello.

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)

Dagli alberi agli ensemble

Un singolo albero decisionale è instabile: ricampionando i dati si ottengono alberi molto diversi. I metodi ensemble sfruttano questa instabilità:

  • Bagging / Random Forest: calcolano la media di molti alberi addestrati su campioni bootstrap.
  • Boosting: costruisce gli alberi in sequenza, facendo in modo che ciascuno corregga gli errori dell'albero precedente.
  • Entrambi riducono la varianza mantenendo la capacità espressiva degli alberi.
# 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])

Parametri di controllo di rpart

rpart.control() governa il modo in cui cresce l'albero. Parametri fondamentali: cp (penalità di complessità), minsplit (numero minimo di osservazioni per tentare uno split), minbucket (dimensione minima di una foglia) e maxdepth. Comprendere questi parametri è essenziale per ottimizzare i modelli basati sugli alberi.

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)

Valutazione delle prestazioni dell'albero

Dopo la potatura, valuti l'albero sul test set messo da parte. Per la regressione, calcoli RMSE e R-quadro; per la classificazione, calcoli l'accuratezza e la matrice di confusione. Confronti queste metriche con quelle dei modelli di riferimento per comprendere il valore offerto da un singolo albero.

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))

Verifica rapida

Quale affermazione descrive meglio lo scopo della chiamata prune(tree, cp = best_cp)?

Riepilogo degli alberi decisionali

Concetti chiave di Alberi decisionali — Fondamento degli ensemble:

  • Gli alberi suddividono ricorsivamente lo spazio delle feature; gli split usano i criteri Gini o entropia.
  • rpart(y ~ ., data, method) addestra l'albero; printcp() mostra la tabella della complessità.
  • Trovi il valore di CP con l'errore minimo in cross-validation, quindi esegui prune(tree, cp).
  • rpart.plot() visualizza la struttura dell'albero.
  • Gli alberi profondi vanno in overfitting (bias basso, varianza elevata); gli alberi poco profondi vanno in underfitting.
  • tree$variable.importance ordina i predittori in base al miglioramento totale degli split.
  • I metodi ensemble (random forest e boosting) superano l'instabilità dei singoli alberi.
# 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)

Domande Frequenti

La lezione «Alberi decisionali: la base degli ensemble» è gratuita?

Sì — il testo completo di «Alberi decisionali: la base degli ensemble» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Alberi decisionali: la base degli ensemble»?

Costruisca e visualizzi alberi decisionali con rpart e comprenda il compromesso bias-varianza Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Alberi decisionali: la base degli ensemble»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Alberi decisionali: la base degli ensemble
  2. Random forest con ranger
  3. Gradient boosting con xgboost
  4. Importanza delle feature e interpretazione dei modelli
← Torna a R Academy