Viktiga hyperparametrar: learning rate, n_estimators och max_depth
Ni kommer att undersöka hur shrinkage (learning rate), ensemble-storlek och djup påverkar avvägningen mellan bias och varians genom systematiska experiment.
Viktiga hyperparametrar: learning rate, n_estimators och max_depth är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Gradient boostings heliga treenighet
Gradient boosting har tre hyperparametrar som samverkar starkast och har störst inverkan på modellens prestanda: learning_rate (hur stort varje träds bidrag är), n_estimators (hur många träd som ska byggas) och max_depth (hur komplext varje enskilt träd får vara). Att förstå hur dessa tre samverkar är nyckeln till att effektivt justera alla modeller för gradient boosting — oavsett om det gäller scikit-learns GradientBoostingClassifier, XGBoost eller LightGBM.
Learning rate (krympning) på djupet
Learning rate η (eta) skalar varje träds bidrag: F_m(x) = F_{m-1}(x) + η × h_m(x). Ett mindre η innebär att varje träd endast korrigerar en del av residualen, vilket kräver fler träd för att konvergera men ger en jämnare och mer regulariserad prediktionsyta. Typiska värden är 0.01–0.3. Det omvända sambandet mellan learning_rate och n_estimators är avgörande: om ni halverar learning rate behöver ni ungefär fördubbla n_estimators för att nå samma träningsförlust. Använd alltid early stopping för att hitta rätt n_estimators för den learning rate ni har valt.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
# Inverse relationship between lr and n_estimators
configs = [(0.3, 50), (0.1, 150), (0.05, 300), (0.01, 1000)]
for lr, n in configs:
model = GradientBoostingClassifier(learning_rate=lr, n_estimators=n, max_depth=3, random_state=42)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'lr={lr:.2f}, n={n:4d}: CV={score:.4f}')n_estimators: Fler träd är inte alltid bättre
n_estimators anger det totala antalet sekventiella träd i ensemblen. Till skillnad från random forests (där fler träd alltid är bättre) kan boostingmodeller överanpassas med för många träd, särskilt vid höga learning rates. Den optimala punkten hittas genom att övervaka valideringsförlusten mellan omgångarna. Med early stopping kan ni tryggt ange n_estimators=2000 — träningen stoppas när valideringsresultatet inte längre förbättras. Utan early stopping använder ni korsvalidering över ett intervall av värden och väljer det n_estimators-värde som ligger vid vändpunkten på kurvan för valideringsfelet.
from sklearn.ensemble import GradientBoostingClassifier
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 n in [10, 50, 100, 200, 500]:
model = GradientBoostingClassifier(n_estimators=n, learning_rate=0.1, max_depth=3, random_state=42)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'n_estimators={n:4d}: CV accuracy={score:.4f}')max_depth: Svaga inlärare vinner i boosting
Gradient boosting fungerar bäst med svaga inlärningsmodeller — grunda träd (max_depth 2-6). Ett träd med djup 1 (beslutsstubbe) fångar bara en interaktion mellan egenskaper per omgång, medan ett träd med djup 3 fångar interaktioner mellan tre egenskaper. Djupare träd är individuellt kraftfullare och kräver färre omgångar, men medför risk för överanpassning. Grundare träd kräver fler omgångar men generaliserar bättre. I praktiken: börja med max_depth=3 för klassificering och max_depth=4-6 för komplex tabulär regression. Mycket djupa träd (>8) är nästan aldrig optimala i boosting.
from sklearn.ensemble import GradientBoostingClassifier
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 depth in [1, 2, 3, 5, 8, 15]:
model = GradientBoostingClassifier(n_estimators=200, learning_rate=0.1, max_depth=depth, random_state=42)
train_score = model.fit(X, y).train_score_[-1]
cv_score = cross_val_score(GradientBoostingClassifier(n_estimators=200, learning_rate=0.1, max_depth=depth, random_state=42), X, y, cv=5).mean()
print(f'max_depth={depth:2d}: train={train_score:.4f}, CV={cv_score:.4f}')Avvägningen mellan inlärningshastighet och n_estimators
Samverkan mellan learning_rate och n_estimators är den viktigaste avvägningen att förstå. Tänk på följande scenarier:
- Högt lr (0.3) + få träd (50): snabb träning, men riskerar att missa den optimala anpassningen
- Medelhögt lr (0.1) + medelstort antal träd (200): standardmässig startpunkt
- Lågt lr (0.01) + många träd (2000): mest regulariserat, bäst generalisering men långsam träning
Kurvor för tränings- och valideringsförlust
En av de mest informativa diagnostikmetoderna för gradient boosting är att plotta tränings- och valideringsförlusten över boosting-omgångarna. Träningsförlusten minskar alltid monotont. Valideringsförlusten minskar först, men börjar öka när modellen överanpassas. Punkten där valideringsförlusten är som lägst anger optimalt n_estimators. Den här grafen visar om ni behöver mer regularisering (valideringsförlusten ökar snabbt), mindre regularisering (valideringsförlusten minskar fortfarande i slutet) eller om ni har hittat den optimala balansen.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
model = GradientBoostingClassifier(n_estimators=300, learning_rate=0.1, max_depth=3, random_state=42)
model.fit(X_train, y_train)
val_scores = [model.estimators_[:i+1] and model.loss_(y_val, model.staged_predict_proba(X_val).__next__()) for i in range(5)]
# Simplified: use staged_predict to check improvement
val_staged = list(model.staged_predict(X_val))
val_acc = [np.mean(p == y_val) for p in val_staged]
print('Val acc at round 50:', round(val_acc[49], 4))
print('Val acc at round 300:', round(val_acc[299], 4))
print('Best round:', np.argmax(val_acc) + 1)Regularisering utöver de tre parametrarna
Utöver learning_rate, n_estimators och max_depth erbjuder gradient boosting ytterligare regularisering: min_samples_leaf (minsta antal exempel per löv, förhindrar överanpassning på mycket små lövgrupper), subsample (stokastisk träning, minskar variansen), max_features (subsampling av egenskaper vid varje uppdelning, minskar korrelationen), min_impurity_decrease (delar bara upp om ökningen överstiger ett tröskelvärde). Dessa sekundära parametrar är vanligtvis mindre viktiga än de tre primära, men kan göra betydande skillnad på brusiga dataset.
Systematisk strategi för hyperparametersökning
En praktisk strategi i tre steg för att finjustera gradient boosting: (1) Fixera learning_rate=0.1 och ange n_estimators=1000 med early stopping — hitta det optimala antalet omgångar; (2) Gör en grid search för max_depth (prova 3, 4, 5, 6) och min_samples_leaf (prova 1, 5, 10) med det trädantal som hittades i steg 1; (3) Sänk learning rate till 0.05 eller 0.01 och skala n_estimators därefter för att eventuellt få ut ännu bättre prestanda. På så sätt undviker ni dimensionalitetens förbannelse som uppstår när alla parametrar söks igenom samtidigt.
subsample som stokastisk regularisering
Att ange subsample < 1.0 (till exempel 0.8) i gradient boosting innebär att varje träd tränas på slumpmässigt valda 80 % av träningsdatan (utan återläggning). Detta kallas stokastisk gradient boosting. Det stokastiska inslaget skapar variation mellan träden (på liknande sätt som dropout i neurala nätverk) och förbättrar ofta valideringsprestandan med 0.5-2 %. Ett typiskt värde är 0.8. Om ni minskar värdet ytterligare (till 0.5) kan ni behöva fler träd för att kompensera för den högre variansen per träd.
from sklearn.ensemble import GradientBoostingClassifier
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 ss in [1.0, 0.8, 0.6, 0.5]:
model = GradientBoostingClassifier(n_estimators=200, learning_rate=0.1, max_depth=3,
subsample=ss, random_state=42)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'subsample={ss}: CV accuracy={score:.4f}')Balansera träningstid och prestanda
I produktion är träningstiden en verklig begränsning. Större n_estimators och fler CV-foldar ökar tiden linjärt. Praktiska genvägar: (1) använd n_jobs=-1 för parallellisering av korsvalideringen; (2) använd LightGBM eller XGBoost i stället för sklearna GradientBoosting för 5-10 gånger högre hastighet; (3) använd RandomizedSearchCV med 30-50 iterationer i stället för en fullständig grid search; (4) använd early stopping inom korsvalideringens foldar för att automatiskt ange n_estimators. Kombinationen av early stopping + LightGBM + RandomizedSearchCV minskar finjusteringstiden dramatiskt utan att noggrannheten försämras.
Standardhyperparametrar för gradient boosting
Bra standardvärden att utgå från för hyperparametrar i gradient boosting är: learning_rate=0.1, n_estimators=200 (med early stopping på en holdout-mängd), max_depth=3 för klassificering eller 4-5 för regression, subsample=0.8 för stokastisk regularisering samt min_samples_leaf=5-10 för att förhindra överdriven uppdelning av små grupper. Dessa standardvärden fungerar förvånansvärt bra på många dataset och bör vara er utgångspunkt innan ni börjar finjustera. Finjustera bara om baslinjens prestanda inte räcker för ert användningsfall.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
# Good defaults — try these before tuning
default_gb = GradientBoostingClassifier(
learning_rate=0.1, n_estimators=200, max_depth=3,
subsample=0.8, min_samples_leaf=5, random_state=42
)
scores = cross_val_score(default_gb, X, y, cv=5)
print('Default GBM CV:', scores.mean().round(4), '+/-', scores.std().round(4))Snabbtest
Testa era kunskaper om hyperparametrar för gradient boosting från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har ni lärt er att: learning rate och n_estimators har ett omvänt förhållande — en lägre lr kräver fler träd, grunda träd (max_depth 2-5) är att föredra i boosting eftersom de fungerar som svaga inlärningsmodeller och subsample och min_samples_leaf ger ytterligare regularisering utöver de tre primära parametrarna. Nästa avsnitt handlar om K-Fold Cross-Validation och hur ni utvärderar modeller utan att läcka testdata.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Viktiga hyperparametrar: learning rate, n_estimators och max_depth” gratis?
Ja – hela texten till ”Viktiga hyperparametrar: learning rate, n_estimators och max_depth” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Viktiga hyperparametrar: learning rate, n_estimators och max_depth”?
Ni kommer att undersöka hur shrinkage (learning rate), ensemble-storlek och djup påverkar avvägningen mellan bias och varians genom systematiska experiment. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Viktiga hyperparametrar: learning rate, n_estimators och max_depth”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Intuition för boosting: sekventiell felkorrigering
- XGBoost: regularisering, tidigt stopp och egenskapernas betydelse
- LightGBM: lövvis tillväxt och hastighetsfördelar
- Viktiga hyperparametrar: learning rate, n_estimators och max_depth