Phase 12 - Lesson 14

Modelos Unificados Show-o e de Difusão Discreta

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

Transfusion mistura representações contínuas e discretas. Show-o (Xie et al., agosto de 2024) vai pelo outro caminho: tokens de texto usam previsão causal do próximo token (next-token prediction), tokens de imagem usam difusão discreta mascarada no estilo do MaskGIT. Ambos residem em um único transformer com uma máscara de atenção híbrida. O resultado unifica VQA, texto para imagem (text-to-image), inpainting e geração de modalidades mistas em uma única estrutura (backbone), um tokenizador por modalidade e uma formulação de perda única (perda de próximo token estendida para previsão mascarada). Esta lição aborda o design do Show-o — por que a difusão discreta mascarada é um gerador de imagens paralelo de poucos passos — e o contrasta com o Transfusion e o Emu3.

Tipo: Aprender Idiomas: Python (biblioteca padrão, amostrador de difusão discreta mascarada) Pré-requisitos: Fase 12 · 13 (Transfusion) Tempo: ~120 minutos

Objetivos de Aprendizado

• Explicar a difusão discreta mascarada: o cronograma que mascara os tokens uniformemente e depois pede ao transformer para recuperá-los.
• Comparar a decodificação paralela de imagens (Show-o, MaskGIT) com a decodificação autorregressiva de imagens (Chameleon, Emu3) em relação a velocidade e qualidade.
• Nomear as três tarefas que o Show-o executa em um único checkpoint: T2I, VQA e inpainting de imagem.
• Escolher um cronograma de mascaramento (cosseno, linear, truncado) e raciocinar sobre seu efeito na qualidade da amostra.

O Problema

O treinamento de duas perdas (two-loss) do Transfusion funciona, mas tem dinâmicas mais complicadas — a perda de difusão contínua reside em uma escala numérica diferente da perda de NTP discreta. Equilibrar os pesos das perdas exige uma busca de hiperparâmetros. A arquitetura é eficaz, mas complexa.

A resposta do Show-o: manter ambas as modalidades discretas (como o Chameleon), mas gerar imagens em paralelo via difusão discreta mascarada em vez de sequencialmente. O objetivo de treinamento se torna uma previsão única de token mascarado (masked-token-prediction) que generaliza naturalmente a previsão do próximo token (next-token-prediction).

O Conceito

Difusão discreta mascarada (MaskGIT)

O truque original do MaskGIT de Chang et al. (2022) é elegante. Comece com uma imagem totalmente mascarada (cada token é o ID especial <MASK>). A cada etapa, preveja todos os tokens mascarados em paralelo, depois mantenha as K previsões mais confiantes e mascare o restante novamente. Após ~8-16 iterações, todos os tokens estão preenchidos. O cronograma de quantos tokens desmascarar por etapa é ajustado — cronogramas de cosseno funcionam bem.

O treinamento é simples: selecione uma taxa de mascaramento uniformemente de [0, 1], aplique-a aos tokens VQ da imagem e treine o transformer para recuperar os tokens mascarados. Exatamente o que o BERT fez para texto, escalado para a geração de imagens.

Show-o: um transformer, máscara híbrida

O Show-o coloca o MaskGIT dentro de um transformer de modelo de linguagem causal. A máscara de atenção é:

• Tokens de texto: causal (LLM padrão).
• Tokens de imagem: bidirecional completo dentro do bloco de imagem (para que os tokens mascarados consigam ver todos os outros tokens de imagem durante a previsão).
• Texto para imagem: o texto atende a imagens anteriores, a imagem atende a textos anteriores.

O treinamento alterna entre:

1. NTP padrão em sequências de texto.
2. Amostras de T2I: texto → imagem com tokens de imagem mascarados, perda de previsão de tokens mascarados (masked-token-prediction loss).
3. Amostras de VQA: imagem → texto com tokens de texto mascarados (na verdade, apenas NTP).

A perda unificada é a entropia cruzada nos tokens <MASK>, que cobre tanto o NTP de texto (onde apenas o último token é "mascarado") quanto a difusão mascarada de imagem (onde um subconjunto aleatório é mascarado).

Amostragem paralela

O Show-o gera uma imagem em ~16 etapas em vez de ~1000 (autorregressivo por token) ou ~20 (difusão). Em cada etapa, preveja todos os tokens mascarados em paralelo; confirme as K previsões mais confiantes (top-K); repita.

Compare:

• Chameleon / Emu3 (autorregressivo sobre tokens): N_tokens passagens diretas (forward passes), tipicamente de 1024 a 4096 por imagem.
• Transfusion (difusão contínua): ~20 etapas, cada uma sendo uma passagem completa pelo transformer.
• Show-o (difusão discreta mascarada): ~16 etapas, cada uma sendo uma passagem completa pelo transformer.

O Show-o é mais rápido que o Chameleon em modelos de escala semelhante e praticamente se iguala à contagem de etapas do Transfusion com um custo menor por etapa (logits de vocabulário discreto vs perda MSE contínua).

Tarefas em um único checkpoint

O Show-o suporta quatro tarefas na inferência, selecionadas pelo formato do prompt:

• Geração de texto: saída de texto autorregressiva padrão.
• VQA: imagem de entrada, texto de saída.
• T2I: texto de entrada, imagem de saída via difusão discreta mascarada.
• Inpainting: imagem com alguns tokens mascarados, preenchimento.

A capacidade de inpainting vem de graça graças ao treinamento de previsão mascarada. Mascare uma região da grade de tokens VQ, envie o restante junto com um prompt de texto e preveja os tokens mascarados.

Cronograma de mascaramento

O cronograma de quantos tokens desmascarar por etapa molda a qualidade. O Show-o recomenda o cosseno:

mask_ratio(t) = cos(pi * t / (2 * T))   # t = 0..T

Na etapa 0, todos os tokens estão mascarados (taxa de 1.0). Na etapa T, nenhum está mascarado. O cosseno concentra a massa em taxas intermediárias, onde a previsão é mais informativa. Cronogramas lineares também funcionam, mas atingem um patamar de estabilização (plateau) mais rapidamente.

Show-o2

O Show-o2 (sequência de 2025, arXiv 2506.15564) escala o Show-o: base LLM maior, melhor tokenizador, cronograma de máscara aprimorado. O mesmo padrão arquitetônico.

Onde o Show-o se posiciona

Na taxonomia de 2026:

• Tokens discretos + NTP: Chameleon, Emu3. Simples, mas com inferência lenta.
• Tokens discretos + difusão mascarada: Show-o, MaskGIT, LlamaGen, Muse. Amostragem paralela, ainda com perdas devido ao tokenizador (lossy).
• Contínuo + difusão: Transfusion, MMDiT, DiT. Qualidade mais alta, treinamento mais complexo.
• Contínuo + correspondência de fluxo (flow matching) em um VLM: JanusFlow, InternVL-U. O mais recente.

Escolha pela tarefa: Show-o quando desejar T2I + inpainting + VQA in um único modelo aberto com velocidade razoável; Transfusion quando a qualidade for primordial e você puder arcar com a estrutura de duas perdas.

Use

O arquivo code/main.py simula a amostragem do Show-o:

• Uma grade de brinquedo de 16 tokens VQ.
• Um "transformer" simulado (mock) que prevê logits com base em um prompt e nos tokens atualmente desmascarados.
• Amostragem mascarada paralela ao longo de 8 etapas com cronograma de cosseno.
• Imprime os estados intermediários (evolução do padrão de máscara) e os tokens finais.

Execute-o e observe a máscara se dissolver passo a passo.

Envie

Esta lição produz o arquivo outputs/skill-unified-gen-model-picker.md. Dado um produto que necessita tanto de compreensão (VQA, legendagem/captioning) quanto de geração (T2I, inpainting) sob uma restrição de pesos abertos (open weights), escolhe entre a família Show-o, a família Transfusion/MMDiT e a família Emu3 / Chameleon com base em trade-offs concretos.

Exercícios

1. A difusão discreta mascarada gera amostras em ~16 etapas. Por que não em 1? O que quebra se você desmascarar tudo na etapa 0?

2. O inpainting vem de graça com a difusão mascarada. Proponha um caso de uso de produto (real ou hipotético) no qual o inpainting do Show-o supere um modelo especialista.

3. Cronograma de cosseno vs cronograma linear: trace o número de tokens desmascarados por etapa para T=8. Qual deles é mais equilibrado?

4. Uma imagem de 512x512 no Show-o tem 1024 tokens. Com um vocabulário K=16384, o modelo emite 1024 * log2(16384) = 14.336 bits (1.75 KiB) de dados. O Stable Diffusion gera 51251224 bits = 6.291.456 bits (768 KiB) de pixels brutos. Qual é a taxa de compressão e que qualidade ela proporciona?

5. Leia o artigo do LlamaGen (arXiv:2406.06525). Como o modelo de imagem autorregressivo condicional a classes do LlamaGen difere da abordagem mascarada do Show-o?

Termos-Chave

Leituras Adicionais

• Xie et al. — Show-o (arXiv:2408.12528)
• Show-o2 (arXiv:2506.15564)
• Chang et al. — MaskGIT (arXiv:2202.04200)
• Sun et al. — LlamaGen (arXiv:2406.06525)
• Chang et al. — Muse (arXiv:2301.00704)