World Models与规划

World Models将世界理解为一个可学习的生成模型，使智能体能够在”想象空间”中学习和规划。¹

World Models基础

Ha & Schmidhuber (2018)

World Models是首个将完整的世界模型概念应用于强化学习的系统。

World Models 架构
┌─────────────────────────────────────────────────────────────┐
│                                                              │
│   输入: 环境观察 o_t (图像)                                    │
│         │                                                    │
│         ▼                                                    │
│   ┌───────────┐                                              │
│   │   VAE     │  变分自编码器                                  │
│   │ 编码器    │  将图像压缩为隐向量 z_t                         │
│   └─────┬─────┘                                              │
│         │                                                    │
│         ▼                                                    │
│   ┌───────────┐                                              │
│   │  MDN-RNN  │  混合密度网络 + RNN                           │
│   │  世界模型  │  学习 p(z_{t+1}|z_t, a_t, h_t)               │
│   │           │  预测未来隐状态分布                             │
│   └─────┬─────┘                                              │
│         │                                                    │
│         ▼                                                    │
│   ┌───────────┐                                              │
│   │ Controller │  线性/小型控制器 C                            │
│   │   C       │  在原观察空间直接输出动作 a_t                   │
│   └───────────┘                                              │
│         │                                                    │
│         ▼                                                    │
│   输出: 动作 a_t                                             │
│                                                              │
└─────────────────────────────────────────────────────────────┘

三大组件

组件	功能	关键技术
VAE	感知压缩	变分自编码器，将高维图像编码为$z_t$
MDN-RNN	动态预测	混合密度网络+RNN，预测未来分布
Controller	动作选择	极简线性控制器，使用CMA-ES优化

---

Dreamer系列

Dreamer发展时间线

Dreamer 发展时间线
─────────────────────────────────────────────────────────────
│
│ 2019          2020           2022           2023
│  │             │              │              │
│  ▼             ▼              ▼              ▼
│ PlaNet ───▶ Dreamer ───▶ DreamerV2 ───▶ DreamerV3
│ (Hafner)     (Hafner)       (Hafner)       (Hafner)
│
│              + 隐空间规划    + 离散latent    + 通用算法
│              + Actor-Critic  + symlog        + 150+任务
│                            + 目标表示
│
└─────────────────────────────────────────────────────────────

DreamerV1训练流程

class DreamerAgent:
    def __init__(self):
        self.encoder = Encoder()      # o_t -> s_t
        self.dynamics = Dynamics()     # h_t, s_t = f(h_{t-1}, s_{t-1}, a_{t-1})
        self.reward_model = RewardModel()
        self.actor = Actor()          # 策略 π(a_t|h_t, s_t)
        self.critic = Critic()        # 价值 V(h_t, s_t)
    
    def imagine_rollout(self, h_T, s_T, horizon=15):
        """在隐空间中进行想象 rollout"""
        traj = [(h_T, s_T)]
        for k in range(horizon):
            a = self.actor(traj[-1])   # 选择动作
            h_next, s_next = self.dynamics(traj[-1], a)
            r = self.reward_model(h_next, s_next)
            traj.append((h_next, s_next, a, r))
        return traj
    
    def update(self, batch):
        # 1. 编码观察
        enc = self.encoder(batch.observations)
        
        # 2. 展开隐状态序列
        imag_traj = self.imagine_rollout(
            batch.initial_hidden, 
            batch.initial_state
        )
        
        # 3. 计算lambda回报
        returns = compute_returns(traj, self.critic, lambda_=0.95)
        
        # 4. 更新 actor 和 critic
        self.actor.update(traj, returns)
        self.critic.update(traj, returns)
        self.dynamics.update(batch)  # 重建损失

DreamerV3关键创新

DreamerV3在Nature 2025发表，实现单一算法覆盖150+任务。²

symlog变换：

def symlog(x):
    """处理不同尺度的奖励信号"""
    return np.sign(x) * np.log(np.abs(x) + 1)
 
def symexp(x):
    """symlog的逆变换"""
    return np.sign(x) * (np.exp(np.abs(x)) - 1)

---

MuZero与规划

Schrittwieser et al. (2019)

MuZero结合了AlphaZero的MCTS规划能力与学习世界模型的能力。³

MuZero 与 AlphaZero 对比
┌─────────────────────┬─────────────────────────────┐
│      AlphaZero      │          MuZero              │
├─────────────────────┼─────────────────────────────┤
│   需要已知规则       │   学习环境模型               │
│   真实MCTS          │   模拟MCTS (Learned Model)   │
│   无法处理视觉输入   │   可处理像素输入             │
└─────────────────────┴─────────────────────────────┘

MuZero 网络结构
┌─────────────────────────────────────────────────────┐
│                                                      │
│   输入: s_{t-1} (编码后的观察)                         │
│      │                                               │
│      ▼                                               │
│   ┌─────────────────────────────────────────────┐   │
│   │              Representation Network h        │   │
│   │         s_{t-1} -> hidden state h_0          │   │
│   └─────────────────────────────────────────────┘   │
│      │                                               │
│      ▼                                               │
│   ┌─────────────────────────────────────────────┐   │
│   │              Dynamics Network g              │   │
│   │    (h_t, a_t) -> r_t, s_t (中间表示)        │   │
│   │                                              │   │
│   │    只预测 reward 和中间隐状态                 │   │
│   └─────────────────────────────────────────────┘   │
│      │                                               │
│      ▼                                               │
│   ┌─────────────────────────────────────────────┐   │
│   │              Prediction Network f            │   │
│   │         s_t -> policy p_t, value v_t        │   │
│   └─────────────────────────────────────────────┘   │
│                                                      │
└─────────────────────────────────────────────────────┘

MuZero MCTS实现

class MuZeroMCTS:
    def __init__(self, representation, dynamics, prediction):
        self.h = representation  # s -> hidden
        self.g = dynamics         # (hidden, action) -> (reward, hidden)
        self.f = prediction       # hidden -> (policy, value)
        self.num_simulations = 50
        self.gamma = 0.997
    
    def mcts(self, obs, num_simulations=None):
        num_simulations = num_simulations or self.num_simulations
        
        # 1. 初始隐藏状态
        hidden = self.h(obs)
        
        # 2. 蒙特卡洛树搜索
        root = Node(hidden=hidden)
        for _ in range(num_simulations):
            self.search(root)
        
        # 3. 返回策略
        return root.get_visit_distribution()
    
    def search(self, node):
        if node.is_terminal():
            return 0
        
        if node.is_expanded():
            # Selection: 使用PUCT选择最佳子节点
            action, child = node.best_child()
            
            # Dynamics: 在模型中前进一步
            reward, next_hidden = self.g(node.hidden, action)
            
            # 递归搜索
            value = self.search(child)
            return reward + self.gamma * value
        else:
            # Expansion: 展开节点
            policy, value = self.f(node.hidden)
            node.expand(policy)
            return value

---

AlphaZero

Silver et al. (2018)

AlphaZero使用MCTS进行规划，在已知规则的游戏中达到超人类水平。⁴

AlphaZero MCTS 流程
┌─────────────────────────────────────────────────────┐
│                                                      │
│   当前状态 s                                          │
│      │                                               │
│      ▼                                               │
│   ┌───────────────────────┐                         │
│   │   Monte Carlo Tree Search                        │
│   │                                               │
│   │   ┌─────────┐                                │
│   │   │Selection│ 选择最优子节点 (PUCT)           │
│   │   └────┬────┘                                │
│   │        ▼                                     │
│   │   ┌─────────┐                                │
│   │   │Expansion│ 扩展叶节点                      │
│   │   └────┬────┘                                │
│   │        ▼                                     │
│   │   ┌─────────┐                                │
│   │   │Simulation│ 随机 rollout                   │
│   │   └────┬────┘                                │
│   │        ▼                                     │
│   │   ┌─────────┐                                │
│   │   │Backprop │ 反向传播更新统计                 │
│   │   └─────────┘                                │
│   │                                               │
│   └───────────────────────┘                       │
│      │                                               │
│      ▼                                               │
│   选择访问次数最多的动作                              │
│                                                      │
└─────────────────────────────────────────────────────┘

PUCT选择公式

$a^{\ast }=\arg {\max }_a\left[Q(s,a)+c_{puct}\cdot P(s,a)\cdot \frac{\sqrt{N(s)}}{1+N(s,a)}\right]$

---

比较分析

方法	模型类型	规划方式	优点	缺点
World Models	生成模型	短horizon	端到端学习	复合误差
Dreamer	RSSM	想象rollout	高样本效率	隐空间近似
MuZero	隐式模型	MCTS	强规划能力	需大量计算
AlphaZero	已知模型	MCTS	超人类棋力	需规则

---

最新进展 (2024-2025)

DreamerV3 (Nature 2025)

• 单一算法覆盖150+任务
• 包括机器人控制、游戏、自动驾驶
• 单一超参数集，无需任务特定调优

SafeDreamer (2024)

• 在Dreamer框架中引入安全约束
• 使用Lagrangian方法处理约束

Graph Dreamer (NeurIPS 2025)

• 将图神经网络与Dreamer结合
• 处理时序图结构数据

---

参考资料

---

相关链接

• 基于模型RL理论基础 — PETS、Dreamer基础
• 模型预测控制 — MPC理论基础
• PPO算法 — 策略优化算法

Footnotes

1. Ha & Schmidhuber, “World Models”, arXiv:1803.10122, 2018 ↩

2. Hafner et al., “Mastering Diverse Domains through World Models”, Nature, 2025 ↩

3. Schrittwieser et al., “Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model”, arXiv:1911.08265, 2019 ↩

4. Silver et al., “A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play”, Science, 2018 ↩