Aproximação de Kernel Polinomial com Scikit-Learn

Introdução

Este laboratório demonstrará como usar a aproximação de kernel polinomial no scikit-learn para gerar eficientemente aproximações do espaço de características do kernel polinomial. Isto é usado para treinar classificadores lineares que aproximam a precisão de classificadores kernel. Usaremos o conjunto de dados Covtype, que contém 581.012 amostras com 54 características cada, distribuídas em 6 classes. O objetivo deste conjunto de dados é prever o tipo de cobertura florestal a partir de variáveis cartográficas apenas (sem dados de sensoriamento remoto). Após o carregamento, transformaremos o problema em uma classificação binária para corresponder à versão do conjunto de dados na página da web LIBSVM, que foi usada no artigo original.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar e Preparar os Dados

Primeiro, carregaremos o conjunto de dados Covtype e o transformaremos num problema de classificação binária, selecionando apenas uma classe. Em seguida, dividiremos os dados em conjuntos de treino e teste e normalizaremos as características.

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

## Carregar o conjunto de dados Covtype, selecionando apenas uma classe
X, y = fetch_covtype(return_X_y=True)
y[y != 2] = 0
y[y == 2] = 1

## Dividir os dados em conjuntos de treino e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=5000, test_size=10000, random_state=42
)

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

Estabelecer um Modelo de Linha de Base

Treinaremos uma SVM linear nas características originais para estabelecer um modelo de linha de base e imprimiremos a sua precisão.

from sklearn.svm import LinearSVC

## Treinar uma SVM linear nas características originais
lsvm = LinearSVC(dual="auto")
lsvm.fit(X_train, y_train)
lsvm_score = 100 * lsvm.score(X_test, y_test)

## Imprimir a precisão do modelo de linha de base
print(f"Precisão da SVM Linear nas características originais: {lsvm_score:.2f}%")

Estabelecer o Modelo de Aproximação do Kernel

Agora, treinaremos SVMs lineares em características geradas pelo PolynomialCountSketch com diferentes valores para n_components. Usaremos um loop para iterar através de diferentes valores para n_components e imprimiremos a precisão de cada modelo.

from sklearn.kernel_approximation import PolynomialCountSketch
from sklearn.pipeline import make_pipeline

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

for n_components in N_COMPONENTS:
    ps_lsvm_score = 0
    for _ in range(n_runs):
        ## Treinar uma SVM linear em características geradas pelo 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

    ## Imprimir a precisão do modelo
    print(f"Precisão da SVM Linear em {n_components} características PolynomialCountSketch: {ps_lsvm_score:.2f}%")

Estabelecer o Modelo SVM Kernel

Treinaremos uma SVM kernel para verificar quão bem o PolynomialCountSketch está aproximando o desempenho do kernel.

from sklearn.svm import SVC

## Treinar uma SVM kernel
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)

## Imprimir a precisão da SVM kernel
print(f"Precisão da SVM Kernel nas características originais: {ksvm_score:.2f}%")

Comparar os Resultados

Plotaremos os resultados dos diferentes métodos contra seus tempos de treinamento para comparar seu desempenho.

import matplotlib.pyplot as plt

## Plotar os resultados dos diferentes métodos
fig, ax = plt.subplots(figsize=(7, 7))
ax.scatter(
    [
        lsvm_time,
    ],
    [
        lsvm_score,
    ],
    label="SVM Linear",
    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="SVM Kernel",
    c="red",
    marker="x",
)

ax.set_xlabel("Tempo de treinamento (s)")
ax.set_ylabel("Precisão (%)")
ax.legend()
plt.show()

Resumo

Este laboratório demonstrou como usar a aproximação de kernel polinomial no scikit-learn para gerar eficientemente aproximações do espaço de características do kernel polinomial. Aplicamos esta técnica ao conjunto de dados Covtype, transformando-o em um problema de classificação binária e treinando classificadores lineares que aproximam a precisão de classificadores kernel. Também comparamos o desempenho dos diferentes métodos e plotamos os resultados contra seus tempos de treinamento.