Redes Neurais Artificiais e Deep Learning · Insper

Geração Autorregressiva de Imagens

Uma imagem como uma frase de tokens

Duas maneiras de fazer uma imagem

Difusão / flow

  • todas as posições, a cada passo
  • latentes contínuos
  • a melhor imagem por unidade de computação (capítulo anterior)

Autorregressiva sobre tokens

  • imagem → grade de inteiros
  • um token por vez, como um LLM escreve texto
  • mais antiga que a difusão

A difusão faz imagens melhores pelo mesmo custo. Por que a OpenAI chamou a geração de imagens do GPT-4o de "um modelo autorregressivo embutido nativamente no ChatGPT"?

Onde isto é usado hoje

Domínio Tokens aprendidos + previsão do próximo token
Imagens em LLMs multimodais Chameleon, Emu3 / Emu3.5, Janus-Pro; o GPT-4o diz "autorregressivo"
Fala e áudio tokens de codec (SoundStream, EnCodec, Mimi) + um LM: VALL-E, MusicGen, Moshi
Vídeo e modelos de mundo VideoPoet; o NVIDIA Cosmos traz AR e difusão; o Genie 3 vai quadro a quadro
Políticas de robôs RT-2, OpenVLA: 256 faixas por dimensão da ação; FAST: DCT + BPE

Toda linha tem também uma concorrente de difusão ou de flow. Guarde isso: são os dois eixos do final.

Passo 1: um vocabulário visual

  • VQ-GAN: um VQ-VAE treinado com perdas perceptual e adversarial
  • encoder → grade de vetores → o mais próximo de vetores do codebook → grade de inteiros
  • decoder: vetores do codebook → pixels

Uma imagem 256 × 256, redução 16, . Quantos tokens e quantos bits eles carregam?

redução 16: cada token resume um bloco 16 × 16 de pixels · K = nº de vetores do codebook

  • por lado: tokens, bits cada
  • no máximo 3 584 bits ≈ 450 bytes, para bytes de pixels
  • todo o resto o decoder inventa: o teto de fidelidade

Simulador · tokenizando uma imagem

Treinar um quantizador

çãó

x = imagem · ze = saída do encoder · e = o código mais próximo de ze · D = decoder · sg[·] = stop-gradient: constante na volta · β = peso do commitment (0,25 no lab)

  • o argmin não tem gradiente: o estimador straight-through copia o gradiente do decoder para o encoder ( na ida, na volta)

Que códigos o termo do meio move?

  • Só os que foram escolhidos. Um código que nunca é o mais próximo nunca se move: um código morto.

Diagrama · um passo do quantizador, ida e volta

Um passo de treino de um tokenizador VQ. Na ida: a imagem x passa pelo encoder até um vetor z_e, que é trocado pelo mais próximo dos K vetores do codebook (o código e); o seu número k é o token; o decoder D reconstrói a imagem a partir dele. Na volta: o gradiente da reconstrução para no argmin, o estimador straight-through o copia de z_q para z_e, o termo do codebook move só o código escolhido e o termo de commitment puxa z_e para ele. Os códigos não escolhidos não recebem gradiente. UM PASSO DE TREINO straight-through: o gradiente é copiado ximagem EncoderCNN zed números Mais próximoíndice k = token zq = evai ao decoder Decoder DCNN D(zq)refeita CODEBOOKK VETORES,NUMERADOS 0 … K − 1 0 1 2 3 4 6 … ek = 5 0000000← gradiente 0: não foram escolhidos β ‖ze − sg[e]‖²commitment: move ze ‖sg[ze] − e‖²move o código e ‖x − D(zq)‖²reconstrução valores, para a frente (setas de cima) gradiente, para trás (setas de baixo) sg[·] = stop-gradient: uma constante na volta β = peso do commitment, 0,25 no lab

Simulador · um codebook em 2-D

Corrigindo o colapso

  • Um VQ melhor: inicializar com dados, reiniciar códigos mortos, códigos normalizados de baixa dimensão
    (LlamaGen: códigos de 8-d, 97% de 16 384 usados)
  • FSQ: 3–6 números, cada um limitado por e arredondado para poucos níveis; → códigos numa grade fixa
  • LFQ (MAGVIT-v2): 18 sinais → códigos
  • Nenhum quantizador: tokens contínuos (MAR, mais adiante)

O FSQ não tem codebook, nem perda de codebook, nem perda de commitment: nada pode morrer.

Laboratório · VQ contra FSQ no MNIST

dígitos 28 × 28, redução 4 → grade , 49 tokens

tokenizador códigos usados no teste perplexidade MSE de reconstrução
VQ, códigos de 16-d 256 82 de 256 (32%) 44 0,0047
FSQ, níveis (8, 6, 5) 240 de 240 (100%) 77 0,0034

usados = códigos que aparecem nos 10 000 × 49 = 490 000 tokens do teste · perplexidade = 2entropia do uso dos códigos: a quantos códigos igualmente usados o uso equivale

  • a mesma qualidade de reconstrução a olho, com 3 números por posição (FSQ) em vez de 16 (VQ)
  • vocabulário efetivo 1,8× maior:

Passo 2: gerar os tokens como texto

ti = o i-ésimo token (um inteiro do codebook) · N = nº de tokens · c = a condição (uma classe ou um prompt)

O treino usa máscara causal e roda todas as posições de uma vez. A amostragem pode fazer o mesmo?

  • Não: o token precisa do valor sorteado do token .
  • Treino: paralelo (teacher forcing). Amostragem: passadas sequenciais pela rede.
  • Temperatura, top- e classifier-free guidance nos logits vêm direto dos LLMs.

teacher forcing: a entrada são os tokens anteriores verdadeiros · classifier-free guidance: ℓ = ℓ∅ + w (ℓc − ℓ∅), os logits com c afastados dos logits sem c, w > 1

Simulador · tokenizar e prever, linha a linha

z · saída do encoder
codebook (K = 4)
logits do modelo para t4

Simulador · ordem raster

O que custa

imagem grade = lado / f tokens = passadas sequenciais
256², f = 16 256/16 = 16 → 16 × 16 256
512², f = 16 (Chameleon) 512/16 = 32 → 32 × 32 1 024
1024², f = 16 1024/16 = 64 → 64 × 64 4 096
ImageGPT: pixels crus 64², f = 1 64 × 64 4 096, para uma miniatura

f = fator de redução do tokenizador: cada token resume um bloco f × f de pixels

  • o KV cache faz cada passada processar um token novo; ele não elimina a sequência
  • o tokenizador é o que torna isso viável: reduzir por 16 em cada lado divide a sequência por

Diagrama · o que o KV cache economiza e o que não economiza

Amostragem de 8 tokens depois de uma condição c, uma passada pela rede por token. Cada linha é uma passada: a entrada é c mais os tokens já sorteados; no fim ela sorteia o próximo token, que entra na linha seguinte. Sem cache, cada passada recalcula o prefixo inteiro (36 posições no total); com KV cache, cada passada calcula só a posição mais nova (8 no total), mas ainda atende a todas as chaves anteriores. As 8 passadas continuam sequenciais. ENTRADA DE CADA PASSADA SORTEADO calculada lida do cache ainda não sorteada ESTA AMOSTRA · 8 TOKENS passadas sequenciais8 posições calculadas chaves lidas pela atenção A MESMA CONTA EM ESCALA tokens Npassadascalculadas

A verossimilhança é exata, mas dos tokens

Laboratório, MNIST, 49 tokens FSQ por dígito:

modelo bits por token × 49 tokens = bits por imagem
teto: todo código igualmente provável 387,4
só as frequências dos tokens, sem contexto 6,26 (a entropia) 307
Transformer autorregressivo (862 832 parâmetros) 3,07 150,5

bits = −log₂ p(token): o que o modelo paga, em média, por token dos dígitos de teste

  • a região do traço custa até 5,17 bits por token; o último canto, 0,31
  • exata pela regra da cadeia, mas dos tokens: muitas imagens os compartilham

MaskGIT: poucas rodadas paralelas

  1. começa com todo token [MASK]
  2. um Transformer bidirecional prevê todos os tokens mascarados de uma vez
  3. sorteia-os, mantém os mais confiantes, volta a mascarar o resto
  4. depois da rodada de , restam mascarados — com , : depois da rodada 1, só 5 fixados

8 rodadas para 256 tokens, 12 para 1 024. O artigo relata uma decodificação de 30 a 64 vezes mais rápida que a autorregressão.

Simulador · o cronograma de cosseno

Por que não uma rodada só?

Uma passada prevê todos os tokens. Por que não sortear os 49 e parar?

  • Tokens sorteados na mesma passada são independentes entre si, dado o que está visível.
  • Laboratório, 1 000 dígitos condicionados à classe. Dígitos reais: acerto 98,1%, distância de Fréchet 25,2 (o piso).
decodificador passadas acerto distância de Fréchet ↓
autorregressivo 49 0,840 31,2
MaskGIT, 1 rodada 1 0,689 138,2
MaskGIT, 4 rodadas 4 0,882 64,3
MaskGIT, 8 rodadas 8 0,899 69,3

acerto = fração que o juiz (uma CNN pequena) classifica como o dígito pedido · distância de Fréchet entre as features do juiz para os gerados e para os reais: penaliza amostras ruins e amostras parecidas demais

VAR: prever a próxima escala

  • não um token por passo: um mapa de tokens inteiro, na resolução seguinte
  • 256²: mapas de lado 1, 2, 3, 4, 5, 6, 8, 10, 13, 16 → dez lados, 10 passadas em vez de
  • cada mapa condicionado em todos os mais grossos; os tokens de um mapa em paralelo
  • uma ordem que os dados têm: o layout antes do detalhe

ImageNet 256²: FID 1,73 contra 2,27 do DiT-XL/2 (18,65 da sua linha de base raster, ~20× mais lenta). Melhor artigo da NeurIPS 2024. Infinity (2025): a mesma ideia em texto-para-imagem a 1 024².

FID = distância de Fréchet entre imagens geradas e reais nas features de uma rede Inception: menor é melhor

Diagrama · dez mapas, dez passadas

Previsão da próxima escala no VAR para uma imagem 256 por 256: dez mapas de tokens de lado 1, 2, 3, 4, 5, 6, 8, 10, 13 e 16, 680 tokens no total; cada mapa sai de uma passada pela rede condicionada em todos os mais grossos. Os mapas são resíduos: ampliados para 16 por 16 e somados, eles dão o mapa de features que o decoder lê. Embaixo, as passadas sequenciais: 256 na ordem raster, 10 no VAR. PRÓXIMA ESCALA · UM MAPA DE TOKENS POR PASSADA Σ ampliar para 16 × 16 e somar → decoder próximo token · 256 passadas próxima escala · 10 passadas ← uma passada por mapa, de 1 a 256 tokens

MAR: dispensar o quantizador

O codebook limita a fidelidade. Como sortear um token contínuo de forma autorregressiva?

  • Não com uma gaussiana (uma média borrada para uma distribuição com vários modos).
  • Com um pequeno modelo de difusão por token: o Transformer produz e um MLP (~21 M, cerca de 5% do modelo) remove o ruído de a partir dele.

  • MAR: ordem aleatória, grupos paralelos, FID 1,55. Fluid, NextStep-1: o mesmo na escala de texto-para-imagem.

zi = a saída do Transformer para a posição i · xi = o token contínuo da posição i · xi,t = xi com ruído no nível t (aqui t é o tempo da difusão, não um token) · ε = o ruído sorteado · εθ = o MLP, que tenta adivinhá-lo

O eixo não é o que as pessoas pensam

categórica (codebook) contínua (cabeça de difusão / flow)
um token por vez VQ-GAN, LlamaGen, Chameleon, Emu3 NextStep-1
rodadas paralelas MaskGIT, Muse, Show-o MAR, Fluid
do grosso ao fino VAR, Infinity —
todas as posições, a cada passo difusão discreta Stable Diffusion, FLUX, DiT
  • ordem e distribuição por token são escolhas independentes
  • a direção oposta: modelos de linguagem por difusão (LLaDA, Gemini Diffusion, Mercury)

Imagens dentro de um modelo de linguagem

[TEXTO: "uma foto de"] [IMG_3742] [IMG_891] ... [IMG_5531] [TEXTO: "um gato"]
  • Chameleon (2024): imagem 512² = 1 024 tokens de 8 192 códigos, somados ao vocabulário do texto
  • um Transformer, uma perda de próximo token, desde o primeiro passo do pré-treino

Essa é a única maneira de pôr geração de imagens dentro de um LLM?

Diagrama · quatro projetos, uma sequência

Quem faz o quê

modelo tokens de imagem gera imagens por
Chameleon, Emu3, Janus-Pro VQ próximo token
Emu3.5 (2025) IBQ, 131 072 códigos próximo token, + modo paralelo (~20×)
Transfusion, BAGEL latentes de VAE perda de difusão / flow dentro do LLM
HunyuanImage 3.0 (2025) latentes de VAE no estilo Transfusion, MoE de 80 B
MetaQuery, BLIP3-o — LLM condiciona um modelo de difusão separado

Janus-Pro: SigLIP para entender, VQ para gerar. Entender pede semântica; gerar pede os pixels de volta.

O que não é público

GPT-4o / GPT Image: "um modelo autorregressivo embutido nativamente no ChatGPT". Nada oficial além disso. "AR + decoder de difusão" é uma leitura de uma imagem de quadro branco no post de lançamento.

Modelos de imagem do Gemini: cobrados como 1 290 tokens de saída por imagem. Arquitetura não descrita.

  • qualquer projeto do slide anterior é compatível com o que é público
  • diga "não divulgado" em vez de repetir um palpite

AR contra difusão em 2026

AR / mascarado sobre tokens difusão / flow
FID no ImageNet 256² VAR 1,73, MAR 1,55, RAR 1,48 DiT 2,27; REPA / RAE ≈ 1,1–1,4
texto-para-imagem, aberto competitivo lidera (SD3, FLUX, Qwen-Image)
texto + imagem, um modelo natural precisa de uma 2ª perda ou de um 2º modelo
amostragem passadas, 8–12 rodadas, ~10 escalas 1–50 passadas sobre todas as posições
verossimilhança exata (tokens) limite / EDO

FID: menor é melhor · REPA, RAE: transformers de difusão que se apoiam num encoder de imagem pré-treinado (DINOv2), capítulo 22

Laboratório · tokens, medidos

Notebook no Colab, ~2 h de trabalho, GPU T4 (plano gratuito, ~10 min de computação), MNIST, tudo treinado do zero. Cada seção termina num checkpoint.

  1. um juiz: acerto de uma CNN + distância de Fréchet
  2. um tokenizador VQ e os seus códigos mortos
  3. FSQ: sem codebook
  4. a imagem como 49 tokens
  1. um Transformer autorregressivo: bits por imagem
  2. a amostragem: 49 passadas
  3. MaskGIT: rodadas contra qualidade
  4. qualidade contra custo: a tabela é sua

abrir no Colab →

Pontos principais

  1. Um tokenizador transforma a imagem em inteiros: no máximo bits, o teto de fidelidade.
  2. Codebooks VQ colapsam; FSQ / LFQ trocam o codebook por uma grade fixa.
  3. Uma passada sequencial por token; o KV cache não elimina a sequência.
  4. MaskGIT: 8–12 rodadas, mas não 1. VAR: ~10 escalas. MAR: tokens contínuos.
  5. Os eixos reais: ordem × distribuição por token.
  6. Ela voltou pela unificação; em qualidade, a difusão ainda lidera texto-para-imagem.

Roteiro: (1) por que isto voltou e onde é usado; (2) o tokenizador e o colapso do codebook; (3) a autorregressão e o que ela custa; (4) MaskGIT, VAR, MAR; (5) os dois eixos; (6) imagens dentro de um modelo de linguagem e o que não é público; (7) AR contra difusão em 2026. Fecha com o laboratório no Colab.

Resposta: uma sequência, uma perda, um modelo para texto e imagens. Ler, raciocinar e desenhar no mesmo contexto.

Passe pelos passos: imagem → encoder → latente 16×16×256 → código mais próximo → 16×16 inteiros (256 tokens, K = 16.384) → decoder.

Oito passos: codificar; o código mais próximo toma o lugar de z_e (o seu número k é o token); decodificar e pontuar; na volta, o argmin é um muro; o straight-through copia o gradiente para z_e; os outros dois termos (o código anda na direção de z_e, z_e na direção do código); quem fica sem nada: todo código não escolhido recebe 0, os códigos mortos do próximo slide.

Inicialização aleatória ampla, K = 32: treine 30 passos, termina com 21/32 usados. K = 64: 28/64. Depois "cópias de pontos dos dados" (63/64) ou marque "reiniciar códigos mortos" (64/64): (quase) 100%. O VQGAN original usava 3,4% dos seus 16 384 códigos no ImageNet.

O código do laboratório numa imagem 2 × 2, K = 4 códigos em 2-D: todo número confere à mão. Avance linha a linha em "o exemplo da página". Linhas 2-6 são o tokenizador: dist, argmin → tokens [1, 3, 0, 3]; o código 2 não vence nada e recebe gradiente zero (linha 5); os dois termos auxiliares dão o mesmo número na ida (0,0475) e só diferem para onde vai o gradiente. Linhas 7-10 são um passo do modelo AR: loss = −log 0,598 = 0,515 (chute cego log 4 = 1,386). Na última linha mexa em τ: 0,1 → sempre o código 3; 5 → quase uniforme. Casos: "um código longe dos dados" → código morto, aux dobra; "um ponto entre dois códigos" → empate, argmin pega o primeiro, o alvo t4 muda e a perda pula para 3,0; "o modelo aposta em outro token" → perda 2,28 e o sorteio dá 1.

16×16 = 256 tokens, um por passo. Troque para ordem aleatória: continua um por vez, as mesmas 256 passadas.

Comece sem cache: a passada i recalcula o prefixo inteiro, 36 posições para 8 tokens; as setas tracejadas são a dependência sequencial. Clique em "Com KV cache": 8 posições, mas ainda 8 passadas; a posição nova ainda lê i chaves (36 no total). A tabela: 49 tokens (o lab) 1 225 contra 49; 256 tokens 32 896 contra 256. Passe o mouse sobre uma passada para ver os números dela.

5, 20, 44, 75, 114, 159, 207, 256 fixados depois das rodadas 1–8: poucos no começo, muitos no fim. Espalhados, não em raster.

com 8 rodadas ele é reconhecido um pouco mais vezes (0,899 contra 0,840), mas a sua FD é mais que o dobro da do modelo autorregressivo (69,3 contra 31,2): os dígitos são mais limpos e mais parecidos entre si.

Avance pelas dez passadas: cada mapa sai de uma passada pela rede, condicionado em todos os mais grossos (o colchete laranja); 1, 5, 14, 30, 55, 91, 155, 255, 424, 680 tokens até ali. As barras: 256 passadas na ordem raster, 10 no VAR. Último passo: os mapas são resíduos, ampliados para 16 × 16 e somados.

Passe pelas abas: o que uma posição de imagem guarda, como é prevista, a máscara de atenção, o que a decodifica.

Quase empate no ImageNet; a difusão lidera texto-para-imagem isolado; a AR vence onde a geração divide um contexto com texto.