A tese desta página: gerar imagem é remover ruído em passos, guiado por texto. Isso soa como simplificação de divulgação e não é: é a descrição literal do algoritmo, linha por linha. Você começa com ruído puro, um modelo estima quanto de cada pixel é ruído, você subtrai um pouco, e repete. Vinte vezes depois há uma imagem. Esta página roda esse processo inteiro cronograma, passo reverso, CFG, img2img no seu navegador.
O que NÃO acontece
não há busca num banco de imagens: nada é recuperado, tudo é gerado
não há colagem de pedaços de imagens de treino
não há desenho: nenhuma etapa "traça" nada, só se subtrai ruído
não há composição planejada: a estrutura emerge dos passos, e por isso mãos são difíceis
O que acontece
um cronograma fixo define quanto ruído existe em cada passo
uma rede prevê o ruído presente, não a imagem final
o texto entra por atenção dentro dessa rede, a cada passo
e tudo roda no espaço latente, ~48 vezes menor que a imagem
Explore cada etapa →
A matemática, num só lugar
As 4 fórmulas que descrevem o processo inteiro. Clique em qualquer uma para pular direto para a etapa que a explica.
Honestidade, antes de começar leia esta parte: tudo nesta página roda de verdade numa grade de 24×24 em RGB, exceto uma coisa. O cronograma de ruído é real (as fórmulas de cosseno e linear dos artigos originais, com ᾱ_t calculado; o valor final do cronograma linear bate com o do artigo de 2020 na quarta casa). O processo direto é real.O passo reverso DDIM é real.A fórmula do CFG é real e é por isso que o estouro em escala alta que você vai ver na etapa 4 é o estouro de verdade, não uma animação programada. O que não é real é o denoiser: um modelo de verdade tem bilhões de pesos treinados; aqui é uma função de dez linhas que mistura um borrão do estado atual com um protótipo escolhido pelo "prompt". Ela reproduz o comportamento certo alucina estrutura quando há muito ruído, refina quando há pouco mas não aprendeu nada. Onde isso importa, a página avisa de novo.
Antes de aprender a gerar, o treino aprende a destruir. Pega-se uma imagem real e adiciona-se ruído gaussiano em quantidade crescente até sobrar só ruído. Esse é o processo direto, e o mais importante sobre ele é que não tem nada de aprendido: é uma fórmula fechada, e qualquer passo é calculado direto de x₀ sem iterar.
A imagem de partida
·
x₀ · original+ε · o ruído somado=x_t · ruidosa
o campo de ruído tem média zero e valores negativos: para ser visível, ele é reescalado na exibição
Cronograma de ruído
t = 0 · imagem limpat = 1000 · ruído puro
Fórmula · o processo direto, em um passo
x_t = √ᾱ_t · x₀ + √(1 − ᾱ_t) · ε · ε ~ 𝒩(0, I)
Leia assim: a imagem ruidosa no passo t é a imagem original multiplicada por √ᾱ_t, mais ruído gaussiano multiplicado por √(1 − ᾱ_t). Os dois coeficientes somam 1 em variância, o que mantém a escala constante ao longo de todo o processo. E note o em um passo: não é preciso simular t adições sucessivas de ruído para chegar em x_t. Essa propriedade é o que torna o treino paralelizável cada exemplo do lote sorteia o seu próprio t e vai direto.
Aqui está a escolha de projeto que faz o método funcionar: a rede não tenta adivinhar a imagem limpa. Ela tenta adivinhar o ruído que foi somado. Parece a mesma coisa dado x_t, saber ε é saber x₀ e não é: prever ruído dá um alvo com estatística estável em todos os níveis, e prever imagem não.
x_t · estado atualx̂₀ · o que o modelo acha que vai sairε̂ · o ruído previsto
A cada passo o denoiser produz uma estimativa de ε, o DDIM converte essa estimativa em x̂₀, e dá um passo em direção a x_{t−1}. Repare no painel do meio: a estimativa de x̂₀ existe desde o primeiro passo ela só é péssima no começo, e vai ficando boa.
Duas linhas, e é o sampler inteiro. A primeira inverte a fórmula do processo direto: se você sabe x_t e chuta ε, dá para isolar x₀. A segunda reaplica o processo direto, mas para o passo anterior com menos ruído. É por isso que o método é estável: cada passo volta para a trajetória em vez de acumular erro livremente. E é por isso que ele é determinístico: não há sorteio nenhum aqui, o mesmo ruído inicial dá sempre a mesma imagem.
Por que prever o ruído, e não a imagem
Porque o ruído tem a mesma distribuição em todos os níveis sempre gaussiano padrão, sempre com a mesma escala. Já a imagem limpa é um alvo cuja dificuldade varia brutalmente: em t alto é quase impossível adivinhar, em t baixo é quase trivial. Treinar contra um alvo de dificuldade constante dá gradientes bem-comportados, e foi essa reformulação que transformou difusão de curiosidade teórica em método que funciona.
Honestidade · este denoiser não aprendeu nada
A função que produz ε̂ aqui tem dez linhas: ela mistura um borrão do estado atual com o protótipo que o "prompt" escolheu, dosando pelos coeficientes do cronograma. Isso imita o comportamento certo com muito ruído ela alucina estrutura do nada, com pouco ela refina o que já existe mas não é um modelo. Tudo o mais na etapa é a matemática de verdade: se você trocar esta função por uma U-Net treinada e não mexer em mais nada, isto vira Stable Diffusion.
Difundir direto em pixels funciona e é caro demais. Uma imagem de 512×512 tem 786 mil números, e a atenção dentro do denoiser é quadrática no número de posições. A solução que destravou tudo em 2022 foi simples de enunciar: comprima antes, difunda no comprimido, descomprima no fim.
A conta da compressão
O que o autoencoder joga fora
A compressão não é sem perda e a escolha do que perder é o projeto inteiro. O autoencoder é treinado com uma perda perceptual, então ele preserva o que o olho nota (bordas, formas, cor) e descarta o que o olho não nota (textura de alta frequência, ruído de sensor). É por isso que imagens geradas por difusão latente costumam ter dificuldade com texto pequeno e padrões finos: aquilo caiu fora antes de a difusão começar.
O número que mudou a história
Antes do latente, treinar um modelo de difusão em alta resolução era coisa de laboratório com centenas de GPUs. Depois dele, o mesmo modelo cabe numa placa de consumidor e a inferência roda em segundos. Não foi uma arquitetura nova nem um truque de treino: foi rodar o processo caro num espaço 48 vezes menor. Poucas otimizações na história recente tiveram um efeito tão desproporcional.
O texto vira um vetor por um codificador (um CLIP, um T5), e esse vetor entra na atenção cruzada dentro do denoiser em cada passo, em cada camada. Mas há um segundo controle, e é o mais mal compreendido da área: a escala de guia.
O prompt
Escala de guia (CFG)
s = 7
Fórmula · classifier-free guidance
ε̂ = εincond + s · ( εcond − εincond )
Olhe a fórmula com atenção, porque ela explica tudo. O modelo faz duas previsões por passo: uma com o texto e outra sem. A diferença entre elas é "a direção que o texto empurra". Com s = 1 você fica na previsão condicional. Com s = 7 você anda sete vezes nessa direção muito além do que o modelo previu. CFG não é uma média ponderada: é uma extrapolação, e é exatamente por isso que valores altos estouram. Você está pedindo ao modelo um lugar onde ele nunca esteve.
O custo escondido do CFG: duas previsões por passo significa duas passadas pelo denoiser. Rodar com CFG custa literalmente o dobro de rodar sem. Todo número de "passos por segundo" que você vê publicado precisa dessa multiplicação para virar tempo real, e é a primeira coisa a conferir quando o desempenho medido não bate com o anunciado.
O cronograma define a trajetória; o sampler define como andar por ela. Ele não muda o modelo, não muda o cronograma e não muda o destino ele só escolhe onde parar no caminho. E um sampler bom dá passos maiores sem sair da trajetória, que é toda a razão de 20 passos hoje renderem o que 250 rendiam.
A mesma trajetória, contagens diferentes
O que um sampler é, tecnicamente
O processo reverso pode ser escrito como uma equação diferencial, e um sampler é um método numérico para resolvê-la. DDIM é essencialmente Euler. DPM-Solver++ usa termos de ordem mais alta e por isso acerta mais o caminho com menos avaliações. É a mesma matemática de integração numérica que se usa para simular órbitas e a intuição é a mesma: método melhor, passo maior, mesmo erro.
Honestidade · a curva aqui é do denoiser de brinquedo
O retorno decrescente que você vê acima é real dentro desta simulação: as quatro imagens rodaram o mesmo DDIM sobre o mesmo cronograma, com contagens diferentes. Mas o ponto exato em que ele satura depende do denoiser, e o daqui é de brinquedo. Num modelo real a faixa útil costuma ficar entre 20 e 30 passos com um sampler moderno o formato da curva é o mesmo, o joelho dela não é necessariamente no mesmo lugar.
Prompt é um volante impreciso: você descreve o que quer e torce. As formas de dirigir de verdade agem sobre pontos diferentes do processo, e a mais simples de todas nem precisa de treino nenhum é só começar do meio da trajetória em vez do começo.
img2img · começar do meio
força = 0,60
imagem de partida→resultado
As seis formas de dirigir, do mais vago ao mais estrutural
O erro clássico de controle: tentar fixar geometria por prompt. "Pessoa de perfil olhando para a esquerda, braço direito levantado a 45 graus" gasta tokens e não fixa nada porque o prompt entra como condição difusa na atenção, não como restrição. Geometria se fixa com ControlNet, que injeta um mapa de pose ou de contorno a cada passo. Reconhecer quando o problema é de estrutura, e não de descrição, poupa horas de tentativa e erro.
O caminho inteiro
No fim: difusão é um método com poucas peças e quase nenhuma delas é misteriosa. Um cronograma fixo, uma rede que prevê ruído, uma equação de dois termos para andar de trás para frente, e uma extrapolação para o texto mandar mais. O que impressiona não é a complexidade do algoritmo é que tão pouca coisa baste. Todo o resto (latente, samplers melhores, ControlNet, LoRA) é engenharia em cima dessas quatro peças, exatamente como as páginas de LLM desta série descrevem engenharia em cima de uma pilha de blocos idênticos. A semelhança não é coincidência: nos dois casos, o que escalou foi um núcleo simples repetido muitas vezes.