Tutorial ensemblemodellering: ontdek technieken voor ensemble learning

Machinelearningmodellen zijn niet zoals traditionele softwareoplossingen. Deze modellen hebben voortdurende updates nodig zodra er nieuwe data beschikbaar komt, om nauwkeurige en betrouwbare voorspellingen te kunnen doen. In complexe en gevoelige situaties is het vertrouwen op één enkel model mogelijk niet voldoende voor een optimaal resultaat, en hier kan ensemblemodellering helpen.

Deze conceptuele tutorial behandelt wat ensemblemodellering in machine learning is en hoe het je algehele modelprestaties kan verbeteren. Daarna geven we een overzicht van verschillende ensemblemethoden voordat we een praktijkscenario illustreren met een stapsgewijze implementatie in Python.

Onze tutorial Ensemble Learning in R met SuperLearner legt uit hoe je je machinelearningresultaten kunt verbeteren op basis van ensemble learning met het SuperLearner-pakket in R.

Ensemblemodellen in machine learning

Stel je een muziekmanager voor die meedoet aan een internationale competitie. Die heeft toegang tot een breed scala aan muzikanten met verschillende expertises:

• Klassieke musici met de vaardigheid om traditionele stukken te componeren.
• Elektronische musici die experts zijn in het gebruik van elektronische instrumenten.
• Jazzmusici met een sterk gevoel voor improvisatie.
• Solisten die complexe solo’s kunnen uitvoeren en hun technische vaardigheden kunnen laten zien.

Gezien het brede spectrum aan muzikale expertise en achtergronden kan de manager ze allemaal combineren om een unieke en gedenkwaardige uitvoering te creëren.

Denk aan ensemblemodellen als een orkest van musici, waarbij ieder is gespecialiseerd in een specifiek instrument zoals piano, trompet, drum en meer. De combinatie van die vaardigheden creëert een harmonieuze melodie.

Ensemble learning gebruikt dezelfde logica:

Het combineert meerdere algoritmen om een betere voorspellende prestatie te behalen dan met één enkel model. Er is geen vooraf gedefinieerd aantal modellen, en sommige zakelijke doelen vereisen meer modellen dan andere.

Modelerror en het verminderen daarvan met ensembles

De fout die uit elk machinelearningmodel voortkomt, kan wiskundig worden opgesplitst in drie componenten:

Bias + Variantie + Onherleidbare fout

Waarom is dit belangrijk in deze context? Om te begrijpen wat er achter een ensemblemodel gebeurt, moet je eerst weten wat een fout in het model veroorzaakt.

Laten we naar deze fouten kijken:

Biasfout

Dit is handig om te kwantificeren hoeveel de voorspelde waarden gemiddeld afwijken van de werkelijke waarde. Een hoge biasfout betekent dat we een onderpresterend model hebben dat essentiële trends blijft missen.

Variantie

Aan de andere kant kwantificeert variantie hoe de voorspellingen op dezelfde observatie van elkaar verschillen. Een model met hoge variantie zal overfitten op je trainingspopulatie en slecht presteren op elke observatie buiten de training. Het volgende diagram geeft meer duidelijkheid (ga ervan uit dat de rode stip de werkelijke waarde is en de blauwe punten de voorspellingen):

Meestal zie je, naarmate je de complexiteit van je model verhoogt, een afname van de fout door een lagere bias in het model. Dit gebeurt echter maar tot een bepaald punt. Als je je model steeds complexer maakt, ga je overfitten en gaat je model dus lijden onder een hoge variantie.

Nu je bekend bent met de basis van ensemble learning, gaan we kijken naar verschillende technieken voor ensemble learning:

Types ensemblemethoden

Er zijn verschillende soorten ensemblemethoden, en elk brengt een set voor- en nadelen met zich mee. In dit gedeelte komen die aspecten aan bod om je te helpen de juiste keuze te maken voor jouw use-cases.

Voordat we in elke methode duiken, is het goed om te begrijpen wat meta- en basismodellen zijn voor een beter begrip van de volgende concepten.

• Basismodellen vormen het eerste niveau van een architectuur voor ensemble learning, en elk van hen wordt getraind om individuele voorspellingen te doen.
• Metamodellen staan daarentegen op het tweede niveau en worden getraind op de output van de basismodellen.

Bagging

Bagging staat ook bekend als bootstrap-aggregatie. Deze techniek lijkt op random forest, maar gebruikt alle predictoren, terwijl random forest in elke boom slechts een subset van de predictoren gebruikt.

Bij bagging wordt een willekeurige steekproef van data uit de trainingsset geselecteerd met teruglegging, wat het dupliceren van steekproefinstanties in een set mogelijk maakt. Hieronder staan de belangrijkste stappen bij bagging:

• Genereren van meerdere bootstrap-resamples.
• Een algoritme op elke resample laten draaien om voorspellingen te doen.
• De voorspellingen combineren door het gemiddelde van de voorspellingen te nemen of de meerderheid te laten stemmen (bij classificatie).

Bagging heeft verschillende belangrijke voor- en nadelen bij gebruik voor classificatie- of regressietaken.

Voordelen

• Het modelleerproces is eenvoudig, vereist geen diepgaande wiskundige concepten en kan met ontbrekende waarden omgaan.
• Het scikit-learn-pakket maakt het eenvoudig om de onderliggende logica te implementeren. Het bevat alle modules om de voorspellingen van elk model te combineren, ook wel basismodellen genoemd.
• Het heeft een significant effect op het verminderen van variantie bij modellen met hoge variantie. Dit is nuttig bij het omgaan met hoog-dimensionale data, zodat het model niet generaliseert op nieuwe data.
• Bagging geeft een onbevooroordeelde schatting van de out-of-bag-fout, wat overeenkomt met de gemiddelde fout/verlies die al deze classifiers opleveren.

Nadelen

• Bagging is computationeel duur door het gebruik van meerdere modellen.
• Het middelen over voorspellingen maakt het moeilijk om het eindresultaat te interpreteren.

Boosting

Boosting hanteert een sequentiële aanpak, waarbij de voorspelling van het huidige model wordt doorgegeven aan het volgende. Elk model richt zich iteratief op de observaties die door zijn voorgangers verkeerd geclassificeerd zijn. We schetsen hieronder het algemene proces:

Voordelen

• Net als bagging is boosting makkelijk te begrijpen en te implementeren. Bovendien is er geen preprocessing nodig en kan het met ontbrekende waarden in de data omgaan.
• Het reduceert bias efficiënt.
• Boosting-algoritmen geven tijdens de training prioriteit aan features die de algehele nauwkeurigheid verhogen. Dit proces vermindert de dimensionaliteit van de data en daarmee de rekentijd.

Nadelen

• De sequentiële aanpak van boosting zorgt ervoor dat de volgende modellen de fouten van hun voorganger corrigeren. Hierdoor wordt het totale model kwetsbaar voor outliers.
• Boosting is om dezelfde reden niet goed schaalbaar als gevolg van het sequentiële karakter.

Stacking

Stacking lijkt sterk op boosting. De voorspellingen van de basismodellen worden op elkaar gestapeld en gebruikt als input om het metamodell te trainen voor robuustere voorspellingen. Het metamodell wordt vervolgens gebruikt om de uiteindelijke voorspellingen te doen. Bagging en boosting gebruiken doorgaans homogene basismodellen, terwijl stacking eerder heterogene basismodellen omvat.

Voordelen

• Maakt gebruik van de sterke punten van meerdere hoog presterende modellen voor zowel classificatie- als regressietaken.
• Net als andere ensemblemodellen helpt stacking om een nauwkeuriger model te bouwen dan individuele modellen op zichzelf.

Nadelen

• Het gebruik van complexe basismodellen kan het risico op overfitting vergroten.
• Verschillende niveaus van training van een model kunnen de stacking-architectuur complex maken om te implementeren.

Blending

Blending lijkt op stacking. Bij blending bestaat de datastructuur uit trainings-, hold-out- en testdata. De metamodellen worden getraind op de trainingsdata. Vervolgens worden hun voorspellingen gecombineerd met de hold-out-data om het uiteindelijke metamodell te bouwen, dat de testdata gebruikt om de definitieve voorspellingen te doen.

Voordelen

• Net als stacking en veel andere ensemblemethoden kan blending in veel gevallen de prestaties van het eindmodel verbeteren.
• Het gebruik van deze techniek heeft bij veel competities succes opgeleverd.

Nadelen

• Het opdelen van de oorspronkelijke data volgens de blending-architectuur kan het gebruik van data voor het trainen van basismodellen beperken, wat kan leiden tot mindere prestaties.
• Net als bij andere ensemblemodellen wordt de uitlegbaarheid van het eindmodel verminderd door de toegenomen complexiteit, waardoor het lastig wordt om cruciale zakelijke inzichten te halen.

Voting

Bij voting worden meerdere modellen onafhankelijk getraind en worden hun voorspellingen gecombineerd om tot een eindvoorspelling te komen met behulp van hard voting, soft voting of gewogen voting:

• Bij hard voting is de uiteindelijke voorspelling de meest voorkomende voorspelling van alle modellen.
• Bij soft voting genereert elk model een kansverdeling in plaats van een binaire voorspelling. Vervolgens wordt de klasse met de hoogste kans voorspeld.
• Tot slot is er bij gewogen voting de aanname dat sommige modellen vaardiger zijn dan andere, en die modellen krijgen een grotere bijdrage bij het maken van voorspellingen.

Voordelen

• De voting-architectuur is eenvoudiger te implementeren dan stacking en blending. Ook is uitgebreide fine-tuning niet nodig.
• Het gebruik van meerdere basismodellen bij voting maakt het minder gevoelig voor de invloed van individuele modellen, wat bijdraagt aan meer stabiele en betrouwbare voorspellingen.

Nadelen

• Het kan lastig zijn om met conflicterende modelvoorspellingen om te gaan, waardoor het moeilijk wordt om op een betekenisvolle manier een eindbeslissing te nemen.
• Meer modellen toevoegen aan het ensemble-votingmodel verbetert niet per se de uiteindelijke prestaties.

Cascading

Cascading gebruikt een stacking-aanpak maar met slechts één model per laag. Het eerste model wordt getraind op alle trainingsdata en het volgende model wordt getraind op de output van het model ervoor. Het doel van deze strategie is om complexe patronen uit de data te leren, zodat het model betere voorspellingen kan doen.

Voordelen

• Het volgende model is gespecialiseerd in de output van het vorige model, wat ruis in de data vermindert.
• Robuuster tegen overfitting en kan goed presteren op real-world data.

Nadelen

• Het implementeren van cascading kan complex zijn omdat het trainen van elk van de modellen in de volgorde vereist is.
• Het vinden van de optimale cascading-architectuur kan veel experimenteren en fine-tuning vereisen.

Overzicht van ensemble-algoritmen

De vorige secties behandelden de verschillende soorten ensemblemodellen. Laten we nu kort enkele populaire modellen bekijken.

Random Forest

Random forest is een veelgebruikt model dat zowel classificatie- als regressieproblemen kan oplossen. Een random forest bestaat uit veel beslissingsbomen die zijn getraind met bagging. De uitkomst wordt bepaald door het gemiddelde te nemen van de voorspellingen van de individuele bomen.

De nodegrootte, het aantal bomen en het aantal gesamplede features zijn de drie belangrijkste hyperparameters die moeten worden ingesteld voordat je het random forest traint.

Hoe zit het met de willekeurigheid in een random forest?

Feature bagging, ook wel feature randomness genoemd, creëert een willekeurige steekproef van features om een lage correlatie tussen beslissingsbomen te garanderen. Deze aanpak onderscheidt random forests van beslissingsbomen, die alle mogelijke feature-splitsingen overwegen, terwijl random forests slechts een subset van die features in beschouwing nemen. Lees meer in onze tutorial over random-forestclassificatie.

XGBoost

Extreme Gradient Boosting, of kortweg XGBoost, wordt gebruikt voor zowel classificatie als regressie. XGBoost is ontworpen om schaalbaar en zeer efficiënt te zijn en implementeert het framework van gradient boosting decision trees.

Het is geschikt voor het verwerken van grootschalige datasets en is compatibel met grote gedistribueerde omgevingen zoals Hadoop, MPI (Message Passing Inference) en SGI (Sun Grid Engine). Je kunt meer leren in onze XGBoost-tutorial.

AdaBoost

Adaptive Boosting, of AdaBoost, is een van de eerste succesvolle boosting-classifiers voor binaire classificatie. Het is adaptief omdat de gewichten opnieuw worden toegewezen aan elke instantie en verkeerd geclassificeerde instanties hogere gewichten krijgen. Lees meer over AdaBoost-classificatie in Python in onze aparte tutorial.

Een stapsgewijze implementatie van ensemblemodellen

Nu je het hoofdidée van ensemblemodellering en de werking van sommige modellen begrijpt, richten we ons in dit gedeelte op de technische implementatie met Python.

De omgeving instellen

Om te beginnen moet je Python op je computer geïnstalleerd hebben, samen met de volgende bibliotheken:

• pandas voor het laden van de dataframe.
• Scikit-learn om de bestaande machinelearningalgoritmen te gebruiken.
• Seaborn en matplotlib voor visualisatiedoeleinden.

Je kunt deze bibliotheken installeren met pip, de Python-pakketbeheerder, als volgt:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Om de use-case beter te illustreren gebruiken we de Leendata die beschikbaar is op DataLab. De code voor deze tutorial is ook beschikbaar op DataLab in deze workbook; je kunt je eigen kopie maken en de code in je browser bewerken en uitvoeren zonder iets op je computer te hoeven installeren.

De data begrijpen

De dataset bevat 9.500 leningen met informatie over de leenstructuur, de lener en of de lening volledig is terugbetaald, weergegeven door de kolom not.fully.paid. De eerste vijf observaties zie je hieronder:

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

Met de functie info() krijg je de volgende relevante informatie over de data:

• 9.578 rijen (van 0 tot 9577) en 14 kolommen van numerieke types, behalve purpose, dat object is en de tekstuele beschrijving van het doel van de lening geeft.
• De tag non-null voor elke kolom betekent dat er in die specifieke kolom geen ontbrekende informatie is, in geen van de kolommen.

loan_data.info()

We zien een ongebalanceerd datascenario, waarbij er veel meer observaties zijn met klasse 0 (8045 observaties) dan met klasse 1 (slechts 1533 observaties).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Het trainen van modellen met zulke ongebalanceerde data beïnvloedt de algehele prestaties.

Eén manier om dit aan te pakken is undersampling, wat betekent dat we het aantal observaties van de meerderheid (klasse 0) verminderen. In dit scenario zullen er evenveel observaties voor klasse 0 zijn als voor klasse 1, en het proces verloopt als volgt:

• Haal eerst het aantal van klasse 1 op.

• Selecteer N willekeurige observaties uit klasse 0, waarbij N de grootte is van de dataframe van klasse 1.

• Concateneer de twee eerdere dataframes.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

De tutorial Diving Deep with Imbalanced Data biedt meer bronnen om technieken te leren om met een ongebalanceerde dataset om te gaan.

Na de undersampling krijgen we:

• In totaal 3066 observaties en 14 kolommen.

En de uiteindelijke gebalanceerde verdeling zie je hieronder.

De data voorbereiden voor training

Als we naar de dataset kijken, merken we dat niet alle features dezelfde schaal hebben, en sommige machinelearningmodellen zoals KNN zijn gevoelig voor zulke schaling. Dit probleem kan worden aangepakt door de bereiken van de features naar dezelfde schaal te normaliseren met de module MinMaxScaler. In dit geval tussen 0 en 1.

Ook verwijderen we de kolom purpose uit eenvoud, omdat die extra preprocessing vereist.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Remove unwanted 'purpose' column and get the data
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Zoals bij elke voorspellende taak, moeten we de data splitsen in trainings- en testsets. In dit geval gebruiken we 77% voor training en de resterende 33% voor testen.

• De random_state-attribuut wordt geïnitialiseerd met een willekeurige waarde (in ons geval 2023) om de reproduceerbaarheid van de resultaten te waarborgen.

Stratify wordt gebruikt om ervoor te zorgen dat de doelwaarde y gelijkmatig verdeeld is in zowel de trainings- als de testdata.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Alle modellen volgen de volgorde: trainen op de trainingsdata, voorspellen op de testdata en de prestaties van de modellen evalueren.

Baggingmodel

Random forest is het baggingmodel dat in dit gedeelte wordt gebruikt. We gebruiken de standaardparameters voor de eenvoud.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Define the model
random_forest_model = RandomForestClassifier()
# Fit the random search object to the data
random_forest_model.fit(X_train, y_train)

Na het trainen van het model worden de prestaties bepaald met de functie accuracy_score als volgt:

# Make predictions
y_pred = random_forest_model.predict(X_test)

# Get the performance
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

De vorige print-instructie geeft 0,6156, oftewel 61,56%.

Laten we deze score nu vergelijken met de prestaties van een blending-aggregatieaanpak.

Blendingmodel

Voor blending gebruiken we twee basismodellen: een beslissingsboom en een K-Nearest Neighbors-classifier. Een uiteindelijke regressiemodel wordt gebruikt om de definitieve voorspellingen te doen.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

De oorspronkelijke trainingsdata wordt gesplitst in een nieuwe trainingsset en een validatieset. De basismodellen worden getraind op de trainingsdata.

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)

Vervolgens worden twee dataframes gegenereerd op basis van de voorspellingen van die basismodellen:

• Eerste dataframe met de voorspellingen op de validatiedata, samengevoegd met de oorspronkelijke validatiedata.
• Tweede dataframe met de voorspellingen op de testdata, samengevoegd met de oorspronkelijke testdata.

# Decision Tree Model
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# KNN Model
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

Het uiteindelijke logistieke regressiemodel wordt gebouwd met de samengevoegde validatiedata en geëvalueerd met de samengevoegde testdata.

x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Logistic Regression Model
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)

Met de functie .score() wordt standaard de accuracy-score berekend en zijn geen expliciete voorspellingen nodig.

Het prestatiecijfer is 0,6383, oftewel 63,83%, en is ongeveer 2% hoger dan de initiële random forest; het blendingmodel levert dus de beste prestaties op.

Onze cursussen Ensemble Methods in Python en Machine Learning with Tree-Based Models in R zijn een mooie volgende stap om je machinelearningreis voort te zetten door je te verdiepen in de wondere wereld van ensembleclassifiers, respectievelijk in Python en R.

Conclusie

Dit artikel heeft verschillende soorten ensemblemodellering behandeld, samen met hun kenmerken, voordelen en nadelen. Ook gaf het een kort overzicht van enkele voorbeelden van op ensemblemodellen gebaseerde algoritmen zoals random forest, Adaboost, XGBoost, Gradient Boosting Trees en Gradient Boosting Machines.

Bij het bouwen van ensemblemodellen is het belangrijk om je bewust te zijn van hun voor- en nadelen voor betere zakelijke inzichten.

Veelgestelde vragen

Wat is het verschil tussen homogene en heterogene learners?

Homogene learners zijn learners met een vergelijkbaar type algoritme en hyperparameters. Random forest kan worden beschouwd als een ensemble van homogene learners.

Heterogene learners daarentegen hebben verschillende algoritmen en hyperparameters. Random forest, neurale netwerken en KNN kunnen heterogene learners zijn binnen een ensemblemodel.

Wat zijn de voordelen van ensemblemodellen ten opzichte van enkelvoudige modellen?

Met ensemblemodellen kun je betere voorspellingen doen dan met een enkel model.

Wat is de beperking van ensemblemodellen?

Ensemblemodellen kunnen last hebben van een gebrek aan uitlegbaarheid, wat betekent dat de kennis die door de ensemblemodellen is geleerd niet begrijpelijk is voor eindgebruikers.

Wanneer moet je het gebruik van ensemblemodellen vermijden?

Het gebruik van ensemblemodellen moet worden vermeden in de volgende omstandigheden, maar niet beperkt tot: hoge uitlegbaarheid, beperkte data, realtime-constraint en hoge rekenkosten.

Wat zijn de verschillende soorten ensemblemethoden in machine learning?

Bagging, boosting, stacking, voting, blending en cascading zijn de belangrijkste types ensemblemethoden in machine learning.