Intuition för boosting: sekventiell felkorrigering
Ni kommer att simulera tre omgångar gradient boosting för hand på en liten datamängd och anpassa varje nytt träd till residualerna från ensemblen hittills.
Intuition för boosting: sekventiell felkorrigering är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 1 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.
Boosting kontra Bagging: en viktig skillnad
Bagging tränar många modeller parallellt på slumpmässiga delmängder av data och kombinerar dem, vilket minskar variansen. Boosting tränar modeller sekventiellt: varje ny modell fokuserar på att korrigera de misstag som den föregående ensemblen gjorde. Medan bagging minskar variansen minskar boosting främst bias — det kan omvandla många svaga, underanpassade modeller till en kraftfull inlärningsmodell. Denna strategi med sekventiell felkorrigering utgör grunden för gradient boosting, AdaBoost och XGBoost.
Idén med sekventiell felkorrigering
Föreställ Er att Ni förutsäger huspriser. Er första modell förutsäger värden nära medelvärdet och gör stora fel. I stället för att kasta bort den tränar Ni en andra modell specifikt på den första modellens residualer (felen: faktiskt värde − förutsagt värde). Den andra modellen lär sig de mönster som den första missade. En tredje modell korrigerar sedan det som den andra fortfarande förutsåg fel. Varje ny modell gör en liten förbättring av det ackumulerade ensemble-resultatets aktuella fel. Den slutliga prediktionen är summan av alla modellers prediktioner.
Boosting för hand: tre omgångar
Betrakta ett litet regressionsdataset med 5 exempel. Börja med en modell som förutsäger medelvärdet. Beräkna residualerna. Träna ett träd på residualerna. Lägg till en andel av dess prediktioner (learning rate) till den aktuella ensemblen. Beräkna de nya residualerna. Upprepa. I varje omgång bör residualerna minska om träden fångar ett mönster. Efter tillräckligt många omgångar närmar sig residualerna noll för träningsmängden. Detta är exakt den algoritm som gradient boosting implementerar för regression med förlustfunktionen mean squared error.
import numpy as np
# Tiny example: manual 3-round gradient boosting for regression
y = np.array([3.0, 5.0, 2.0, 8.0, 1.0])
pred = np.full(5, y.mean()) # Round 0: predict the mean
print('Round 0 pred:', pred, 'Residuals:', y - pred)
# Round 1: suppose our tree predicts half the residual
residuals_1 = y - pred
pred += 0.5 * residuals_1 # learning_rate=0.5
print('Round 1 pred:', pred, 'Residuals:', np.round(y - pred, 2))
# Round 2
residuals_2 = y - pred
pred += 0.5 * residuals_2
print('Round 2 pred:', np.round(pred, 2), 'Residuals:', np.round(y - pred, 3))Inlärningshastigheten (krympning)
Inlärningshastigheten (ofta kallad shrinkage) skalar ned varje träds bidrag innan det läggs till i ensemblen. I stället för att korrigera hela residualen i ett enda steg (inlärningshastighet = 1.0) tar boosting ett litet steg (t.ex. 0.1) och låter efterföljande träd korrigera det som återstår. En mindre inlärningshastighet kräver fler träd för att uppnå samma anpassning men generaliserar bättre, eftersom inget enskilt träd dominerar. Kompromissen är att mycket små inlärningshastigheter kräver ett mycket stort värde på n_estimators, vilket ökar träningstiden.
Gradient descent i funktionsrymden
Gradient boosting har fått sitt namn genom kopplingen till gradient descent. I standardmässig gradient descent uppdaterar vi parametrar genom att röra oss i den riktning som minskar förlusten. I gradient boosting uppdaterar vi prediktionsfunktionen genom att träna ett nytt träd på förlustens negativa gradient med avseende på de aktuella prediktionerna. För förlustfunktionen mean squared error är den negativa gradienten helt enkelt residualen (faktiskt värde − förutsagt värde). För andra förlustfunktioner (log-loss och absolut fel) beräknas motsvarande pseudo-residualer.
GradientBoostingClassifier i scikit-learn
scikit-learn tillhandahåller GradientBoostingClassifier, som implementerar Friedmans ursprungliga gradient boosting-algoritm. Viktiga parametrar är: n_estimators (antal träd), learning_rate (krympning), max_depth (djupet på varje träd — grunda träd föredras, vanligtvis 3–5) och subsample (andelen träningsdata som används för varje träd, vilket tillför ett stokastiskt element som förbättrar generaliseringen). Kombinationen av låg inlärningshastighet, många grunda träd och subsampling är standardreceptet.
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)
gb = GradientBoostingClassifier(
n_estimators=200,
learning_rate=0.1,
max_depth=3,
subsample=0.8,
random_state=42
)
scores = cross_val_score(gb, X, y, cv=5)
print('GradientBoosting CV:', round(scores.mean(), 4))Överanpassning i boosting
Till skillnad från bagging kan boosting överanpassa med tillräckligt många estimatorer, särskilt vid hög inlärningshastighet. När Ni lägger till fler omgångar fortsätter träningsförlusten att minska, men valideringsförlusten börjar så småningom öka. Lösningen är att: (1) använda early stopping — övervaka valideringsförlusten och stoppa när den inte längre förbättras; (2) använda en låg inlärningshastighet (0.01–0.1) med många träd i stället för en hög hastighet med få träd; (3) regularisera enskilda träd med grunt djup och ett minsta antal observationer per löv. Alla dessa tekniker finns tillgängliga i XGBoost och LightGBM:s omfattande uppsättningar av hyperparametrar.
AdaBoost: den ursprungliga boosting-algoritmen
AdaBoost (Adaptive Boosting) var den första praktiskt användbara boosting-algoritmen. I stället för att träna träd på residualer tilldelar den observationsvikter: felklassificerade exempel får högre vikt i nästa omgång, så att efterföljande träd fokuserar på de svåra fallen. Varje träds bidrag till den slutliga omröstningen viktas också efter dess träffsäkerhet — bättre träd får större inflytande. AdaBoost implementeras i scikit-learn som AdaBoostClassifier och är historiskt viktigt, men gradient boosting (och XGBoost) har i praktiken till stor del ersatt det.
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
ada = AdaBoostClassifier(
estimator=DecisionTreeClassifier(max_depth=1), # stumps
n_estimators=200,
learning_rate=0.5,
random_state=42
)
print('AdaBoost CV:', round(cross_val_score(ada, X, y, cv=5).mean(), 4))Stokastisk gradient boosting
Om Ni anger subsample < 1.0 i gradient boosting införs slumpmässighet: varje träd tränas på en slumpmässig delmängd av träningsdata (utan återläggning). Detta stokastiska inslag minskar korrelationen mellan träden och förbättrar ofta generaliseringen — ungefär som dropout-idén i neurala nätverk. Ett vanligt värde är subsample=0.8. När subsample är mindre än 1 beräknar scikit-learn dessutom en out-of-bag-uppskattning av förbättringen i varje omgång, tillgänglig via oob_improvement_.
När boosting slår Random Forest
Boosting överträffar vanligtvis random forests på rena tabulära data där signal-brusförhållandet är högt och det finns komplexa samspel mellan egenskaper. Den sekventiella felkorrigeringen gör att boosting kan utvinna nästan all förutsägbar signal. Boosting är dock känsligare för brusiga data och avvikare — eftersom varje omgång fokuserar på svåra exempel kan brus dra modellen i fel riktning. Random forests är mer robusta mot brus i etiketterna. För brusiga och röriga data från verkligheten beror valet på det specifika datasetet.
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
gb = GradientBoostingClassifier(n_estimators=200, learning_rate=0.1, max_depth=3, random_state=42)
rf = RandomForestClassifier(n_estimators=200, random_state=42)
print('Gradient Boosting:', round(cross_val_score(gb, X, y, cv=5).mean(), 4))
print('Random Forest: ', round(cross_val_score(rf, X, y, cv=5).mean(), 4))Boosting för regressionsuppgifter
Gradient boosting är lika kraftfullt för regression. GradientBoostingRegressor minimerar som standard en regressionsförlust (kvadratiskt fel), men stöder även absolut fel (loss='absolute_error', robust mot avvikare) och Huber-förlust (loss='huber', som kombinerar kvadratiskt fel för små fel med absolut fel för stora fel). För förutsägelse av huspriser, energiprognoser och liknande uppgifter överträffar gradient boosting konsekvent linjär regression och matchar eller överträffar ofta neurala nätverk på tabulära data utan behov av GPU-hårdvara.
from sklearn.ensemble import GradientBoostingRegressor
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)
gbr = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1, max_depth=4,
subsample=0.8, random_state=42)
rmse = np.sqrt(-cross_val_score(gbr, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print('GBR Regression RMSE:', round(rmse, 4))Snabbkontroll
Testa Er förståelse av Boosting och sekventiell felkorrigering från den här lektionen.
Lektionssammanfattning
I den här lektionen lärde Ni Er att: boosting tränar modeller sekventiellt, där varje modell korrigerar residualfelen från den föregående ensemblen, inlärningshastigheten skalar varje träds bidrag och styr överanpassningen och gradient boosting minimerar en deriverbar förlust genom att träna träd på den negativa gradienten. Härnäst utforskar vi XGBoost:s regularisering och funktioner för early stopping.
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 ”Intuition för boosting: sekventiell felkorrigering” gratis?
Ja – hela texten till ”Intuition för boosting: sekventiell felkorrigering” 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 ”Intuition för boosting: sekventiell felkorrigering”?
Ni kommer att simulera tre omgångar gradient boosting för hand på en liten datamängd och anpassa varje nytt träd till residualerna från ensemblen hittills. 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 1 av 4.
Hur lång tid tar lektionen ”Intuition för boosting: sekventiell felkorrigering”?
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