Approximation du noyau polynomial avec Scikit-Learn

Introduction

Ce laboratoire démontrera comment utiliser l'approximation du noyau polynomial dans scikit-learn pour générer efficacement des approximations d'espace de caractéristiques de noyau polynomial. Cela est utilisé pour entraîner des classifieurs linéaires qui approchent la précision des classifieurs à noyau. Nous utiliserons le jeu de données Covtype, qui contient 581 012 échantillons avec 54 caractéristiques chacun, répartis entre 6 classes. Le but de ce jeu de données est de prédire le type de couvert forestier à partir de variables cartographiques seulement (aucune donnée de télédétection). Après le chargement, nous le transformons en un problème de classification binaire pour correspondre à la version du jeu de données sur la page web de LIBSVM, qui était celle utilisée dans l'article original.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.

Charger et préparer les données

Nous allons tout d'abord charger le jeu de données Covtype et le transformer en un problème de classification binaire en sélectionnant seulement une classe. Ensuite, nous allons diviser les données en un ensemble d'entraînement et un ensemble de test, et normaliser les caractéristiques.

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

## Charger le jeu de données Covtype, en sélectionnant seulement une classe
X, y = fetch_covtype(return_X_y=True)
y[y!= 2] = 0
y[y == 2] = 1

## Diviser les données en un ensemble d'entraînement et un ensemble de test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=5000, test_size=10000, random_state=42
)

## Normaliser les caractéristiques
mm = make_pipeline(MinMaxScaler(), Normalizer())
X_train = mm.fit_transform(X_train)
X_test = mm.transform(X_test)

Établir un modèle de base

Nous allons entraîner un SVM linéaire sur les caractéristiques d'origine pour établir un modèle de base et afficher sa précision.

from sklearn.svm import LinearSVC

## Entraîner un SVM linéaire sur les caractéristiques d'origine
lsvm = LinearSVC(dual="auto")
lsvm.fit(X_train, y_train)
lsvm_score = 100 * lsvm.score(X_test, y_test)

## Afficher la précision du modèle de base
print(f"Linear SVM score on raw features: {lsvm_score:.2f}%")

Établir le modèle d'approximation du noyau

Nous allons maintenant entraîner des SVM linéaires sur les caractéristiques générées par PolynomialCountSketch avec différentes valeurs pour n_components. Nous utiliserons une boucle pour itérer sur différentes valeurs de n_components et afficher la précision de chaque modèle.

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):
        ## Entraîner un SVM linéaire sur les caractéristiques générées par 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

    ## Afficher la précision du modèle
    print(f"Linear SVM score on {n_components} PolynomialCountSketch features: {ps_lsvm_score:.2f}%")

Établir le modèle SVM à noyau

Nous allons entraîner un SVM à noyau pour voir à quel point PolynomialCountSketch approche les performances du noyau.

from sklearn.svm import SVC

## Entraîner un SVM à noyau
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)

## Afficher la précision du SVM à noyau
print(f"Kernel-SVM score on raw features: {ksvm_score:.2f}%")

Comparer les résultats

Nous allons tracer les résultats des différentes méthodes en fonction de leurs temps d'entraînement pour comparer leurs performances.

import matplotlib.pyplot as plt

## Tracer les résultats des différentes méthodes
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("Temps d'entraînement (s)")
ax.set_ylabel("Précision (%)")
ax.legend()
plt.show()

Sommaire

Ce laboratoire a démontré comment utiliser l'approximation du noyau polynomial dans scikit-learn pour générer efficacement des approximations d'espace de caractéristiques de noyau polynomial. Nous avons appliqué cette technique au jeu de données Covtype, en le transformant en un problème de classification binaire et en entraînant des classifieurs linéaires qui approchent la précision des classifieurs à noyau. Nous avons également comparé les performances des différentes méthodes et tracé les résultats en fonction de leurs temps d'entraînement.