Équilibrer la complexité du modèle et le score de validation croisée

Introduction

Dans ce laboratoire, nous allons apprendre à équilibrer la complexité du modèle et le score de validation croisée en trouvant une précision correcte à l'intérieur de 1 écart-type du meilleur score de précision tout en minimisant le nombre de composants PCA. Nous utiliserons le jeu de données digits de scikit-learn et un pipeline composé de PCA et de LinearSVC.

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églerons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous allons commencer par importer les bibliothèques nécessaires pour ce laboratoire.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC

Définition de fonctions

Nous allons définir deux fonctions qui seront utilisées plus tard dans le laboratoire.

def lower_bound(cv_results):
    """
    Calculer la borne inférieure à l'intérieur d'un écart-type
    du meilleur `mean_test_scores`.

    Paramètres
    ----------
    cv_results : dict de ndarrays numpy(masked)
        Voir l'attribut cv_results_ de `GridSearchCV`

    Retours
    -------
    float
        Borne inférieure à l'intérieur d'un écart-type du
        meilleur `mean_test_score`.
    """
    best_score_idx = np.argmax(cv_results["mean_test_score"])

    return (
        cv_results["mean_test_score"][best_score_idx]
        - cv_results["std_test_score"][best_score_idx]
    )


def best_low_complexity(cv_results):
    """
    Équilibrer la complexité du modèle avec le score de validation croisée.

    Paramètres
    ----------
    cv_results : dict de ndarrays numpy(masked)
        Voir l'attribut cv_results_ de `GridSearchCV`.

    Retour
    ------
    int
        Index d'un modèle qui a le nombre minimum de composants PCA
        tout en ayant son score de test à l'intérieur d'un écart-type du meilleur
        `mean_test_score`.
    """
    threshold = lower_bound(cv_results)
    candidate_idx = np.flatnonzero(cv_results["mean_test_score"] >= threshold)
    best_idx = candidate_idx[
        cv_results["param_reduce_dim__n_components"][candidate_idx].argmin()
    ]
    return best_idx

Charger les données et définir le pipeline

Nous allons charger le jeu de données digits de scikit-learn et définir un pipeline composé de PCA et de LinearSVC.

pipe = Pipeline(
    [
        ("reduce_dim", PCA(random_state=42)),
        ("classify", LinearSVC(random_state=42, C=0.01, dual="auto")),
    ]
)

X, y = load_digits(return_X_y=True)

Définir les paramètres pour GridSearchCV

Nous allons définir les paramètres pour GridSearchCV.

param_grid = {"reduce_dim__n_components": [6, 8, 10, 12, 14]}

Définir l'objet GridSearchCV

Nous allons définir l'objet GridSearchCV et ajuster le modèle.

grid = GridSearchCV(
    pipe,
    cv=10,
    n_jobs=1,
    param_grid=param_grid,
    scoring="accuracy",
    refit=best_low_complexity,
)

grid.fit(X, y)

Visualiser les résultats

Nous allons visualiser les résultats en traçant la précision en fonction du nombre de composants PCA.

n_components = grid.cv_results_["param_reduce_dim__n_components"]
test_scores = grid.cv_results_["mean_test_score"]

plt.figure()
plt.bar(n_components, test_scores, width=1.3, color="b")

lower = lower_bound(grid.cv_results_)
plt.axhline(np.max(test_scores), linestyle="--", color="y", label="Meilleur score")
plt.axhline(lower, linestyle="--", color=".5", label="Meilleur score - 1 écart-type")

plt.title("Équilibrer la complexité du modèle et le score de validation croisée")
plt.xlabel("Nombre de composants PCA utilisés")
plt.ylabel("Précision de classification des chiffres")
plt.xticks(n_components.tolist())
plt.ylim((0, 1.0))
plt.legend(loc="upper left")

best_index_ = grid.best_index_

print("Le best_index_ est %d" % best_index_)
print("Le nombre de composants PCA sélectionnés est %d" % n_components[best_index_])
print(
    "Le score de précision correspondant est %.2f"
    % grid.cv_results_["mean_test_score"][best_index_]
)
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à équilibrer la complexité du modèle et le score de validation croisée en utilisant la PCA et la LinearSVC. Nous avons utilisé GridSearchCV pour trouver le meilleur nombre de composants PCA tout en maximisant le score de précision dans un écart-type du meilleur score. Nous avons également visualisé les résultats pour mieux comprendre le compromis entre la complexité du modèle et la précision.