Bayesiaanse optimalisatie onder de knie krijgen in data science

In het brede veld van machine learning is het een veelvoorkomende uitdaging om tijdens het trainen van modellen je weg te vinden in grote en complexe datasets om optimale hyperparameters te vinden.

Traditionele methoden, vaak gebaseerd op random en grid search, kunnen tijdrovend en inefficiënt zijn, vooral bij complexe modelarchitecturen of grootschalige data.

Daarom wordt de behoefte aan een slimmere en adaptieve aanpak zoals Bayesiaanse optimalisatie steeds crucialer voor hyperparameteroptimalisatie.

Het eerste doel van dit artikel is uit te leggen wat Bayesiaanse optimalisatie is, zodat je een stevige theoretische basis krijgt. Voordat we op het concept Bayesiaanse optimalisatie ingaan, is het echter belangrijk om de verschillende methoden voor hyperparameteroptimalisatie te begrijpen die we tot onze beschikking hebben.

Het tweede deel van het artikel behandelt een meer praktische implementatie van de kernconcepten met de programmeertaal Python. In het laatste deel leer je hoe je Bayesiaanse optimalisatie inzet voor het finetunen van de hyperparameters van een machinelearningmodel.

Wat is Bayesiaanse optimalisatie?

Voordat we de definitie van Bayesiaanse optimalisatie induiken, bekijken we de vier belangrijkste methoden voor hyperparameteroptimalisatie met eenvoudige voorbeelden:

• Handmatig zoeken
• Random search
• Grid search, en
• Bayesiaanse optimalisatie.

Handmatig zoeken

Dit is de meest basale methode, gebaseerd op ervaring, intuïtie of trial-and-error. Het is vaak tijdrovend en leunt sterk op de expertise van de beoefenaar.

Zo stelt een ervaren bakker de oventemperatuur en baktijd in op basis van eerdere ervaring en intuïtie.

Een typisch startpunt kan een temperatuur van 350°F en een baktijd van 30 minuten zijn, waarden die vaak succesvol zijn gebleken. Aanpassingen worden gedaan op basis van het resultaat van elke bakpoging.

Random search

Deze aanpak houdt in dat combinaties van temperatuur en tijd willekeurig worden gekozen binnen een opgegeven bereik. Bijvoorbeeld, temperaturen tussen 325°F en 375°F en tijden tussen 25 en 35 minuten.

De selectie kan beginnen bij 330°F voor 27 minuten, gevolgd door 370°F voor 31 minuten, en zo willekeurig doorgaan totdat de meest effectieve combinatie is gevonden.

Grid search

Deze methode onderzoekt systematisch meerdere combinaties van hyperparametervaarden.

Om bij hetzelfde bakvoorbeeld te blijven: de bakker maakt een gestructureerd raster met combinaties van temperatuur en tijd aan de muur.

Het raster kan elke 5°F tussen 325°F en 375°F bevatten en elke 2 minuten tussen 25 en 35 minuten. De cake wordt vervolgens gebakken met elke combinatie in dit raster (325°F gedurende 25 minuten, 325°F gedurende 27 minuten, ... , 375°F gedurende 35 minuten) om de beste combinatie te vinden.

Bayesiaans zoeken

Bayesiaanse optimalisatie kun je zien als een intelligentere aanpak om de beste baktijd en -temperatuur voor een cake te vinden, vergeleken met random search.

Bij random search probeert de bakker mogelijk lukraak allerlei combinaties van temperatuur en tijd, waarvan er veel resulteren in te gaar of niet gaar genoeg gebak.

Bij Bayesiaanse optimalisatie wordt de zoektocht van de bakker naar optimale bakcondities gestuurd en geïnformeerd door eerdere resultaten.

Als de bakker bijvoorbeeld merkt dat cakes die rond 350°F en 30 minuten worden gebakken vaker slagen, zal hij of zij zich bij volgende pogingen meer richten op combinaties van temperatuur en tijd die in de buurt van deze waarden liggen.

Deze methode vermindert het aantal benodigde pogingen omdat ze ‘leert’ welke combinaties waarschijnlijk een perfect gebakken cake opleveren op basis van eerdere resultaten.

Kortom, Bayesiaanse optimalisatie is gebaseerd op de stelling van Bayes voor het optimaliseren van doelfuncties die duur zijn om te evalueren. Het is vooral effectief wanneer sampelen kostbaar is en de doelfunctie onbekend is maar wel bemonsterd kan worden.

Bayesiaanse optimalisatie gebruikt doorgaans een probabilistisch model, zoals een Gaussian Process, om de doelfunctie te schatten en vervolgens een acquisitionfunctie om te bepalen waar de volgende meting moet plaatsvinden.

Uitdagingen van Bayesiaanse optimalisatie

Deze methode is met succes toegepast in meerdere domeinen. Het is echter belangrijk op te merken dat ze enkele uitdagingen kent; de belangrijkste staan hieronder:

Batch-/Parallelle evaluatie

Een uitdaging is het efficiënt uitvoeren van batch- of parallelle evaluaties. Bayesiaanse optimalisatie werkt traditioneel sequentieel en kiest telkens één punt om te evalueren. Dit uitbreiden naar batchinstellingen, waar meerdere punten tegelijk worden geëvalueerd, is niet triviaal en vereist een zorgvuldige balans om diversiteit en efficiëntie in de gekozen punten te waarborgen.


Niet-kortzichtige optimalisatie

Dit verwijst naar de uitdaging om langetermijn- en strategische beslissingen te nemen over welke punten geëvalueerd moeten worden. Niet-kortzichtige methoden houden rekening met de toekomstige impact van huidige evaluaties, wat computationeel intensief en complex te modelleren kan zijn.


De dimensionaliteit van de ruimte

Naarmate de dimensionaliteit van de zoekruimte toeneemt, kan Bayesiaanse optimalisatie minder effectief worden. Dit komt door de ‘vloek van dimensionaliteit’, waarbij het volume van de ruimte exponentieel toeneemt, waardoor het met een beperkt aantal evaluaties moeilijker wordt om optimum te vinden.


Gestructureerde zoekruimte

In veel realistische problemen is de zoekruimte geen eenvoudige, continue n-dimensionale ruimte, maar heeft deze een complexe structuur, zoals afhankelijkheden tussen variabelen of constraints. Het effectief omgaan met zulke gestructureerde ruimtes is een aanzienlijke uitdaging.


Multi-task/objectieve zoektochten, multi-fidelity zoektochten

Bayesiaanse optimalisatie uitbreiden om meerdere doelstellingen tegelijk te behandelen of om informatie te integreren uit evaluaties met verschillende nauwkeurigheid (fidelity) is complex. Deze scenario’s vereisen het afwegen van trade-offs tussen verschillende doelstellingen of verschillende detailniveaus in de evaluaties.


Warm-start zoeken

Dit houdt in dat je voorkennis of data gebruikt om het optimalisatieproces te versnellen. Deze informatie effectief opnemen in het Bayesiaanse raamwerk zonder de resultaten te vertekenen is lastig.


Groot aantal evaluaties

Hoewel Bayesiaanse optimalisatie is ontworpen voor situaties waarin evaluaties duur zijn, kan in sommige gevallen toch een groot aantal evaluaties nodig zijn. Dit grote aantal efficiënt beheren en navigeren kan uitdagend zijn, met name qua rekenbronnen en tijd.


Lastige doelfuncties

Omgaan met doelfuncties met veel lokale optima, discontinuïteiten of non-stationariteit (waar de functie in de tijd verandert) is moeilijk. Zulke functies kunnen het optimalisatieproces misleiden en het vinden van een globaal optimum bemoeilijken.


Indirecte observatie

In sommige scenario’s kan de doelfunctie niet direct worden waargenomen, maar alleen via indirecte metingen. Dit voegt complexiteit toe omdat het optimalisatie-algoritme de werkelijke doelfunctie moet afleiden uit deze indirecte observaties.


Acquisitionfuncties en besluitvorming

In Bayesiaanse optimalisatie worden acquisitionfuncties gebruikt om de zoektocht naar optimale waarden te sturen.

Acquisitionfuncties en surrogaatmodellen zijn onderling afhankelijk in Bayesiaanse optimalisatie.

Het surrogaatmodel geeft een probabilistische voorspelling van de doelfunctie, die de acquisitionfunctie vervolgens gebruikt om te bepalen welke punten het meest veelbelovend zijn voor de volgende evaluatie. Surrogaatmodellen zoals Gaussian Process Regression zijn vooral nuttig wanneer de doelfunctie complex is of duur om direct te evalueren.

Door het surrogaatmodel continu bij te werken met nieuwe datapunten kan de acquisitionfunctie bovendien gerichter worden ingezet op gebieden in de zoekruimte die de grootste kans bieden op goede resultaten.

Er zijn verschillende acquisitionfuncties die je kunt gebruiken in Bayesiaanse optimalisatie, waaronder:

• Thompson Sampling: deze functie selecteert punten op basis van een probabilistische schatting van de doelfunctie.
• Upper Confidence Bound (UCB): deze functie selecteert het punt met de hoogste kans om de beste geobserveerde waarde te verbeteren. Ze gebruikt het verschil tussen de potentiële uitkomst van de nieuwe oplossing en de huidige beste, en berekent de kans op verbetering.
• Probability of Improvement (PI): gebruikt om het punt te selecteren met de hoogste kans om de tot nu toe beste geobserveerde waarde te verbeteren.
• Expected Improvement (EI): gebruikt om het punt te selecteren met de hoogste verwachte verbetering ten opzichte van de huidige beste geobserveerde waarde.

Er is geen beste of slechtste functie. Elke acquisitionfunctie heeft sterke punten en wordt gekozen op basis van de specifieke vereisten van het optimalisatieprobleem.

Toepassingen van Bayesiaanse optimalisatie

Bayesiaanse optimalisatie is met succes toegepast in veel sectoren; in dit onderdeel lichten we dit toe aan de hand van vier use-cases:

• Natural Language Processing
• Machine learning en hyperparametertuning
• A/B-testen, en
• Reinforcement learning en robotica

Deze voorbeelden zijn bijzonder relevant en informatief voor data scientists.

Natural Language Processing

Bij het toepassen van machine learning op Natural Language Processing-problemen zijn er meerdere keuzes te maken over de representatie van inputteksten, en die keuzes kunnen het eindresultaat van het onderliggende model beïnvloeden.

Bayesiaanse optimalisatie wordt gebruikt om het kiezen van de beste manier om tekst te representeren in NLP-modellen te automatiseren. Zo wordt het ontwikkelproces eenvoudiger en efficiënter, terwijl de algehele prestatie van deze modellen behouden blijft of zelfs verbetert.

Wil je meer leren over embeddings? Onze cursus Introduction to Embeddings with OpenAI API biedt een complete gids voor het maken van embeddings met de OpenAI API.

Machine learning en hyperparametertuning

Bayesiaanse optimalisatie in automatische machine learning (AutoML) automatiseert de selectie van het beste model en de bijbehorende hyperparameters voor een gegeven probleem op een gegeven dataset.

Recente toepassingen van Bayesiaanse optimalisatie tonen de effectiviteit bij het tunen van complexe modellen zoals deep belief-netwerken, convolutionele neurale netwerken en Markov chain Monte Carlo-methoden.

Daarnaast is het nuttig gebleken bij het automatiseren van de selectie tussen modellen die worden aangeboden door populaire machinelearningbibliotheken zoals WEKA en scikit-learn.

A/B-testen

Bij A/B-testen wordt Bayesiaanse optimalisatie gebruikt om het testen van verschillende productconfiguraties, zoals advertenties, apps, games of websites, efficiënter te maken.

Door twee opties (A en B) aan een kleine subset gebruikers te tonen, verzamelen ontwikkelaars feedback om verschillende metrics te optimaliseren, zoals gebruikersbetrokkenheid of doorklikratio’s. De kernuitdaging is de beste productconfiguratie te identificeren binnen een beperkt budget aan gebruikersinteracties.

Bayesiaanse optimalisatie ondersteunt dit proces door feedback uit eerdere tests te gebruiken om weloverwogen beslissingen te nemen over welke gebruikerssubsets vervolgens bevraagd worden, met als doel de algehele prestatie van het product te optimaliseren en opportunity costs te minimaliseren.

Reinforcement learning en robotica

Bayesiaanse optimalisatie is effectief toegepast in zowel robotica als reinforcement learning.

In robotica is het gebruikt om de gang (gait) van een robot te optimaliseren voor specifieke doelen zoals snelheid of soepelheid, zoals aangetoond met de Sony AIBO ERS-7-robot. Het is ook ingezet bij navigatietaken, waarbij robots onzekerheid over hun locatie en kaartschattingen minimaliseren terwijl ze door omgevingen bewegen.

Bayesiaanse optimalisatie is toegepast in hiërarchisch reinforcement learning om parameters van neurale netwerkpolicies automatisch te tunen en waardefuncties te leren op verschillende niveaus van een hiërarchisch systeem.

Daarnaast is de techniek gebruikt om aandachtspolicies te ontwikkelen bij beeldtracking met deep networks, wat de veelzijdigheid toont in het aanpassen aan verschillende aspecten van leren en beslissingsvorming in complexe omgevingen.

Een stapsgewijze gids voor het implementeren van Bayesiaanse optimalisatie

De vorige secties boden een uitgebreid begrip van Bayesiaanse optimalisatie. In dit onderdeel laten we zien hoe je de hyperparameters van een XGBRegressor optimaliseert met de GPyOpt-bibliotheek.

PyMC3 is een andere krachtige bibliotheek voor Bayesiaanse optimalisatie, en onze cursus Bayesian Data Analysis in Python biedt een complete gids met realistische voorbeelden.

Voor wie Bayesiaanse optimalisatie wil toepassen in de programmeertaal R is onze cursus Fundamentals of Bayesian Data Analysis in R een goede match.

We passen twee methoden toe: grid search en Bayesiaanse optimalisatie. Het doel is vast te stellen welke de optimale hyperparameters oplevert en tot een beter model leidt. De complete broncode staat in deze DataLab-werkmap; je kunt een eigen kopie maken om de code in de browser te bewerken en uit te voeren zonder iets op je computer te installeren.

Vereisten

De volgende bibliotheken zijn nodig om beide technieken succesvol uit te voeren.

• numpy: een bibliotheek voor numerieke berekeningen in Python.
• scipy: een bibliotheek voor wetenschappelijke berekeningen in Python.
• sklearn: een machinelearningbibliotheek in Python.
• GPyOpt: een bibliotheek voor Bayesiaanse optimalisatie in Python.
• Xgboost voor het XGBoost-model

Deze bibliotheken kun je in Jupyter Notebook met pip installeren als volgt:

!pip -q install xgboost scikit-learn GPyOpt numpy

Na succesvolle uitvoering van de vorige code worden de imports gedaan met het import-statement:

import xgboost as xgb
from sklearn.datasets import fetch_california_housing as fch
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import RandomizedSearchCV
from GPyOpt.methods import BayesianOptimization
from sklearn.model_selection import cross_val_score
import numpy as np

Datasetvoorbereiding

De benchmarkanalyse is gebaseerd op de California housing-dataset.

• 70% van de data wordt gebruikt voor het trainen van het XGBoost-model
• De overige 30% wordt gebruikt voor testen

De verdeling tussen training en testen staat hieronder:

# Load dataset
california_housing = fch()

X = california_housing.data
y = california_housing.target

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                	test_size=0.3,
                                                	random_state=2024)

Na het inladen van de trainings- en testdata kunnen we hun afmetingen controleren met de .shape-functie.

print(f"Training Shape: {X_train.shape}")
print(f"Testing Shape: {X_test.shape}")

Hyperparametertuning met Random Search

Dit onderdeel legt uit hoe je hyperparametertuning met de gridsearch-aanpak opzet en uitvoert voor een XGBoost-regressie met de klasse RandomizedSearchCV uit de scikit-learn-module.

Stel het parameterrooster op

Er wordt een dictionary genaamd param_dist gemaakt met verschillende hyperparameters als sleutels en lijsten met mogelijke waarden als corresponderende waarden. Deze hyperparameters omvatten:

• max_depth: Maximale diepte van een tree. Waarden: 3, 10, 5, 15.
• min_child_weight: Minimale som van instance weight (hessian) die in een child nodig is. Waarden: 1, 5, 10.
• subsample: Subsampleratio van de trainingsinstanties. Waarden: 0.5, 0.7, 1.0.
• colsample_bytree: Subsampleratio van kolommen bij het construeren van elke tree. Waarden: 0.5, 0.7, 1.0.
• n_estimators: Aantal gradient boosted trees. Equivalent aan het aantal boostingrondes. Waarden: 100, 200, 300, 400.

param_dist = {
	'max_depth': [3, 10, 5, 15],
	'min_child_weight': [1, 5, 10],
	'subsample': [0.5, 0.7, 1.0],
	'colsample_bytree': [0.5, 0.7, 1.0],
	'n_estimators': [100, 200, 300, 400],
	'learning_rate': [0.01, 0.05, 0.1, 0.15, 0.2]
}

Initialiseer XGBoost Regressor

Er wordt een instantie van de klasse XGBRegressor uit de XGBoost-bibliotheek gemaakt:

xgb_reg = xgb.XGBRegressor()

Configureer de RandomizedSearchCV

RandomizedSearchCV wordt ingesteld met de volgende parameters:

• De estimator (xgb_reg) is de XGBoost-regressor.
• param_distributions=param_dist specificeert de dictionary met te sampelen parameters.
• n_iter=25 geeft aan dat 25 verschillende combinaties worden geprobeerd.
• scoring='neg_mean_squared_error' stelt de scoringsmetric in op de negatieve mean squared error.
• cv=3 stelt de cross-validatiestrategie in op 3 vouwen.
• verbose=1 schakelt uitgebreide uitvoer in.
• random_state=42 zorgt voor reproduceerbaarheid.

random_search = RandomizedSearchCV(
	xgb_reg, param_distributions=param_dist, n_iter=25,
	scoring='neg_mean_squared_error', cv=3, verbose=1, random_state=2024
)

Het model fitten en parameters opvragen

De fit-methode wordt gebruikt om de gerandomiseerde zoekopdracht uit te voeren op de aangeleverde trainingsdata (X_train en y_train):

random_search.fit(X_train, y_train)

Het attribuut best_params van het gefitte model bevat de informatie over de beste hyperparameters die tot betere modelprestatie hebben geleid.

Die parameters kun je als volgt opvragen:

print("Random Search Best Parameters:", random_search.best_params_)

Beste parameters voor random search

Van alle mogelijke parameters zijn de beste voor het XGBoost-model met random search hieronder gegeven:

'subsample': 0.5,
'n_estimators': 400,
'min_child_weight': 5,
'max_depth': 10,
'learning_rate': 0.05,
'colsample_bytree': 1.0
}

Evalueer het model

Met deze waarden kunnen we het model evalueren en de prestatie ophalen als volgt:

Eerst initialiseren we het model met de beste hyperparameters voordat we gaan trainen.

# Initialize and train the model
model_random_search = xgb.XGBRegressor(**params_random_search)
model_random_search.fit(X_train, y_train)

Daarna wordt het model geëvalueerd op de testdata

predictions_random_search = model_random_search.predict(X_test)
mse_random_search = mean_squared_error(y_test, predictions_random_search)
print("MSE for Random Search: ", mse_random_search)

De succesvolle uitvoering van de bovenstaande code genereert de volgende mean squared error-waarde:

MSE voor XGBoost met hyperparameters uit random search

Hyperparametertuning met Bayesiaanse optimalisatie

Net als bij random search volgen we een stapsgewijs proces om de beste hyperparameters te genereren met Bayesiaanse optimalisatie.

Stel de parametergrenzen in

De grenzen voor de hyperparameters worden gedefinieerd in een lijst baysian_opt_bounds. Elke hyperparameter wordt weergegeven als een dictionary met de sleutels: name, type en domain.

• max_depth, min_child_weight, n_estimators zijn discrete variabelen.
• subsample, colsample_bytree, learning_rate zijn continue variabelen.
• Het domein specificeert het bereik van waarden voor elke hyperparameter.

baysian_opt_bounds = [
	{'name': 'max_depth', 'type': 'discrete', 'domain': (3, 10, 5, 15)},
	{'name': 'min_child_weight', 'type': 'discrete', 'domain': (1, 5, 10)},
	{'name': 'subsample', 'type': 'continuous', 'domain': (0.5, 1.0)},
	{'name': 'colsample_bytree', 'type': 'continuous', 'domain': (0.5, 1.0)},
	{'name': 'n_estimators', 'type': 'discrete', 'domain': (100, 200, 300, 400)},
	{'name': 'learning_rate', 'type': 'continuous', 'domain': (0.01, 0.2)}
]

Definieer de doelfunctie

Er wordt een doelfunctie xgb_cv_score gedefinieerd om de cross-gevalideerde negatieve mean squared error van een XGBoost-model te berekenen.

• De functie neemt een set parameters en zet deze om naar het vereiste formaat.
• cross_val_score wordt gebruikt om het XGBoost-model te evalueren met de opgegeven parameters.
• Het negatieve gemiddelde van de scores uit cross-validatie wordt geretourneerd als de te minimaliseren doelwaarde.

def xgb_cv_score(parameters):
	parameters = parameters[0]
	score = -cross_val_score(
            	xgb.XGBRegressor(
                	max_depth=int(parameters[0]),
                	min_child_weight=int(parameters[1]),
                	subsample=parameters[2],
                	colsample_bytree=parameters[3],
                	n_estimators=int(parameters[4]),
                	learning_rate=parameters[5]),
            	X_train, y_train, scoring='neg_mean_squared_error', cv=3).mean()
	return score

Initialiseer en voer het Bayesiaanse model uit

Bayesiaanse optimalisatie wordt geïnstantieerd met de volgende parameters:

• f=xgb_cv_score: De te minimaliseren doelfunctie.
• domain=baysian_opt_bounds: De hyperparametergrenzen.
• model_type='GP': Specificeert het gebruik van Gaussian Processes.
• acquisition_type='EI': Gebruikt Expected Improvement als acquisitionfunctie.
• max_iter=25: Het aantal iteraties voor het optimalisatieproces.

Het optimalisatieproces wordt gestart met optimizer.run_optimization()

optimizer = BayesianOptimization(
	f=xgb_cv_score, domain=baysian_opt_bounds, model_type='GP',
	acquisition_type='EI', max_iter=25
)
optimizer.run_optimization()

Verkrijg de beste parameters

Na de optimalisatie worden de beste parameters geëxtraheerd en geformatteerd:

• Parameters worden opgehaald uit optimizer.x_opt.
• Discrete parameters (max_depth, min_child_weight, n_estimators) worden naar gehele getallen gecast.

De beste parameters worden afgedrukt:

print("Bayesian Optimization Best Parameters:", best_params_bayesian)

Beste parameters voor Bayesiaanse optimalisatie

Evalueer het model

De initialisatie- en fitprocedure is hetzelfde als eerder. Dit keer gebruiken we echter de parameters uit de Bayesiaanse optimalisatie:

params_bayesian_opt = {
	'max_depth': 10,
	'min_child_weight': 10,
	'subsample': 0.820222997732141,
	'colsample_bytree': 0.6710357796023916,
	'n_estimators': 300,
	'learning_rate': 0.04797554348030097
}

# Initialize and train the model
model_bayesian_opt = xgb.XGBRegressor(**params_bayesian_opt)
model_bayesian_opt.fit(X_train, y_train)

# Make predictions and evaluate
predictions_bayesian_opt = model_bayesian_opt.predict(X_test)
mse_bayesian_opt = mean_squared_error(y_test, predictions_bayesian_opt)
print("MSE for Bayesian Optimization: ", mse_bayesian_opt)

De modelprestatie wordt weergegeven na succesvolle uitvoering van bovenstaande code, en het resultaat staat hieronder:

MSE voor XGBoost met hyperparameters uit Bayesiaanse optimalisatie

Interpretatie van de resultaten

Uit de twee experimenten merken we het volgende op:

• Lagere MSE bij Bayesiaanse optimalisatie: Het model dat is getraind met hyperparameters uit Bayesiaanse optimalisatie heeft een lagere MSE (0.204) vergeleken met dat uit random search (0.219). Deze lagere waarde suggereert dat het model gemiddeld dichter bij de werkelijke datapunten ligt.
• Modelprestatie: De lagere MSE geeft aan dat de Bayesiaanse optimalisatiemethode effectiever was in het tunen van de hyperparameters voor het XGBoost-model. Dit resultaat suggereert dat het door Bayesiaanse optimalisatie getunede model beter generaliseert van de trainingsdata naar onzichtbare data (in dit geval de testset).
• Efficiëntie van Bayesiaanse optimalisatie: Bayesiaanse optimalisatie leidt doorgaans tot betere prestaties bij hyperparametertuning omdat het een probabilistisch model gebruikt om de zoektocht naar de beste parameters te sturen. Het leert van eerdere evaluaties en richt de zoektocht op de meest veelbelovende hyperparameters, wat vaak tot betere waarden leidt dan random search.

In dit specifieke geval leverde de Bayesiaanse optimalisatiemethode betere resultaten op, zoals blijkt uit de lagere MSE. Dit suggereert dat voor deze dataset en dit model (XGBoost) Bayesiaanse optimalisatie effectiever was in het identificeren van de set hyperparameters die de voorspellingsfout op de testset minimaliseerde.

Het is belangrijk op te merken dat, hoewel Bayesiaanse optimalisatie hier beter presteerde, de keuze tussen random search en Bayesiaanse optimalisatie kan afhangen van verschillende factoren, zoals de complexiteit van het model, de aard van de data en de beschikbare rekenbronnen.

In scenario’s waar precisie in hyperparametertuning cruciaal is en rekenbronnen dit toelaten, blijkt Bayesiaanse optimalisatie echter vaak de betere keuze.

Conclusie

Dit artikel bood een grondige verkenning van Bayesiaanse optimalisatie, een sleuteltechniek voor het optimaliseren van complexe functies.

We begonnen met de definitie van Bayesiaanse optimalisatie en bespraken vervolgens de uitdagingen bij functie-optimalisatie, wat leidde tot de relevantie van Bayesiaanse optimalisatie.

Aan de hand van een praktische gids doken we in de implementatie-aspecten, met een focus op Gaussian Process Regression en acquisitionfuncties. Een belangrijk deel van de bespreking draaide om het toepassen van Bayesiaanse optimalisatie voor hyperparametertuning in machinelearningmodellen, waarmee de praktische bruikbaarheid werd getoond.

Al met al dient dit artikel zowel als inleidend overzicht als praktische handleiding en benadrukt het de cruciale rol van Bayesiaanse optimalisatie in machine learning en computationele optimalisatie.

Het biedt waardevolle inzichten voor praktijkmensen, onderzoekers en enthousiastelingen in deze velden, en benadrukt de toepasbaarheid en impact van de methode bij moderne computationele vraagstukken.

Voor wie dieper wil duiken in Bayesiaanse optimalisatie en de implementatie in Python, biedt onze cursus Hyperparameter Tuning in Python praktische ervaring met gangbare methodologieën voor geautomatiseerde hyperparametertuning met de Scikit Learn-bibliotheek. Enkele geavanceerde methodologieën omvatten Bayesiaanse en genetische algoritmen.