Phase 04 - Lesson 28

Modelos de Mundo e Difusão de Vídeo

Um modelo de vídeo que prevê os próximos segundos de uma cena é um simulador de mundo. Condicione essa previsão a ações e você tem um motor de jogo aprendido.

Tipo: Aprender + Construir Linguagens: Python Pré-requisitos: Fase 4 Lição 10 (Difusão), Fase 4 Lição 12 (Compreensão de Vídeo), Fase 4 Lição 23 (DiT + Rectified Flow) Tempo: ~75 minutos

Objetivos de Aprendizagem

• Explicar a diferença entre um modelo puro de geração de vídeo (Sora 2) e um modelo de mundo condicionado a ações (Genie 3, DreamerV3)
• Descrever um DiT de vídeo: patches espaço-temporais, codificação posicional 3D, atenção conjunta entre tokens (T, H, W)
• Traçar como um modelo de mundo se encaixa na robótica: VLM planeja → modelo de vídeo simula → dinâmica inversa emite ações
• Escolher entre Sora 2, Genie 3, Runway GWM-1 Worlds, Wan-Video e HunyuanVideo para um dado caso de uso (vídeo criativo, simulação interativa, síntese para direção autônoma)

O Problema

Geração de vídeo e modelagem de mundo convergiram em 2026. Um modelo que consegue gerar um minuto coerente de vídeo aprendeu, em certo sentido, como o mundo se move: permanência de objetos, gravidade, causalidade, estilo. Se você condicionar essa previsão a ações (andar para a esquerda, abrir a porta), o modelo de vídeo se torna um simulador aprendível que pode substituir um motor de jogo, um simulador de direção ou um ambiente de robótica.

As apostas são concretas. O Genie 3 gera ambientes jogáveis a partir de uma única imagem. O Runway GWM-1 Worlds sintetiza cenas exploráveis infinitas. O Sora 2 produz vídeos de um minuto com áudio sincronizado e física modelada. NVIDIA Cosmos-Drive, Wayve Gaia-2 e Tesla DrivingWorld geram vídeo de direção realista para dados de treinamento de veículos autônomos. O paradigma de modelos de mundo está silenciosamente assumindo o sim-to-real para robótica.

Esta lição é a lição do "panorama geral" da Fase 4. Ela conecta geração de imagens, compreensão de vídeo e raciocínio agêntico no padrão de arquitetura para o qual a pesquisa dominante está se movendo.

O Conceito

Três famílias de modelagem de mundo

flowchart LR
    subgraph GEN["Geração pura de vídeo"]
        G1["Prompt de texto / imagem"] --> G2["DiT de vídeo"] --> G3["Frames de vídeo"]
    end
    subgraph ACTION["Modelo de mundo condicionado a ações"]
        A1["Frames passados + ação"] --> A2["DiT de vídeo com ação latente"] --> A3["Próximos frames"]
        A3 --> A1
    end
    subgraph RL["Modelos de mundo para RL (DreamerV3)"]
        R1["Estado + ação"] --> R2["Modelo de transição 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 é geração pura de vídeo condicionada a prompts. Sem interface de ação. Você não pode "guiá-lo" no meio do rollout.
• Genie 3, GWM-1 Worlds, Mirage / Magica são modelos de mundo condicionados a ações. Inferem ações latentes a partir de vídeo observado e, então, condicionam as previsões de frames futuros às ações. Interativos — você pressiona teclas ou move uma câmera e a cena responde.
• DreamerV3 e a família clássica de modelos de mundo para RL preveem em um espaço latente com condicionamento explícito a ações, treinados em um sinal de recompensa. Menos visuais; mais úteis para RL com eficiência amostral.

Arquitetura do DiT de vídeo

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

A codificação posicional é 3D: um embedding rotativo ou aprendido por coordenada (t, h, w). A atenção pode ser:

• Conjunta completa — todos os tokens atendem a todos os tokens. O(N^2) com N tokens. Proibitiva para vídeos longos.
• Dividida — alterna atenção temporal (mesma posição espacial, ao longo do tempo: (H*W) * T^2) e atenção espacial (mesmo timestep, ao longo do espaço: T * (H*W)^2). Usada pelo TimeSformer e pela maioria dos DiTs de vídeo.
• Janela — janelas locais em (t, h, w). Usada pelo Video Swin.

Todo modelo de difusão de vídeo de 2026 usa um desses três padrões mais o condicionamento AdaLN (Lição 23) e rectified flow.

Condicionamento a ações: modelos de ação latente

O Genie aprende uma ação latente por frame ao prever discriminativamente a ação entre um par de frames consecutivos. O decodificador do modelo então se condiciona à ação latente inferida — não a teclas explícitas do teclado. Na inferência, um usuário pode especificar uma ação latente (ou amostrar uma de um prior novo) e o modelo gera o próximo frame consistente com aquela ação.

O Sora pula completamente a interface de ação. Seu decodificador prevê os próximos tokens espaço-temporais a partir dos tokens espaço-temporais passados. O prompt condiciona o início; nada o guia no meio da geração.

Plausibilidade física

O lançamento do Sora 2 em 2026 anunciou explicitamente a plausibilidade física: peso, equilíbrio, permanência de objetos, causa e efeito. Medida pela equipe por meio de pontuações de plausibilidade avaliadas manualmente; o modelo melhora visivelmente em objetos sendo derrubados, personagens colidindo e falhas propositais (um pulo malsucedido) em relação ao Sora 1.

A plausibilidade continua sendo o modo de falha dominante. Vídeos de 2024-2025 de pessoas comendo espaguete ou bebendo de copos revelaram a falta de representação persistente de objetos do modelo. Os modelos de 2026 (Sora 2, Runway Gen-5, HunyuanVideo) reduzem, mas não eliminam, esses problemas.

Modelos de mundo para direção autônoma

Os modelos de mundo de direção geram cenas de rua realistas condicionadas a trajetórias, caixas delimitadoras ou mapas de navegação. Uso:

• Cosmos-Drive-Dreams (NVIDIA) — gera minutos de vídeo de direção para treinamento de RL.
• Gaia-2 (Wayve) — síntese de cenas condicionada a trajetórias para avaliação de políticas.
• DrivingWorld (Tesla) — simula clima variado, hora do dia e condições de tráfego.
• Vista (ByteDance) — síntese reativa de cenas de direção.

Eles substituem a cara coleta de dados do mundo real para casos extremos — pedestres atravessando fora da faixa à noite, cruzamentos com gelo, tipos incomuns de veículos — que de outra forma exigiriam milhões de quilômetros dirigidos.

Pilha de robótica: VLM + modelo de vídeo + dinâmica inversa

O ciclo de robótica emergente de três componentes:

1. VLM analisa o objetivo ("pegue a xícara vermelha"), planeja uma sequência de ações de alto nível.
2. Modelo de geração de vídeo simula como seria executar cada ação — prevê observações N frames à frente.
3. Modelo de dinâmica inversa extrai os comandos motores concretos que produziriam essas observações.

Isso substitui o reward shaping e o RL intensivo em amostras. O modelo de mundo faz a imaginação; a dinâmica inversa fecha o ciclo na atuação. O Genie Envisioner é uma instanciação; muitos grupos de pesquisa estão convergindo para essa estrutura.

Avaliação

• Qualidade visual — FVD (Fréchet Video Distance), estudos com usuários.
• Alinhamento ao prompt — CLIPScore por frame, avaliação no estilo VQA.
• Plausibilidade física — avaliada manualmente em um conjunto de benchmark (o benchmark interno do Sora 2, VBench).
• Controlabilidade (para modelos de mundo interativos) — consistência ação → observação; é possível voltar a um estado anterior?

Panorama de modelos em 2026

Construa

Passo 1: Patchify 3D para vídeo

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)

Uma convolução 3D com stride igual ao kernel atua como o patchificador espaço-temporal. Grid de tokens (T, H, W) -> (T/2, H/2, W/2).

Passo 2: Codificação posicional rotativa 3D

Rotary Position Embeddings (RoPE) aplicados separadamente ao longo dos eixos 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. O RoPE real rotaciona canais pareados em frequências; a informação posicional é a mesma.

Passo 3: Bloco de atenção 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

A atenção temporal atende dentro de cada posição espacial ao longo do tempo; a atenção espacial atende dentro de cada frame ao longo das posições. Duas operações O(T^2 + (HW)^2) em vez de uma O((THW)^2). Este é o núcleo do TimeSformer e de todo DiT de vídeo moderno.

Passo 4: Componha um DiT de vídeo minúsculo

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

Não é um gerador de vídeo funcional; uma demonstração estrutural em que cada peça molda corretamente.

Passo 5: Verifique as 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)}")

Espere grid = (4, 8, 8) e out = (1, 256, 32) após o patching; a cabeça então projeta para patches espaço-temporais por token, prontos para serem des-patchificados de volta em um vídeo.

Use

Padrões de acesso em produção para 2026:

• API do Sora 2 (OpenAI) — texto-para-vídeo, áudio sincronizado. Preço premium.
• Runway Gen-5 / GWM-1 (Runway) — imagem-para-vídeo, mundos interativos.
• Wan-Video 2.1 / HunyuanVideo — código aberto, auto-hospedado.
• Cosmos / Cosmos-Drive (NVIDIA) — pesos abertos para simulação de direção.
• Genie 3 — preview de pesquisa, solicite acesso.

Para construir uma demonstração de modelo de mundo interativo: comece com o Wan-Video pela qualidade, adicione um adaptador de ação latente para interatividade. Para simulação de direção autônoma: o Cosmos-Drive é a referência aberta de 2026.

Para robótica, a pilha na prática:

1. Objetivo em linguagem -> VLM (Qwen3-VL) -> plano de alto nível.
2. Plano -> modelo de vídeo com ação latente -> rollout imaginado.
3. Rollout -> modelo de dinâmica inversa -> ações de baixo nível.
4. Ações executadas -> observação realimentada no passo 1.

Entregue

Esta lição produz:

• outputs/prompt-video-model-picker.md — escolhe entre Sora 2 / Runway / Wan / HunyuanVideo / Cosmos dada a tarefa, os termos de uso e a latência.
• outputs/skill-physical-plausibility-checks.md — uma skill que define verificações automatizadas (permanência de objetos, gravidade, continuidade) para rodar em qualquer vídeo gerado antes de entregar.

Exercícios

1. (Fácil) Calcule a contagem de tokens para um vídeo de 5 segundos em 360p com patch-t=2, patch-h=8, patch-w=8. Raciocine sobre a memória para atenção nesse tamanho.
2. (Médio) Troque o bloco de atenção dividida acima por um bloco de atenção conjunta completa e meça a shape e a contagem de parâmetros. Explique por que a atenção dividida é necessária para modelos de vídeo reais.
3. (Difícil) Construa um modelo mínimo de vídeo com ação latente: pegue um conjunto de dados de triplas (frame_t, action_t, frame_{t+1}) (qualquer jogo 2D simples), treine um DiT de vídeo minúsculo condicionado a embeddings de ação e mostre que ações diferentes produzem frames seguintes diferentes.

Termos-Chave

Leitura Adicional

• Sora technical report (OpenAI)
• Genie: Generative Interactive Environments (Bruce et al., 2024) — modelos de mundo com ação latente
• TimeSformer (Bertasius et al., 2021) — atenção dividida para transformers de vídeo
• DreamerV3 (Hafner et al., 2023) — modelos de mundo para RL
• Cosmos-Drive-Dreams (NVIDIA, 2025) — modelo de mundo de direção
• Top 10 Video Generation Models 2026 (DataCamp)
• From Video Generation to World Model — survey repo