Gerar uma imagem apagando o ruído

Uma família diferente

Tudo o que vimos até aqui descreve Transformers que preveem o próximo token. É a arquitetura que domina a linguagem, o código, e cada vez mais o vídeo e o áudio.

Mas quando você digita um prompt no Midjourney, no Stable Diffusion ou no FLUX, não é isso que acontece. A imagem não é gerada pixel por pixel da esquerda para a direita. Ela aparece em todo lugar ao mesmo tempo, refinada por etapas sucessivas.

É a obra de uma família de modelos bem diferente: os modelos de difusão.

A ideia central: aprender a remover ruído

O processo de difusão se inspira numa intuição quase simples demais. Se eu pego uma imagem nítida e vou adicionando progressivamente ruído gaussiano, em algum momento ela fica indistinguível do ruído puro. Se eu aprendo a inverter esse processo — a tirar ruído pouco a pouco — então posso partir de ruído puro e terminar com uma imagem nítida.

Durante o treinamento:

1. Pegamos uma imagem do dataset
2. Adicionamos ruído a ela segundo um cronograma predefinido (por exemplo T = 1000 etapas)
3. Treinamos uma rede a prever o ruído que foi adicionado dados a imagem ruidosa e o passo t

Assim o modelo aprende, para qualquer nível de ruído, a reconhecer o que é "imagem real" e o que é "ruído adicionado".

Na inferência, invertemos: partimos de ruído puro e, a cada passo, o modelo prevê o ruído, nós o subtraímos, e recomeçamos. Após T passos, obtemos uma imagem plausível — que se parece com a distribuição aprendida.

Experimente o denoising

Dois ajustes, um botão. Coloque primeiro o número de passos no mínimo e clique em Gerar; repita no máximo e compare. Depois deixe os passos em paz e varie a guidance (CFG) de 0 a 15. São exatamente os dois controles que qualquer interface de geração de imagens expõe.

A animação parte de uma imagem de ruído puro e a denoising em passos sucessivos. Cada passo segue o gradiente aprendido no treinamento, guiado pelo embedding textual do CLIP. Em 5 passos o resultado é borrado; em 50, é nítido.

Brinque com o número de passos. Em 5 passos, a imagem fica granulada — o modelo não tem tempo de refinar. Em 50 passos, ela fica nítida mas com dez vezes mais cálculo. A maioria dos samplers modernos (DDIM, DPM-Solver) atingem qualidade quase ótima em 20 a 30 passos.

Direcionar para uma imagem precisa: a guidance

O ruído puro é o mesmo para todos os prompts. Como o modelo sabe que queremos um pôr do sol e não um cachorro? A resposta: nós condicionamos o modelo no texto.

Durante o treinamento, fornecemos à rede, além da imagem ruidosa e do passo, um embedding do texto associado à imagem (frequentemente um encoder do tipo CLIP). A rede aprende assim previsões de ruído condicionadas: "sabendo que a imagem descreve um pôr do sol, é assim que parece o ruído".

Na inferência, calculamos duas previsões: uma com o prompt, outra sem (ou com prompt vazio). A técnica do Classifier-Free Guidance (CFG) consiste em extrapolar na direção do prompt:

predicao_final = predicao_sem_prompt + guidance × (predicao_com_prompt − predicao_sem_prompt)

O coeficiente guidance (CFG scale) controla quanto nos afastamos do natural para colar no prompt. Em CFG=0, o modelo ignora o texto; em CFG=7, a imagem segue fielmente o prompt sem ficar artificial; além de 12, ela fica supersaturada e perde os detalhes finos.

Latent diffusion: fazer menos cálculo

Uma imagem 512×512 tem 262.144 pixels — e como cada um carrega três canais de cor, são 786.432 valores a tratar. Fazer 1.000 passos de denoising em tantos pixels é muito caro. O Stable Diffusion popularizou um truque: trabalhar num espaço latente comprimido.

Antes de treinar o modelo de difusão, treinamos um autoencoder (um VAE) que comprime as imagens num espaço latente 64×64×4 — cerca de 48× menor. A difusão se aplica então apenas a esse latente, não aos pixels. No final do denoising, decodificamos o latente para a imagem final.

É isso que torna o Stable Diffusion executável num GPU consumidor em alguns segundos — enquanto um modelo equivalente baseado em pixels exigiria um cluster.

CLIP: a ponte entre texto e imagem

Para condicionar em texto, precisamos de uma representação textual que compartilhe um espaço com a das imagens. Esse é o papel do CLIP (Contrastive Language-Image Pretraining), treinado pela OpenAI em 400 milhões de pares imagem/legenda.

O CLIP aprende dois encoders — um para imagens, um para texto — que produzem embeddings num espaço comum. Uma legenda e sua imagem alvo têm embeddings próximos; uma legenda não relacionada fica distante. Esse alinhamento permite ao modelo de difusão entender prompts textuais que ele nunca viu exatamente no treinamento.

U-Net vs Transformer (DiT)

Por muito tempo, a arquitetura de referência para difusão era a U-Net: uma rede convolucional em U, com skip connections que preservam os detalhes finos. Stable Diffusion 1.4, 1.5 e 2 todos usam U-Net.

Mas em 2022, Peebles e Xie propuseram o DiT (Diffusion Transformer): substituir a U-Net por um Transformer puro. Cada "patch" da imagem é tratado como um token, com atenção completa sobre todos os outros patches. Sem mais pirâmide convolucional, sem mais skip connections — apenas blocos Transformer empilhados.

Stable Diffusion 3, FLUX, Sora (vídeo) — todas as arquiteturas recentes migraram para o Transformer. Por quê? Porque os Transformers escalam melhor: encontramos as mesmas scaling laws da linguagem. Dobrar o compute num DiT melhora as imagens de forma previsível.

O sampler: DDPM, DDIM, DPM-Solver

O sampler é o algoritmo que decide, a cada passo, como combinar a previsão do ruído com o estado atual para produzir o próximo passo.

Sampler	Passos típicos	Particularidade
DDPM	1000	Estocástico, fiel ao treinamento, lento
DDIM	20–50	Determinístico, qualidade comparável ao DDPM em bem menos passos
DPM-Solver	10–25	Solver de EDO, ainda mais rápido
Euler / Heun	20–30	Métodos clássicos de EDO, simples e robustos
LCM	4–8	Destilação latente, ultra-rápida

A escolha do sampler é uma das alavancas mais acessíveis para ajustar velocidade vs qualidade.

Por que essa família existe ao lado dos Transformers

Você pode perguntar: por que não gerar imagens como geramos texto, token por token? A resposta é sutil.

Para o texto, a ordem é natural: lemos da esquerda para a direita, e cada palavra depende das anteriores. Para uma imagem, não há ordem canônica. Gerar pixel por pixel introduz artefatos (os primeiros pixels não têm o contexto dos últimos). A difusão resolve esse problema gerando a imagem inteira em paralelo, refinada globalmente a cada passo.

É por isso que as abordagens autoregressivas sobre pixels (PixelRNN, o ImageGPT inicial da OpenAI) foram abandonadas: lentas demais, e o resultado carregava a marca da ordem de geração.

Mas a história não parou aí, e é uma bela lição de humildade. O autoregressivo voltou — não mais sobre pixels, e sim sobre tokens de imagem, exatamente como um LLM manipula tokens de texto. Quando a OpenAI integrou a geração de imagens diretamente em seus modelos de linguagem, em 2025, a abordagem foi para a frente dos comparativos, à frente das melhores difusões do momento. Desde então, a fronteira mistura as duas: um transformer autoregressivo que decide o que representar, e um decodificador do tipo difusão que produz a imagem final.

A difusão não é um Transformer: é uma outra forma, matematicamente ortogonal, de aprender uma distribuição complexa. Ela ainda domina o open source para imagem — mas a ideia de que "a difusão venceu" não se sustentou. As duas famílias estão se reencontrando.

E essa é uma boa forma de fechar este percurso. Você partiu de um sistema que prevê a próxima palavra e seguiu esse fio até os tokens, os vetores, a atenção, o alinhamento, os agentes, as features. Este último capítulo lembra que existia outra rota — e que ela acaba cruzando a primeira. Nada disso está estabilizado: as arquiteturas dominantes de hoje não serão necessariamente as de daqui a três anos. Mas os mecanismos que você agora conhece não vão mudar muito. São eles que vão te permitir ler a próxima surpresa pelo que ela é: uma ideia de engenharia, não mágica.

Atualizado em 2 de agosto de 2026