GR00T N1 论文深度拆解：英伟达给机器人装上了“快与慢“双系统大脑

论文：GR00T N1: An Open Foundation Model for Generalist Humanoid Robots
作者：NVIDIA（研究负责人 Linxi “Jim” Fan、Yuke Zhu）
出处：arXiv:2503.14734 [cs.RO]，2025-03-18
开源：模型权重（HuggingFace nvidia/GR00T-N1-2B）、训练数据、仿真基准全量开放
一句话概括：一个 2.2B 参数的视觉-语言-动作（VLA）基础模型，用"System 2 推理 + System 1 执行"的双系统架构，把从人类视频到仿真数据再到真实遥操作的异构数据统一训练，让人形机器人既能听懂指令、又能以 120Hz 高频输出流畅动作。

一、介绍：当机器人开始"开卷"，先得有本教材

先抛一个问题：为什么大语言模型（LLM）和图像生成模型能火遍全球，而机器人模型一直憋屈？

答案其实很残酷——互联网上没有"机器人数据集"。GPT 可以用整个互联网当语料库，Stable Diffusion 可以把几十亿张图灌进模型，但你要训练一个"会干活的机器人"，得雇人拿遥操作设备一个个录轨迹。录一条 30 秒的抓取演示要几分钟，录 10 万条就是几个月。这就是论文里说的核心矛盾：

“Unlike the digital realms of words and pixels, no Internet of humanoid robot datasets exist for large-scale pre-training.”

而且不同机器人之间还是"数据孤岛"（data islands）：机械臂、双机械臂、人形机器人、灵巧手，传感器不同、自由度不同、控制模式不同，数据集像太平洋上一串互不相连的小岛，凑不成一块大陆。

NVIDIA 这篇 GR00T N1 论文，就是试图把这片"数据群岛"填成"数据大陆"的工程宣言。它的三大卖点：

1. 全球首个开源人形机器人基础模型（2.2B 参数，权重全公开）；
2. 双系统架构：借鉴诺贝尔奖得主 Daniel Kahneman《思考，快与慢》的 System 1 / System 2 理论，VLM 负责"慢思考"，扩散 Transformer 负责"快执行"；
3. 数据金字塔策略：用人类视频（底层）→ 合成数据（中层）→ 真实机器人遥操作数据（顶层）的混合语料库，把 88 小时的遥操作数据"变"成 827 小时。

🧭 如果你是视频编解码背景的读者（比如我），这篇论文有几个非常亲切的切入点：它用来造数据的 WAN2.1 视频生成模型、图像 token 化用的 pixel shuffle（就是 ESPCN 超分那招）、还有大量 egocentric 视频数据集（Ego4D、EPIC-KITCHENS）——都是老熟人。

二、原理：双系统架构，"慢思考"与"快执行"的分工

2.1 灵感的来源：《思考，快与慢》

Kahneman 把人脑分成两个系统：

• System 1：快，自动，直觉。比如你看到球飞过来下意识伸手去接，不需要"算"。
• System 2：慢，理性，费力。比如做数学题、规划"先拿苹果再放篮子"。

机器人界的正统做法通常只取其一：要么端到端行为克隆（快但笨，听不懂复杂指令），要么高层规划+底层控制器解耦（聪明但慢，且中间接口难设计）。GR00T N1 的选择是两个都要，还端到端一起训：

有意思的细节：System 2 跑 10Hz（因为 VLM 推理贵），System 1 跑 120Hz（因为控制频率要高）。两者通过 cross-attention 紧密耦合，联合端到端训练——推理模块输出的 embedding 直接喂给动作模块当条件，没有硬编码的中间表示。

2.2 System 2：Eagle-2 视觉语言模型

• 底座：SmolLM2 LLM（小但够用）+ SigLIP-2 图像编码器；
• 图像处理：每帧 224×224 → pixel shuffle → 64 个图像 token/帧；
• 语言+图像在 LLM 中统一编码，任务指令走 chat 格式；
• 关键工程发现：取 第 12 层（中间层）的 LLM embedding 喂给动作模块，而不是最后一层。论文原话：更快推理速度 + 更高下游策略成功率，“win-win”。这个反直觉的点我们放在踩坑章节细聊。

2.3 System 1：扩散 Transformer + Flow Matching

System 1 是一个 DiT（Diffusion Transformer）变体，结构类似 Flamingo/VIMA 的"交替注意力"：

• Self-Attention 块：处理加噪动作 token + 本体状态 embedding；
• Cross-Attention 块：以 VLM 输出的视觉-语言 token 为条件（key/value）；
• 每个 DiT 块用 AdaLN（自适应层归一化） 注入去噪时间步信息；
• 尾部接 embodiment-specific 的动作解码器（MLP）。

为什么用"流匹配"（Flow Matching）而不是传统扩散（DDPM）？因为流匹配的生成轨迹更"直"：从噪声到数据的路径是线性插值，训练目标简单（直接回归速度场），推理时几步 Euler 积分就能出结果，实时性碾压传统扩散的千百步去噪。对机器人这种要求低延迟的场景，这是刚需。

2.4 跨本体：一套权重，多副身体

GR00T N1 的杀手锏是一个模型、一套权重，同时支持单臂机械臂、双臂机械臂、人形机器人 + 灵巧手。做法：

• 每个 embodiment 一个独立的 MLP 做状态编码器 + 动作解码器（维度适配器）；
• 中间共享同一套 DiT 骨干 + VLM 骨干；
• 动作以 chunk（H=16 步）为单位预测，即"一次预测未来 16 步动作"，类似 AVC 的帧组（GOP）思想——一次决策管一段。

三、公式：流匹配如何"画"出动作

3.1 动作分块（Action Chunking）

设某时刻 t 的动作向量为 $a_t$，模型一次预测未来 H 步：

$$A_t=[a_t,a_{t+1},\dots ,a_{t+H-1}]$$

GR00T N1 取 H=16。推理时每 63.9ms（L40 GPU, bf16）采样一组 16 个动作——即"用 16ms 想，接下来 16 步怎么做"。

3.2 训练：回归速度场

给定真实动作 chunk $A_t$、流匹配时间步 $\tau \in [0,1]$、采样噪声 $ϵ\sim \mathcal{N}(0,I)$，加噪动作定义为噪声与数据的线性插值：

$$A_t^{\tau }=\tau A_t+(1-\tau )ϵ$$

注意这个式子：$\tau =0$ 时是纯噪声，$\tau =1$ 时是纯数据。模型 $V_{\theta }({\varphi }_t,A_t^{\tau },q_t)$ 的目标是回归"去噪方向" $ϵ-A_t$，即流匹配损失：

$${\mathcal{L}}_{fm}(\theta )={\mathbb{E}}_{\tau }\left[{\Vert V_{\theta }({\varphi }_t,A_t^{\tau },q_t)-(ϵ-A_t)\Vert }^2\right]$$

其中 ${\varphi }_t$ 是 VLM 视觉-语言 token，$q_t$ 是本体状态 embedding。训练时时间步按 Beta 分布采样（模仿 DDPM 的 noise schedule，让模型重点学中间难度）：

$$p(\tau )=\text{Beta}\left(\frac{s-\tau }{s};1.5,1\right),s=0.999$$

3.3 推理：K 步 Euler 积分

推理时从纯噪声出发：$A_t^0\sim \mathcal{N}(0,I)$，然后做前向 Euler 积分迭代去噪：

$$A_t^{\tau +1/K}=A_t^{\tau }+\frac{1}{K}{V}_{\theta }({\varphi }_t,A_t^{\tau },q_t)$$

K=4 步就够用——这是论文里的实用主义结论：对动作流匹配，4 步 Euler 已经在所有 embodiment 上表现良好，没必要像图像生成那样堆 20 步。

3.4 辅助损失：让模型"看着物体"学

为了增强空间理解，论文加了一个辅助目标检测损失：用 OWL-v2 检测器给轨迹帧里的目标物体打 bounding box，取归一化中心坐标 $x_{gt}$，在 VLM 最终 token 上接一个线性层预测 2D 坐标 $x_{pred}$：

$${\mathcal{L}}_{det}=\Vert x_{pred}-x_{gt}{\Vert }^2$$

总损失：$\mathcal{L}={\mathcal{L}}_{fm}+{\mathcal{L}}_{det}$。这就好比给"只会写字"的模型加了个"读题"的监督信号——它必须真的看到苹果在哪，才能把苹果放篮子。

📐 编解码视角：这个"速度场回归"的配方，本质上和视频超分/插帧里的 flow 估计是同构的——只是这里预测的是动作空间里的"位移场"，而视频领域预测的是像素空间的运动矢量。换汤不换药，都是回归一个连续的向量场。

四、图示：架构与数据金字塔

4.1 模型总体架构

4.2 数据金字塔

            ▲  真实机器人遥操作数据（88h→827h）
           / \  高特异性、高成本、高价值
          /   \        ▲
         / 合成数据 \      │
        / 仿真(6500h) +   │ 数据特异性↑
       /  神经生成视频     │ 数据量↓
      /_________________\
     /  人类视频 + Web 数据  \
    /   Ego4D/EPIC/Assembly  \
   /__________________________\
   数据量最大，提供"视觉与行为先验"

金字塔的哲学：越底层的数据越便宜、越多、但越"泛"；越顶层的越贵、越少、但越"专"。底层提供视觉先验和行为语义，顶层保证真实的具身执行接地气。GR00T N1 用混合采样把三层一起训练，一套权重通吃。

4.3 数据规模总览（Table 7 精华）

重点划一下：真实遥操作只有 88 小时（GR-1 采集），其余全是"变"出来的。这就是数据工程的艺术。

五、踩坑点：论文里藏着的工程血泪

这篇论文最值钱的地方，其实是 appendix 和散落在正文里的"我们试过 X，不行"的细节。我帮你扒出来：

5.1 坑 1：VLM 最后一层 embedding 不是最优解

直觉上，LLM 最后一层的表示"最丰富"，但 GR00T N1 发现取第 12 层（中间层）反而更好：

• 推理更快：中间层可以提前截断，省掉后半段计算；
• 成功率更高：中间层特征更"视觉化"、更贴近感知，最后一层过度抽象、偏语言语义，反而不利于生成精细动作。

教训：机器人策略要的不是"最聪明"的表示，而是"感知友好"的表示。这个反直觉结论值得所有做 VLA 的人抄作业。

5.2 坑 2：去噪步数 K=4 是甜点

K=4 步 Euler 就够，更多步数徒增延迟。这是因为流匹配的轨迹接近直线（线性插值设计），收敛极快。对比图像扩散的 20~50 步，这是"动作空间维度低 + 轨迹直"的红利。

5.3 坑 3：LAPA 潜动作 vs IDM 伪动作，谁赢看数据量

给"没有动作标签的视频"标动作，论文试了两条路：

• LAPA（Latent Action Pretraining）：VQ-VAE 编码器从相邻帧对 (x_t, x_{t+H}) 提取潜动作；
• IDM（Inverse Dynamics Model）：DiT 架构，输入两帧图，回归两帧之间的动作 chunk。

结论很有意思：低数据 regime（每任务 30 条）LAPA 略胜；数据越多（100/300 条），IDM 拉开差距。原因也合理——IDM 直接预测真实动作空间，数据足够时标签更对齐；LAPA 是自监督的抽象潜空间，冷启动友好但天花板低。

5.4 坑 4：动作空间标准化藏着四个细节

跨本体训练前，动作/状态空间做了统一化，每个细节都是坑：

1. 末端旋转状态转 6D 表示（避免欧拉角的万向锁和跳变）；
2. 末端旋转动作用 axis-angle（紧凑、平滑）；
3. 关节/末端位置做 min-max 归一化（不同机器人量纲差 10 倍很正常）；
4. 状态/动作向量固定排序：末端旋转 → 末端位置 → 夹爪开合，从左臂到右臂。

不这么干，跨本体训练直接崩——这不是论文正文讲的，是附录 D.2 的干货。

5.5 坑 5：后训练会"忘掉"预训练的本领

定性实验里有个扎心发现：预训练 checkpoint 遇到"苹果在左手边"这种训练集里少见的场景，会自己左手拿→右手交接→放篮子；但后训练（post-training）后的模型反而忘了交接——因为后训练数据全是右手单臂操作。

这就是灾难性遗忘（catastrophic forgetting）在机器人策略里的活例子。数据分布一变，模型就"偏科"。论文没给解药，只说"预训练模型反而更鲁棒"。

5.6 坑 6：造数据的成本不可小觑

神经轨迹不是免费的：微调 WAN2.1-I2V-14B（LoRA，3000 条真实轨迹，100 epochs），生成 827 小时视频花了 105,000 L40 GPU 小时（约 3600 张 L40 跑 1.5 天），且生成 1 秒视频要 2 分钟。还要用多模态 LLM 当"评委"过滤不跟指令的视频、重新打 caption。数据金字塔的底层，是实打实的算力金字塔。

六、源码拆解：Isaac-GR00T 开源仓库

论文开源在 github.com/NVIDIA/Isaac-GR00T（Apache 2.0），代码基于 Hugging Face LeRobot 生态。当前 main 分支已经迭代到 GR00T N1.7（VLM 从 Eagle-2 换成了 Qwen3-VL，还加了 TensorRT 部署），但核心架构与论文一致。我们来拆核心链路。

6.1 仓库结构一览

Isaac-GR00T/
├── gr00t/                       # 核心 Python 包
│   ├── model/                   # 模型定义
│   │   ├── modules/
│   │   │   ├── dit.py           # ★ Diffusion Transformer（AdaLN + 时间步）
│   │   │   ├── embodiment_conditioned_mlp.py   # 跨本体 MLP 适配
│   │   │   └── qwen3_backbone.py               # N1.7 的 VLM backbone
│   │   ├── gr00t_n1d7/          # N1.7 模型（含 get_action 去噪采样）
│   │   └── registry.py          # 模型注册表
│   ├── policy/
│   │   ├── gr00t_policy.py      # ★ Gr00tPolicy：推理封装层
│   │   ├── policy.py            # BasePolicy 基类
│   │   ├── replay_policy.py     # 轨迹回放策略
│   │   └── server_client.py     # PolicyServer/PolicyClient（ZMQ）
│   ├── data/                    # LeRobot 数据加载、embodiment tags
│   ├── experiment/              # launch_finetune.py / launch_train.py
│   ├── eval/                    # 评估入口（run_gr00t_server.py 等）
│   ├── deployment/              # 部署模式、TensorRT/ONNX 导出
│   └── utils/                   # parse_observation_gr00t 等
├── scripts/
│   ├── deployment/standalone_inference_script.py   # 独立推理脚本
│   └── lerobot_conversion/convert_v3_to_v2.py      # 数据格式转换
├── examples/                    # DROID / LIBERO / SO100 / SimplerEnv 等
├── demo_data/                   # 示例数据集（含 modality.json）
├── getting_started/             # Jupyter 教程 + 文档
└── tests/

6.2 Gr00tPolicy：一次推理的完整链路

gr00t/policy/gr00t_policy.py 里的 Gr00tPolicy 是用户最常接触的入口。模型加载到动作输出一共五步：

def __init__(self, embodiment_tag, model_path, *, device, strict=True):
    # 注册模型 + 加载预训练权重，切 bf16 推理
    model = AutoModel.from_pretrained(model_dir)
    model.eval()
    model.to(device=device, dtype=torch.bfloat16)
    self.model = model
    # 加载 processor（负责观测编码与动作反归一化）
    self.processor = AutoProcessor.from_pretrained(processor_dir)

def _get_action(self, observation, options=None):
    # Step 1: 批量观测拆成单条
    unbatched_observations = self._unbatch_observation(observation)
    # Step 2: 每条观测转 VLAStepData，喂给 VLA processor（图像编码 + 文本拼 prompt）
    for obs in unbatched_observations:
        vla_step_data = self._to_vla_step_data(obs)
        messages = [{"type": MessageType.EPISODE_STEP.value,
                     "content": vla_step_data}]
        processed_inputs.append(self.processor(messages))
    # Step 3: collate 成 batch，统一转 bf16
    collated_inputs = self.collate_fn(processed_inputs)
    collated_inputs = _rec_to_dtype(collated_inputs, dtype=torch.bfloat16)
    # Step 4: 模型推理 —— 内部就是 flow matching 去噪采样
    with torch.inference_mode():
        model_pred = self.model.get_action(**collated_inputs)
    normalized_action = model_pred["action_pred"].float()
    # Step 5: 归一化动作 → 物理动作（processor.decode_action 反归一化）
    unnormalized_action = self.processor.decode_action(
        normalized_action.cpu().numpy(), self.embodiment_tag, batched_states)
    return {k: v.astype(np.float32) for k, v in unnormalized_action.items()}, {}

关键点：去噪采样（第 4 步）被封装在模型内部的 get_action()——输入 VLM 编码好的视觉-语言特征 + 加噪动作 + 状态，输出 K=4 步 Euler 积分后的动作 chunk。策略层只负责"数据进出"，生成细节全在模型层，这个分层很干净。

6.3 DiT：AdaLN 是怎么把时间步"注入"进去的

gr00t/model/modules/dit.py 里的 DiT 是 System 1 的骨干。它的条件注入机制是自适应层归一化（AdaLN）——时间步 embedding 经过一层线性变换，拆成 scale 和 shift，去调制 LayerNorm 的输出：

class AdaLayerNorm(nn.Module):
    def __init__(self, embedding_dim, norm_elementwise_affine=False,
                 norm_eps=1e-5, chunk_dim=0):
        super().__init__()
        self.chunk_dim = chunk_dim
        output_dim = embedding_dim * 2
        self.silu = nn.SiLU()
        self.linear = nn.Linear(embedding_dim, output_dim)   # D → 2D
        self.norm = nn.LayerNorm(output_dim // 2, norm_eps,
                                 norm_elementwise_affine)

    def forward(self, x, temb=None):
        # 时间步 embedding → scale/shift 对
        temb = self.linear(self.silu(temb))
        scale, shift = temb.chunk(2, dim=1)
        # 特征调制：LayerNorm 之后按 (1+scale) 缩放、加 shift
        x = self.norm(x) * (1 + scale[:, None]) + shift[:, None]
        return x

DiT 的 block 组织是交替自注意力 / 交叉注意力（论文说类似 Flamingo），交叉注意力以 VLM token 为 key/value：

for idx, block in enumerate(self.transformer_blocks):
    if idx % 2 == 1 and self.config.interleave_self_attention:
        # 奇数块：纯自注意力（动作 token 之间互相看）
        hidden_states = block(hidden_states, temb=temb)
    else:
        # 偶数块：交叉注意力（动作 token 去"看" VLM 的视觉-语言 token）
        hidden_states = block(
            hidden_states,
            encoder_hidden_states=encoder_hidden_states,  # VLM token
            encoder_attention_mask=None,
            temb=temb,
        )

输出端再用一次 AdaLN 调制（proj_out_1 拆 shift/scale，proj_out_2 投影回动作维度），整个网络"时间步条件 + 视觉语言条件 + 本体状态条件"三路条件齐活。

💡 C++ 风格的吐槽：这里 AdaLN 的"chunk 拆两半"其实就是 FiLM 条件化，Pytorch 一行 temb.chunk(2, dim=1) 搞定；如果换成 C++ 手写（比如你想在 CUDA 里抠延迟），无非就是 h = (x - mean) * inv_std * (1 + scale) + shift 的逐元素 fused kernel——和我们优化 SAD/SATD 的 SIMD 思维一模一样。

6.4 数据格式：LeRobot 的"超集"

训练数据基于 Hugging Face LeRobot 格式，但扩展了 4 点：

1. modality.json：显式声明状态/动作向量的每一维语义；
2. 细粒度模态拆分：状态不再是一坨向量，而是拆成末端位置、旋转、夹爪开合等字段，各自带类型/范围/变换；
3. 多注释支持：任务描述、有效性标志、成功标志并存；
4. 旋转表示指定：明确是四元数/欧拉角/轴角。

这份"格式化洁癖"换来的是跨本体训练的稳定性——不同机器人数据混在一个 batch 里还不打架，全靠这个 schema。

6.5 快速上手（官方 Getting Started）

# 安装（CUDA 12.4 必装，否则 flash-attn 会教你做人）
git clone https://github.com/NVIDIA/Isaac-GR00T && cd Isaac-GR00T
conda create -n gr00t python=3.10 && conda activate gr00t
pip install -e .
pip install --no-build-isolation flash-attn==2.7.1.post4

# 推理：三行代码跑起来
from gr00t.models import Gr00tPolicy
policy = Gr00tPolicy.from_pretrained("nvidia/gr00t-n1-2b")   # HuggingFace 权重
action = policy.select_action(observation)                     # 喂观测，出动作

微调：gr00t/experiment/launch_finetune.py + 自定义 LeRobot 数据集（数据 → scripts/lerobot_conversion 转格式 → 验证 → 微调 → 推理）。官方说 RTX 4090（24GB）能推理，A6000（48GB）能微调，L40/H100 更佳——这门槛比想象中低，英伟达这次是真想让人"开箱即用"。

七、效果对比：数字会说话

7.1 仿真基准（每任务 100 条演示，成功率）

亮点在 GR-1 人形任务：GR00T N1 比 Diffusion Policy 高出 17.3 个百分点（50.0% vs 32.7%）——人形 + 灵巧手的联合控制最难，也是预训练先验最能发挥的地方。

7.2 真实机器人（Fourier GR-1，8 类任务）

最震撼的是数据效率：GR00T-N1-2B 只用 10% 数据（42.6%）就逼近 Diffusion Policy 用全量数据（46.4%）的成绩——数据少 90%，效果只差 3.8%。这就是基础模型预训练的意义：底子好，学得快。

7.3 神经轨迹协同训练增益

RoboCasa 上"真实轨迹 + 神经生成轨迹"协同训练（1:1 采样）：

7.4 定性行为

• 预训练模型会"交替换手"：苹果放左手边，预训练 checkpoint 左手抓→右手接→放篮子，一气呵成（虽然动作略抖）；
• 后训练模型忘了交接（灾难性遗忘实锤）；
• Diffusion Policy 的短板：初始几帧经常"呆住不动"、抓取不准；GR00T N1 动作明显更平滑、抓取更准。

7.5 局限（作者自认）

1. 目前主要覆盖短视界桌面操作，长视界移动操作（loco-manipulation）未解决；
2. 神经生成数据仍难严格遵循物理规律（液体、铰接物体是难点）；
3. 更强的 VLM 骨干是明确的提升方向（N1.7 已经换了 Qwen3-VL，验证了这个判断）。

八、总结与跨界启示

8.1 一句话总结

GR00T N1 不是某个算法上的"灵光一现"，而是系统工程 + 数据工程 + 算力工程的三重胜利：双系统架构解决了"理解与执行"的分工，数据金字塔解决了"没有互联网级机器人数据"的悖论，而开源策略让整个社区站在 NVIDIA 的肩膀上起步。

8.2 给视频编码技术人的三个启示

启示一：数据金字塔是通用的。 视频编码器的训练数据同样可以分层：海量未标注视频（底层）→ 合成/增强数据（中层）→ 精心标注的高清序列（顶层）。x265 调参、VTM 训练 CNN 滤波，本质都在做"少量高质量 + 大量低成本"的配比优化。

启示二：Flow Matching 是扩散模型的"工程化"。 它对标到视频领域就是：既然图像/视频生成里扩散已经卷到能一步出图（LCM、整流流），那"几步采样 + 直接回归速度场"的套路，同样可以复用到端到端学习型视频编码（如神经视频压缩中的隐空间扩散解码）上。

启示三：中间层特征 > 最后一层特征。 这个反直觉结论其实在视频领域早有呼应——可学习滤波（如 VVC 的 ALF、JND 感知编码里的滤波器）用浅层感知特征往往比深层语义特征更稳。特征不是越深越好，匹配任务层级才是关键。

8.3 后续看点

• N1.7：VLM 换 Qwen3-VL，加 TensorRT 部署（Jetson Thor 也能跑）——"端侧人形机器人"近在眼前；
• Isaac GR00T Blueprint：11 小时生成 78 万条仿真轨迹的合成数据流水线已开源；
• 与 Google DeepMind/Disney 合作的 Newton 物理引擎：比现有引擎快 5 倍，专门服务"生成物理可信的合成数据"。

一句话收尾：“从光子到动作”（from photons to actions）——这是 GR00T N1 的野心，也是整个具身智能赛道正在集体奔赴的终点。VLA 模型的下一个爆点，大概率不在模型本身，而在"谁能造出更大、更物理可信的数据金字塔"。

附录：关键信息速查

本文基于论文 arXiv:2503.14734v1（2025-03-18）与 NVIDIA/Isaac-GR00T 仓库（2026-07 版本）撰写。所有实验数据均引自论文原文，未做修改。