Optimiser les modèles de machine learning avec Pipeline et GridSearchCV

Introduction

Ce laboratoire démontre l'utilisation de Pipeline et GridSearchCV dans scikit-learn pour optimiser différents types d'estimateurs lors d'un seul entraînement par validation croisée. Nous utiliserons un classifieur à vecteurs de support pour prédire des chiffres manuscrits à partir de l'ensemble de données MNIST populaire.

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 limites 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.

Importez les bibliothèques nécessaires et chargez les données

Nous commencerons par importer les bibliothèques nécessaires et charger l'ensemble de données de chiffres à partir de scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.decomposition import PCA, NMF
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.preprocessing import MinMaxScaler

X, y = load_digits(return_X_y=True)

Créez un pipeline et définissez la grille de paramètres

Nous allons créer un pipeline qui effectue une réduction de dimensionnalité suivie d'une prédiction avec un classifieur à vecteurs de support. Nous utiliserons des réductions de dimensionnalité non supervisées PCA et NMF, ainsi qu'une sélection de caractéristiques univariée lors de la recherche en grille.

pipe = Pipeline(
    [
        ("scaling", MinMaxScaler()),
        ## l'étape reduce_dim est remplie par param_grid
        ("reduce_dim", "passthrough"),
        ("classify", LinearSVC(dual=False, max_iter=10000)),
    ]
)

N_FEATURES_OPTIONS = [2, 4, 8]
C_OPTIONS = [1, 10, 100, 1000]
param_grid = [
    {
        "reduce_dim": [PCA(iterated_power=7), NMF(max_iter=1_000)],
        "reduce_dim__n_components": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
    {
        "reduce_dim": [SelectKBest(mutual_info_classif)],
        "reduce_dim__k": N_FEATURES_OPTIONS,
        "classify__C": C_OPTIONS,
    },
]
reducer_labels = ["PCA", "NMF", "KBest(mutual_info_classif)"]

Créez un objet GridSearchCV et ajustez les données

Nous allons créer un objet GridSearchCV en utilisant le pipeline et la grille de paramètres que nous avons définis dans l'étape précédente. Nous allons ensuite ajuster les données à l'objet.

grid = GridSearchCV(pipe, n_jobs=1, param_grid=param_grid)
grid.fit(X, y)

Tracer les résultats

Nous allons tracer les résultats de GridSearchCV à l'aide d'un graphique en barres. Cela nous permettra de comparer la précision de différentes techniques de réduction de caractéristiques.

import pandas as pd

mean_scores = np.array(grid.cv_results_["mean_test_score"])
## les scores sont dans l'ordre de l'itération de param_grid, qui est alphabétique
mean_scores = mean_scores.reshape(len(C_OPTIONS), -1, len(N_FEATURES_OPTIONS))
## sélectionnez le score pour le meilleur C
mean_scores = mean_scores.max(axis=0)
## créez un DataFrame pour faciliter la tracé
mean_scores = pd.DataFrame(
    mean_scores.T, index=N_FEATURES_OPTIONS, columns=reducer_labels
)

ax = mean_scores.plot.bar()
ax.set_title("Comparaison des techniques de réduction de caractéristiques")
ax.set_xlabel("Nombre réduit de caractéristiques")
ax.set_ylabel("Précision de la classification de chiffres")
ax.set_ylim((0, 1))
ax.legend(loc="upper left")

plt.show()

Mémorisation des transformateurs dans un Pipeline

Nous allons maintenant démontrer comment stocker l'état d'un transformateur spécifique, car il pourrait être utilisé à nouveau. L'utilisation d'un pipeline dans GridSearchCV déclenche de telles situations. Par conséquent, nous utilisons l'argument memory pour activer la mémorisation.

from joblib import Memory
from shutil import rmtree

## Créez un dossier temporaire pour stocker les transformateurs du pipeline
location = "cachedir"
memory = Memory(location=location, verbose=10)
cached_pipe = Pipeline(
    [("reduce_dim", PCA()), ("classify", LinearSVC(dual=False, max_iter=10000))],
    memory=memory,
)

## Cette fois, un pipeline mis en cache sera utilisé dans la recherche en grille

## Supprimez le cache temporaire avant de quitter
memory.clear(warn=False)
rmtree(location)

Sommaire

Dans ce laboratoire, nous avons utilisé Pipeline et GridSearchCV dans scikit-learn pour optimiser différents types d'estimateurs au cours d'un seul entraînement par validation croisée. Nous avons également démontré comment stocker l'état d'un transformateur spécifique en utilisant l'argument memory pour activer la mémorisation. Cela peut s'avérer particulièrement utile lorsque l'ajustement d'un transformateur est coûteux.

Réduction de la dimensionalité avec Pipeline et GridSearchCV