O que é redução de dimensionalidade
A redução de dimensionalidade é uma técnica não supervisionada. Ela transforma dados com muitas características em poucas dimensões. Por exemplo, imagens de 1000 pixels viram 2 ou 3 coordenadas. O objetivo é visualizar padrões e reduzir ruído. Diferentemente da clusterização, aqui o foco é a compressão. Essa compressão preserva ao máximo a estrutura original. Primeiramente, os dados são projetados em um espaço menor. Em seguida, é possível plotar e interpretar os resultados. Além disso, modelos de machine learning ficam mais rápidos. Contudo, alguma informação é inevitavelmente perdida.
Cinco modelos principais são frequentemente utilizados. PCA é linear e baseado em autovetores da covariância. t-SNE é não linear e ótimo para visualização local. LDA é supervisionado, mas adaptável para redução. UMAP é moderno, rápido e preserva topologia global. Autoencoders usam redes neurais para compressão não linear. Cada método tem vantagens e desvantagens específicas. Por conseguinte, a escolha depende do problema. Iniciantes devem começar com PCA e t-SNE. Eles são bem documentados e fáceis de usar.
Arquitetura e características dos modelos
O PCA encontra direções de máxima variância nos dados. Sua arquitetura é baseada em álgebra linear pura. Primeiro, calcula-se a matriz de covariância das características. Depois, obtêm-se os autovalores e autovetores dessa matriz. Os autovetores são as componentes principais ordenadas. A fórmula da primeira componente principal é: \(PC_1 = \arg\max_{||w||=1} Var(Xw)\). Projeções subsequentes são ortogonais à primeira. O t-SNE, por outro lado, usa probabilidades condicionais. Ele mapeia similaridades de alta dimensão para baixa dimensão. Uma arquitetura de rede neural é usada pelos autoencoders. Eles têm um codificador e um decodificador simétrico. O codificador comprime os dados no “gargalo” (bottleneck). O decodificador reconstrói os dados a partir da compressão. A perda de reconstrução é minimizada durante o treinamento.
O UMAP combina teoria de variedades e topologia. Ele constrói um grafo fuzzy de vizinhanças nos dados. Depois, otimiza um embedding de baixa dimensão similar. Sua arquitetura é eficiente e escala para milhões de pontos. O LDA é supervisionado, mas pode ser usado sem rótulos. Ele maximiza a separação entre classes conhecidas. Para redução não supervisionada, PCA é mais recomendado. Cada modelo tem hiperparâmetros específicos e críticos.
Hiperparâmetros e fórmulas matemáticas
No PCA, o principal hiperparâmetro é o número de componentes. Ele determina quantas dimensões serão mantidas. A variância explicada acumulada guia essa escolha: \(Var_{acum}(k) = \frac{\sum_{i=1}^{k} \lambda_i}{\sum_{i=1}^{d} \lambda_i}\). Aqui, \(\lambda_i\) são os autovalores ordenados. Para t-SNE, a perplexidade é o hiperparâmetro mais importante. Ela controla o equilíbrio entre vizinhos locais e globais. Valores típicos variam entre 5 e 50. O número de iterações e a taxa de aprendizado também contam. No UMAP, n_neighbors e min_dist são os principais ajustes. n_neighbors controla o tamanho da vizinhança local. min_dist define quão próximos os pontos ficam no embedding. Autoencoders têm muitos hiperparâmetros: camadas, neurônios, taxa de aprendizado. A regularização evita overfitting em redes neurais. A fórmula da perda de reconstrução para autoencoder é: \(L = \frac{1}{N}\sum_{i=1}^{N} ||x_i – \hat{x}_i||^2\). Essa é a distância euclidiana entre entrada e saída.
Enunciado do exemplo clássico (dígitos MNIST)
Você recebeu imagens de dígitos escritos à mão (MNIST). Cada imagem tem 784 pixels (28×28 em escala de cinza). Seu objetivo é reduzir essa dimensionalidade para 2D. Use PCA, t-SNE e UMAP para comparar os resultados. Visualize os dígitos em um gráfico de dispersão colorido. Cada cor representa um dígito de 0 a 9. Avalie qual método separa melhor os grupos naturais. O código abaixo resolve este enunciado completamente. Ele roda no Google Colab e baixa o MNIST automaticamente. Boa prática! A redução de dimensionalidade revela estruturas.
|
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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import fetch_openml from sklearn.decomposition import PCA from sklearn.manifold import TSNE from sklearn.preprocessing import StandardScaler import umap import time # Carrega o dataset MNIST (apenas 5000 amostras para velocidade) print("Carregando MNIST...") X, y = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False, parser='pandas') # Reduz para 5000 amostras para execução rápida np.random.seed(42) indices = np.random.choice(X.shape[0], 5000, replace=False) X = X[indices] y = y[indices].astype(int) # Normalização dos dados scaler = StandardScaler() X_scaled = scaler.fit_transform(X) print(f"Dados carregados: {X_scaled.shape[0]} amostras, {X_scaled.shape[1]} características") # 1. PCA print("\nExecutando PCA...") start = time.time() pca = PCA(n_components=2, random_state=42) X_pca = pca.fit_transform(X_scaled) print(f"PCA concluído em {time.time()-start:.2f} segundos") print(f"Variância explicada: {pca.explained_variance_ratio_.sum():.3f}") # 2. t-SNE (mais lento, mas muito usado) print("\nExecutando t-SNE (pode levar 1-2 minutos)...") start = time.time() tsne = TSNE(n_components=2, random_state=42, perplexity=30, n_iter=1000) X_tsne = tsne.fit_transform(X_scaled) print(f"t-SNE concluído em {time.time()-start:.2f} segundos") # 3. UMAP (requer instalação: !pip install umap-learn) try: print("\nExecutando UMAP...") start = time.time() reducer = umap.UMAP(n_components=2, random_state=42, n_neighbors=30, min_dist=0.1) X_umap = reducer.fit_transform(X_scaled) print(f"UMAP concluído em {time.time()-start:.2f} segundos") umap_disponivel = True except Exception as e: print(f"UMAP não disponível: {e}") print("Instale com: !pip install umap-learn") umap_disponivel = False # Cria os gráficos fig, axes = plt.subplots(1, 3 if umap_disponivel else 2, figsize=(18, 5)) cores = plt.cm.tab10(np.linspace(0, 1, 10)) # Gráfico PCA scatter1 = axes[0].scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='tab10', s=5, alpha=0.7) axes[0].set_title(f'PCA - 2D (Variância: {pca.explained_variance_ratio_.sum():.2f})') axes[0].set_xlabel('Componente 1') axes[0].set_ylabel('Componente 2') plt.colorbar(scatter1, ax=axes[0], ticks=range(10)) # Gráfico t-SNE scatter2 = axes[1].scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='tab10', s=5, alpha=0.7) axes[1].set_title('t-SNE (perplexidade=30)') axes[1].set_xlabel('Dimensão 1') axes[1].set_ylabel('Dimensão 2') plt.colorbar(scatter2, ax=axes[1], ticks=range(10)) # Gráfico UMAP (se disponível) if umap_disponivel: scatter3 = axes[2].scatter(X_umap[:, 0], X_umap[:, 1], c=y, cmap='tab10', s=5, alpha=0.7) axes[2].set_title('UMAP (n_neighbors=30, min_dist=0.1)') axes[2].set_xlabel('Dimensão 1') axes[2].set_ylabel('Dimensão 2') plt.colorbar(scatter3, ax=axes[2], ticks=range(10)) plt.suptitle('Comparação de métodos de redução de dimensionalidade - MNIST', fontsize=14) plt.tight_layout() plt.show() # Métricas adicionais para PCA print("\n" + "=" * 60) print("Análise dos resultados:") print("=" * 60) print(f"PCA: 2 componentes explicam {pca.explained_variance_ratio_.sum()*100:.1f}% da variância") print("t-SNE: Preserva bem vizinhanças locais, ideal para visualização") if umap_disponivel: print("UMAP: Rápido e preserva estrutura global e local") # Visualização de um dígito específico e sua reconstrução (para PCA) print("\n" + "=" * 60) print("Demonstração de reconstrução com PCA (100 componentes):") print("=" * 60) pca_100 = PCA(n_components=100, random_state=42) X_pca_100 = pca_100.fit_transform(X_scaled) X_reconstruido = pca_100.inverse_transform(X_pca_100) # Mostra um exemplo original e reconstruído idx = 0 fig, axes = plt.subplots(1, 2, figsize=(8, 4)) axes[0].imshow(X[idx].reshape(28, 28), cmap='gray') axes[0].set_title(f'Original - Dígito {y[idx]}') axes[0].axis('off') axes[1].imshow(X_reconstruido[idx].reshape(28, 28), cmap='gray') axes[1].set_title(f'Reconstruído (100 PCs)') axes[1].axis('off') plt.suptitle('PCA como compressor/reconstrução') plt.tight_layout() plt.show() print(f"\nErro de reconstrução (MSE): {np.mean((X[idx] - X_reconstruido[idx])**2):.4f}") print("\nConclusão: PCA é linear e rápido, mas t-SNE e UMAP revelam") print("melhor a estrutura dos dígitos em 2D. UMAP é o mais equilibrado.") |
Esse código compara três métodos de redução dimensional. O PCA é linear e rápido, mas separa menos os dígitos. O t-SNE revela agrupamentos mais nítidos e locais. O UMAP oferece bom equilíbrio entre velocidade e qualidade. Cada ponto colorido representa um dígito de 0 a 9. Clusters bem separados indicam boa redução dimensional. A reconstrução com PCA mostra a compressão e perda. Para instalar UMAP no Colab, use: !pip install umap-learn. Redução de dimensionalidade é essencial para visualização. Parabéns por explorar essas poderosas ferramentas!