VAEs

Visão geral

Autoencoders Variacionais (Variational Autoencoders, VAEs) são modelos generativos de variáveis latentes treinados com inferência variacional (variational inference). Eles aprendem:

  • Um codificador probabilístico (modelo de inferência) que mapeia dados (x) para uma distribuição sobre variáveis latentes (z): (q_\phi(z \mid x))
  • Um decodificador probabilístico (modelo generativo) que mapeia latentes de volta para dados: (p_\theta(x \mid z))
  • Uma distribuição a priori sobre os latentes, geralmente simples: (p(z))

VAEs ficam na família de modelos generativos “baseados em verossimilhança” (likelihood-based): eles otimizam um limite inferior tratável da log-verossimilhança dos dados e podem ser usados tanto para geração (amostrar um novo (x)) quanto para aprendizado de representações (usar (z) como um embedding aprendido).

No panorama da modelagem generativa, VAEs são frequentemente comparados com:

  • GANs: amostras mais nítidas, mas sem verossimilhança explícita e com treinamento mais difícil
  • Modelos Autorregressivos: excelente verossimilhança e fidelidade, mas amostragem lenta
  • Modelos de Fluxo: verossimilhança exata via transformações invertíveis, mas com restrições arquiteturais
  • Modelos de Difusão: fidelidade muito alta, mas tipicamente com amostragem/treinamento mais lentos; sistemas modernos frequentemente usam VAEs como compressores latentes

Modelagem generativa com variáveis latentes

Um VAE assume que os dados (x) são gerados primeiro amostrando um latente (z) e, em seguida, amostrando (x) condicionado a (z):

[ z \sim p(z), \quad x \sim p_\theta(x \mid z) ]

A verossimilhança marginal de uma observação (x) é:

[ p_\theta(x) = \int p_\theta(x \mid z)p(z),dz ]

Essa integral geralmente é intratável para decodificadores neurais, porque requer integrar sobre todas as configurações latentes. VAEs lidam com isso usando inferência aproximada (approximate inference).

Inferência variacional e o ELBO

O problema de inferência

A posteriori “verdadeira” é:

[ p_\theta(z \mid x) = \frac{p_\theta(x \mid z)p(z)}{p_\theta(x)} ]

Computá-la requer (p_\theta(x)), a marginal intratável. VAEs introduzem uma posteriori aproximada (q_\phi(z \mid x)) (o codificador) e a treinam para ficar próxima da posteriori verdadeira.

Esse é um arranjo padrão em Inferência Variacional.

Derivando o Evidence Lower Bound (ELBO)

Comece pela log-verossimilhança marginal:

[ \log p_\theta(x) = \log \int p_\theta(x \mid z)p(z),dz ]

Introduza (q_\phi(z \mid x)) e aplique a desigualdade de Jensen:

[ \log p_\theta(x) \ge \mathbb{E}{q\phi(z \mid x)}[\log p_\theta(x \mid z)]

  • \mathrm{KL}\big(q_\phi(z \mid x)\ |\ p(z)\big) ]

Esse limite inferior é o ELBO (Evidence Lower Bound):

\[ \mathcal{L}(\theta,\phi; x)

\underbrace{\mathbb{E}_{q_\phi(z \mid x)}[\log p_\theta(x \mid z)]}_{\text{termo de reconstrução}}

\underbrace{\mathrm{KL}\big(q_\phi(z \mid x)\ |\ p(z)\big)}_{\text{termo de regularização}} ]

Maximizar o ELBO faz duas coisas:

  1. Reconstrução: incentiva o decodificador a explicar os dados dados os latentes.
  2. Regularização: incentiva a posteriori do codificador a permanecer próxima da a priori para que possamos amostrar de (p(z)) no momento da geração.

O termo de KL usa a Divergência de Kullback–Leibler, uma medida de quão diferentes duas distribuições são.

O ponto de vista de “autoencoder”

Um autoencoder clássico aprende mapeamentos determinísticos:

  • Codificador: (z = f(x))
  • Decodificador: (\hat{x} = g(z))

Um VAE torna ambos os lados probabilísticos:

  • O codificador produz parâmetros de uma distribuição (q_\phi(z\mid x)) (frequentemente média e variância de uma Gaussiana)
  • O decodificador define uma verossimilhança (p_\theta(x\mid z)) (Gaussiana para dados contínuos, Bernoulli/Categórica para binários/discretos)

Essa formulação probabilística é o que transforma um autoencoder em um modelo generativo com um espaço latente significativo.

O truque da reparametrização (como VAEs fazem backprop através de amostragem)

Um obstáculo central: o ELBO contém uma esperança sobre amostras (z \sim q_\phi(z\mid x)), mas amostrar não é diretamente diferenciável em relação a (\phi).

Para uma escolha comum (q_\phi(z\mid x)=\mathcal{N}(\mu_\phi(x), \mathrm{diag}(\sigma^2_\phi(x)))), VAEs usam o truque da reparametrização (reparameterization trick):

[ \epsilon \sim \mathcal{N}(0, I), \quad z = \mu_\phi(x) + \sigma_\phi(x)\odot \epsilon ]

Agora a aleatoriedade está em (\epsilon), independente de (\phi), então os gradientes podem fluir por (\mu_\phi(x)) e (\sigma_\phi(x)) via Retropropagação e otimização como Descida do Gradiente.

Parametrizações típicas de VAE

A priori

Geralmente: [ p(z) = \mathcal{N}(0, I) ]

Priori simples tornam a amostragem fácil, mas podem limitar a expressividade.

Codificador (posteriori aproximada)

Frequentemente uma Gaussiana diagonal: [ q_\phi(z\mid x)=\mathcal{N}(\mu_\phi(x), \mathrm{diag}(\sigma^2_\phi(x))) ]

A rede do codificador produz (\mu) e (\log \sigma^2).

Decodificador (verossimilhança)

Depende do tipo de dado:

  • Pixels binários / normalizados: verossimilhança Bernoulli
    (\log p_\theta(x\mid z)) corresponde à entropia cruzada
  • Contínuo: verossimilhança Gaussiana
    corresponde (até constantes) ao erro quadrático médio se a variância for fixa
  • Tokens discretos (texto): verossimilhança categórica (frequentemente mais difícil de treinar com latentes contínuos; veja variantes abaixo)

Tanto codificador quanto decodificador geralmente são implementados com Redes Neurais (MLPs, CNNs, Transformers etc., dependendo do domínio).

Objetivo de treinamento na prática

Para um minibatch ({x^{(i)}}), maximize:

\[ \sum_i \Big( \mathbb{E}_{q_\phi(z \mid x^{(i)})}[\log p_\theta(x^{(i)} \mid z)]

\mathrm{KL}(q_\phi(z \mid x^{(i)}) | p(z)) \Big) ]

Em código, isso tipicamente vira:

  • Perda de reconstrução: BCE ou MSE (log-verossimilhança negativa)
  • Perda de KL: forma fechada para Gaussianas com covariância diagonal

KL em forma fechada para (q=\mathcal{N}(\mu, \sigma^2 I)) vs (p=\mathcal{N}(0, I)):

[ \mathrm{KL}(q | p) = \frac{1}{2}\sum_j\left(\mu_j^2 + \sigma_j^2 - \log\sigma_j^2 - 1\right) ]

Exemplo mínimo em PyTorch (VAE estilo MNIST)

Abaixo está um exemplo compacto mostrando a mecânica principal (o codificador produz (\mu,\log\sigma^2), reparametrização, perdas do ELBO):

import torch
import torch.nn as nn
import torch.nn.functional as F

class VAE(nn.Module):
    def __init__(self, x_dim=784, z_dim=16, hidden=400):
        super().__init__()
        # Encoder
        self.fc1 = nn.Linear(x_dim, hidden)
        self.fc_mu = nn.Linear(hidden, z_dim)
        self.fc_logvar = nn.Linear(hidden, z_dim)
        # Decoder
        self.fc2 = nn.Linear(z_dim, hidden)
        self.fc_out = nn.Linear(hidden, x_dim)

    def encode(self, x):
        h = F.relu(self.fc1(x))
        return self.fc_mu(h), self.fc_logvar(h)

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + std * eps

    def decode(self, z):
        h = F.relu(self.fc2(z))
        logits = self.fc_out(h)
        return logits  # for Bernoulli likelihood

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        logits = self.decode(z)
        return logits, mu, logvar

def vae_loss(x, logits, mu, logvar):
    # Reconstruction term: Bernoulli negative log-likelihood
    recon = F.binary_cross_entropy_with_logits(logits, x, reduction="sum")
    # KL term: closed-form KL(q||p) for diagonal Gaussians vs N(0, I)
    kl = 0.5 * torch.sum(mu.pow(2) + logvar.exp() - logvar - 1.0)
    return recon + kl, recon, kl

Notas práticas:

  • Para imagens, VAEs frequentemente se beneficiam de codificadores/decodificadores CNN em vez de MLPs.
  • A escala relativa de reconstrução vs KL pode afetar fortemente a qualidade das amostras e a utilidade do latente (veja (\beta)-VAE abaixo).

Amostragem e geração

Depois de treinado, você pode gerar novas amostras:

  1. Amostrar (z \sim p(z)=\mathcal{N}(0, I))
  2. Amostrar (x \sim p_\theta(x\mid z)) (ou usar a média do decodificador)

No caso Bernoulli (comum em VAEs de imagens “de brinquedo”), o decodificador produz logits; você pode:

  • Usar (\sigma(\text{logits})) como probabilidades de pixel
  • Amostrar pixels dessas Bernoullis ou apenas visualizar as probabilidades em tons de cinza

No que VAEs são bons (e onde têm dificuldades)

Pontos fortes

  • Treinamento estável: geralmente mais fácil do que métodos adversariais como GANs
  • Espaço latente estruturado: dá suporte a interpolação, clusterização e aprendizado de representações
  • Objetivo fundamentado: otimiza um limite inferior da verossimilhança
  • Inferência amortizada: inferência rápida por exemplo após o codificador ser treinado

Fraquezas comuns

  • Amostras borradas (especialmente para imagens) ao usar verossimilhanças simples como Gaussianas/Bernoullis fatoradas
  • Colapso da posteriori (especialmente com decodificadores poderosos): codificador é ignorado, (q(z\mid x)\approx p(z))
  • Especificação incorreta da verossimilhança: decodificadores independentes por pixel não correspondem bem às estatísticas de imagens naturais

Em muitos stacks modernos de geração de imagens, VAEs são usados menos como “geradores finais” e mais como compressores latentes (por exemplo, para mapear imagens para um espaço latente de menor dimensão onde um gerador de Modelos de Difusão opera).

Aplicações práticas

Aprendizado de representações e disentanglement (às vezes)

Latentes podem servir como características compactas para tarefas downstream (classificação, clusterização). Variantes como (\beta)-VAE incentivam uma representação latente mais fatorada, às vezes produzindo fatores mais “disentangled” (desemaranhados), embora isso não seja garantido e dependa dos dados e vieses indutivos.

Detecção de anomalias

Treine um VAE em dados “normais”. No teste, anomalias frequentemente levam a:

  • Alto erro de reconstrução
  • Baixo ELBO (limite inferior de verossimilhança ruim)

Isso é comum em monitoramento industrial, imagem médica e cenários do tipo fraude. Ressalva: a detecção de anomalias pode falhar se o VAE generalizar demais ou se as anomalias se parecerem com os dados de treino no espaço de pixels.

Imputação de dados faltantes

Como VAEs modelam (p(x\mid z)), você pode inferir (z) a partir de (x) parcialmente observado (com modificações) e então reconstruir as entradas ausentes. Isso é útil para dados tabulares e de sensores com missingness, frequentemente com verossimilhanças especializadas por tipo de atributo.

Aumento de dados

A amostragem do modelo pode aumentar conjuntos de dados pequenos. Na prática:

  • Garanta que as amostras geradas sejam diversas e consistentes com os rótulos se usadas para aprendizado supervisionado.
  • VAEs condicionais (abaixo) tipicamente são melhores para aumento condicionado à classe.

Aprendizado semi-supervisionado (resultado clássico de VAE)

Ao adicionar rótulos (y) como variáveis latentes/observadas (dependendo da formulação), VAEs podem aproveitar dados não rotulados para melhorar a classificação — particularmente em regimes com poucos rótulos.

Variantes importantes de VAE

VAE Condicional (CVAE)

Adicione informação de condicionamento (c) (rótulo de classe, texto, atributos):

[ q_\phi(z\mid x,c), \quad p_\theta(x\mid z,c) ]

Isso permite geração controlada, por exemplo, gerar um dígito condicionado ao rótulo (c \in {0,\dots,9}) ou gerar uma imagem condicionada a atributos.

\(\beta\)-VAE

Modifique o objetivo para ponderar o termo de KL:

[ \mathbb{E}_{q(z \mid x)}[\log p(x \mid z)] - \beta,\mathrm{KL}(q(z \mid x)|p(z)) ]

  • (\beta>1): regularização mais forte, frequentemente mais “disentangled”, mas pior reconstrução
  • (\beta<1): reconstruções melhores, mas o espaço latente pode ficar menos organizado

VQ-VAE (VAE com Quantização Vetorial)

Usa códigos latentes discretos via um codebook aprendido (quantização). Benefícios:

  • Evita parte do borramento ao deslocar o “ônus” da modelagem
  • Útil para combinar com decodificadores poderosos (por exemplo, a priori autorregressivas sobre códigos)

VQ-VAEs são amplamente usados como um tokenizer para imagens/áudio em pipelines generativos.

VAEs hierárquicos e a prioris/posterioris mais ricas

Você pode aumentar a expressividade com:

  • Múltiplas camadas latentes ((z) hierárquico)
  • Posterioris aproximadas mais expressivas (por exemplo, com fluxos normalizantes; veja Modelos de Fluxo)
  • A prioris aprendidas (misturas, VampPrior etc.)

Isso melhora o ajuste, mas adiciona complexidade e potencial dificuldade de otimização.

Colapso da posteriori e como profissionais lidam com isso

Colapso da posteriori acontece quando o decodificador fica tão forte que modela (p(x)) sem precisar de (z). Então:

  • O termo de KL vai para ~0
  • Os latentes carregam pouca informação sobre (x)

Mitigações comuns:

  • Anelamento de KL (KL annealing): aumentar gradualmente o peso do KL durante o treinamento
  • Free bits / piso de KL (KL floor): impor um KL mínimo por dimensão latente
  • Decodificador mais fraco / restrições arquiteturais: limitar a capacidade do decodificador para que ele precise usar (z)
  • Skip connections com cuidado: skips demais podem permitir que o decodificador ignore os latentes
  • Objetivos alternativos: por exemplo, incentivo à informação mútua no estilo InfoVAE

Esse problema é especialmente evidente quando o decodificador é um modelo autorregressivo (por exemplo, um Transformer) treinado para prever pixels/tokens muito bem.

Avaliação e diagnósticos

Formas comuns de avaliar VAEs:

  • ELBO em dados de validação: proxy do objetivo de treino; maior é melhor (menos negativo)
  • Qualidade de reconstrução: visualizar reconstruções e medir distorção (MSE/BCE)
  • Interpolações no latente: amostrar dois valores (z) e interpolar para testar suavidade
  • Qualidade das amostras: inspeção subjetiva; também métricas como FID (embora mais típica para GAN/difusão)

Atenção: ELBO mais alto nem sempre significa amostras “mais bonitas”, porque a fidelidade das amostras depende fortemente do modelo de verossimilhança e das suposições do decodificador.

Como VAEs se comparam a outras famílias de modelos generativos

  • Vs GANs: VAEs são mais estáveis e fundamentados (ELBO), mas frequentemente menos nítidos para imagens a menos que sejam aprimorados.
  • Vs Modelos Autorregressivos: VAEs podem amostrar em uma única passada forward (rápido), enquanto a amostragem autorregressiva é sequencial (lenta), mas com fidelidade muito alta.
  • Vs Modelos de Fluxo: fluxos fornecem verossimilhança exata e inferência exata, mas exigem restrições de invertibilidade; VAEs são mais flexíveis, mas otimizam um limite.
  • Vs Modelos de Difusão: difusão frequentemente vence em qualidade de imagem; VAEs frequentemente servem como etapa de compressão latente para difusão (difusão latente), melhorando velocidade e memória.

Resumo

Um VAE é um modelo generativo que combina:

  • Um modelo de variáveis latentes (p_\theta(x,z)=p_\theta(x\mid z)p(z))
  • Uma aproximação variacional amortizada (q_\phi(z\mid x))
  • O objetivo ELBO que equilibra reconstrução e regularização do latente
  • O truque da reparametrização que possibilita treinamento eficiente baseado em gradientes

VAEs continuam sendo uma ferramenta fundamental para aprendizado de representações probabilísticas, espaços latentes estruturados, detecção de anomalias e como blocos de construção em sistemas generativos modernos — especialmente quando integrados a a prioris mais fortes ou combinados com outras famílias de modelos.