Graficar la Búsqueda en Cuadrícula de Dígitos

Introducción

Esta práctica muestra cómo realizar la optimización de hiperparámetros con validación cruzada utilizando la biblioteca scikit-learn. El objetivo es clasificar imágenes de dígitos manuscritos mediante una clasificación binaria para una comprensión más fácil: identificar si un dígito es un 8 o no. El conjunto de datos utilizado es el conjunto de datos de dígitos. A continuación, se mide el rendimiento de los hiperparámetros seleccionados y del modelo entrenado en un conjunto de evaluación dedicado que no se utilizó durante el paso de selección del modelo.

Consejos sobre la VM

Una vez finalizada la inicialización de 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

Cargar datos

Cargaremos el conjunto de datos de dígitos y aplanaremos las imágenes en vectores. Cada imagen de 8 por 8 píxeles debe transformarse en un vector de 64 píxeles. De este modo, obtendremos una matriz de datos final de forma (n_imagenes, n_píxeles). También dividiremos los datos en un conjunto de entrenamiento y un conjunto de prueba de tamaño igual.

from sklearn import datasets
from sklearn.model_selection import train_test_split

digits = datasets.load_digits()

n_samples = len(digits.images)
X = digits.images.reshape((n_samples, -1))
y = digits.target == 8

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)

Definir la estrategia de búsqueda en cuadrícula

Definiremos una función que se pasará al parámetro refit de la instancia GridSearchCV. Implementará la estrategia personalizada para seleccionar el mejor candidato a partir del atributo cv_results_ de la instancia GridSearchCV. Una vez que se ha seleccionado el candidato, se ajusta automáticamente por la instancia GridSearchCV.

Aquí, la estrategia es reducir a una lista los modelos que son los mejores en términos de precisión y recuperación. A partir de los modelos seleccionados, finalmente elegimos el modelo más rápido en la predicción. Tenga en cuenta que estas elecciones personalizadas son completamente arbitrarias.

import pandas as pd
from sklearn.metrics import classification_report

def print_dataframe(filtered_cv_results):
    """Impresión bonita para el dataframe filtrado"""
    for mean_precision, std_precision, mean_recall, std_recall, params in zip(
        filtered_cv_results["mean_test_precision"],
        filtered_cv_results["std_test_precision"],
        filtered_cv_results["mean_test_recall"],
        filtered_cv_results["std_test_recall"],
        filtered_cv_results["params"],
    ):
        print(
            f"precision: {mean_precision:0.3f} (±{std_precision:0.03f}),"
            f" recall: {mean_recall:0.3f} (±{std_recall:0.03f}),"
            f" para {params}"
        )
    print()


def refit_strategy(cv_results):
    """Define la estrategia para seleccionar el mejor estimador.

    La estrategia definida aquí es filtrar todos los resultados por debajo de un umbral de precisión
    del 0.98, clasificar los restantes por recuperación y mantener todos los modelos con una
    desviación estándar del mejor por recuperación. Una vez que se han seleccionado estos modelos,
    podemos elegir el modelo más rápido para predecir.

    Parámetros
    ----------
    cv_results : dict de ndarrays de numpy (enmascarados)
        Resultados de la validación cruzada devueltos por el `GridSearchCV`.

    Devuelve
    -------
    best_index : int
        El índice del mejor estimador tal como aparece en `cv_results`.
    """
    ## Imprime la información sobre la búsqueda en cuadrícula para las diferentes puntuaciones
    precision_threshold = 0.98

    cv_results_ = pd.DataFrame(cv_results)
    print("Todos los resultados de la búsqueda en cuadrícula:")
    print_dataframe(cv_results_)

    ## Filtra todos los resultados por debajo del umbral
    high_precision_cv_results = cv_results_[
        cv_results_["mean_test_precision"] > precision_threshold
    ]

    print(f"Modelos con una precisión mayor que {precision_threshold}:")
    print_dataframe(high_precision_cv_results)

    high_precision_cv_results = high_precision_cv_results[
        [
            "mean_score_time",
            "mean_test_recall",
            "std_test_recall",
            "mean_test_precision",
            "std_test_precision",
            "rank_test_recall",
            "rank_test_precision",
            "params",
        ]
    ]

    ## Selecciona los modelos más performantes en términos de recuperación
    ## (dentro de 1 sigma del mejor)
    best_recall_std = high_precision_cv_results["mean_test_recall"].std()
    best_recall = high_precision_cv_results["mean_test_recall"].max()
    best_recall_threshold = best_recall - best_recall_std

    high_recall_cv_results = high_precision_cv_results[
        high_precision_cv_results["mean_test_recall"] > best_recall_threshold
    ]
    print(
        "De los modelos de alta precisión previamente seleccionados, mantenemos todos los\n"
        "modelos dentro de una desviación estándar del modelo de mayor recuperación:"
    )
    print_dataframe(high_recall_cv_results)

    ## De los mejores candidatos, selecciona el modelo más rápido para predecir
    fastest_top_recall_high_precision_index = high_recall_cv_results[
        "mean_score_time"
    ].idxmin()

    print(
        "\nEl modelo final seleccionado es el más rápido para predecir dentro del\n"
        "subconjunto previamente seleccionado de mejores modelos basados en precisión y recuperación.\n"
        "Su tiempo de puntuación es:\n\n"
        f"{high_recall_cv_results.loc[fastest_top_recall_high_precision_index]}"
    )

    return fastest_top_recall_high_precision_index

Definir hiperparámetros

Definiremos los hiperparámetros y crearemos la instancia GridSearchCV.

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

tuned_parameters = [
    {"kernel": ["rbf"], "gamma": [1e-3, 1e-4], "C": [1, 10, 100, 1000]},
    {"kernel": ["linear"], "C": [1, 10, 100, 1000]},
]

grid_search = GridSearchCV(
    SVC(), tuned_parameters, scoring=["precision", "recall"], refit=refit_strategy
)

Ajustar el modelo y hacer predicciones

Ajustaremos el modelo y haremos predicciones en el conjunto de evaluación.

grid_search.fit(X_train, y_train)

## Los parámetros seleccionados por la búsqueda en cuadrícula con nuestra estrategia personalizada son:
grid_search.best_params_

## Finalmente, evaluamos el modelo ajustado en el conjunto de evaluación no utilizado: el
## objeto `grid_search` **ha sido automáticamente ajustado** en el conjunto de entrenamiento
## completo con los parámetros seleccionados por nuestra estrategia de ajuste personalizada.
y_pred = grid_search.predict(X_test)
print(classification_report(y_test, y_pred))

Resumen

En este laboratorio, aprendimos cómo realizar el ajuste de hiperparámetros con validación cruzada utilizando la biblioteca scikit-learn. Utilizamos el conjunto de datos de dígitos y definimos una estrategia de ajuste personalizada para seleccionar el mejor candidato a partir del atributo cv_results_ de la instancia GridSearchCV. Finalmente, evaluamos el modelo ajustado en el conjunto de evaluación no utilizado.