Bootstrap-aggregering (bagging) förklarad
Ni kommer att implementera bootstrap-sampling för hand, träna klassificerare på varje stickprov och förstå varför ett genomsnitt av olika modeller minskar variansen.
Bootstrap-aggregering (bagging) förklarad ä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.
Vad är bootstrapaggregering?
Bootstrap Aggregation, som ofta kallas Bagging, är en ensembleteknik som tränar flera modeller på olika slumpmässiga delmängder av träningsdata och kombinerar deras prognoser. Ordet bootstrap kommer från statistiken och innebär att man samplar med återläggning från sina data. Genom att beräkna medelvärdet av eller rösta med många olika modeller minskar bagging den slutliga prognosens varians kraftigt utan att öka bias.
Sampling med återläggning förklarat
Sampling med återläggning innebär att varje bootstrap-urval dras oberoende från hela datasetet – samma rad kan förekomma flera gånger i ett och samma urval, medan andra rader kan utelämnas helt. För ett dataset med N exempel innehåller varje bootstrap-urval också N rader. I genomsnitt förekommer cirka 63,2 % av de unika exemplen i ett givet bootstrap-urval, och de återstående cirka 37 % bildar out-of-bag-mängden som kan användas för validering.
import numpy as np
np.random.seed(42)
data = np.arange(10) # [0, 1, 2, ..., 9]
bootstrap_sample = np.random.choice(data, size=len(data), replace=True)
print('Original:', data)
print('Bootstrap sample:', bootstrap_sample)Varför mångfald minskar variansen
Anta att du har n oberoende modeller, var och en med variansen σ². Om du beräknar medelvärdet av deras prognoser blir variansen för medelvärdet σ²/n – den minskar när du lägger till fler modeller. I praktiken är modeller som tränats på bootstrap-urval korrelerade (de delar samma träningsfördelning), så minskningen är begränsad men fortfarande betydande. Den viktiga insikten är att medelvärdesbildning minskar variansen utan att öka bias, vilket leder till bättre generalisering.
Implementera Bagging för hand
Du kan implementera bagging manuellt genom att träna en lista med estimatorer, var och en på ett annat bootstrap-urval, och sedan beräkna medelvärdet av deras utdata. Detta visar exakt vad BaggingClassifier gör internt. Om du förstår den manuella versionen blir det enklare att diagnostisera problem och utöka tekniken till anpassade modeller.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
n_estimators = 10
models = []
for _ in range(n_estimators):
idx = np.random.choice(len(X), size=len(X), replace=True)
X_boot, y_boot = X[idx], y[idx]
tree = DecisionTreeClassifier()
tree.fit(X_boot, y_boot)
models.append(tree)
# Predict by majority vote
predictions = np.array([m.predict(X) for m in models])
ensemble_pred = [np.bincount(col).argmax() for col in predictions.T]
print('Ensemble accuracy:', np.mean(ensemble_pred == y))scikit-learn BaggingClassifier
scikit-learn tillhandahåller BaggingClassifier, som kapslar in valfri basestimator och automatiserar bootstrapsampling och aggregering. Du styr n_estimators (antal modeller), max_samples (andel eller absolut antal träningsprover per modell) och max_features (antal funktioner som ska användas). Om du anger oob_score=True beräknas ett kostnadsfritt valideringsresultat med hjälp av out-of-bag-exemplen för varje estimator.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
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)
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
oob_score=True,
random_state=42
)
bag.fit(X_train, y_train)
print('OOB score:', bag.oob_score_)
print('Test accuracy:', bag.score(X_test, y_test))Bagging för regression
Bagging är inte begränsat till klassificering. BaggingRegressor använder samma idé: träna flera regressorer på bootstrap-urval och beräkna medelvärdet av deras numeriska prognoser. Detta är särskilt värdefullt när basmodellen har hög varians, till exempel ett obeskuret beslutsträd. Ett enda träd memorerar brus, medan medelvärdet av många träd jämnar ut bruset och minskar testets RMSE avsevärt.
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
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)
single_tree = DecisionTreeRegressor(random_state=42)
bag_reg = BaggingRegressor(estimator=DecisionTreeRegressor(), n_estimators=100, random_state=42)
single_rmse = np.sqrt(-cross_val_score(single_tree, X, y, scoring='neg_mean_squared_error', cv=3).mean())
bag_rmse = np.sqrt(-cross_val_score(bag_reg, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print(f'Single tree RMSE: {single_rmse:.4f}')
print(f'Bagged tree RMSE: {bag_rmse:.4f}')Andelen out-of-bag-data
Eftersom cirka 37 % av tränings exemplen utelämnas från varje bootstrap-urval kan dessa exempel fungera som en valideringsmängd för respektive estimator utan någon ytterligare uppdelning av data. OOB-resultatet beräknas genom att förutsäga varje träningspunkt med endast de estimatorer som inte såg den under träningen. Detta ger en nästan opartisk uppskattning av generaliseringsprestandan, ungefär som leave-one-out-korsvalidering men till en mycket lägre beräkningskostnad.
Effekten av n_estimators på prestandan
Att lägga till fler estimatorer i en bagging-ensemble förbättrar nästan alltid testresultatet (eller försämrar det i värsta fall inte). Till skillnad från neurala nätverks djup finns det ingen överanpassningskostnad för att lägga till fler träd — variansen fortsätter att minska medan bias förblir oförändrad. I praktiken planar resultatet ut efter flera hundra estimatorer. Den huvudsakliga avvägningen gäller beräkningstid: om n_estimators fördubblas fördubblas träningstiden. Kontrollera alltid om den marginella förbättringen motiverar den extra kostnaden.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
for n in [1, 10, 50, 200]:
bag = BaggingClassifier(estimator=DecisionTreeClassifier(), n_estimators=n, random_state=42)
score = cross_val_score(bag, X, y, cv=5).mean()
print(f'n_estimators={n:4d}: CV accuracy={score:.4f}')Bagging jämfört med en enda komplex modell
En enda komplex modell (ett djupt träd, ett polynom av hög grad) har låg bias men hög varians — den passar träningsdata väl men varierar kraftigt på data som den inte har sett. Bagging dämpar denna varians genom att ta medelvärdet av många sådana modeller. Den kombinerade prediktionen blir mycket stabilare. Det är därför bagging fungerar bäst när basmodellen har hög varians och låg bias. Om bagging tillämpas på en enkel modell som redan lider av underanpassning (till exempel linjär regression) blir nyttan liten, eftersom variansen redan var låg.
Parallellism: Bagging är pinsamt parallelliserbart
Varje estimator i en bagging-ensemble tränas självständigt, utan databeroenden mellan estimatorerna. Det gör bagging pinsamt parallelliserbart — alla estimatorer kan tränas samtidigt på flera CPU-kärnor. scikit-learn erbjuder detta via parametern n_jobs=-1, som använder alla tillgängliga kärnor. Detta står i skarp kontrast till boostingmetoder som XGBoost, där varje modell är beroende av den föregående och träningen i grunden sker sekventiellt.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
import time
X, y = load_breast_cancer(return_X_y=True)
bag_serial = BaggingClassifier(n_estimators=200, n_jobs=1, random_state=42)
bag_parallel = BaggingClassifier(n_estimators=200, n_jobs=-1, random_state=42)
start = time.time(); bag_serial.fit(X, y); print('Serial:', round(time.time()-start, 2), 's')
start = time.time(); bag_parallel.fit(X, y); print('Parallel:', round(time.time()-start, 2), 's')Begränsningar och när bagging misslyckas
Bagging har viktiga begränsningar. För det första ökar beräknings- och minnesåtgången linjärt med antalet estimatorer. För det andra ger metoden ingen förbättring av bias — om basmodellen är för enkel ger många enkla modeller fortfarande en enkel ensemble. För det tredje gör bagging modellen svårare att tolka — Ni förlorar det enskilda beslutsträd som Ni kunde visa för en intressent. Slutligen gör bagging i sig inte träden okorrelerade om alla egenskaper används vid varje delning, vilket är anledningen till att Random Forests lägger till det extra tricket med delurval av egenskaper.
Snabb kontroll
Testa Er förståelse av begreppen Bootstrap Aggregation från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har Ni lärt Er att bootstrap aggregation tränar flera modeller på slumpmässiga urval med återläggning, att medelvärdesbildning av prediktioner minskar variansen utan att öka bias och att out-of-bag-exemplen ger kostnadsfri validering för varje estimator. Härnäst utforskar vi Random Forest-tricket att göra delurval av egenskaper för att ytterligare minska korrelationen mellan träden.
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 ”Bootstrap-aggregering (bagging) förklarad” gratis?
Ja – hela texten till ”Bootstrap-aggregering (bagging) förklarad” 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 ”Bootstrap-aggregering (bagging) förklarad”?
Ni kommer att implementera bootstrap-sampling för hand, träna klassificerare på varje stickprov och förstå varför ett genomsnitt av olika modeller minskar variansen. 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 ”Bootstrap-aggregering (bagging) förklarad”?
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
- Bootstrap-aggregering (bagging) förklarad
- Slumpmässigt egenskapsurval: Random Forest-tricket
- Out-of-bag-fel: kostnadsfri validering i skogen
- Ensembler med röstning: hård röstning kontra mjuk röstning