En el Módulo 7 resolvimos dónde generar: en un espacio latente chico y barato, no en los píxeles. Hoy resolvemos cómo, y entramos al corazón del curso. Los modelos de difusión son la familia que domina hoy la generación de imágenes —Stable Diffusion, FLUX, Midjourney o Imagen son de difusión; la excepción notable es GPT Image de OpenAI, que genera la imagen token a token como un LLM— y su idea central es tan simple que sorprende: enséñale a una red a quitar ruido, y luego pídele que quite ruido de una imagen que es puro ruido. Lo que aparece es una imagen nueva.

La tesis del módulo

Generar es lo mismo que limpiar, hecho muchas veces. En vez de fabricar una imagen de un solo golpe —lo que hacía inestable a la GAN—, la difusión aprende a dar un pasito chico: quitarle un poco de ruido a algo. Repite ese pasito cincuenta veces partiendo de ruido puro, y de la nada emerge una imagen.

La intuición: destruir para aprender a construir

Piensa en una foto y en una máquina que le echa ruido encima, de a poquito, como estática de televisor. Al principio la foto casi no cambia; ronda tras ronda se ensucia más, hasta que después de muchos pasos no queda nada reconocible: puro ruido gaussiano (ruido aleatorio con forma de campana de Gauss — los números al azar de siempre). Ese camino de imagen a ruido es fácil y no requiere aprender nada; es pura receta.

La pregunta genial fue: ¿y si entrenamos una red para andar ese camino al revés? Si sabe deshacer un pasito de ruido, podemos encadenar muchos pasitos y llegar de ruido puro a imagen. Eso es un modelo de difusión.

Los dos procesos

Forward: agregar ruido (la parte fácil)

El proceso forward (proceso hacia adelante — agregar ruido gaussiano poco a poco hasta que la imagen es puro ruido) no usa ninguna red. Es una fórmula fija: en cada uno de los T pasos (1.000 en el DDPM original), le sumas un poquito de ruido gaussiano a la imagen. Paso 0 es la imagen limpia; paso T es indistinguible del ruido puro. Sirve para fabricar los ejemplos de entrenamiento: pares de “imagen con algo de ruido” y “el ruido exacto que le pusimos”.

Reverse: quitar ruido (la parte que se aprende)

El proceso reverse (proceso hacia atrás — deshacer el ruido paso a paso) es donde vive la red. Su tarea, en cada paso, es denoising (quitar ruido — limpiar una imagen ruidosa). El detalle fino y contraintuitivo: la red no predice la imagen limpia directamente. Predice el ruido que hay que restar en ese paso. Con ese ruido predicho, das un pasito hacia una versión un poco más limpia, y repites.

   FORWARD  (agregar ruido — receta fija, sin red)

    x0        x1        x2                xT
  ┌────┐    ┌────┐    ┌────┐    ···    ┌────┐
  │foto│ ─► │ +· │ ─► │+···│ ─►     ─► │████│
  └────┘    └────┘    └────┘           └────┘
  limpia                              puro ruido

   REVERSE  (quitar ruido — la red aprende esto)

    xT                  x2        x1        x0
  ┌────┐    ···    ┌────┐    ┌────┐    ┌────┐
  │████│ ─►     ─► │+···│ ─► │ +· │ ─► │foto│
  └────┘           └────┘    └────┘    └────┘
  puro ruido                          generada

Cada flecha del reverse es una pasada por la misma red, prediciendo y restando el ruido de ese paso.

Entrenamiento: predecir el ruido

Entrenar es sorprendentemente directo, y ahí está su gran ventaja sobre la GAN. Este pseudocódigo captura el objetivo real (DDPM, el modelo de difusión clásico):

import torch
import torch.nn as nn

criterio = nn.MSELoss()
opt = torch.optim.Adam(red.parameters(), lr=1e-4)

for x0, _ in loader:                 # x0 = imágenes limpias (en el latente)
    B = x0.size(0)
    # 1) elegir un paso de ruido al azar para cada imagen
    t = torch.randint(0, T, (B,))
    # 2) el ruido REAL que vamos a inyectar (esto es la "respuesta")
    ruido = torch.randn_like(x0)
    # 3) versión ruidosa según la fórmula del forward
    x_t = agregar_ruido(x0, ruido, t)     # receta fija, sin red
    # 4) la red intenta ADIVINAR ese ruido a partir de x_t y t
    ruido_pred = red(x_t, t)
    # 5) pérdida = ¿acertó el ruido que le pusimos?
    perdida = criterio(ruido_pred, ruido)
    opt.zero_grad(); perdida.backward(); opt.step()

Un solo objetivo estable —adivinar el ruido inyectado— y a entrenar. Sin dos redes peleando, sin equilibrios frágiles, sin mode collapse. La pérdida baja y de verdad significa que el modelo mejora (a diferencia de la GAN del Módulo 6).

Sampling: generar desde la nada

Con la red ya entrenada, generar se llama sampling (muestreo — el proceso de crear una imagen nueva) y es puro proceso reverse:

Parte de ruido puro al azar (un torch.randn, sin ninguna imagen detrás).
La red predice el ruido de ese paso; se lo restas parcialmente. Ahora hay algo un poco menos ruidoso.
Repites decenas de veces (los famosos “steps” que ajustas en cualquier interfaz de Stable Diffusion).
Al final del último paso, el ruido se convirtió en una imagen coherente que nunca existió.

Cada semilla de ruido inicial distinta da una imagen distinta — por eso la difusión tiene tanta diversidad y no colapsa: cada punto de partida lleva a un lugar distinto del espacio de imágenes.

Ojo con los “steps”: más pasos de sampling suele dar más calidad y detalle, pero cada paso es una pasada completa por la red. Ahí está el costo. Por eso el truco del Módulo 7 es tan vital: si cada uno de esos 50 pasos ocurre en el latente chico y no en los píxeles, la difusión pasa de imposible-en-casa a correr en tu GPU.

Por qué funciona: muchos pasitos chicos

La razón profunda de que la difusión supere a la GAN cabe en una frase: aprender muchos pasitos chicos es más fácil que aprender un salto gigante. La GAN intenta ir de ruido a imagen perfecta de un solo golpe — un problema durísimo, por eso su entrenamiento es tan frágil. La difusión descompone ese salto imposible en cincuenta pasitos de “quítale un poquito de ruido”, cada uno fácil y estable de aprender. Divide y vencerás, aplicado a generar imágenes.

Difusión vs GAN

	GAN	Difusión
Cómo genera	un salto (ruido → imagen)	muchos pasitos de denoising
Estabilidad de entrenamiento	frágil, se descarrila	estable y predecible
La pérdida indica calidad	no (juego adversarial)	sí (predecir ruido)
Diversidad	riesgo de mode collapse	alta, sin colapso
Velocidad al generar	rápida (una pasada)	más lenta (muchos pasos)
Redes involucradas	dos (compiten)	una (predice ruido)

El único punto donde la GAN gana es la velocidad de generación: una GAN produce en una sola pasada, la difusión necesita muchas. Ese es el precio a cambio de estabilidad y diversidad — y buena parte de la investigación actual va en reducir el número de pasos.

Errores comunes

Creer que la red predice la imagen limpia. Predice el ruido a restar, no la foto final. Es un detalle técnico, pero es el detalle: cambia todo el diseño del entrenamiento.
Pensar que el forward “se aprende”. El forward es una receta fija de sumar ruido; no tiene parámetros. Solo el reverse se entrena.
Confundir steps de sampling con épocas de entrenamiento. Los “steps” de una interfaz son pasos del reverse al generar una imagen, no rondas de entrenamiento.
Suponer que más steps siempre es mejor. Hay rendimientos decrecientes: pasado cierto punto, sumar pasos casi no mejora la imagen y solo cuesta tiempo.
Olvidar dónde ocurre todo. En Stable Diffusion, esta danza de ruido pasa en el latente del Módulo 7, no en los píxeles. Sin eso, no correría en tu máquina.

La frase para llevarse

“La GAN intenta pintar el cuadro de un solo trazo perfecto; la difusión aprende a limpiar la estática un poquito a la vez. Cincuenta limpiezas después, sobre un lienzo de puro ruido, aparece una imagen que nadie pintó.”

Qué viene

Arranca el bloque avanzado. Módulo 9: Stable Diffusion por dentro. Ahora que tienes las tres piezas —el VAE que comprime (M5, M7) y la difusión que genera (M8)—, las vamos a ensamblar en el sistema completo, y agregaremos la que falta: cómo un texto (“un gato astronauta”) guía el denoising para que la imagen que emerge sea la que pediste.

Generación de imágenes — Módulo 8: modelos de difusión — agregar y quitar ruido