Introduction
L'Analyse en Composantes Principales (PCA en anglais) est une technique utilisée pour réduire la dimensionalité d'un ensemble de données tout en conservant la majeure partie de sa variation initiale. Cependant, la PCA est une méthode linéaire et peut ne pas fonctionner correctement lorsque les données ont une structure non linéaire. Dans de tels cas, on peut utiliser la PCA Kernel à la place de la PCA. Dans ce laboratoire, nous allons démontrer les différences entre la PCA et la PCA Kernel et comment les utiliser.
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 au Notebook Jupyter pour pratiquer.
Parfois, vous devrez peut-être attendre quelques secondes pour que le Notebook Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites du Notebook Jupyter.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.
Charger l'ensemble de données
Nous allons créer un ensemble de données composé de deux cercles imbriqués à l'aide de la fonction make_circles provenant de sklearn.datasets.
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)
Visualiser l'ensemble de données
Nous allons tracer l'ensemble de données généré à l'aide de matplotlib pour visualiser l'ensemble de données.
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("Données d'entraînement")
test_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
test_ax.set_xlabel("Feature #0")
_ = test_ax.set_title("Données de test")
Utiliser la PCA pour projeter l'ensemble de données
La PCA est utilisée pour projeter l'ensemble de données dans un nouvel espace qui conserve la majeure partie de sa variation initiale.
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_test_pca = pca.fit(X_train).transform(X_test)
Utiliser la PCA Kernel pour projeter l'ensemble de données
La PCA Kernel est utilisée pour projeter l'ensemble de données dans un nouvel espace qui conserve la majeure partie de sa variation initiale, mais permet également des structures non linéaires.
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)
Visualiser les projections de la PCA et de la PCA Kernel
Nous allons tracer les projections de la PCA et de la PCA Kernel pour visualiser les différences entre elles.
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("Données de test")
pca_proj_ax.scatter(X_test_pca[:, 0], X_test_pca[:, 1], c=y_test)
pca_proj_ax.set_ylabel("Composante principale #1")
pca_proj_ax.set_xlabel("Composante principale #0")
pca_proj_ax.set_title("Projection des données de test\n en utilisant la 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("Composante principale #1")
kernel_pca_proj_ax.set_xlabel("Composante principale #0")
_ = kernel_pca_proj_ax.set_title("Projection des données de test\n en utilisant la PCA Kernel")
Reprojecter la projection de la PCA Kernel dans l'espace d'origine
Nous allons utiliser la méthode inverse_transform de la PCA Kernel pour reprojecter la projection de la PCA Kernel dans l'espace d'origine.
X_reconstructed_kernel_pca = kernel_pca.inverse_transform(kernel_pca.transform(X_test))
Visualiser l'ensemble de données reconstruit
Nous allons tracer l'ensemble de données d'origine et l'ensemble de données reconstruit pour les comparer.
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("Données de test d'origine")
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 la 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 la PCA Kernel")
Sommaire
Dans ce laboratoire, nous avons appris les différences entre la PCA et la PCA Kernel. Nous avons utilisé la PCA et la PCA Kernel pour projeter un ensemble de données dans un nouvel espace, et visualisé les projections. Nous avons également utilisé la PCA Kernel pour reprojecter la projection dans l'espace d'origine et la comparer avec l'ensemble de données d'origine.