Machine Learning Academy · leksjon

LightGBM: Bladvis vekst og fordeler med høy hastighet

De vil sammenligne LightGBM med XGBoost på et stort datasett, forstå bladvis og nivåvis trevekst og bruke støtte for kategoriske egenskaper.

Leksjon 3 av 413 trinn

LightGBM: Bladvis vekst og fordeler med høy hastighet er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva er LightGBM?

LightGBM (Light Gradient Boosting Machine) er et bibliotek for gradient boosting som ble utviklet av Microsoft i 2017. Det ble utformet spesielt for å håndtere begrensningene i hastighet og minnebruk som XGBoost har på store datasett. LightGBM introduserte to viktige algoritmiske nyvinninger: Gradient-based One-Side Sampling (GOSS) for å redusere antallet dataforekomster som vurderes i hver runde, og Exclusive Feature Bundling (EFB) for å redusere antallet egenskaper ved å samle gjensidig utelukkende sparsomme egenskaper. Til sammen gjør dette LightGBM betydelig raskere enn XGBoost på store tabellariske datasett.

Nivåvis kontra bladvis trevekst

De fleste implementasjoner av gradient boosting (inkludert XGBoost som standard) bygger trær nivåvis: Alle noder på dybde 1 splittes før en node på dybde 2 splittes. Dette sikrer balanserte trær, men sløser med beregninger på splitter som reduserer tapet svært lite. LightGBM bygger trær bladvis: I hvert trinn finner det det ene bladet i hele treet som vil redusere tapet mest, og splitter dette, uavhengig av nivå. Dette gir ubalanserte trær som reduserer tapet raskere per splitt, og som krever færre splitter for å oppnå samme nøyaktighet.

Risiko for overtilpasning ved bladvis vekst

Bladvis vekst kan føre til overtilpasning på små datasett fordi den aggressivt prioriterer den største tapsreduksjonen og potensielt memoriserer individuelle eksempler i svært dype blader. Løsningen er parameteren num_leaves (maksimalt totalt antall blader i ett tre). Ved å angi num_leaves på en passende måte begrenses treets kompleksitet mer presist enn med max_depth alene. En vanlig tommelfingerregel er: num_leaves = 2^(max_depth) / 2. For en max_depth-ekvivalent på 6 kan De prøve num_leaves rundt 32–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}')

Installering og grunnleggende bruk av LightGBM

LightGBM installeres med pip install lightgbm. I likhet med XGBoost tilbyr det et scikit-learn-kompatibelt API gjennom LGBMClassifier og LGBMRegressor. Angi verbose=-1 for å skjule treningsutdataene (LightGBM er som standard svært ordrikt). De viktigste hyperparametrene ligner på dem i XGBoost: n_estimators, learning_rate, num_leaves (i stedet for max_depth) og 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))

Hastighetsmåling: LightGBM kontra XGBoost

LightGBM er vanligvis 5–10 ganger raskere enn XGBoost på store datasett, samtidig som det oppnår tilsvarende eller bedre nøyaktighet. Hastighetsfordelen skyldes: (1) histogrambasert søk etter splitter (grupperer kontinuerlige egenskapsverdier i diskrete intervaller og reduserer beregningen av splitter fra O(n) til O(bins)); (2) bladvis vekst (færre splitter er nødvendig); (3) GOSS (trener bare på eksempler med høy gradient og tilfeldig utvalgte eksempler med lav gradient). Hastighetsfordelen er tydeligst for datasett med mer enn 100 000 rader eller mer enn 1 000 egenskaper.

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

Støtte for kategoriske egenskaper

En av LightGBM sine praktiske fordeler er innebygd støtte for kategoriske egenskaper. I stedet for å kreve one-hot-koding kan De sende indeksene til de kategoriske kolonnene til parameteren categorical_feature. LightGBM lærer optimale splitter ved å teste alle grupperinger av kategorier. Dette er mer uttrykksfullt enn binære one-hot-splitter og unngår den kraftige økningen i størrelse som oppstår når egenskaper med hundrevis av kategorier one-hot-kodes. Dette er særlig nyttig for e-handelsdatasett med produkt-ID-er eller stedskoder.

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

Tidlig stopp i LightGBM

LightGBM støtter tidlig stopp gjennom tilbakekallingsfunksjoner. Send inn en early_stopping-tilbakekalling med antallet tålmodighetsrunder og en log_evaluation-tilbakekalling for å styre hvor mye som logges. Den beste modelltilstanden (best_iteration_) brukes automatisk til prediksjon. I likhet med XGBoost gjør dette at De kan angi n_estimators svært høyt og la tidlig stopp finne det optimale punktet uten overtilpasning.

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

Viktige hyperparametre i LightGBM

De viktigste hyperparametrene i LightGBM er: num_leaves (styrer kompleksiteten og er det viktigste regulariseringsverktøyet), learning_rate (lavere verdi = flere nødvendige trær og bedre generalisering), min_child_samples (minimum antall eksempler per blad, bør økes sammen med num_leaves for å hindre overtilpasning), subsample og colsample_bytree (stokastisk regularisering), samt reg_alpha/reg_lambda (L1-/L2-straffer). Start med standardverdiene, og juster num_leaves og min_child_samples først.

LightGBM for regresjon

LGBMRegressor fungerer på samme måte for regresjonsoppgaver. Det støtter flere tapsfunksjoner via parameteren objective: 'regression' (L2), 'regression_l1' (MAE), 'huber' (robust mot uteliggere) og 'quantile' (for prediksjonsintervaller). Kvantilregresjon med LightGBM er særlig nyttig i produksjon: Tren én modell for 10-persentilen og én for 90-persentilen for å lage kalibrerte usikkerhetsgrenser rundt prediksjonene.

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

Valg mellom XGBoost og LightGBM

Både XGBoost og LightGBM er utmerkede verktøy. Praktiske retningslinjer: Bruk LightGBM når datasettet er stort (over 100 000 rader), når De trenger rask iterasjon under utforskningen, eller når De har kategoriske egenskaper med mange kategorier. Bruk XGBoost når datasettet er lite til middels stort, når De ønsker en mer konservativ nivåvis vekst som er vanskeligere å overtilpasse på støyende data, eller når teamet allerede har erfaring med XGBoost. I konkurranser prøver man ofte begge og velger den som gjør det best på valideringssettet. CatBoost er et tredje, sterkt alternativ med enda bedre håndtering av kategoriske egenskaper.

Egenskapsviktighet i LightGBM

I likhet med XGBoost tilbyr LightGBM egenskapsviktighet, tilgjengelig via model.feature_importances_ (bruker antall splitter som standard i sklearn-API-et) eller model.booster_.feature_importance(importance_type='gain'). Typen gain er vanligvis mer informativ – den måler den gjennomsnittlige forbedringen i tap per splitt som bruker denne egenskapen. LightGBM støtter også SHAP-verdier for modellagnostiske forklaringer via model.predict(X, pred_contrib=True) i det opprinnelige API-et, noe som gir detaljerte egenskapstilordninger for hver prediksjon.

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

Kort kontroll

Test forståelsen Deres av LightGBM sin vekststrategi fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen lærte De at LightGBM sin bladvise vekst finner det beste enkeltbladet å splitte i hver runde og konvergerer raskere enn nivåvis vekst, at num_leaves er den viktigste kontrollen for kompleksitet og erstatter max_depth, og at LightGBM sin innebygde støtte for kategoriske egenskaper unngår kostnadene ved one-hot-koding. Deretter skal vi se nærmere på de viktigste hyperparametrene learning rate, n_estimators og max_depth.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120

Ofte stilte spørsmål

Er leksjonen «LightGBM: Bladvis vekst og fordeler med høy hastighet» gratis?

Ja – hele teksten i «LightGBM: Bladvis vekst og fordeler med høy hastighet» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «LightGBM: Bladvis vekst og fordeler med høy hastighet»?

De vil sammenligne LightGBM med XGBoost på et stort datasett, forstå bladvis og nivåvis trevekst og bruke støtte for kategoriske egenskaper. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «LightGBM: Bladvis vekst og fordeler med høy hastighet»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Intuisjon for boosting: Sekvensiell feilretting
  2. XGBoost: Regulering, tidlig stopp og egenskapsviktighet
  3. LightGBM: Bladvis vekst og fordeler med høy hastighet
  4. Viktige hyperparametre: Learning rate, n_estimators og max_depth
← Tilbake til Machine Learning Academy