Random forests en bagging
Het ensembleconcept, RandomForestClassifier, n_estimators, feature importance en OOB-score.
Random forests en bagging is een gratis Leer AI met Python-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer AI met Python. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer AI met Python bevat in totaal 4 lessen.
Het probleem met afzonderlijke bomen
Een afzonderlijke beslisboom heeft een hoge variantie: opnieuw trainen met iets andere gegevens kan een heel andere boom opleveren. Ensembles lossen dit op door veel bomen te combineren.
Bagging (bootstrapaggregatie)
Bagging traint veel modellen op verschillende bootstrapsteekproeven (willekeurige steekproeven met teruglegging) van de gegevens en middelt daarna hun voorspellingen.
Het middelen van veel modellen met een hoge variantie vermindert de totale variantie zonder de vertekening veel te vergroten.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
random_state=0,
)
bag.fit(Xtr, ytr)Van bagging naar random forests
Een random forest is bagging van bomen met één extra truc: bij elke splitsing wordt slechts een willekeurige deelverzameling van kenmerken bekeken.
Hierdoor zijn de bomen minder gecorreleerd en heffen hun fouten elkaar beter op, waardoor het ensemble beter presteert.
De basis van RandomForestClassifier
Gebruik RandomForestClassifier. Met de belangrijkste parameter n_estimators stel je in hoeveel bomen worden gebouwd. Meer bomen = stabieler, maar trager.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=0)
rf.fit(Xtr, ytr)
print("Accuracy:", rf.score(Xte, yte))Parallel trainen met n_jobs
Bomen in een forest zijn onafhankelijk en kunnen daarom parallel worden getraind. Stel n_jobs=-1 in om alle CPU-kernen te gebruiken en het trainen aanzienlijk te versnellen.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=500,
n_jobs=-1, # use all cores
random_state=0,
)
rf.fit(Xtr, ytr)Out-of-bag-score (OOB-score)
Elke boom laat ongeveer een derde van de voorbeelden weg (de bootstrapsteekproef heeft ze niet geselecteerd). Deze out-of-bag-voorbeelden vormen een ingebouwde validatieset.
Stel oob_score=True in voor een gratis schatting van de generalisatiefout zonder een afzonderlijke splitsing.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
oob_score=True,
random_state=0,
)
rf.fit(Xtr, ytr)
print("OOB score:", rf.oob_score_)Boomdiepte in het forest regelen
Dezelfde boomparameters zijn van toepassing: max_depth, min_samples_leaf en max_features (het aantal kenmerken dat per splitsing wordt geprobeerd).
max_features="sqrt" is de gebruikelijke standaard voor classificatie.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
max_depth=12,
max_features="sqrt",
random_state=0,
)Ingebouwde belangrijkheid van kenmerken
Net als afzonderlijke bomen bieden forests feature_importances_, gemiddeld over alle bomen. Deze op onzuiverheid gebaseerde belangrijkheid is snel te berekenen, maar kan bevooroordeeld zijn ten gunste van kenmerken met veel unieke waarden.
from sklearn.ensemble import RandomForestClassifier
import numpy as np
rf = RandomForestClassifier(n_estimators=200, random_state=0).fit(Xtr, ytr)
order = np.argsort(rf.feature_importances_)[::-1]
for i in order[:5]:
print(i, rf.feature_importances_[i])Belangrijkheid via permutatie
Belangrijkheid via permutatie is betrouwbaarder: de waarden in één kenmerkkolom worden door elkaar geschud en er wordt gemeten hoeveel de score daalt. Een grote daling betekent dat het kenmerk belangrijk was.
Deze methode is modelonafhankelijk en vermijdt de vertekening van belangrijkheid op basis van onzuiverheid.
from sklearn.inspection import permutation_importance
result = permutation_importance(
rf, Xte, yte, n_repeats=10, random_state=0, n_jobs=-1
)
print(result.importances_mean)Permutatieresultaten interpreteren
permutation_importance retourneert over meerdere herhalingen importances_mean en importances_std. Bereken dit op een afgezonderde set, zodat je de invloed op generalisatie meet en niet de pasvorm op de trainingsgegevens.
import numpy as np
means = result.importances_mean
stds = result.importances_std
for i in np.argsort(means)[::-1]:
print(f"feature {i}: {means[i]:.3f} +/- {stds[i]:.3f}")Wanneer random forests gebruiken
Random forests zijn een sterke standaardkeuze: robuust, weinig afstemming nodig, geschikt voor niet-lineariteiten en interacties en bestand tegen overfitting. Nadelen zijn het grotere geheugengebruik, de tragere voorspellingen dan bij een afzonderlijke boom en de geringere interpreteerbaarheid.
Korte controle
Controleer je begrip van bagging en forests.
Samenvatting
Samenvatting: Bagging traint modellen op bootstrapsteekproeven en middelt ze om de variantie te verlagen. Random forests voegen per splitsing willekeurige deelverzamelingen van kenmerken toe. Stem af met n_estimators, gebruik n_jobs=-1 voor snelheid, krijg gratis validatie via oob_score en geef voor betrouwbare rangschikkingen de voorkeur aan permutation_importance boven belangrijkheid op basis van onzuiverheid.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 53
- Lessen
- 225
Veelgestelde vragen
Is de les “Random forests en bagging” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer AI met Python, waaronder “Random forests en bagging”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer AI met Python bevat in totaal 4 lessen.
Wat leer ik in “Random forests en bagging”?
Het ensembleconcept, RandomForestClassifier, n_estimators, feature importance en OOB-score. Je oefent met Leer AI met Python door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Leer AI met Python te beginnen?
Ervaring vooraf is niet nodig. Leer AI met Python op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Random forests en bagging”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Leer AI met Python?
Ja. Elke les over Leer AI met Python bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Beslisbomen: theorie en implementatie
- Random forests en bagging
- Gradient boosting: GBM en XGBoost
- LightGBM en CatBoost