Explizite Approximation der Feature Map für RBF-Kerne

Einführung

In diesem Lab wird die Approximation der Feature Map eines RBF-Kernels mithilfe von RBFSampler und Nystroem veranschaulicht, um die Feature Map eines RBF-Kernels für die Klassifizierung mit einem SVM auf dem Digits-Dataset zu approximieren. Es werden die Ergebnisse eines linearen SVM im ursprünglichen Raum, eines linearen SVM mit den approximativen Abbildungen und eines kernelisierten SVM verglichen. Es werden Laufzeiten und Genauigkeiten für unterschiedliche Mengen an Monte Carlo-Stichproben (im Falle von RBFSampler, der zufällige Fourier-Features verwendet) und verschiedene Größen von Teilmengen des Trainingssets (für Nystroem) für die approximative Abbildung gezeigt.

VM-Tipps

Nachdem der VM-Start 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 von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase 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

Python-Paket und Datensatzimporte, Datensatz laden

## Standardwissenschaftliche Python-Importe
import matplotlib.pyplot as plt
import numpy as np
from time import time

## Importe von Datensätzen, Klassifizierern und Leistungsmessgrößen
from sklearn import datasets, svm, pipeline
from sklearn.kernel_approximation import RBFSampler, Nystroem
from sklearn.decomposition import PCA

## Der Digits-Datensatz
digits = datasets.load_digits(n_class=9)

Zeit- und Genauigkeitsplots

## Um einen Klassifizierer auf diesen Daten anzuwenden, müssen wir das Bild flachmachen, um
## die Daten in eine (Samples, Feature)-Matrix zu verwandeln:
n_samples = len(digits.data)
data = digits.data / 16.0
data -= data.mean(axis=0)

## Wir lernen die Ziffern auf der ersten Hälfte der Ziffern
data_train, targets_train = (data[: n_samples // 2], digits.target[: n_samples // 2])

## Nun predizieren wir den Wert der Ziffer auf der zweiten Hälfte:
data_test, targets_test = (data[n_samples // 2 :], digits.target[n_samples // 2 :])

## Erstellen eines Klassifizierers: eines Support-Vector-Klassifizierers
kernel_svm = svm.SVC(gamma=0.2)
linear_svm = svm.LinearSVC(dual="auto")

## Erstellen eines Pipelines aus Kernel-Approximation und linearem SVM
feature_map_fourier = RBFSampler(gamma=0.2, random_state=1)
feature_map_nystroem = Nystroem(gamma=0.2, random_state=1)

fourier_approx_svm = pipeline.Pipeline([
  ("feature_map", feature_map_fourier),
  ("svm", svm.LinearSVC(dual="auto"))
])

nystroem_approx_svm = pipeline.Pipeline([
  ("feature_map", feature_map_nystroem),
  ("svm", svm.LinearSVC(dual="auto"))
])

## Anpassen und Vorhersagen mit linearem und kernelisiertem SVM:
kernel_svm_time = time()
kernel_svm.fit(data_train, targets_train)
kernel_svm_score = kernel_svm.score(data_test, targets_test)
kernel_svm_time = time() - kernel_svm_time

linear_svm_time = time()
linear_svm.fit(data_train, targets_train)
linear_svm_score = linear_svm.score(data_test, targets_test)
linear_svm_time = time() - linear_svm_time

sample_sizes = 30 * np.arange(1, 10)
fourier_scores = []
nystroem_scores = []
fourier_times = []
nystroem_times = []

for D in sample_sizes:
  fourier_approx_svm.set_params(feature_map__n_components=D)
  nystroem_approx_svm.set_params(feature_map__n_components=D)

  start = time()
  nystroem_approx_svm.fit(data_train, targets_train)
  nystroem_times.append(time() - start)

  start = time()
  fourier_approx_svm.fit(data_train, targets_train)
  fourier_times.append(time() - start)

  fourier_score = fourier_approx_svm.score(data_test, targets_test)
  nystroem_score = nystroem_approx_svm.score(data_test, targets_test)
  nystroem_scores.append(nystroem_score)
  fourier_scores.append(fourier_score)

## Plotten der Ergebnisse:
plt.figure(figsize=(16, 4))
accuracy = plt.subplot(121)
## Zweite y-Achse für Zeitmessungen
timescale = plt.subplot(122)

accuracy.plot(sample_sizes, nystroem_scores, label="Nystroem approx. kernel")
timescale.plot(sample_sizes, nystroem_times, "--", label="Nystroem approx. kernel")

accuracy.plot(sample_sizes, fourier_scores, label="Fourier approx. kernel")
timescale.plot(sample_sizes, fourier_times, "--", label="Fourier approx. kernel")

## Horizontale Linien für exakte rbf- und lineare Kerne:
accuracy.plot([sample_sizes[0], sample_sizes[-1]], [linear_svm_score, linear_svm_score], label="linear svm")
timescale.plot([sample_sizes[0], sample_sizes[-1]], [linear_svm_time, linear_svm_time], "--", label="linear svm")

accuracy.plot([sample_sizes[0], sample_sizes[-1]], [kernel_svm_score, kernel_svm_score], label="rbf svm")
timescale.plot([sample_sizes[0], sample_sizes[-1]], [kernel_svm_time, kernel_svm_time], "--", label="rbf svm")

## Vertikale Linie für die Datenmenge = 64
accuracy.plot([64, 64], [0.7, 1], label="n_features")

## Legenden und Beschriftungen
accuracy.set_title("Classification accuracy")
timescale.set_title("Training times")
accuracy.set_xlim(sample_sizes[0], sample_sizes[-1])
accuracy.set_xticks(())
accuracy.set_ylim(np.min(fourier_scores), 1)
timescale.set_xlabel("Sampling steps = transformed feature dimension")
accuracy.set_ylabel("Classification accuracy")
timescale.set_ylabel("Training time in seconds")
accuracy.legend(loc="best")
timescale.legend(loc="best")
plt.tight_layout()
plt.show()

Entscheidungsflächen von RBF-Kernel-SVM und linearem SVM

## Visualisiere die Entscheidungsfläche, projiziert auf die ersten
## zwei Hauptkomponenten des Datensatzes
pca = PCA(n_components=8).fit(data_train)

X = pca.transform(data_train)

## Generiere Gitter entlang der ersten beiden Hauptkomponenten
multiples = np.arange(-2, 2, 0.1)
## Schritte entlang der ersten Komponente
first = multiples[:, np.newaxis] * pca.components_[0, :]
## Schritte entlang der zweiten Komponente
second = multiples[:, np.newaxis] * pca.components_[1, :]
## Kombiniere
grid = first[np.newaxis, :, :] + second[:, np.newaxis, :]
flat_grid = grid.reshape(-1, data.shape[1])

## Titel für die Plots
titles = [
    "SVC mit rbf-Kernel",
    "SVC (linearer Kernel)\n mit Fourier rbf-Feature-Map\nn_components=100",
    "SVC (linearer Kernel)\n mit Nystroem rbf-Feature-Map\nn_components=100",
]

plt.figure(figsize=(18, 7.5))
plt.rcParams.update({"font.size": 14})
## Vorhersage und Plot
for i, clf in enumerate((kernel_svm, nystroem_approx_svm, fourier_approx_svm)):
    ## Zeichne die Entscheidungsgrenze. Dazu werden wir jeder
    ## Punkt im Gitter [x_min, x_max]x[y_min, y_max] eine Farbe zuweisen.
    plt.subplot(1, 3, i + 1)
    Z = clf.predict(flat_grid)

    ## Bringe das Ergebnis in einen Farbplot
    Z = Z.reshape(grid.shape[:-1])
    levels = np.arange(10)
    lv_eps = 0.01  ## Anpassen einer Zuordnung von berechneten Kontur-Ebenen zu Farben.
    plt.contourf(
        multiples,
        multiples,
        Z,
        levels=levels - lv_eps,
        cmap=plt.cm.tab10,
        vmin=0,
        vmax=10,
        alpha=0.7,
    )
    plt.axis("off")

    ## Zeichne auch die Trainingspunkte
    plt.scatter(
        X[:, 0],
        X[:, 1],
        c=targets_train,
        cmap=plt.cm.tab10,
        edgecolors=(0, 0, 0),
        vmin=0,
        vmax=10,
    )

    plt.title(titles[i])
plt.tight_layout()
plt.show()

Zusammenfassung

In diesem Lab wurde die Approximation der Feature Map eines RBF-Kernels mithilfe von RBFSampler und Nystroem veranschaulicht, um die Feature Map eines RBF-Kernels für die Klassifizierung mit einem SVM auf dem Digits-Dataset zu approximieren. Es wurden die Ergebnisse eines linearen SVM im ursprünglichen Raum, eines linearen SVM mit den approximativen Abbildungen und eines kernelisierten SVM verglichen. Es wurden Laufzeiten und Genauigkeiten für unterschiedliche Mengen an Monte Carlo-Stichproben (im Falle von RBFSampler, der zufällige Fourier-Features verwendet) und verschiedene Größen von Teilmengen des Trainingssets (für Nystroem) für die approximative Abbildung gezeigt. Schließlich wurden die Entscheidungsflächen der Klassifizierer visualisiert, projiziert auf die ersten beiden Hauptkomponenten der Daten.