Modele ale lumii și difuzia video

Un model video care prezice următoarele secunde ale unei scene este un simulator al lumii. Condiționați acea predicție de acțiuni și obțineți un motor de joc învățat.

Tip: Învățați + construiți Limbaje: Python Cerințe prealabile: Faza 4 Lecția 10 (Difuzie), Faza 4 Lecția 12 (Înțelegerea videoclipurilor), Faza 4 Lecția 23 (DiT + flux rectificat) Timp: ~75 de minute

Obiective de învățare

• Explicați diferența dintre un model pur de generare video (Sora 2) și un model al lumii condiționat de acțiuni (Genie 3, DreamerV3)
• Descrieți un DiT video: patch-uri spațio-temporale, codificare de poziție 3D, atenție comună asupra tokenurilor (T, H, W)
• Urmăriți cum se integrează un model al lumii în robotică: un VLM planifică → modelul video simulează → dinamica inversă produce acțiuni
• Alegeți între Sora 2, Genie 3, Runway GWM-1 Worlds, Wan-Video și HunyuanVideo pentru un anumit caz de utilizare (video creativ, simulare interactivă, sinteză pentru conducere autonomă)

Problema

Generarea video și modelarea lumii au convergit în 2026. Un model care poate genera un minut coerent de videoclip a învățat, într-un anumit sens, cum se mișcă lumea: permanența obiectelor, gravitația, cauzalitatea, stilul. Dacă acea predicție este condiționată de acțiuni (mergeți la stânga, deschideți ușa), modelul video devine un simulator care poate fi învățat și care poate înlocui un motor de joc, un simulator de conducere sau un mediu de robotică.

Notă tehnică a traducerii: Coerența vizuală nu demonstrează că un model a învățat un simulator fizic fidel și nu este suficientă, de una singură, pentru a înlocui un motor de joc sau un simulator de siguranță. Modelele generative pot părea plauzibile, dar pot încălca constrângeri fizice, pot deriva pe secvențe lungi și necesită evaluare specifică sarcinii înainte de folosirea pentru antrenare sau control.

Miza este concretă. Genie 3 generează medii jucabile dintr-o singură imagine. Runway GWM-1 Worlds sintetizează scene explorabile infinite. Sora 2 produce videoclipuri de un minut cu audio sincronizat și fizică modelată. NVIDIA Cosmos-Drive, Wayve Gaia-2 și Tesla DrivingWorld generează videoclipuri de conducere realiste pentru date de antrenare a vehiculelor autonome. Paradigma modelelor lumii preia discret sim-to-real pentru robotică.

Notă tehnică a traducerii: Capacitățile, accesul și durata depind de produs și de versiune. Documentația oficială Genie 3 descrie lumi interactive din descrieri text, la 720p și 20–24 fps, cu interacțiune continuă de numai câteva minute și limitări declarate. OpenAI a lansat Sora 2 în septembrie 2025, dar pagina oficială precizează că produsul Sora nu mai este disponibil din 26 aprilie 2026; verificați separat disponibilitatea API-ului și prețul. Prin urmare, nu tratați afirmațiile despre o durată de un minut, 1080p sau orice produs din listă ca proprietăți universale ori permanente.

Această lecție este lecția de „imagine de ansamblu” pentru Faza 4. Ea conectează generarea de imagini, înțelegerea videoclipurilor și raționamentul agentic în tiparul de arhitectură spre care se îndreaptă cercetarea dominantă.

Conceptul

Trei familii de modelare a lumii

• Sora 2 este generare video pură condiționată de prompturi. Nu are interfață de acțiuni. Nu îl puteți „dirija” în timpul unei derulări.
• Genie 3, GWM-1 Worlds, Mirage / Magica sunt modele ale lumii condiționate de acțiuni. Ele deduc acțiuni latente din videoclipul observat, apoi condiționează predicțiile cadrelor viitoare de acțiuni. Interactive — apăsați taste sau mișcați camera, iar scena răspunde.
• DreamerV3 și familia clasică de modele ale lumii pentru RL prezic într-un spațiu latent cu condiționare explicită de acțiuni, antrenate pe un semnal de recompensă. Sunt mai puțin vizuale, dar mai utile pentru RL eficient din punctul de vedere al eșantioanelor.

Notă tehnică a traducerii: Acestea sunt familii conceptuale, nu interfețe interschimbabile. Documentația publică Genie 3 descrie control în timp real prin intrări de navigare și evenimente de lume bazate pe prompt, iar GWM-1 declară condiționare pentru poziția camerei, comenzi robotice și audio. Nu rezultă că toate modelele enumerate folosesc aceeași reprezentare de „acțiune latentă”, aceeași buclă de control sau aceeași interfață programatică.

Arhitectura unui DiT video

Latent video:          (C, T, H, W)
Împărțire în patch-uri (spațial):    grilă de patch-uri P_h x P_w per cadru
Împărțire în patch-uri (temporal):   grupează P_t cadre într-un patch temporal
Tokenuri rezultate:      (T / P_t) * (H / P_h) * (W / P_w) tokenuri

Codificarea pozițională este 3D: o reprezentare vectorială rotativă sau învățată pentru fiecare coordonată (t, h, w). Atenția poate fi:

• Comună completă — toate tokenurile acordă atenție tuturor tokenurilor. O(N^2) pentru N tokenuri. Prohibitivă pentru videoclipuri lungi.
• Împărțită — alternează atenția temporală (aceeași poziție spațială, de-a lungul timpului: (H*W) * T^2) și atenția spațială (același pas de timp, de-a lungul spațiului: T * (H*W)^2). Folosită de TimeSformer și de majoritatea DiT-urilor video.
• Pe ferestre — ferestre locale în (t, h, w). Folosită de Video Swin.

Fiecare model de difuzie video din 2026 folosește unul dintre aceste trei tipare, plus condiționare AdaLN (Lecția 23) și flux rectificat.

Notă tehnică a traducerii: Lista de mecanisme de atenție este un rezumat util, nu o clasificare exhaustivă sau o regulă pentru fiecare model video. Complexitatea atenției împărțite include numărul de poziții: O(HW · T^2 + T · (HW)^2) pe strat, nu doar O(T^2 + (HW)^2). Arhitecturile și obiectivele de antrenare diferă între modele; AdaLN și fluxul rectificat nu sunt condiții universale.

Condiționarea pe acțiuni: modele de acțiuni latente

Genie învață o acțiune latentă pentru fiecare cadru, prezicând discriminatoriu acțiunea dintre o pereche de cadre consecutive. Decoderul modelului se condiționează apoi de acțiunea latentă dedusă — nu de taste explicite de la tastatură. La inferență, un utilizator poate specifica o acțiune latentă (sau poate eșantiona una dintr-un prior nou), iar modelul generează următorul cadru compatibil cu acea acțiune.

Notă tehnică a traducerii: Descrierea acțiunilor latente provine din lucrarea Genie din 2024 și nu trebuie atribuită automat lui Genie 3. Informațiile publice despre Genie 3 pun accent pe navigare, evenimente de lume declanșate prin prompt și o gamă limitată de acțiuni; ele nu publică aici o specificație echivalentă a decoderului din Genie 2024.

Sora omite complet interfața de acțiuni. Decoderul său prezice următoarele tokenuri spațiu-timp din tokenurile spațiu-timp anterioare. Promptul condiționează începutul; nimic nu îl dirijează în mijlocul generării.

Notă tehnică a traducerii: Documentația publică OpenAI pentru Sora 2 descrie intrări text sau imagine și ieșiri video cu audio sincronizat, dar nu publică o specificație a decoderului care să confirme această predicție de tokenuri spațiu-timp. Tratați propoziția ca intuiție arhitecturală, nu ca interfață sau detaliu de implementare documentat.

Plauzibilitatea fizică

Lansarea Sora 2 din 2026 a promovat explicit plauzibilitatea fizică: greutate, echilibru, permanența obiectelor, cauză și efect. Echipa a măsurat-o prin scoruri de plauzibilitate acordate de evaluatori umani; modelul se îmbunătățește vizibil pentru obiecte scăpate, personaje care se ciocnesc și eșecuri intenționate (un salt ratat) față de Sora 1.

Plauzibilitatea rămâne modul dominant de eșec. Videoclipurile din 2024–2025 cu persoane care mănâncă spaghete sau beau din pahare au arătat lipsa modelului de reprezentare persistentă a obiectelor. Modelele din 2026 (Sora 2, Runway Gen-5, HunyuanVideo) reduc, dar nu elimină, aceste probleme.

Notă tehnică a traducerii: OpenAI descrie pentru Sora 2 o fizică mai exactă decât la sistemele anterioare, dar aceasta este o comparație de produs și nu o garanție de corectitudine fizică. Nu există o metrică vizuală unică ce certifică permanența obiectelor, cauzalitatea sau siguranța controlului; testați explicit constrângerile relevante pentru aplicație și tratați scorurile umane drept o măsură dependentă de protocol.

Modele ale lumii pentru conducere autonomă

Modelele lumii pentru conducere generează scene rutiere realiste condiționate de traiectorii, casete de încadrare sau hărți de navigare. Utilizări:

• Cosmos-Drive-Dreams (NVIDIA) — generează minute de videoclipuri de conducere pentru antrenare RL.
• Gaia-2 (Wayve) — sinteză de scene condiționată de traiectorii pentru evaluarea politicilor.
• DrivingWorld (Tesla) — simulează condiții variate de vreme, moment al zilei și trafic.
• Vista (ByteDance) — sinteză reactivă a scenelor de conducere.

Ele înlocuiesc colectarea costisitoare de date din lumea reală pentru cazuri-limită — pietoni care traversează neregulamentar noaptea, intersecții înghețate, tipuri neobișnuite de vehicule — care ar necesita altfel milioane de mile de conducere.

Notă tehnică a traducerii: Datele sintetice completează, nu înlocuiesc în mod demonstrat, colectarea și validarea în lumea reală. De exemplu, Wayve descrie GAIA-2 ca instrument offboard pentru generarea, testarea și validarea scenariilor de conducere, cu condiționare multi-cameră și structurată. Pentru siguranță sunt necesare evaluări de fidelitate, de acoperire a cazurilor-limită și de transfer către senzori, politici și distribuția operațională reale.

Stiva de robotică: VLM + model video + dinamică inversă

Bucla emergentă de robotică alcătuită din trei componente:

1. VLM analizează scopul („ridicați cana roșie”), planifică o secvență de acțiuni de nivel înalt.
2. Modelul de generare video simulează cum ar arăta executarea fiecărei acțiuni — prezice observații cu N cadre înainte.
3. Modelul de dinamică inversă extrage comenzile motoare concrete care ar produce acele observații.

Aceasta înlocuiește proiectarea recompensei și RL care necesită multe eșantioane. Modelul lumii face imaginația; dinamica inversă închide bucla de acționare. Genie Envisioner este o instanțiere; multe grupuri de cercetare converg către această structură.

Notă tehnică a traducerii: Aceasta este un tipar de cercetare, nu un înlocuitor demonstrat pentru proiectarea recompensei sau pentru RL. Un model de dinamică inversă poate fi ambiguu, poate ieși din distribuție și nu rezolvă singur urmărirea stării, constrângerile de siguranță, calibrarea, feedbackul sau controlul la nivel jos. O buclă robotică implementabilă are nevoie de validare în simulator și pe hardware, precum și de mecanisme explicite de supraveghere.

Evaluare

• Calitate vizuală — FVD (Fréchet Video Distance), studii cu utilizatori.
• Aliniere la prompt — CLIPScore pe cadru, evaluare de tip VQA.
• Plauzibilitate fizică — evaluată de oameni pe o suită de repere (reperul intern Sora 2, VBench).
• Controlabilitate (pentru modelele interactive ale lumii) — consistența acțiune → observație; puteți reveni la o stare anterioară?

Notă tehnică a traducerii: FVD, CLIPScore și evaluările pe cadre nu măsoară direct corectitudinea fizică, consistența cauzală sau controlabilitatea pe orizont lung. Benchmarkurile, extractorii de caracteristici, procedurile de eșantionare și evaluarea umană trebuie raportate exact; comparațiile între produse sau între protocoale interne nu sunt direct echivalente.

Peisajul modelelor în 2026

Model	Utilizare	Parametri	Ieșire	Licență
Sora 2	text-la-video, audio	—	1-min 1080p + audio	numai API
Runway Gen-5	text/imagine-la-video	—	clipuri de 10 s	API
Runway GWM-1 Worlds	lume interactivă	—	derulare 3D infinită	API
Genie 3	lume interactivă din imagine	11B+	cadre jucabile	previzualizare de cercetare
Wan-Video 2.1	text-la-video deschis	14B	clipuri de calitate înaltă	necomercial
HunyuanVideo	text-la-video deschis	13B	10 s	permisivă
Cosmos / Cosmos-Drive	simulare pentru conducere autonomă	7-14B	scene de conducere	NVIDIA open
Magica / Mirage 2	motor de joc nativ pentru IA	—	lumi modificabile	produs

Notă tehnică a traducerii: Tabelul este o fotografie editorială, nu un catalog verificat de versiuni. Denumirile comerciale, numărul de parametri, rezoluțiile, durata, licențele, accesul și prețurile se modifică frecvent; de pildă, documentația oficială GWM-1 îl prezintă ca familie cu variante Worlds, Avatars și Robotics, construită pe Gen-4.5, nu pe Gen-5, iar documentația oficială Genie 3 indică o durată de câteva minute la 720p. Înainte de integrare, verificați pagina oficială actuală și condițiile checkpointului sau ale API-ului.

Construiți

Pasul 1: patchify 3D pentru 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)

O convoluție 3D cu pas egal cu nucleul acționează ca împărțitor în patch-uri spațio-temporale. Grila de tokenuri (T, H, W) -> (T/2, H/2, W/2).

Notă tehnică a traducerii: Fără padding, Conv3d folosește împărțirea prin rotunjire în jos; dacă T, H sau W nu sunt divizibile cu dimensiunea patch-ului, voxelii de la margine sunt omiși. O implementare de producție trebuie să aleagă și să păstreze explicit politica de padding, crop și reconstrucție.

Pasul 2: codificare de poziție rotativă 3D

Reprezentări poziționale rotative (RoPE) aplicate separat de-a lungul axelor 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)

Formă aditivă simplificată. RoPE real rotește canale pereche la frecvențe; informația pozițională este aceeași.

Notă tehnică a traducerii: Fragmentul construiește o reprezentare sinusoidală aditivă, nu aplică rotațiile RoPE la perechi de canale ale interogărilor și cheilor. Prin urmare, informația pozițională și proprietățile de atenție relativă nu sunt aceleași ca pentru RoPE. Pentru a fi robust, cereți dimensiuni axiale pare și strict pozitive; altfel expresii precum t_dim // 2 pot produce împărțire la zero sau dimensiuni incompatibile. Nu substituiți acest exemplu demonstrativ unei implementări RoPE verificate a modelului ales.

Pasul 3: bloc de atenție împărțită

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

Atenția temporală acordă atenție în cadrul fiecărei poziții spațiale de-a lungul timpului; atenția spațială acordă atenție în cadrul fiecărui cadru de-a lungul pozițiilor. Două operații O(T^2 + (HW)^2) în locul uneia O((THW)^2). Aceasta este esența TimeSformer și a fiecărui DiT video modern.

Notă tehnică a traducerii: Reducerea calculului provine din factorii de grupare: atenția temporală costă O(HW · T^2), iar cea spațială O(T · (HW)^2), înainte de factorii de lot, capete și dimensiune ascunsă. Exemplul presupune că seq == T * H * W și că dim este divizibil cu heads; validați aceste invariante la intrare. Atenția împărțită este importantă pentru TimeSformer, dar nu definește toate arhitecturile video DiT moderne.

Pasul 4: compuneți un DiT video mic

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

Nu este un generator video funcțional; este o demonstrație structurală în care fiecare componentă are forme corecte.

Notă tehnică a traducerii: Formele sunt suficiente numai pentru demonstrație. Un DiT de difuzie funcțional mai are cel puțin variabila de timp/zgomot, condiționarea aleasă, ținta de antrenare, un proces de denoising și operația de unpatchify către latentul sau videoclipul final. Mai mult, TinyVideoDiT nu apelează rope_3d, deci acest model demonstrativ nu introduce deloc codificare pozițională. Ieșirea acestui bloc nu este un videoclip generat.

Pasul 5: verificați formele

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)}")

Așteptați-vă la grid = (4, 8, 8) și out = (1, 256, 32) după împărțirea în patch-uri; capul proiectează apoi către patch-uri spațio-temporale per token, gata să fie reunite prin un-patchify într-un videoclip.

Utilizați-l

Tipare de acces în producție pentru 2026:

• Sora 2 API (OpenAI) — text-la-video, audio sincronizat. Preț premium.
• Runway Gen-5 / GWM-1 (Runway) — imagine-la-video, lumi interactive.
• Wan-Video 2.1 / HunyuanVideo — auto-găzduire open-source.
• Cosmos / Cosmos-Drive (NVIDIA) — ponderi deschise pentru simularea conducerii.
• Genie 3 — previzualizare de cercetare, solicitați acces.

Notă tehnică a traducerii: Acestea nu sunt instrucțiuni de integrare garantate. Accesul la produse, API-uri, puncte de control, licențe comerciale și prețuri este volatil; pagina OpenAI pentru Sora 2 marchează produsul Sora drept indisponibil din 26 aprilie 2026, în timp ce documentația API trebuie verificată separat. Pentru modelele cu ponderi, citiți licența exactă și cardul modelului, nu presupuneți că „open-source” autorizează orice utilizare.

Pentru construirea unei demonstrații interactive de model al lumii: începeți cu Wan-Video pentru calitate, adăugați deasupra un adaptor de acțiuni latente pentru interactivitate. Pentru simularea conducerii autonome: Cosmos-Drive este reperul deschis din 2026.

Pentru robotică, stiva folosită în practică:

1. Scop lingvistic -> VLM (Qwen3-VL) -> plan de nivel înalt.
2. Plan -> model video cu acțiuni latente -> derulare imaginată.
3. Derulare -> model de dinamică inversă -> acțiuni de nivel jos.
4. Acțiuni executate -> observație trimisă înapoi la pasul 1.

Notă tehnică a traducerii: „Începeți cu Wan-Video” și „reperul deschis” sunt recomandări editoriale, nu rețete validate universal. Pentru un sistem interactiv, verificați dacă modelul acceptă într-adevăr acțiuni, ce spațiu de control este expus, cum se menține starea și cum sunt evaluate erorile de predicție; un adaptor adăugat peste un generator video nu oferă automat control fiabil.

Livrați

Această lecție produce:

• outputs/prompt-video-model-picker.md — alege între Sora 2 / Runway / Wan / HunyuanVideo / Cosmos în funcție de sarcină, licență și latență.
• outputs/skill-physical-plausibility-checks.md — o competență care definește verificări automate (permanența obiectelor, gravitație, continuitate) de rulat pe orice videoclip generat înainte de livrare.

Exerciții

1. (Ușor) Calculați numărul de tokenuri pentru un videoclip 360p de 5 secunde la patch-t=2, patch-h=8, patch-w=8. Raționați despre memoria necesară pentru atenție la această dimensiune.
2. (Mediu) Înlocuiți blocul de atenție împărțită de mai sus cu un bloc de atenție comună complet și măsurați forma și numărul de parametri. Explicați de ce atenția împărțită este necesară pentru modele video reale.
3. (Dificil) Construiți un model video minim cu acțiuni latente: luați un set de date de triplete (frame_t, action_t, frame_{t+1}) (orice joc 2D simplu), antrenați un DiT video mic condiționat de reprezentări vectoriale ale acțiunilor și arătați că acțiuni diferite produc cadre următoare diferite.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
Model al lumii	„Simulator învățat”	Un model care prezice observații viitoare având starea și acțiunea
DiT video	„Transformer spațiu-timp”	Transformer de difuzie cu împărțire în patch-uri 3D și atenție împărțită
Acțiune latentă	„Control dedus”	Acțiune latentă discretă sau continuă dedusă din perechi de cadre; utilizată pentru a condiționa generarea cadrului următor
Atenție împărțită	„Timp, apoi spațiu”	Două operații de atenție per bloc — de-a lungul timpului, apoi a spațiului — pentru a păstra O(N^2) gestionabil
Permanența obiectelor	„Lucrurile rămân reale”	Proprietate a scenei pe care modelele video trebuie să o învețe; mod clasic de eșec pentru alimente și sticlărie
FVD	„Distanța video Fréchet”	Echivalentul video al FID; metrică principală a calității vizuale
Model de dinamică inversă	„Observații către acțiuni”	Având (stare, starea următoare), produce acțiunea care le conectează; închide bucla de robotică
Cosmos-Drive	„Simulator de conducere NVIDIA”	Model al lumii cu ponderi deschise pentru conducere autonomă, destinat RL și evaluării

Lecturi suplimentare

• Raportul tehnic Sora (OpenAI)
• Genie: medii interactive generative (Bruce et al., 2024) — modele ale lumii cu acțiuni latente
• TimeSformer (Bertasius et al., 2021) — atenție împărțită pentru Transformere video
• DreamerV3 (Hafner et al., 2023) — modele ale lumii pentru RL
• Cosmos-Drive-Dreams (NVIDIA, 2025) — model al lumii pentru conducere
• Top 10 modele de generare video în 2026 (DataCamp)
• De la generare video la model al lumii — depozit de sondaj

Sursă: Originalul în limba engleză

Navigare: ← Lecția 04.27 — Urmărirea mai multor obiecte și memoria video · Faza 4 — Viziune computerizată · Lecția 05.01 — Prelucrarea textului — tokenizare, stemming, lematizare → · Catalog complet