企业官网建设流程全解析

训练一个强化学习策略，最贵的从来不是算法，而是数据。真机采样要磨损硬件、占用测试场地、消耗人工；仿真器采样要么建模成本高，要么保真度不够，策略在仿真里跑得再好，一上真机照样崩。这条成本曲线卡住了太多项目：算法论文复现得很快，真机落地却要按季度算。

世界模型（World Model）这两个字之所以最近被反复提起，就是因为它给出了第三条路：不碰真实环境，也不完全依赖手工搭建的物理仿真器，而是从已有数据里学一个"可推演的环境"，让智能体在这个学出来的想象空间里试错。Dreamer 系列在多个控制任务上用同一套超参数跑通、MuZero 在没有规则输入的棋类游戏里达到超人水平、Wayve 用生成式世界模型做自动驾驶闭环仿真、NVIDIA Cosmos 把世界基础模型做成通用底座——这些都在指向同一件事。

但我的判断是：世界模型不是"免费环境"，它是"带偏差的加速器"。用得好，样本效率能提升一个量级，真机试错次数大幅下降；用不好，策略会在一个错误的想象里收敛得非常漂亮，然后一上真实环境就原形毕露。这篇文章不讲概念综述，而是把世界模型接入强化学习的完整链路拆开：它到底预测什么、三类主流技术路线怎么选、最小可运行代码长什么样、自动驾驶和机器人以及 LLM 智能体这三类场景的差异在哪、以及最容易踩的坑是什么。

读完之后，你应该能判断自己的项目适不适合引入世界模型，能跑通一个最小闭环，并且知道当"想象里很好、现实里很糟"时该从哪里排查。

1. 为什么"不碰真实环境"突然成了一个工程问题

强化学习的样本效率问题不是新问题，但它的解法一直在变。早期大家靠并行采样堆算力，把成千上万个环境实例跑在 CPU 集群上；后来靠分布式架构和优先经验回放，把每一条数据榨干；再后来靠离线强化学习，直接从已有日志里学。这三条路的共同点是：它们都不改变"数据从哪来"这件事，只是改变"数据怎么用"。

世界模型改变的是前者。它把"从环境拿数据"变成"从数据学环境，再从环境采样"。这个转变的意义在于，环境不再是外部给定的固定对象，而是一个可以随数据更新的、可微的、能批量并行推演的内部组件。你在 GPU 上一次前向传播就能推进一千条轨迹，这在真机上完全不可能。

代价也很清楚。任何模型都有近似误差，当你把策略放进这个带误差的环境里训练，误差会被策略主动利用——强化学习的目标就是最大化回报，它会自动找到模型预测偏乐观的区域，然后疯狂往那里钻。这就是常说的模型利用（model exploitation），也是世界模型方法最核心的工程难题。

所以更适合问的问题是：你的项目里，采样成本有多高？建模误差有多大？能不能承受分布外漂移？如果真机采样成本极高（机器人、自动驾驶、医疗决策），世界模型的收益就很明显；如果任务本身可以用解析仿真器精确建模（棋类、简单控制），那世界模型就是多余的中间层；如果奖励函数本身都定义不清，那先解决奖励，别急着上世界模型。

这篇文章面向三类读者：正在做机器人或自动驾驶、被真机采样成本卡住的工程师；在做 LLM 智能体、想用模拟环境替代真实 API 调用的应用开发者；以及想理解 Dreamer、TD-MPC2 这类方法究竟在做什么的算法同学。三类读者的场景差异很大，所以第 7 节会分开讲。

2. 世界模型到底是什么：从"预测下一帧"到"可训练的想象空间"

最朴素的理解是：世界模型就是一个"预测下一步会发生什么"的模型。给它当前状态和动作，它输出下一个状态、奖励、以及是否终止。这个定义没错，但太宽泛，宽泛到把查表、物理引擎、甚至一个 if-else 都能算进去。

真正有工程价值的定义要加两个约束：第一，它工作在压缩后的潜空间（latent space）里，而不是原始观测上；第二，它必须可微，能反向传播梯度。第一个约束决定了它能不能高效推演，第二个约束决定了它能不能和策略网络联合优化。这两点合起来，才是"可以用它训练策略"的世界模型。

2.1 与世界模型容易混淆的三个概念

很多人第一次接触时会把它和仿真器、数字孪生、模型预测控制混在一起，其实差别很大。

仿真器是人工编写的物理规则集合，比如 MuJoCo、CARLA、Isaac Sim。它的行为由代码决定，可解释、可调试，但保真度取决于建模投入。世界模型是从数据里学出来的，它可能学出人类没写进仿真的规律，也可能学出完全错误的规律，而且你无法直接读懂它。

数字孪生更偏向工程侧的实时映射，通常用于监控和运维，强调的是"和真实系统同步"，而不是"可微、可训练"。它解决的是观测问题，不是决策优化问题。

模型预测控制（MPC）用的是显式模型，通过在线优化求解动作序列。TD-MPC2 这类方法确实借用了 MPC 的思想，但它的模型是学出来的，而且优化过程嵌在策略学习里。MPC 不需要"训练一个模型"，世界模型方法的核心恰恰是"模型本身要被训练"。

一句话区分：仿真器是人写的，数字孪生是同步的，MPC 是求解的，世界模型是学出来的且可微的。

2.2 世界模型的三条主流技术路线

按"预测什么"来分，目前主流做法可以归成三类，每一类的取舍完全不同。

第三列值得多说一句。Dreamer 系列选择重建观测，是因为重建提供了一个非常强的辅助信号，逼着潜状态保留足够的信息，不容易塌缩。但重建原始像素在视觉复杂的场景里非常浪费容量，所以 DreamerV3 用 symlog 变换和离散化来缓解，TD-MPC2 干脆放弃重建，改用潜空间的一致性损失。MuZero 走得更远，它连观测都不重建，只保证奖励、价值和策略在潜空间里一致——但代价是需要配套的蒙特卡洛树搜索才能发挥威力。

生成式路线是另一回事。GAIA-1、NVIDIA Cosmos、DeepMind 的 Genie 系列，它们产出的是可以直接看的画面或可交互的 token 序列，主要用途不是训练策略，而是生成数据、做闭环仿真、做场景扩增。它们的"世界模型"含义更接近"可交互的视频生成器"。这类方法在自动驾驶里很受欢迎，因为长尾场景太稀缺，能生成出来就已经很有价值。

选择建议很直接：如果你的观测是高维图像、任务对视觉细节敏感，从 Dreamer 系入手；如果算力紧张、控制维度不高，看 TD-MPC2；如果需要大量合成数据补充长尾场景，关注生成式路线。不要一上来就追求最复杂的方案。

2.3 想象 rollout 为什么会失效

这是整篇文章里最需要理解的一点。世界模型训练好之后，策略是在它上面做"想象 rollout"的：从真实数据里取一个起点状态，然后在潜空间里连续推演几十步，用累积的想象回报去更新策略。

问题在于，每一步推演都有误差，误差会累积。推演 5 步可能还很准，推演 50 步可能已经完全偏离真实轨迹。更麻烦的是，策略会主动寻找模型误差大的区域——因为在那些地方模型会给出虚高的奖励预测。这就是奖励黑客（reward hacking）在模型层面的版本。

所以你会看到所有成熟实现都在做两件事：控制想象长度，以及定期用真实数据校准。DreamerV3 的想象视界通常在 15 步左右，不是随便定的；训练时世界模型和策略是交替优化的，不是先训完模型再训策略。TD-MPC2 则用短视界的 MPC 加价值函数兜底，本质上也是同一个思路。

3. 环境准备与依赖清单

下面这套配置是为第 5 节的代码准备的。它是一个最小骨架，用来跑通"编码器 + RSSM + 想象 rollout + actor-critic"这条链路，不是 DreamerV3 的完整复现。生产环境建议直接用官方实现或成熟的社区复现版本，本文的代码价值在于让你看懂每一块在做什么。

运行环境建议如下。具体版本请以你本地项目为准，本文重点演示通用思路，不锁定版本号。

• 操作系统：Linux（Ubuntu 20.04 及以上）或 macOS，Windows 建议用 WSL2
• Python：3.9 及以上
• 深度学习框架：PyTorch 2.x，需要 CUDA 可用
• 数值计算：NumPy
• 环境接口：Gymnasium（用于低维观测的连续控制任务）
• 配置管理：PyYAML
• 可视化：TensorBoard 或 Weights & Biases（可选）

安装命令如下：

# 文件路径：scripts/setup.sh # 创建虚拟环境 python -m venv .venv source .venv/bin/activate # 安装 PyTorch，请按本机 CUDA 版本选择对应命令 pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121 # 安装其余依赖 pip install numpy gymnasium pyyaml tensorboard tqdm # 验证 CUDA 是否可用 python -c "import torch; print(torch.__version__, torch.cuda.is_available())"

如果最后一行输出False，先别急着往下跑。CPU 也能跑通本文的示例，但速度会慢很多，尤其是想象 rollout 部分。排查顺序是：驱动版本、CUDA 版本、PyTorch 安装的 wheel 是否匹配。这一步出错后续所有报错都会变得难以定位。

项目结构建议按下面这样组织，后面每个代码块的文件路径都和它对应：

# 文件路径：项目目录结构 wm_rl/ ├── configs/ │ └── default.yaml ├── models/ │ ├── rssm.py │ ├── world_model.py │ └── actor_critic.py ├── utils/ │ ├── replay.py │ └── envs.py └── train.py

4. 核心流程拆解：一个世界模型 RL 系统由哪几块组成

在写代码之前，先把整套系统的数据流理清楚。少了任何一块，或者顺序搞错，都会导致训练不收敛，而且现象很隐蔽。

4.1 表征模型：把观测压成向量

第一块是编码器，负责把原始观测（图像或低维状态向量）映射成一个定长的嵌入向量。它的作用是降维和去噪，让后续的循环网络不必直接处理高维输入。

这里最容易犯的错是编码器容量给太大。很多人觉得编码器越强越好，结果潜状态里塞满了对决策无用的细节，转移模型学不动。更合理的做法是让编码器和解码器对称，重建损失自然会约束它保留"能重建回来"的信息，而不是所有信息。

4.2 转移模型：在潜空间里推进时间

第二块是循环状态空间模型（RSSM），它是整个系统的核心。RSSM 维护两个状态：确定性隐状态h（由 GRU 更新，记住历史）和随机隐状态z（由分布采样得到，表达不确定性）。

每一步它同时算出两个分布：先验分布p(z|h)只看历史，后验分布q(z|h,o)还看了当前观测。训练时用后验（因为知道观测），推演时用先验（因为不知道未来观测）。两者之间的 KL 散度就是"模型对未来的预测有多不确定"的度量。

这个双分布设计是关键。如果只有先验，模型无法从观测中纠正自己；如果只有后验，推演时就没有可用的分布。KL 项的作用是让先验尽量贴近后验，这样推演时才不会跑偏。

4.3 奖励与终止预测：给想象空间装上评价标准

第三块是奖励头和终止头，它们从潜状态直接预测标量奖励和回合是否结束。没有它们，想象 rollout 就没有优化目标。

奖励预测的难度经常被低估。真实环境里的奖励可能有很大的动态范围，直接回归会导致梯度爆炸或数值不稳。常见做法是先做 symlog 变换（sign(x) * log(1 + |x|)），在压缩后的空间里做回归，使用的时候再反变换回来。DreamerV3 正是这么做的，这一步对跨任务稳定性影响很大。

4.4 想象 rollout 与策略优化：在潜空间里做演员-评论家

最后一块是把前三块串起来。从回放缓冲区里采样一批真实轨迹，用表征模型和转移模型算出起点状态，然后在潜空间里连续推演若干步：策略网络基于当前潜状态输出动作，转移模型给出下一个潜状态，奖励头给出即时奖励，终止头给出继续概率。

推演出序列之后，用 TD(lambda) 计算回报，再用它去更新演员和评论家。这里有个细节：评论家的训练目标是想象出来的回报，而想象是有偏的，所以评论家的价值估计本身也带偏。为了缓解这一点，成熟实现会混合真实数据里的回报来做校准。

5. 完整代码实现：一个可跑的 RSSM 世界模型骨架

这一节给出可复制的最小实现。为了让它能独立运行，观测用低维向量，环境用 Gymnasium 的连续控制任务。如果你要换成图像输入，只需要把编码器换成卷积网络，其余部分不用动。

5.1 配置文件

先把超参数集中管理，避免散落在代码里。

# 文件路径：wm_rl/configs/default.yaml env: name: Pendulum-v1 max_episode_steps: 200 data: capacity: 200000 seq_len: 32 # 训练世界模型时每条序列的长度 batch_size: 32 model: embed_dim: 64 deter_dim: 256 stoch_dim: 32 hidden_dim: 256 train: seed: 42 device: cuda warmup_steps: 5000 # 先用随机策略填充缓冲区 train_steps: 200000 world_model_lr: 3.0e-4 actor_lr: 8.0e-5 critic_lr: 8.0e-5 imagine_horizon: 15 # 想象 rollout 长度 gamma: 0.99 lambda_: 0.95 kl_free_bits: 1.0

imagine_horizon和kl_free_bits是两个最需要调的参数。前者太大策略会利用模型误差，太小信用分配不够；后者控制 KL 正则的松弛程度，太小会导致后验塌缩，太大则先验学不好。

5.2 RSSM 核心模块

# 文件路径：wm_rl/models/rssm.py import torch import torch.nn as nn import torch.nn.functional as F from torch.distributions import Normal class RSSM(nn.Module): """循环状态空间模型：维护确定性状态 h 和随机状态 z""" def __init__(self, action_dim, embed_dim=64, deter_dim=256, stoch_dim=32, hidden_dim=256): super().__init__() self.deter_dim = deter_dim self.stoch_dim = stoch_dim # 确定性转移：输入上一时刻的 z 和动作，更新 h self.gru = nn.GRUCell(stoch_dim + action_dim, deter_dim) # 先验：只看 h，不看当前观测 self.prior_net = nn.Sequential( nn.Linear(deter_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 2 * stoch_dim), ) # 后验：同时看 h 和观测嵌入 self.post_net = nn.Sequential( nn.Linear(deter_dim + embed_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 2 * stoch_dim), ) def initial_state(self, batch_size, device): h = torch.zeros(batch_size, self.deter_dim, device=device) z = torch.zeros(batch_size, self.stoch_dim, device=device) return h, z @staticmethod def _split_stats(x): mean, raw_std = torch.chunk(x, 2, dim=-1) std = F.softplus(raw_std) + 0.1 # 保证标准差为正且有下界 return mean, std def obs_step(self, prev_h, prev_z, prev_a, obs_embed): """训练阶段：同时用先验和后验""" h = self.gru(torch.cat([prev_z, prev_a], dim=-1), prev_h) prior_mean, prior_std = self._split_stats(self.prior_net(h)) post_mean, post_std = self._split_stats( self.post_net(torch.cat([h, obs_embed], dim=-1)) ) z = Normal(post_mean, post_std).rsample() stats = { "prior_mean": prior_mean, "prior_std": prior_std, "post_mean": post_mean, "post_std": post_std, } return h, z, stats def img_step(self, prev_h, prev_z, prev_a): """推演阶段：没有观测，只能用先验""" h = self.gru(torch.cat([prev_z, prev_a], dim=-1), prev_h) prior_mean, prior_std = self._split_stats(self.prior_net(h)) z = Normal(prior_mean, prior_std).rsample() return h, z, (prior_mean, prior_std)

关键在obs_step和img_step的区别。前者用于训练世界模型，能拿到观测所以用后验；后者用于想象 rollout，必须只用先验。如果误把obs_step用在推演里，就等于在想象时偷看了未来，训练出来的策略在真实环境里会完全失效——这是最常见也最难发现的错误之一。

5.3 世界模型整体封装

# 文件路径：wm_rl/models/world_model.py import torch import torch.nn as nn import torch.nn.functional as F from torch.distributions import Normal, kl_divergence from models.rssm import RSSM def symlog(x): return torch.sign(x) * torch.log1p(torch.abs(x)) def symexp(x): return torch.sign(x) * (torch.exp(torch.abs(x)) - 1.0) class WorldModel(nn.Module): def __init__(self, obs_dim, action_dim, embed_dim=64, deter_dim=256, stoch_dim=32, hidden_dim=256): super().__init__() self.embed_dim = embed_dim self.stoch_dim = stoch_dim self.encoder = nn.Sequential( nn.Linear(obs_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, embed_dim), ) self.rssm = RSSM(action_dim, embed_dim, deter_dim, stoch_dim, hidden_dim) self.decoder = nn.Sequential( nn.Linear(deter_dim + stoch_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, obs_dim), ) self.reward_head = nn.Sequential( nn.Linear(deter_dim + stoch_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 1), ) self.cont_head = nn.Sequential( nn.Linear(deter_dim + stoch_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 1), ) def feature(self, h, z): return torch.cat([h, z], dim=-1) def forward(self, obs, actions, dones, rewards, kl_free_bits=1.0): """obs: [B, T, obs_dim]，actions: [B, T, action_dim]""" B, T, _ = obs.shape device = obs.device embeds = self.encoder(obs) h, z = self.rssm.initial_state(B, device) obs_loss, reward_loss, cont_loss, kl_loss = 0.0, 0.0, 0.0, 0.0 hs, zs = [], [] for t in range(T): prev_a = torch.zeros(B, actions.shape[-1], device=device) if t == 0 else actions[:, t - 1] h, z, stats = self.rssm.obs_step(h, z, prev_a, embeds[:, t]) hs.append(h) zs.append(z) feat = self.feature(h, z) obs_loss = obs_loss + F.mse_loss(self.decoder(feat), obs[:, t]) reward_loss = reward_loss + F.mse_loss( self.reward_head(feat).squeeze(-1), symlog(rewards[:, t]) ) cont_loss = cont_loss + F.binary_cross_entropy_with_logits( self.cont_head(feat).squeeze(-1), 1.0 - dones[:, t] ) prior = Normal(stats["prior_mean"], stats["prior_std"]) post = Normal(stats["post_mean"], stats["post_std"]) kl = kl_divergence(post, prior).sum(-1).mean() kl_loss = kl_loss + torch.clamp(kl, min=kl_free_bits) scale = 1.0 / T total = (obs_loss + reward_loss + cont_loss) * scale + 0.1 * kl_loss * scale return { "loss": total, "obs_loss": obs_loss.item() * scale, "reward_loss": reward_loss.item() * scale, "cont_loss": cont_loss.item() * scale, "kl_loss": kl_loss.item() * scale, "hs": torch.stack(hs, dim=1), "zs": torch.stack(zs, dim=1), }

这段里有三处需要注意。第一，torch.clamp(kl, min=kl_free_bits)是 free bits 的简化实现，作用是允许 KL 在阈值以下时不产生梯度，防止后验过早塌缩到先验。第二，奖励用symlog后的空间做回归，但解码回来的时候要用symexp。第三，动作要对齐：第 t 步用的是 t-1 时刻的动作，因为转移模型描述的是"上一动作导致当前状态"。

5.4 演员-评论家与想象 rollout

# 文件路径：wm_rl/models/actor_critic.py import torch import torch.nn as nn from torch.distributions import Normal class Actor(nn.Module): def __init__(self, feat_dim, action_dim, hidden_dim=256, min_std=1e-3): super().__init__() self.min_std = min_std self.net = nn.Sequential( nn.Linear(feat_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 2 * action_dim), ) def forward(self, feat): mean, raw_std = torch.chunk(self.net(feat), 2, dim=-1) std = torch.nn.functional.softplus(raw_std) + self.min_std return Normal(torch.tanh(mean), std) def sample(self, feat): dist = self.forward(feat) action = dist.rsample() return action, dist class Critic(nn.Module): def __init__(self, feat_dim, hidden_dim=256): super().__init__() self.net = nn.Sequential( nn.Linear(feat_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, hidden_dim), nn.ELU(), nn.Linear(hidden_dim, 1), ) def forward(self, feat): return self.net(feat).squeeze(-1)

# 文件路径：wm_rl/train.py import argparse import torch import torch.nn.functional as F import yaml from torch.optim import Adam from models.world_model import WorldModel, symexp from models.actor_critic import Actor, Critic from utils.replay import ReplayBuffer from utils.envs import make_env def lambda_return(rewards, values, continues, gamma, lam): """在想象轨迹上倒序计算 TD(lambda) 回报""" horizon = rewards.shape[0] out = torch.zeros_like(rewards) acc = values[horizon] for t in reversed(range(horizon)): acc = rewards[t] + gamma * continues[t] * ( (1 - lam) * values[t + 1] + lam * acc ) out[t] = acc return out def imagine(wm, actor, critic, start_h, start_z, horizon, gamma, lam): """在潜空间里推演，返回特征、动作、回报""" feats = [wm.feature(start_h, start_z)] rewards, continues = [], [] h, z = start_h, start_z for _ in range(horizon): action, _ = actor.sample(feats[-1]) h, z, _ = wm.rssm.img_step(h, z, action) feat = wm.feature(h, z) feats.append(feat) rewards.append(symexp(wm.reward_head(feat).squeeze(-1))) continues.append(torch.sigmoid(wm.cont_head(feat).squeeze(-1))) values = torch.stack([critic(f) for f in feats], dim=0) rewards = torch.stack(rewards, dim=0) continues = torch.stack(continues, dim=0) returns = lambda_return(rewards, values, continues, gamma, lam) return torch.stack(feats[:-1], dim=0), torch.stack(rewards), returns, values def main(): parser = argparse.ArgumentParser() parser.add_argument("--config", default="configs/default.yaml") args = parser.parse_args() cfg = yaml.safe_load(open(args.config, "r")) torch.manual_seed(cfg["train"]["seed"]) device = torch.device(cfg["train"]["device"] if torch.cuda.is_available() else "cpu") env = make_env(cfg["env"]["name"]) obs_dim = env.observation_space.shape[0] action_dim = env.action_space.shape[0] wm = WorldModel(obs_dim, action_dim, cfg["model"]["embed_dim"], cfg["model"]["deter_dim"], cfg["model"]["stoch_dim"], cfg["model"]["hidden_dim"]).to(device) feat_dim = cfg["model"]["deter_dim"] + cfg["model"]["stoch_dim"] actor = Actor(feat_dim, action_dim).to(device) critic = Critic(feat_dim).to(device) wm_opt = Adam(wm.parameters(), lr=cfg["train"]["world_model_lr"]) actor_opt = Adam(actor.parameters(), lr=cfg["train"]["actor_lr"]) critic_opt = Adam(critic.parameters(), lr=cfg["train"]["critic_lr"]) buffer = ReplayBuffer(cfg["data"]["capacity"], obs_dim, action_dim, device) # 第一阶段：用随机策略填充缓冲区 obs, _ = env.reset(seed=cfg["train"]["seed"]) for step in range(cfg["train"]["warmup_steps"]): action = env.action_space.sample() nxt, reward, term, trunc, _ = env.step(action) buffer.add(obs, action, reward, float(term), float(trunc)) obs = nxt if term or trunc: obs, _ = env.reset() # 第二阶段：交替训练世界模型与策略 for step in range(cfg["train"]["train_steps"]): batch = buffer.sample_sequence(cfg["data"]["batch_size"], cfg["data"]["seq_len"]) out = wm(batch["obs"], batch["actions"], batch["dones"], batch["rewards"], cfg["train"]["kl_free_bits"]) wm_opt.zero_grad() out["loss"].backward() torch.nn.utils.clip_grad_norm_(wm.parameters(), 100.0) wm_opt.step() # 从后验状态出发做想象推演 h0 = out["hs"][:, -1].detach() z0 = out["zs"][:, -1].detach() feats, rewards, returns, values = imagine( wm, actor, critic, h0, z0, cfg["train"]["imagine_horizon"], cfg["train"]["gamma"], cfg["train"]["lambda_"], ) actor_opt.zero_grad() actor_loss = -returns.detach().mean() actor_loss.backward() torch.nn.utils.clip_grad_norm_(actor.parameters(), 100.0) actor_opt.step() critic_opt.zero_grad() critic_loss = F.mse_loss(values[:-1], returns.detach()) critic_loss.backward() torch.nn.utils.clip_grad_norm_(critic.parameters(), 100.0) critic_opt.step() if step % 1000 == 0: print(f"step={step} wm={out['loss'].item():.3f} " f"actor={actor_loss.item():.3f} critic={critic_loss.item():.3f}") if __name__ == "__main__": main()

这段代码里critic_loss = F.mse_loss(values[:-1], returns.detach())是关键细节。values长度是 horizon+1，最后一个是 bootstrap 用的，不参与评论家回归，所以要用[:-1]对齐。如果这里写错，训练会表现成评论家损失一直不降，但世界模型损失正常，很容易误判为模型问题。

buffer.sample_sequence和make_env是辅助模块，实现上就是标准的序列采样和 Gymnasium 包装，本文不展开。要注意dones里应该只放真实终止，不要把时间截断也算成终止，否则转移模型会学到错误的终止规律。

5.5 启动训练

# 文件路径：scripts/train.sh cd wm_rl python train.py --config configs/default.yaml

6. 运行结果与效果验证

训练开始后，你会看到三类输出，需要分别判断。

世界模型损失里的obs_loss应该在前几千步快速下降然后趋于平缓，reward_loss下降更快，kl_loss通常在 free bits 阈值附近波动。如果obs_loss一直不降，先检查编码器和解码器是否对称、观测是否做了归一化。如果kl_loss迅速掉到接近 0，说明后验塌缩了，先验没有学到东西，推演一定失败。

策略侧的现象更有意思。actor_loss是负的回报均值，它应该随着训练逐渐变得更负（回报更高）。如果它一直不变或者振荡，通常不是策略网络的问题，而是世界模型给的奖励信号太弱或者太噪。

判断世界模型质量最直接的方法是做开环预测对比：从一批真实轨迹里取起点，用世界模型推演 15 步，把重建的观测和真实观测逐帧比对，算 MSE。这个指标应该在 5 到 15 步之内保持较低水平，超过就说明模型只能支撑短视界推演。

更严格的验证是闭环评估：把训练好的策略放回真实环境跑若干个完整回合，看平均回报。这一步不能省。很多项目在这里翻车——想象里的回报曲线漂亮得不像话，真实环境里还不如随机策略。出现这种情况基本可以断定是模型利用，后面的排查章节会详细展开。

如果环境是图像输入，强烈建议定期把想象的画面解码出来存成图片或者拼成视频。这不是为了好看，而是最直观的诊断手段。想象画面越走越糊、或者出现明显伪影，说明模型在分布外推演时已经失控，此时的策略更新基本是在噪声上做优化。

7. 三类落地场景的差异：自动驾驶、机器人、LLM 智能体

标题里提到的三个方向，看起来都是"用世界模型替代真实交互"，但工程上的差别比想象中大得多。这一节按场景拆开讲。

7.1 自动驾驶：世界模型主要用来造数据和做闭环仿真

自动驾驶是最早也最舍得在世界模型上投入的领域，原因很直接：长尾场景太稀缺，真车采集成本太高，而且很多危险场景根本没法在现实中反复试。一个"鬼探头"场景可能要跑几十万公里才遇到一次，用世界模型把它生成出来，成本差着几个数量级。

Wayve 的 GAIA 系列是目前公开信息里比较有代表性的工作。它的思路是用大量驾驶视频训练一个生成式世界模型，然后用它做闭环仿真：给定一段历史，模型可以生成后续的多个可能未来，策略在这些未来里做决策。NVIDIA Cosmos 走的是更通用的路线，把世界基础模型做成可以适配多种下游任务的底座。DeepMind 的 Genie 系列则偏向可交互的虚拟环境生成。

这一类场景的关键难点有三个。第一是多智能体交互一致性，你生成的自车轨迹和其他车辆的行为必须互相自洽，不能出现两辆车穿模；第二是传感器一致性，如果模型只生成前视相机画面，那它无法支撑需要多摄像头融合的策略；第三是时序长期一致性，生成 3 秒和生成 30 秒的难度完全不是一个量级，而驾驶决策往往需要长时预测。

还有一个容易被忽略的点：自动驾驶的世界模型往往不是用来训练策略的，而是用来训练感知模块和做数据增广。这跟 Dreamer 那套"在潜空间里做策略优化"是两条完全不同的技术路径。如果你的目标是端到端策略，需要的是可微的、能提供梯度的世界模型；如果目标是生成逼真的测试场景，那生成式路线更合适。这两者经常被混为一谈。

7.2 机器人：最贴近 Dreamer 原始设定的场景

机器人操作和四足运动，是 Dreamer 系列最典型的应用场景。DayDreamer 这类工作直接把 Dreamer 部署到真实四足机器人上，让它自己采集数据、自己学世界模型、自己在想象中训练，整个过程不需要人工搭建精确的物理模型。

为什么机器人特别适合？因为机器人采样的成本结构很特殊。单次采样不贵，但需要人看着、需要充电、需要维护，而且硬件有磨损寿命。一个策略在真机上试错几万次，可能意味着几周的实验周期和不确定的硬件损耗。相比之下，GPU 上推演几百万步的成本可以忽略。

难点在于接触动力学和视觉域差异。机械臂抓取一个物体，接触瞬间的力学非常复杂，世界模型很难学准；相机画面在不同光照、不同背景下差异巨大，学到的潜状态容易过拟合到训练环境。所以机器人场景里一般会做两件事：一是尽量用本体感受（关节角度、力矩）而不是纯视觉做输入，降低表征难度；二是在真实环境里保留一定比例的在线采样，用真实数据持续修正模型。

另一个实践要点是安全性。想象 rollout 里策略可能学出非常激进的动作，这些动作在真机上执行会损坏硬件。所以从想象策略到真机部署之间，通常要加动作限幅、力矩限制、急停机制，并且先在低速低负载条件下验证。这一步不能因为"想象里已经很好"就跳过。

7.3 LLM 智能体：世界模型的概念在这里更模糊

到了 LLM 智能体这一块，"世界模型"这个词的含义就变得不太一样了。自动驾驶和机器人里的世界模型是一个神经网络，输入状态和动作输出下一个状态；而 LLM 智能体的"世界模型"，更多指的是对环境状态转移规律的预测能力——比如点击一个按钮后页面会变成什么样、调用一个 API 后返回什么结构的数据。

这个差异带来几个后果。第一，状态空间是离散的、高维的、不可微的，你没法像 RSSM 那样做梯度传播。第二，误差来源不同：机器人世界模型的误差来自物理建模不准，LLM 世界模型的误差主要来自幻觉——它会编造一个看起来合理的状态转移，而实际环境根本不是这样。第三，验证成本高，因为每次推演都涉及真实的 API 调用或者环境交互。

目前比较实用的思路是用 LLM 本身作为模拟器，在"沙盒"里推演动作后果，再用少量真实交互做校准。比如在网页操作、代码编辑这类任务里，可以先用模型预测"执行这一步会发生什么"，只有当预测置信度高的时候才真正执行。这类方法的公开研究里，共同结论是：LLM 预测的状态转移在短视界内可用，视界一长就开始编。所以工程上普遍采用"短推演 + 频繁真实校准"的策略。

对应用开发者的建议是：如果你在做 LLM 智能体，不要一上来就追求"完整的世界模型"。更现实的做法是把世界模型降级成一个动作后果预测器，只在关键决策点使用，并且必须保留人工兜底和回滚路径。涉及真实数据写入、资金操作、权限变更的动作，绝对不能只依赖模型预测就执行。

还有一个安全边界要强调：无论哪个场景，用世界模型生成的数据去训练策略，都必须经过真实环境验证才能上线。想象里表现好不等于真实可用，这一点在 LLM 智能体上尤其危险，因为幻觉产生的错误动作可能直接造成业务损失。

8. 常见问题与排查思路

世界模型训练的报错往往很隐蔽，因为损失函数在降，但策略就是不长。下面这个表覆盖了实践中最高频的几类问题。

表格里第一行值得单独展开。我在前面强调过obs_step和img_step的区别，但在实际代码里，很多人会把两者合并成一个函数，用一个training标志位切换。这种做法在重构时很容易出错，而且出错后现象极其隐蔽——损失正常、梯度正常、训练不报错，只是策略在真实环境里完全无效。更稳妥的做法是保留两个独立的函数，让调用点一眼能看出用的是哪一个。

第二行也是高频问题。想象视界设成 50 步，前 10 步的预测可能还很准，后面 40 步基本是噪声，策略在这些噪声上做优化，学到的就是如何最大化模型的错误。判断方法很简单：把 horizon 设成 5、15、30 分别训一次，看真实环境回报的变化曲线。如果 30 明显比 15 差，说明模型支撑不了那么长的推演，老老实实用 15。

第五行涉及数值稳定性。奖励的原始范围可能从 -1 到 1000，直接做 MSE 回归会让梯度极不稳定。symlog 变换能把这个范围压缩到对数尺度，是 DreamerV3 里非常关键的一个工程细节。同理，观测如果没做归一化，重建损失的梯度也会失衡。

9. 最佳实践与工程建议

这一节整理的是从项目落地角度出发的经验，偏工程侧，和具体算法选型关系不大。

数据质量比模型容量重要得多。很多人第一反应是把世界模型做大，参数翻倍、层数加深。但如果训练数据本身覆盖的场景有限，更大的模型只会更精确地记住那点数据，泛化反而更差。更有效的做法是保证数据覆盖足够的初始状态分布和动作分布，必要时做数据增广。

永远保留一条真实数据的通路。完全离线地训练世界模型、再完全离线地训练策略、最后直接上真机，这条路在实践中失败率很高。更稳妥的架构是：世界模型在线更新，策略在想象中训练，但每隔固定步数就用真实数据重跑一遍评估，发现偏差就回滚。这条真实通路既是校准手段，也是安全网。

想象视界从短开始，不要一上来就调大。短视界训练出来的策略保守但可靠，长视界训练出来的策略激进但容易崩。正确顺序是先跑通短视界、确认闭环评估有效，再逐步拉长，每次拉长都重新验证。

给关键超参数建立检查清单。世界模型这一套的参数耦合很紧，改一个往往要连带调另一个。建议固定几组经过验证的配置组合，每次实验只动一个变量，记录清楚。kl_free_bits、imagine_horizon、世界模型和策略的学习率比例，这三个是最需要小心维护的。

图像输入场景一定要做想象画面可视化。这不是锦上添花。图像的潜空间表征很难靠损失曲线判断好坏，唯一可靠的方式是把解码出来的画面拿出来看。想象画面在 5 步内还清晰、10 步开始模糊、20 步完全崩坏，这个衰减曲线直接决定了你的想象视界该设多少。

版本和依赖要锁定。世界模型的实现对 PyTorch 版本、CUDA 版本、随机数行为都比较敏感，同一份代码在不同环境下结果可能差很多。建议固定环境镜像，记录完整的依赖清单，否则复现实验会非常痛苦。

安全边界要写进代码，而不是写进文档。涉及真机控制的场景，动作限幅、力矩上限、急停条件应该在执行层硬编码，不能依赖策略网络自觉。想象 rollout 训练出来的策略完全可能输出超出物理极限的动作，这些动作在仿真里可能是合法的，在真机上会直接损坏设备。

9.1 什么时候不该用世界模型

最后这一点可能比前面所有建议都重要。世界模型不是万能的，有几类情况明显不适合引入。

第一，任务可以用精确的解析仿真器建模。棋类、简单的倒立摆、标准的控制基准任务，这些用现成仿真器又快又准，学一个世界模型等于在正确的答案外面再套一层近似，纯属增加复杂度。

第二，数据量本来就很充足。如果你的场景每天能产生海量真实交互数据，采样不是瓶颈，那世界模型带来的收益就很有限，反而增加了训练不稳定性和调参成本。

第三，评估本身就很难做。世界模型的价值完全依赖于"能不能可靠地判断策略好坏"。如果连真实环境里的评估都不稳定、方差极大，那你无法判断想象中的改进是真的还是假的，这条路就走不通。

第四，安全和合规要求极高，不允许试错。某些场景下任何未经充分验证的策略都不能上线，这时候世界模型只能用作离线分析工具，不能进入训练闭环。

判断标准其实很简单：先算清楚采样成本占整个项目的比重，再看模型误差能不能被控制住。如果采样成本极高而模型误差可控，那世界模型是划算的；如果采样成本一般，或者你根本没法验证模型误差有多大，那就老老实实用真实数据，把工程做扎实。

写到这里，回到开头那个判断：世界模型降低的是采样成本，抬高的是建模和验证成本。它不是让强化学习变简单了，而是把困难从"怎么采数据"转移到了"怎么保证模型可信"。这个转移值不值得，取决于你的项目里哪一头更贵。真正难的部分从来不是把 Dreamer 跑起来，而是建立一套能判断"想象里的好是不是真的好"的验证机制——这套机制建起来了，世界模型才真正可用。