Modelos de Fluxo

Modelos de fluxo (flow models), frequentemente chamados de fluxos normalizantes (normalizing flows), são uma família de modelos generativos (generative models) que aprendem uma distribuição de dados complexa ao compor uma sequência de transformações inversíveis (invertible transformations). Sua característica definidora é que fornecem log-verossimilhanças exatas e tratáveis (exact, tractable log-likelihoods) (não apenas um limite), ao mesmo tempo em que permitem amostragem eficiente — uma combinação atraente em comparação com outras famílias em Modelagem Generativa.

Em alto nível, um modelo de fluxo aprende uma bijeção (bijection) entre:

uma distribuição base (base distribution) simples (por exemplo, uma Gaussiana padrão) no espaço latente (latent space)
a complexa distribuição de dados (data distribution) no espaço de dados (data space) (imagens, áudio, dados tabulares etc.)

Como a transformação é inversível e tem um determinante Jacobiano (Jacobian determinant) tratável, podemos avaliar a densidade de probabilidade de qualquer ponto de dado observado exatamente via a fórmula de mudança de variáveis (change-of-variables formula).

Ideia central: mudança de variáveis com transformações inversíveis

Seja (z \sim p_Z(z)) uma distribuição simples (comumente ( \mathcal{N}(0, I) )). Um fluxo define uma função inversível (f_\theta) tal que:

[ x = f_\theta(z) \quad\text{e}\quad z = f_\theta^{-1}(x) ]

Para computar a densidade de (x), usamos a regra de mudança de variáveis (change-of-variables):

[ p_X(x) = p_Z(z)\left|\det \frac{\partial z}{\partial x}\right| \quad\text{onde}\quad z=f_\theta^{-1}(x) ]

Na forma logarítmica (mais estável e usada no treinamento):

[ \log p_X(x) = \log p_Z(f_\theta^{-1}(x)) + \log \left|\det J_{f_\theta^{-1}}(x)\right| ]

Um fluxo normalmente é construído como uma composição de (K) etapas inversíveis:

[ f_\theta = f_K \circ f_{K-1} \circ \cdots \circ f_1 ]

Então, o termo do log-determinante se torna uma soma:

[ \log \left|\det J_{f_\theta^{-1}}(x)\right| = \sum_{k=1}^{K} \log \left|\det J_{f_k^{-1}}(h_k)\right| ]

onde (h_k) é o estado intermediário na etapa (k). Essa estrutura aditiva é uma das razões pelas quais fluxos são práticos: só precisamos que o determinante Jacobiano de cada etapa seja fácil.

O que torna uma transformação “amigável a fluxos”?

Cada camada deve ser:

Inversível (para que possamos mapear (x \leftrightarrow z))
Ter log-determinante Jacobiano tratável (para que a verossimilhança seja viável)
Ser expressiva quando composta muitas vezes

Isso conduz muitas escolhas arquiteturais em modelos de fluxo.

Objetivo de treinamento: máxima verossimilhança exata

Modelos de fluxo tipicamente são treinados via estimação por máxima verossimilhança (maximum likelihood estimation):

[ \max_\theta \sum_{i=1}^N \log p_X(x_i) ]

Isso é “modelagem generativa de verossimilhança exata (exact likelihood generative modeling)”, em contraste com modelos como Autoencoders Variacionais (variational autoencoders), que otimizam um limite variacional (limite inferior da evidência (evidence lower bound, ELBO)), ou Redes Adversariais Generativas (GANs), que não otimizam diretamente a verossimilhança.

Na prática, o treinamento usa o ferramental padrão de aprendizado profundo (deep learning) — Retropropagação (backpropagation) e Descida do Gradiente (gradient descent) — porque todas as operações (incluindo log-determinantes) são diferenciáveis.

Amostragem e inferência

Modelos de fluxo suportam duas operações-chave:

Amostragem (sampling): amostrar (z \sim p_Z), então computar (x = f_\theta(z))
Inferência (inferência/“codificação”) (inference (encoding)): computar (z = f_\theta^{-1}(x))

A segunda operação é notavelmente eficiente em comparação com muitas outras famílias de modelos generativos, que podem exigir inferência iterativa (por exemplo, Modelos de Difusão) ou redes auxiliares de inferência (por exemplo, autoencoders variacionais).

Blocos de construção comuns em fluxos

Diferentes arquiteturas de fluxo diferem principalmente em como projetam as etapas inversíveis e mantêm o determinante Jacobiano tratável.

Camadas de acoplamento afim (RealNVP / estilo Glow)

Uma abordagem amplamente usada é a camada de acoplamento (coupling layer) (introduzida em NICE e RealNVP, depois popularizada por Glow). Divida a entrada em duas partes:

[ x = (x_a, x_b) ]

Deixe uma parte inalterada e transforme a outra usando uma função da parte inalterada:

[ y_a = x_a ] [ y_b = x_b \odot \exp(s(x_a)) + t(x_a) ]

onde (s(\cdot)) e (t(\cdot)) são redes neurais (frequentemente CNNs rasas para imagens), e (\odot) denota multiplicação elemento a elemento (elementwise multiplication).

Por que isso é útil:

A inversão é fácil: [ x_b = (y_b - t(y_a)) \odot \exp(-s(y_a)) ]
O Jacobiano é triangular, então: [ \log|\det J| = \sum , s(x_a) ] (até o sinal, dependendo da direção)

Camadas de acoplamento são um compromisso prático: elas restringem a forma de cada camada, mas se tornam expressivas quando empilhadas com permutações/mistura.

Permutações e convoluções 1×1 inversíveis

Se você sempre divide as variáveis do mesmo jeito, parte do vetor pode não se transformar o suficiente. Arquiteturas de fluxo, portanto, adicionam etapas de mistura (mixing) entre camadas de acoplamento:

permutações fixas (embaralhamento)
transformações lineares inversíveis aprendidas
convolução 1×1 inversível (invertible 1×1 convolution) (Glow): uma matriz aprendida de mistura de canais com log-determinante tratável

Essas etapas garantem que toda dimensão eventualmente influencie toda outra dimensão por meio da composição.

Fluxos autorregressivos (MAF / IAF)

Fluxos autorregressivos (autoregressive flows) usam uma fatoração autorregressiva (autoregressive factorization) para garantir Jacobianos triangulares.

Uma forma simplificada:

[ x_i = \mu_i(z_{<i}) + \sigma_i(z_{<i}) \cdot z_i ]

Como cada (x_i) depende apenas de variáveis anteriores, o Jacobiano é triangular, e o log-determinante é apenas a soma dos log-escalares.

Trade-off:

Algumas variantes são rápidas para avaliação de densidade, mas mais lentas para amostragem, ou vice-versa.
Elas se conectam conceitualmente a Modelos Autorregressivos, mas fluxos mantêm inversibilidade e transformações contínuas.

Fluxos de spline (Neural Spline Flows)

Transformações afins podem ser limitantes. O acoplamento baseado em splines (spline-based coupling) substitui a transformação afim por um polinômio por partes monótono (monotonic piecewise polynomial) (por exemplo, uma spline racional-quadrática (rational-quadratic spline)), permitindo deformações não lineares mais flexíveis, enquanto retém:

inversibilidade
log-determinantes fáceis (via derivada da spline)

Fluxos de spline são especialmente fortes para estimação de densidade em dados tabulares e incerteza calibrada.

Fluxos normalizantes contínuos (CNFs / FFJORD)

Em vez de uma pilha discreta de camadas, fluxos contínuos definem uma transformação em tempo contínuo via uma equação diferencial ordinária (ordinary differential equation, ODE):

[ \frac{d h(t)}{d t} = v_\theta(h(t), t) ]

A log-densidade evolui de acordo com:

[ \frac{d \log p(h(t))}{d t} = -\text{tr}\left(\frac{\partial v_\theta}{\partial h}\right) ]

Fluxos normalizantes contínuos podem ser muito expressivos, mas exigem resolver uma ODE numericamente, o que pode ser mais lento e introduz tolerâncias do solucionador. Eles são usados quando a flexibilidade é crucial e o custo computacional é aceitável.

Exemplo prático: uma camada de acoplamento mínima (no estilo PyTorch)

Abaixo está uma camada de acoplamento afim simplificada (entrada vetorial). Implementações reais adicionam mascaramento, permutações e estabilização.

import torch
import torch.nn as nn

class AffineCoupling(nn.Module):
    def __init__(self, dim, hidden=256):
        super().__init__()
        self.dim = dim
        self.half = dim // 2
        self.net = nn.Sequential(
            nn.Linear(self.half, hidden), nn.ReLU(),
            nn.Linear(hidden, hidden), nn.ReLU(),
            nn.Linear(hidden, 2 * (dim - self.half))  # outputs s and t
        )

    def forward(self, x):
        xa, xb = x[:, :self.half], x[:, self.half:]
        st = self.net(xa)
        s, t = st[:, :xb.shape[1]], st[:, xb.shape[1]:]
        s = torch.tanh(s)  # common stabilization
        yb = xb * torch.exp(s) + t
        y = torch.cat([xa, yb], dim=1)
        log_det = s.sum(dim=1)  # log|det J|
        return y, log_det

    def inverse(self, y):
        ya, yb = y[:, :self.half], y[:, self.half:]
        st = self.net(ya)
        s, t = st[:, :yb.shape[1]], st[:, yb.shape[1]:]
        s = torch.tanh(s)
        xb = (yb - t) * torch.exp(-s)
        x = torch.cat([ya, xb], dim=1)
        log_det = -s.sum(dim=1)
        return x, log_det

Para computar a log-verossimilhança de um modelo completo, você:

mapeia (x \rightarrow z) usando o inverso de cada camada e soma os log-determinantes
adiciona (\log p_Z(z)) da distribuição base (por exemplo, normal padrão)

Esse padrão de “inverter e então pontuar” é o laço padrão de treinamento de fluxos.

Lidando com dados do mundo real: imagens são discretas (uma sutileza)

Muitos modelos de fluxo operam sobre densidades contínuas (continuous densities), mas os pixels de imagens geralmente são discretos (0–255). Um modelo de densidade contínua aplicado diretamente pode produzir verossimilhanças enganosas.

A prática comum é a desquantização (dequantization):

adicionar ruído uniforme (u \sim \text{Uniform}(0, 1)) a pixels inteiros
opcionalmente aprender uma distribuição de desquantização (desquantização variacional (variational dequantization))

Frequentemente, você também aplica uma transformação logit (logit transform) inversível para mapear valores limitados ([0,1]) para (\mathbb{R}).

Isso importa porque artigos de fluxos frequentemente reportam bits por dimensão (bits per dimension, bpd), uma métrica normalizada de log-verossimilhança negativa comumente usada para modelos de densidade de imagens.

Onde modelos de fluxo são usados na prática

1) Estimação de densidade e modelagem probabilística

Fluxos são naturais quando você realmente precisa de uma densidade normalizada:

modelagem de distribuições de atributos tabulares
modelagem de dados científicos (física, clima)
previsão probabilística onde a verossimilhança calibrada importa

2) Detecção de anomalias e fora da distribuição (OOD)

Treine um fluxo em dados “normais”; pontos com baixa verossimilhança são sinalizados como anomalias.

Ressalva: verossimilhança pura pode se comportar de modo contraintuitivo em altas dimensões (algumas amostras fora da distribuição podem receber alta verossimilhança). Bons pipelines de detecção fora da distribuição frequentemente combinam fluxos com:

modelagem no espaço de atributos (fluxos sobre incorporações aprendidas)
razões de verossimilhança ou testes de tipicidade
validação específica da tarefa

3) Aprendizado de representações inversíveis

Como (x \leftrightarrow z) é bijetivo, fluxos podem ser usados para aprender representações que:

preservam informação
suportam reconstrução exata
permitem manipulações controláveis no latente (limitadas pelo desentrelaçamento)

4) Geração condicional

Fluxos podem ser condicionados em rótulos, texto ou outros sinais:

[ x = f_\theta(z; c) ]

Exemplos:

síntese de imagens condicionada por classe
densidade condicional para predição estruturada (structured prediction)
geração de áudio condicionada em atributos linguísticos (historicamente explorada, embora difusão domine muitos pipelines modernos de áudio)

5) Compressão e codificação (conexão conceitual)

Um modelo de verossimilhança exata pode ser usado para codificação entrópica (entropy coding) em princípio. Algumas pesquisas conectam fluxos à compressão sem perdas aprendida, embora sistemas práticos precisem lidar cuidadosamente com discretização.

Pontos fortes e limitações (e como se comparam)

Modelos de fluxo ocupam um ponto distintivo entre as principais famílias de modelos generativos:

Pontos fortes

Log-verossimilhança exata (útil para estimação de densidade e avaliação)
Inferência exata (mapeamento inversível fornece códigos latentes diretamente)
Amostragem eficiente (frequentemente um único passe direto, diferente do desruído iterativo na difusão)

Limitações

Restrições arquiteturais (architectural constraints): inversibilidade e Jacobianos tratáveis restringem o projeto de camadas
Custo de computação/memória: fluxos para imagens de alta resolução podem ser pesados
Qualidade das amostras vs difusão: para imagens de alta fidelidade, Modelos de Difusão em grande parte se tornaram o padrão devido à qualidade perceptual superior, apesar da amostragem mais lenta
Correspondência de dimensões (dimension matching): fluxos padrão exigem que as dimensões de latente e dados coincidam; existem extensões (augmentações, arquiteturas multiescala), mas isso molda o design

Comparação rápida com famílias irmãs de modelos

vs Redes Adversariais Generativas: fluxos são estáveis para treinar com máxima verossimilhança e fornecem verossimilhanças; redes adversariais generativas frequentemente geram amostras mais nítidas, mas não têm verossimilhança tratável e podem ser instáveis.
vs Autoencoders Variacionais: fluxos fornecem verossimilhança exata e inversibilidade; autoencoders variacionais lidam naturalmente com espaços latentes de menor dimensionalidade e podem ser mais flexíveis para aprendizado de representações.
vs Modelos Autorregressivos: modelos autorregressivos fornecem verossimilhança exata para sequências discretas e podem ser muito fortes, mas a amostragem é inerentemente sequencial; fluxos podem amostrar em paralelo, mas tipicamente são usados para espaços contínuos.
vs Modelos de Difusão: difusão frequentemente vence em qualidade para imagem/áudio; fluxos vencem em verossimilhança exata e amostragem rápida (quando as arquiteturas são eficientes).

Intuição: por que compor etapas inversíveis simples funciona

Um modelo mental útil: comece com uma nuvem de pontos de uma Gaussiana padrão. Cada camada inversível:

deforma o espaço (estica, cisalha, dobra)
atualiza a densidade via o determinante Jacobiano (mudança de volume)
permanece reversível, então nenhuma informação é destruída

Após etapas suficientes, a distribuição deformada pode corresponder a distribuições de dados multimodais complicadas — enquanto ainda consegue computar “quanta massa de probabilidade” o modelo atribui a qualquer ponto.

Considerações de implementação e dicas

Estabilize as saídas de escala: use tanh, clamping ou parametrizações limitadas para (s(\cdot)) para evitar explosões numéricas em exp(s).
Use arquiteturas multiescala para imagens: fatorize variáveis progressivamente para reduzir computação e melhorar a mistura.
Acompanhe log-determinantes com cuidado: some ao longo das camadas e do lote; verifique sinais para a direção direta vs inversa.
Avalie com a métrica correta: para imagens, reporte bits/dim com desquantização consistente; para tabulares, use log-verossimilhança negativa (negative log-likelihood, NLL) e verificações de calibração.
A estratégia de condicionamento importa: injete condicionamento nas redes de acoplamento (as redes (s,t)) ou via modulação afim por características (feature-wise affine modulation) (padrões do tipo FiLM).

Resumo

Modelos de fluxo são modelos generativos construídos a partir de transformações inversíveis e diferenciáveis que permitem cálculo exato de verossimilhança por meio da fórmula de mudança de variáveis. Eles são treinados com máxima verossimilhança direta, suportam amostragem eficiente e fornecem inversos latentes exatos — tornando-os especialmente valiosos para estimação de densidade, modelagem consciente de incerteza e aprendizado de representações inversíveis.

Embora fluxos não sejam mais a escolha padrão para a geração de imagens da mais alta fidelidade (onde Modelos de Difusão frequentemente dominam), eles permanecem uma técnica central no kit de ferramentas de modelagem generativa e uma ponte importante entre a teoria de modelagem probabilística e sistemas práticos de aprendizado profundo.