Recherche de site Web

Optimisation des hyperparamètres avec recherche aléatoire et recherche par grille


Les modèles d'apprentissage automatique comportent des hyperparamètres que vous devez définir afin de personnaliser le modèle en fonction de votre ensemble de données.

Les effets généraux des hyperparamètres sur un modèle sont souvent connus, mais il est difficile de définir au mieux un hyperparamètre et des combinaisons d'hyperparamètres en interaction pour un ensemble de données donné. Il existe souvent des heuristiques générales ou des règles empiriques pour configurer les hyperparamètres.

Une meilleure approche consiste à rechercher objectivement différentes valeurs pour les hyperparamètres du modèle et à choisir un sous-ensemble qui aboutit à un modèle qui atteint les meilleures performances sur un ensemble de données donné. C'est ce qu'on appelle optimisation des hyperparamètres ou réglage des hyperparamètres et est disponible dans la bibliothèque d'apprentissage automatique Python scikit-learn. Le résultat d’une optimisation d’hyperparamètres est un ensemble unique d’hyperparamètres performants que vous pouvez utiliser pour configurer votre modèle.

Dans ce tutoriel, vous découvrirez l'optimisation des hyperparamètres pour l'apprentissage automatique en Python.

Après avoir terminé ce tutoriel, vous saurez :

  • L'optimisation des hyperparamètres est nécessaire pour tirer le meilleur parti de vos modèles d'apprentissage automatique.
  • Comment configurer l'optimisation des hyperparamètres de recherche aléatoire et de grille pour les tâches de classification.
  • Comment configurer l'optimisation des hyperparamètres de recherche aléatoire et de grille pour les tâches de régression.

Commençons.

Présentation du didacticiel

Ce didacticiel est divisé en cinq parties ; ils sont:

  1. Optimisation des hyperparamètres du modèle
  2. API Scikit-Learn d'optimisation des hyperparamètres
  3. Optimisation des hyperparamètres pour la classification

    1. Recherche aléatoire de classification
    2. Recherche de grille pour la classification
  4. Optimisation des hyperparamètres pour la régression

    1. Recherche aléatoire de régression
    2. Recherche de grille pour la régression
  5. Questions courantes sur l'optimisation des hyperparamètres

Optimisation des hyperparamètres du modèle

Les modèles d'apprentissage automatique ont des hyperparamètres.

Les hyperparamètres sont des points de choix ou de configuration qui permettent de personnaliser un modèle d'apprentissage automatique pour une tâche ou un ensemble de données spécifique.

  • Hyperparamètre : argument de configuration du modèle spécifié par le développeur pour guider le processus d'apprentissage pour un ensemble de données spécifique.

Les modèles d'apprentissage automatique ont également des paramètres, qui sont les coefficients internes définis par l'entraînement ou l'optimisation du modèle sur un ensemble de données d'entraînement.

Les paramètres sont différents des hyperparamètres. Les paramètres sont appris automatiquement ; les hyperparamètres sont définis manuellement pour aider à guider le processus d'apprentissage.

Pour en savoir plus sur la différence entre paramètres et hyperparamètres, consultez le tutoriel :

  • Quelle est la différence entre un paramètre et un hyperparamètre ?

Généralement, un hyperparamètre a un effet connu sur un modèle au sens général, mais il n'est pas clair comment définir au mieux un hyperparamètre pour un ensemble de données donné. De plus, de nombreux modèles d’apprentissage automatique comportent une gamme d’hyperparamètres et peuvent interagir de manière non linéaire.

En tant que tel, il est souvent nécessaire de rechercher un ensemble d’hyperparamètres permettant d’obtenir les meilleures performances d’un modèle sur un ensemble de données. C'est ce qu'on appelle l'optimisation des hyperparamètres, le réglage des hyperparamètres ou la recherche d'hyperparamètres.

Une procédure d'optimisation consiste à définir un espace de recherche. Cela peut être considéré géométriquement comme un volume à n dimensions, où chaque hyperparamètre représente une dimension différente et l'échelle de la dimension correspond aux valeurs que l'hyperparamètre peut prendre, telles que valeur réelle, valeur entière ou catégorielle.

  • Espace de recherche : volume à rechercher où chaque dimension représente un hyperparamètre et chaque point représente une configuration de modèle.

Un point dans l'espace de recherche est un vecteur avec une valeur spécifique pour chaque valeur d'hyperparamètre. L'objectif de la procédure d'optimisation est de trouver un vecteur qui aboutit aux meilleures performances du modèle après apprentissage, comme une précision maximale ou une erreur minimale.

Une gamme d'algorithmes d'optimisation différents peut être utilisée, bien que deux des méthodes les plus simples et les plus courantes soient la recherche aléatoire et la recherche par grille.

  • Recherche aléatoire. Définissez un espace de recherche comme un domaine délimité de valeurs d'hyperparamètres et échantillonnez aléatoirement des points dans ce domaine.
  • Recherche par grille. Définissez un espace de recherche sous forme de grille de valeurs d'hyperparamètres et évaluez chaque position dans la grille.

La recherche par grille est idéale pour la vérification ponctuelle de combinaisons connues pour fonctionner généralement bien. La recherche aléatoire est idéale pour la découverte et l'obtention de combinaisons d'hyperparamètres que vous n'auriez pas devinées intuitivement, même si son exécution nécessite souvent plus de temps.

Des méthodes plus avancées sont parfois utilisées, telles que l'optimisation bayésienne et l'optimisation évolutive.

Maintenant que nous sommes familiers avec l’optimisation des hyperparamètres, voyons comment utiliser cette méthode en Python.

API Scikit-Learn d'optimisation des hyperparamètres

La bibliothèque d'apprentissage automatique open source Python scikit-learn fournit des techniques pour régler les hyperparamètres du modèle.

Plus précisément, il fournit RandomizedSearchCV pour la recherche aléatoire et GridSearchCV pour la recherche par grille. Les deux techniques évaluent les modèles pour un vecteur d'hyperparamètres donné en utilisant la validation croisée, d'où le suffixe « CV » de chaque nom de classe.

Les deux classes nécessitent deux arguments. Le premier est le modèle que vous optimisez. Il s'agit d'une instance du modèle avec les valeurs des hyperparamètres définis que vous souhaitez optimiser. Le second est l'espace de recherche. Ceci est défini comme un dictionnaire où les noms sont les arguments des hyperparamètres du modèle et les valeurs sont des valeurs discrètes ou une distribution de valeurs à échantillonner dans le cas d'une recherche aléatoire.

...
# define model
model = LogisticRegression()
# define search space
space = dict()
...
# define search
search = GridSearchCV(model, space)

Les deux classes fournissent un argument « cv » qui permet de spécifier un nombre entier de plis, par ex. 5, ou un objet de validation croisée configuré. Je recommande de définir et de spécifier un objet de validation croisée pour obtenir plus de contrôle sur l'évaluation du modèle et rendre la procédure d'évaluation évidente et explicite.

Dans le cas des tâches de classification, je recommande d'utiliser la classe RepeatedStratifiedKFold, et pour les tâches de régression, je recommande d'utiliser le RepeatedKFold avec un nombre approprié de plis et de répétitions, comme 10 plis et trois répétitions.

...
# define evaluation
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define search
search = GridSearchCV(..., cv=cv)

Les deux classes d'optimisation d'hyperparamètres fournissent également un argument « scoring » qui prend une chaîne indiquant la métrique à optimiser.

La métrique doit être maximisée, ce qui signifie que de meilleurs modèles entraînent des scores plus élevés. Pour la classification, cela peut être « précision ». Pour la régression, il s'agit d'une mesure d'erreur négative, telle que « neg_mean_absolute_error » pour une version négative de l'erreur absolue moyenne, où les valeurs plus proches de zéro représentent moins d'erreurs de prédiction de la part du modèle.

...
# define search
search = GridSearchCV(..., scoring='neg_mean_absolute_error')

Vous pouvez voir une liste de mesures de notation intégrées ici :

  • Le paramètre de scoring : définir les règles d'évaluation du modèle

Enfin, la recherche peut être parallèle, par ex. utilisez tous les cœurs du processeur en spécifiant l'argument « n_jobs » sous forme d'entier avec le nombre de cœurs de votre système, par ex. 8. Ou vous pouvez le définir sur -1 pour utiliser automatiquement tous les cœurs de votre système.

...
# define search
search = GridSearchCV(..., n_jobs=-1)

Une fois définie, la recherche est effectuée en appelant la fonction fit() et en fournissant un ensemble de données utilisé pour entraîner et évaluer les combinaisons d'hyperparamètres du modèle à l'aide de la validation croisée.

...
# execute search
result = search.fit(X, y)

L'exécution de la recherche peut prendre des minutes ou des heures, selon la taille de l'espace de recherche et la vitesse de votre matériel. Vous souhaiterez souvent adapter la recherche au temps dont vous disposez plutôt qu’à la possibilité de ce qui pourrait être recherché.

A la fin de la recherche, vous pouvez accéder à l'ensemble des résultats via les attributs sur la classe. Les attributs les plus importants sont peut-être le meilleur score observé et les hyperparamètres qui ont obtenu le meilleur score.

...
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

Une fois que vous connaissez l'ensemble d'hyperparamètres qui permettent d'obtenir le meilleur résultat, vous pouvez alors définir un nouveau modèle, définir les valeurs de chaque hyperparamètre, puis ajuster le modèle sur toutes les données disponibles. Ce modèle peut ensuite être utilisé pour faire des prédictions sur de nouvelles données.

Maintenant que nous connaissons l'API d'optimisation des hyperparamètres dans scikit-learn, examinons quelques exemples concrets.

Optimisation des hyperparamètres pour la classification

Dans cette section, nous utiliserons l'optimisation des hyperparamètres pour découvrir une configuration de modèle performante pour l'ensemble de données sonar.

L'ensemble de données sonar est un ensemble de données d'apprentissage automatique standard comprenant 208 lignes de données avec 60 variables d'entrée numériques et une variable cible avec deux valeurs de classe, par ex. classement binaire.

En utilisant un ensemble de tests de validation croisée 10 fois stratifiée et répétée avec trois répétitions, un modèle naïf peut atteindre une précision d’environ 53 %. Un modèle très performant peut atteindre une précision d’environ 88 % sur ce même faisceau de test. Cela fournit les limites des performances attendues sur cet ensemble de données.

L'ensemble de données consiste à prédire si les retours du sonar indiquent une roche ou une mine simulée.

  • Ensemble de données sonar (sonar.csv)
  • Description de l'ensemble de données du sonar (sonar.names)

Pas besoin de télécharger l'ensemble de données ; nous le téléchargerons automatiquement dans le cadre de nos exemples concrets.

L'exemple ci-dessous télécharge l'ensemble de données et résume sa forme.

# summarize the sonar dataset
from pandas import read_csv
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)

L'exécution de l'exemple télécharge l'ensemble de données et le divise en éléments d'entrée et de sortie. Comme prévu, nous pouvons voir qu'il y a 208 lignes de données avec 60 variables d'entrée.

(208, 60) (208,)

Utilisons ensuite la recherche aléatoire pour trouver une bonne configuration de modèle pour l'ensemble de données du sonar.

Pour simplifier les choses, nous nous concentrerons sur un modèle linéaire, le modèle de régression logistique et les hyperparamètres courants adaptés à ce modèle.

Recherche aléatoire de classification

Dans cette section, nous explorerons l'optimisation des hyperparamètres du modèle de régression logistique sur l'ensemble de données sonar.

Tout d'abord, nous définirons le modèle qui sera optimisé et utiliserons les valeurs par défaut pour les hyperparamètres qui ne seront pas optimisés.

...
# define model
model = LogisticRegression()

Nous évaluerons les configurations du modèle en utilisant une validation croisée stratifiée répétée k fois avec trois répétitions et 10 fois.

...
# define evaluation
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)

Ensuite, nous pouvons définir l'espace de recherche.

Il s'agit d'un dictionnaire dans lequel les noms sont des arguments du modèle et les valeurs sont des distributions à partir desquelles tirer des échantillons. Nous allons optimiser le solveur, la pénalité et les hyperparamètres C du modèle avec des distributions discrètes pour le solveur et le type de pénalité et un log- distribution uniforme de 1e-5 à 100 pour la valeur C.

Log-uniform est utile pour rechercher des valeurs de pénalité, car nous explorons souvent des valeurs de différents ordres de grandeur, au moins dans un premier temps.

...
# define search space
space = dict()
space['solver'] = ['newton-cg', 'lbfgs', 'liblinear']
space['penalty'] = ['none', 'l1', 'l2', 'elasticnet']
space['C'] = loguniform(1e-5, 100)

Ensuite, nous pouvons définir la procédure de recherche avec tous ces éléments.

Surtout, nous devons définir le nombre d'itérations ou d'échantillons à extraire de l'espace de recherche via l'argument « n_iter ». Dans ce cas, nous le fixerons à 500.

...
# define search
search = RandomizedSearchCV(model, space, n_iter=500, scoring='accuracy', n_jobs=-1, cv=cv, random_state=1)

Enfin, nous pouvons effectuer l'optimisation et rapporter les résultats.

...
# execute search
result = search.fit(X, y)
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

En reliant cela ensemble, l’exemple complet est répertorié ci-dessous.

# random search logistic regression model on the sonar dataset
from scipy.stats import loguniform
from pandas import read_csv
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import RandomizedSearchCV
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = LogisticRegression()
# define evaluation
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define search space
space = dict()
space['solver'] = ['newton-cg', 'lbfgs', 'liblinear']
space['penalty'] = ['none', 'l1', 'l2', 'elasticnet']
space['C'] = loguniform(1e-5, 100)
# define search
search = RandomizedSearchCV(model, space, n_iter=500, scoring='accuracy', n_jobs=-1, cv=cv, random_state=1)
# execute search
result = search.fit(X, y)
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

L’exécution de l’exemple peut prendre une minute. C'est rapide car nous utilisons un petit espace de recherche et un modèle rapide pour ajuster et évaluer. Vous pouvez voir des avertissements lors de l'optimisation pour des combinaisons de configuration non valides. Ceux-ci peuvent être ignorés en toute sécurité.

À la fin de l’exécution, le meilleur score et la configuration d’hyperparamètres ayant permis d’obtenir les meilleures performances sont signalés.

Vos résultats spécifiques varieront en fonction de la nature stochastique de la procédure d'optimisation. Essayez d'exécuter l'exemple plusieurs fois.

Dans ce cas, nous pouvons voir que la meilleure configuration a atteint une précision d'environ 78,9 pour cent, ce qui est juste, et les valeurs spécifiques pour le solveur, la pénalité et C utilisés pour atteindre ce score.

Best Score: 0.7897619047619049
Best Hyperparameters: {'C': 4.878363034905756, 'penalty': 'l2', 'solver': 'newton-cg'}

Utilisons ensuite la recherche par grille pour trouver une bonne configuration de modèle pour l'ensemble de données du sonar.

Recherche de grille pour la classification

L’utilisation de la recherche par grille s’apparente à la recherche aléatoire pour la classification.

La principale différence est que l’espace de recherche doit être une grille discrète pour être recherché. Cela signifie qu'au lieu d'utiliser une distribution log-uniforme pour C, nous pouvons spécifier des valeurs discrètes sur une échelle logarithmique.

...
# define search space
space = dict()
space['solver'] = ['newton-cg', 'lbfgs', 'liblinear']
space['penalty'] = ['none', 'l1', 'l2', 'elasticnet']
space['C'] = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]

De plus, la classe GridSearchCV ne nécessite pas un certain nombre d'itérations, car nous évaluons uniquement des combinaisons d'hyperparamètres dans la grille.

...
# define search
search = GridSearchCV(model, space, scoring='accuracy', n_jobs=-1, cv=cv)

En reliant cela ensemble, l'exemple complet de configurations de régression logistique de recherche de grille pour l'ensemble de données sonar est répertorié ci-dessous.

# grid search logistic regression model on the sonar dataset
from pandas import read_csv
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import GridSearchCV
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = LogisticRegression()
# define evaluation
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define search space
space = dict()
space['solver'] = ['newton-cg', 'lbfgs', 'liblinear']
space['penalty'] = ['none', 'l1', 'l2', 'elasticnet']
space['C'] = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]
# define search
search = GridSearchCV(model, space, scoring='accuracy', n_jobs=-1, cv=cv)
# execute search
result = search.fit(X, y)
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

L’exécution de l’exemple peut prendre un moment. C'est rapide car nous utilisons un petit espace de recherche et un modèle rapide pour ajuster et évaluer. Encore une fois, vous pouvez voir des avertissements lors de l'optimisation pour des combinaisons de configuration non valides. Ceux-ci peuvent être ignorés en toute sécurité.

À la fin de l’exécution, le meilleur score et la configuration d’hyperparamètres ayant permis d’obtenir les meilleures performances sont signalés.

Vos résultats spécifiques varieront en fonction de la nature stochastique de la procédure d'optimisation. Essayez d'exécuter l'exemple plusieurs fois.

Dans ce cas, nous pouvons voir que la meilleure configuration a atteint une précision d'environ 78,2 %, ce qui est également juste, et les valeurs spécifiques pour le solveur, la pénalité et C hyperparamètres utilisés pour atteindre ce score. Il est intéressant de noter que les résultats sont très similaires à ceux trouvés via la recherche aléatoire.

Best Score: 0.7828571428571429
Best Hyperparameters: {'C': 1, 'penalty': 'l2', 'solver': 'newton-cg'}

Optimisation des hyperparamètres pour la régression

Dans cette section, nous utiliserons l'hyperoptimisation pour découvrir une configuration de modèle la plus performante pour l'ensemble de données d'assurance automobile.

L'ensemble de données d'assurance automobile est un ensemble de données d'apprentissage automatique standard comprenant 63 lignes de données avec 1 variable d'entrée numérique et une variable cible numérique.

En utilisant un faisceau de tests de validation croisée 10 fois stratifiée et répétée avec 3 répétitions, un modèle naïf peut atteindre une erreur absolue moyenne (MAE) d'environ 66. Un modèle le plus performant peut atteindre un MAE sur ce même faisceau de tests d'environ 28. Cela fournit les limites des performances attendues sur cet ensemble de données.

L'ensemble de données consiste à prédire le montant total des réclamations (en milliers de couronnes suédoises) en fonction du nombre de réclamations pour différentes régions géographiques.

  • Ensemble de données sur l'assurance automobile (auto-insurance.csv)
  • Description de l'ensemble de données sur l'assurance automobile (auto-insurance.names)

Pas besoin de télécharger l'ensemble de données, nous le téléchargerons automatiquement dans le cadre de nos exemples concrets.

L'exemple ci-dessous télécharge l'ensemble de données et résume sa forme.

# summarize the auto insurance dataset
from pandas import read_csv
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)

L'exécution de l'exemple télécharge l'ensemble de données et le divise en éléments d'entrée et de sortie. Comme prévu, nous pouvons voir qu'il y a 63 lignes de données avec 1 variable d'entrée.

(63, 1) (63,)

Ensuite, nous pouvons utiliser l'optimisation des hyperparamètres pour trouver une bonne configuration de modèle pour l'ensemble de données d'assurance automobile.

Pour simplifier les choses, nous nous concentrerons sur un modèle linéaire, le modèle de régression linéaire et les hyperparamètres communs adaptés à ce modèle.

Recherche aléatoire de régression

Configurer et utiliser la procédure d'optimisation des hyperparamètres de recherche aléatoire pour la régression revient un peu à l'utiliser pour la classification.

Dans ce cas, nous configurerons les hyperparamètres importants de l'implémentation de la régression linéaire, notamment le solver, alpha, fit_intercept et normalize .

Nous utiliserons une distribution discrète des valeurs dans l'espace de recherche pour tous sauf l'argument « alpha » qui est un terme de pénalité, auquel cas nous utiliserons une distribution log-uniforme comme nous l'avons fait dans le précédent section pour l'argument « C » de la régression logistique.

...
# define search space
space = dict()
space['solver'] = ['svd', 'cholesky', 'lsqr', 'sag']
space['alpha'] = loguniform(1e-5, 100)
space['fit_intercept'] = [True, False]
space['normalize'] = [True, False]

La principale différence entre la régression et la classification réside dans le choix de la méthode de notation.

Pour la régression, la performance est souvent mesurée à l’aide d’une erreur minimisée, zéro représentant un modèle parfaitement compétent. Les procédures d'optimisation des hyperparamètres dans scikit-learn supposent un score de maximisation. Par conséquent, une version de chaque mesure d’erreur est fournie et rendue négative.

Cela signifie que les grandes erreurs positives deviennent de grandes erreurs négatives, les bonnes performances sont de petites valeurs négatives proches de zéro et la compétence parfaite est nulle.

Le signe du MAE négatif peut être ignoré lors de l’interprétation du résultat.

Dans ce cas, nous parlerons d'erreur absolue (MAE) et une version maximisée de cette erreur est disponible en définissant l'argument « scoring » sur « neg_mean_absolute_error ».

...
# define search
search = RandomizedSearchCV(model, space, n_iter=500, scoring='neg_mean_absolute_error', n_jobs=-1, cv=cv, random_state=1)

En reliant cela ensemble, l’exemple complet est répertorié ci-dessous.

# random search linear regression model on the auto insurance dataset
from scipy.stats import loguniform
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import RepeatedKFold
from sklearn.model_selection import RandomizedSearchCV
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = Ridge()
# define evaluation
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# define search space
space = dict()
space['solver'] = ['svd', 'cholesky', 'lsqr', 'sag']
space['alpha'] = loguniform(1e-5, 100)
space['fit_intercept'] = [True, False]
space['normalize'] = [True, False]
# define search
search = RandomizedSearchCV(model, space, n_iter=500, scoring='neg_mean_absolute_error', n_jobs=-1, cv=cv, random_state=1)
# execute search
result = search.fit(X, y)
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

L’exécution de l’exemple peut prendre un moment. C'est rapide car nous utilisons un petit espace de recherche et un modèle rapide pour ajuster et évaluer. Vous pouvez voir des avertissements lors de l'optimisation pour des combinaisons de configuration non valides. Ceux-ci peuvent être ignorés en toute sécurité.

À la fin de l’exécution, le meilleur score et la configuration d’hyperparamètres ayant permis d’obtenir les meilleures performances sont signalés.

Vos résultats spécifiques varieront en fonction de la nature stochastique de la procédure d'optimisation. Essayez d'exécuter l'exemple plusieurs fois.

Dans ce cas, on constate que la meilleure configuration atteint un MAE d'environ 29,2, ce qui est très proche des meilleures performances du modèle. Nous pouvons alors voir les valeurs d’hyperparamètres spécifiques qui ont permis d’obtenir ce résultat.

Best Score: -29.23046315344758
Best Hyperparameters: {'alpha': 0.008301451461243866, 'fit_intercept': True, 'normalize': True, 'solver': 'sag'}

Utilisons ensuite la recherche par grille pour trouver une bonne configuration de modèle pour l'ensemble de données d'assurance automobile.

Recherche de grille pour la régression

En tant que recherche de grille, nous ne pouvons pas définir de distribution à échantillonner et devons plutôt définir une grille discrète de valeurs d'hyperparamètres. En tant que tel, nous spécifierons l'argument « alpha » comme une plage de valeurs sur une échelle log-10.

...
# define search space
space = dict()
space['solver'] = ['svd', 'cholesky', 'lsqr', 'sag']
space['alpha'] = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]
space['fit_intercept'] = [True, False]
space['normalize'] = [True, False]

La recherche par grille pour la régression nécessite que le « scoring » soit spécifié, tout comme nous l'avons fait pour la recherche aléatoire.

Dans ce cas, nous utiliserons à nouveau la fonction de notation MAE négative.

...
# define search
search = GridSearchCV(model, space, scoring='neg_mean_absolute_error', n_jobs=-1, cv=cv)

En reliant cela ensemble, l'exemple complet de configurations de régression linéaire de recherche de grille pour l'ensemble de données d'assurance automobile est répertorié ci-dessous.

# grid search linear regression model on the auto insurance dataset
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import RepeatedKFold
from sklearn.model_selection import GridSearchCV
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = Ridge()
# define evaluation
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# define search space
space = dict()
space['solver'] = ['svd', 'cholesky', 'lsqr', 'sag']
space['alpha'] = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]
space['fit_intercept'] = [True, False]
space['normalize'] = [True, False]
# define search
search = GridSearchCV(model, space, scoring='neg_mean_absolute_error', n_jobs=-1, cv=cv)
# execute search
result = search.fit(X, y)
# summarize result
print('Best Score: %s' % result.best_score_)
print('Best Hyperparameters: %s' % result.best_params_)

L’exécution de l’exemple peut prendre une minute. C'est rapide car nous utilisons un petit espace de recherche et un modèle rapide pour ajuster et évaluer. Encore une fois, vous pouvez voir des avertissements lors de l'optimisation pour des combinaisons de configuration non valides. Ceux-ci peuvent être ignorés en toute sécurité.

À la fin de l’exécution, le meilleur score et la configuration d’hyperparamètres ayant permis d’obtenir les meilleures performances sont signalés.

Vos résultats spécifiques varieront en fonction de la nature stochastique de la procédure d'optimisation. Essayez d'exécuter l'exemple plusieurs fois.

Dans ce cas, nous pouvons voir que la meilleure configuration a atteint un MAE d'environ 29,2, ce qui est presque identique à ce que nous avons obtenu avec la recherche aléatoire de la section précédente. Fait intéressant, les hyperparamètres sont également presque identiques, ce qui est une bonne confirmation.

Best Score: -29.275708614337326
Best Hyperparameters: {'alpha': 0.1, 'fit_intercept': True, 'normalize': False, 'solver': 'sag'}

Questions courantes sur l'optimisation des hyperparamètres

Cette section répond à quelques questions courantes sur l'optimisation des hyperparamètres.

Comment choisir entre la recherche aléatoire et la recherche par grille ?

Choisissez la méthode en fonction de vos besoins. Je recommande de commencer par la grille et de faire une recherche aléatoire si vous avez le temps.

La recherche par grille est appropriée pour les recherches petites et rapides de valeurs d’hyperparamètres qui sont généralement connues pour fonctionner correctement.

La recherche aléatoire est appropriée pour découvrir de nouvelles valeurs d’hyperparamètres ou de nouvelles combinaisons d’hyperparamètres, ce qui entraîne souvent de meilleures performances, même si cela peut prendre plus de temps.

Comment accélérer l’optimisation des hyperparamètres ?

Assurez-vous de définir l'argument « n_jobs » sur le nombre de cœurs de votre machine.

Après cela, d'autres suggestions incluent :

  • Évaluez sur un échantillon plus petit de votre ensemble de données.
  • Explorez un espace de recherche plus petit.
  • Utilisez moins de répétitions et/ou de plis pour la validation croisée.
  • Exécutez la recherche sur une machine plus rapide, telle qu'AWS EC2.
  • Utilisez un modèle alternatif plus rapide à évaluer.

Comment choisir les hyperparamètres à rechercher ?

La plupart des algorithmes possèdent un sous-ensemble d’hyperparamètres qui ont le plus d’influence sur la procédure de recherche.

Ceux-ci sont répertoriés dans la plupart des descriptions de l’algorithme. Par exemple, voici quelques algorithmes et leurs hyperparamètres les plus importants :

  • Ajustez les hyperparamètres pour les algorithmes d’apprentissage automatique de classification

Si vous n'êtes pas sûr :

  • Examinez les articles qui utilisent l’algorithme pour trouver des idées.
  • Consultez la documentation de l'API et de l'algorithme pour avoir des idées.
  • Recherchez tous les hyperparamètres.

Comment utiliser les hyperparamètres les plus performants ?

Définissez un nouveau modèle et définissez les valeurs des hyperparamètres du modèle sur les valeurs trouvées par la recherche.

Ajustez ensuite le modèle à toutes les données disponibles et utilisez le modèle pour commencer à faire des prédictions sur de nouvelles données.

C'est ce qu'on appelle préparer un modèle final. En voir plus ici :

  • Comment former un modèle final d'apprentissage automatique

Comment faire une prédiction ?

Tout d’abord, ajustez un modèle final (question précédente).

Appelez ensuite la fonction predict() pour faire une prédiction.

Pour obtenir des exemples de prédiction avec un modèle final, consultez le didacticiel :

  • Comment faire des prédictions avec scikit-learn

Avez-vous une autre question sur l'optimisation des hyperparamètres ?
Faites-le moi savoir dans les commentaires ci-dessous.

Lectures complémentaires

Cette section fournit plus de ressources sur le sujet si vous souhaitez approfondir.

Tutoriels

  • Quelle est la différence entre un paramètre et un hyperparamètre ?
  • Résultats pour les ensembles de données d’apprentissage automatique de classification et de régression standard
  • Ajustez les hyperparamètres pour les algorithmes d’apprentissage automatique de classification
  • Comment former un modèle final d'apprentissage automatique
  • Comment faire des prédictions avec scikit-learn

Apis

  • Réglage des hyper-paramètres d'un estimateur, scikit-learn Documentation.
  • API sklearn.model_selection.GridSearchCV.
  • API sklearn.model_selection.RandomizedSearchCV.

Articles

  • Optimisation des hyperparamètres, Wikipédia.

Résumé

Dans ce didacticiel, vous avez découvert l'optimisation des hyperparamètres pour l'apprentissage automatique en Python.

Concrètement, vous avez appris :

  • L'optimisation des hyperparamètres est nécessaire pour tirer le meilleur parti de vos modèles d'apprentissage automatique.
  • Comment configurer l'optimisation des hyperparamètres de recherche aléatoire et de grille pour les tâches de classification.
  • Comment configurer l'optimisation des hyperparamètres de recherche aléatoire et de grille pour les tâches de régression.

Avez-vous des questions ?
Posez vos questions dans les commentaires ci-dessous et je ferai de mon mieux pour y répondre.

Articles connexes