LightGBM: crescita per foglie e vantaggi in termini di velocità
Confronterà le prestazioni di LightGBM e XGBoost su un dataset di grandi dimensioni, comprenderà la crescita degli alberi per foglie rispetto a quella per livelli e utilizzerà il supporto per le feature categoriche.
LightGBM: crescita per foglie e vantaggi in termini di velocità è una lezione Machine Learning 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 Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Che cos'è LightGBM?
LightGBM (Light Gradient Boosting Machine) è una libreria di gradient boosting sviluppata da Microsoft nel 2017. È stata progettata appositamente per affrontare i limiti di velocità e memoria di XGBoost sui dataset di grandi dimensioni. LightGBM ha introdotto due importanti innovazioni algoritmiche: Gradient-based One-Side Sampling (GOSS) per ridurre il numero di istanze di dati considerate a ogni iterazione ed Exclusive Feature Bundling (EFB) per ridurre il numero di caratteristiche raggruppando caratteristiche sparse mutuamente esclusive. Insieme, queste innovazioni rendono LightGBM significativamente più veloce di XGBoost sui grandi dataset tabellari.
Crescita degli alberi per livelli e per foglie
La maggior parte delle implementazioni di gradient boosting (incluso XGBoost per impostazione predefinita) fa crescere gli alberi per livelli: tutti i nodi alla profondità 1 vengono suddivisi prima di qualsiasi nodo alla profondità 2. Questo garantisce alberi bilanciati, ma spreca risorse di calcolo per suddivisioni che riducono molto poco la perdita. LightGBM fa crescere gli alberi per foglie: a ogni passaggio individua la singola foglia dell'intero albero la cui suddivisione ridurrebbe maggiormente la perdita e la suddivide, indipendentemente dal livello. In questo modo produce alberi sbilanciati che riducono la perdita più rapidamente a ogni suddivisione, richiedendo meno suddivisioni per ottenere la stessa accuratezza.
Rischio di overfitting con la crescita per foglie
La crescita per foglie può causare overfitting sui dataset di piccole dimensioni perché ricerca in modo aggressivo la maggiore riduzione della perdita, rischiando di memorizzare singoli esempi in foglie molto profonde. La soluzione è il parametro num_leaves (numero massimo complessivo di foglie in un albero). Impostare correttamente num_leaves limita la complessità dell'albero in modo più preciso rispetto al solo max_depth. Una regola pratica comune è: num_leaves = 2^(max_depth) / 2. Per un valore equivalente di max_depth pari a 6, provi con un valore di num_leaves compreso tra circa 32 e 50.
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
for nl in [8, 16, 31, 64, 128]:
model = lgb.LGBMClassifier(n_estimators=100, num_leaves=nl, learning_rate=0.1,
random_state=42, verbose=-1)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'num_leaves={nl:4d}: CV accuracy={score:.4f}')Installazione e utilizzo di base di LightGBM
LightGBM si installa tramite pip install lightgbm. Come XGBoost, offre un'API compatibile con scikit-learn attraverso LGBMClassifier e LGBMRegressor. Imposti verbose=-1 per disattivare l'output dell'addestramento (per impostazione predefinita, LightGBM produce molti messaggi). Gli iperparametri principali sono simili a quelli di XGBoost: n_estimators, learning_rate, num_leaves (anziché max_depth) e subsample.
# Install: pip install lightgbm
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = lgb.LGBMClassifier(
n_estimators=200,
learning_rate=0.05,
num_leaves=31,
random_state=42,
verbose=-1
)
model.fit(X_train, y_train)
print('LightGBM test accuracy:', model.score(X_test, y_test))Benchmark della velocità: LightGBM e XGBoost
In genere, LightGBM è da 5 a 10 volte più veloce di XGBoost sui dataset di grandi dimensioni, raggiungendo un'accuratezza simile o superiore. Il vantaggio in termini di velocità deriva da: (1) ricerca delle suddivisioni basata su istogrammi (raggruppa i valori continui delle caratteristiche in intervalli discreti, riducendo il calcolo delle suddivisioni candidate da O(n) a O(bins)); (2) crescita per foglie (sono necessarie meno suddivisioni); (3) GOSS (l'addestramento utilizza solo gli esempi con gradiente elevato e un campione casuale di quelli con gradiente basso). Il vantaggio in termini di velocità è più evidente per i dataset con più di 100.000 righe o più di 1.000 caratteristiche.
import lightgbm as lgb
import xgboost as xgb
from sklearn.datasets import fetch_california_housing
import time, numpy as np
X, y = fetch_california_housing(return_X_y=True)
lgb_model = lgb.LGBMRegressor(n_estimators=300, verbose=-1, random_state=42)
xgb_model = xgb.XGBRegressor(n_estimators=300, eval_metric='rmse', verbosity=0, random_state=42)
for name, m in [('LightGBM', lgb_model), ('XGBoost', xgb_model)]:
start = time.time()
m.fit(X, y)
print(f'{name}: {round(time.time()-start, 2)}s')Supporto per le caratteristiche categoriche
Uno dei vantaggi pratici di LightGBM è il supporto nativo per le caratteristiche categoriche. Invece di richiedere una codifica one-hot, è possibile passare gli indici delle colonne categoriche al parametro categorical_feature. LightGBM impara le suddivisioni ottimali testando tutti i raggruppamenti delle categorie, una soluzione più espressiva rispetto alle suddivisioni binarie one-hot, che evita inoltre l'esplosione dimensionale causata dalla codifica one-hot di caratteristiche con centinaia di categorie. Questo è particolarmente utile per i dataset di e-commerce con ID di prodotto o codici di località.
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
np.random.seed(42)
n = 1000
df = pd.DataFrame({'color': np.random.choice(['red', 'blue', 'green'], n),
'size': np.random.randint(1, 10, n),
'label': np.random.randint(0, 2, n)})
df['color'] = df['color'].astype('category')
X, y = df[['color', 'size']], df['label']
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)
model = lgb.LGBMClassifier(n_estimators=50, verbose=-1)
model.fit(X_tr, y_tr, categorical_feature=['color'])
print('Accuracy with native categoricals:', round(model.score(X_te, y_te), 4))Arresto anticipato in LightGBM
LightGBM supporta l'arresto anticipato tramite callback. Passi un callback early_stopping con il numero di iterazioni di pazienza e un callback log_evaluation per controllare il livello di dettaglio dei messaggi. Lo stato del modello migliore (best_iteration_) viene utilizzato automaticamente per le previsioni. Come XGBoost, questo consente di impostare n_estimators su un valore molto alto e lasciare che l'arresto anticipato individui il punto ottimale senza overfitting.
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
model = lgb.LGBMClassifier(n_estimators=1000, learning_rate=0.05, num_leaves=31, random_state=42)
model.fit(X_tr, y_tr,
eval_set=[(X_val, y_val)],
callbacks=[lgb.early_stopping(stopping_rounds=20), lgb.log_evaluation(0)])
print('Best iteration:', model.best_iteration_)
print('Val accuracy:', round(model.score(X_val, y_val), 4))Iperparametri principali di LightGBM
Gli iperparametri più importanti di LightGBM sono: num_leaves (controlla la complessità ed è il principale strumento di regolarizzazione), learning_rate (un valore più basso richiede più alberi, ma garantisce una generalizzazione migliore), min_child_samples (numero minimo di esempi per foglia, da aumentare insieme a num_leaves per prevenire l'overfitting), subsample e colsample_bytree (regolarizzazione stocastica) e reg_alpha/reg_lambda (penalità L1/L2). Inizi con i valori predefiniti e ottimizzi prima num_leaves e min_child_samples.
LightGBM per la regressione
LGBMRegressor funziona allo stesso modo per le attività di regressione. Supporta diverse funzioni di perdita tramite il parametro objective: 'regression' (L2), 'regression_l1' (MAE), 'huber' (robusta rispetto agli outlier) e 'quantile' (per gli intervalli di previsione). La regressione quantile con LightGBM è particolarmente utile in produzione: addestri un modello per il 10° percentile e uno per il 90° percentile, così da produrre limiti di incertezza calibrati intorno alle previsioni.
import lightgbm as lgb
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
model = lgb.LGBMRegressor(n_estimators=300, learning_rate=0.05, num_leaves=31,
verbose=-1, random_state=42)
rmse = np.sqrt(-cross_val_score(model, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print('LightGBM Regression RMSE:', round(rmse, 4))Scegliere tra XGBoost e LightGBM
Sia XGBoost sia LightGBM sono eccellenti. Indicazioni pratiche: utilizzi LightGBM quando il dataset è grande (oltre 100.000 righe), ha bisogno di iterazioni rapide durante l'esplorazione o dispone di caratteristiche categoriche ad alta cardinalità. Utilizzi XGBoost quando il dataset è piccolo o medio, desidera una crescita per livelli più conservativa e meno soggetta all'overfitting sui dati rumorosi, oppure il team ha già esperienza con XGBoost. Nelle competizioni, spesso si provano entrambi e si sceglie quello che ottiene i risultati migliori sul set di validazione. CatBoost è una terza valida alternativa, con una gestione delle caratteristiche categoriche ancora migliore.
Importanza delle caratteristiche in LightGBM
Come XGBoost, LightGBM fornisce l'importanza delle caratteristiche, accessibile tramite model.feature_importances_ (nell'API sklearn utilizza per impostazione predefinita il conteggio delle suddivisioni) oppure model.booster_.feature_importance(importance_type='gain'). Il tipo gain è generalmente più informativo: misura il miglioramento medio della perdita per ogni suddivisione che utilizza quella caratteristica. LightGBM supporta anche i valori SHAP per spiegazioni indipendenti dal modello tramite model.predict(X, pred_contrib=True) nell'API nativa, fornendo attribuzioni dettagliate delle caratteristiche per ogni previsione.
import lightgbm as lgb
import pandas as pd
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X, y = data.data, data.target
model = lgb.LGBMClassifier(n_estimators=100, verbose=-1, random_state=42)
model.fit(X, y)
importances = pd.Series(model.feature_importances_, index=data.feature_names)
print(importances.sort_values(ascending=False).head(5))Verifica rapida
Verifichi la Sua comprensione della strategia di crescita di LightGBM presentata in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: la crescita per foglie di LightGBM individua la foglia migliore da suddividere a ogni iterazione, raggiungendo la convergenza più rapidamente rispetto alla crescita per livelli, num_leaves è il principale parametro di controllo della complessità e sostituisce max_depth e il supporto nativo di LightGBM per le caratteristiche categoriche evita il sovraccarico della codifica one-hot. Ora esamineremo in dettaglio gli iperparametri principali learning rate, n_estimators e max_depth.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «LightGBM: crescita per foglie e vantaggi in termini di velocità» è gratuita?
Sì — il testo completo di «LightGBM: crescita per foglie e vantaggi in termini di velocità» è 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 Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «LightGBM: crescita per foglie e vantaggi in termini di velocità»?
Confronterà le prestazioni di LightGBM e XGBoost su un dataset di grandi dimensioni, comprenderà la crescita degli alberi per foglie rispetto a quella per livelli e utilizzerà il supporto per le feat… Eserciti Machine Learning 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 Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning 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 «LightGBM: crescita per foglie e vantaggi in termini di velocità»?
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 Machine Learning Academy?
Sì. Ogni lezione Machine Learning 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
- Intuizione sul boosting: correzione sequenziale degli errori
- XGBoost: regolarizzazione, early stopping e importanza delle feature
- LightGBM: crescita per foglie e vantaggi in termini di velocità
- Iperparametri principali: learning rate, n_estimators e max_depth