RandomSearch

RandomSearch est une méthode utilisée pour optimiser les hyperparamètres d’un modèle d’apprentissage supervisé en explorant aléatoirement un espace défini de valeurs possibles. L’objectif est de trouver rapidement une combinaison d’hyperparamètres qui améliore la performance du modèle.

Le principe consiste à définir un espace de valeurs pour chaque hyperparamètre et à échantillonner un certain nombre de combinaisons aléatoires. Chaque combinaison est évaluée, généralement via une validation croisée, et la meilleure configuration est sélectionnée pour le modèle final.

RandomSearch est utilisé en science des données et machine learning pour optimiser des modèles lorsque l’espace des hyperparamètres est vaste et que l’exploration exhaustive (comme avec GridSearch) serait trop coûteuse en temps de calcul.

Les performances peuvent être évaluées à l’aide de métriques adaptées au problème, comme l’exactitude, la précision, le rappel, la F1-score ou l’erreur quadratique moyenne.

En résumé, RandomSearch permet de trouver efficacement de bonnes combinaisons d’hyperparamètres en explorant l’espace de manière aléatoire et contrôlée.

Fonctions :

RandomizedSearchCV()

La fonction RandomizedSearchCV() de la bibliothèque sklearn.model_selection permet d'effectuer une recherche aléatoire sur une grille d'hyperparamètres pour un modèle d'apprentissage automatique. Contrairement à GridSearchCV(), qui explore toutes les combinaisons possibles d'hyperparamètres, RandomizedSearchCV() sélectionne aléatoirement un certain nombre de combinaisons à partir de la grille d'hyperparamètres. Cela permet de réduire le temps de calcul tout en trouvant des hyperparamètres performants, en particulier lorsqu'il existe une grande quantité de paramètres à tester.

Importation :

from sklearn.model_selection import RandomizedSearchCV

Attributs :

Paramètre	Description
`estimator`	Le modèle à ajuster (par exemple, un classificateur ou un régression). C'est l'objet qui sera optimisé avec les hyperparamètres.
`param_distributions`	Dictionnaire ou liste de dictionnaires, où les clés sont les hyperparamètres à tester et les valeurs sont des distributions ou des listes de valeurs possibles pour ces paramètres.
`n_iter`	Le nombre d'itérations à effectuer pour la recherche aléatoire. Plus ce nombre est élevé, plus il y a de chances de trouver de bonnes combinaisons de paramètres.
`scoring`	La méthode de scoring à utiliser pour évaluer les performances du modèle. Par défaut, il est défini à `None`, ce qui signifie que la méthode `score` du modèle sera utilisée.
`cv`	Le nombre de splits pour la validation croisée. Par défaut, il est défini à 5.
`n_jobs`	Le nombre de processus à utiliser pour la recherche en parallèle. Par défaut, il est défini à 1 (aucune parallélisation).
`verbose`	Le niveau de verbosité du processus de recherche. Par défaut, il est défini à 0 (pas de sortie).
`refit`	Si `True`, le modèle sera réajusté avec les meilleurs hyperparamètres trouvés. Par défaut, il est défini à `True`.
`random_state`	Générateur de nombres aléatoires pour le contrôle des tirages aléatoires dans la recherche. Cela permet de reproduire les résultats.

Exemple de code :

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
from scipy.stats import uniform

# Chargement du jeu de données Iris
data = load_iris()
X = data.data
y = data.target

# Division des données en train et test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Définition du modèle à optimiser
model = SVC()

# Définition de la grille d'hyperparamètres sous forme de distributions
param_dist = {
    'C': uniform(loc=0, scale=10),  # Distribution uniforme pour C
    'kernel': ['linear', 'rbf'],    # Valeurs possibles pour kernel
    'gamma': ['scale', 'auto']      # Valeurs possibles pour gamma
}

# Initialisation de RandomizedSearchCV
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_dist, n_iter=100, cv=5, verbose=1, random_state=42)

# Ajustement du modèle avec la recherche aléatoire
random_search.fit(X_train, y_train)

# Affichage des meilleurs hyperparamètres
print(f"Meilleurs hyperparamètres : {random_search.best_params_}")

# Évaluation du modèle avec les meilleurs paramètres
best_model = random_search.best_estimator_
accuracy = best_model.score(X_test, y_test)
print(f"Précision sur le jeu de test : {accuracy:.4f}")

Explication du code :

Chargement des données :
- Le jeu de données Iris est chargé avec load_iris() et contient des informations sur les fleurs d'iris avec des caractéristiques comme la longueur et la largeur des pétales et des sépales.
Séparation des données :
- Les données sont divisées en ensembles d'entraînement et de test à l'aide de train_test_split(). 70 % des données sont utilisées pour l'entraînement et 30 % pour le test.
Définition du modèle :
- Nous choisissons un modèle SVM (SVC()) pour la classification des fleurs.
Grille d'hyperparamètres :
- Nous définissons une grille d'hyperparamètres à tester. Pour l'hyperparamètre C, nous utilisons une distribution uniforme (uniform(loc=0, scale=10)), ce qui signifie que nous tirons des valeurs aléatoires pour C entre 0 et 10. Les paramètres kernel et gamma prennent des valeurs discrètes, à savoir 'linear' et 'rbf' pour kernel et 'scale' et 'auto' pour gamma.
Initialisation de RandomizedSearchCV :
- Nous initialisons RandomizedSearchCV en spécifiant le modèle SVC(), la distribution des paramètres param_dist, le nombre d'itérations n_iter=100 (qui détermine le nombre de combinaisons d'hyperparamètres à tester), le nombre de splits pour la validation croisée (cv=5), la verbosité pour afficher les informations de progression (verbose=1) et un random_state pour assurer la reproductibilité des résultats.
Ajustement du modèle :
- random_search.fit() ajuste le modèle sur les données d'entraînement, en testant différentes combinaisons d'hyperparamètres tirées de la distribution spécifiée.
Affichage des meilleurs paramètres :
- random_search.best_params_ renvoie les meilleurs hyperparamètres trouvés pendant la recherche.
Évaluation avec les meilleurs paramètres :
- Nous utilisons le modèle avec les meilleurs paramètres (random_search.best_estimator_) pour effectuer des prédictions sur le jeu de test et calculer la précision avec score().

Points importants :

Recherche aléatoire : RandomizedSearchCV() sélectionne aléatoirement des combinaisons d'hyperparamètres, ce qui permet de réduire le nombre d'itérations par rapport à GridSearchCV() et de gagner du temps tout en explorant efficacement l'espace des paramètres.
Distributions de paramètres : Contrairement à GridSearchCV(), qui teste des valeurs spécifiques, RandomizedSearchCV() permet d'utiliser des distributions de paramètres pour générer des valeurs aléatoires pour chaque hyperparamètre, ce qui peut conduire à de meilleures performances dans un espace de recherche plus large.
Parallélisation : Le paramètre n_jobs peut être utilisé pour paralléliser les calculs et accélérer la recherche. Par exemple, n_jobs=-1 utilise tous les processeurs disponibles pour accélérer le processus de recherche.

Applications courantes :

Optimisation des hyperparamètres : Idéal pour les cas où vous avez un grand espace d'hyperparamètres à tester, et que vous ne pouvez pas vous permettre d'explorer toutes les combinaisons possibles.
Recherche rapide dans un grand espace de paramètres : Lorsque vous avez beaucoup de paramètres à tester, RandomizedSearchCV() permet de trouver des combinaisons efficaces plus rapidement qu'une recherche exhaustive.