Itérations par division successive

Introduction

Dans ce laboratoire, vous allez apprendre à utiliser la méthode de recherche par division successive pour choisir itérativement la meilleure combinaison de paramètres parmi plusieurs candidats. Cette méthode est implémentée dans les classes HalvingGridSearchCV et HalvingRandomSearchCV de la bibliothèque Scikit-learn. La classe HalvingRandomSearchCV sera utilisée dans ce laboratoire.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques requises

Les bibliothèques suivantes seront utilisées dans ce laboratoire : pandas, numpy, matplotlib, sklearn.datasets, RandomForestClassifier, randint et HalvingRandomSearchCV. Importez-les à l'aide du code suivant :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint
from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingRandomSearchCV

Chargement du jeu de données

La fonction make_classification du module sklearn.datasets est utilisée pour générer un jeu de données de classification. Le jeu de données contient 400 échantillons avec 12 caractéristiques. Le code pour charger le jeu de données est le suivant :

rng = np.random.RandomState(0)
X, y = datasets.make_classification(n_samples=400, n_features=12, random_state=rng)

Définition de l'espace de paramètres

Définissez un dictionnaire param_dist qui contient les hyperparamètres et leurs valeurs respectives à explorer. Les hyperparamètres sont max_depth, max_features, min_samples_split, bootstrap et criterion. La plage de recherche pour max_features et min_samples_split est définie à l'aide de la fonction randint du module scipy.stats. Le code pour définir l'espace de paramètres est le suivant :

param_dist = {
    "max_depth": [3, None],
    "max_features": randint(1, 6),
    "min_samples_split": randint(2, 11),
    "bootstrap": [True, False],
    "criterion": ["gini", "entropy"],
}

Création d'un objet de recherche aléatoire par division successive

Créez un objet HalvingRandomSearchCV pour explorer l'espace de paramètres. L'objet prend les arguments suivants :

• estimator : l'estimateur à optimiser
• param_distributions : l'espace de paramètres à explorer
• factor : le facteur par lequel le nombre de candidats est réduit à chaque itération
• random_state : l'état aléatoire utilisé pour la recherche

Le code pour créer l'objet est le suivant :

clf = RandomForestClassifier(n_estimators=20, random_state=rng)
rsh = HalvingRandomSearchCV(
    estimator=clf, param_distributions=param_dist, factor=2, random_state=rng
)

Ajustement de l'objet de recherche aléatoire par division successive

Ajustez l'objet HalvingRandomSearchCV au jeu de données à l'aide de la méthode fit. Le code pour ajuster l'objet est le suivant :

rsh.fit(X, y)

Analyse des résultats

L'attribut cv_results_ de l'objet de recherche contient les résultats de la recherche. Convertissez-le en un DataFrame pandas à l'aide du code suivant :

results = pd.DataFrame(rsh.cv_results_)

La colonne params_str est créée en convertissant la colonne params en chaîne de caractères. Supprimez les lignes dupliquées qui ont les mêmes valeurs pour params_str et iter :

results["params_str"] = results.params.apply(str)
results.drop_duplicates(subset=("params_str", "iter"), inplace=True)

Les scores moyens de test sont ensuite pivotés par rapport au numéro d'itération et à la combinaison de paramètres à l'aide de la méthode pivot :

mean_scores = results.pivot(
    index="iter", columns="params_str", values="mean_test_score"
)

Enfin, tracez les scores moyens de test au cours des itérations à l'aide du code suivant :

ax = mean_scores.plot(legend=False, alpha=0.6)

labels = [
    f"itération={i}\nn_échantillons={rsh.n_resources_[i]}\nn_candidats={rsh.n_candidates_[i]}"
    for i in range(rsh.n_iterations_)
]

ax.set_xticks(range(rsh.n_iterations_))
ax.set_xticklabels(labels, rotation=45, multialignment="left")
ax.set_title("Scores des candidats au cours des itérations")
ax.set_ylabel("score moyen de test", fontsize=15)
ax.set_xlabel("itérations", fontsize=15)
plt.tight_layout()
plt.show()

Interprétation des résultats

Le graphique montre les scores moyens de test des candidats au cours des itérations. À la première itération, tous les candidats sont évalués avec une petite quantité de ressources. À la deuxième itération, seulement la moitié des meilleurs candidats est évaluée avec le double de la quantité de ressources. Ce processus est répété jusqu'à la dernière itération, où seulement 2 candidats restent. Le meilleur candidat est celui avec le score moyen de test le plus élevé à la dernière itération.

Sommaire

Dans ce laboratoire, vous avez appris à utiliser la méthode de recherche par division successive pour choisir itérativement la meilleure combinaison de paramètres parmi plusieurs candidats. La classe HalvingRandomSearchCV de la bibliothèque Scikit-learn a été utilisée pour implémenter la méthode de recherche. Les résultats de la recherche ont été analysés et interprétés à l'aide d'un graphique des scores moyens de test au cours des itérations.