Appliquer la recherche par grille en utilisant Python : Un guide complet

Introduction

L'ajustement des hyperparamètres est une étape cruciale dans l'optimisation des modèles d'apprentissage automatique. L'une des techniques les plus efficaces pour l'ajustement des hyperparamètres est la recherche en grille, qui évalue systématiquement les combinaisons d'hyperparamètres pour trouver la configuration la plus performante.

Dans ce tutoriel, vous découvrirez comment appliquer la recherche sur grille en utilisant Python avec GridSearchCV de scikit-learn, comparer la recherche sur grille avec la recherche aléatoire, et explorer les meilleures pratiques pour éviter le surapprentissage et optimiser le temps d'exécution.

Qu'est-ce que la recherche par grille en Python ?

En apprentissage automatique, un hyperparamètre est un paramètre qui est choisi avant l'entraînement d'un modèle. Des exemples d'hyperparamètres incluent le taux d'apprentissage, la taille du lot et le nombre de couches cachées dans un réseau de neurones.

La bonne combinaison d'hyperparamètres peut avoir un impact significatif sur la performance d'un modèle. La recherche par grille est une méthode utilisée pour trouver la meilleure combinaison d'hyperparamètres pour un modèle en essayant systématiquement toutes les combinaisons possibles dans une plage spécifiée. Cette recherche exhaustive aide à identifier l'ensemble optimal d'hyperparamètres qui donne la meilleure performance du modèle.

Comment fonctionne la recherche par grille ?

Le processus de recherche par grille peut être décomposé en les étapes suivantes :

1. Définir un ensemble de valeurs d'hyperparamètres pour le modèle : Il s'agit de la plage de valeurs que la recherche par grille considérera pour chaque hyperparamètre. Par exemple, si vous réglez le taux d'apprentissage d'un réseau de neurones, vous pourriez définir une plage de valeurs de 0,001 à 0,1.

2. Entraînez le modèle en utilisant toutes les combinaisons possibles de ces hyperparamètres : La recherche par grille va alors entraîner le modèle en utilisant chaque combinaison possible d'hyperparamètres dans la plage définie. Par exemple, si vous avez 3 hyperparamètres et que chacun a 5 valeurs possibles, la recherche par grille entraînera le modèle 5^3=125 fois.

3. Évaluer les performances à l'aide de la validation croisée : Après avoir formé le modèle avec chaque combinaison d'hyperparamètres, la recherche en grille évaluera les performances du modèle à l'aide de la validation croisée. C'est une technique utilisée pour évaluer comment le modèle se généralisera à un ensemble de données indépendant.

4. Sélectionnez la meilleure combinaison d'hyperparamètres en fonction des métriques de performance : Enfin, la recherche par grille sélectionnera la combinaison d'hyperparamètres qui a entraîné la meilleure performance. Cela se fait généralement en choisissant la combinaison qui a abouti à la plus haute précision, mais cela peut également être basé sur d'autres métriques de performance telles que la précision, le rappel ou le score F1.

Le tableau suivant illustre comment fonctionne une recherche en grille :

Dans ce tableau, chaque ligne représente une combinaison différente d'hyperparamètres, et la dernière colonne représente la performance du modèle lorsqu'il est entraîné avec cette combinaison. L'objectif de la recherche en grille est de trouver la combinaison d'hyperparamètres qui donne la meilleure performance.

Implémentation de la recherche par grille en Python

Dans cette section, vous apprendrez l'implémentation étape par étape de la recherche par grille en Python en utilisant la classe GridSearchCV de scikit-learn. Vous utiliserez un exemple simple d'ajustement des hyperparamètres d'un modèle de machine à vecteurs de support (SVM).

Étape 1 - Importer les bibliothèques

Tout d'abord, nous devons importer les bibliothèques nécessaires. Nous utiliserons scikit-learn pour le modèle SVM et la recherche de grille, et numpy pour la manipulation des données.

import numpy as np
from sklearn import svm
from sklearn.model_selection import GridSearchCV

Étape 2 - Charger les données

Ensuite, vous chargerez le jeu de données. Pour cet exemple, vous utiliserez le jeu de données iris, qui est un jeu de données populaire en apprentissage automatique.

from sklearn import datasets
iris = datasets.load_iris()
Inspect the dataset
print("Dataset loaded successfully.")
print("Dataset shape:", iris.data.shape)
print("Number of classes:", len(np.unique(iris.target)))
print("Class names:", iris.target_names)
print("Feature names:", iris.feature_names)

Dataset loaded successfully.
Dataset shape: (150, 4)
Number of classes: 3
Class names: ['setosa' 'versicolor' 'virginica']
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

Étape 3 - Définir le modèle et les hyperparamètres

Maintenant, vous allez définir le modèle SVM et les hyperparamètres que vous souhaitez ajuster. Pour le modèle SVM, vous allez ajuster les hyperparamètres du noyau et de C.

This code block initializes a Support Vector Machine (SVM) model and defines a parameter grid for hyperparameter tuning.
The SVM model is created using the svm.SVC() function from the scikit-learn library.
The parameter grid is a dictionary that specifies the hyperparameters to be tuned and their possible values.
In this case, the hyperparameters are 'C' (regularization parameter) and 'kernel' (type of kernel to use).
The values for 'C' are [1, 10, 100, 1000], indicating that the model will be trained with these different regularization strengths.
The values for 'kernel' are ['linear', 'rbf'], indicating that the model will be trained with both linear and radial basis function (RBF) kernels.
model = svm.SVC()
param_grid = {'C': [1, 10, 100, 1000], 'kernel': ['linear', 'rbf']}

Étape 4 - Effectuer une recherche en grille

Dans cette étape, vous allez exécuter une recherche sur grille en utilisant la classe GridSearchCV de scikit-learn. Le but d'une recherche sur grille est de trouver les hyperparamètres optimaux pour votre modèle en essayant systématiquement toutes les combinaisons possibles d'hyperparamètres spécifiés et en évaluant leur performance à l'aide de la validation croisée.

Ici, vous utiliserez une validation croisée à 5 plis (cv=5) pour évaluer la performance de chaque combinaison d'hyperparamètres. Cela signifie que le jeu de données sera divisé en 5 sous-ensembles, et le modèle sera entraîné et évalué sur chaque sous-ensemble. La performance moyenne de ces sous-ensembles sera utilisée pour déterminer les meilleurs hyperparamètres.

grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(iris.data, iris.target)

Le bloc de code ci-dessus initialise un objet GridSearchCV avec les paramètres suivants :

• modèle: Le modèle SVM défini précédemment.
• param_grid : Le dictionnaire spécifiant les hyperparamètres à ajuster et leurs valeurs possibles.
• cv=5 : Le nombre de plis pour la validation croisée.

La méthode fit est ensuite appelée sur l'objet grid_search, en passant les données des caractéristiques (iris.data) et les valeurs cibles (iris.target). Cela lance le processus de recherche en grille, qui évaluera les performances du modèle pour chaque combinaison d'hyperparamètres et identifiera le meilleur ensemble d'hyperparamètres.

Étape 5 - Voir les résultats

Enfin, vous pouvez voir les résultats de la recherche sur grille. Les meilleurs hyperparamètres et le score de précision correspondant seront affichés.

print("Best hyperparameters: ", grid_search.best_params_)
print("Best accuracy: ", grid_search.best_score_)

Visualizing the best hyperparameters
import matplotlib.pyplot as plt
import numpy as np

C_values = [1, 10, 100, 1000]
kernel_values = ['linear', 'rbf']
scores = grid_search.cv_results_['mean_test_score'].reshape(len(C_values), len(kernel_values))

plt.figure(figsize=(8, 6))
plt.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95)
plt.imshow(scores, interpolation='nearest', cmap=plt.cm.hot)
plt.xlabel('kernel')
plt.ylabel('C')
plt.colorbar()
plt.xticks(np.arange(len(kernel_values)), kernel_values)
plt.yticks(np.arange(len(C_values)), C_values)
plt.title('Grid Search Mean Test Scores')
plt.show()

Best hyperparameters:  {'C': 1, 'kernel': 'linear'}
Best accuracy:  0.9800000000000001

La meilleure valeur pour l'hyperparamètre ‘C’ est 1, qui contrôle la force de régularisation. Une valeur plus petite de ‘C’ signifie une régularisation plus forte. La meilleure valeur pour l'hyperparamètre ‘kernel’ est ‘linéaire’, qui spécifie le type de noyau à utiliser dans l'algorithme.

La meilleure précision atteinte avec ces hyperparamètres est de 0,98, ce qui indique que le modèle prédit correctement 98% des instances dans le processus de validation croisée.

C'est ça ! Vous avez maintenant mis en œuvre une recherche sur grille en Python. Vous pouvez appliquer cette technique pour ajuster les hyperparamètres de n'importe quel modèle d'apprentissage automatique.

Recherche en grille vs. Recherche aléatoire

Une autre technique populaire de réglage des hyperparamètres est la recherche aléatoire, qui sélectionne des combinaisons d'hyperparamètres aléatoires au lieu de tester toutes les possibilités.

from sklearn.model_selection import RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

Load dataset and split into training and test sets
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

Define the parameter grid
param_distributions = {'C': [1, 10, 100, 1000], 'kernel': ['linear', 'rbf']}

Initialize the RandomizedSearchCV object
random_search = RandomizedSearchCV(SVC(), param_distributions=param_distributions, n_iter=5, cv=5, scoring='accuracy', random_state=42)

Fit the model
random_search.fit(X_train, y_train)

Print the best parameters
print("Best Parameters:", random_search.best_params_)

Best Parameters: {'kernel': 'linear', 'C': 1}

Quand utiliser la recherche par grille vs. la recherche aléatoire ?

Le choix entre la recherche par grille et la recherche aléatoire dépend de plusieurs facteurs, y compris la taille de l'espace des hyperparamètres, les ressources informatiques disponibles et les exigences spécifiques de votre projet d'apprentissage automatique.

La recherche par grille est idéale quand :

• L'espace des hyperparamètres est petit : Si le nombre d'hyperparamètres et leurs valeurs possibles sont limités, la recherche par grille peut explorer efficacement toutes les combinaisons.
• Les ressources computationnelles sont abondantes : Étant donné que la recherche par grille est intensivement computationnelle, elle est appropriée lorsque vous avez accès à un matériel puissant ou à des ressources cloud.
• Une Précision Élevée est Cruciale : La recherche par grille peut potentiellement donner une précision plus élevée en explorant de manière exhaustive toutes les combinaisons possibles, ce qui la rend adaptée aux applications critiques où la performance est primordiale.
• Simples modèles : Cela fonctionne bien avec des modèles plus simples qui ont moins d'hyperparamètres, garantissant que la recherche exhaustive reste réalisable.

La recherche aléatoire est préférable lorsque :

• L'espace des hyperparamètres est vaste: Pour les modèles avec un grand nombre d'hyperparamètres ou une large gamme de valeurs possibles, la recherche aléatoire peut échantillonner efficacement l'espace sans avoir besoin d'une recherche exhaustive.
• Ressources de calcul limitées: La recherche aléatoire est moins exigeante en termes de calcul, ce qui la rend adaptée aux scénarios avec des ressources matérielles ou des contraintes de temps limitées.
• Des résultats plus rapides sont nécessaires: Si vous avez besoin de résultats plus rapides et êtes prêt à sacrifier un peu de précision, la recherche aléatoire peut offrir un bon équilibre entre performance et coût computationnel.
• Modèles complexes : Il est plus adapté aux modèles complexes avec de nombreux hyperparamètres, où une recherche exhaustive serait impraticable.

En résumé, utilisez la recherche par grille lorsque vous avez un espace de hyperparamètres plus petit et que vous pouvez vous permettre le coût computationnel pour une précision potentiellement plus élevée. Optez pour la recherche aléatoire lorsque vous traitez avec des espaces de hyperparamètres plus grands, des ressources limitées, ou lorsque des résultats plus rapides sont nécessaires.

Optimiser le temps d'exécution de la recherche en grille

La recherche en grille peut être coûteuse en termes de calcul en raison de la nature exhaustive de l'évaluation de toutes les combinaisons possibles d'hyperparamètres. Voici quelques stratégies pour optimiser le temps d'exécution de la recherche en grille :

1. Utilisez un espace de recherche plus petit : En limitant le nombre d'hyperparamètres et leurs valeurs possibles, vous pouvez réduire considérablement la charge computationnelle. Par exemple, au lieu de tester une large gamme de valeurs pour chaque hyperparamètre, concentrez-vous sur un sous-ensemble plus petit et plus pertinent. Cela peut être réalisé en réalisant des expériences préliminaires pour identifier les plages d'hyperparamètres les plus prometteuses.

2. Utilisez le traitement parallèle : La recherche en grille peut être parallélisée pour tirer parti de plusieurs cœurs CPU, ce qui accélère le calcul. Dans GridSearchCV, vous pouvez définir le paramètre n_jobs sur -1 pour utiliser tous les cœurs disponibles. Cela permet à la recherche en grille d'évaluer plusieurs combinaisons d'hyperparamètres simultanément, réduisant ainsi le temps de recherche global.

3. Utilisez un ensemble de données plus petit pour l'ajustement: Effectuez un réglage des hyperparamètres sur un sous-ensemble plus petit de vos données pour identifier rapidement les meilleures combinaisons d'hyperparamètres. Une fois les paramètres optimaux trouvés, vous pouvez les appliquer à l'ensemble de données complet pour l'entraînement final du modèle. Cette approche peut faire économiser un temps considérable, en particulier lors de la manipulation de grands ensembles de données.

4. Utiliser des techniques d'arrêt précoce : Certaines bibliothèques d'apprentissage automatique, telles que XGBoost, prennent en charge l'arrêt précoce. Cette technique permet d'interrompre le processus d'entraînement si les performances du modèle cessent de s'améliorer sur un ensemble de validation. En réduisant le nombre d'itérations, l'arrêt précoce peut aider à accélérer le processus de recherche par grille tout en identifiant des hyperparamètres efficaces.

En mettant en œuvre ces stratégies, vous pouvez rendre le processus de recherche sur grille plus efficace et gérable, même en traitant des modèles complexes et de grands ensembles de données.

FAQ

1. Que fait GridSearchCV() ?

GridSearchCV automatise l'ajustement des hyperparamètres en effectuant une validation croisée pour trouver la meilleure combinaison d'hyperparamètres.

2. Comment appliquer la recherche par grille en Python ?

Vous pouvez utiliser GridSearchCV de scikit-learn pour entraîner un modèle avec différentes valeurs d'hyperparamètres et sélectionner la meilleure.

3. Quelle est la différence entre la recherche aléatoire et la recherche par grille ?

• La recherche en grille teste toutes les combinaisons possibles de manière exhaustive.

• La recherche aléatoire sélectionne des combinaisons aléatoires, réduisant le temps de calcul.

4. Que fait grid() en Python ?

Dans matplotlib ou les frameworks GUI, .grid() est utilisé pour créer une mise en page en grille. Cela n'a rien à voir avec la recherche en grille en apprentissage automatique.

5. Comment appliquer la recherche par grille ?

Pour appliquer une recherche par grille en Python, vous pouvez utiliser la classe GridSearchCV de scikit-learn en suivant ces étapes :

1. Importer les bibliothèques nécessaires.
2. Définissez votre modèle et les hyperparamètres que vous souhaitez ajuster.
3. Créez un objet GridSearchCV en fournissant le modèle, un dictionnaire d'hyperparamètres et vos paramètres de validation croisée souhaités.
4. Ajustez l'objet GridSearchCV à votre ensemble de données.
5. Récupérez les meilleurs hyperparamètres et évaluez votre modèle.

Voici un exemple qui démontre le processus :

import numpy as np
from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV

Load the iris dataset
iris = datasets.load_iris()

Define the SVM model
model = svm.SVC()

Set up the hyperparameter grid
param_grid = {
    'C': [1, 10, 100],
    'kernel': ['linear', 'rbf']
}

Create a GridSearchCV object with 5-fold cross-validation
grid_search = GridSearchCV(model, param_grid, cv=5)

Fit the grid search to the data
grid_search.fit(iris.data, iris.target)

Retrieve and display the best hyperparameters and corresponding score
print("Best hyperparameters:", grid_search.best_params_)
print("Best cross-validation score:", grid_search.best_score_)

Cet exemple ajuste un classificateur SVM sur le jeu de données iris en recherchant différentes valeurs pour le paramètre de régularisation et le type de noyau.

6. Comment effectuer une recherche par grille pour des personnes disparues ?

Bien que le terme « recherche en grille » soit renommé dans l'apprentissage automatique pour l'optimisation des hyperparamètres, appliquer son concept pour localiser des personnes disparues implique d'adapter une stratégie de recherche systématique. En pratique, cela signifie diviser la zone de recherche en une grille structurée, puis explorer méthodiquement chaque segment. Voici comment cela peut fonctionner :

1. Divisez la zone de recherche en cellules de grille égales pour garantir que chaque zone soit couverte.
2. Affecter des équipes ou déployer des ressources (par exemple, des drones, des bénévoles) à chaque segment de grille.
3. Recherchez systématiquement chaque cellule, en veillant à ne pas avoir de chevauchements.
4. Ajustez la grille en fonction du terrain, des données d'analyse ou des indices émergents pour se concentrer sur les zones à priorité plus élevée.

Cette approche basée sur une grille aide à organiser les opérations de recherche et garantit une couverture complète, bien que les recherches dans le monde réel nécessitent également une coordination avec les autorités locales et les services d'urgence.

Conclusion

La recherche par grille est une méthode puissante pour le réglage des hyperparamètres dans les modèles d'apprentissage automatique. Bien qu'elle offre une sélection optimale des paramètres, elle peut être coûteuse en termes de calcul, rendant la recherche aléatoire une alternative utile. En suivant les meilleures pratiques, telles que la limitation de l'espace de recherche et l'utilisation du traitement parallèle, vous pouvez optimiser efficacement les performances du modèle.

Pour des tutoriels de machine learning plus avancés, consultez :

1. Comment construire un modèle d'apprentissage profond.

2. Boosting par gradient pour la classification.

3. Validation croisée K-Fold en Python.