Polynomielle Kernapproximation mit Scikit-Learn

Einführung

In diesem Lab wird gezeigt, wie die polynomielle Kernapproximation in scikit-learn verwendet werden kann, um effizient Approximationen des polynomiellen Kern-Funktionsraums zu generieren. Dies wird verwendet, um lineare Klassifizierer zu trainieren, die die Genauigkeit von kernbasierten Klassifizierern approximieren. Wir werden den Covtype-Datensatz verwenden, der 581.012 Samples mit jeweils 54 Merkmalen enthält, die auf 6 Klassen verteilt sind. Ziel dieses Datensatzes ist es, die Waldbedeckungstypen ausschließlich aus kartographischen Variablen (ohne Fernerkundungsdaten) vorherzusagen. Nachdem wir ihn geladen haben, transformieren wir ihn in ein binäres Klassifizierungsproblem, um der Version des Datensatzes auf der LIBSVM-Webseite zu entsprechen, die in der ursprünglichen Veröffentlichung verwendet wurde.

Tipps für die VM

Nachdem der Start der VM abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Daten laden und vorbereiten

Wir laden zunächst den Covtype-Datensatz und transformieren ihn in ein binäres Klassifizierungsproblem, indem wir nur eine Klasse auswählen. Anschließend teilen wir die Daten in einen Trainingssatz und einen Testsatz auf und normalisieren die Merkmale.

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

## Lade den Covtype-Datensatz, wähle nur eine Klasse aus
X, y = fetch_covtype(return_X_y=True)
y[y!= 2] = 0
y[y == 2] = 1

## Teile die Daten in einen Trainingssatz und einen Testsatz auf
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=5000, test_size=10000, random_state=42
)

## Normalisiere die Merkmale
mm = make_pipeline(MinMaxScaler(), Normalizer())
X_train = mm.fit_transform(X_train)
X_test = mm.transform(X_test)

Ein Baselinemodell etablieren

Wir werden einen linearen SVM auf den ursprünglichen Merkmalen trainieren, um ein Baselinemodell zu etablieren und seine Genauigkeit auszugeben.

from sklearn.svm import LinearSVC

## Trainiere einen linearen SVM auf den ursprünglichen Merkmalen
lsvm = LinearSVC(dual="auto")
lsvm.fit(X_train, y_train)
lsvm_score = 100 * lsvm.score(X_test, y_test)

## Gib die Genauigkeit des Baselinemodells aus
print(f"Linear SVM score on raw features: {lsvm_score:.2f}%")

Das Kernapproximationsmodell etablieren

Wir werden jetzt lineare SVMs auf Merkmalen trainieren, die von PolynomialCountSketch mit unterschiedlichen Werten für n_components generiert werden. Wir verwenden eine Schleife, um durch verschiedene Werte für n_components zu iterieren und die Genauigkeit jedes Modells auszugeben.

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):
        ## Trainiere eine lineare SVM auf Merkmalen, die von PolynomialCountSketch generiert werden
        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

    ## Gib die Genauigkeit des Modells aus
    print(f"Linear SVM score on {n_components} PolynomialCountSketch features: {ps_lsvm_score:.2f}%")

Das kernelbasierte SVM-Modell etablieren

Wir werden ein kernelbasiertes SVM trainieren, um zu sehen, wie gut PolynomialCountSketch die Leistung des Kerns approximiert.

from sklearn.svm import SVC

## Trainiere ein kernelbasiertes SVM
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)

## Gib die Genauigkeit des kernelbasierten SVMs aus
print(f"Kernel-SVM score on raw features: {ksvm_score:.2f}%")

Die Ergebnisse vergleichen

Wir werden die Ergebnisse der verschiedenen Methoden gegen ihre Trainingszeiten aufzeichnen, um ihre Leistung zu vergleichen.

import matplotlib.pyplot as plt

## Zeichne die Ergebnisse der verschiedenen Methoden
fig, ax = plt.subplots(figsize=(7, 7))
ax.scatter(
    [
        lsvm_time,
    ],
    [
        lsvm_score,
    ],
    label="Linear SVM",
    c="grün",
    marker="^",
)

for n_components in N_COMPONENTS:
    ax.scatter(
        [
            results[f"LSVM + PS({n_components})"]["time"],
        ],
        [
            results[f"LSVM + PS({n_components})"]["score"],
        ],
        c="blau",
    )
    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="rot",
    marker="x",
)

ax.set_xlabel("Trainingszeit (s)")
ax.set_ylabel("Genauigkeit (%)")
ax.legend()
plt.show()

Zusammenfassung

In diesem Lab wurde gezeigt, wie man in scikit-learn die polynomielle Kernapproximation verwendet, um effizient Approximationen des polynomiellen Kern-Funktionsraums zu generieren. Wir haben diese Technik auf den Covtype-Datensatz angewandt, ihn in ein binäres Klassifizierungsproblem transformiert und lineare Klassifizierer trainiert, die die Genauigkeit von kernelbasierten Klassifizierern approximieren. Wir haben auch die Leistung der verschiedenen Methoden verglichen und die Ergebnisse gegen ihre Trainingszeiten aufgetragen.