PC A.pt

Intuição #

O PCA gira o sistema de coordenadas em direção às direções que capturam a maior variação. Manter apenas os eixos mais fortes comprime os dados enquanto retém a estrutura dominante.

Explicação Detalhada #

1. Por que PCA? #

• Dados de alta dimensão são difíceis de interpretar e visualizar; o PCA encontra direções ortogonais que resumem a maior parte da variância.
• O método é não supervisionado: não usa rótulos, apenas a estrutura de covariância dos dados.
• Uma vez projetados nas componentes principais, podemos visualizar, remover ruído ou alimentar as características comprimidas a modelos subsequentes.

2. Matemática #

Dada a matriz de dados centrada em zero (X \in \mathbb{R}^{n \times d}):

1. Matriz de covariância $$ \Sigma = \frac{1}{n} X^\top X $$
2. Decomposição em autovalores $$ \Sigma v_j = \lambda_j v_j $$ onde (v_j) são autovetores (eixos principais) e (\lambda_j) autovalores (variância explicada).
3. Projeção $$ Z = X V_k $$ usando os (k) autovetores principais.

3. Criar um conjunto de dados de exemplo #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=600, n_features=3, random_state=117117)

fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(projection="3d")
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y)
ax.set_xlabel("$x_1$")
ax.set_ylabel("$x_2$")
ax.set_zlabel("$x_3$")

4. Executar PCA com scikit-learn #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

pca = PCA(n_components=2, whiten=True)
X_pca = pca.fit_transform(StandardScaler().fit_transform(X))

plt.figure(figsize=(8, 8))
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y)
plt.xlabel("PC1")
plt.ylabel("PC2")
plt.title("2-D embedding via PCA")
plt.show()

5. O escalonamento importa #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from sklearn.preprocessing import StandardScaler

X, y = make_blobs(
    n_samples=200,
    n_features=3,
    random_state=11711,
    centers=3,
    cluster_std=2.0,
)
X[:, 1] *= 1000
X[:, 2] *= 0.01

X_ss = StandardScaler().fit_transform(X)

pca = PCA(n_components=2).fit(X)
X_pca = pca.transform(X)

pca_ss = PCA(n_components=2).fit(X_ss)
X_pca_ss = pca_ss.transform(X_ss)

plt.figure(figsize=(10, 5))
plt.subplot(121)
plt.title("Unscaled features")
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, marker="x", alpha=0.6)
plt.subplot(122)
plt.title("Scaled features")
plt.scatter(X_pca_ss[:, 0], X_pca_ss[:, 1], c=y, marker="x", alpha=0.6)
plt.show()

O PCA é dominado por características com grande variância; o escalonamento (ou branqueamento) é essencial quando as unidades das características diferem.

6. Considerações práticas #

• Razão de variância explicada: (\lambda_j / \sum_i \lambda_i) ajuda a decidir quantas componentes principais manter (geralmente 80-90%).
• Computação: o PCA é implementado via SVD internamente; use svd_solver='randomized' para grandes conjuntos de dados.
• Kernel PCA: quando o PCA linear não é suficiente, mude para kernels (veja a seção dedicada) ou tente UMAP/t-SNE para estrutura local.