SEXTANTEcursos técnicos de IA
BancoRTX 5090 · GB202
Rev2026.06
Entrar
N3 · Breadth profunda/C

Difusión: imagen y policies (Checkpoint C3c)

Objetivo de maestría

entender la familia de modelos de difusión (su matemática propia, distinta de los LLM), entrenar un LoRA de FLUX de calidad, y entrenar una diffusion policy para control — conectando difusión con robótica. Es un dominio entero con su propio aparato matemático que un AI engineer completo debe manejar.

C.1 La idea: generar invirtiendo un proceso de ruido

Un modelo de difusión aprende a revertir un proceso que añade ruido gaussiano progresivamente a los datos:

  • Forward (fijo): toma una imagen x₀, le añade ruido en T pasos hasta x_T ≈ ruido puro.
  • Reverse (aprendido): una red aprende a quitar ruido paso a paso, de x_T a x₀. Generar = empezar de ruido y denoizar.

Evolución de la formulación (tienes que conocer la progresión):

  • DDPM (Ho et al. 2020): el modelo predice el ruido ε en cada paso; muchos pasos, lento.
  • DDIM: muestreo determinista, menos pasos.
  • Latent Diffusion / Stable Diffusion: la difusión ocurre en el espacio latente de un VAE (no en píxeles) → mucho más barato. Condicionado por texto vía cross-attention.
  • Flow matching / Rectified Flow: en vez de predecir ruido, aprende un campo de velocidad que transporta la distribución de ruido a la de datos por un camino casi recto → menos pasos, mejor calidad. FLUX y los modelos SOTA 2026 usan esto.
  • Consistency models: generación en 1–4 pasos.

Diferencia clave vs LLM: los LLM son autoregresivos (token a token, discreto); la difusión es iterativa-refinamiento (denoising paralelo, continuo). Distinta matemática, distinto hardware sweet-spot.

C.2 Track C.1 — Fine-tunear FLUX con LoRA

FLUX.1 (Black Forest Labs) es el modelo de imagen abierto de referencia. Un LoRA de FLUX te permite enseñarle un estilo, un sujeto o un concepto con pocas imágenes. FLUX.1-dev en BF16 ocupa ~24 GB → cabe en la 5090 con sitio para entrenar LoRA (presets de 12/16/20 GB con gradient checkpointing).

Laboratorio C.1 — LoRA de FLUX (genérico):

bash
1# Usaremos FluxGym/kohya (sd-scripts) — el camino estándar para LoRAs de FLUX
2git clone https://github.com/kohya-ss/sd-scripts && cd sd-scripts
3uv venv && source .venv/bin/activate
4uv pip install -r requirements.txt
5
6# Dataset: 15-30 imágenes de un concepto/estilo consistente + captions (.txt por imagen)
7# Estructura: dataset/img1.png + dataset/img1.txt ("a photo in <mi-estilo> style, ...")
8
9accelerate launch flux_train_network.py \
10  --pretrained_model_name_or_path black-forest-labs/FLUX.1-dev \
11  --dataset_config dataset.toml \
12  --output_dir ./flux_lora_out --output_name mi-estilo \
13  --network_module networks.lora_flux \
14  --network_dim 16 --network_alpha 16 \
15  --learning_rate 1e-4 --max_train_steps 1500 \
16  --gradient_checkpointing --mixed_precision bf16 \
17  --cache_latents --cache_text_encoder_outputs \
18  --sdpa

Líneas no triviales:

  • --cache_latents --cache_text_encoder_outputs: precomputa y cachea los latentes del VAE y los embeddings de texto → no recomputas el VAE/encoder en cada paso → clave para que quepa y vaya rápido en 32 GB.
  • --gradient_checkpointing: estira VRAM (N0·L3.4); imprescindible para FLUX en la 5090.
  • --network_dim 16: el rank del LoRA (mismo concepto que N2·L2). 16 va bien para estilos; sube para sujetos complejos.
  • Captions consistentes con un trigger word (<mi-estilo>): el LoRA aprende a asociar el concepto a ese token.

Inferencia y evaluación: genera con y sin el LoRA (mismo prompt+seed) y compara. Para calidad cuantitativa: CLIP score (alineación texto-imagen) y, si entrenas un sujeto, fidelidad visual. La calidad "útil" es el criterio del checkpoint.

C.3 Track C.2 — Diffusion policies para control (LeRobot)

La difusión no es solo imagen: una diffusion policy genera acciones de control denoizando — modela la distribución multimodal de acciones (clave en manipulación robótica, donde hay varias formas válidas de hacer algo). Es el puente entre difusión y RL/robótica, y conecta conceptualmente con world models (Nivel 4).

Laboratorio C.2 — entrenar ACT / Diffusion Policy con LeRobot:

bash
1# LeRobot (HuggingFace): framework de robot learning con datasets y policies listas
2uv pip install lerobot
3
4# Entrena una policy sobre un dataset público (no necesitas robot físico para entrenar)
5python -m lerobot.scripts.train \
6  --dataset.repo_id=lerobot/svla_so101_pickplace \
7  --policy.type=act \
8  --output_dir=./act_policy \
9  --batch_size=64 --steps=100000 \
10  --policy.device=cuda
11# Para diffusion policy: --policy.type=diffusion
  • ACT (Action Chunking Transformer) y Diffusion Policy son las dos policies de referencia. ACT predice "chunks" de acciones; Diffusion Policy las genera por denoising. Con 50 demos, una policy entrena en ~7–10 min en la 5090.
  • Evalúa el success-rate en el entorno de simulación del dataset. Ese número es tu checkpoint.

Líneas no triviales:

  • --dataset.repo_id: datasets en formato LeRobot (episodios de demostración con observaciones+acciones). Hay muchos públicos (SO-100/SO-101).
  • No necesitas hardware: entrenas y evalúas en sim. Si algún día tienes un brazo SO-101, la misma policy se despliega.

C.4 CHECKPOINT C3c — criterio de aprobado

  • Un LoRA de FLUX entrenado por ti, de calidad útil (el concepto/estilo se transfiere de forma reconocible), reproducible.
  • Una diffusion policy o ACT (LeRobot) que alcanza un success-rate objetivo en un dataset público, evaluada en sim.
  • Sabes explicar la diferencia entre DDPM, latent diffusion y flow matching, y por qué FLUX usa flow matching.

Rúbrica: Nivel 3 si entrenas ambos y los evalúas; Nivel 4 si publicas un LoRA con utilidad real o mejoras una policy sobre el baseline del dataset.

C.5 Ejercicios

E1. Entrena el FLUX LoRA con network_dim 8, 16 y 32. ¿Cómo cambia la fidelidad del concepto vs el overfit (el LoRA "contamina" otros prompts)?

E2. Compara ACT vs Diffusion Policy en el mismo dataset. ¿Cuál tiene mejor success-rate? ¿Cuál maneja mejor la multimodalidad de acciones?

E3. Explica por qué entrenar difusión en espacio latente (no en píxeles) fue el salto que hizo viable Stable Diffusion en consumer GPUs.

C.6 Trampas comunes

  • No cachear latentes/text-encoder → OOM o lentísimo en FLUX.
  • Captions inconsistentes o sin trigger word → el LoRA no aprende el concepto.
  • Evaluar la policy solo por la loss de entrenamiento en vez de por success-rate en sim.
  • Licencias: FLUX.1-dev tiene términos no comerciales; audítalos antes de cualquier uso comercial.

C.7 Referencias

  • HF Diffusion Course. Papers: DDPM (Ho 2020), DDIM (Song 2021), Latent Diffusion (Rombach 2022), Flow Matching (Lipman 2023), Rectified Flow (Liu 2023), Diffusion Policy (Chi 2023), ACT (Zhao 2023). Repos: kohya-ss/sd-scripts, FluxGym, huggingface/diffusers, huggingface/lerobot. HF Robotics Course.