Image par auteur
 

Chaque modèle d'apprentissage automatique que vous entraînez possède un ensemble de paramètres ou de coefficients de modèle. L'objectif de l'algorithme d'apprentissage automatique, formulé comme un problème d'optimisation, est d'apprendre les valeurs optimales de ces paramètres. 

De plus, les modèles d’apprentissage automatique disposent également d’un ensemble d’hyperparamètres. Comme la valeur de K, le nombre de voisins, dans l'algorithme K-Nearest Neighbours. Ou la taille du lot lors de la formation d’un réseau neuronal profond, et bien plus encore.

Ces hyperparamètres ne sont pas appris par le modèle. Mais plutôt précisé par le développeur. Ils influencent les performances du modèle et sont réglables. Alors, comment trouver les meilleures valeurs pour ces hyperparamètres ? Ce processus est appelé optimisation des hyperparamètres or réglage hyperparamètre.

Les deux techniques de réglage des hyperparamètres les plus courantes comprennent :

• Grille de recherche
• Recherche aléatoire

Dans ce guide, nous apprendrons comment fonctionnent ces techniques et leur implémentation scikit-learn.

Commençons par former un simple Classificateur de machine à vecteurs de support (SVM) sur l'ensemble de données sur le vin. 

Tout d’abord, importez les modules et classes requis : 

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

L'ensemble de données sur le vin fait partie des ensembles de données intégrés dans scikit-learn. Lisons donc les fonctionnalités et les étiquettes cibles comme indiqué :

# Load the Wine dataset
wine = datasets.load_wine()
X = wine.data
y = wine.target

L'ensemble de données sur le vin est un ensemble de données simple comportant 13 caractéristiques numériques et trois étiquettes de classe de sortie. Il s'agit d'un bon ensemble de données candidat pour vous familiariser avec les problèmes de classification multi-classes. Tu peux courir wine.DESCR pour obtenir une description de l’ensemble de données.

Sortie de wine.DESCR 
 

Ensuite, divisez l'ensemble de données en ensembles d'entraînement et de test. Ici, nous avons utilisé un test_size de 0.2. Ainsi, 80 % des données vont dans l’ensemble de données d’entraînement et 20 % dans l’ensemble de données de test.

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

Instanciez maintenant un classificateur de vecteurs de support et ajustez le modèle à l'ensemble de données d'entraînement. Évaluez ensuite ses performances sur l’ensemble de test.

# Create a baseline SVM classifier
baseline_svm = SVC()
baseline_svm.fit(X_train, y_train)
y_pred = baseline_svm.predict(X_test)

Puisqu'il s'agit d'un simple problème de multi-classification, nous pouvons examiner la précision du modèle.

# Evaluate the baseline model
accuracy = accuracy_score(y_test, y_pred)
print(f"Baseline SVM Accuracy: {accuracy:.2f}")

On voit que le score de précision de ce modèle avec les valeurs par défaut des hyperparamètres est d'environ 0.78. 

Output >>>
Baseline SVM Accuracy: 0.78

Ici, nous avons utilisé un random_state de 24. Pour un état aléatoire différent, vous obtiendrez une répartition différente du test d'entraînement, et par la suite un score de précision différent.

Nous avons donc besoin d'un meilleur moyen qu'une seule répartition de tests de train pour évaluer les performances du modèle. Peut-être entraînez-vous le modèle sur de nombreuses divisions de ce type et tenez compte de la précision moyenne. Tout en essayant également différentes combinaisons d'hyperparamètres ? Oui, c'est pourquoi nous utilisons la validation croisée dans l'évaluation des modèles et la recherche d'hyperparamètres. Nous en apprendrons davantage dans les sections suivantes.

Identifions ensuite les hyperparamètres que nous pouvons régler pour ce classificateur de machines à vecteurs de support.

Dans le réglage des hyperparamètres, nous visons à trouver la meilleure combinaison de valeurs d'hyperparamètres pour notre classificateur SVM. Les hyperparamètres couramment réglés pour le classificateur de vecteurs de support incluent :

• C: Paramètre de régularisation, contrôlant le compromis entre maximiser la marge et minimiser l'erreur de classification.
• kernel: Spécifie le type de fonction noyau à utiliser (par exemple, 'linear', 'rbf', 'poly').
• gamma: Coefficient de noyau pour les noyaux 'rbf' et 'poly'.

Validation croisée aide à évaluer la qualité du modèle généralise à des données invisibles et réduit le risque de surajustement à une seule répartition de test de train. La validation croisée k-fold couramment utilisée implique de diviser l'ensemble de données en k plis de même taille. Le modèle est formé k fois, chaque pli servant d'ensemble de validation une fois et les plis restants comme ensemble d'entraînement. Ainsi, pour chaque pli, nous obtiendrons une précision de validation croisée.

Lorsque nous exécutons la grille et des recherches aléatoires pour trouver les meilleurs hyperparamètres, nous choisissons les hyperparamètres en fonction du meilleur score de validation croisée moyen.

Grille de recherche est une technique de réglage d'hyperparamètres qui effectue un recherche exhaustive sur un espace d'hyperparamètres spécifié pour trouver la combinaison d'hyperparamètres qui donne les meilleures performances du modèle.

Comment fonctionne la recherche par grille

Nous définissons l'espace de recherche des hyperparamètres comme une grille de paramètres. Le grille de paramètres est un dictionnaire dans lequel vous spécifiez chaque hyperparamètre que vous souhaitez régler avec une liste de valeurs à explorer. 

La recherche de grille explore ensuite systématiquement toutes les combinaisons possibles d'hyperparamètres de la grille de paramètres. Il ajuste et évalue le modèle pour chaque combinaison à l'aide d'une validation croisée et sélectionne la combinaison qui donne les meilleures performances.

Ensuite, implémentons la recherche par grille dans scikit-learn.

Tout d'abord, importez le GridSearchCV cours de scikit-learn sélection_modèle module:

from sklearn.model_selection import GridSearchCV

Définissons la grille de paramètres pour le classificateur SVM :

# Define the hyperparameter grid
param_grid = { 'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf', 'poly'], 'gamma': [0.1, 1, 'scale', 'auto']
}

La recherche de grille explore ensuite systématiquement toutes les combinaisons possibles d'hyperparamètres de la grille de paramètres. Pour cet exemple, il évalue les performances du modèle avec :

• C réglé sur 0.1, 1 et 10,
• kernel réglé sur « linéaire », « rbf » et « poly », et
• gamma réglé sur 0.1, 1, « échelle » et « auto ».

Cela donne un total de 3 * 3 * 4 = 36 combinaisons différentes à évaluer. La recherche par grille ajuste et évalue le modèle pour chaque combinaison à l'aide d'une validation croisée et sélectionne la combinaison qui donne les meilleures performances.

On instancie alors GridSearchCV pour régler les hyperparamètres du baseline_svm:

# Create the GridSearchCV object
grid_search = GridSearchCV(estimator=baseline_svm, param_grid=param_grid, cv=5) # Fit the model with the grid of hyperparameters
grid_search.fit(X_train, y_train)

Notez que nous avons utilisé une validation croisée 5 fois. 

Enfin, nous évaluons les performances du meilleur modèle — avec les hyperparamètres optimaux trouvés par recherche par grille — sur les données de test :

# Get the best hyperparameters and model
best_params = grid_search.best_params_
best_model = grid_search.best_estimator_ # Evaluate the best model
y_pred_best = best_model.predict(X_test)
accuracy_best = accuracy_score(y_test, y_pred_best)
print(f"Best SVM Accuracy: {accuracy_best:.2f}")
print(f"Best Hyperparameters: {best_params}")

Comme on le voit, le modèle atteint un score de précision de 0.94 pour les hyperparamètres suivants :

Output >>>
Best SVM Accuracy: 0.94
Best Hyperparameters: {'C': 0.1, 'gamma': 0.1, 'kernel': 'poly'}

L'utilisation de la recherche par grille pour le réglage des hyperparamètres présente les avantages suivants :

• La recherche par grille explore toutes les combinaisons spécifiées, garantissant que vous ne manquez pas les meilleurs hyperparamètres dans l'espace de recherche défini.
• C'est un bon choix pour explorer des espaces d'hyperparamètres plus petits.

D’un autre côté cependant :

• La recherche de grille peut être coûteuse en termes de calcul, en particulier lorsqu'il s'agit d'un grand nombre d'hyperparamètres et de leurs valeurs. Cela peut ne pas être réalisable pour des modèles très complexes ou des recherches approfondies d'hyperparamètres.

Découvrons maintenant la recherche aléatoire.

Recherche aléatoire est une autre technique de réglage des hyperparamètres qui explore des combinaisons aléatoires d'hyperparamètres dans des distributions ou des plages spécifiées. C'est particulièrement utile lorsqu'il s'agit d'un grand espace de recherche d'hyperparamètres.

Comment fonctionne la recherche aléatoire 

Dans la recherche aléatoire, au lieu de spécifier une grille de valeurs, vous pouvez définir des distributions ou des plages de probabilité pour chaque hyperparamètre. Ce qui devient un espace de recherche d’hyperparamètres beaucoup plus grand.

Recherche aléatoire alors des échantillons au hasard un nombre fixe de combinaisons d'hyperparamètres issus de ces distributions. Cela permet à la recherche aléatoire d’explorer efficacement un ensemble diversifié de combinaisons d’hyperparamètres.

Ajustons maintenant les paramètres du classificateur SVM de base à l'aide d'une recherche aléatoire.

Nous importons le RandomizedSearchCV classer et définir param_dist, un espace de recherche d'hyperparamètres beaucoup plus grand :

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform param_dist = { 'C': uniform(0.1, 10), # Uniform distribution between 0.1 and 10 'kernel': ['linear', 'rbf', 'poly'], 'gamma': ['scale', 'auto'] + list(np.logspace(-3, 3, 50))
}

Semblable à la recherche par grille, nous instancions le modèle de recherche aléatoire pour rechercher les meilleurs hyperparamètres. Ici, nous définissons n_iter à 20 ; donc 20 combinaisons aléatoires d'hyperparamètres seront échantillonnées.

# Create the RandomizedSearchCV object
randomized_search = RandomizedSearchCV(estimator=baseline_svm, param_distributions=param_dist, n_iter=20, cv=5) randomized_search.fit(X_train, y_train)

Nous évaluons ensuite les performances du modèle avec les meilleurs hyper paramètres trouvés grâce à la recherche aléatoire :

# Get the best hyperparameters and model
best_params_rand = randomized_search.best_params_
best_model_rand = randomized_search.best_estimator_ # Evaluate the best model
y_pred_best_rand = best_model_rand.predict(X_test)
accuracy_best_rand = accuracy_score(y_test, y_pred_best_rand)
print(f"Best SVM Accuracy: {accuracy_best_rand:.2f}")
print(f"Best Hyperparameters: {best_params_rand}")

La meilleure précision et les hyperparamètres optimaux sont :

Output >>>
Best SVM Accuracy: 0.94
Best Hyperparameters: {'C': 9.66495227534876, 'gamma': 6.25055192527397, 'kernel': 'poly'}

Les paramètres trouvés grâce à la recherche aléatoire sont différents de ceux trouvés grâce à la recherche par grille. Le modèle avec ces hyperparamètres atteint également un score de précision de 0.94.

Résumons les avantages de la recherche aléatoire :

• La recherche aléatoire est efficace lorsqu'il s'agit d'un grand nombre d'hyperparamètres ou d'une large plage de valeurs car elle ne nécessite pas une recherche exhaustive.
• Il peut gérer différents types de paramètres, notamment des valeurs continues et discrètes.

Voici quelques limites de la recherche aléatoire :

• En raison de sa nature aléatoire, il ne trouve pas toujours les meilleurs hyperparamètres. Mais il en trouve souvent rapidement de bons.
• Contrairement à la recherche par grille, elle ne garantit pas que toutes les combinaisons possibles seront explorées.

Nous avons appris à effectuer le réglage des hyperparamètres avec RandomizedSearchCV ainsi que GridSearchCV dans scikit-learn. Nous avons ensuite évalué les performances de notre modèle avec les meilleurs hyperparamètres. 

En résumé, la recherche par grille recherche de manière exhaustive toutes les combinaisons possibles dans la grille de paramètres. Tandis que la recherche aléatoire échantillonne de manière aléatoire les combinaisons d'hyperparamètres.

Ces deux techniques vous aident à identifier les hyperparamètres optimaux pour votre modèle d'apprentissage automatique tout en réduisant le risque de surajustement à une répartition train-test spécifique.
 
 

Bala Priya C est un développeur et rédacteur technique indien. Elle aime travailler à l'intersection des mathématiques, de la programmation, de la science des données et de la création de contenu. Ses domaines d'intérêt et d'expertise incluent DevOps, la science des données et le traitement du langage naturel. Elle aime lire, écrire, coder et prendre un café ! Actuellement, elle travaille à l'apprentissage et au partage de ses connaissances avec la communauté des développeurs en créant des didacticiels, des guides pratiques, des articles d'opinion, etc.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.kdnuggets.com/hyperparameter-tuning-gridsearchcv-and-randomizedsearchcv-explained?utm_source=rss&utm_medium=rss&utm_campaign=hyperparameter-tuning-gridsearchcv-and-randomizedsearchcv-explained