Maîtriser l’optimisation bayésienne en data science

Dans le vaste champ de l’apprentissage automatique, le défi de parcourir des jeux de données volumineux et complexes pour trouver les hyperparamètres optimaux lors de l’entraînement des modèles est un obstacle courant.

Les méthodes classiques, souvent basées sur la recherche aléatoire et la recherche par grille, peuvent être longues et peu efficaces, en particulier avec des architectures de modèles complexes ou des données à grande échelle.

D’où le besoin d’une approche plus intelligente et adaptative comme l’optimisation bayésienne, devenue essentielle pour l’optimisation des hyperparamètres.

Le premier objectif de cet article est d’expliquer ce qu’est l’optimisation bayésienne, en offrant une base théorique solide. Cependant, avant d’entrer dans le concept d’optimisation bayésienne, il est important de comprendre les différentes méthodes d’optimisation des hyperparamètres à notre disposition.

La seconde partie de l’article couvre une mise en œuvre plus pratique des concepts clés en langage Python. Dans la dernière section, vous verrez comment exploiter l’optimisation bayésienne pour le réglage des hyperparamètres d’un modèle de machine learning.

Qu’est-ce que l’optimisation bayésienne ?

Avant de définir l’optimisation bayésienne, passons en revue les quatre principales méthodes d’optimisation des hyperparamètres au travers d’exemples simples :

• Recherche manuelle
• Recherche aléatoire
• Recherche par grille, et
• Optimisation bayésienne.

Recherche manuelle

C’est la méthode la plus basique, fondée sur l’expérience, l’intuition ou l’essai-erreur. Elle prend souvent du temps et repose fortement sur l’expertise de la personne qui la met en œuvre.

Par exemple, un boulanger expérimenté règle la température du four et le temps de cuisson grâce à son vécu et à son intuition.

Un point de départ typique pourrait être 350 °F et 30 minutes, des réglages souvent gagnants. Des ajustements sont ensuite réalisés en fonction du résultat de chaque fournée.

Recherche aléatoire

Cette approche consiste à sélectionner aléatoirement des combinaisons de température et de temps dans un intervalle donné. Par exemple, des températures entre 325 °F et 375 °F, et des durées entre 25 et 35 minutes.

On pourrait commencer à 330 °F pendant 27 minutes, puis 370 °F pendant 31 minutes, en poursuivant au hasard jusqu’à identifier la combinaison la plus efficace.

Recherche par grille

Cette méthode consiste à explorer systématiquement plusieurs combinaisons de valeurs d’hyperparamètres.

Pour reprendre l’exemple de la pâtisserie, le boulanger crée sur le mur une grille structurée de combinaisons temps/température.

La grille peut inclure un incrément de 5 °F entre 325 °F et 375 °F et un pas de 2 minutes entre 25 et 35 minutes. On cuit alors le gâteau pour chaque combinaison de la grille (325 °F pendant 25 minutes, 325 °F pendant 27 minutes, …, 375 °F pendant 35 minutes) afin de trouver la meilleure.

Recherche bayésienne

L’optimisation bayésienne peut être vue comme une approche plus intelligente pour trouver la meilleure température et le meilleur temps de cuisson d’un gâteau, comparée à la recherche aléatoire.

Avec la recherche aléatoire, le boulanger essaie une grande variété de combinaisons au hasard, dont beaucoup mènent à des gâteaux trop ou pas assez cuits.

Avec l’optimisation bayésienne, la recherche des conditions optimales est guidée par les résultats précédents.

Par exemple, si le boulanger observe que des cuissons autour de 350 °F pendant 30 minutes réussissent mieux, il va concentrer ses essais sur des combinaisons proches de ces valeurs lors des fournées suivantes.

Cette méthode réduit le nombre d’essais nécessaires, car elle « apprend » quelles combinaisons ont le plus de chances de donner un gâteau parfaitement cuit à partir des résultats passés.

Globalement, l’optimisation bayésienne s’appuie sur le théorème de Bayes pour optimiser des fonctions objectif coûteuses à évaluer. Elle est particulièrement efficace lorsque l’échantillonnage est onéreux et que la fonction objectif est inconnue mais peut être échantillonnée.

Elle utilise typiquement un modèle probabiliste, comme un processus gaussien, pour estimer la fonction objectif, puis une fonction d’acquisition pour décider où échantillonner ensuite.

Défis de l’optimisation bayésienne

Cette méthode a fait ses preuves dans de nombreux domaines. Il convient toutefois de noter qu’elle présente plusieurs défis, dont les principaux sont listés ci-dessous :

Évaluation par lots / en parallèle

Un défi consiste à mener efficacement des évaluations par lots ou en parallèle. L’optimisation bayésienne fonctionne traditionnellement de manière séquentielle, en sélectionnant un point à la fois. L’étendre à des paramètres par lots, où plusieurs points sont évalués simultanément, n’est pas trivial et nécessite un équilibre subtil entre diversité et efficacité des points choisis.


Optimisation non myope

Il s’agit de la difficulté à prendre des décisions stratégiques de long terme sur les points à évaluer. Les méthodes non myopes considèrent l’impact futur des évaluations courantes, ce qui peut être coûteux en calcul et complexe à modéliser.


Dimensionnalité de l’espace

À mesure que la dimension de l’espace de recherche augmente, l’optimisation bayésienne peut perdre en efficacité. C’est l’effet de la « malédiction de la dimensionnalité », où le volume de l’espace croît de façon exponentielle, rendant plus difficile la recherche d’optima avec un nombre limité d’évaluations.


Espace de recherche structuré

Dans de nombreux problèmes réels, l’espace de recherche n’est pas un simple espace n-dimensionnel continu, mais possède une structure complexe, avec des dépendances entre variables ou des contraintes. Gérer efficacement ces espaces structurés est un défi majeur.


Recherche multi-tâches/objectifs, multi-fidélité

Étendre l’optimisation bayésienne pour traiter plusieurs objectifs simultanément ou intégrer des informations issues d’évaluations de fidélité (précision) variable est complexe. Ces scénarios exigent d’arbitrer entre différents objectifs ou niveaux de détail dans les évaluations.


Démarrage à chaud (warm-start)

Cela consiste à exploiter des connaissances ou des données préalables pour accélérer l’optimisation. Intégrer ces informations dans le cadre bayésien sans biaiser les résultats est délicat.


Grand nombre d’évaluations

Bien que l’optimisation bayésienne vise les cas où les évaluations sont coûteuses, il arrive qu’un grand nombre d’évaluations soit tout de même nécessaire. Gérer et parcourir efficacement ce volume peut être difficile, tant en ressources de calcul qu’en temps.


Fonctions objectif difficiles

Traiter des fonctions objectif avec de nombreux optima locaux, des discontinuités, ou non stationnaires (la fonction évolue dans le temps) est ardu. Ces fonctions peuvent induire l’optimisation en erreur et compliquer la recherche d’un optimum global.


Observation indirecte

Dans certains cas, la fonction objectif ne peut pas être observée directement, seulement via des mesures indirectes. Cela ajoute de la complexité, car l’algorithme doit inférer la véritable fonction objectif à partir de ces observations.


Fonctions d’acquisition et prise de décision

En optimisation bayésienne, les fonctions d’acquisition guident la recherche des valeurs optimales.

Les fonctions d’acquisition et les modèles de substitution sont interdépendants en optimisation bayésienne.

Le modèle de substitution fournit une prédiction probabiliste de la fonction objectif, qu’exploite ensuite la fonction d’acquisition pour déterminer les points les plus prometteurs à évaluer. Les modèles de substitution, comme la régression par processus gaussien, sont particulièrement utiles quand la fonction objectif est complexe ou coûteuse à évaluer directement.

De plus, en mettant à jour en continu le modèle de substitution avec de nouvelles observations, la fonction d’acquisition se dirige plus précisément vers les zones de l’espace de recherche les plus susceptibles de donner les meilleurs résultats.

Plusieurs fonctions d’acquisition peuvent être utilisées en optimisation bayésienne, notamment :

• Échantillonnage de Thompson : sélectionne des points sur la base d’une estimation probabiliste de la fonction objectif.
• Upper Confidence Bound (UCB) : permet de sélectionner le point ayant la plus forte probabilité d’améliorer la meilleure valeur observée. Elle s’appuie sur l’écart entre le résultat potentiel d’une nouvelle solution et l’actuelle meilleure, en calculant la probabilité d’amélioration.
• Probability of Improvement (PI) : sélectionne le point qui a la probabilité la plus élevée d’améliorer la meilleure valeur observée à ce jour.
• Expected Improvement (EI) : sélectionne le point avec l’amélioration attendue la plus élevée par rapport à la meilleure valeur observée.

Il n’existe pas de « meilleure » ou « pire » fonction universelle. Chacune a ses atouts et se choisit selon les besoins spécifiques du problème d’optimisation.

Applications de l’optimisation bayésienne

L’optimisation bayésienne a été appliquée avec succès dans de nombreux secteurs. Cette section l’illustre sur quatre cas d’usage :

• Traitement du langage naturel
• Machine learning et réglage des hyperparamètres
• Tests A/B, et
• Apprentissage par renforcement et robotique

Ces exemples sont particulièrement pertinents et instructifs pour les data scientists.

Traitement du langage naturel

Lorsqu’on applique le machine learning au traitement du langage naturel, de nombreux choix de représentation des textes d’entrée s’offrent à nous, et ces choix influencent le résultat final du modèle.

L’optimisation bayésienne automatise la sélection de la meilleure façon de représenter le texte dans les modèles NLP, simplifiant ainsi le développement tout en améliorant, ou à minima en préservant, les performances globales.

Pour en savoir plus sur les embeddings, notre cours Introduction to Embeddings with OpenAI API propose un guide complet pour créer des embeddings avec l’API OpenAI.

Machine learning et réglage des hyperparamètres

En AutoML (apprentissage automatique automatisé), l’optimisation bayésienne automatise la sélection du meilleur modèle et de ses hyperparamètres pour un problème donné sur un jeu de données donné.

Des applications récentes ont montré son efficacité pour régler des modèles complexes tels que les deep belief networks, réseaux de neurones convolutifs, et les méthodes de Monte Carlo par chaînes de Markov.

Elle a également facilité l’automatisation du choix entre les modèles proposés par des bibliothèques populaires comme WEKA et scikit-learn.

Tests A/B

En tests A/B, l’optimisation bayésienne permet d’accroître l’efficacité des expérimentations sur différentes configurations produit (publicités, applications, jeux, sites web).

En présentant deux options (A et B) à un sous-ensemble restreint d’utilisateurs, les équipes collectent des retours pour optimiser des indicateurs comme l’engagement ou le taux de clics. L’enjeu clé est d’identifier la meilleure configuration produit avec un budget limité de sollicitations utilisateur.

L’optimisation bayésienne facilite ce processus en exploitant les retours des premiers tests pour décider intelligemment des prochains sous-groupes à interroger, afin d’optimiser la performance globale du produit tout en minimisant les coûts d’opportunité.

Apprentissage par renforcement et robotique

L’optimisation bayésienne a été appliquée avec succès en robotique et en apprentissage par renforcement.

En robotique, elle a servi à optimiser l’allure (gait) d’un robot selon des objectifs comme la vitesse ou la fluidité, comme l’illustre le robot Sony AIBO ERS-7. Elle a aussi été utilisée dans des tâches de navigation, aidant les robots à réduire l’incertitude sur leur localisation et leur carte de l’environnement pendant leurs déplacements.

En apprentissage par renforcement hiérarchique, elle a permis d’ajuster automatiquement les paramètres de politiques à réseaux de neurones et d’apprendre des fonctions de valeur à différents niveaux d’un système hiérarchique.

La méthode a également servi à développer des politiques d’attention pour le suivi d’images avec des réseaux profonds, illustrant sa polyvalence pour l’apprentissage et la prise de décision dans des environnements complexes.

Guide pas à pas pour mettre en œuvre l’optimisation bayésienne

Les sections précédentes ont offert une compréhension approfondie de l’optimisation bayésienne. Voyons maintenant comment optimiser les hyperparamètres d’un XGBRegressor avec la bibliothèque GPyOpt.

PyMC3 est une autre bibliothèque puissante utilisée en optimisation bayésienne. Notre cours Bayesian Data Analysis in Python propose un guide complet avec des exemples réels.

Si vous souhaitez appliquer l’optimisation bayésienne en R, notre cours Fundamentals of Bayesian Data Analysis in R est fait pour vous.

Deux méthodes sont appliquées : recherche par grille et optimisation bayésienne. L’objectif est d’identifier celle qui fournit les meilleurs hyperparamètres et donc le meilleur modèle. Le code source complet est disponible dans ce carnet DataLab ; vous pouvez en créer une copie pour modifier et exécuter le code dans votre navigateur, sans rien installer sur votre ordinateur.

Prérequis

Les bibliothèques suivantes sont nécessaires pour exécuter correctement les deux techniques.

• numpy : bibliothèque de calcul numérique en Python.
• scipy : bibliothèque de calcul scientifique en Python.
• sklearn : bibliothèque de machine learning en Python.
• GPyOpt : bibliothèque d’optimisation bayésienne en Python.
• Xgboost pour le modèle XGBoost

Ces bibliothèques peuvent être installées avec la commande pip depuis un notebook Jupyter :

!pip -q install xgboost scikit-learn GPyOpt numpy

Après exécution réussie du code précédent, on effectue les imports avec l’instruction import :

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

Préparation du jeu de données

L’analyse comparative s’appuie sur le jeu de données California housing.

• 70 % des données sont utilisées pour entraîner le modèle XGBoost
• Les 30 % restants servent au test

La répartition entraînement/test est la suivante :

# 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)

Après le chargement des données d’entraînement et de test, on peut vérifier leurs dimensions avec la fonction .shape.

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

Réglage des hyperparamètres avec recherche aléatoire

Cette section explique comment configurer et exécuter le réglage d’hyperparamètres avec l’approche GridSearch pour une régression XGBoost à l’aide de la classe RandomizedSearchCV du module scikit-learn.

Définir la grille de paramètres

On crée un dictionnaire nommé param_dist dont les clés sont les hyperparamètres et les valeurs des listes de valeurs possibles. Ces hyperparamètres incluent :

• max_depth : profondeur maximale d’un arbre. Valeurs : 3, 10, 5, 15.
• min_child_weight : somme minimale des poids d’instances (hessien) requise dans un nœud enfant. Valeurs : 1, 5, 10.
• subsample : ratio d’échantillonnage des instances d’entraînement. Valeurs : 0,5, 0,7, 1,0.
• colsample_bytree : ratio d’échantillonnage des colonnes lors de la construction de chaque arbre. Valeurs : 0,5, 0,7, 1,0.
• n_estimators : nombre d’arbres de gradient boosting (nombre d’itérations de boosting). Valeurs : 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]
}

Initialiser le régressseur XGBoost

On crée une instance de la classe XGBRegressor de la bibliothèque XGBoost :

xgb_reg = xgb.XGBRegressor()

Configurer RandomizedSearchCV

RandomizedSearchCV est paramétré comme suit :

• l’estimateur (xgb_reg) est le régressseur XGBoost ;
• param_distributions=param_dist indique le dictionnaire des paramètres à échantillonner ;
• n_iter=25 signifie que 25 combinaisons différentes seront testées ;
• scoring='neg_mean_squared_error' définit la métrique comme l’erreur quadratique moyenne négative ;
• cv=3 fixe la validation croisée à 3 plis ;
• verbose=1 active les journaux détaillés ;
• random_state=42 garantit la reproductibilité.

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

Entraîner le modèle et accéder aux paramètres

La méthode fit est utilisée pour lancer la recherche aléatoire sur les données d’entraînement (X_train et y_train) :

random_search.fit(X_train, y_train)

L’attribut best_params du modèle entraîné contient les meilleurs hyperparamètres ayant conduit aux meilleures performances.

On peut les récupérer ainsi :

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

Meilleurs paramètres trouvés par recherche aléatoire

Parmi tous les paramètres possibles, les meilleurs pour le modèle XGBoost via la recherche aléatoire sont les suivants :

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

Évaluer le modèle

À l’aide de ces valeurs, nous pouvons évaluer le modèle et récupérer ses performances comme suit :

Nous initialisons d’abord le modèle avec les meilleurs hyperparamètres avant l’entraînement.

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

Ensuite, le modèle est évalué sur les données de test.

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)

L’exécution réussie du code ci-dessus génère la valeur d’erreur quadratique moyenne suivante :

MSE pour XGBoost avec des hyperparamètres issus de la recherche aléatoire

Réglage des hyperparamètres avec l’optimisation bayésienne

De manière similaire à la recherche aléatoire, nous suivons un processus pas à pas pour générer les meilleurs hyperparamètres via l’optimisation bayésienne.

Définir les bornes des paramètres

Les bornes des hyperparamètres sont définies dans une liste baysian_opt_bounds. Chaque hyperparamètre est représenté par un dictionnaire avec les clés : name, type et domain.

• max_depth, min_child_weight, n_estimators sont des variables discrètes.
• subsample, colsample_bytree, learning_rate sont des variables continues.
• Le domain spécifie l’intervalle de valeurs pour chaque hyperparamètre.

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)}
]

Définir la fonction objectif

Une fonction objectif xgb_cv_score est définie pour calculer l’erreur quadratique moyenne négative en validation croisée d’un modèle XGBoost.

• La fonction prend un jeu de paramètres et les convertit au format requis.
• cross_val_score évalue le modèle XGBoost avec les paramètres spécifiés.
• La moyenne négative des scores de la validation croisée est renvoyée comme objectif à minimiser.

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

Initialiser et exécuter le modèle bayésien

L’optimisation bayésienne est instanciée avec les paramètres suivants :

• f=xgb_cv_score : la fonction objectif à minimiser.
• domain=baysian_opt_bounds : les bornes des hyperparamètres.
• model_type='GP' : utilisation des processus gaussiens.
• acquisition_type='EI' : utilisation de l’amélioration attendue comme fonction d’acquisition.
• max_iter=25 : nombre d’itérations du processus d’optimisation.

Le processus d’optimisation est lancé avec 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()

Accéder aux meilleurs paramètres

Après optimisation, on extrait et on met en forme les meilleurs paramètres :

• Les paramètres sont récupérés via optimizer.x_opt.
• Les paramètres discrets (max_depth, min_child_weight, n_estimators) sont convertis en entiers.

Les meilleurs paramètres sont affichés :

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

Meilleurs paramètres trouvés par optimisation bayésienne

Évaluer le modèle

L’initialisation et l’entraînement sont identiques à précédemment, mais cette fois avec les paramètres issus de l’optimisation bayésienne :

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)

La performance du modèle est fournie après l’exécution du code ci-dessus, comme indiqué ci-dessous :

MSE pour XGBoost avec des hyperparamètres issus de l’optimisation bayésienne

Interprétation des résultats

Des deux expérimentations, on observe que :

• MSE plus faible avec l’optimisation bayésienne : le modèle entraîné avec les hyperparamètres issus de l’optimisation bayésienne présente une MSE plus faible (0,204) que celui issu de la recherche aléatoire (0,219). Cette baisse indique que, en moyenne, les prédictions sont plus proches des vraies valeurs.
• Performance du modèle : la MSE plus faible montre que l’optimisation bayésienne a été plus efficace pour régler les hyperparamètres du modèle XGBoost. Le modèle ainsi réglé généralise mieux des données d’entraînement vers les données inédites (ici, le jeu de test).
• Efficacité de l’optimisation bayésienne : elle conduit généralement à de meilleures performances en réglage d’hyperparamètres, car elle s’appuie sur un modèle probabiliste pour guider la recherche. Elle apprend des évaluations précédentes et oriente la recherche vers les hyperparamètres les plus prometteurs, ce qui permet souvent de trouver de meilleures valeurs que la recherche aléatoire.

Dans ce cas précis, l’optimisation bayésienne a donné de meilleurs résultats, comme en témoigne la MSE plus faible. Cela suggère que, pour ce jeu de données et ce modèle (XGBoost), elle a été plus efficace pour identifier l’ensemble d’hyperparamètres minimisant l’erreur de prédiction sur le jeu de test.

Il est important de noter que, même si l’optimisation bayésienne a montré de meilleures performances ici, le choix entre recherche aléatoire et optimisation bayésienne dépend de divers facteurs : complexité du modèle, nature des données, ressources de calcul.

Cependant, lorsque la précision du réglage des hyperparamètres est cruciale et que les ressources le permettent, l’optimisation bayésienne s’impose souvent comme un meilleur choix.

Conclusion

Cet article a proposé une exploration approfondie de l’optimisation bayésienne, une technique clé pour optimiser des fonctions complexes.

Nous avons commencé par définir l’optimisation bayésienne, avant d’aborder les défis de l’optimisation de fonctions, soulignant ainsi sa pertinence.

À travers un guide pratique, nous avons détaillé sa mise en œuvre, en nous concentrant sur la régression par processus gaussiens et les fonctions d’acquisition. Une part importante a porté sur l’application de l’optimisation bayésienne au réglage des hyperparamètres de modèles de machine learning, démontrant son utilité concrète.

En somme, cet article fait office à la fois d’introduction et de guide pratique, en mettant en lumière le rôle central de l’optimisation bayésienne en apprentissage automatique et en optimisation numérique.

Il offre des enseignements utiles aux praticiens, chercheurs et passionnés, en insistant sur l’applicabilité et l’impact de cette méthode face aux défis computationnels modernes.

Pour approfondir l’optimisation bayésienne et son implémentation en Python, notre cours Hyperparameter Tuning in Python propose une mise en pratique des méthodologies courantes d’automatisation du réglage d’hyperparamètres avec la bibliothèque Scikit Learn. Parmi les approches avancées figurent notamment les algorithmes bayésiens et génétiques.