LightGBM: lehtikohtainen kasvu ja nopeusedut
Vertaa LightGBM:n suorituskykyä XGBoostiin suurella aineistolla, ymmärrä lehti- ja tasokohtaisen puunkasvun erot ja käytä kategoristen piirteiden tukea.
LightGBM: lehtikohtainen kasvu ja nopeusedut on ilmainen Machine Learning Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Machine Learning Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.
Mikä LightGBM on?
LightGBM (Light Gradient Boosting Machine) on Microsoftin vuonna 2017 kehittämä gradienttitehostuskirjasto. Se suunniteltiin erityisesti ratkaisemaan XGBoostin suurten aineistojen nopeus- ja muistirajoitukset. LightGBM esitteli kaksi keskeistä algoritmi-innovaatiota: Gradient-based One-Side Sampling (GOSS) vähentää kullakin kierroksella käsiteltävien dataesiintymien määrää, ja Exclusive Feature Bundling (EFB) vähentää piirteiden määrää niputtamalla keskenään poissulkevia harvoja piirteitä. Yhdessä nämä tekevät LightGBM:stä huomattavasti XGBoostia nopeamman suurilla taulukkomuotoisilla aineistoilla.
Tasokohtainen ja lehtikohtainen puiden kasvatus
Useimmat gradienttitehostuksen toteutukset (myös XGBoost oletusarvoisesti) kasvattavat puita tasokohtaisesti: kaikki syvyyden 1 solmut jaetaan ennen minkään syvyyden 2 solmun jakamista. Tämä tuottaa tasapainoisia puita, mutta laskentaa kuluu jakoihin, jotka pienentävät häviötä vain hyvin vähän. LightGBM kasvattaa puita lehtikohtaisesti: kullakin askeleella se etsii koko puusta yksittäisen lehden, jonka jakaminen pienentäisi häviötä eniten, riippumatta sen tasosta, ja jakaa sen. Tuloksena syntyy epätasapainoisia puita, jotka pienentävät häviötä nopeammin jokaista jakoa kohden ja tarvitsevat saman tarkkuuden saavuttamiseen vähemmän jakoja.
Lehtikohtaisen kasvatuksen ylisovittamisriski
Lehtikohtainen kasvatus voi ylisovittaa pieniä aineistoja, koska se tavoittelee aggressiivisesti suurinta häviön pienennystä ja saattaa painaa yksittäiset esimerkit mieleensä hyvin syvissä lehdissä. Ratkaisu on num_leaves-parametri (yhden puun lehtien enimmäismäärä). Kun num_leaves asetetaan sopivaksi, puun monimutkaisuutta voidaan rajoittaa täsmällisemmin kuin pelkällä max_depth-parametrilla. Yleinen nyrkkisääntö on: num_leaves = 2^(max_depth) / 2. Kun max_depth-arvoa vastaa 6, kokeilkaa num_leaves-arvoja noin väliltä 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}')LightGBM:n asentaminen ja perusteet
LightGBM asennetaan komennolla pip install lightgbm. XGBoostin tavoin se tarjoaa scikit-learn-yhteensopivan API:n luokkien LGBMClassifier ja LGBMRegressor kautta. Asettakaa verbose=-1, jos haluatte piilottaa koulutuksen tulosteen (LightGBM tulostaa oletusarvoisesti paljon tietoa). Keskeiset hyperparametrit ovat samankaltaisia kuin XGBoostissa: n_estimators, learning_rate, num_leaves (max_depthin sijaan) ja 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))Nopeusvertailu: LightGBM ja XGBoost
LightGBM on suurilla aineistoilla yleensä 5–10 kertaa XGBoostia nopeampi ja saavuttaa samankaltaisen tai paremman tarkkuuden. Nopeusetu perustuu seuraaviin tekijöihin: (1) histogrammipohjainen jakokohtien etsintä (jatkuvien piirteiden arvot ryhmitellään erillisiin lokeroihin, jolloin jakoehdokkaiden laskenta vähenee muodosta O(n) muotoon O(bins)); (2) lehtikohtainen kasvatus (jakoja tarvitaan vähemmän); (3) GOSS (koulutus käyttää vain suuren gradientin esimerkkejä ja satunnaisesti otettuja pienen gradientin esimerkkejä). Nopeusetu on suurin aineistoilla, joissa on yli 100 000 riviä tai yli 1 000 piirrettä.
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')Kategoristen piirteiden tuki
Yksi LightGBM:n käytännön eduista on kategoristen piirteiden natiivin tuki. One-hot-koodausta ei tarvita, vaan kategoristen sarakkeiden indeksit voidaan välittää parametrille categorical_feature. LightGBM oppii optimaaliset jaot kokeilemalla kaikkia kategorioiden ryhmittelyjä. Tämä on ilmaisuvoimaisempaa kuin binääriset one-hot-jaot ja estää satoja kategorioita sisältävien piirteiden one-hot-koodauksesta aiheutuvan suuren ulottuvuuden kasvun. Tämä on erityisen hyödyllistä verkkokaupan aineistoissa, joissa on tuotetunnuksia tai sijaintikoodeja.
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))Ennenaikainen pysäytys LightGBM:ssä
LightGBM tukee ennenaikaista pysäytystä callback-funktioiden avulla. Välittäkää early_stopping-callback-funktiolle kärsivällisyyskierrosten määrä ja käyttäkää log_evaluation-callback-funktiota tulostuksen hallintaan. Parhaan mallin tila (best_iteration_) otetaan automaattisesti käyttöön ennustamista varten. XGBoostin tavoin tämän ansiosta n_estimators voidaan asettaa hyvin suureksi ja ennenaikainen pysäytys voi löytää sopivan kohdan ilman ylisovittamista.
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))LightGBM:n keskeiset hyperparametrit
LightGBM:n tärkeimmät hyperparametrit ovat: num_leaves (hallinnoi monimutkaisuutta ja on ensisijainen säännöllistämiskeino), learning_rate (pienempi arvo edellyttää useampia puita ja yleistyy paremmin), min_child_samples (lehden esimerkkien vähimmäismäärä, jota kasvatetaan yhdessä num_leaves-arvon kanssa ylisovittamisen estämiseksi), subsample ja colsample_bytree (stokastinen säännöllistäminen) sekä reg_alpha/reg_lambda (L1/L2-rangaistukset). Aloittakaa oletusarvoilla ja säätäkää ensin num_leaves- ja min_child_samples-arvoja.
LightGBM regressioon
LGBMRegressor toimii samalla tavalla regressiotehtävissä. Se tukee useita häviöfunktioita objective-parametrin kautta: 'regression' (L2), 'regression_l1' (MAE), 'huber' (kestävä poikkeaville arvoille) ja 'quantile' (ennusteväleille). Kvantiiliregressio LightGBM:llä on erityisen hyödyllinen tuotantokäytössä: kouluttakaa yksi malli 10. persentiilille ja toinen 90. persentiilille, jolloin ennusteiden ympärille saadaan kalibroidut epävarmuusrajat.
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))XGBoostin ja LightGBM:n valitseminen
Sekä XGBoost että LightGBM ovat erinomaisia. Käytännön ohje: käyttäkää LightGBM:ää, kun aineisto on suuri (yli 100 000 riviä), tarvitsette nopeita iteraatioita tutkimisen aikana tai aineistossa on suuren kardinaliteetin kategorisia piirteitä. Käyttäkää XGBoostia, kun aineisto on pieni tai keskikokoinen, haluatte konservatiivisemman tasokohtaisen kasvun, joka ylisovittaa meluisalla datalla vaikeammin, tai tiimillänne on jo kokemusta XGBoostista. Kilpailuissa kokeillaan yleensä molempia ja valitaan validointiaineistolla paremmin toimiva malli. CatBoost on kolmas vahva vaihtoehto, joka käsittelee kategorisia piirteitä vielä paremmin.
LightGBM:n piirteiden tärkeys
XGBoostin tavoin LightGBM tarjoaa piirteiden tärkeydet, jotka ovat käytettävissä muodossa model.feature_importances_ (scikit-learn-API käyttää oletusarvoisesti jakojen määrää) tai model.booster_.feature_importance(importance_type='gain'). gain-tyyppi on yleensä informatiivisempi: se mittaa häviön keskimääräistä paranemista jaossa, jossa kyseistä piirrettä käytetään. LightGBM tukee myös SHAP-arvoja malliriippumattomia selityksiä varten natiivin API:n kautta komennolla model.predict(X, pred_contrib=True), joka tarjoaa yksityiskohtaiset piirrekohtaiset vaikutukset jokaiselle ennusteelle.
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))Pikatesti
Testatkaa, kuinka hyvin ymmärrätte tässä oppitunnissa käsitellyn LightGBM:n kasvustrategian.
Oppitunnin yhteenveto
Tässä oppitunnissa opitte, että LightGBM:n lehtikohtainen kasvatus etsii kullakin kierroksella parhaan yksittäisen jaettavan lehden ja saavuttaa ratkaisun nopeammin kuin tasokohtainen kasvatus, num_leaves on ensisijainen monimutkaisuuden säätöparametri ja korvaa max_depth-parametrin ja LightGBM:n natiivi kategoristen piirteiden tuki poistaa one-hot-koodauksen aiheuttaman lisätyön. Seuraavaksi tutustumme yksityiskohtaisesti keskeisiin hyperparametreihin learning_rate, n_estimators ja max_depth.
Opi Python tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 30
- Oppitunnit
- 120
Usein kysytyt kysymykset
Onko oppitunti ”LightGBM: lehtikohtainen kasvu ja nopeusedut” ilmainen?
Kyllä – oppitunnin ”LightGBM: lehtikohtainen kasvu ja nopeusedut” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Machine Learning Academy-kurssin, päivitä CoddyKit PROhon. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”LightGBM: lehtikohtainen kasvu ja nopeusedut”?
Vertaa LightGBM:n suorituskykyä XGBoostiin suurella aineistolla, ymmärrä lehti- ja tasokohtaisen puunkasvun erot ja käytä kategoristen piirteiden tukea. Harjoittelet Machine Learning Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Machine Learning Academy-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Machine Learning Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.
Kuinka kauan ”LightGBM: lehtikohtainen kasvu ja nopeusedut”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Machine Learning Academy-oppitunnilla?
Kyllä. Jokainen Machine Learning Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Boostauksen intuitio: virheiden korjaaminen peräkkäin
- XGBoost: regularisointi, early stopping ja piirteiden tärkeys
- LightGBM: lehtikohtainen kasvu ja nopeusedut
- Keskeiset hyperparametrit: learning rate, n_estimators ja max_depth