阶段总览

周次	主题	交付物
第 1 周	世界模型概念、与 LLM 关系、三用途、代表路线	对比报告：Genie 3 / Dreamer / JEPA 路线差异
第 2 周	VLA 架构、代表工作、动作表示、控制回路	读 π0 / π0.5 / OpenVLA 并画结构图
第 3 周	数据、仿真环境、sim2real 与域随机化	机器人数据来源与采集成本分析
第 4 周	评测基准、泛化维度、2026 现状与决策判断	一份具身场景可行性评估报告
第 5–6 周	仿真中的决策 Agent（M12，可跳过）	在仿真环境里跑通感知-规划-执行的闭环

1. 世界模型：让 AI 学会“想象后果”

1.1 世界模型是什么：与 LLM 的关系

理解世界模型最好的起点，是把它和你已经熟悉的 LLM 放在同一张表里对比。LLM 训练目标是预测下一个 token，它建模的是「给定前文，下一个词是什么」；世界模型训练目标是预测下一个状态 / 下一帧画面，它建模的是「给定当前状态与某个动作，世界会变成什么样」。一句话：LLM 在语言的空间里做自回归，世界模型在物理 / 视觉的空间里做自回归。

维度	LLM（下一 token）	世界模型（下一状态）
预测对象	离散 token 序列（词表约 10^5 量级）	连续观测 / 状态（图像、物理量、点云）
训练目标	最大似然预测下一个词	预测动作之后的未来状态或画面
能否被动作驱动	否（被动生成，动作不是输入）	是（动作作为条件输入，可干预）
主要用途	对话、写作、推理、编码	想象未来、在内部规划、合成训练数据
典型失败	幻觉、事实错误、推理不自洽	物理不一致、可控性差、长程漂移
可交互性	只能对话，不能改变环境	可作为可导航的交互式世界

一个常用的判别标准：如果你只能看，那是视频生成；如果你能干预并且结果会相应改变，那是世界模型。世界模型的核心不是画面逼真，而是「能够接受动作作为条件、预测行动之后世界的下一个状态」——也就是说，它从「渲染器」升级为「规划器」。注意：能生成视频不等于能规划，规划要求模型里显式地存在一个「动作 → 状态」的动力学。

python# 模型-based RL 的核心思想：用学到的世界模型在「想象」中做 rollout，
# 而不必在真实环境里一步一步试错——这正是世界模型相对 LLM 的关键价值。
import torch

class LatentWorldModel(torch.nn.Module):
    """Dreamer 风格：在潜空间里预测未来，而非逐像素生成。
       关键组件：
         表示模型  p(s_t | s_{t-1}, a_{t-1}, o_t)  把观测压成状态
         动力学模型 q(s_t | s_{t-1}, a_{t-1})       状态转移（不含观测）
         奖励模型  r(s_t)                           预测即时奖励
         折扣因子  gamma（典型 0.99）"""
    def __init__(self, dim_s=256, dim_a=8, gamma=0.99):
        super().__init__()
        self.dynamics = torch.nn.Sequential(
            torch.nn.Linear(dim_s + dim_a, 512), torch.nn.ELU(),
            torch.nn.Linear(512, dim_s))
        self.reward = torch.nn.Linear(dim_s, 1)
        self.gamma = gamma

    def rollout(self, s0, actions, horizon=15):
        """从初始潜状态 s0 出发，按候选动作序列想象未来 horizon 步。
           返回想象的奖励轨迹 —— 规划器用它挑选最优动作序列。"""
        s, traj = s0, []
        for a in actions:                       # actions: [horizon, dim_a]
            s = self.dynamics(torch.cat([s, a], dim=-1))
            traj.append(self.reward(s).item())
        return traj                              # 长度 = horizon 的想象奖励

# 把想象轨迹按 gamma 折扣求和，即为该动作序列的期望回报
def imagined_return(wm, s0, actions):
    r = wm.rollout(s0, actions, horizon=15)
    returns = []
    for t in range(len(r)):
        tail = r[t:]
        disc = [wm.gamma ** i for i in range(len(tail))]
        returns.append(sum(x * d for x, d in zip(tail, disc)))
    return max(returns)                          # 取想象中最优累计回报

python# 最小可运行的「世界模型」：一维质点动力学，学一个 action -> next_state 的动力学
# 目的：证明世界模型的核心是「动作条件化」，而不是画面逼真度。
import numpy as np
rng = np.random.default_rng(0)

def true_dynamics(s, a, dt=0.1, damp=0.1):
    # s=[pos, vel]；a=加速度；半隐式欧拉积分
    pos, vel = s
    vel = vel * (1 - damp) + a * dt
    pos = pos + vel * dt
    return np.array([pos, vel])

# 用「真实环境」采样 2000 条 (s, a, s_next)，最小二乘拟合线性动力学 W
X, Y = [], []
for _ in range(2000):
    s = rng.normal(0, 1, 2); a = rng.normal(0, 0.5)
    X.append(np.r_[s, a]); Y.append(true_dynamics(s, a))
X, Y = np.array(X), np.array(Y)
W, *_ = np.linalg.lstsq(X, Y, rcond=None)          # 学到的世界模型
print("MAE =", round(float(np.abs(X @ W - Y).mean()), 4))
# 预期输出：MAE ≈ 0.0005 —— 线性动力学下几乎完美拟合。
# 关键对比：若把动作 a 从输入去掉，模型对同一 s 只能给出同一个 s_next，
#   无法回答「推它一下会怎样」，也就不能规划。
# 世界模型与 LLM 的分界线正在于此：动作是输入，输出是「动作之后的世界」。

1.2 三种用途：预测 / 规划 / 仿真

同一个世界模型，在工程里通常被当作三种不同的工具使用。它们的产出不同、失败模式不同，落地时的考量也完全不同。

用途	做什么	代表方法	产出	局限
预测（想象未来）	给定当前状态，生成未来若干帧 / 状态	视频扩散、Genie / Genie 3	未来画面或状态序列	长程易漂移、误差累积
规划（rollout）	在模型内部试动作，挑选最优序列	Dreamer、model-based RL	最优动作序列 / 价值估计	模型误差会被当作真实，误导规划
仿真（生成数据）	批量生成带标签的训练轨迹	Cosmos、世界模型合成	机器人训练数据	需校验物理合理性，否则学到假规律
安全校验	在执行前预判结果，拦截危险动作	动作条件生成 + 规则	风险评分 / 否决	依赖模型对危险的可辨识度

python# 规划用途最小演示：用世界模型在「想象」里比较候选动作序列，再择优执行
gamma, H = 0.9, 5
def dyn(s, a):                       # 简化动力学：s=(pos, vel)
    pos, vel = s
    vel = vel * 0.9 + a * 0.1
    return (pos + vel * 0.1, vel)
def imagine_return(s0, actions):
    s, ret = s0, 0.0
    for t, a in enumerate(actions):
        s = dyn(s, a)
        ret += (gamma ** t) * (-abs(s[0]))     # 奖励：越靠近原点(pos=0)越好
    return ret

cands = [[0.0]*H, [-0.5]*H, [0.5]*H]           # 三条候选计划
print("想象回报:", [round(imagine_return((1.0, 0.0), c), 3) for c in cands])
# 预期输出：想象回报: [-4.095, -3.978, -4.212]
# argmax -> 第二组（持续 a=-0.5，把 pos 拉回原点），这就是 model-based 规划。
# 量级：一次规划只花 H=5 次前向；若在真机试 5 步，可能就要几十秒 + 硬件损耗。
# 现实提醒：世界模型不准时，规划会沿错误方向优化（误差不进真实世界，但决策会错）。

1.3 代表路线：Genie 3 / Dreamer / JEPA

2026 年世界模型领域三条主流路线，本质分歧在于「预测发生在哪个空间、是否可交互、训练数据要什么」。

路线	代表	预测空间	可交互	训练数据	最适用
自回归帧预测	Genie / Genie 3	像素 / 隐空间帧	是（实时导航）	游戏 / 视频	交互式环境、游戏仿真
潜空间想象	Dreamer V3/V2	潜变量状态	是（RL rollout）	像素观测	样本高效 RL、控制
联合嵌入预测	JEPA / I-JEPA	抽象表征	否（不生成）	图像 / 视频自监督	表征学习、高效预测底座
推理 + 生成	Cosmos	多模态 token	是（动作条件）	文本/图像/视频/动作	合成数据、机器人训练

python# 三条路线的算力直觉：预测空间的「维度」决定单步预测的成本量级
pixel_tokens_per_frame = 4096    # 720p 经 patch 化后的近似 token 数/帧
latent_dim = 512                 # 潜状态 / JEPA 表征维度
H = 50                           # 规划视界
print("帧预测 rollout 输出 token:", pixel_tokens_per_frame * H)   # 204800
print("潜空间 rollout 输出维度:", latent_dim * H)                  # 25600
print("量级比:", round(pixel_tokens_per_frame * H / (latent_dim * H), 1))  # 8.0
# 结论：同视界下帧预测的输出量级比潜空间大近一个数量级（此处 8x），
#   还要额外解码像素并维持长程一致性，成本更高；
#   因此高频闭环规划优先潜空间 / JEPA，要可交互演示才选帧预测。
# 提示：World Labs 的 Marble（2025 末）走的是「3D 一致场景生成」，
#   强调可编辑、可导出的三维世界而非逐帧 2D 视频，是帧预测之外的第三条产物形态。

1.4 世界模型的评测方式：一致性 / 可控性 / 物理合理性

世界模型不像分类任务有天然标签，评测必须拆成多个维度。2026 年社区逐渐形成的共识是：单看「画面好不好看」毫无意义，要看它作为「规划器 / 仿真器」是否可信。

指标	测什么	怎么测	常用做法
一致性	帧间物体身份 / 位置不跳变、不凭空出现消失	跟踪物体 ID 存活率、光流连贯性	一致性评分、Video consistency metric
可控性	给定动作后状态按预期改变	动作-状态因果准确率、干预实验	固定动作序列看结果是否确定性变化
物理合理性	符合重力、碰撞、刚性与因果	物理规律违反计数（穿模、反重力）	Physics-IQ、物理推理基准
时序稳定性	长序列不崩溃、不重复、不静默	平均无故障步数、重复帧比例	长程 rollout 测试
泛化到未见动作	没见过的动作组合也能合理预测	留出动作组合做 OOD 测试	组合泛化基准

python# 世界模型评测的核心指标：一致性 / 可控性（用玩具轨迹演示）
import numpy as np
pred = np.array([[0,0],[1.0,0.1],[2.1,0.2],[3.3,0.25]])   # 预测轨迹 [T,2]
gt   = np.array([[0,0],[1.0,0.0],[2.0,0.0],[3.0,0.0]])    # 真值轨迹

def jump_rate(pred, thresh=1.3):
    d = np.linalg.norm(np.diff(pred, axis=0), axis=1)     # 相邻帧位移
    return float((d > thresh).mean())                     # 跳变率，越低越好

def traj_error(pred, gt):
    return float(np.linalg.norm(pred - gt, axis=1).mean()) # 同动作下与真值偏差

print("跳变率:", jump_rate(pred))                    # 0.0（thresh=1.3，此例无跳变）
print("轨迹误差:", round(traj_error(pred, gt), 3))   # 0.179
# 一致性看「物体不凭空跳变 / 消失」，可控性看「给同一动作是否稳定复现」，
# 物理合理性看「是否违反重力 / 碰撞」。三者必须分开测，不能只看画面好看。

1.5 为什么 2026 年世界模型重新变重要

世界模型并不是新概念（2018 年的《World Models》论文就提出了），但它在这几年几起几落。2026 年它重新成为焦点，是四个因素叠加的结果。

驱动因素	说明	带来的效果
视频生成质量跨越临界点	Sora / Genie 3 级别的画面已经可交互、可导航	世界模型从「玩具」变成「可用工具」
VLA 需要可规模化的数据	真实机器人数据很贵，一条高质量示范可能要 5–20 美元	世界模型成为低成本「数据工厂」
长程规划需求上升	机器人与自动驾驶要提前想好几步，而非一步一动	model-based 规划范式回潮
算力与架构成熟	扩散模型与 Transformer 已能实时运行	实时可交互世界在端侧 / 云端可行

python# 世界模型作为「数据工厂」的收益量化：为什么 2026 年它成为热点
real_traj_cost = 12            # 一条高质量真实遥操作示范约 5–20 美元，取 12
need = 200_000                 # 训练一个 VLA 需要的数据量级
print("全真机采集成本(美元):", need * real_traj_cost)     # 2400000
# 预期输出：2400000（约 240 万美元），且采集周期以月计。
# 换用世界模型合成同规模：算力成本约几万美元量级 + 物理校验，
# 这就是「用世界模型造数据」的直接经济动因。
# 但合成数据必须过物理合理性校验，否则学到假规律、迁移必失败。

1.6 动手练习与自测

1. 用 1.1 的 lstsq 代码训练一维动力学世界模型；再把输入里的动作 a 去掉重训一次，比较 MAE 与「能否回答反事实问题」。
2. 把 1.2 的想象规划改成 H=10、gamma=0.99，观察最优候选是否改变，并解释 gamma 越大越看重远期收益的机制。
3. 给 1.4 的玩具轨迹手工构造一条「物体凭空跳变」的预测，验证跳变率指标能否从 0 升到 > 0。
4. 一句话说明：预测能力强为什么不等价于规划能力强？
5. Genie 3、Dreamer、JEPA 分别在什么空间做预测？各自最适合什么用途？
6. 世界模型当「数据工厂」时，为什么必须先做物理合理性校验？
7. 要做闭环高频规划，为什么潜空间 / JEPA 往往比逐帧生成更省算力？

题号	考点	关键判据 / 参考答案
1	动作条件化	含 a 的 MAE ≈ 0.0005；去掉 a 后同一状态预测唯一，无法做反事实与规划
2	折扣因子	gamma=0.99 时远期奖励权重显著变大，最优候选可能从「立刻拉回」变为「先规划更远」
3	一致性指标	人为让某一帧位置跳变 > 阈值，跳变率由 0 升为 1/T
4	预测 vs 规划	预测只要求逼真；规划要求「输入动作 A 必然得到状态 B」的确定性因果，不可控的生成模型不能当规划器
5	路线差异	Genie 3 在像素/隐空间帧自回归、可交互导航；Dreamer 在潜变量状态空间做动力学，适合样本高效 RL 与控制；JEPA 在抽象表征空间预测、不生成
6	合成数据风险	合成轨迹若偏离真实物理分布，策略学到假规律，sim-to-real 时整体失效
7	算力量级	同视界下帧预测输出 token 量级比潜状态大近一个数量级（示例 4096×H vs 512×H），且需解码像素与维持一致性

2. VLA：端到端视觉-语言-动作模型

2.1 架构三段式：视觉编码 + LLM 主干 + 动作头

过去机器人控制是「感知 → 规划 → 控制」的模块化流水线，每个模块独立开发，误差逐级累积。2026 年，VLA 端到端架构成为主流：输入像素与文字指令，直接输出动作信号，中间的黑盒由神经网络自动学习。本质价值是让泛化能力从架构中自然涌现——大模型在语言领域验证过的缩放律，开始在物理世界起作用。

python# VLA 的典型结构：视觉骨干 + 语言骨干 + 流匹配动作头
import torch, torch.nn as nn

class SimpleVLA(nn.Module):
    def __init__(self, d_vision=1024, d_lang=2048, d_fuse=1024, action_dim=7, chunk=16):
        super().__init__()
        self.vision  = nn.Linear(d_vision, d_fuse)     # 实际是 ViT / SigLIP
        self.lang    = nn.Linear(d_lang, d_fuse)       # 实际是 LLM 的隐藏状态
        self.fuse    = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_fuse, 8, batch_first=True), num_layers=6)
        # action chunk：一次预测未来 chunk 步动作，显著降低误差累积
        self.action_head = nn.Sequential(              # 实际用 flow matching / 扩散
            nn.Linear(d_fuse, d_fuse), nn.SiLU(),
            nn.Linear(d_fuse, chunk * action_dim))

    def forward(self, vis_feat, txt_feat):
        # 交叉模态融合：图像 token 与语言 token 在同一序列里做注意力
        x = self.fuse(torch.cat([self.vision(vis_feat), self.lang(txt_feat)], dim=1))
        pooled = x.mean(dim=1)                         # 简化：实际会用专门的动作查询 token
        return self.action_head(pooled)                # 输出未来 chunk 步的动作序列

# 关键概念：action chunk（一次预测多步动作）显著提升长时程任务成功率，
# 因为它避免了逐步预测的误差累积与推理延迟瓶颈（chunk=16 步 × 7 维）。

• 视觉骨干：通常是 ViT 或 SigLIP，输入 2–4 路相机视图，分辨率 224×224 或 336×336，频率 10–50Hz。
• 语言骨干：LLM（如 LLaMA / Gemma / Qwen 系）提供语义与任务理解，取最后一层隐藏状态作为条件。
• 动作头：流匹配或扩散模型，输出平滑的轨迹或关节力矩；常见做法是一次预测一段动作（action chunk，典型 8–50 步）。
• 组合泛化的意义：模型见过「抓红杯子」和「如果杯子烫就用夹子」之后，无需为组合单独训练即可处理新情形——这被称为机器人领域的「GPT-3 时刻」。

python# action chunk 为什么能救长程任务：把「每步都推理」的延迟放大算清楚
control_hz = 10          # 机械臂控制频率 10Hz -> 控制周期 100ms
infer_ms = 60            # VLA 一次前向 60ms
chunk = 16               # 一次预测未来 16 步动作
per_step_mode = infer_ms                 # 逐步推理：每步都要一次前向
chunk_mode = infer_ms / chunk            # chunk：16 步只推理一次，摊到每步
print("逐步推理每步延迟(ms):", per_step_mode)            # 60
print("chunk 模式每步延迟(ms):", round(chunk_mode, 2))   # 3.75
print("延迟比:", round(per_step_mode / chunk_mode, 1))    # 16.0
# 结论：chunk=16 把每步有效推理延迟摊薄 16 倍，从「远超控制周期」变成「远低于」。
# 代价：chunk 越大越平滑，但对环境突变响应越迟钝（chunk 太大 = 动作变笨）。
# 经验区间：chunk 常取 8–50 步（π0 用 ~50，灵巧任务常用 16–32）。

2.2 代表工作：RT-1/RT-2、OpenVLA、π0/π0.5、Gemini Robotics

模型	机构	主干	动作表示	特点
RT-1	Google	PaLI / EfficientNet + FiLM	离散动作 token	22k 机器人示范端到端，实时部署到真实机械臂
RT-2	Google	PaLM-E 视觉-语言-动作	联合嵌入动作	把网络知识蒸馏进动作，零样本泛化到新物体 / 新指令
OpenVLA	社区	Prismatic + LLaMA	连续动作回归	7B 开源基线，第一次让个人能跑通 VLA 推理
π0	Physical Intelligence	VLM + flow matching	连续 flow 头	跨本体预训练，组合泛化，灵巧任务表现强
π0.5	Physical Intelligence	π0 + 显式推理	flow + 推理	针对更难的灵巧 / 移动操作，引入推理链提升长程
Gemini Robotics	Google DeepMind	Gemini 多模态	连续动作	长程任务、安全约束、跨 embodiment 适配

一个值得记住的范式转移：RT-2 证明了「互联网规模的视觉-语言知识」可以直接迁移到动作空间——你可以用自然语言描述一个它从没被示范过的任务，它凭借世界知识去执行。π0 / π0.5 则把重点放到「动作头的连续化」与「跨本体」：同一套权重可以驱动不同构型的机械臂，适配新本体只需几十到上百条示范。2026 年，「预训练融入海量异构数据 + 少量人类示范快速适配」已成为可行的技术路线。

模型	参数量级	动作表示	动作 chunk	数据规模（量级）
RT-2	55B（PaLI-X）级	离散 token	1（逐步）	数十万机器人 episode
OpenVLA	7B	连续（7 维回归）	1	约 97 万条真实机器人演示
π0	~3B	连续 flow	~50	跨多本体、上万小时异构数据
π0.5	~3B	flow + 显式推理	~50	加推理链以提升长程灵巧任务
Gemini Robotics	10B+（未公开）	连续动作	多步	多模态 + 长程 + 安全约束

2.3 动作表示：离散 token vs 连续 flow matching / 扩散头

动作如何被「写进」模型，是 VLA 设计里最微妙的决定之一。它直接决定模型能表达的动作粒度、训练稳定性和能否处理多模态动作分布。

表示方式	做法	优点	缺点	适用
离散动作 token	把连续动作量化成 codebook 索引，用自回归生成	可直接借用 LLM 的自回归机制，训练稳	量化误差、codebook 崩塌、动作不平滑	低维、离散或可离散化的动作
连续动作回归	直接回归动作向量（MSE 损失）	简单、快	单峰、无法表达多模态（同一观测多种合理动作）	简单控制、单峰场景
flow matching / 扩散头	学习把噪声推向真实动作分布的向量场	多模态、平滑、高维友好	需多步采样，推理慢数倍	灵巧操作、高自由度、7–20 维动作
混合	粗动作离散 + 细动作连续	兼顾效率与精度	实现复杂	工业落地常见折中

python# 连续动作用 flow matching / 扩散头生成（而非离散 token）
# 思想：学习一个把噪声「推」向真实动作分布的向量场 v(x, t)
import torch

def flow_matching_sample(net, cond, action_dim, steps=10, sigma_min=1e-3):
    """从噪声出发，沿学习到的向量场积分得到动作。
       cond = 视觉 + 语言融合后的上下文表示（一个向量）。"""
    x = torch.randn(1, action_dim)                  # 起点：纯噪声
    ts = torch.linspace(1.0, sigma_min, steps)      # 从 t=1 收敛到 t=0
    with torch.no_grad():
        for i in range(steps - 1):
            t = ts[i].expand_as(x)
            v = net(x, t, cond)                      # 预测当前位置的速度场
            dt = ts[i + 1] - ts[i]                   # 负步长（向 t=0 收敛）
            x = x + dt * v                            # 欧拉积分一步
    return x.clamp(-1, 1)                            # 动作通常归一化到 [-1, 1]

# 与离散 token 对比：连续头直接输出 7 维关节角速度，
# 无需把动作量化成 codebook，避免了量化误差与 codebook 崩塌；
# 代价是多步采样（通常 8–16 步 ODE / 欧拉），比单步回归慢。

python# 离散动作 token 的量化误差：256 个 bin 已经是「很细」的切分
import numpy as np
bins = 256
centers = np.linspace(-1, 1, bins)        # 把 [-1,1] 归一化动作切成 256 档
x = np.random.default_rng(1).uniform(-1, 1, 200000)
err = np.abs(centers[np.abs(x[:, None] - centers[None, :]).argmin(1)] - x)
print("最大量化误差:", round(float(err.max()), 5))     # 0.00392
print("平均量化误差:", round(float(err.mean()), 5))    # 0.00196
# 单看数值很小，但灵巧操作连续 50 步、每步都量化、误差还会累积；
# 且离散化把「多模态连续分布」硬切成若干点，动作不平滑。
# flow matching / 扩散头直接建模连续分布，代价是多步采样（通常 8–16 步）。

2.4 动作频率与控制系统回路

这是 VLA 落地最被低估、却最致命的工程约束：推理延迟必须低于控制周期，否则系统不稳定甚至发散。一个 1 秒才出一次动作的模型，不可能去稳定一个 5ms 就要调一次的机械臂。

系统	控制周期	对推理延迟的要求	现实做法
工业机械臂	1–10 ms	远低于控制周期（亚毫秒级闭环）	高频控制交给本地轻量策略，模型只做低频规划
人形平衡	1–5 ms	亚毫秒级的反射级响应	S1「小脑」高频（50–200+ Hz），S2 大脑低频
移动机器人	50–100 ms	低于 50 ms	S2 规划 1–5 Hz，控制 20–50 Hz
视觉伺服抓取	10–30 Hz	低于 33 ms（即一帧内）	延迟超过周期则跟踪失稳、目标跟丢
自动驾驶	10–100 ms	低于控制周期	感知-规划-控制分频，安全关键回路本地化

工程上的标准解法是双系统 / 双频：把慢而聪明的大模型（VLM，跑规划，1–5 Hz）与快而精准的轻量策略（视觉运动网络，50–200+ Hz）解耦。大模型负责「想清楚下一步干什么」，轻量策略负责「在毫秒级把动作做平滑、做稳定」。这正呼应了 2.5 节的双系统架构。

python# 落地的第一道算术题：推理延迟 vs 控制周期
def feasible(control_hz, infer_ms, safety=1.0):
    period = 1000 / control_hz                 # 控制周期(ms)
    return infer_ms <= period * safety, period
ok, period = feasible(control_hz=100, infer_ms=80)   # 100Hz 机械臂
print("控制周期(ms):", period, "可行:", ok)             # 10.0 False
ok2, _ = feasible(control_hz=10, infer_ms=80)
print("10Hz 可行:", ok2)                                # True
# 结论：80ms 的模型在 10Hz(100ms) 勉强可行，在 100Hz(10ms) 完全不可行。
# 工程解法：高频闭环交给 50–200Hz 的本地小策略，大模型只做 1–5Hz 的规划。

# 2026 现实参数参考：π0 级模型单次前向常为几十 ms；RT-2(55B) 更慢，
# 因此真正上产线的 VLA 都要么降频做规划、要么配一个高频执行器。

2.5 双系统架构：慢思考 + 快控制

人形机器人等高自由度、需实时平衡的系统普遍采用双系统架构：S2「大脑」是慢而聪明的 VLM，负责场景理解、任务规划与复杂推理，运行频率低；S1「小脑」是快而精准的视觉运动策略，负责几十赫兹的高频动作控制与平衡微调。

系统	职责	频率	典型技术
S2 大脑	任务理解、规划、异常处理	1–5 Hz	VLM / LLM + 长程规划
S1 小脑	动作生成、平衡、力控	50–200+ Hz	视觉运动策略 / VLA 动作头
世界模型	预测动作后果，做安全校验与子目标生成	按需调用	动作条件生成、潜空间预测
记忆与状态	任务进度、已尝试动作、失败记录	持续	结构化状态机 + 向量记忆

1 秒内的时间片	S2 大脑（1–5Hz）	S1 小脑（50–200Hz）	世界模型（按需）
0–200ms	解析指令、规划子目标	执行约 10–40 次平衡微调	—
200–400ms	检查进度、决定下一步	继续高频控制	预判「推一下是否会倒」
400–800ms	异常处理 / 重新规划	持续闭环	—
800–1000ms	更新任务状态记忆	持续闭环	按需安全校验

2.6 动手练习与自测

1. 某 VLA 单次前向 45ms，机械臂控制 20Hz。它能否独立闭环？若不能，给出两种工程解法。
2. 把 2.1 的 action chunk 从 16 改到 50，重新计算每步有效延迟，并说明它对「响应突变」的影响。
3. 为什么说 RT-2 是机器人领域的「GPT-3 时刻」？它证明了什么可以迁移到什么？
4. 离散动作 token 在什么维度 / 什么任务上会明显吃亏？连量化误差量级一起说明。
5. 双系统里 S2 与 S1 的分工依据是什么？为什么不用一个模型全干？
6. π0 与 OpenVLA 的关键差异（动作表示、chunk、数据配方）是什么？
7. 什么情况下你会给 VLA 配一个「世界模型做安全校验」？

题号	考点	关键判据 / 参考答案
1	延迟预算	控制周期 50ms，45ms 勉强可行但无余量；解法：外挂高频策略 / 降频做规划 / 换更小模型
2	chunk 权衡	90ms/50≈1.8ms 每步；chunk 越大延迟越省，但对环境突变响应越迟钝
3	范式转移	证明了互联网规模的视觉-语言知识可直接迁移到动作空间，零样本执行未示范任务
4	离散化代价	高维（7–20 维）、多模态灵巧任务；256 bin 最大量化误差 0.00392、均值 0.00196，且逐步累积
5	双系统依据	规划需大模型与世界知识（慢贵），控制需毫秒响应（快轻），需求矛盾，强行统一两头不讨好
6	代表工作对比	π0 连续 flow + chunk≈50 + 跨本体异构数据；OpenVLA 7B 连续回归、chunk=1、约 97 万条演示
7	安全校验	高风险 / 不可逆动作前，用动作条件世界模型预判结果拦截危险，再落真机

3. 数据、仿真与 sim2real

3.1 数据来源：遥操作 / 人类视频 / 仿真

来源	方式	规模 / 成本	优点与局限
遥操作	人手操控机械臂 / 机器人采集	成本高、速度慢（约 5–20 美元 / 条）	真实、质量高；难以规模化
动捕数据	亚毫米级光学动捕采集人类动作	可到万小时级	动作质量好；需重定向到不同本体
仿真数据	物理引擎 + 域随机化	可无限生成	便宜、可控；存在 sim-to-real 差距
人类视频	互联网人类操作视频	规模巨大（十亿级帧）	无动作标签，需从视频推断动作（video to action）
合成数据	用世界模型生成轨迹与场景	成本中等	2026 年热点；需校验物理合理性
真实部署日志	机器人在真实环境长时间运行	最有价值	含真实故障与边界情况；获取慢

python# 三种数据源的规模与成本量级：判断「该自采、买、还是拿视频」
sources = {
    "遥操作":   {"unit_cost_usd": 12,   "scale": 1e4,  "note": "真实但难规模化"},
    "仿真":     {"unit_cost_usd": 0.01, "scale": 1e7,  "note": "便宜可控，有 sim2real gap"},
    "人类视频": {"unit_cost_usd": 0.0,  "scale": 1e10, "note": "海量但无动作标签"},
}
for k, v in sources.items():
    print(k, "规模量级:", v["scale"], "单条成本:", v["unit_cost_usd"], v["note"])
# 预期输出（量级）：
#  遥操作   规模量级 10000.0 单条成本 12   真实但难规模化
#  仿真     规模量级 1e7     单条成本 0.01 便宜可控，有 sim2real gap
#  人类视频 规模量级 1e10    单条成本 0.0  海量但无动作标签
# 结论：真实数据最贵最稀缺（~12 美元/条），视频最便宜但缺动作标签 ->
#   2026 的解法是「视频预训练 + 少量真机动作对齐」。

人类视频学习是 2026 年增长最快的数据方向：互联网上有海量人类操作视频，成本几乎为零，但难点在于「视频里没有动作标签」。常见做法有三类：① 用遥操作数据训练一个逆向动力学模型（IDM），把视频帧对映射成动作；② 直接用视频做预训练，只在最后用少量真实动作做对齐；③ 用世界模型把视频续写成带动作的轨迹。2026 年的标志性做法是预训练融入海量异构数据 + 少量人类示范的快速适配：某些模型在适配新本体时只需 50–100 条人类示范；另一类预训练融入数万小时真实物理数据，覆盖十几个品牌、二十余种构型。

3.2 仿真环境：MuJoCo / Isaac Sim / LIBERO / RoboSuite

动手做具身，几乎一定要从仿真起步。仿真让你以零成本获得无限带标签数据、可重复的实验、以及不担心撞坏硬件的安全空间。

仿真器	特点	最适用	速度量级
MuJoCo	刚体接触快、数值稳定、API 简洁	机械臂 / 腿足控制、算法研究	快（万步 / 秒级，CPU）
Isaac Sim / Lab	GPU 大规模并行、照片级渲染、数字孪生	大规模 RL、Sim2Real、工厂场景	中（需 GPU，可并行千环境）
LIBERO	内置 130+ 操作任务基准与语言标注	操作策略评测、方法对比	中
RoboSuite	模块化、易扩展、任务定义灵活	算法原型、新任务快速搭建	中
SimplerEnv	把仿真策略映射到真实机器人做评测	Sim2Real 泛化测试	中

python# 仿真环境的最小闭环：以 LIBERO / robosuite 风格为例
import numpy as np

class PickEnv:
    """一个抽象出来的抓取环境接口（真实用 MuJoCo / Isaac Lab）。
       关键：观测空间、动作空间、奖励、终止条件都要明确定义。"""
    obs_dim  = 24        # 关节角 + 末端位姿 + 目标相对位置
    act_dim  = 7         # 6 自由度末端 + 夹爪开合
    max_steps = 200      # 单回合最大步数（决定 episode 长度）

    def __init__(self):
        self.t = 0; self.state = self.reset()

    def reset(self):
        self.t = 0
        return np.zeros(self.obs_dim)            # 实际从仿真器采样初始状态

    def step(self, action):
        # 动力学：action 施加到仿真器，返回新观测 + 奖励 + 终止标志
        self.t += 1
        done = self.t >= self.max_steps
        reward = self._sparse_reward()           # 稀疏奖励：只有抓到才给 1
        return self._observe(), reward, done, {}

    def _sparse_reward(self):
        return 1.0 if self._gripper_hold() else 0.0

python# MuJoCo / Isaac Lab 的吞吐量级：决定「一晚上能采多少数据」
mujoco_steps_per_sec = 1e6      # 简单场景单核可达百万步/秒量级（CPU）
isaac_envs = 4096               # Isaac Lab 单卡并行环境数
isaac_hz = 60                   # 每环境 60Hz
print("Isaac Lab 单卡每小时步数:", f"{isaac_envs * isaac_hz * 3600:.0e}")
# 预期输出：8.8e+08（约 8.8 亿步/小时）
# 即单卡一小时产生近 9 亿步交互，相当于真实机器人跑几百年。
# 但注意：这只换来「仿真里的经验」，要过 sim2real 才算数。

3.3 sim2real 差距与域随机化

sim2real（仿真到真实）是具身智能永恒的难题。差距主要来自四个来源，每一个都有对应的缓解手段。

差距来源	在真实世界的表现	缓解手段
视觉差距	纹理、光照、摄像头参数、遮挡与仿真不一致	域随机化（外观 / 光照 / 相机）、仿真域自适应、真实图混合训练
动力学差距	质量、摩擦、阻尼、刚度不准	参数随机化、系统辨识（真实数据反推参数）、在线适应
传感噪声	真实传感器噪声远大于仿真	训练时注入噪声、用真实噪声分布做数据增强
延迟与丢帧	真实控制有延迟、相机掉帧	随机延迟训练、时序模型容忍丢帧
未建模物理	柔性物体、液体、接触非线性	更高保真仿真、真实数据补位

python# 域随机化：在仿真里随机化那些「真实与仿真不一致」的要素，
# 让策略学到对干扰鲁棒的特征，从而迁移到真实机器人。
import numpy as np

def randomized_sim_params(base):
    """对动力学与外观参数加随机扰动，覆盖 sim-to-real 的差距来源。"""
    return {
        "mass_scale":      base["mass"]      * np.random.uniform(0.7, 1.3),
        "friction":        base["friction"]  * np.random.uniform(0.5, 1.5),
        "joint_damping":   base["damping"]   * np.random.uniform(0.8, 1.2),
        "camera_pose":     base["cam"] + np.random.randn(6) * 0.02,   # 视角抖动
        "light_intensity": np.random.uniform(0.4, 1.6),               # 光照变化
        "sensor_noise":    np.random.uniform(0.0, 0.02),              # 传感噪声
        "latency_ms":      int(np.random.choice([0, 8, 16, 33])),     # 控制延迟
    }

# 经验法则：随机化范围要覆盖真实世界的实际分布，
# 但不能过大以至于任务变得不可解（过随机化会拖慢收敛甚至学不动）。

python# 域随机化的权衡：范围太小过拟合仿真，范围太大任务不可解
def sim2real_gap(random_frac):
    too_narrow = max(0.0, 0.5 - random_frac)        # 随机化不足 -> 真机掉点
    too_wide   = max(0.0, random_frac - 0.6) * 0.8  # 过宽 -> 学不动
    return 0.05 + too_narrow * 0.5 + too_wide
for f in [0.10, 0.30, 0.45, 0.70, 0.90]:
    print(f"random_frac={f:.2f}  估计 sim2real gap≈{sim2real_gap(f):.2f}")
# 预期输出（示意曲线，实操靠真机数据回灌校准）：
#  0.10 gap≈0.25；0.30 gap≈0.15；0.45 gap≈0.08；0.70 gap≈0.13；0.90 gap≈0.29
# 结论：随机化存在「甜点区」，不是越宽越好——太窄过拟合，太宽任务不可解。

3.4 训练方法：模仿学习与 RL

• 行为克隆 / 模仿学习：把示范数据当成监督学习（观测 → 动作）。简单有效，但误差累积（compounding error）是核心问题——测试时一旦偏离示范分布，错误会自激放大。
• DAgger 类方法：让策略自己执行、由专家纠正错误状态，缓解分布偏移。关键是在「错误的地方」补数据。
• 流匹配回归当作隐式奖励：有工作直接用流匹配回归损失充当隐式奖励，无需额外 Critic 网络，效果优于传统 DAgger 类方法。
• 强化学习：在仿真中大规模做 RL 再迁移到真实世界；真实世界 RL 受安全性、样本效率与成本限制，通常只在仿真里放量与在真机里做微调。
• 奖励设计：物理任务的奖励设计极难，因此常用「成功判定 + 稀疏奖励 + 课程学习」的组合，避免手工奖励被策略钻空子（reward hacking）。

python# 行为克隆的误差累积：为什么「逐步回归」在长时程必然崩
import numpy as np
rng = np.random.default_rng(0)
def _ar(H, eps, drift):
    e = 0.0
    for _ in range(H):
        e = e * (1 + drift) + rng.normal(0, eps)   # 误差自激放大
    return e
def rollout_err(H, eps=0.01, drift=0.05, trials=3000):
    return float(np.mean([abs(_ar(H, eps, drift)) for _ in range(trials)]))
print("H=10  平均末端误差:", round(rollout_err(10), 3))   # ≈ 0.032
print("H=50  平均末端误差:", round(rollout_err(50), 3))   # ≈ 0.29
# 结论：per-step 误差仅 0.01，但误差随视界自激放大，H=50 时末端误差放大近 30 倍。
# 这正是 DAgger / 流匹配隐式奖励 / RL 微调要解决的「分布偏移（compounding error）」。

3.5 动手练习与自测

1. 用 3.4 的误差累积模型，把 per-step 误差从 0.01 提高到 0.03，重算 H=50 的末端误差量级。
2. 在 MuJoCo 里把 episode 长度从 200 步改为 500 步，说明为什么「稀疏奖励 + 长 episode」会让 RL 学不动，并给出两个缓解手段。
3. sim2real 的四类差距来源分别是什么？域随机化主要对付哪几类？
4. 为什么说「仿真里 95% 成功率」不能直接当产品指标？
5. 人类视频没有动作标签，三种把它变成训练信号的做法是什么？
6. Isaac Lab 能并行 4096 个环境，这对 RL 样本效率意味着什么量级？

题号	考点	关键判据 / 参考答案
1	误差累积	误差与 eps 近似线性；eps 三倍 -> 末端误差约 0.29×3 ≈ 0.87 量级
2	稀疏奖励	探索空间随步数指数增大；缓解：课程学习 + 示范引导 + 密集奖励塑形
3	sim2real 差距	视觉 / 动力学 / 传感噪声 / 延迟与丢帧；域随机化主要覆盖视觉与动力学
4	仿真-真实落差	视觉纹理、摩擦质量、传感噪声、延迟都不一致，真机常掉到 30% 量级
5	人类视频	训练逆向动力学模型(IDM) / 视频预训练后少量动作对齐 / 世界模型续写成带动作轨迹
6	并行吞吐	单卡约 8.8e8 步/小时，等价于真实机器人跑几百年，是样本效率的关键杠杆

4. 评测、现状与决策

4.1 机器人基准：LIBERO / SimplerEnv / 真实成功率

基准 / 场景	考什么	为什么重要
LIBERO（130+ 任务）	语言条件操作、长时程任务成功率	VLA 最常用的标准化标尺，可比性强
SimplerEnv	仿真策略映射到真实机器人的泛化	专门测 sim-to-real，暴露随机化不足
RoboTwin 类双臂基准	双臂操作、长时程任务	衡量通用操作能力
Physics-IQ / 物理推理	对重力、碰撞、流体的理解	检验是否真的理解物理而非拟合外观
RoboArena / 真实评测	真实硬件上的泛化	仿真分数与真实表现常有巨大落差
自动驾驶仿真	边缘场景（corner case）	世界模型在此处价值最明确
工业分拣 / 质检	高重复、高精度	已可落地，投资回报清晰
人形通用操作	开放环境多任务	仍在早期，需谨慎评估时间表

python# 为什么「平均成功率」会骗人：把它拆成四类看
raw = {"已知任务": (0.92, 100), "OOD 物体": (0.61, 60),
       "长程(>10步)": (0.38, 40), "新环境": (0.29, 30)}
avg = sum(r * c for r, c in raw.values()) / sum(c for _, c in raw.values())
print("加权平均成功率:", round(avg, 3))            # ≈ 0.635
for k, (r, c) in raw.items():
    print(f"{k}: {r:.0%} (n={c})")
# 预期输出：加权平均成功率: 0.635；但长程仅 38%、新环境仅 29%。
# 结论：一个 0.635 的「平均分」掩盖了产品化真正的门槛（长程 + 新环境）。

4.2 泛化维度：新物体 / 新指令 / 新环境

评判一个具身系统的真实水平，最有用的是沿三个泛化维度分别测，而不是混在一起报一个数。

维度	含义	测试方式	难度
新物体	从未见过的物体形状 / 材质 / 颜色	换物体重测同一指令	中（ViT 表征已部分覆盖）
新指令	用没见过的自然语言表述同一任务	改写 / 同义指令重测	低—中（语言泛化已被大模型解决）
新环境	新背景、新光照、新布局	换场景重测	高（视觉分布偏移大）
新任务组合	已知原子技能的新组合	组合泛化测试	高（考验是否真涌现）
长程任务	多步骤序列（>10 步）	多步任务成功率	最高（误差累积 + 记忆）

python# 泛化维度的「掉点幅度」经验值：用于快速估算不同场景的风险
dims = {"新指令": 0.05, "新物体": 0.15, "新环境": 0.35,
        "新任务组合": 0.40, "长程(>10步)": 0.55}
base = 0.92
for k, drop in dims.items():
    print(f"{k}: 预计成功率 {base * (1 - drop):.2f}（掉 {drop:.0%}）")
# 预期输出：新指令 0.87；新物体 0.78；新环境 0.60；新任务组合 0.55；长程 0.41。
# 结论：语言泛化几乎免费（大模型红利），环境与长程才是硬骨头。

4.3 2026 真实水平与瓶颈

把 hype 去掉，2026 年具身智能的真实水位大致如下。这是帮助你在面试和选型时不被 demo 误导的基准线。

能力	2026 现状	主要瓶颈
短程抓取 / 放置	已可落地（工业分拣、质检）	长程、灵巧仍难
跨本体泛化	预训练 + 低样本适配可行（50–100 条）	数据规模仍远小于 CV/NLP
灵巧操作	起步（叠衣、插拔、用工具）	高自由度、缺触觉反馈
长程任务	demo 级，产品级极少	误差累积、缺乏持久记忆
人机协作安全	规则 + 慢系统兜底	快系统安全验证难
数据采集	遥操作 + 视频学习 + 世界模型合成	真实长尾数据极贵

python# 具身场景可行性打分（把四问框架变成可量化评分）
def score(structured, fail_cost, data_ok, gen_ok):
    # 每项 0–1，越高越有利；失败代价越高越不利
    return 0.30 * structured + 0.20 * (1 - fail_cost) + 0.25 * data_ok + 0.25 * gen_ok
scenarios = {
    "工业分拣": (0.9, 0.2, 0.8, 0.7),
    "仓库拣选": (0.7, 0.3, 0.7, 0.6),
    "家庭家务": (0.2, 0.6, 0.3, 0.15),
}
for k, v in scenarios.items():
    print(k, round(score(*v), 2))
# 预期输出：工业分拣 0.80；仓库拣选 0.65；家庭家务 0.29
# 结论：越结构化、失败代价越低、数据越可得 -> 分数越高，越该现在做。

4.4 什么情况下值得投入 / 什么情况理解原理即可

本阶段标记为「可跳过」不是随便写的。下面是明确的判断标准，帮你在时间有限时做取舍。

你的情况	建议	原因
目标是进入机器人 / 自动驾驶方向	值得深入：能训 VLA、会仿真、懂数据管线	这是该方向的硬通货，缺口大
做通用 AI 应用 / Agent / RAG	理解原理即可，知道何时调用世界模型	你的战场是软件系统，不是物理本体
个人 / 小团队、无硬件	跑通开源、读论文、做仿真实验，不必自训大模型	自训机器人基础模型成本千万级
做技术选型 / 投资 / 产品决策	重点掌握判断标准与真实边界	避免被 demo 与融资叙事误导
偏后端系统背景	从仿真 + 数据管线 + 闭环工程切入	比从模型算法切入更容易形成差异化

python# 「自训机器人基础模型」的成本量级：解释为什么个人不该自训
gpu_hours = 500_000          # 具备竞争力所需的 GPU 小时（量级估计）
usd_per_gpu_hour = 2.0       # 云上 A100/H100 级租用价
print("训练算力成本(美元):", int(gpu_hours * usd_per_gpu_hour))   # 1000000
# 预期输出：1000000（约 100 万美元，仅算力）。
# 再加数据采集（真实示范 5–20 美元/条）、标注与人力，总投入通常在千万美元级。
# 结论：个人 / 小团队跑通开源 + 仿真实验即可，自训基础模型不现实。

4.5 入门路径（想动手的话）

python# 入门路径的最小验证骨架：先跑通「观测 -> 动作 -> 成功判定」闭环
def episode(env, policy, max_steps=200):
    obs, done, steps = env.reset(), False, 0
    while not done and steps < max_steps:
        action = policy(obs)                       # 先用随机策略或开源 VLA
        obs, reward, done, info = env.step(action)
        steps += 1
    return info.get("success", False), steps

# 先跑 100 个 episode 统计成功率基线，再逐步替换策略：
#  随机策略成功率 < 5%；换成 OpenVLA 零样本可到 20%–60%（视任务与本体）。
# 然后加入失败检测与重试 —— 这一步才是真实系统与 demo 的最大差距。

能力维度	代表基准	测什么	看指标
通用操作	LIBERO	多任务语言条件操作	平均成功率
长程组合	RoboSuite / CALVIN	连续子任务与状态依赖	完成链长 / 平均完成步数
泛化鲁棒	LIBERO-Plus / 域随机化	新物体、新位置、新光照	相对基线的掉点幅度
本体迁移	跨机器人基准	换本体后的适配成本	微调所需示范数据量
仿真拟真	Isaac Sim / MuJoCo	物理与渲染逼真度	sim2real gap

python# 评测统计：成功率要带置信区间，别拿 10 个 episode 下结论
import math

def wilson(k, n, z=1.96):                       # 二项比例的 Wilson 区间
    if n == 0: return (0.0, 0.0)
    p = k / n
    d = 1 + z*z/n
    c = (p + z*z/(2*n)) / d
    h = z * math.sqrt(p*(1-p)/n + z*z/(4*n*n)) / d
    return (max(0, c-h), min(1, c+h))

for n in (10, 200):
    lo, hi = wilson(int(0.6*n), n)              # 观测成功率均为 0.6
    print(n, round(lo, 2), round(hi, 2))
# 10 个 episode：约 0.31-0.83，区间宽到无法判断策略好坏；
# 200 个：约 0.53-0.67，才勉强可用于对比两个策略的优劣。
# 结论：具身评测样本量不足时，任何「成功率提升」都可能是噪声。

4.6 动手练习与自测

1. 用 4.1 的代码把「长程任务」样本权重从 40 提到 200，重算加权平均成功率，观察均值如何被拉低。
2. 用 4.2 的掉点经验值，估算「新环境下连续做 10 步」的联合成功率（提示：掉点叠加）。
3. 为什么一个「换个说法就能做」的 demo 不足以说明系统可落地？
4. 用四问框架给「餐厅后厨洗碗机器人」打分，并说明哪一问最致命。
5. 什么情况下你应该深入世界模型 / VLA，什么情况下理解原理即可？各给一个理由。
6. 个人开发者做具身，为什么建议从「仿真 + 数据管线 + 闭环工程」切入？

题号	考点	关键判据 / 参考答案
1	指标构成	长程权重上升后加权均值向 0.38 靠拢，暴露长程短板；说明单一均值会掩盖关键维度
2	泛化叠加	新环境 0.65 × 长程 0.45 ≈ 0.29 量级，联合成功率远低于任一单项
3	泛化排序	语言泛化已接近免费，真正门槛是新环境与长程；demo 常在「新指令」维度好看
4	四问打分	结构化中、失败代价中、数据稀缺、泛化要求高 -> 总分偏低，泛化与数据最致命
5	投入判断	机器人/自动驾驶方向深入；通用应用理解原理、会用即可
6	差异化	具身门槛高但供给少；后端系统背景从仿真/数据/闭环切入比从模型算法切入更易形成优势

项目里程碑

阶段练习项目

常见误区

• 把视频生成等同于世界模型，忽略「动作条件化」与「可干预」才是分界线。
• 以为有了世界模型就能规划，忽视研究发现——Agent 常常不会正确使用模拟能力。
• 低估数据成本，以为可以像文本一样从互联网抓取机器人数据（真实示范约 5–20 美元 / 条）。
• 忽略动作频率约束：模型推理延迟高于控制周期，闭环必然失稳。
• 在仿真里刷到很高分数就以为可落地，忽略 sim-to-real 差距（视觉 / 动力学 / 传感噪声）。
• 设计高自由度人形机器人的通用任务，却不评估失败代价与安全约束。
• 混淆三种用途（预测 / 规划 / 仿真），用不可控的生成模型当规划器。
• 只看平均成功率，不拆 OOD 泛化与长程任务完成率，被 demo 误导。
• 只关注模型，忽略工程侧的状态管理、失败检测与重试——这是 demo 与产品的真正差距。

面试高频问题速答

世界模型和视频生成模型有什么区别？

判据是「可干预性」：视频生成只根据文本或图像条件生成画面，你只能看；世界模型接受动作作为条件，能预测执行该动作后的下一个状态，因此可用于规划与安全校验。技术上的关键差异是动作条件化与闭环使用。2026 年的趋势是两者在顶部开始模糊（视频模型开始具备物理理解），但「能否被动作驱动」仍是分界线。三者用途也不同：预测（想象）、规划（rollout 选动作）、仿真（造数据）。

VLA 为什么用端到端而不是模块化流水线？

模块化方案中感知、规划、控制各自独立开发，每个模块的误差会逐级累积，且模块间接口是人工设计的，泛化受限于设计者预设的情形。端到端把整个闭环一起学习，泛化能力从架构中涌现——模型见过足够多的组合后无需为每种情形单独编程，语言领域验证过的缩放律开始在物理世界起作用。代价是需要更多数据与算力，且动作头要独立训练。

离散动作 token 和连续 flow matching 动作头怎么选？

看动作空间的维度与多模态程度。低维、可离散化的动作（如离散导航）用 token 最方便，能直接复用 LLM 自回归；但量化会引入误差、codebook 易崩塌。高维、连续、多模态的灵巧操作（7–20 维关节、同一观测多种合理动作）必须用连续头，flow matching / 扩散能建模多模态连续分布、动作更平滑，代价是多步采样导致推理更慢。工程上常混合：粗动作离散、细动作连续。

为什么 VLA 落地必须考虑动作频率？

因为推理延迟必须低于控制周期，否则系统失稳。一个控制周期 10ms 的机械臂，根本不能等一个 80ms 的模型 forward。标准解法是双系统：慢而聪明的大模型（1–5 Hz）做规划，快而精准的轻量策略（50–200+ Hz）做高频控制与平衡。这决定了 VLA 通常不能独立做闭环，必须外挂高频策略或换更小更快的模型。

sim2real 差距来自哪里，怎么缓解？

四类来源：① 视觉（纹理 / 光照 / 相机）；② 动力学（质量 / 摩擦 / 阻尼不准）；③ 传感噪声（真实更大）；④ 延迟与丢帧。缓解以域随机化为主——在仿真里随机化这些参数，让策略学到鲁棒特征；再配合仿真域自适应、真实数据回灌校准、系统辨识。关键是随机化范围要覆盖真实分布但不过宽，否则任务不可解。

怎么判断一个具身项目现在该不该做？

用四问框架：任务结构化程度（越高越好）、失败代价（高则必须有人工监督与安全层）、数据可得性（能否拿到真实部署数据）、泛化要求（固定工位 vs 开放环境差异巨大）。四项都友好就可以做（如工业分拣、质检）；有一项很差就应该等或换场景。不要被通用人形机器人的演示视频误导——演示与稳定生产的距离通常很大。

什么情况下值得投入世界模型与 VLA，什么情况理解原理即可？

明确分界：目标是进入机器人 / 自动驾驶方向 → 值得深入（能训 VLA、会仿真、懂数据管线，这是该方向硬通货）；做通用 AI 应用 / Agent / RAG → 理解原理即可，知道何时调用世界模型、能评估供应商方案就够了。个人无硬件则跑通开源与仿真实验即可，不必自训基础模型（成本千万级）。

学习资源

Genie 3（可交互世界生成）报告 deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/ 实时可导航世界模型的代表，理解自回归帧预测路线与一致性挑战。 Dreamer V3（潜空间想象）论文 arxiv.org/abs/2301.04104 在潜空间做 model-based RL 的代表作，样本效率极高，理解 latent imagination。 I-JEPA（联合嵌入预测）论文 arxiv.org/abs/2301.08243 JEPA 架构代表作，理解「在表征空间预测而非像素空间」的核心思想。 NVIDIA Cosmos（世界基础模型）GitHub github.com/NVIDIA/Cosmos 面向物理 AI 的开放世界模型，含推理 + 生成专家架构与合成数据能力。 π0 / π0.5（Physical Intelligence）项目 www.physicalintelligence.company/ flow matching 动作头的 VLA 代表作，展示了跨本体与组合泛化能力。 OpenVLAGitHub github.com/openvla/openvla 开源 7B VLA 基线，适合第一次动手跑通。 LeRobot（HuggingFace）GitHub github.com/huggingface/lerobot 机器人学习工具链：数据集、模型、训练与评测，社区活跃。 LIBERO（操作基准）基准 libero-project.github.io/ 130+ 语言条件操作任务基准，VLA 常用标尺。 Isaac Sim / Lab（NVIDIA）文档 developer.nvidia.com/isaac/sim GPU 并行仿真器，大规模 RL 与数字孪生首选。 MuJoCoGitHub github.com/google-deepmind/mujoco 主流刚体物理仿真器，先玩仿真再上真机。 A Unified Survey of Multimodal Generative Models论文 arxiv.org/abs/2503.04641 把生成式模型放进「世界模拟」统一框架，理解 2D→4D 的演进。