Arquivo de AM Não Supervisionado - Página 6 de 8

2 – Nao Supervisionado
2.2 – Reducao de Dimensionalidade
2.2.1 – PCA, t-SNE, LDA, UMAP, Autoencoders

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

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.

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.")

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!

Regras de Associação

descobrindo itens que andam juntos

métricas essenciais: suporte, confiança, lift

algoritmo apriori: mineração eficiente

aplicações além de cestas de compras

PCA, t-SNE, LDA, UMAP, Autoencoders

O que é redução de dimensionalidade

Arquitetura e características dos modelos

Hiperparâmetros e fórmulas matemáticas

Enunciado do exemplo clássico (dígitos MNIST)