Random forest e bagging
Concetto di ensemble, RandomForestClassifier, n_estimators, importanza delle feature e punteggio OOB.
Random forest e bagging è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 2 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 Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Il problema degli alberi singoli
Un singolo albero decisionale ha alta varianza: riaddestrarlo su dati leggermente diversi può produrre un albero molto diverso. Gli ensemble risolvono questo problema combinando molti alberi.
Bagging (aggregazione bootstrap)
Il bagging addestra molti modelli su diversi campioni bootstrap, ovvero campioni casuali con reinserimento, dei dati, quindi calcola la media delle loro predizioni.
Calcolare la media di molti modelli ad alta varianza riduce la varianza complessiva senza aumentare molto il bias.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
random_state=0,
)
bag.fit(Xtr, ytr)Dal bagging alle foreste casuali
Una foresta casuale applica il bagging agli alberi e aggiunge un ulteriore accorgimento: a ogni divisione considera solo un sottoinsieme casuale delle feature.
In questo modo gli alberi risultano meno correlati, quindi i loro errori si compensano meglio e l'ensemble migliora.
Nozioni di base su RandomForestClassifier
Usi RandomForestClassifier. Il parametro principale, n_estimators, stabilisce quanti alberi costruire. Un numero maggiore di alberi rende il modello più stabile, ma anche più lento.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=0)
rf.fit(Xtr, ytr)
print("Accuracy:", rf.score(Xte, yte))Addestramento parallelo con n_jobs
Gli alberi di una foresta sono indipendenti, quindi vengono addestrati in parallelo. Imposti n_jobs=-1 per usare tutti i core della CPU e velocizzare notevolmente l'addestramento.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=500,
n_jobs=-1, # use all cores
random_state=0,
)
rf.fit(Xtr, ytr)Punteggio out-of-bag (OOB)
Ogni albero esclude circa un terzo dei campioni, che non sono stati selezionati dal bootstrap. Questi campioni out-of-bag costituiscono un set di validazione integrato.
Imposti oob_score=True per ottenere una stima gratuita dell'errore di generalizzazione senza una divisione separata dei dati.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
oob_score=True,
random_state=0,
)
rf.fit(Xtr, ytr)
print("OOB score:", rf.oob_score_)Controllare la profondità degli alberi nella foresta
Si applicano gli stessi parametri degli alberi: max_depth, min_samples_leaf e max_features, che indica quante feature provare a ogni divisione.
max_features="sqrt" è il valore predefinito più comune per la classificazione.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
max_depth=12,
max_features="sqrt",
random_state=0,
)Importanza delle feature integrata
Come gli alberi singoli, le foreste espongono feature_importances_, calcolato come media sui vari alberi. Questa importanza basata sull'impurità è rapida, ma può essere distorta a favore delle feature con elevata cardinalità.
from sklearn.ensemble import RandomForestClassifier
import numpy as np
rf = RandomForestClassifier(n_estimators=200, random_state=0).fit(Xtr, ytr)
order = np.argsort(rf.feature_importances_)[::-1]
for i in order[:5]:
print(i, rf.feature_importances_[i])Importanza tramite permutazione
L'importanza tramite permutazione è più affidabile: mescola una colonna delle feature e misura di quanto diminuisce il punteggio. Una grande diminuzione indica che la feature era importante.
È indipendente dal modello ed evita la distorsione dovuta all'impurità.
from sklearn.inspection import permutation_importance
result = permutation_importance(
rf, Xte, yte, n_repeats=10, random_state=0, n_jobs=-1
)
print(result.importances_mean)Interpretare i risultati della permutazione
permutation_importance restituisce importances_mean e importances_std tra le diverse ripetizioni. Lo calcoli su un set tenuto da parte, così misurerà l'impatto sulla generalizzazione e non sull'adattamento ai dati di addestramento.
import numpy as np
means = result.importances_mean
stds = result.importances_std
for i in np.argsort(means)[::-1]:
print(f"feature {i}: {means[i]:.3f} +/- {stds[i]:.3f}")Quando usare le foreste casuali
Le foreste casuali sono un'ottima scelta predefinita: sono robuste, richiedono poca ottimizzazione, gestiscono non linearità e interazioni e resistono all'overfitting. Gli svantaggi sono un maggiore utilizzo di memoria, predizioni più lente rispetto a un singolo albero e una minore interpretabilità.
Verifica rapida
Verifichi la sua comprensione del bagging e delle foreste casuali.
Riepilogo
Riepilogo: il bagging addestra i modelli su campioni bootstrap e ne calcola la media per ridurre la varianza. Le foreste casuali aggiungono sottoinsiemi casuali di feature a ogni divisione. Ottimizzi il modello con n_estimators, usi n_jobs=-1 per aumentare la velocità, ottenga la validazione gratuitamente tramite oob_score e preferisca permutation_importance all'importanza basata sull'impurità per ottenere classifiche affidabili.
Domande Frequenti
La lezione «Random forest e bagging» è gratuita?
Sì — il testo completo di «Random forest e bagging» è 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 Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «Random forest e bagging»?
Concetto di ensemble, RandomForestClassifier, n_estimators, importanza delle feature e punteggio OOB. Eserciti Learn AI with Python 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 Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Random forest e bagging»?
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 Learn AI with Python?
Sì. Ogni lezione Learn AI with Python 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
- Alberi decisionali: teoria e implementazione
- Random forest e bagging
- Gradient boosting: GBM e XGBoost
- LightGBM e CatBoost