Análise de Componentes Principais com Kernel PCA

Introdução

A Análise de Componentes Principais (PCA) é uma técnica usada para reduzir a dimensionalidade de um conjunto de dados, preservando a maior parte da sua variação original. No entanto, a PCA é um método linear e pode não funcionar bem quando os dados têm uma estrutura não linear. Nestes casos, a PCA Kernel pode ser usada em vez da PCA. Neste laboratório, demonstraremos as diferenças entre PCA e PCA Kernel e como utilizá-las.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Carregar o conjunto de dados

Criaremos um conjunto de dados composto por dois círculos aninhados usando a função 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 o conjunto de dados

Vamos plotar o conjunto de dados gerado usando matplotlib para visualizar os dados.

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("Dados de treino")

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

Usar PCA para projetar o conjunto de dados

A PCA é usada para projetar o conjunto de dados em um novo espaço que preserva a maior parte de sua variação 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 projetar o conjunto de dados

A PCA Kernel é usada para projetar o conjunto de dados em um novo espaço que preserva a maior parte de sua variação original, mas também permite estruturas não lineares.

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 as projeções PCA e PCA Kernel

Vamos plotar as projeções PCA e PCA Kernel para visualizar as diferenças entre elas.

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("Dados de teste")

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("Projeção dos dados de teste\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("Projeção dos dados de teste\n usando KernelPCA")

Projetar novamente a projeção PCA Kernel para o espaço original

Usaremos o método inverse_transform da PCA Kernel para projetar novamente a projeção PCA Kernel para o espaço original.

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

Visualizar o conjunto de dados reconstruído

Vamos plotar o conjunto de dados original e o conjunto de dados reconstruído para compará-los.

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("Dados de teste originais")

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("Reconstrução 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("Característica #0")
_ = kernel_pca_back_proj_ax.set_title("Reconstrução via KernelPCA")

Resumo

Neste laboratório, aprendemos sobre as diferenças entre PCA e Kernel PCA. Usamos PCA e Kernel PCA para projetar um conjunto de dados em um novo espaço e visualizamos as projeções. Também usamos Kernel PCA para projetar novamente a projeção para o espaço original e comparamos-a com o conjunto de dados original.