Equilibrar la complejidad del modelo y la puntuación validada cruzada

Introducción

En este laboratorio, aprenderemos a equilibrar la complejidad del modelo y la puntuación validada cruzada al encontrar una precisión decente dentro de 1 desviación estándar de la mejor puntuación de precisión mientras minimizamos el número de componentes PCA. Utilizaremos el conjunto de datos de dígitos de scikit-learn y una tubería que consta de PCA y LinearSVC.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias para este laboratorio.

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

Definir funciones

Definiremos dos funciones que se utilizarán más adelante en el laboratorio.

def lower_bound(cv_results):
    """
    Calcular el límite inferior dentro de 1 desviación estándar
    de la mejor `mean_test_scores`.

    Parámetros
    ----------
    cv_results : dict de ndarrays de numpy(masked)
        Ver atributo cv_results_ de `GridSearchCV`

    Devuelve
    -------
    float
        Límite inferior dentro de 1 desviación estándar de la
        mejor `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):
    """
    Equilibrar la complejidad del modelo con la puntuación validada cruzada.

    Parámetros
    ----------
    cv_results : dict de ndarrays de numpy(masked)
        Ver atributo cv_results_ de `GridSearchCV`.

    Devuelve
    ------
    int
        Índice de un modelo que tiene el menor número de componentes PCA
        mientras que su puntuación de prueba está dentro de 1 desviación estándar de la mejor
        `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

Cargar datos y definir tubería

Cargaremos el conjunto de datos de dígitos de scikit-learn y definiremos una tubería que consta de PCA y 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)

Definir parámetros para GridSearchCV

Definiremos los parámetros para GridSearchCV.

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

Definir objeto GridSearchCV

Definiremos el objeto GridSearchCV y ajustaremos el modelo.

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

grid.fit(X, y)

Visualizar resultados

Visualizaremos los resultados trazando la precisión en función del número de componentes 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="Mejor puntuación")
plt.axhline(lower, linestyle="--", color=".5", label="Mejor puntuación - 1 desv. estándar")

plt.title("Equilibrar la complejidad del modelo y la puntuación validada cruzada")
plt.xlabel("Número de componentes PCA utilizados")
plt.ylabel("Precisión de clasificación de dígitos")
plt.xticks(n_components.tolist())
plt.ylim((0, 1.0))
plt.legend(loc="upper left")

best_index_ = grid.best_index_

print("El best_index_ es %d" % best_index_)
print("El número de componentes PCA seleccionados es %d" % n_components[best_index_])
print(
    "La puntuación de precisión correspondiente es %.2f"
    % grid.cv_results_["mean_test_score"][best_index_]
)
plt.show()

Resumen

En este laboratorio, aprendimos cómo equilibrar la complejidad del modelo y la puntuación validada cruzada utilizando PCA y LinearSVC. Utilizamos GridSearchCV para encontrar el mejor número de componentes PCA mientras maximizábamos la puntuación de precisión dentro de 1 desviación estándar de la mejor puntuación. También visualizamos los resultados para entender mejor el compromiso entre la complejidad del modelo y la precisión.