Reducción de dimensionalidad con Pipeline y GridSearchCV

Introducción

Esta práctica demuestra el uso de Pipeline y GridSearchCV en scikit-learn para optimizar diferentes clases de estimadores en una sola ejecución de validación cruzada (CV). Usaremos un clasificador de vectores de soporte para predecir dígitos escritos a mano a partir del popular conjunto de datos MNIST.

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 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 las bibliotecas necesarias y cargar los datos

Comenzaremos importando las bibliotecas necesarias y cargando el conjunto de datos de dígitos 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)

Crear una tubería y definir la cuadrícula de parámetros

Crearemos una tubería que realice la reducción de dimensionalidad seguida de una predicción con un clasificador de vectores de soporte. Usaremos reducciones de dimensionalidad no supervisadas PCA y NMF, junto con la selección de características univariada durante la búsqueda en la cuadrícula.

pipe = Pipeline(
    [
        ("escalado", MinMaxScaler()),
        ## la etapa reduce_dim está poblada por param_grid
        ("reduce_dim", "passthrough"),
        ("clasificar", 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,
        "clasificar__C": C_OPTIONS,
    },
    {
        "reduce_dim": [SelectKBest(mutual_info_classif)],
        "reduce_dim__k": N_FEATURES_OPTIONS,
        "clasificar__C": C_OPTIONS,
    },
]
etiquetas_reductor = ["PCA", "NMF", "KBest(mutual_info_classif)"]

Crear un objeto GridSearchCV y ajustar los datos

Crearemos un objeto GridSearchCV utilizando la tubería y la cuadrícula de parámetros que definimos en el paso anterior. Luego ajustaremos los datos al objeto.

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

Graficar los resultados

Graficaremos los resultados de GridSearchCV utilizando un gráfico de barras. Esto nos permitirá comparar la precisión de diferentes técnicas de reducción de características.

import pandas as pd

mean_scores = np.array(grid.cv_results_["mean_test_score"])
## las puntuaciones están en el orden de la iteración de param_grid, que es alfabética
mean_scores = mean_scores.reshape(len(C_OPTIONS), -1, len(N_FEATURES_OPTIONS))
## selecciona la puntuación para el mejor C
mean_scores = mean_scores.max(axis=0)
## crea un dataframe para facilitar la graficación
mean_scores = pd.DataFrame(
    mean_scores.T, index=N_FEATURES_OPTIONS, columns=etiquetas_reductor
)

ax = mean_scores.plot.bar()
ax.set_title("Comparando técnicas de reducción de características")
ax.set_xlabel("Número reducido de características")
ax.set_ylabel("Precisión de clasificación de dígitos")
ax.set_ylim((0, 1))
ax.legend(loc="upper left")

plt.show()

Almacenamiento en caché de transformadores dentro de una tubería

Ahora demostraremos cómo almacenar el estado de un transformador específico, ya que podría ser utilizado nuevamente. Utilizar una tubería en GridSearchCV desencadena situaciones como esta. Por lo tanto, usamos el argumento memory para habilitar el almacenamiento en caché.

from joblib import Memory
from shutil import rmtree

## Crea una carpeta temporal para almacenar los transformadores de la tubería
ubicación = "cachedir"
memory = Memory(location=ubicación, verbose=10)
cached_pipe = Pipeline(
    [("reduce_dim", PCA()), ("classify", LinearSVC(dual=False, max_iter=10000))],
    memory=memory,
)

## Esta vez, se utilizará una tubería almacenada en caché dentro de la búsqueda en la cuadrícula

## Elimina la caché temporal antes de salir
memory.clear(warn=False)
rmtree(ubicación)

Resumen

En este laboratorio, utilizamos Pipeline y GridSearchCV en scikit-learn para optimizar diferentes clases de estimadores en una sola ejecución de validación cruzada. También demostramos cómo almacenar el estado de un transformador específico utilizando el argumento memory para habilitar el almacenamiento en caché. Esto puede ser particularmente útil cuando es costoso ajustar un transformador.