Wat is bagging in machine learning? Een gids met voorbeelden

Ensemblemethoden zijn krachtige technieken in machine learning die meerdere modellen combineren om de algehele predictienauwkeurigheid en modelstabiliteit te verbeteren. Bootstrap Aggregating, beter bekend als bagging, springt eruit als een populaire en veelgebruikte ensemblemethode.

In deze tutorial duiken we dieper in bagging: hoe het werkt en waar het in uitblinkt. We vergelijken het met een andere ensemblemethode (boosting) en bekijken een bagging-voorbeeld in Python. Aan het einde heb je een solide begrip van bagging, inclusief best practices.

Ensemble learning begrijpen

Ensemblemodellering is een techniek die meerdere machinelearningmodellen combineert om de algehele voorspellende prestaties te verbeteren. Het basisidee is dat een groep zwakke leerders samen één sterke leerder kan vormen.

Een ensemblemodel bestaat doorgaans uit twee stappen:

1. Meerdere machinelearningmodellen worden onafhankelijk getraind.
2. Hun voorspellingen worden op een bepaalde manier geaggregeerd, bijvoorbeeld door te stemmen, te middelen of te wegen. Dit ensemble wordt vervolgens gebruikt om de uiteindelijke voorspelling te doen.

Ensembles leveren vaak betere resultaten op omdat de verschillende modellen elkaar aanvullen en hun individuele zwaktes compenseren. Ze verlagen ook de variantie en voorkomen overfitting.

Populaire ensemblemethoden zijn onder andere bagging, boosting en stacking. Ensembles worden veel gebruikt bij machinelearningtaken zoals classificatie, regressie en clustering om nauwkeurigheid en robuustheid te vergroten.

Wat is bagging?

Bagging (bootstrap aggregating) is een ensemblemethode waarbij meerdere modellen onafhankelijk worden getraind op willekeurige subsets van de data, en hun voorspellingen worden geaggregeerd via stemmen of middelen.

Concreet wordt elk model getraind op een willekeurige subset van de data, getrokken met terugleggen, wat betekent dat individuele datapunten meer dan eens kunnen worden gekozen. Deze willekeurige subset heet een bootstrap-steekproef. Door modellen op verschillende bootstraps te trainen, vermindert bagging de variantie van de individuele modellen. Het voorkomt ook overfitting door de deelmodellen aan verschillende delen van de dataset bloot te stellen.

De voorspellingen van alle getrainde modellen worden vervolgens gecombineerd door eenvoudig te middelen om tot de uiteindelijke voorspelling te komen. Zo neemt het geaggregeerde model de sterke punten van de individuele modellen over en heffen hun fouten elkaar op.

Bagging is vooral effectief in het verminderen van variantie en overfitting, waardoor het model robuuster en nauwkeuriger wordt, met name in gevallen waarin de individuele modellen een hoge variabiliteit vertonen.

Bagging vs. boosting

Boosting is een andere populaire ensemblemethode die vaak met bagging wordt vergeleken. Het belangrijkste verschil zit in hoe de deelmodellen worden getraind.

Bij bagging worden modellen onafhankelijk en parallel getraind op verschillende willekeurige subsets van de data. Bij boosting daarentegen worden modellen sequentieel getraind, waarbij elk model leert van de fouten van het vorige. Bovendien gebruikt bagging doorgaans eenvoudig middelen van modellen, terwijl boosting gewichten toekent op basis van nauwkeurigheid.

Bagging verlaagt de variantie, terwijl boosting de bias verlaagt. Bagging kan worden gebruikt met onstabiele modellen zoals beslissingsbomen, terwijl boosting beter werkt voor stabiele modellen zoals lineaire regressie.

Beide methoden hebben hun sterke en zwakke punten. Bagging is eenvoudiger parallel uit te voeren, terwijl boosting krachtiger en nauwkeuriger kan zijn. In de praktijk is het handig om beide te testen op een nieuw probleem om te zien welke beter presteert.

Voordelen van bagging

Hier zijn enkele belangrijke voordelen van bagging:

1. Vermindert overfitting: Het kan de kans op een overfit model verkleinen, wat resulteert in een betere nauwkeurigheid op onzichtbare data.
2. Verlaagt de modelvariantie: Meerdere modellen die op verschillende subsets van de data zijn getraind, middelen hun voorspellingen, wat leidt tot een lagere variantie dan een enkel model.
3. Verbetert stabiliteit: Veranderingen in de trainingsdataset hebben minder impact op gebagde modellen, waardoor het totale model stabieler wordt.
4. Kan hoge variabiliteit aan: Met name effectief voor algoritmen zoals beslissingsbomen, die de neiging hebben hoge variantie te vertonen.
5. Paralleliseerbare berekening: Elk model in het ensemble kan onafhankelijk worden getraind, wat parallelle verwerking en efficiënt gebruik van rekenbronnen mogelijk maakt.
6. Eenvoudig te begrijpen en te implementeren: Het concept achter bagging is rechttoe rechtaan en kan worden geïmplementeerd zonder complexe aanpassingen aan het leeralgoritme.
7. Goed met rumoerige data: Het middelen helpt om ruis in de uiteindelijke voorspelling te verminderen.
8. Kan ongebalanceerde data aan: Bagging kan helpen in scenario’s waar de dataset ongebalanceerd is, waardoor de prestaties in zulke situaties verbeteren.

Bagging in Python: een korte tutorial

In deze Python-tutorial trainen we een beslissingsboom-classificatiemodel op een telecom customer churn-dataset en gebruiken we de bagging-ensemblemethode om de prestaties te verbeteren. We gebruiken DataLab om de dataset op te halen en onze code uit te voeren. De code is ook beschikbaar in dit DataLab-werkboek, dat je kunt kopiëren om in je browser uit te voeren zonder iets te installeren.

Dataset

De dataset over telecom customer churn komt van een Iraans telecombedrijf. Elke rij in de dataset komt overeen met de activiteit van een klant gedurende een jaar, inclusief informatie over mislukte oproepen, abonnementsduur en een churn-label dat aangeeft of de klant de dienst heeft verlaten.

Eerst laden we de dataset en bekijken we de bovenste 5 rijen.

import pandas as pd

customer = pd.read_csv("data/customer_churn.csv")
customer.head()Mogelijk gemaakt door

Daarna maken we onafhankelijke (X) en afhankelijke (y) variabelen. Vervolgens splitsen we de dataset in trainings- en testsubsets.

X = customer.drop("Churn", axis=1)
y = customer.Churn

# Split into train and test 
from sklearn.model_selection import train_test_split, cross_val_score
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)Mogelijk gemaakt door

Train een machinelearningmodel

We maken een eenvoudige machinelearningpijplijn en fitten daar de trainingsdataset op. De pijplijn normaliseert de data voordat de invoer naar de beslissingsboomclassificator gaat.

from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', DecisionTreeClassifier(random_state=42))
])

pipeline.fit(X_train, y_train)Mogelijk gemaakt door

Volg de cursus Machine Learning with Tree-Based Models in Python om te leren hoe je boombased modellen en ensembles gebruikt voor regressie en classificatie met scikit-learn.

Model-evaluatie

We evalueren een beslissingsboommodel zodat we het kunnen vergelijken met het ensemblemodel.

We genereren classificatierapporten door voorspellingen te doen op een testdataset.

from sklearn.metrics import classification_report

# Make prediction on the testing data
y_pred = pipeline.predict(X_test)

# Classification Report
print(classification_report(y_pred, y_test))Mogelijk gemaakt door

Ons model behaalde 96% precisie en 97% recall op de meerderheidsklasse “0”, maar presteerde slecht op de minderheidsklasse “1”.

Om een beter beeld te krijgen van de prestaties van het model voeren we cross-validatie uit en berekenen we de bijbehorende scores.

# Evaluate the classifier using cross-validation
cv_scores = cross_val_score(pipeline, X, y, cv=5)

print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {np.mean(cv_scores):.2f}")Mogelijk gemaakt door

Er is een grote variatie in scores, met pieken op 95% en dalen op 92%.

Cross-validation scores: [0.95079365 0.94126984 0.93492063 0.94285714 0.92222222]
Mean CV accuracy: 0.94Mogelijk gemaakt door

Bagging Classifier

Laten we nu een bagging-classificator maken met als basisestimator onze pijplijn (schaalbewerker + beslissingsboomclassificator) en die trainen op een trainingsdataset.

We kunnen de modelprestaties verbeteren door n_estimators te verhogen, maar 50 is voldoende voor basisresultaten.

from sklearn.ensemble import BaggingClassifier

# Create a bagging classifier with the decision tree pipeline
bagging_classifier = BaggingClassifier(base_estimator=pipeline, n_estimators=50, random_state=42)

# Train the bagging classifier on the training data
bagging_classifier.fit(X_train, y_train)Mogelijk gemaakt door

Het ensemblemodel evalueren

Laten we de resultaten van het ensemblemodel evalueren en vergelijken met de prestaties van het enkele model. Daarvoor genereren we classificatierapporten op een testdataset.

# Make prediction on the testing data
y_pred = bagging_classifier.predict(X_test)

# Classification Report
print(classification_report(y_pred, y_test))Mogelijk gemaakt door

Zoals je ziet, hebben we de modelprestaties relatief verbeterd. De precisie en recall voor de minderheidsklasse zijn gestegen van respectievelijk 79% naar 80% en van 77% naar 82%. Dit is een aanzienlijke verbetering.

Laten we nu de cross-validatiescore berekenen.

# Evaluate the classifier using cross-validation
cv_scores = cross_val_score(bagging_classifier, X, y, cv=5)

print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {np.mean(cv_scores):.2f}")Mogelijk gemaakt door

Onze cross-validatiescores hebben een lage variantie, variërend van 94% tot 96%. De algehele nauwkeurigheid van het model is ook gestegen van 94% naar 95%.

Cross-validation scores: [0.95396825 0.95714286 0.94126984 0.96190476 0.95714286]
Mean CV accuracy: 0.95Mogelijk gemaakt door

De baggingtechniek is een handig hulpmiddel in machinelearningtoepassingen om de nauwkeurigheid en stabiliteit van modellen te verbeteren.

Leer ensemblemethoden zoals bagging, boosting en stacking om geavanceerde en effectieve machinelearningmodellen in Python te bouwen met de cursus Ensemble Methods in Python.

Best practices en tips

Door best practices en tips te volgen, haal je meer uit bagging in machine learning:

1. Gebruik bagging wanneer je hoge-variantie-modellen hebt zoals beslissingsbomen om de stabiliteit te verbeteren.
2. Combineer bagging met cross-validatie voor een betrouwbaardere evaluatie van je modellen.
3. Gebruik random forests (gebagde beslissingsbomen) als krachtige, kant-en-klare baggingtechniek.
4. Stel een hogere n_estimators-waarde in, zoals 100-200, om maximaal voordeel uit bagging te halen.
5. Bagging is eenvoudig te paralleliseren met n_jobs. Voer het uit over meerdere CPU’s/machines voor snellere training.
6. Omdat bagging op bootstrap-steekproeven steunt, zorg je ervoor dat elk model wordt getraind op een voldoende gevarieerde subset van de data.
7. Optimaliseer voor het aggregeren de prestaties van elk model met GridSearchCV. Goede prestaties van individuele modellen vertalen zich meestal in betere prestaties van het ensemble.

Lees MLOps (Machine Learning Operations) Best Practices om te leren welke MLOps-praktijken succesvol zijn voor betrouwbare en schaalbare uitrol van machinelearningsystemen.

Conclusie

In deze tutorial hebben we bagging verkend, een krachtige ensemblemethode in machine learning. Bagging aggregeert meerdere modellen om de algehele voorspellende prestaties te verbeteren. We hebben het vergeleken met boosting en geleerd wat de voordelen zijn ten opzichte van een enkel model.

Tot slot hebben we een bagging-classificator in Python geïmplementeerd op een telecom-churn-dataset. Het gebagde ensemble van beslissingsbomen verbeterde de nauwkeurigheid en de prestaties op de minderheidsklasse ten opzichte van een enkele beslissingsboom. Bovendien hebben we waardevolle tips en tricks geleerd om de effectiviteit van bagging in machine learning te maximaliseren.

Als je een carrière als professioneel machinelearning engineer wilt nastreven, begin dan met inschrijven voor de carrièreroute Machine Learning Scientist with Python. Je leert hoe je supervised, unsupervised en deep learning-modellen traint met de programmeertaal Python.