Aproximación del kernel polinomial con Scikit-Learn

Introducción

Esta práctica demostrará cómo utilizar la aproximación del kernel polinomial en scikit-learn para generar eficientemente aproximaciones del espacio de características del kernel polinomial. Esto se utiliza para entrenar clasificadores lineales que se aproximan a la precisión de los clasificadores kernelizados. Utilizaremos el conjunto de datos Covtype, que contiene 581.012 muestras con 54 características cada una, distribuidas entre 6 clases. El objetivo de este conjunto de datos es predecir el tipo de cobertura forestal a partir solo de variables cartográficas (sin datos de teleobservación). Después de cargarlo, lo transformamos en un problema de clasificación binaria para coincidir con la versión del conjunto de datos en la página web de LIBSVM, que fue la utilizada en el artículo original.

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 Notebook 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 su retroalimentación después de la sesión y resolveremos rápidamente el problema para usted.

Cargar y Preparar los Datos

Primero cargaremos el conjunto de datos Covtype y lo transformaremos en un problema de clasificación binaria seleccionando solo una clase. Luego, dividiremos los datos en un conjunto de entrenamiento y un conjunto de prueba, y normalizaremos las características.

from sklearn.datasets import fetch_covtype
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler, Normalizer

## Cargar el conjunto de datos Covtype, seleccionando solo una clase
X, y = fetch_covtype(return_X_y=True)
y[y!= 2] = 0
y[y == 2] = 1

## Dividir los datos en un conjunto de entrenamiento y un conjunto de prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=5000, test_size=10000, random_state=42
)

## Normalizar las características
mm = make_pipeline(MinMaxScaler(), Normalizer())
X_train = mm.fit_transform(X_train)
X_test = mm.transform(X_test)

Establecer un Modelo de Referencia

Entrenaremos un SVM lineal en las características originales para establecer un modelo de referencia y mostrar su precisión.

from sklearn.svm import LinearSVC

## Entrenar un SVM lineal en las características originales
lsvm = LinearSVC(dual="auto")
lsvm.fit(X_train, y_train)
lsvm_score = 100 * lsvm.score(X_test, y_test)

## Mostrar la precisión del modelo de referencia
print(f"Linear SVM score on raw features: {lsvm_score:.2f}%")

Establecer el Modelo de Aproximación del Kernel

Ahora entrenaremos SVMs lineales en las características generadas por PolynomialCountSketch con diferentes valores para n_components. Utilizaremos un bucle para iterar a través de diferentes valores de n_components y mostrar la precisión de cada modelo.

from sklearn.kernel_approximation import PolynomialCountSketch

n_runs = 1
N_COMPONENTS = [250, 500, 1000, 2000]

for n_components in N_COMPONENTS:
    ps_lsvm_score = 0
    for _ in range(n_runs):
        ## Entrenar un SVM lineal en las características generadas por PolynomialCountSketch
        pipeline = make_pipeline(
            PolynomialCountSketch(n_components=n_components, degree=4),
            LinearSVC(dual="auto"),
        )
        pipeline.fit(X_train, y_train)
        ps_lsvm_score += 100 * pipeline.score(X_test, y_test)

    ps_lsvm_score /= n_runs

    ## Mostrar la precisión del modelo
    print(f"Linear SVM score on {n_components} PolynomialCountSketch features: {ps_lsvm_score:.2f}%")

Establecer el Modelo de SVM Kernelizado

Entrenaremos un SVM kernelizado para ver qué tan bien PolynomialCountSketch está aproximando el rendimiento del kernel.

from sklearn.svm import SVC

## Entrenar un SVM kernelizado
ksvm = SVC(C=500.0, kernel="poly", degree=4, coef0=0, gamma=1.0)
ksvm.fit(X_train, y_train)
ksvm_score = 100 * ksvm.score(X_test, y_test)

## Mostrar la precisión del SVM kernelizado
print(f"Kernel-SVM score on raw features: {ksvm_score:.2f}%")

Comparar los Resultados

Graficaremos los resultados de los diferentes métodos en función de sus tiempos de entrenamiento para comparar su rendimiento.

import matplotlib.pyplot as plt

## Graficar los resultados de los diferentes métodos
fig, ax = plt.subplots(figsize=(7, 7))
ax.scatter(
    [
        lsvm_time,
    ],
    [
        lsvm_score,
    ],
    label="Linear SVM",
    c="green",
    marker="^",
)

for n_components in N_COMPONENTS:
    ax.scatter(
        [
            results[f"LSVM + PS({n_components})"]["time"],
        ],
        [
            results[f"LSVM + PS({n_components})"]["score"],
        ],
        c="blue",
    )
    ax.annotate(
        f"n_comp.={n_components}",
        (
            results[f"LSVM + PS({n_components})"]["time"],
            results[f"LSVM + PS({n_components})"]["score"],
        ),
        xytext=(-30, 10),
        textcoords="offset pixels",
    )

ax.scatter(
    [
        ksvm_time,
    ],
    [
        ksvm_score,
    ],
    label="Kernel SVM",
    c="red",
    marker="x",
)

ax.set_xlabel("Training time (s)")
ax.set_ylabel("Accuracy (%)")
ax.legend()
plt.show()

Resumen

Esta práctica mostró cómo utilizar la aproximación del kernel polinomial en scikit-learn para generar eficientemente aproximaciones del espacio de características del kernel polinomial. Aplicamos esta técnica al conjunto de datos Covtype, transformándolo en un problema de clasificación binaria y entrenando clasificadores lineales que se aproximan a la precisión de los kernelizados. También comparamos el rendimiento de los diferentes métodos y graficamos los resultados en función de sus tiempos de entrenamiento.