Hauptkomponentenanalyse mit Kernel PCA

Einführung

Die Hauptkomponentenanalyse (Principal Component Analysis, PCA) ist eine Technik, die verwendet wird, um die Dimension eines Datensatzes zu reduzieren, während die meiste ursprüngliche Variation beibehalten wird. Die PCA ist jedoch eine lineare Methode und kann nicht gut funktionieren, wenn die Daten eine nicht-lineare Struktur aufweisen. In solchen Fällen kann die Kernel PCA anstelle der PCA verwendet werden. In diesem Lab werden wir die Unterschiede zwischen PCA und Kernel PCA demonstrieren und zeigen, wie man sie verwendet.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und den Jupyter Notebook-Access für die Übung zu erhalten.

Manchmal müssen Sie einige Sekunden warten, bis das Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen im 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

Lade den Datensatz

Wir werden einen Datensatz aus zwei geschachtelten Kreisen mit der Funktion make_circles aus sklearn.datasets erstellen.

from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

X, y = make_circles(n_samples=1_000, factor=0.3, noise=0.05, random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)

Visualisiere den Datensatz

Wir werden den erzeugten Datensatz mit matplotlib darstellen, um ihn zu visualisieren.

import matplotlib.pyplot as plt

_, (train_ax, test_ax) = plt.subplots(ncols=2, sharex=True, sharey=True, figsize=(8, 4))

train_ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train)
train_ax.set_ylabel("Feature #1")
train_ax.set_xlabel("Feature #0")
train_ax.set_title("Training data")

test_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
test_ax.set_xlabel("Feature #0")
_ = test_ax.set_title("Testing data")

Verwende die PCA, um den Datensatz zu projizieren

Die PCA wird verwendet, um den Datensatz in einen neuen Raum zu projizieren, in dem die meiste ursprüngliche Variation erhalten bleibt.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)

X_test_pca = pca.fit(X_train).transform(X_test)

Verwende die Kernel PCA, um den Datensatz zu projizieren

Die Kernel PCA wird verwendet, um den Datensatz in einen neuen Raum zu projizieren, in dem die meiste ursprüngliche Variation erhalten bleibt, aber auch nicht-lineare Strukturen ermöglicht.

from sklearn.decomposition import KernelPCA

kernel_pca = KernelPCA(
    n_components=None, kernel="rbf", gamma=10, fit_inverse_transform=True, alpha=0.1
)

X_test_kernel_pca = kernel_pca.fit(X_train).transform(X_test)

Visualisiere die PCA- und Kernel-PCA-Projektionen

Wir werden die PCA- und Kernel-PCA-Projektionen darstellen, um die Unterschiede zwischen ihnen zu visualisieren.

fig, (orig_data_ax, pca_proj_ax, kernel_pca_proj_ax) = plt.subplots(
    ncols=3, figsize=(14, 4)
)

orig_data_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
orig_data_ax.set_ylabel("Feature #1")
orig_data_ax.set_xlabel("Feature #0")
orig_data_ax.set_title("Testing data")

pca_proj_ax.scatter(X_test_pca[:, 0], X_test_pca[:, 1], c=y_test)
pca_proj_ax.set_ylabel("Principal component #1")
pca_proj_ax.set_xlabel("Principal component #0")
pca_proj_ax.set_title("Projection of testing data\n using PCA")

kernel_pca_proj_ax.scatter(X_test_kernel_pca[:, 0], X_test_kernel_pca[:, 1], c=y_test)
kernel_pca_proj_ax.set_ylabel("Principal component #1")
kernel_pca_proj_ax.set_xlabel("Principal component #0")
_ = kernel_pca_proj_ax.set_title("Projection of testing data\n using KernelPCA")

Projektieren Sie die Kernel-PCA-Projektion zurück in den ursprünglichen Raum

Wir werden die inverse_transform-Methode der Kernel PCA verwenden, um die Kernel-PCA-Projektion zurück in den ursprünglichen Raum zu projizieren.

X_reconstructed_kernel_pca = kernel_pca.inverse_transform(kernel_pca.transform(X_test))

Visualisiere den rekonstruierten Datensatz

Wir werden den ursprünglichen Datensatz und den rekonstruierten Datensatz darstellen, um sie zu vergleichen.

fig, (orig_data_ax, pca_back_proj_ax, kernel_pca_back_proj_ax) = plt.subplots(
    ncols=3, sharex=True, sharey=True, figsize=(13, 4)
)

orig_data_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
orig_data_ax.set_ylabel("Feature #1")
orig_data_ax.set_xlabel("Feature #0")
orig_data_ax.set_title("Original test data")

pca_back_proj_ax.scatter(X_reconstructed_pca[:, 0], X_reconstructed_pca[:, 1], c=y_test)
pca_back_proj_ax.set_xlabel("Feature #0")
pca_back_proj_ax.set_title("Reconstruction via PCA")

kernel_pca_back_proj_ax.scatter(
    X_reconstructed_kernel_pca[:, 0], X_reconstructed_kernel_pca[:, 1], c=y_test
)
kernel_pca_back_proj_ax.set_xlabel("Feature #0")
_ = kernel_pca_back_proj_ax.set_title("Reconstruction via KernelPCA")

Zusammenfassung

In diesem Lab haben wir die Unterschiede zwischen PCA und Kernel PCA kennengelernt. Wir haben die PCA und die Kernel PCA verwendet, um einen Datensatz in einen neuen Raum zu projizieren und die Projektionen visualisiert. Wir haben auch die Kernel PCA verwendet, um die Projektion zurück in den ursprünglichen Raum zu projizieren und sie mit dem ursprünglichen Datensatz zu vergleichen.