En el Módulo 8 vimos la idea de fondo de los modelos de difusión: partir de ruido puro y quitarlo de a poco hasta que aparezca una imagen. Bonito en teoría — pero un modelo de difusión “a secas” tiene dos problemas prácticos: hacer el denoising directo sobre millones de píxeles es carísimo, y sobre todo, ¿cómo le decimos qué queremos que dibuje? Stable Diffusion es la respuesta industrial a esas dos preguntas, y la maquinaria que resuelve ambas junta casi todo lo que aprendiste en el curso: convoluciones, un autoencoder, atención y un modelo que alinea texto con imágenes. Este es el módulo que arma el rompecabezas.

La tesis del módulo

Stable Diffusion no hace difusión sobre píxeles: la hace sobre un espacio latente comprimido, guiada por texto. Tres piezas se reparten el trabajo: CLIP entiende tu prompt, la U-Net limpia ruido paso a paso escuchando ese texto, y el VAE traduce el resultado a píxeles. Entender quién hace qué es entender toda la generación moderna de imágenes.

Las tres piezas y el mapa general

Antes de meternos en cada una, el mapa mental. Stable Diffusion es un pipeline (una cadena de etapas donde la salida de una alimenta a la siguiente), no un modelo único. Hay tres redes distintas colaborando:

CLIP (Contrastive Language-Image Pretraining): un modelo entrenado para poner texto e imágenes en el mismo espacio de vectores, de modo que la frase “un gato naranja” caiga cerca de las fotos de gatos naranjas. Aquí lo usamos solo su mitad de texto: convierte tu prompt en embeddings (vectores de números que capturan el significado).
U-Net: una red convolucional con forma de U —encoder que comprime, decoder que expande, y skip connections (atajos que pasan información directa del encoder al decoder para no perder detalle). Es la que realmente hace el denoising: recibe algo con ruido y predice el ruido que hay que quitar.
VAE (el autoencoder variacional del Módulo 5): su encoder comprime la imagen a un espacio latente pequeño, y su decoder hace el camino inverso, de latente a píxeles.

La idea clave que hace todo esto barato se llama latent diffusion (difusión latente): en vez de quitar ruido sobre una imagen de 512×512×3 píxeles, se trabaja sobre un latente de 64×64×4 — unas 48 veces menos números. Toda la difusión ocurre ahí adentro, en chiquito, y solo al final se decodifica a imagen grande.

Paso a paso: de tu prompt a la imagen

Sigamos el recorrido completo de “un gato astronauta” hasta el archivo .png:

Paso 1 — el texto se vuelve números. El prompt entra al text encoder de CLIP y sale convertido en una secuencia de embeddings. Esos vectores son el “pedido” que va a condicionar todo lo demás.

Paso 2 — se parte de puro ruido. No partimos de una imagen: partimos de un tensor latente de 64×64×4 lleno de ruido gaussiano aleatorio. Ese ruido inicial depende del seed (la semilla, el número que fija el azar); mismo seed y mismo prompt → misma imagen.

Paso 3 — la U-Net limpia, muchas veces. Acá está el corazón. Se repite un bucle (típicamente 20 a 50 pasos): en cada paso la U-Net mira el latente ruidoso actual, y también los embeddings del texto, y predice qué ruido sacar. Un poquito en cada vuelta. La conexión entre el texto y la imagen se hace por cross-attention (atención cruzada): el mismo mecanismo de atención del Transformer que viste en Atención desde cero, pero en vez de que las palabras se miren entre sí, aquí las regiones de la imagen “consultan” a las palabras del prompt para decidir qué dibujar en cada zona.

Paso 4 — el VAE decodifica. Cuando el latente ya está limpio, el decoder del VAE lo expande de 64×64×4 a la imagen final de 512×512×3. Recién ahí existen los píxeles que ves.

   "un gato astronauta"
           │
           ▼
   ┌───────────────┐
   │  CLIP (texto) │  ──► embeddings de texto
   └───────────────┘             │
                                 │ condiciona
                                 ▼
   ruido        ┌────────────────────────┐
   latente ───► │   U-Net (denoising)    │
   64x64x4      │   x20-50 pasos, con    │
      ▲         │   cross-attention      │
      │         └────────────────────────┘
      │                    │
      └── bucle: repite ───┘
                           │  latente limpio
                           ▼
                  ┌─────────────────┐
                  │  VAE (decoder)  │
                  └─────────────────┘
                           │
                           ▼
                   imagen 512x512x3

Guidance: cuánto caso le hace al prompt

Si dejáramos a la U-Net sola, tendería a generar imágenes plausibles pero que ignoran a medias el prompt. Para forzarla a obedecer se usa classifier-free guidance (CFG, guía sin clasificador). El truco es sencillo y elegante: en cada paso la U-Net predice el ruido dos veces — una escuchando el prompt (condicionada) y otra sin prompt (incondicional) — y luego se exagera la diferencia entre ambas. Esa exageración empuja el resultado hacia lo que el texto pide.

Cuánto se exagera lo controla el guidance scale (escala de guía), un número que tú eliges:

Guidance scale	Efecto
~1	Casi ignora el prompt; imágenes variadas pero “sordas”
7–8	El rango dulce por defecto: fiel al prompt sin artefactos
15+	Obedece demasiado; colores quemados y detalles rígidos

Ojo: guidance scale alto no significa “mejor calidad”. Pasado cierto punto la imagen se satura, se vuelve dura y aparecen artefactos. Subirlo es pedir obediencia, no realismo.

Los componentes y su rol, en una tabla

Componente	Qué es	Su trabajo en el pipeline
CLIP (text encoder)	Modelo texto-imagen	Convierte el prompt en embeddings
U-Net	Red conv. encoder-decoder	Predice y quita el ruido paso a paso
Cross-attention	Atención del Transformer	Conecta cada zona de la imagen con las palabras
VAE (decoder)	Mitad del autoencoder	Traduce el latente limpio a píxeles
Scheduler	Algoritmo, no red	Decide cuánto ruido quitar en cada paso

Ojo: esto describe Stable Diffusion 1.x y 2.x, la arquitectura que conviene aprender primero. En los modelos más nuevos (Stable Diffusion 3, FLUX) la U-Net fue reemplazada por un Transformer de difusión (DiT), pero el resto del pipeline —text encoder, latente, VAE, guidance— sigue igual. El Módulo 10 explica por qué un Transformer puede hacer ese trabajo.

El código real, con diffusers

En la práctica no armas estas tres redes a mano: la librería diffusers de HuggingFace las carga y las orquesta por ti. Este es el mínimo funcional y correcto:

import torch
from diffusers import StableDiffusionPipeline

# Carga las tres redes (CLIP, U-Net, VAE) ya entrenadas y conectadas.
# torch_dtype=float16 usa media precisión: la mitad de VRAM, igual calidad.
pipe = StableDiffusionPipeline.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5",  # el repo original de RunwayML ya no existe
    torch_dtype=torch.float16,
)
pipe = pipe.to("cuda")   # todo esto necesita GPU

# El generador fija el seed: mismo número -> misma imagen reproducible
generador = torch.Generator("cuda").manual_seed(42)

imagen = pipe(
    prompt="un gato astronauta flotando en el espacio, foto realista",
    num_inference_steps=30,     # pasos de denoising (paso 3)
    guidance_scale=7.5,         # el rango dulce del CFG
    generator=generador,
).images[0]

imagen.save("gato_astronauta.png")

Fíjate que en tres parámetros —num_inference_steps, guidance_scale y el seed— está condensado todo lo teórico del módulo. No es casualidad: son las tres perillas que de verdad se tocan en producción.

Errores comunes

Creer que Stable Diffusion es un solo modelo. Son tres redes distintas (CLIP, U-Net, VAE) más un scheduler. Cuando algo falla, ayuda saber cuál de las piezas es.
Pensar que la difusión ocurre sobre píxeles. Ocurre sobre el latente comprimido; los píxeles solo existen tras el VAE. De ahí el nombre latent diffusion y su bajo costo.
Subir el guidance scale para “mejorar” la imagen. Lo que hace es forzar obediencia al prompt; pasado 12–15 quema la imagen. Más no es mejor.
Confundir steps con calidad infinita. Más pasos de denoising ayudan hasta ~30–50; de ahí en adelante casi no cambia nada y solo gastas tiempo y GPU.
Olvidar el seed. Sin fijarlo, cada corrida es distinta y no puedes iterar sobre un resultado que te gustó. El seed es tu control de reproducibilidad.

La frase para llevarse

“Stable Diffusion es un trío: CLIP escucha lo que pides, la U-Net esculpe quitando ruido, y el VAE revela la imagen. La difusión no pasa en los píxeles — pasa en un latente diminuto, y por eso cabe en tu GPU.”

Qué viene

Módulo 10: de CNN a Vision Transformer. La U-Net de hoy es puro convolución con un poco de atención encima. En el próximo módulo damos vuelta la tortilla: ¿y si tratáramos la imagen completa como si fuera texto, partida en parches y pasada por un Transformer? Ese es el ViT, el puente entre este curso y el de Transformers.

Generación de imágenes — Módulo 9: Stable Diffusion por dentro — U-Net, latent diffusion y CLIP