En el Módulo 6 vimos que la difusión terminó ganándole a las GANs por estabilidad y diversidad. Antes de abrir esa caja (Módulo 8), hay que resolver un problema práctico que casi hunde la idea: la difusión, tal como se inventó, trabajaba directo sobre los píxeles — y eso es tan caro que solo grandes laboratorios con cientos de GPUs podían permitírselo. Este módulo es corto y conceptual, pero es la bisagra de todo el curso: explica el truco que llevó la generación de imágenes desde un datacenter hasta tu propia tarjeta gráfica.

La tesis del módulo

No generes donde es caro; genera donde es barato. Una imagen tiene cientos de miles de píxeles, casi todos redundantes. El latent diffusion comprime primero con un VAE, hace todo el trabajo pesado en un espacio 48 veces más chico, y recién al final decodifica a píxeles. Esa sola idea es lo que puso Stable Diffusion en tu computador.

El problema: los píxeles son enormes

Cuenta los números de una imagen a color modesta de 512×512:

   512 (ancho) × 512 (alto) × 3 (RGB) = 786.432 números

Casi 800 mil números para una sola imagen chica. El pixel-space (el espacio de píxeles — la imagen representada como todos sus valores de color crudos) es un lugar gigantesco. Y la difusión, como verás en el Módulo 8, no procesa la imagen una vez: la pasa por la red decenas de veces (un paso por cada nivel de ruido que quita). Multiplica 800 mil números por 50 pasadas por cada imagen del batch y entiendes por qué la difusión en pixel-space consumía presupuestos de laboratorio.

El desperdicio está en que la mayoría de esos píxeles son redundantes. Un cielo azul son miles de píxeles casi idénticos. La información real de la imagen —qué hay, dónde, con qué forma— cabe en muchísimos menos números. Justo lo que el encoder de un VAE sabe hacer.

La solución: latent diffusion

El latent diffusion (difusión latente — hacer la difusión en el espacio latente en vez de en los píxeles) reutiliza exactamente la pieza que guardamos en el Módulo 5: el VAE. La receta es de tres actos:

Comprimir (una vez): el encoder del VAE toma la imagen de 512×512×3 y la reduce a un latente chico, típicamente 64×64×4. La imagen “esencial”, sin la redundancia de los píxeles.
Generar (lo pesado): toda la difusión —las decenas de pasadas de quitar ruido— ocurre dentro de ese latente chico. Acá vive casi todo el cómputo, y ahora es barato.
Decodificar (una vez): el decoder del VAE toma el latente ya generado y lo expande a la imagen final de 512×512×3.

   pixel-space (grande, caro)
  ┌──────────────────────┐
  │   512 × 512 × 3      │
  │   ≈ 786.432 números  │
  └──────────┬───────────┘
             │ encoder VAE (comprime)
             ▼
   latent-space (chico, barato)
  ┌──────────────────────┐
  │   64 × 64 × 4        │   ◄── acá ocurre
  │   ≈ 16.384 números   │      TODA la difusión
  └──────────┬───────────┘
             │ decoder VAE (expande)
             ▼
  ┌──────────────────────┐
  │   imagen final       │
  │   512 × 512 × 3      │
  └──────────────────────┘

Fíjate en los dos VAE a los lados: el encoder a la entrada, el decoder a la salida. En el medio, donde se hace el trabajo caro, todo es pequeño.

Cuánto se ahorra

El latente de 64×64×4 tiene 16.384 números frente a los 786.432 del pixel-space. La diferencia no es cosmética:

	Pixel-space	Latent-space	Ahorro
Dimensiones	512×512×3	64×64×4	—
Números por imagen	786.432	16.384	~48× menos
Lado espacial	512×512	64×64	8× más chico por lado
Costo de cada paso	altísimo	manejable	~48× menos
Corre en	datacenter	tu GPU consumer	de la nube a tu escritorio

Reducir cada lado a la octava parte achica el área a 1/64; con los canales el factor neto ronda 48×. Como la difusión repite ese costo decenas de veces por imagen, el ahorro se multiplica y convierte lo imposible-en-casa en algo que corre en una RTX cualquiera.

Ojo: el VAE acá NO se usa para generar (como en el Módulo 5), sino solo como traductor entre píxeles y latente. Va congelado: se entrenó una vez y no se toca. El que genera es el modelo de difusión que vive dentro del latente. Son dos piezas distintas cumpliendo dos roles distintos.

Errores comunes

Creer que el latente es “una miniatura” de la imagen. No es una versión chica en píxeles; es una representación aprendida donde cada número codifica información abstracta. Si intentas mirarlo como imagen, ves ruido de colores raros.
Pensar que comprimir arruina la calidad. El VAE de un buen latent diffusion reconstruye con fidelidad altísima: la pérdida de comprimir/descomprimir es casi imperceptible frente al ahorro brutal de cómputo.
Confundir el VAE traductor con el generador. En latent diffusion el VAE no inventa nada; solo traduce. Toda la creatividad vive en el modelo de difusión del centro.
Olvidar que el ahorro se multiplica. No es un 48× de una vez: es 48× por cada uno de los muchos pasos de difusión. Ahí está la diferencia entre correr o no correr en casa.

La frase para llevarse

“Los píxeles son caros y redundantes; el latente es chico y esencial. La jugada maestra de Stable Diffusion fue simple: comprime primero, genera en pequeño, y expande solo al final.”

Qué viene

Módulo 8: modelos de difusión — agregar y quitar ruido. Ya sabes dónde generar (el latente); ahora toca cómo. Entramos en el corazón del curso: el proceso que agrega ruido a una imagen hasta borrarla, y la red que aprende a deshacer ese ruido paso a paso hasta hacer aparecer una imagen desde la nada.

Generación de imágenes — Módulo 7: del pixel-space al latent-space — por qué generar en pequeño