Come Funzionano gli Alberi Decisionali
Gli alberi decisionali sono algoritmi di ML supervisionato che prendono decisioni attraverso una serie di domande binarie organizzate in una struttura ad albero. Ogni nodo interno rappresenta una domanda su una feature (es. "Età > 30?"), ogni ramo rappresenta una risposta, e ogni foglia rappresenta la previsione finale. La loro forza è l'interpretabilità: puoi leggere un albero decisionale come un diagramma di flusso e capire esattamente perché il modello ha preso una certa decisione.
L'algoritmo costruisce l'albero selezionando ad ogni nodo la feature e la soglia che meglio separano i dati in sottogruppi più omogenei. Questo processo ricorsivo continua finché non si raggiunge un criterio di stop (profondità massima, numero minimo di campioni per foglia, purezza delle foglie).
Cosa Imparerai in Questo Articolo
- Come gli alberi decisionali costruiscono le regole di split
- Entropy, Information Gain e Gini Impurity
- Algoritmi ID3, C4.5 e CART
- Random Forest: la potenza dell'ensemble
- Feature Importance e interpretazione del modello
- Tecniche di pruning per evitare l'overfitting
Entropy e Information Gain
L'entropy misura il disordine (o incertezza) in un insieme di dati. Un dataset con tutte le stesse etichette ha entropy 0 (perfettamente puro), mentre un dataset con etichette distribuite equamente ha entropy massima. L'information gain misura quanto una feature riduce l'entropy quando usata per splittare i dati: più alto è il gain, migliore è lo split.
La Gini Impurity è un'alternativa all'entropy, computazionalmente più veloce. Misura la probabilità che un campione casuale venga classificato scorrettamente se gli assegnassimo un'etichetta casuale in base alla distribuzione delle classi nel nodo. CART (usato da scikit-learn) usa Gini di default, mentre ID3 e C4.5 usano l'entropy.
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
# Caricare dataset
iris = load_iris()
X, y = iris.data, iris.target
feature_names = iris.feature_names
target_names = iris.target_names
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Albero con Gini (default)
tree_gini = DecisionTreeClassifier(
criterion='gini',
max_depth=3,
min_samples_split=5,
min_samples_leaf=2,
random_state=42
)
tree_gini.fit(X_train, y_train)
# Albero con Entropy
tree_entropy = DecisionTreeClassifier(
criterion='entropy',
max_depth=3,
random_state=42
)
tree_entropy.fit(X_train, y_train)
# Valutazione
for name, tree in [("Gini", tree_gini), ("Entropy", tree_entropy)]:
y_pred = tree.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(f"{name} - Accuracy: {acc:.3f}")
# Visualizzazione testuale dell'albero
print("\nStruttura dell'albero (Gini):")
print(export_text(tree_gini, feature_names=list(feature_names)))Overfitting negli Alberi e Pruning
Gli alberi decisionali sono particolarmente soggetti all'overfitting: senza limiti, un albero può crescere fino ad avere una foglia per ogni campione di training, memorizzando i dati invece di apprendere pattern generalizzabili. Il pruning (potatura) è l'insieme di tecniche per limitare la complessità dell'albero.
Il pre-pruning (early stopping) limita l'albero durante la costruzione: profondità
massima (max_depth), numero minimo di campioni per split (min_samples_split),
numero minimo di campioni per foglia (min_samples_leaf). Il post-pruning
costruisce l'albero completo e poi rimuove i rami che non migliorano la performance su un validation set.
Scikit-learn offre il parametro ccp_alpha (cost-complexity pruning) per il post-pruning.
Random Forest: L'Ensemble di Alberi
Il Random Forest è un algoritmo di ensemble che combina centinaia di alberi decisionali per ottenere previsioni più accurate e stabili. Ogni albero viene addestrato su un sottoinsieme casuale dei dati (bootstrap sampling) e usa un sottoinsieme casuale delle feature ad ogni split. La previsione finale è il voto di maggioranza (classificazione) o la media (regressione) di tutti gli alberi.
Questa doppia randomizzazione riduce la varianza senza aumentare il bias: ogni singolo albero può essere impreciso, ma l'insieme è molto più robusto. L'Out-of-Bag (OOB) error permette di stimare l'errore di generalizzazione senza un validation set separato, sfruttando i campioni non selezionati nel bootstrap di ciascun albero.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np
# Dataset
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Random Forest
rf = RandomForestClassifier(
n_estimators=200, # 200 alberi
max_depth=10, # profondità' massima
min_samples_split=5,
oob_score=True, # OOB error estimation
random_state=42,
n_jobs=-1 # usa tutti i core
)
rf.fit(X_train, y_train)
# Performance
y_pred = rf.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.3f}")
print(f"OOB Score: {rf.oob_score_:.3f}")
# Feature Importance - quali feature contano di più'?
importances = rf.feature_importances_
sorted_idx = np.argsort(importances)[::-1]
print("\nTop 10 Feature Importance:")
for i in range(10):
idx = sorted_idx[i]
print(f" {feature_names[idx]:<30s} {importances[idx]:.4f}")Feature Importance: Interpretare il Modello
Una delle caratteristiche più preziose degli alberi e dei Random Forest è la feature importance: la capacità di quantificare quanto ciascuna feature contribuisce alle previsioni. In scikit-learn, l'importanza è calcolata come la riduzione media di impurità (Gini o entropy) apportata da ciascuna feature in tutti gli alberi della foresta.
Questo è fondamentale per la comprensione del dominio, la selezione delle feature e la comunicazione dei risultati. Se una feature ha importanza vicina a zero, probabilmente può essere rimossa senza perdita di performance, semplificando il modello e riducendo il rischio di overfitting.
Albero singolo vs Random Forest: Un albero singolo è interpretabile ma instabile (piccoli cambiamenti nei dati producono alberi molto diversi). Il Random Forest sacrifica l'interpretabilità diretta per ottenere previsioni molto più stabili e accurate. In pratica, il Random Forest è quasi sempre preferibile, e la feature importance compensa la perdita di interpretabilità.
Quando Usare Alberi Decisionali
Gli alberi decisionali e i Random Forest eccellono quando servono modelli interpretabili, quando le feature hanno scale diverse (non serve normalizzazione), quando ci sono relazioni non lineari nei dati e quando si vuole un buon baseline rapido da implementare. Sono meno adatti per dataset con moltissime feature sparse (come il text mining) o quando la relazione tra feature e target è fortemente lineare (dove la regressione lineare è più efficiente).
Punti Chiave
- Gli alberi decisionali usano split ricorsivi basati su entropy o Gini impurity
- Information Gain misura la qualità di ogni split: più alto è meglio è
- Il pruning (pre e post) è essenziale per evitare l'overfitting
- Random Forest combina centinaia di alberi con bootstrap e feature randomizzate
- L'OOB error stima la generalizzazione senza validation set separato
- Feature importance rivela quali variabili guidano le previsioni del modello