23. Autoregressive Generation

Modelos de difusão dominam a geração de imagens desde 2021. Existe uma segunda maneira de fazer isso, mais antiga que a difusão e bem viva: transformar a imagem numa sequência de tokens discretos e gerá-la como um modelo de linguagem gera texto, um token por vez, cada um condicionado nos anteriores.

Não é o caminho para a melhor imagem por unidade de computação — o capítulo anterior é. Ela voltou por outro motivo: é a única formulação em que uma figura e uma frase são o mesmo tipo de objeto, então um modelo, uma sequência e uma perda conseguem ler, raciocinar e desenhar. A OpenAI descreve a geração de imagens do GPT-4o (março de 2025) como "um modelo autorregressivo embutido nativamente no ChatGPT"⁷; modelos multimodais abertos como Chameleon⁴, Emu3⁹ e Janus-Pro¹⁰ geram imagens como tokens; e, fora das imagens, a mesma receita — um tokenizador aprendido seguido de previsão do próximo token — é o projeto padrão para fala e áudio e um projeto comum para ações de robôs.

Este capítulo constrói tudo a partir da base: o tokenizador, o laço autorregressivo e o que ele custa, as três maneiras de deixá-lo mais rápido ou melhor (rodadas paralelas, do grosso ao fino, tokens contínuos) e os projetos que colocam a geração de imagens dentro de um modelo de linguagem.

Slides

Clique nos slides e use as setas ← → para navegar; F abre em tela cheia e P abre a visão do apresentador, com as notas. Os simuladores desta página rodam dentro dos slides. Abrir os slides numa aba nova

O Problema: Como Tokenizar uma Imagem?

Texto é naturalmente discreto (palavras, subpalavras). Uma imagem é uma grade de pixels, cada um com três intensidades em \([0, 255]\): discreta em princípio, mas com \(256^3 \approx 16{,}8\) milhões de cores por pixel e 65 536 pixels numa imagem \(256 \times 256\), são opções demais e finas demais para prever uma a uma. Para usar geração autorregressiva, precisamos de um vocabulário visual e de um decoder que transforme uma grade de entradas desse vocabulário de volta em pixels.

A solução clássica é o VQ-GAN¹, um VQ-VAE (capítulo 17) treinado com perdas perceptual e adversarial para que as reconstruções saiam nítidas. Um encoder CNN transforma a imagem numa grade de vetores; cada vetor é trocado pelo mais próximo de \(K\) vetores aprendidos do codebook; a imagem vira uma grade de índices inteiros; um decoder CNN leva os vetores do codebook de volta a pixels.

Vale fazer a conta uma vez. Uma imagem \(256 \times 256\) com fator de redução 16 vira uma grade \(16 \times 16\): \(N = 256\) tokens. Com \(K = 16\,384\) códigos, cada token tem \(\log_2 K = 14\) bits, então a imagem inteira é descrita por no máximo \(256 \times 14 = 3\,584\) bits — cerca de 450 bytes para uma imagem que ocupa 196 608 bytes crua. Todo o resto o decoder inventa. Esse teto é o limite de fidelidade de qualquer modelo construído sobre o tokenizador.

Treinar um quantizador e como ele falha

A busca do vizinho mais próximo não tem gradiente, então o treino do VQ precisa de três peças. Com \(x\) a imagem, \(z_e\) a saída do encoder, \(e\) o código escolhido, \(D\) o decoder, \(\mathrm{sg}[\cdot]\) o stop-gradient (a identidade na passada para a frente, uma constante na passada para trás) e \(\beta\) o peso do termo de commitment (0,25 no laboratório):

A última expressão é o estimador straight-through: na passada para a frente \(z_q = e\); na passada para trás o gradiente do decoder é copiado para o encoder como se a quantização fosse a identidade. Percorra um passo de treino: a passada para a frente, o muro que o gradiente encontra no argmin, a cópia que passa por ele e os códigos que os outros dois termos alcançam.

O ponto fraco é o termo do meio. Só o código escolhido recebe gradiente. Um código que começa longe de todas as saídas do encoder nunca é escolhido, nunca se move e nunca é usado: é um código morto. Na prática, codebooks grandes são em sua maioria mortos. O VQGAN-LC relata que o VQGAN original, com 16 384 códigos, usava 3,4% deles no ImageNet (e uma variante com códigos fatorados, 11,2%)¹¹. Treine um abaixo e veja acontecer.

Com uma inicialização aleatória ampla, um codebook de 32 códigos termina com 21 usados e um de 64 com 28: quanto maior o codebook, maior a fração morta. Inicializar os códigos a partir dos dados, ou reiniciar os códigos mortos em saídas aleatórias do encoder, leva o uso a (quase) 100%. A área usou várias correções:

• Um VQ melhor. Inicializar os códigos com dados, reiniciar códigos mortos, manter os códigos num espaço normalizado de baixa dimensão. O LlamaGen³ usa códigos de 8 dimensões e relata uso de 97% de 16 384 entradas.
• Nenhum codebook aprendido. O FSQ¹² (finite scalar quantization) projeta o latente em poucas dimensões, limita cada uma com \(\tanh\) e a arredonda para poucos níveis: os níveis \((8, 6, 5)\) dão \(8 \cdot 6 \cdot 5 = 240\) códigos, cada um deles um ponto de uma grade fixa. Não há perda de codebook nem de commitment: nada pode morrer. O LFQ¹³ (MAGVIT-v2) é o caso binário — cada uma de 18 dimensões vira só o seu sinal — o que dá um vocabulário de \(2^{18} = 262\,144\) palavras.
• Nenhum quantizador. Manter tokens contínuos e mudar o que os prevê — a seção do MAR abaixo.

O laboratório treina um tokenizador VQ e um FSQ do mesmo tamanho no MNIST e mede exatamente isso: o codebook VQ usou 82 dos seus 256 códigos (32%) e a grade FSQ todos os seus 240 (100%). O FSQ ainda reconstruiu um pouco melhor (MSE 0,0034 contra 0,0047) com 3 números por posição em vez de 16.

Geração Autorregressiva de Tokens

Com um tokenizador treinado, qualquer imagem é uma sequência de \(N\) índices inteiros — em ordem raster, linha por linha. Geramos essa sequência exatamente como um LLM gera texto:

em que \(c\) é a condição (uma classe ou um prompt de texto). O treino é a entropia cruzada usual do próximo token com máscara causal, todas as posições em paralelo, com os tokens anteriores verdadeiros como entrada (teacher forcing). A amostragem sorteia um token, acrescenta-o e roda o modelo de novo.

Três coisas vêm diretamente dos modelos de linguagem:

• Os botões de amostragem. Temperatura e top-\(k\) trocam diversidade por fidelidade, exatamente como no texto.
• Classifier-free guidance também funciona aqui. Roda-se o modelo com e sem a condição e extrapolam-se os logits (as notas antes do softmax), \(\ell = \ell_\varnothing + w\,(\ell_c - \ell_\varnothing)\), com \(\ell_c\) os logits dada a condição \(c\), \(\ell_\varnothing\) os logits sem ela e \(w > 1\) a escala do guidance. O LlamaGen e o VAR dependem disso para os seus melhores números.
• O modelo de custo é o do LLM. Uma passada pela rede por token e as passadas são sequenciais: o token \(i\) precisa do valor sorteado do token \(i-1\). O KV cache mantém cada passada em um token novo, mas não elimina a sequência. Uma grade \(16 \times 16\) são 256 passadas sequenciais; 1 024 para as imagens 512 × 512 do Chameleon; 4 096 para uma grade \(64 \times 64\).

O painel conta o que custa uma amostra de 8 tokens, passada a passada, sem e com o cache:

O comprimento dessa sequência é a razão de isto funcionar sobre tokens e não sobre pixels. O ImageGPT¹⁶ (2020) rodou um GPT sobre pixels crus, a \(32 \times 32\) e \(64 \times 64\) com uma paleta reduzida de 9 bits: de 1 024 a 4 096 passos para uma miniatura. Um tokenizador que reduz por 16 divide a sequência por 256.

MaskGIT: Geração Paralela por Mascaramento

A ordem raster é lenta e também arbitrária: o token 200 não vem "depois" do 199 em nenhum sentido que importe para a imagem. O MaskGIT² abandona a ordem e decodifica em poucas rodadas paralelas, com um Transformer bidirecional treinado como o BERT:

1. Começa com todos os tokens mascarados [MASK].
2. A cada rodada, prevê todos os tokens mascarados de uma vez (atenção bidirecional).
3. Sorteia-os e mantém só os mais confiantes; os demais voltam a ser mascarados.
4. Repete. O número de tokens ainda mascarados depois da rodada \(t\) de \(T\) segue um cronograma de cosseno, \(\lfloor N \cos(\tfrac{\pi}{2}\,t/T) \rfloor\): poucos tokens fixados no começo, quando o modelo sabe menos; muitos no fim.

O artigo usa \(T = 8\) rodadas para \(16 \times 16 = 256\) tokens e 12 rodadas para \(32 \times 32 = 1\,024\) e relata uma decodificação de 30 a 64 vezes mais rápida que a autorregressiva.

Por que não uma rodada só? Porque, numa passada, cada token mascarado é sorteado da sua própria distribuição dados os tokens visíveis, independentemente dos outros. Sem nada visível, dois tokens vizinhos podem ser prováveis cada um e ainda assim errados juntos. Cada rodada condiciona no que as anteriores fixaram e é isso que torna a amostra conjunta coerente. O laboratório mede no MNIST: com uma rodada, 69% dos dígitos gerados são reconhecidos como o dígito pedido e a sua distância de Fréchet até dígitos reais é 138; com oito rodadas, 90% e 69. Oito rodadas são 6× menos passadas que as 49 do modelo autorregressivo, que marca 84% e uma distância de Fréchet de 31: os dígitos do MaskGIT são mais limpos, mas mais parecidos entre si, porque manter só os tokens mais confiantes favorece os típicos.

O Muse¹⁷ (2023) levou o mesmo decoder para texto-para-imagem a 512 × 512 e o relatou várias vezes mais rápido que os modelos de difusão da época. Chamar o MaskGIT de modelo de difusão discreta — o processo direto mascara em vez de adicionar ruído — é justo e é um dos lugares em que as famílias se misturam.

Previsão da próxima escala: VAR

O VAR⁶ mantém a autorregressão, mas muda o que um passo produz: não um token, mas um mapa de tokens inteiro na resolução seguinte. Para uma imagem \(256 \times 256\) ele gera dez mapas, de lado 1, 2, 3, 4, 5, 6, 8, 10, 13 e 16. Cada mapa é previsto numa passada, condicionado em todos os mais grossos (são resíduos; o mapa final é a soma deles reamostrada), com os tokens de um mesmo mapa produzidos em paralelo. Percorra as dez passadas:

Essa é uma ordem que os dados de fato têm — o layout grosso é decidido antes do detalhe — e ela precisa de \(O(\log n)\) passos em vez de \(O(n^2)\) para uma grade \(n \times n\): 10 passadas em vez de 256. O VAR relatou no ImageNet 256 × 256 um FID (a distância de Fréchet entre imagens geradas e reais nas features de uma rede Inception; menor é melhor) de 1,73 contra 2,27 do DiT-XL/2 (e contra 18,65 da linha de base em ordem raster de que partiu, com inferência cerca de 20× mais rápida) e escreveu que, "pela primeira vez, faz modelos AR no estilo GPT superarem transformers de difusão"; recebeu o prêmio de melhor artigo da NeurIPS 2024. O Infinity¹⁸ (2025) levou a previsão da próxima escala para texto-para-imagem a 1 024 × 1 024 com um tokenizador binário, gerando uma imagem em cerca de 0,8 s.

Tokens contínuos: o MAR dispensa o quantizador

O codebook é onde os modelos autorregressivos de imagem perdem fidelidade: tudo o que fica entre as entradas do codebook é irrepresentável. O MAR⁵ o remove. Os tokens continuam contínuos (os latentes de um VAE, como no Stable Diffusion) e o softmax categórico é trocado por um pequeno modelo de difusão por token: o Transformer produz um vetor de condicionamento \(z_i\) para a posição \(i\) e um MLP pequeno (21 M de parâmetros por padrão, cerca de 5% do MAR-L, o modelo de 400 M de parâmetros), treinado com a perda usual de remoção de ruído, sorteia o token contínuo \(x_i\) de \(p(x_i \mid z_i)\) em 100 passos de remoção de ruído.

Aqui \(x_{i,t}\) é \(x_i\) com o ruído \(\epsilon\) somado até o tempo de difusão \(t\) (nesta fórmula \(t\) é um nível de ruído, não um token) e \(\epsilon_\theta\), o MLP, tenta recuperar \(\epsilon\). As letras são as do MAR: \(x_i\) é um token contínuo, não a imagem \(x\) do tokenizador; \(z_i\) é a saída do Transformer, não a saída \(z_e\) do encoder.

O MAR também gera em ordem aleatória e em grupos paralelos, no estilo do MaskGIT, com atenção bidirecional. Chegou a FID 1,55 no ImageNet 256 × 256. O Fluid¹⁹ escalou a receita para 10,5 B de parâmetros em texto-para-imagem e encontrou as duas metades da lição separadamente: tokens contínuos vencem tokens discretos e a ordem aleatória vence a ordem raster. O NextStep-1²⁰ (2025) é um modelo autorregressivo de texto-para-imagem de 14 B construído do mesmo jeito, com uma cabeça de flow matching por token.

O eixo não é o que as pessoas pensam

"Autorregressivo versus difusão" soa como a escolha de uma família de modelos. Na verdade são duas escolhas independentes:

Quando você enxerga os dois eixos, a taxonomia deixa de ser tribal. A mesma ideia roda agora na direção oposta: modelos de linguagem por difusão geram texto desmascarando iterativamente a sequência inteira em vez de ir da esquerda para a direita — o LLaDA²¹ (8 B, 2025) é competitivo com um LLaMA 3 8B autorregressivo; o Gemini Diffusion experimental do Google (maio de 2025) e o Mercury comercial da Inception são exemplos rápidos. Eles trocam o KV cache por decodificação paralela.

Any-to-Any: imagens dentro de um modelo de linguagem

O passo que trouxe a autorregressão de volta é remover a distinção entre tokens de texto e de imagem. O Chameleon⁴ (Meta, 2024) os intercala numa única sequência desde o primeiro passo do pré-treino: uma imagem 512 × 512 vira 1 024 tokens de um codebook de 8 192 entradas, somados ao vocabulário do texto. Um Transformer é treinado com uma única perda de próximo token.

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

Esse é um projeto. Desde 2024 apareceram pelo menos quatro, que diferem exatamente nos dois eixos acima: o que uma posição de imagem guarda e como ela é prevista. Percorra-os:

Duas correções a coisas muito repetidas. Primeiro, a arquitetura dos sistemas fechados de fronteira não é pública: "o GPT-4o é um modelo autorregressivo com um decoder de difusão" é uma leitura plausível de uma imagem de quadro branco no post de lançamento da OpenAI, não um fato documentado. E nada oficial descreve como o Gemini desenha. Segundo, os modelos abertos que lideram em qualidade de imagem em geral não são os de tokens discretos: o Janus-Pro e o Emu3 mostram que um único modelo de próximo token consegue desenhar, mas os projetos que põem uma perda de difusão ou de flow dentro do modelo (Transfusion, BAGEL, HunyuanImage 3.0) ou atrás dele (MetaQuery, BLIP3-o) concentraram a maior parte do esforço de 2025.

AR vs. Difusão em 2026

O REPA e o RAE são transformers de difusão que se apoiam num encoder de imagem pré-treinado (o DINOv2): o primeiro alinha as features do modelo com as dele; o segundo faz a difusão no espaço latente dele (capítulo 22). No ImageNet condicionado à classe, as duas famílias se alternam na liderança desde 2024 e ficam a poucos décimos de FID uma da outra; nenhuma é "melhor" em geral. Para texto-para-imagem isolado, os modelos abertos mais fortes são transformers de difusão ou de flow (capítulo 22). Onde a autorregressão é a escolha natural é justamente a razão de ela ter voltado: geração que precisa viver no mesmo contexto que o texto — conversas que editam uma imagem, documentos intercalados, raciocínio antes de desenhar.

Onde isto é usado hoje

A receita — aprender um tokenizador e depois prever o próximo token — não é só uma técnica de imagem. Ela é o projeto padrão em vários lugares e todos eles têm agora uma variante de difusão ou de flow competindo com ela, que é de novo o quadro dos dois eixos:

Onde cada um é usado

Implementação: tokenizador + Transformer autorregressivo

O laboratório constrói tudo isso no MNIST. O núcleo é pequeno:

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

# 1. Quantizador vetorial, com as duas perdas que treinam o codebook e o encoder
class VectorQuantizer(nn.Module):
    def __init__(self, n_codes, d_code, beta=0.25):
        super().__init__()
        self.codebook = nn.Embedding(n_codes, d_code)
        self.beta = beta

    def forward(self, z):                          # z: (B, H, W, d_code), saída do encoder
        flat = z.reshape(-1, z.shape[-1])
        idx = torch.cdist(flat, self.codebook.weight).argmin(-1)   # código mais próximo
        q = self.codebook(idx).view_as(z)
        loss = F.mse_loss(q, z.detach()) + self.beta * F.mse_loss(z, q.detach())
        q = z + (q - z).detach()                   # estimador straight-through
        return q, idx.view(z.shape[:-1]), loss

# 1'. FSQ: sem codebook, sem perda. levels=(8, 6, 5) dá 240 códigos numa grade fixa
def fsq(z, levels=(8, 6, 5)):                      # z: (..., len(levels))
    L = torch.tensor(levels, dtype=z.dtype, device=z.device)
    half = (L - 1) / 2
    offset = (L % 2 == 0) * 0.5                    # níveis pares: desloca a grade em meio passo
    z = torch.tanh(z + torch.atanh(offset / half)) * half - offset
    return z + (z.round() - z).detach()            # arredonda, com gradiente straight-through

# 2. Geração autorregressiva com um modelo estilo GPT sobre os ids dos tokens
class ImageGPT(nn.Module):
    def __init__(self, n_codes, n_classes, seq_len, d_model=192, n_heads=4, n_layers=4):
        super().__init__()
        self.tok_emb = nn.Embedding(n_codes, d_model)
        self.cls_emb = nn.Embedding(n_classes, d_model)       # a condição é o token 0
        self.pos_emb = nn.Parameter(torch.zeros(1, seq_len + 1, d_model))
        layer = nn.TransformerEncoderLayer(d_model, n_heads, 4 * d_model,
                                           batch_first=True, norm_first=True)
        self.blocks = nn.TransformerEncoder(layer, n_layers)
        self.head = nn.Linear(d_model, n_codes)

    def forward(self, y, tokens):                  # tokens: (B, T), T <= seq_len
        x = torch.cat([self.cls_emb(y)[:, None], self.tok_emb(tokens)], 1)
        T = x.shape[1]
        x = x + self.pos_emb[:, :T]
        causal = nn.Transformer.generate_square_subsequent_mask(T, device=x.device)
        return self.head(self.blocks(x, mask=causal, is_causal=True))   # (B, T, n_codes)

    @torch.no_grad()
    def generate(self, y, n_tokens, temperature=1.0, top_k=None):
        tokens = torch.zeros(len(y), 0, dtype=torch.long, device=y.device)
        for _ in range(n_tokens):                  # uma passada pela rede por token
            logits = self(y, tokens)[:, -1] / temperature
            if top_k:
                logits[logits < logits.topk(top_k)[0][:, -1:]] = -float('inf')
            nxt = torch.multinomial(logits.softmax(-1), 1)
            tokens = torch.cat([tokens, nxt], 1)
        return tokens                              # decodifique com o decoder do tokenizador

O treino do Transformer é F.cross_entropy(model(y, s[:, :-1]).flatten(0, 1), s.flatten()): a saída na posição \(i\) (que viu a condição e \(t_1, \ldots, t_{i-1}\)) é comparada com \(t_i\).

O mesmo código, rodado numa imagem \(2 \times 2\) com códigos de 2 dimensões e \(K = 4\), para que cada número possa ser conferido à mão: o quantizador (código mais próximo, as duas perdas auxiliares, straight-through) e depois um passo do modelo autorregressivo, com a perda de treino e um sorteio. No caso inicial o código 2 não vence nenhuma posição e recebe gradiente zero; a perda para \(t_4\) é 0,515, contra \(\log 4 = 1{,}386\) de um chute cego. Mude um número, a temperatura ou o caso e veja qual linha se mexe:

Laboratório: tokens, medidos

As afirmações do capítulo são medidas num notebook do Colab sobre o MNIST (70 000 dígitos manuscritos, 28 × 28): um tokenizador, um Transformer autorregressivo e um MaskGIT, todos treinados do zero. Ele precisa de GPU: no Colab, Ambiente de execução → Alterar o tipo de ambiente de execução → GPU T4 (o plano gratuito basta; a execução de referência do notebook inteiro levou 10,5 minutos numa GPU de notebook da Apple). São oito seções, cada uma terminando num checkpoint com um valor de verificação:

1. um juiz para os dígitos gerados: um pequeno classificador CNN e uma distância de Fréchet no seu espaço de features;
2. um tokenizador VQ: a reconstrução e quantos dos seus 256 códigos ele de fato usa;
3. um tokenizador FSQ do mesmo tamanho: as mesmas medidas, sem codebook;
4. a imagem como sequência: 49 tokens, os bits que eles carregam e a sua frequência;
5. um Transformer autorregressivo: bits por imagem e quais posições são difíceis;
6. a amostragem: 49 passadas sequenciais, acerto do dígito, distância de Fréchet e tempo;
7. um MaskGIT sobre os mesmos tokens: qualidade em função do número de rodadas e o ganho de velocidade;
8. uma tabela para preencher: temperatura, tokenizador e decoder contra qualidade e custo.

Abrir o laboratório no Colab — salve uma cópia no seu Drive (Arquivo → Salvar uma cópia no Drive) para rodar e editar.

Pontos principais

1. A geração autorregressiva de imagens precisa de um tokenizador: a imagem vira \(N\) inteiros de um vocabulário de \(K\), no máximo \(N \log_2 K\) bits. O tokenizador é ao mesmo tempo o truque que habilita tudo e o teto de fidelidade.
2. Um codebook VQ colapsa: códigos não usados não recebem gradiente e morrem. Inicializar com dados, reiniciar códigos mortos e usar códigos de baixa dimensão ajudam; o FSQ e o LFQ trocam o codebook por uma grade fixa em que nada pode morrer.
3. O custo é uma passada sequencial pela rede por token, com ou sem KV cache. Por isso ela roda sobre tokens latentes (256 – 4 096) e não sobre pixels.
4. A ordem raster é arbitrária. O MaskGIT decodifica em 8–12 rodadas paralelas; o VAR prevê a próxima escala em ~10 passos. Rodadas paralelas precisam ser várias porque tokens sorteados na mesma passada são independentes entre si.
5. O MAR mostra que o quantizador é opcional: tokens contínuos com uma pequena cabeça de difusão por token.
6. Os eixos reais são ordem de geração e distribuição por elemento, não "autorregressivo versus difusão". No ImageNet as duas famílias estão quase empatadas; em qualidade de texto-para-imagem, os transformers de difusão e de flow lideram.
7. A razão de a abordagem ter voltado é a unificação. Modelos multimodais hoje geram imagens de quatro maneiras — próximo token discreto, discreto mascarado, uma perda de difusão dentro do LLM ou um LLM que comanda um decoder de difusão separado — e os sistemas fechados de fronteira não dizem qual usam.
8. Fora das imagens, tokenizador + previsão do próximo token é o projeto padrão para fala e áudio e um projeto comum para modelos de mundo em vídeo e ações de robôs.