ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Xu hướng mới

AI Researcher

Mô hình thế giới — AI biết tưởng tượng

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Mô hình AI xây dựng biểu diễn nội tại về thế giới, có thể dự đoán hậu quả hành động trước khi thực hiện.

lesson120 minXu hướng mớiAI Researcher

Dự đoán

AI có thể tưởng tượng hậu quả của một hành động trước khi thực hiện không?

World Models là bước tiến lớn: AI không chỉ 'nhớ' patterns mà còn 'hiểu' cách thế giới vận hành. Giống cách bạn biết cốc sẽ rơi mà không cần thử — AI xây dựng mô hình vật lý nội tại để dự đoán. Sora, GAIA, Dreamer đều đang phát triển khả năng này.

Dòng thời gian và so sánh

  1. 2018: Ha & Schmidhuber giới thiệu 'World Models' — VAE + MDN-RNN học dynamics của game đua xe.
  2. 2020: Hafner công bố Dreamer — backprop xuyên qua latent dynamics.
  3. 2022: DayDreamer — robot vật lý học bơi/đi trong thế giới thật chỉ với vài giờ kinh nghiệm nhờ dream-based RL.
  4. 2023: DreamerV3 giải Minecraft end-to-end, GAIA-1 của Wayve mô phỏng lái xe.
  5. 2024: Sora, Veo, Genie — world model khổng lồ xử lý video + có action controllable.
  6. 2025-nay: Xu hướng foundation world model đa modal (JEPA2, Cosmos của NVIDIA) làm nền cho robot đa dạng.
Tiêu chíLatent (JEPA, DreamerV3)Pixel-level (Sora, GAIA)
Tốc độ rolloutRất nhanh (vector)Chậm (mỗi pixel)
Dễ train policyDễ — không gian nhỏKhó — không gian lớn
Tương tác với con ngườiKhó trực quan hoáDễ — ra video xem được
Sai số dài hạnÍt compoundingNhiều hallucinate

Khoảnh khắc A-ha

Con người không cần thử mọi thứ để hiểu thế giới — bạn biết lửa nóng, đá trơn, cốc rơi. Đây là vì não có world model. AI đang học cách tương tự: Sora học vật lý từ video, Dreamer tự chơi trong 'giấc mơ' để luyện chính sách, GAIA mô phỏng giao thông. Đây là bước tiến từ 'AI biết nói' sang 'AI biết nghĩ trước khi hành động'.

Thử thách

Xe tự lái đang chạy 60 km/h và thấy người sang đường. World model cần làm gì để ra quyết định?
Robot hút bụi chỉ thấy khoảng 30 cm quanh nó. Cách nào lập kế hoạch dọn cả phòng?

SLAM + world model: robot ghép các quan sát partial thành bản đồ (map building), sau đó dùng world model dự đoán phần chưa đi qua. Đây chính là nguyên lý Roborock, iRobot, Ecovacs.

Lý thuyết

World Models là AI xây dựng biểu diễn nội tại về cách thế giới vận hành — có thể dự đoán hậu quả hành động trước khi thực hiện. Đây là bước tiến bổ sung cho reasoning models (suy luận bằng ngôn ngữ) và là 'simulator tưởng tượng' cho các tác tử reinforcement learning lập kế hoạch.

Core loop:

s^t+1=fworld(st,at)(dự đoaˊn state tieˆˊp theo)\hat{s}_{t+1} = f_{\text{world}}(s_t, a_t) \quad \text{(dự đoán state tiếp theo)}
a∗=arg⁡max⁡a∑tr(s^t,at)(chọn action toˆˊt nhaˆˊt trong ’tưởng tượng’)a^* = \arg\max_a \sum_{t} r(\hat{s}_t, a_t) \quad \text{(chọn action tốt nhất trong 'tưởng tượng')}

Belief state & partial observability: Khi agent chỉ thấy một phần (observation o), nó duy trì belief state b(s) — phân phối xác suất trên các state có thể. World model cập nhật belief theo action và observation mới, rồi plan trên belief đó.

bt+1(s′)=η⋅p(ot+1∣s′)∑sp(s′∣s,at) bt(s)b_{t+1}(s') = \eta \cdot p(o_{t+1}|s') \sum_s p(s'|s, a_t) \, b_t(s)

Ba hướng tiếp cận

3 hướng tiếp cận:

  • Learned Simulators: Neural network học physics từ data (Sora, GAIA-1 của Wayve)
  • Latent World Models: Mô hình trong latent space, không render pixel (JEPA của Meta, DreamerV3)
  • Foundation World Models: Train trên nhiều domain, transfer cho task mới (Genie của DeepMind)

Code mẫu

World Model concept: dự đoán state tiếp theo

import torch
import torch.nn as nn

class SimpleWorldModel(nn.Module):
    """World model: dự đoán state_{t+1} từ state_t và action_t."""
    def __init__(self, state_dim=64, action_dim=4, hidden=256):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(state_dim + action_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
        )
        self.state_predictor = nn.Linear(hidden, state_dim)
        self.reward_predictor = nn.Linear(hidden, 1)

    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)
        h = self.encoder(x)
        next_state = self.state_predictor(h)  # Dự đoán
        reward = self.reward_predictor(h)
        return next_state, reward

    def imagine(self, state, actions_sequence):
        """'Tưởng tượng' nhiều bước tương lai (rollout in dream)."""
        states, rewards = [state], []
        for action in actions_sequence:
            state, reward = self.forward(state, action)
            states.append(state)
            rewards.append(reward)
        return states, rewards  # Trajectory trong 'tưởng tượng'

Dream-based training loop (Dreamer style)

import torch
from torch.optim import Adam

world_model = SimpleWorldModel()
policy = PolicyNetwork()
value = ValueNetwork()

opt_wm = Adam(world_model.parameters(), lr=1e-4)
opt_pi = Adam(policy.parameters(), lr=3e-5)

replay_buffer = []  # kinh nghiệm từ môi trường thật

for epoch in range(10_000):
    # ----- GIAI ĐOẠN 1: THU THẬP DATA THẬT -----
    state, _ = env.reset()
    done = False
    while not done:
        action = policy(state).sample()
        next_state, reward, done, _, _ = env.step(action)
        replay_buffer.append((state, action, reward, next_state))
        state = next_state

    # ----- GIAI ĐOẠN 2: HUẤN LUYỆN WORLD MODEL -----
    batch = sample(replay_buffer, 256)
    s, a, r, s_next = stack(batch)
    pred_s, pred_r = world_model(s, a)
    loss_wm = (pred_s - s_next).pow(2).mean() + (pred_r - r).pow(2).mean()
    opt_wm.zero_grad(); loss_wm.backward(); opt_wm.step()

    # ----- GIAI ĐOẠN 3: TRAIN POLICY TRONG 'GIẤC MƠ' -----
    # Không gọi env thật — tất cả diễn ra bên trong world model!
    dream_states = [sample_start_state(replay_buffer)]
    log_probs, rewards = [], []
    for _ in range(horizon := 15):
        dist = policy(dream_states[-1])
        a = dist.sample()
        log_probs.append(dist.log_prob(a))
        s_next, r = world_model(dream_states[-1], a)
        dream_states.append(s_next)
        rewards.append(r)
    # Policy gradient trên trajectory tưởng tượng
    returns = discounted_return(rewards, gamma=0.99)
    loss_pi = -(torch.stack(log_probs) * returns.detach()).mean()
    opt_pi.zero_grad(); loss_pi.backward(); opt_pi.step()
# → Policy đã tốt hơn MÀ KHÔNG cần tương tác thêm với env thật

JEPA và học không cần pixel

Yann LeCun lập luận: dự đoán từng pixel là lãng phí — quá nhiều chi tiết không quan trọng (hình dáng chính xác của mỗi chiếc lá). Joint Embedding Predictive Architecture (JEPA) encode observation thành vector trừu tượng, rồi dự đoán vector tiếp theo. Kết quả: nhanh hơn, khái quát tốt hơn, ít hallucinate. I-JEPA và V-JEPA (cho video) đã chứng minh trên ImageNet và Kinetics. Đây là con đường Meta đi khác với OpenAI/Sora.

World model trong robot thật

Tesla FSD v12, Wayve GAIA-1, và Covariant RFM đều dựa trên world model (theo nguồn bài, chưa kiểm chứng). Bài toán: robot phải quyết định an toàn trong realtime khi chỉ có camera + một số sensor. World model (1) dự đoán hành vi các agent khác (xe, người đi bộ), (2) mô phỏng kết quả nhiều hành động của chính mình, (3) chọn hành động tối ưu theo cost (an toàn + hiệu quả). Thử thách lớn nhất: độ chính xác dưới điều kiện khó (mưa, đêm, đường xa lạ).

Chuỗi tiến hoá của world model:

  • 2018 — World Models (Ha & Schmidhuber): VAE + RNN dự đoán frame tiếp theo trong game CarRacing. Bài paper đầu tiên đặt tên 'world model' và chứng minh khái niệm dream training.
  • 2020 — Dreamer (Hafner et al.): Latent dynamics model + policy học qua backprop xuyên qua imagination. Vượt SOTA trên DeepMind Control Suite.
  • 2023 — DreamerV3: Giải Minecraft không cần reward shaping thủ công — lần đầu một agent tự học thu thập kim cương.
  • 2024 — Sora, Genie, GAIA-1: Video generation khổng lồ, có thể 'chạy' như game engine neural.
  • Tương lai: Foundation world model đa modal (text + image + video + action) — backbone chung cho robot, agent, sim-to-real.

Mối liên hệ với con người: Khoa học nhận thức cho rằng não người có 'generative model' dự đoán cảm giác tiếp theo (predictive coding). Khi dự đoán sai, não chú ý — đó là cơ chế học. World model của AI đang tiến tới mô hình tương tự: học bằng surprise, tập trung vào phần khó dự đoán.

Tóm tắt

  • World model = biểu diễn nội tại về cách thế giới vận hành — dự đoán hậu quả hành động trước khi thực hiện.
  • Giải quyết partial observability: agent chỉ thấy một phần, world model 'điền' phần còn lại.
  • Dream-based training: train policy trong 'tưởng tượng' của world model — tiết kiệm data thật.
  • Hai nhánh chính: pixel-level (Sora) vs latent (JEPA, DreamerV3). Đánh đổi giữa chi tiết và tốc độ.
  • Ứng dụng: xe tự lái (dự đoán hành vi), robot (lập kế hoạch), game engine (Genie), sinh video (Sora).
  • Giới hạn: compounding error khi rollout dài, hallucination, khó đánh giá 'độ đúng vật lý' của mô phỏng.

Continue the module

Lesson 2 of 6