Análisis de Componentes Principales con PCA Kernel

Introducción

El Análisis de Componentes Principales (PCA, por sus siglas en inglés) es una técnica utilizada para reducir la dimensionalidad de un conjunto de datos mientras se conserva la mayor parte de su variación original. Sin embargo, el PCA es un método lineal y puede no funcionar bien cuando los datos tienen una estructura no lineal. En tales casos, se puede utilizar el PCA Kernel en lugar del PCA. En este laboratorio, demostraremos las diferencias entre el PCA y el PCA Kernel y cómo utilizarlos.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Cargar el conjunto de datos

Crearemos un conjunto de datos compuesto por dos círculos anidados utilizando la función make_circles 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)

Visualizar el conjunto de datos

Graficaremos el conjunto de datos generado utilizando matplotlib para visualizar el conjunto de datos.

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("Característica #1")
train_ax.set_xlabel("Característica #0")
train_ax.set_title("Datos de entrenamiento")

test_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
test_ax.set_xlabel("Característica #0")
_ = test_ax.set_title("Datos de prueba")

Usar PCA para proyectar el conjunto de datos

El PCA se utiliza para proyectar el conjunto de datos en un nuevo espacio que conserva la mayor parte de su variación original.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)

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

Usar PCA Kernel para proyectar el conjunto de datos

El PCA Kernel se utiliza para proyectar el conjunto de datos en un nuevo espacio que conserva la mayor parte de su variación original, pero también permite estructuras no lineales.

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)

Visualizar las proyecciones de PCA y PCA Kernel

Graficaremos las proyecciones de PCA y PCA Kernel para visualizar las diferencias entre ellas.

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("Característica #1")
orig_data_ax.set_xlabel("Característica #0")
orig_data_ax.set_title("Datos de prueba")

pca_proj_ax.scatter(X_test_pca[:, 0], X_test_pca[:, 1], c=y_test)
pca_proj_ax.set_ylabel("Componente principal #1")
pca_proj_ax.set_xlabel("Componente principal #0")
pca_proj_ax.set_title("Proyección de los datos de prueba\n usando 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("Componente principal #1")
kernel_pca_proj_ax.set_xlabel("Componente principal #0")
_ = kernel_pca_proj_ax.set_title("Proyección de los datos de prueba\n usando KernelPCA")

Proyectar de vuelta la proyección de PCA Kernel al espacio original

Usaremos el método inverse_transform de PCA Kernel para proyectar de vuelta la proyección de PCA Kernel al espacio original.

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

Visualizar el conjunto de datos reconstruido

Graficaremos el conjunto de datos original y el conjunto de datos reconstruido para compararlos.

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("Característica #1")
orig_data_ax.set_xlabel("Característica #0")
orig_data_ax.set_title("Datos de prueba originales")

pca_back_proj_ax.scatter(X_reconstructed_pca[:, 0], X_reconstructed_pca[:, 1], c=y_test)
pca_back_proj_ax.set_xlabel("Característica #0")
pca_back_proj_ax.set_title("Reconstrucción a través de 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("Característica #0")
_ = kernel_pca_back_proj_ax.set_title("Reconstrucción a través de KernelPCA")

Resumen

En este laboratorio, aprendimos sobre las diferencias entre PCA y PCA Kernel. Usamos PCA y PCA Kernel para proyectar un conjunto de datos a un nuevo espacio y visualizamos las proyecciones. También usamos PCA Kernel para proyectar de vuelta la proyección al espacio original y la comparamos con el conjunto de datos original.