Bootstrap-aggregering (bagging) forklaret
Implementér bootstrap-sampling manuelt, træn klassifikatorer på hver stikprøve, og forstå, hvorfor gennemsnit af forskellige modeller reducerer variansen.
Bootstrap-aggregering (bagging) forklaret er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad er bootstrap-aggregering?
Bootstrap-aggregering, der almindeligvis kaldes Bagging, er en ensembleteknik, som træner flere modeller på forskellige tilfældige delmængder af træningsdataene og kombinerer deres forudsigelser. Ordet bootstrap stammer fra statistik og betyder stikprøveudtagning med tilbagelægning fra dine data. Ved at beregne gennemsnittet af eller stemme på tværs af mange forskellige modeller reducerer bagging variansen for den endelige forudsigelse markant uden at øge bias.
Forklaring af stikprøveudtagning med tilbagelægning
Stikprøveudtagning med tilbagelægning betyder, at hver bootstrap-stikprøve udtages uafhængigt fra hele datasættet — den samme række kan forekomme flere gange i én stikprøve, mens andre rækker helt kan være udeladt. For et datasæt med N eksempler indeholder hver bootstrap-stikprøve også N rækker. I gennemsnit forekommer omkring 63,2 % af de unikke eksempler i en given bootstrap-stikprøve, og de resterende ca. 37 % udgør out-of-bag-mængden, som kan bruges til 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)Hvorfor diversitet reducerer variansen
Antag, at du har n uafhængige modeller, som hver har variansen σ². Hvis du beregner gennemsnittet af deres forudsigelser, er variansen for gennemsnittet σ²/n — den bliver mindre, når du tilføjer flere modeller. I praksis er modeller, der er trænet på bootstrap-stikprøver, korrelerede (de deler den samme træningsfordeling), så reduktionen er delvis, men stadig betydelig. Den centrale pointe er, at gennemsnitsberegning reducerer variansen uden at øge bias, hvilket fører til bedre generalisering.
Implementering af Bagging i hånden
Du kan implementere bagging manuelt ved at træne en liste med estimatorer, hver på en forskellig bootstrap-stikprøve, og derefter beregne gennemsnittet af deres output. Det viser præcis, hvad BaggingClassifier gør internt. Når du forstår den manuelle version, bliver det lettere at diagnosticere problemer og udvide teknikken til brugerdefinerede 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 indeholder BaggingClassifier, som omslutter en vilkårlig basisevaluator og automatiserer bootstrap-udtagningen og aggregeringen. Du styrer n_estimators (antal modeller), max_samples (brøkdel eller absolut antal træningsprøver pr. model) og max_features (antal funktioner, der skal bruges). Hvis du angiver oob_score=True, beregnes en gratis valideringsscore ved hjælp af out-of-bag-eksemplerne for hver 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 til regression
Bagging er ikke begrænset til klassifikation. BaggingRegressor anvender den samme idé: Træn flere regressorer på bootstrap-stikprøver, og beregn gennemsnittet af deres numeriske forudsigelser. Det er især værdifuldt, når den grundlæggende model har høj varians, som f.eks. et ubeskåret beslutningstræ. Et enkelt træ husker støj; gennemsnittet af mange træer udjævner den og reducerer den samlede RMSE på testdata markant.
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 af out-of-bag-eksempler
Da ca. 37 % af træningseksemplerne udelades fra hver bootstrap-stikprøve, kan disse eksempler fungere som et valideringssæt for den tilsvarende estimator uden yderligere opdeling af dataene. OOB-scoren beregnes ved at forudsige hvert træningspunkt udelukkende med de estimatorer, som ikke så punktet under træningen. Det giver et næsten unbiased estimat af generaliseringsydelsen, der minder om leave-one-out-krydsvalidering, men er langt billigere at beregne.
Effekten af n_estimators på ydeevnen
Det hjælper næsten altid på testresultaterne at tilføje flere estimatorer til et bagging-ensemble (eller skader i værste fald ikke). I modsætning til neurale netværks dybde er der ingen overfitting-ulempe ved at tilføje flere træer — variansen bliver ved med at falde, mens bias forbliver konstant. I praksis flader resultaterne ud efter nogle hundrede estimatorer. Den vigtigste afvejning er beregningstiden: Hvis du fordobler n_estimators, fordobler du træningstiden. Kontrollér altid, om den marginale forbedring retfærdiggør den ekstra omkostning.
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 over forenkelt kompleks model
En enkelt kompleks model (et dybt træ, et polynomium af høj grad) opnår lav bias, men høj varians — den tilpasser sig træningsdataene godt, men varierer kraftigt på data, den ikke har set før. Bagging dæmper denne varians ved at tage gennemsnittet af mange sådanne modeller. Den samlede forudsigelse bliver langt mere stabil. Derfor fungerer bagging bedst, når grundmodellen har høj varians og lav bias. Hvis du anvender bagging på en simpel model, der allerede underfitter (f.eks. en lineær regression), er gevinsten lille, fordi variansen allerede var lav.
Parallelisering: Bagging kan paralleliseres trivielt
Hver estimator i et bagging-ensemble trænes uafhængigt, uden dataafhængigheder mellem dem. Derfor kan bagging paralleliseres trivielt — alle estimatorer kan trænes samtidigt på flere CPU-kerner. scikit-learn giver adgang til dette via parameteren n_jobs=-1, som bruger alle tilgængelige kerner. Det står i skarp kontrast til boosting-metoder som XGBoost, hvor hver model afhænger af den forrige, og træningen derfor i sin natur foregår sekventielt.
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ænsninger, og hvornår bagging mislykkes
Bagging har vigtige begrænsninger. For det første vokser beregningsforbruget og hukommelsesforbruget lineært med antallet af estimatorer. For det andet giver det ingen forbedring af bias — hvis din grundmodel er for simpel, giver mange simple modeller stadig et simpelt ensemble. For det tredje gør bagging modellen sværere at fortolke — du mister det enkelte beslutningstræ, som du kunne vise en interessent. Endelig afkorrelerer bagging alene ikke træerne, hvis alle features bruges ved hvert split. Her tilføjer Random Forest-modeller det ekstra trick, at de udvælger et deludvalg af features.
Hurtigt tjek
Test din forståelse af begreberne inden for bootstrap-aggregering fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at bootstrap-aggregering træner flere modeller på tilfældige genudvalg med tilbagelægning, at gennemsnit af forudsigelser reducerer variansen uden at øge bias, og at out-of-bag-eksempler giver gratis validering for hver estimator. Nu ser vi nærmere på Random Forest-tricket, hvor man udvælger et deludvalg af features for at afkorrelere træerne yderligere.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Bootstrap-aggregering (bagging) forklaret” gratis?
Ja — hele teksten til “Bootstrap-aggregering (bagging) forklaret” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Bootstrap-aggregering (bagging) forklaret”?
Implementér bootstrap-sampling manuelt, træn klassifikatorer på hver stikprøve, og forstå, hvorfor gennemsnit af forskellige modeller reducerer variansen. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Bootstrap-aggregering (bagging) forklaret”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Bootstrap-aggregering (bagging) forklaret
- Tilfældig featureudvælgelse: Random Forest-tricket
- Out-of-Bag-fejl: Gratis validering i skoven
- Voting-ensembler: Hard vote eller soft vote