Modelagem Generativa

O que “modelagem generativa (generative modeling)” significa

Um modelo generativo (generative model) é um modelo probabilístico que pode gerar novas amostras que se assemelham a um conjunto de dados. Formalmente, assumimos que existe uma distribuição de dados desconhecida (p_{\text{data}}(x)) sobre observações (x) (texto, imagens, áudio, linhas tabulares, trajetórias, …). Um modelo generativo define uma distribuição (p_\theta(x)) (ou um procedimento que implicitamente define uma) e é treinado para que (p_\theta) se aproxime de (p_{\text{data}}).

Uma vez treinado, podemos:

  • Amostrar novos (x \sim p_\theta(x)) (geração incondicional).
  • Amostrar condicionado a alguma entrada (c): (x \sim p_\theta(x \mid c)) (por exemplo, “gerar uma imagem dado um prompt de texto”).
  • Computar ou aproximar verossimilhanças (likelihoods) (p_\theta(x)) para tarefas como detecção de anomalias, compressão ou estimativa de incerteza (dependente do modelo).

Este artigo apresenta as principais famílias de modelos generativos e, mais importante, como a amostragem funciona em cada família.

Aprofundamentos relacionados: Modelos Autorregressivos, VAEs, GANs, Modelos de Fluxo, Modelos de Difusão. Para ver como modelos generativos aparecem em sistemas para usuários finais, veja Modelos de Linguagem Grandes, Criação de Prompts e Recuperação e Ferramentas.

Ideias centrais compartilhadas entre as famílias

Modelos de densidade explícita vs implícita

Modelos generativos diferem quanto a definir uma função de densidade/massa de probabilidade explícita.

  • Densidade explícita: o modelo consegue avaliar (exatamente ou aproximadamente) (\log p_\theta(x)).
    • Exemplos: modelos autorregressivos (exato), fluxos normalizantes (exato), VAEs (aproximado via ELBO), muitas formulações de difusão (frequentemente treinadas via objetivos de remoção de ruído/pontuação em vez de verossimilhança direta, mas a verossimilhança às vezes pode ser estimada com mecanismos adicionais).
  • Densidade implícita: o modelo define um procedimento de amostragem sem uma verossimilhança tratável.
    • Exemplo: GANs (formulação clássica).

Essa distinção importa para avaliação e para tarefas em que uma verossimilhança calibrada é útil.

Máxima verossimilhança e fatoração

Muitas abordagens podem ser vistas como maneiras de tornar a estimação por máxima verossimilhança (maximum likelihood estimation, MLE) viável:

[ \theta^* = \arg\max_\theta ; \mathbb{E}{x\sim p{\text{data}}}[\log p_\theta(x)]. ]

Modelos autorregressivos tornam (\log p_\theta(x)) tratável ao fatorá-lo em um produto de distribuições condicionais (regra da cadeia). Fluxos tornam isso tratável via transformações inversíveis e a fórmula de mudança de variáveis. VAEs otimizam um limitante inferior. Modelos de difusão usam objetivos de remoção de ruído/pontuação que se conectam à verossimilhança via processos estocásticos.

Variáveis latentes

Muitos modelos introduzem uma variável latente (z) para representar fatores subjacentes:

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

A amostragem vira “amostrar (z) e então decodificar”. Isso é o núcleo de VAEs e GANs, e também aparece em sistemas híbridos (por exemplo, VQ-VAEs com um prior autorregressivo).

Condicionamento e orientação

Sistemas generativos modernos frequentemente são condicionais:

  • Condicionado por classe: (p(x \mid y)) (por exemplo, “gerar um cachorro”)
  • Condicionado por texto: (p(x \mid \text{prompt}))
  • Preenchimento/edição (inpainting/editing): (p(x_{\text{missing}} \mid x_{\text{known}}))

O condicionamento pode ser implementado por concatenação, atenção cruzada (cross-attention) (comum na Arquitetura Transformer), orientação por classificador (classifier guidance) ou orientação sem classificador (classifier-free guidance) (popular em modelos de difusão).

Família 1: Modelos autorregressivos (autoregressive, AR)

Modelos autorregressivos definem uma distribuição decompondo-a em uma sequência de previsões condicionais:

[ p_\theta(x) = \prod_{t=1}^T p_\theta(x_t \mid x_{<t}). ]

Para texto, (x_t) é o próximo token. Para imagens/áudio, é possível rasterizar em sequências ou usar fatorações estruturadas.

Objetivo de treinamento

O treinamento é tipicamente por forçamento do professor (teacher forcing): maximizar o log-probabilidade do próximo elemento dado o prefixo de verdade-terreno. Isso é aprendizado supervisionado padrão com perda de entropia cruzada e é otimizado com Descida do Gradiente via Retropropagação.

Como a amostragem funciona

A amostragem é sequencial:

  1. Comece com um prompt/prefixo (x_{<1}) (talvez vazio).
  2. Para (t = 1..T):
    • Compute a distribuição (p_\theta(x_t \mid x_{<t})).
    • Amostre (x_t) (ou escolha via estratégia de decodificação).
    • Anexe ao prefixo.

Estratégias de decodificação comuns:

  • Gananciosa (greedy): escolher (\arg\max).
  • Temperatura (temperature): amostrar de (\text{softmax}(\text{logits}/\tau)) (menor (\tau) = mais determinístico).
  • Top-(k): restringir aos (k) tokens mais prováveis.
  • Núcleo (nucleus, top-(p)): restringir ao menor conjunto cuja probabilidade cumulativa ≥ (p).
  • Busca em feixe (beam search): mantém múltiplas hipóteses (mais comum em tradução do que em geração aberta).
# Pseudocode: autoregressive sampling
x = prompt_tokens[:]  # may be empty
for t in range(max_new_tokens):
    logits = model(x)               # predicts next-token logits
    probs = softmax(logits / temp)
    probs = top_p_filter(probs, p=0.9)
    next_token = sample(probs)
    x.append(next_token)
return x

Pontos fortes e fracos

Pontos fortes

  • Verossimilhança exata (para sequências discretas) e treinamento direto.
  • Excelente para texto/código; base dos modernos Modelos de Linguagem Grandes.
  • Geração condicional natural (criação de prompts como condicionamento).

Pontos fracos

  • A amostragem é inerentemente sequencial, o que pode ser mais lento para saídas longas.
  • Viés de exposição (exposure bias): treinado com prefixos de verdade-terreno, mas amostra a partir dos próprios prefixos (mitigado por escala, dados e técnicas como RLHF/DFT em pipelines de modelos de linguagem grandes).

Veja: Modelos Autorregressivos.

Exemplo prático: geração de texto

Dado um prompt como “Escreva uma função Python que…”, um modelo autorregressivo prevê iterativamente o próximo token, produzindo código coerente. Ajustar temperatura/top-(p) equilibra criatividade vs determinismo.

Família 2: Autoencoders Variacionais (VAEs)

VAEs são modelos com variáveis latentes com um codificador e um decodificador aprendidos:

  • Prior: (p(z)) (frequentemente (\mathcal{N}(0, I)))
  • Decodificador (gerador): (p_\theta(x \mid z))
  • Codificador (posterior aproximada): (q_\phi(z \mid x))

Objetivo de treinamento (ELBO)

Maximizar diretamente (\log p_\theta(x)) é difícil porque requer integrar sobre (z). VAEs maximizam o limitante inferior da evidência (evidence lower bound, ELBO):

[ \log p_\theta(x) \ge \mathbb{E}{z \sim q\phi(z \mid x)}[\log p_\theta(x \mid z)] - \text{KL}(q_\phi(z \mid x),|,p(z)). ]

Intuitivamente:

  • Termo de reconstrução: decodificar (z) de volta para (x).
  • Termo KL: manter a distribuição latente próxima do prior para que a amostragem funcione.

Como a amostragem funciona

A amostragem é um processo de duas etapas:

  1. Amostrar latente (z \sim p(z)).
  2. Amostrar (ou emitir a média de) (x \sim p_\theta(x \mid z)).
# Pseudocode: VAE sampling
z = torch.randn(batch_size, latent_dim)  # z ~ N(0, I)
x = decoder(z)                           # parameters of p(x|z)
return x

Pontos fortes e fracos

Pontos fortes

  • Amostragem rápida (uma passagem forward).
  • Aprende um espaço latente estruturado útil para interpolação, aprendizado de representações e tarefas downstream.
  • Verossimilhança é tratável via um limitante (ELBO), permitindo alguma avaliação probabilística.

Pontos fracos

  • Pode produzir amostras “borradas” em cenários de imagem com decodificadores gaussianos simples.
  • Colapso do posterior (posterior collapse) (o decodificador ignora (z)) pode ocorrer, especialmente com decodificadores muito fortes.

Veja: VAEs.

Exemplo prático: detecção de anomalias

Um VAE treinado em dados “normais” pode sinalizar anomalias quando o erro de reconstrução é alto ou quando o ELBO é incomumente baixo — útil em manufatura ou monitoramento de fluxos de sensores (com calibração cuidadosa).

Família 3: Redes Adversariais Generativas (GANs)

GANs aprendem um gerador (G_\theta(z)) que mapeia ruído (z \sim p(z)) para o espaço de dados, treinado contra um discriminador (D_\psi(x)) que tenta distinguir amostras reais de geradas.

Objetivo de treinamento (jogo adversarial)

O treinamento clássico de GAN resolve:

[ \min_G \max_D ; \mathbb{E}{x\sim p{\text{data}}}[\log D(x)] + \mathbb{E}_{z\sim p(z)}[\log(1 - D(G(z)))]. ]

Muitas variantes (WGAN, hinge loss, spectral normalization) melhoram a estabilidade.

Como a amostragem funciona

A amostragem é extremamente simples:

  1. Amostrar (z \sim p(z)).
  2. Emitir (x = G_\theta(z)).
# Pseudocode: GAN sampling
z = torch.randn(batch_size, latent_dim)
x = G(z)   # one forward pass
return x

Pontos fortes e fracos

Pontos fortes

  • Frequentemente produz detalhes muito nítidos e de alta frequência (historicamente forte para imagens).
  • Amostragem muito rápida (uma única passagem).

Pontos fracos

  • Sem verossimilhança tratável na forma padrão.
  • Instabilidade de treinamento e colapso de modos (mode collapse) (o gerador cobre apenas parte da distribuição de dados).
  • Mais difícil de escalar e controlar em comparação com difusão ou grandes transformers autorregressivos em muitos pipelines modernos.

Veja: GANs.

Exemplo prático: síntese de imagens em domínios restritos

GANs continuam práticas quando você precisa de geração de alto throughput (por exemplo, gerar muitas imagens pequenas rapidamente) e consegue tolerar um treinamento mais frágil, especialmente em domínios estreitos com fortes vieses indutivos.

Família 4: Fluxos Normalizantes (Normalizing Flows)

Fluxos normalizantes são modelos inversíveis que transformam uma distribuição base simples em uma complexa via uma sequência de bijeções:

  • Base: (z \sim p(z)) (por exemplo, gaussiana)
  • Transformação: (x = f_\theta(z)), com (f_\theta) inversível

Objetivo de treinamento (verossimilhança exata via mudança de variáveis)

Como (f) é inversível:

[ \log p_\theta(x) = \log p(z) + \log \left|\det \frac{\partial f^{-1}(x)}{\partial x}\right| \quad \text{where } z = f^{-1}(x). ]

Isso fornece log-verossimilhança exata, um ponto-chave.

Como a amostragem funciona

A amostragem é direta:

  1. Amostrar (z \sim p(z)).
  2. Calcular (x = f_\theta(z)).
# Pseudocode: flow sampling
z = torch.randn(batch_size, dim)
x = flow.forward(z)  # z -> x
return x

Pontos fortes e fracos

Pontos fortes

  • Verossimilhança exata e amostragem exata.
  • Úteis quando estimação de densidade é central (alguns cenários científicos e semelhantes a compressão).

Pontos fracos

  • Restrições de inversibilidade podem limitar expressividade ou aumentar computação/memória.
  • Para dados perceptuais de alta dimensão (imagens grandes), fluxos historicamente foram menos dominantes do que difusão/autorregressivos em qualidade de amostras, embora a pesquisa continue (por exemplo, correspondência de fluxo (flow matching) e fluxo retificado (rectified flow) desfocam a fronteira com métodos do tipo difusão).

Veja: Modelos de Fluxo.

Exemplo prático: simulação e modelagem científica

Fluxos são uma boa escolha quando você precisa tanto de amostragem quanto de verossimilhanças — por exemplo, modelagem substituta com incerteza em física, ou pipelines de inferência probabilística em que razões de densidade importam.

Família 5: Modelos de difusão e baseados em pontuação (score-based)

Modelos de difusão definem um processo direto de adição de ruído que destrói gradualmente a estrutura e aprendem um processo reverso de remoção de ruído para gerar amostras removendo ruído iterativamente.

Processo direto

Partindo de dados (x_0), produza (x_t) adicionando ruído ao longo de (T) passos:

[ q(x_t \mid x_{t-1}) = \mathcal{N}(\sqrt{1-\beta_t}x_{t-1}, \beta_t I). ]

Após muitos passos, (x_T) fica próximo de ruído gaussiano puro.

Objetivo de treinamento (remoção de ruído / correspondência de pontuação)

Um alvo comum de treinamento é prever o ruído (\epsilon) adicionado no passo (t), ou prever (x_0), ou a pontuação (\nabla_{x_t}\log q(x_t)). Um objetivo padrão:

[ \mathbb{E}{t, x_0, \epsilon}\left[|\epsilon - \epsilon\theta(x_t, t, c)|^2\right]. ]

Como a amostragem funciona

A amostragem começa do ruído e remove ruído iterativamente:

  1. Amostrar (x_T \sim \mathcal{N}(0, I)).
  2. Para (t=T \rightarrow 1):
    • Usar a rede para prever a direção de remoção de ruído (ruído/pontuação).
    • Amostrar (x_{t-1}) a partir de uma distribuição reversa estimada.
# Pseudocode: diffusion sampling (conceptual)
x = torch.randn(batch_size, dim)   # x_T
for t in reversed(range(1, T+1)):
    eps = eps_model(x, t, cond)    # predict noise
    x = denoise_step(x, eps, t)    # sampler update (DDPM/DDIM/etc.)
return x  # x_0

Na prática, amostradores variam:

  • DDPM: estocástico, muitos passos.
  • DDIM: determinístico ou semi-determinístico, menos passos.
  • DPM-Solver / solvers de ODE: amostragem mais rápida com menos avaliações.
  • Destilação / consistência (consistency): comprime muitos passos em poucos.

Pontos fortes e fracos

Pontos fortes

  • Qualidade de amostras estado da arte para imagens/áudio; forte controlabilidade (condicionamento, preenchimento, edição).
  • Treinamento estável em comparação com GANs em muitos regimes.
  • Mecanismos de condicionamento flexíveis (texto, máscaras, mapas de profundidade, etc.).

Pontos fracos

  • A amostragem pode ser mais lenta devido ao refinamento iterativo (embora melhore rapidamente com amostradores melhores e destilação).
  • A verossimilhança não é tão direta quanto em autorregressivos/fluxos (embora existam conexões).

Veja: Modelos de Difusão.

Exemplo prático: geração de texto para imagem

Um codificador de texto produz embeddings para um prompt; o modelo de difusão remove ruído começando de ruído aleatório enquanto faz atenção ao prompt. Orientação sem classificador amplifica a aderência ao texto ao custo de alguma diversidade.

Híbridos e tendências modernas (brevemente)

Sistemas reais frequentemente combinam ideias:

  • Difusão latente (latent diffusion): difundir em um espaço latente aprendido (frequentemente de um autoencoder) para velocidade/memória.
  • VQ-VAE + prior autorregressivo: comprimir imagens em códigos discretos e então treinar um modelo autorregressivo sobre os códigos.
  • Transformers de difusão (Diffusion Transformers) / do tipo DiT (DiT-like): backbones transformer como removedores de ruído para processos de difusão.
  • Correspondência de fluxo / fluxo retificado: treinamento que se assemelha à difusão, mas resulta em amostragem do tipo ODE com menos passos.

Esses híbridos refletem um padrão geral: escolher um objetivo de treinamento estável e escalável e então projetar a amostragem para ser rápida e controlável.

Condicionamento: como modelos geram “o que você pediu”

Geração condicional pode ser expressa como (p(x \mid c)). A mecânica difere por família:

  • Autorregressivos: prefixar tokens de condicionamento ou usar atenção cruzada para (c) (típico em modelos de linguagem grandes e transformers codificador–decodificador).
  • VAEs: condicionar o decodificador (p(x \mid z, c)); às vezes também condicionar o codificador (q(z \mid x, c)).
  • GANs: injetar rótulos/embeddings no gerador e no discriminador (GANs condicionais).
  • Difusão: condicionar o removedor de ruído em (c) e opcionalmente aplicar orientação (por classificador ou sem classificador).

Controles práticos que você verá em sistemas:

  • Semente (seed): controla aleatoriedade e reprodutibilidade.
  • Escala de orientação / temperatura: aumenta seguir restrições vs diversidade.
  • Restrições: máscaras para preenchimento, observações parciais ou saídas estruturadas.

Para padrões de controle voltados ao usuário, veja Criação de Prompts.

Escolhendo uma família de modelos generativos (regras práticas)

A “melhor” família depende das restrições:

  • Precisa de verossimilhanças exatas / estimação de densidade: autorregressivos (discreto), fluxos (contínuo), VAEs (limitada por um bound).
  • Melhor qualidade perceptual para imagens/áudio com condicionamento forte: difusão (padrão comum hoje).
  • Amostragem rápida em uma única passagem em escala: GANs, fluxos, VAEs (e modelos de difusão destilados/de consistência).
  • Geração de texto/código com estrutura de longo alcance: transformers autorregressivos (modelos de linguagem grandes).

Considere também:

  • Orçamento de computação (treinamento vs inferência).
  • Requisitos de latência (amostragem iterativa vs de uma vez).
  • Requisitos de avaliação e segurança (verossimilhança, calibração, controlabilidade).
  • Estratégia de adaptação: se você deve fazer ajuste fino, usar prompts ou usar recuperação (veja Playbook de Ajuste Fino e Recuperação e Ferramentas).

Aplicações práticas de modelagem generativa

  • Geração de conteúdo: texto, código, imagens, áudio, vídeo, ativos 3D (núcleo da moderna IA Generativa).
  • Aumento de dados e dados sintéticos: criar dados de treinamento/avaliação — use com cuidado para evitar ciclos de feedback (veja Dados Sintéticos para GenAI).
  • Compressão: priors generativos para compressão aprendida de imagem/áudio (modelos baseados em verossimilhança são especialmente relevantes).
  • Imputação: preencher valores faltantes condicionados ao contexto observado.
  • Simulação e inferência científica: modelos substitutos que geram amostras plausíveis sob restrições físicas.
  • Detecção de anomalias: baixa verossimilhança ou reconstrução ruim pode indicar entradas fora da distribuição (com ressalvas).

Avaliando modelos generativos

A avaliação depende da modalidade e de a verossimilhança estar disponível.

  • Métricas baseadas em verossimilhança

    • Texto: perplexidade (perplexity) (a partir da log-verossimilhança).
    • Imagens (alguns modelos): bits por dimensão (bits per dimension).
    • Ressalva: alta verossimilhança nem sempre significa alta qualidade perceptual.

  • Métricas de qualidade/diversidade das amostras

    • Imagens: FID, precision/recall para modelos generativos (imperfeitas, mas comuns).
    • Áudio: métricas perceptuais + estudos com humanos.
    • Texto: avaliação humana e benchmarks baseados em tarefas frequentemente são mais significativos do que escores de sobreposição de n-gramas para geração aberta.

  • Utilidade downstream

    • Dados sintéticos melhoram um classificador?
    • Designs gerados passam nas restrições?
    • As saídas são seguras, sem viés e confiáveis?

Resumo

Modelagem generativa trata de aprender distribuições das quais você pode amostrar. As principais famílias diferem em como representam probabilidade e como a amostragem é realizada:

  • Autorregressivos: amostrar um passo por vez usando (p(x_t \mid x_{<t})).
  • VAEs: amostrar o latente (z) e então decodificar em uma passagem.
  • GANs: amostrar ruído (z) e mapear diretamente para os dados via um gerador.
  • Fluxos: amostrar uma base (z) e aplicar uma transformação inversível para verossimilhança e amostragem exatas.
  • Difusão: começar do ruído e remover ruído iterativamente usando um processo reverso aprendido.

Cada família oferece um trade-off diferente entre qualidade das amostras, tratabilidade de verossimilhança, estabilidade de treinamento, controlabilidade e velocidade de inferência — e sistemas modernos misturam cada vez mais ideias para obter o melhor de múltiplos mundos.