Redução de Dimensionalidade

O que é redução de dimensionalidade?

Redução de dimensionalidade transforma dados de um espaço de características de alta dimensionalidade (centenas a milhões de características) em uma representação de menor dimensionalidade (frequentemente 2–100 dimensões), preservando uma estrutura “importante”. Ela é amplamente usada para:

  • Visualização (embeddings 2D/3D para exploração)
  • Compressão (armazenar/transmitir menos números, modelos posteriores mais rápidos)
  • Remoção de ruído (remover componentes de ruído de baixa variância)
  • Acelerar o aprendizado (menos características → menos computação e, às vezes, melhor generalização)
  • Mitigar a maldição da dimensionalidade (curse of dimensionality) (distância/similaridade se torna menos significativa em altas dimensões)

Métodos de redução de dimensionalidade diferem principalmente em o que eles tentam preservar:

  • Geometria global / variância (por exemplo, PCA)
  • Vizinhanças locais (por exemplo, t-SNE, UMAP)
  • Fidelidade de reconstrução (por exemplo, PCA, autoencoders)
  • Separabilidade de classes (variantes supervisionadas como LDA; fora do foco deste artigo)

Este artigo foca em PCA (um “cavalo de batalha” linear para compressão e pré-processamento) e em métodos de visualização não lineares como t-SNE e UMAP.

Por que alta dimensionalidade é difícil

Muitos algoritmos de ML degradam em altas dimensões porque:

  • As distâncias se concentram: os pontos mais próximos e mais distantes ficam a distâncias semelhantes, prejudicando k-NN, clusterização e pontuação de anomalias.
  • Os dados ficam esparsos: o volume do espaço cresce exponencialmente; você precisa de muito mais amostras para cobri-lo.
  • O ruído se acumula: características irrelevantes podem dominar métricas de similaridade e fronteiras de decisão.

A redução de dimensionalidade frequentemente ajuda tarefas posteriores como Clusterização, Detecção de Anomalias e modelos lineares como Regressão Linear/Logística.

Duas grandes famílias: linear vs não linear

Métodos lineares (PCA)

Assumem que os dados estão próximos de um subespaço linear de baixa dimensionalidade. Você projeta em um conjunto de direções ortogonais que capturam a variância máxima.

  • Prós: rápido, estável, interpretável, suporta compressão e reconstrução
  • Contras: não consegue “desdobrar” variedades não lineares

Métodos não lineares (t-SNE, UMAP)

Assumem que os dados estão sobre uma variedade não linear (manifold); preservam relações de vizinhança mais do que a geometria global.

  • Prós: excelente para visualização de clusters e estrutura local
  • Contras: embeddings podem ser enganosos se superinterpretados; em geral não é ideal como etapa genérica de compressão para modelagem preditiva

Análise de Componentes Principais (PCA)

Intuição

PCA encontra novos eixos (componentes principais) de modo que:

  1. O primeiro componente captura a variância máxima nos dados.
  2. O segundo captura a máxima variância restante ortogonal ao primeiro.
  3. E assim por diante.

Projetar nos primeiros (k) componentes produz uma representação (k)-dimensional que preserva o máximo de variância possível dentre todas as projeções lineares.

A visão de otimização (maximização de variância)

Dada a matriz de dados centralizada (X \in \mathbb{R}^{n \times d}) (linhas são amostras), PCA resolve:

[ \max_{|w|=1} \mathrm{Var}(Xw) ]

A solução é o autovetor principal da matriz de covariância:

[ \Sigma = \frac{1}{n} X^\top X ]

Os (k) principais autovetores fornecem o subespaço principal.

A visão de reconstrução (mínimos quadrados)

PCA também é a melhor aproximação de posto-(k) de (X) sob erro quadrático:

[ \min_{\mathrm{rank}(Z)=k} |X - Z|_F^2 ]

É por isso que PCA é naturalmente adequada para compressão: você pode armazenar (k) coordenadas por amostra e reconstruir aproximadamente.

Implementação via SVD (como é computado na prática)

PCA é tipicamente computado via Decomposição em Valores Singulares (Singular Value Decomposition, SVD):

[ X = U S V^\top ]

  • As colunas de (V) são direções principais.
  • Valores singulares se relacionam à variância explicada.

Bibliotecas modernas usam variantes eficientes como SVD randomizada para (d) grande.

Variância explicada e escolha de \(k\)

A razão de variância explicada (explained variance ratio) do componente (i) é:

[ \frac{\lambda_i}{\sum_j \lambda_j} ]

Formas comuns de escolher (k):

  • Manter componentes suficientes para chegar a 90–99% de variância explicada
  • Usar um gráfico scree e o “cotovelo”
  • Escolher (k) pelo desempenho posterior em validação cruzada

Pré-processamento prático: centralização e escala

  • Sempre centralize as características antes de PCA (subtrair a média).
  • Escalone quando as unidades das características diferem (por exemplo, “idade” vs “renda”). PCA é baseado em variância; características em escala maior podem dominar.

Na prática, frequentemente se usa StandardScaler antes de PCA. Para dados esparsos de alta dimensionalidade (por exemplo, bag-of-words), escalar pode não ser apropriado; use TruncatedSVD em vez disso (funciona como PCA sem centralizar).

PCA para compressão (o que você de fato armazena)

Para comprimir (x \in \mathbb{R}^d) em (z \in \mathbb{R}^k):

[ z = (x - \mu) W_k ]

onde (W_k) contém as (k) principais direções. Para reconstruir:

[ \hat{x} = z W_k^\top + \mu ]

A qualidade da compressão depende de quão bem os dados se aproximam de um subespaço linear (k)-dimensional.

Exemplo: PCA como etapa de pré-processamento para classificação

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression

X, y = load_breast_cancer(return_X_y=True)

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("pca", PCA(n_components=10, random_state=0)),
    ("clf", LogisticRegression(max_iter=5000))
])

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
scores = cross_val_score(pipe, X, y, cv=cv, scoring="accuracy")
print(scores.mean(), scores.std())

Ponto-chave: usar um Pipeline evita vazamento de dados (data leakage) porque o PCA é ajustado apenas nos folds de treino durante a validação cruzada.

Variantes de PCA que você pode encontrar

  • IncrementalPCA: para conjuntos de dados grandes demais para a memória; processa minibatches.
  • TruncatedSVD: semelhante a PCA para matrizes esparsas (comum em texto).
  • Kernel PCA: extensão não linear usando kernels (relacionada a SVMs); mais custosa e menos comum para dados muito grandes.
  • Branqueamento (whitening): escala componentes para variância unitária; às vezes ajuda modelos, às vezes amplifica ruído.

t-SNE (Incorporação Estocástica de Vizinhos Distribuída em t; t-distributed Stochastic Neighbor Embedding)

Para que serve o t-SNE

t-SNE é principalmente uma ferramenta de visualização. Ele mapeia pontos de alta dimensionalidade para 2D/3D de forma que pontos próximos permaneçam próximos. É excelente para descobrir estrutura semelhante a clusters em embeddings (por exemplo, embeddings de palavras ou imagens), mas não foi projetado para preservar fielmente a geometria global nem para compressão usada em pipelines de modelagem.

Ideia central (alto nível)

  1. Converter distâncias par-a-par em alta-D em probabilidades de vizinhança (cada ponto tem uma vizinhança Gaussiana).
  2. Definir uma distribuição de probabilidade semelhante em baixa-D, mas usando uma distribuição t de Student de cauda pesada (heavy-tailed) (reduz “crowding”).
  3. Otimizar as coordenadas em baixa-D para minimizar a divergência KL entre essas distribuições.

Isso faz com que t-SNE enfatize fortemente a preservação de vizinhanças locais.

Hiperparâmetros importantes (e o que significam)

  • Perplexidade (perplexity): aproximadamente o número efetivo de vizinhos. Valores comuns: 5–50.
    • Muito baixa → clusters fragmentados
    • Muito alta → suavização excessiva, pode borrar a estrutura local
  • Taxa de aprendizado (learning rate): afeta a dinâmica da otimização.
  • Inicialização (initialization): com frequência, inicialização por PCA melhora a estabilidade.
  • Semente aleatória (random seed): diferentes execuções podem parecer diferentes.

Como interpretar gráficos de t-SNE com segurança

Gráficos de t-SNE são fáceis de superinterpretar. Regras práticas:

  • Separação de clusters é significativa localmente, mas distâncias globais não são confiáveis.
  • Tamanhos de clusters não são diretamente significativos.
  • “Lacunas” aparentes entre clusters podem ser artefatos do objetivo do embedding.
  • Sempre valide com visões alternativas (PCA, UMAP) e checagens do domínio.

Padrão prático: usar PCA antes de t-SNE

Um fluxo comum é:

  1. Reduzir para 30–100 dimensões com PCA (remover ruído, acelerar).
  2. Rodar t-SNE para 2D.

Isso frequentemente melhora tanto a qualidade quanto o tempo de execução.

from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

X, y = load_digits(return_X_y=True)

X_pca = PCA(n_components=50, random_state=0).fit_transform(X)
X_tsne = TSNE(
    n_components=2,
    perplexity=30,
    init="pca",
    learning_rate="auto",
    random_state=0
).fit_transform(X_pca)

plt.figure(figsize=(7, 6))
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, s=10, cmap="tab10")
plt.title("t-SNE on Digits (PCA->t-SNE)")
plt.show()

Limitações para compressão e implantação

  • O t-SNE padrão não aprende naturalmente um mapeamento reutilizável para incorporar novos pontos (embora existam variantes paramétricas e aproximadas).
  • É relativamente lento para conjuntos de dados muito grandes (embora implementações modernas escalem melhor do que versões antigas).
  • Não é ideal como etapa de pré-processamento para aprendizado supervisionado; pode distorcer a estrutura de formas que prejudicam o desempenho preditivo.

UMAP (Aproximação e Projeção Uniforme de Variedades; Uniform Manifold Approximation and Projection)

Para que serve o UMAP

UMAP é um método não linear usado para:

  • Visualização (como t-SNE)
  • Às vezes, como um embedding de uso geral para tarefas posteriores (mais frequentemente do que t-SNE), porque pode fornecer uma geometria mais consistente e dá suporte à transformação de novos pontos em implementações comuns.

UMAP tende a ser mais rápido e mais escalável do que o t-SNE clássico e frequentemente preserva mais da estrutura global, embora ainda enfatize vizinhanças locais.

Fundamentação conceitual (alto nível)

UMAP se baseia em:

  • Uma hipótese de variedade (manifold): os dados estão em uma variedade de menor dimensionalidade dentro de alta-D.
  • Construção de um grafo de k-vizinhos mais próximos (k-nearest neighbor graph) em alta-D.
  • Converter esse grafo em um conjunto simplicial difuso (fuzzy simplicial set) (um grafo ponderado representando pertencimento à vizinhança).
  • Otimizar coordenadas em baixa-D para que o grafo em baixa-D corresponda ao grafo em alta-D via um objetivo semelhante a entropia cruzada.

Hiperparâmetros principais

  • n_neighbors: tamanho da vizinhança usada para construir o grafo.
    • Menor → mais detalhe local, clusters mais “apertados”
    • Maior → mais estrutura global
  • min_dist: quão “apertado” o UMAP empacota os pontos em baixa-D.
    • Menor → clusters mais densos
    • Maior → embeddings mais espalhados
  • metric: função de distância (euclidean, cosine, etc.). Cosseno é comum para embeddings de texto.

Exemplo: UMAP para visualização 2D

UMAP é comumente fornecido pelo pacote umap-learn:

import umap
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

X, y = load_digits(return_X_y=True)

X_50 = PCA(n_components=50, random_state=0).fit_transform(X)

reducer = umap.UMAP(
    n_components=2,
    n_neighbors=15,
    min_dist=0.1,
    random_state=0
)
X_umap = reducer.fit_transform(X_50)

plt.figure(figsize=(7, 6))
plt.scatter(X_umap[:, 0], X_umap[:, 1], c=y, s=10, cmap="tab10")
plt.title("UMAP on Digits (PCA->UMAP)")
plt.show()

UMAP vs t-SNE na prática

Observações comuns de praticantes:

  • UMAP: mais rápido, escala bem, frequentemente preserva mais do layout global, pode ser usado para embedding + clusterização.
  • t-SNE: frequentemente produz separação local de clusters muito clara, mas a geometria global é menos significativa.

Para descoberta de clusters, ambos são frequentemente combinados com Clusterização no espaço original ou em um espaço reduzido por PCA — não no embedding 2D de visualização.

Redução de dimensionalidade para visualização vs compressão

Objetivos de visualização (2D/3D)

Para exploração e apresentações:

  • Comece com PCA para uma checagem rápida de sanidade e para identificar direções dominantes/outliers.
  • Use UMAP ou t-SNE para gráficos 2D/3D que preservem vizinhanças.
  • Considere colorir por rótulos, tempo, atributos do domínio ou predições do modelo.

Boa prática:

  • Tente múltiplas sementes aleatórias e hiperparâmetros para garantir que padrões sejam estáveis.
  • Use conhecimento de domínio para validar clusters aparentes.

Objetivos de compressão (k=10…300)

Para armazenamento, velocidade e modelagem:

  • PCA (ou TruncatedSVD) é uma excelente opção padrão porque fornece:
    • Um mapeamento linear estável
    • Transformação/inversa rápidas
    • Uma troca clara entre variância e dimensionalidade

UMAP pode comprimir para dimensionalidades moderadas e às vezes ajuda classificação ou clusterização, mas introduz distorções não lineares e tem hiperparâmetros adicionais; PCA costuma ser mais previsível.

Como a redução de dimensionalidade se encaixa em fluxos de trabalho de ML

Casos de uso comuns

  • Pré-processamento para modelos baseados em distância: k-NN, alguns detectores de anomalias e clusterização se beneficiam porque as distâncias se tornam mais significativas em um subespaço de menor dimensionalidade.
  • Redução de ruído: PCA pode remover direções de ruído de baixa variância.
  • Engenharia de características para dados tabulares: às vezes ajuda modelos lineares, às vezes prejudica ensembles de árvores.
    • Para Árvores de Decisão e Ensembles, PCA frequentemente traz menos benefício porque árvores lidam com características irrelevantes de outra forma; ainda pode ajudar se as características forem extremamente altas dimensões ou colineares.
  • Embeddings e aprendizado de representações: você pode reduzir embeddings aprendidos por um modelo neural (Redes Neurais) para visualização.

Evitando erros comuns

  • Vazamento de dados (data leakage): ajuste PCA/UMAP apenas nos dados de treino dentro de cada fold de validação cruzada (use pipelines).
  • Escalonamento incorreto: características não escalonadas podem dominar o PCA.
  • Superinterpretar 2D: gráficos de t-SNE/UMAP não são “mapas” fiéis de distâncias reais.
  • Usar embeddings 2D para modelagem: um embedding 2D de t-SNE quase nunca é um bom conjunto de características para um classificador.

Medindo qualidade: o que é “bom” depende do objetivo

Para PCA (compressão/reconstrução)

  • Razão de variância explicada (explained variance ratio)
  • Erro de reconstrução: (|X - \hat{X}|)
  • Desempenho na tarefa posterior (com validação adequada)

Para embeddings que preservam vizinhança (t-SNE/UMAP)

  • Confiabilidade / continuidade (trustworthiness / continuity) (relações de k-NN sobrevivem?)
  • Acurácia de classificação k-NN no espaço do embedding (como diagnóstico, não como métrica final)
  • Estabilidade visual entre sementes/hiperparâmetros

Escolhendo o método certo (guia prático)

Use PCA quando você quer:

  • Compressão confiável com uma troca controlável
  • Treinamento/inferência mais rápidos para modelos posteriores
  • Um baseline simples e interpretabilidade (cargas mostram influência das características)

Use t-SNE quando você quer:

  • Uma visualização 2D/3D de alta qualidade enfatizando clusters locais
  • Análise exploratória de embeddings (por exemplo, representações do modelo)

Use UMAP quando você quer:

  • Visualização com melhor escalabilidade
  • Uma transformação de embedding reutilizável (comum na prática)
  • Um método que frequentemente retém mais estrutura global do que t-SNE

Um fluxo robusto para visualização costuma ser:

  1. Padronizar (se apropriado)
  2. PCA para 30–100 dimensões
  3. UMAP/t-SNE para 2D

Resumo

A redução de dimensionalidade é uma ferramenta central para tornar dados de alta dimensionalidade mais manejáveis. PCA fornece uma projeção linear eficiente e bem fundamentada, que se destaca em compressão, remoção de ruído e pré-processamento. t-SNE e UMAP são métodos não lineares usados principalmente para visualizar estruturas complexas preservando vizinhanças locais; UMAP é frequentemente mais rápido e mais fácil de implantar, enquanto t-SNE é um clássico para produzir visões claras orientadas a clusters.

Quando usada com cuidado — evitando vazamento, escalonando apropriadamente e interpretando gráficos com conservadorismo — a redução de dimensionalidade pode melhorar significativamente tanto a compreensão quanto o desempenho em tarefas como Clusterização, Detecção de Anomalias e modelagem baseada em características.