Phase 04 - Lesson 28

Modelos del Mundo y Difusión de Video

Un modelo de video que predice los próximos segundos de una escena es un simulador del mundo. Condiciona esa predicción a acciones y tendrás un motor de juego aprendido.

Tipo: Aprender + Construir Lenguajes: Python Requisitos previos: Fase 4 Lección 10 (Difusión), Fase 4 Lección 12 (Comprensión de Video), Fase 4 Lección 23 (DiT + Rectified Flow) Tiempo: ~75 minutos

Objetivos de Aprendizaje

• Explicar la diferencia entre un modelo puro de generación de video (Sora 2) y un modelo del mundo condicionado a acciones (Genie 3, DreamerV3)
• Describir un DiT de video: parches espacio-temporales, codificación posicional 3D, atención conjunta entre tokens (T, H, W)
• Trazar cómo un modelo del mundo se integra en la robótica: el VLM planifica → el modelo de video simula → la dinámica inversa emite acciones
• Elegir entre Sora 2, Genie 3, Runway GWM-1 Worlds, Wan-Video y HunyuanVideo para un caso de uso dado (video creativo, simulación interactiva, síntesis para conducción autónoma)

El Problema

La generación de video y el modelado del mundo convergieron en 2026. Un modelo capaz de generar un minuto coherente de video ha aprendido, en cierto sentido, cómo se mueve el mundo: permanencia de objetos, gravedad, causalidad, estilo. Si condicionas esa predicción a acciones (caminar a la izquierda, abrir la puerta), el modelo de video se convierte en un simulador aprendible que puede reemplazar un motor de juego, un simulador de conducción o un entorno de robótica.

Lo que está en juego es concreto. Genie 3 genera entornos jugables a partir de una sola imagen. Runway GWM-1 Worlds sintetiza escenas explorables infinitas. Sora 2 produce videos de un minuto con audio sincronizado y física modelada. NVIDIA Cosmos-Drive, Wayve Gaia-2 y Tesla DrivingWorld generan video de conducción realista como datos de entrenamiento para vehículos autónomos. El paradigma de los modelos del mundo está tomando silenciosamente el control del sim-to-real en robótica.

Esta lección es la lección del "panorama general" de la Fase 4. Conecta la generación de imágenes, la comprensión de video y el razonamiento agéntico en el patrón de arquitectura hacia el cual avanza la investigación dominante.

El Concepto

Tres familias de modelado del mundo

flowchart LR
    subgraph GEN["Generación pura de video"]
        G1["Prompt de texto / imagen"] --> G2["DiT de video"] --> G3["Fotogramas de video"]
    end
    subgraph ACTION["Modelo del mundo condicionado a acciones"]
        A1["Fotogramas pasados + acción"] --> A2["DiT de video con acción latente"] --> A3["Próximos fotogramas"]
        A3 --> A1
    end
    subgraph RL["Modelos del mundo para RL (DreamerV3)"]
        R1["Estado + acción"] --> R2["Modelo de transición latente"] --> R3["Próximo latente + recompensa"]
        R3 --> R1
    end

    style GEN fill:#dbeafe,stroke:#2563eb
    style ACTION fill:#fef3c7,stroke:#d97706
    style RL fill:#dcfce7,stroke:#16a34a

• Sora 2 es generación pura de video condicionada a prompts. Sin interfaz de acción. No puedes "dirigirlo" a mitad del rollout.
• Genie 3, GWM-1 Worlds, Mirage / Magica son modelos del mundo condicionados a acciones. Infieren acciones latentes a partir del video observado y luego condicionan las predicciones de fotogramas futuros a las acciones. Interactivos: presionas teclas o mueves una cámara y la escena responde.
• DreamerV3 y la familia clásica de modelos del mundo para RL predicen en un espacio latente con condicionamiento explícito a acciones, entrenados con una señal de recompensa. Menos visuales; más útiles para RL con eficiencia de muestras.

Arquitectura del DiT de video

Video latent:          (C, T, H, W)
Patchify (spatial):    grid of P_h x P_w patches per frame
Patchify (temporal):   group P_t frames into a temporal patch
Resulting tokens:      (T / P_t) * (H / P_h) * (W / P_w) tokens

La codificación posicional es 3D: un embedding rotatorio o aprendido por coordenada (t, h, w). La atención puede ser:

• Conjunta completa: todos los tokens atienden a todos los tokens. O(N^2) con N tokens. Prohibitiva para videos largos.
• Dividida: alterna atención temporal (misma posición espacial, a lo largo del tiempo: (H*W) * T^2) y atención espacial (mismo timestep, a lo largo del espacio: T * (H*W)^2). Usada por TimeSformer y la mayoría de los DiT de video.
• Ventana: ventanas locales en (t, h, w). Usada por Video Swin.

Todo modelo de difusión de video de 2026 usa uno de estos tres patrones más el condicionamiento AdaLN (Lección 23) y rectified flow.

Condicionamiento a acciones: modelos de acción latente

Genie aprende una acción latente por fotograma al predecir discriminativamente la acción entre un par de fotogramas consecutivos. El decodificador del modelo se condiciona entonces a la acción latente inferida, no a teclas explícitas del teclado. En la inferencia, un usuario puede especificar una acción latente (o muestrear una de un prior nuevo) y el modelo genera el siguiente fotograma consistente con esa acción.

Sora omite por completo la interfaz de acción. Su decodificador predice los próximos tokens espacio-temporales a partir de los tokens espacio-temporales pasados. El prompt condiciona el inicio; nada lo dirige a mitad de la generación.

Plausibilidad física

El lanzamiento de Sora 2 en 2026 anunció explícitamente la plausibilidad física: peso, equilibrio, permanencia de objetos, causa y efecto. Medida por el equipo mediante puntuaciones de plausibilidad evaluadas a mano; el modelo mejora visiblemente en objetos que se caen, personajes que colisionan y fallos a propósito (un salto fallido) respecto a Sora 1.

La plausibilidad sigue siendo el modo de fallo dominante. Los videos de 2024-2025 de personas comiendo espagueti o bebiendo de vasos revelaron la falta de representación persistente de objetos del modelo. Los modelos de 2026 (Sora 2, Runway Gen-5, HunyuanVideo) reducen, pero no eliminan, estos problemas.

Modelos del mundo para conducción autónoma

Los modelos del mundo para conducción generan escenas de carretera realistas condicionadas a trayectorias, cajas delimitadoras o mapas de navegación. Uso:

• Cosmos-Drive-Dreams (NVIDIA): genera minutos de video de conducción para entrenamiento de RL.
• Gaia-2 (Wayve): síntesis de escenas condicionada a trayectorias para evaluación de políticas.
• DrivingWorld (Tesla): simula clima variado, hora del día y condiciones de tráfico.
• Vista (ByteDance): síntesis reactiva de escenas de conducción.

Reemplazan la costosa recopilación de datos del mundo real para casos límite raros (peatones que cruzan fuera de la senda de noche, intersecciones con hielo, tipos inusuales de vehículos) que de otro modo requerirían millones de kilómetros de conducción.

Stack de robótica: VLM + modelo de video + dinámica inversa

El ciclo emergente de robótica de tres componentes:

1. El VLM analiza el objetivo ("toma la taza roja"), planifica una secuencia de acciones de alto nivel.
2. El modelo de generación de video simula cómo se vería ejecutar cada acción: predice observaciones N fotogramas por delante.
3. El modelo de dinámica inversa extrae los comandos motores concretos que producirían esas observaciones.

Esto reemplaza el reward shaping y el RL intensivo en muestras. El modelo del mundo hace la imaginación; la dinámica inversa cierra el ciclo en la actuación. Genie Envisioner es una instanciación; muchos grupos de investigación están convergiendo hacia esta estructura.

Evaluación

• Calidad visual: FVD (Fréchet Video Distance), estudios con usuarios.
• Alineación con el prompt: CLIPScore por fotograma, evaluación al estilo VQA.
• Plausibilidad física: evaluada a mano en un conjunto de benchmark (el benchmark interno de Sora 2, VBench).
• Controlabilidad (para modelos del mundo interactivos): consistencia acción → observación; ¿puedes volver a un estado anterior?

Panorama de modelos en 2026

Constrúyelo

Paso 1: Patchify 3D para video

import torch
import torch.nn as nn


class VideoPatch3D(nn.Module):
    def __init__(self, in_channels=4, dim=64, patch_t=2, patch_h=2, patch_w=2):
        super().__init__()
        self.proj = nn.Conv3d(
            in_channels, dim,
            kernel_size=(patch_t, patch_h, patch_w),
            stride=(patch_t, patch_h, patch_w),
        )
        self.patch_t = patch_t
        self.patch_h = patch_h
        self.patch_w = patch_w

    def forward(self, x):
        # x: (N, C, T, H, W)
        x = self.proj(x)
        n, c, t, h, w = x.shape
        tokens = x.reshape(n, c, t * h * w).transpose(1, 2)
        return tokens, (t, h, w)

Una convolución 3D con stride igual al kernel actúa como el patchificador espacio-temporal. Grid de tokens (T, H, W) -> (T/2, H/2, W/2).

Paso 2: Codificación posicional rotatoria 3D

Rotary Position Embeddings (RoPE) aplicados por separado a lo largo de los ejes t, h, w:

def rope_3d(tokens, t_dim, h_dim, w_dim, grid):
    """
    tokens: (N, T*H*W, D)
    grid: (T, H, W) sizes
    t_dim + h_dim + w_dim == D
    """
    T, H, W = grid
    n, seq, d = tokens.shape
    if t_dim + h_dim + w_dim != d:
        raise ValueError(f"t_dim+h_dim+w_dim ({t_dim}+{h_dim}+{w_dim}) must equal D={d}")
    assert seq == T * H * W
    t_idx = torch.arange(T, device=tokens.device).repeat_interleave(H * W)
    h_idx = torch.arange(H, device=tokens.device).repeat_interleave(W).repeat(T)
    w_idx = torch.arange(W, device=tokens.device).repeat(T * H)
    # Simplified: just scale channels by frequencies. Real RoPE rotates pairs.
    freqs_t = torch.exp(-torch.log(torch.tensor(10000.0)) * torch.arange(t_dim // 2, device=tokens.device) / (t_dim // 2))
    freqs_h = torch.exp(-torch.log(torch.tensor(10000.0)) * torch.arange(h_dim // 2, device=tokens.device) / (h_dim // 2))
    freqs_w = torch.exp(-torch.log(torch.tensor(10000.0)) * torch.arange(w_dim // 2, device=tokens.device) / (w_dim // 2))
    emb_t = torch.cat([torch.sin(t_idx[:, None] * freqs_t), torch.cos(t_idx[:, None] * freqs_t)], dim=-1)
    emb_h = torch.cat([torch.sin(h_idx[:, None] * freqs_h), torch.cos(h_idx[:, None] * freqs_h)], dim=-1)
    emb_w = torch.cat([torch.sin(w_idx[:, None] * freqs_w), torch.cos(w_idx[:, None] * freqs_w)], dim=-1)
    return tokens + torch.cat([emb_t, emb_h, emb_w], dim=-1)

Forma aditiva simplificada. El RoPE real rota canales emparejados a distintas frecuencias; la información posicional es la misma.

Paso 3: Bloque de atención dividida

class DividedAttentionBlock(nn.Module):
    def __init__(self, dim=64, heads=2):
        super().__init__()
        self.time_attn = nn.MultiheadAttention(dim, heads, batch_first=True)
        self.space_attn = nn.MultiheadAttention(dim, heads, batch_first=True)
        self.ln1 = nn.LayerNorm(dim)
        self.ln2 = nn.LayerNorm(dim)
        self.ln3 = nn.LayerNorm(dim)
        self.mlp = nn.Sequential(nn.Linear(dim, 4 * dim), nn.GELU(), nn.Linear(4 * dim, dim))

    def forward(self, x, grid):
        T, H, W = grid
        n, seq, d = x.shape
        # time attention: same (h, w), across t
        xt = x.view(n, T, H * W, d).permute(0, 2, 1, 3).reshape(n * H * W, T, d)
        a, _ = self.time_attn(self.ln1(xt), self.ln1(xt), self.ln1(xt), need_weights=False)
        xt = (xt + a).reshape(n, H * W, T, d).permute(0, 2, 1, 3).reshape(n, seq, d)
        # space attention: same t, across (h, w)
        xs = xt.view(n, T, H * W, d).reshape(n * T, H * W, d)
        a, _ = self.space_attn(self.ln2(xs), self.ln2(xs), self.ln2(xs), need_weights=False)
        xs = (xs + a).reshape(n, T, H * W, d).reshape(n, seq, d)
        xs = xs + self.mlp(self.ln3(xs))
        return xs

La atención temporal atiende dentro de cada posición espacial a lo largo del tiempo; la atención espacial atiende dentro de cada fotograma a lo largo de las posiciones. Dos operaciones O(T^2 + (HW)^2) en lugar de una O((THW)^2). Este es el núcleo de TimeSformer y de todo DiT de video moderno.

Paso 4: Compón un DiT de video diminuto

class TinyVideoDiT(nn.Module):
    def __init__(self, in_channels=4, dim=64, depth=2, heads=2):
        super().__init__()
        self.patch = VideoPatch3D(in_channels=in_channels, dim=dim, patch_t=2, patch_h=2, patch_w=2)
        self.blocks = nn.ModuleList([DividedAttentionBlock(dim, heads) for _ in range(depth)])
        self.out = nn.Linear(dim, in_channels * 2 * 2 * 2)

    def forward(self, x):
        tokens, grid = self.patch(x)
        for blk in self.blocks:
            tokens = blk(tokens, grid)
        return self.out(tokens), grid

No es un generador de video funcional; es una demostración estructural en la que cada pieza da la forma correcta.

Paso 5: Verifica las shapes

vid = torch.randn(1, 4, 8, 16, 16)  # (N, C, T, H, W)
model = TinyVideoDiT()
out, grid = model(vid)
print(f"input  {tuple(vid.shape)}")
print(f"tokens grid {grid}")
print(f"output {tuple(out.shape)}")

Espera grid = (4, 8, 8) y out = (1, 256, 32) tras el patching; la cabeza luego proyecta a parches espacio-temporales por token, listos para des-patchificarse de vuelta en un video.

Úsalo

Patrones de acceso en producción para 2026:

• API de Sora 2 (OpenAI): texto-a-video, audio sincronizado. Precio premium.
• Runway Gen-5 / GWM-1 (Runway): imagen-a-video, mundos interactivos.
• Wan-Video 2.1 / HunyuanVideo: código abierto, autoalojado.
• Cosmos / Cosmos-Drive (NVIDIA): pesos abiertos para simulación de conducción.
• Genie 3: vista previa de investigación, solicita acceso.

Para construir una demo de modelo del mundo interactivo: empieza con Wan-Video por la calidad y añade encima un adaptador de acción latente para la interactividad. Para simulación de conducción autónoma: Cosmos-Drive es la referencia abierta de 2026.

Para robótica, el stack en la práctica:

1. Objetivo en lenguaje -> VLM (Qwen3-VL) -> plan de alto nivel.
2. Plan -> modelo de video con acción latente -> rollout imaginado.
3. Rollout -> modelo de dinámica inversa -> acciones de bajo nivel.
4. Acciones ejecutadas -> observación realimentada al paso 1.

Entrégalo

Esta lección produce:

• outputs/prompt-video-model-picker.md: elige entre Sora 2 / Runway / Wan / HunyuanVideo / Cosmos según la tarea, los términos de uso y la latencia.
• outputs/skill-physical-plausibility-checks.md: una skill que define comprobaciones automatizadas (permanencia de objetos, gravedad, continuidad) para ejecutar en cualquier video generado antes de entregarlo.

Ejercicios

1. (Fácil) Calcula el número de tokens para un video de 5 segundos en 360p con patch-t=2, patch-h=8, patch-w=8. Razona sobre la memoria para la atención a ese tamaño.
2. (Medio) Reemplaza el bloque de atención dividida de arriba por un bloque de atención conjunta completa y mide la shape y el número de parámetros. Explica por qué la atención dividida es necesaria para modelos de video reales.
3. (Difícil) Construye un modelo mínimo de video con acción latente: toma un conjunto de datos de tripletas (frame_t, action_t, frame_{t+1}) (cualquier juego 2D simple), entrena un DiT de video diminuto condicionado a embeddings de acción y muestra que distintas acciones producen distintos fotogramas siguientes.

Términos Clave

Lecturas Adicionales

• Sora technical report (OpenAI)
• Genie: Generative Interactive Environments (Bruce et al., 2024) — modelos del mundo con acción latente
• TimeSformer (Bertasius et al., 2021) — atención dividida para transformers de video
• DreamerV3 (Hafner et al., 2023) — modelos del mundo para RL
• Cosmos-Drive-Dreams (NVIDIA, 2025) — modelo del mundo de conducción
• Top 10 Video Generation Models 2026 (DataCamp)
• From Video Generation to World Model — survey repo