Conseils de réglage des hyperparamètres d'apprentissage automatique en Python

Avec la popularité généralisée des applications d'apprentissage automatique, de plus en plus de data scientists et de développeurs d'apprentissage automatique ont commencé à s'intéresser à l'optimisation des performances des modèles, dont le réglage des hyperparamètres est un élément indispensable. Dans l'apprentissage automatique, les hyperparamètres représentent les paramètres d'un modèle plutôt que les poids appris à partir des données d'entraînement. Des paramètres d'hyperparamètres incorrects peuvent entraîner de mauvaises performances du modèle pendant l'entraînement et les tests. Le réglage des hyperparamètres est donc une étape clé.

Python fournit de nombreuses bibliothèques d'apprentissage automatique populaires, telles que Scikit-learn, TensorFlow, etc. Ces bibliothèques fournissent de nombreux outils pour nous aider à régler les hyperparamètres. Dans cet article, nous aborderons quelques conseils de réglage des hyperparamètres d’apprentissage automatique en Python.

1. Grid search

Grid search est une méthode de réglage d'hyperparamètres simple et efficace. Son idée principale est d'essayer différentes combinaisons d'hyperparamètres et d'effectuer une validation croisée sur chaque combinaison pour trouver la combinaison d'hyperparamètres la plus performante. Dans Scikit-learn, nous pouvons utiliser la classe GridSearchCV pour implémenter la recherche par grille.

Ce qui suit est le processus général de recherche de grille :

1) Définir les paramètres et les combinaisons de paramètres qui doivent être réglés

2) Utiliser la classe GridSearchCV pour effectuer une validation croisée et une recherche de grille

3) Afficher la meilleure combinaison d'hyperparamètres

Par exemple, lors de l'utilisation de Support Vector Machine (SVM) dans Scikit-learn pour classification , vous pouvez utiliser le code suivant pour effectuer une recherche par grille :

from sklearn.model_selection import GridSearchCV
from sklearn import svm, datasets

iris = datasets.load_iris()
X = iris.data[:, :2]
y = iris.target

parameters = {'kernel':('linear', 'rbf'), 'C':[0.1, 1, 10]}
svc = svm.SVC()
clf = GridSearchCV(svc, parameters)
clf.fit(X, y)

print("Best parameters:", clf.best_params_)

2. Recherche aléatoire

Bien que la recherche par grille soit simple et fiable, lorsque la hyperparamètres Lorsque l'espace exhaustif est grand, la quantité de calcul sera extrêmement énorme. Les méthodes de recherche aléatoire atténuent cette situation en échantillonnant aléatoirement un ensemble de paramètres dans l’espace des paramètres et en évaluant leurs performances. Cette méthode explore un espace de paramètres plus large, en particulier lorsque les paramètres ont une large plage et sont indépendants les uns des autres. La recherche aléatoire peut être plus efficace que la recherche par grille avec les mêmes ressources informatiques.

Ce qui suit est le processus général de recherche aléatoire :

1) Définir les paramètres et la plage de paramètres qui doivent être réglés

2) Utiliser la classe RandomizedSearchCV pour effectuer une validation croisée et une recherche aléatoire

3) Afficher la meilleure combinaison d'hyperparamètres

Par exemple, dans le modèle Random Forest, le code suivant peut être utilisé pour recherche aléatoire : #🎜🎜 #

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV
import numpy as np

# Load data
iris = datasets.load_iris()
X = iris.data[:, :2]
y = iris.target

# Define parameter grid
param_grid = {'n_estimators': np.arange(10, 200, 10),
              'max_features': ['auto', 'sqrt', 'log2'],
              'max_depth' : np.arange(1, 10),
              'criterion' :['gini', 'entropy']
             }

# Random search using 10-fold cross validation
rf = RandomForestClassifier()
rf_random = RandomizedSearchCV(estimator=rf,
                               param_distributions=param_grid,
                               n_iter=100,
                               cv=10,
                               random_state=42)

# Fit the model
rf_random.fit(X, y)

# Print the best parameters
print("Best parameters:", rf_random.best_params_)

Optimisation bayésienne

L'optimisation bayésienne est une méthode efficace de réglage des hyperparamètres. Cette méthode recherche l'espace des hyperparamètres en sélectionnant la combinaison d'hyperparamètres la plus susceptible d'améliorer les performances à chaque itération, convergeant progressivement au cours du processus. Cette approche utilise les résultats des premières exécutions à des fins d'inférence lors de l'essai de différents paramètres, et comme la probabilité a priori D est utilisée pour modéliser la distribution de probabilité des paramètres du modèle, elle peut optimiser la situation dans laquelle seule une petite quantité d'exploration peut être effectuée. , et peut bien fonctionner. Il peut gérer des paramètres discrets ou continus, différents types de fonctions objectives et de bruit, et ajuster automatiquement les règles de recherche prédéfinies. Il présente des avantages significatifs dans l'optimisation de l'hyperespace multidimensionnel.

Ce qui suit est le processus général de l'optimisation bayésienne :

1) Définir les paramètres et les plages de paramètres qui doivent être réglés

2) Définir la fonction objectif et utilisez l'algorithme d'optimisation bayésien pour l'optimisation

3) Générez la meilleure combinaison d'hyperparamètres

Par exemple, lors de l'utilisation de la Gradient Boosting Machine (GBM) dans Scikit-learn Lors de la classification, vous pouvez utiliser le code suivant pour l'optimisation bayésienne :

from sklearn.datasets import load_iris
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
from bayes_opt import BayesianOptimization

# Load data
iris = load_iris()
X = iris.data[:, :2]
y = iris.target

# Define objective function
def gbmler_learning_rate(learning_rate):
    gb = GradientBoostingClassifier(learning_rate=learning_rate)
    return cross_val_score(gb, X, y, cv=5).mean()

# Define parameter space
param_space = {'learning_rate': (0.01, 1.0)}

# Initialize optimizer
optimizer = BayesianOptimization(
    f=gbmler_learning_rate,
    pbounds=param_space,
    random_state=42
)

# Optimize
optimizer.maximize(
    init_points=5,
    n_iter=25
)

# Print the best parameters
print("Best parameters:", optimizer.max['params'])

Recherche de paramètres interprétables

Recherche d'hyperparamètres habituelle Il s'agit de mettre le classificateur idée avant la recherche d'hyperparamètres et effectuez un certain codage sur tous les paramètres d'hyperparamètres possibles. Par exemple, pendant le processus de recherche, chaque paramètre d'hyperparamètre est organisé sous la forme d'un tableau et le tableau est utilisé comme entrée. Le principal problème lié à l’exécution d’une recherche avec cette approche est que les hyperparamètres apparaîtront en tant qu’individus et perdront des informations sur leurs effets interactifs. Cette approche s’inscrit plutôt dans le cadre d’une modélisation statistique simple et interprétable. Un autre avantage de l'utilisation de l'optimisation bayésienne est la possibilité de rechercher des relations entre les caméras et les hyperparamètres contraints lors de l'utilisation de l'inférence de modèle probabiliste.

Pour résumer, Python propose de nombreuses techniques de réglage des hyperparamètres d'apprentissage automatique, notamment la recherche de grille, la recherche aléatoire, l'optimisation bayésienne et la recherche de paramètres interprétables. Choisir une méthode adaptée à votre ensemble de données peut vous aider à obtenir de meilleurs résultats en matière de réglage des hyperparamètres.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!