23. Autoregressive Generation

Geração Autorregressiva de Imagens

Modelos de difusão dominam a geração de imagens desde 2020 — mas existe uma abordagem radicalmente diferente que ganhou força: tratar imagens como sequências de tokens discretos e gerá-las da mesma forma que modelos de linguagem geram texto.

Essa é a abordagem por trás da geração de imagens nativa do Gemini, do GPT-4o e de modelos como Chameleon (Meta) e LlamaGen.

O Problema: Como Tokenizar uma Imagem?

Texto é naturalmente discreto (palavras, subpalavras). Imagens são contínuas — pixels em \([0,255]^3\). Para usar geração autorregressiva, precisamos de um vocabulário visual.

A solução: VQ-GAN (Vector Quantization GAN)¹ aprende um codebook de \(K\) vetores. O encoder mapeia qualquer patch de imagem para o vetor mais próximo do codebook — convertendo a imagem em uma grade de índices inteiros.

Geração Autorregressiva de Tokens

Com um codebook treinado, podemos representar qualquer imagem como uma sequência de \(N\) índices inteiros. Geramos então essa sequência exatamente como um LLM gera texto:

Cada token é gerado um de cada vez, condicionado em todos os anteriores e no prompt de texto.

MaskGIT: Geração Paralela por Mascaramento

A geração puramente autorregressiva é lenta: 1024 tokens = 1024 passes de modelo. O MaskGIT² acelera isso com geração paralela iterativa:

1. Começa com todos os tokens mascarados [MASK]
2. A cada iteração, prediz todos os tokens simultaneamente (bidirecional!)
3. "Revela" apenas os tokens com maior confiança
4. Repete com menos tokens mascarados

Em apenas 8–12 iterações, gera 1024 tokens — contra 1024 iterações do AR puro.

Any-to-Any: Gemini, GPT-4o e Chameleon

O passo final é remover a distinção entre tokens de texto e tokens de imagem. Modelos any-to-any tratam tudo como uma sequência de tokens:

[TEXTO: "uma foto de"] [IMG_TOK_3742] [IMG_TOK_891] ... [IMG_TOK_5531] [TEXTO: "gato"]

O modelo Transformer padrão processa essa sequência misturada naturalmente.

Como Cada Modelo Implementa Isso

AR vs. Difusão: Quando Usar Cada Um?

A tendência atual: híbridos — um backbone LLM autorregressivo para entendimento e raciocínio, com um decoder de difusão para renderizar a imagem final com alta qualidade. É exatamente o que o GPT-4o faz.

Implementação: VQ-GAN + Transformer AR

import torch
import torch.nn as nn

# 1. Quantizador vetorial
class VectorQuantizer(nn.Module):
    def __init__(self, n_codes, d_code):
        super().__init__()
        self.codebook = nn.Embedding(n_codes, d_code)

    def forward(self, z):
        # z: (B, H, W, d_code) — latentes do encoder
        flat = z.view(-1, z.shape[-1])
        # Distâncias ao codebook
        dists = torch.cdist(flat, self.codebook.weight)
        indices = dists.argmin(dim=-1)            # índice do código mais próximo
        quantized = self.codebook(indices).view_as(z)
        # Straight-through estimator para backprop
        quantized_st = z + (quantized - z).detach()
        return quantized_st, indices.view(z.shape[:3])

# 2. Geração autorregressiva com modelo estilo GPT
class ImageGPT(nn.Module):
    def __init__(self, n_codes, seq_len, d_model, n_heads, n_layers):
        super().__init__()
        self.tok_emb = nn.Embedding(n_codes + 1, d_model)  # +1 para token BOS
        self.pos_emb = nn.Embedding(seq_len + 1, d_model)
        encoder_layer = nn.TransformerEncoderLayer(d_model, n_heads, d_model*4, batch_first=True)
        self.transformer = nn.TransformerEncoder(encoder_layer, n_layers)
        self.head = nn.Linear(d_model, n_codes)

    def forward(self, tokens):
        B, T = tokens.shape
        pos = torch.arange(T, device=tokens.device).unsqueeze(0)
        x = self.tok_emb(tokens) + self.pos_emb(pos)
        # Máscara causal
        mask = torch.triu(torch.ones(T, T, device=tokens.device), diagonal=1).bool()
        x = self.transformer(x, mask=mask)
        return self.head(x)  # logits sobre n_codes

    @torch.no_grad()
    def generate(self, prompt_tokens, n_new, temperature=1.0, top_k=2048):
        tokens = prompt_tokens.clone()
        for _ in range(n_new):
            logits = self(tokens)[:, -1, :] / temperature
            if top_k: logits[logits < logits.topk(top_k)[0][:,-1:]] = -float('inf')
            probs = logits.softmax(-1)
            next_tok = torch.multinomial(probs, 1)
            tokens = torch.cat([tokens, next_tok], dim=1)
        return tokens

O quadro em 2026

A geração autorregressiva de imagens parecia beco sem saída em 2022 — o VQ-GAN era bom e a difusão era melhor e mais rápida. Ela voltou por uma razão que nada tem a ver com qualidade de imagem: é a única formulação em que uma figura e uma frase são o mesmo tipo de objeto.

Três linhas de trabalho importam agora e elas discordam entre si de um jeito instrutivo.

Onde cada um é usado

Pontos principais

1. Geração autorregressiva de imagens precisa de um tokenizador: um VQ-VAE/VQ-GAN transforma uma imagem numa grade de inteiros e o codebook é ao mesmo tempo o truque habilitador e o teto de fidelidade.
2. O custo é uma passagem direta por token, então ela roda sobre ~1024 tokens latentes, nunca sobre pixels. É a mesma contabilidade do capítulo 16.
3. Ordem raster é arbitrária. O MaskGIT gera em rodadas paralelas; o VAR gera grosso-para-fino e precisa de \(O(\log N)\) passos.
4. O MAR mostra que o quantizador é opcional: tokens contínuos com uma pequena cabeça de difusão por token.
5. Os eixos reais são ordem de geração e distribuição por elemento, não "autorregressivo versus difusão".
6. A razão pela qual a abordagem voltou é unificação: texto e imagens como uma sequência, uma perda, um modelo — que é do que sistemas any-to-any precisam.