Modelli basati su alberi: alberi decisionali e random forest
Costruisca e ottimizzi modelli ad albero decisionale e modelli di ensemble forest.
Modelli basati su alberi: alberi decisionali e random forest è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 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 Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.
Concetti sugli alberi decisionali
Un albero decisionale suddivide i dati in sottoinsiemi ponendo una sequenza di domande binarie. Ogni nodo interno corrisponde a una soglia su una feature; ogni foglia contiene una previsione.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print("Depth:", model.get_depth())
print("Leaves:", model.get_n_leaves())DecisionTreeClassifier
Hyperparameter principali: max_depth, min_samples_split, min_samples_leaf. Gli alberi più profondi vanno in overfitting; quelli più poco profondi vanno in underfitting.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=5)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))DecisionTreeRegressor
Gli alberi decisionali gestiscono anche la regressione, prevedendo il valore medio del target in ogni foglia.
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
X, y = make_regression(noise=15, random_state=0)
model = DecisionTreeRegressor(max_depth=4).fit(X, y)
print("RMSE:", mean_squared_error(y, model.predict(X))**0.5)Importanza delle feature
model.feature_importances_ fornisce l'importanza relativa di ogni feature, calcolata in base alla riduzione dell'impurità.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
model = DecisionTreeClassifier().fit(X, y)
for name, imp in sorted(zip(feature_names, model.feature_importances_), key=lambda x: -x[1]):
print(f"{name}: {imp:.3f}")Panoramica sulle Random Forest
Una Random Forest addestra molti alberi decisionali non correlati su campioni bootstrap e calcola la media delle loro previsioni, riducendo la varianza senza aumentare il bias.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))RandomForestRegressor
Le Random Forest funzionano altrettanto bene per la regressione.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import r2_score
X, y = make_regression(noise=10, random_state=0)
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)
print("R²:", r2_score(y, model.predict(X)))Punteggio out-of-bag
Imposti oob_score=True per ottenere gratuitamente un punteggio di validazione usando i campioni che non appartengono al bootstrap di ciascun albero (senza bisogno di un set di test separato).
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(random_state=0)
model = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=0).fit(X, y)
print("OOB score:", model.oob_score_)Gradient boosting
Il gradient boosting (GBM) addestra gli alberi in sequenza, correggendo ogni volta gli errori dell'albero precedente. Spesso è più accurato delle Random Forest, ma più lento da addestrare.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = GradientBoostingClassifier(n_estimators=100).fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))XGBoost / LightGBM
XGBoost e LightGBM sono librerie di gradient boosting ottimizzate: più veloci, più scalabili e spesso più accurate del GBM di sklearn.
# pip install xgboost lightgbm
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
xgb = XGBClassifier(n_estimators=100, eval_metric="logloss").fit(X_tr, y_tr)
print("XGB acc:", xgb.score(X_te, y_te))Regolazione di n_estimators
Un numero maggiore di alberi in una Random Forest riduce la varianza (fino a un certo punto) senza causare overfitting. Utilizzi la curva di validazione per trovare il numero ottimale.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(random_state=0)
for n in [10, 50, 100, 200]:
scores = cross_val_score(RandomForestClassifier(n_estimators=n, random_state=0), X, y, cv=5)
print(f"n={n}: {scores.mean():.3f}")Visualizzazione di un albero decisionale
Utilizzi sklearn.tree.plot_tree o export_text per esaminare ciò che l'albero ha appreso.
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=2).fit(X, y)
print(export_text(model, feature_names=load_iris().feature_names.tolist()))Verifica rapida
In che modo una Random Forest riduce l'overfitting rispetto a un singolo albero decisionale?
Riepilogo
Gli alberi decisionali suddividono i dati in base alle soglie delle feature e producono previsioni usando i valori delle foglie. Regoli max_depth per controllare l'overfitting. Le Random Forest calcolano la media di molti alberi per ridurre la varianza. Il gradient boosting addestra gli alberi in sequenza per ottenere un'elevata accuratezza. In produzione, preferisca XGBoost o LightGBM.
Domande Frequenti
La lezione «Modelli basati su alberi: alberi decisionali e random forest» è gratuita?
Sì — il testo completo di «Modelli basati su alberi: alberi decisionali e random forest» è 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 Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.
Cosa imparerò in «Modelli basati su alberi: alberi decisionali e random forest»?
Costruisca e ottimizzi modelli ad albero decisionale e modelli di ensemble forest. Eserciti Python 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 Python Academy?
Non è richiesta alcuna esperienza precedente. Python 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 3 di 4.
Quanto tempo richiede la lezione «Modelli basati su alberi: alberi decisionali e random forest»?
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 Python Academy?
Sì. Ogni lezione Python 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
- L'API di scikit-learn: fit, transform, predict
- Modelli lineari: regressione e classificazione
- Modelli basati su alberi: alberi decisionali e random forest
- Valutazione dei modelli e cross-validation