VLA 系统学习第 2 课：Behavior Cloning——机器人究竟怎么从示范中学动作？

从这一课开始，我们第一次真正进入 Robot Learning。

今天只解决一个核心问题：

如果我已经有很多"正确操作示范"，能不能让神经网络直接学会：

\ $\\text{Observation}\\rightarrow\\text{Action} \\$

答案就是：

Behavior Cloning

简称：

中文通常叫：

行为克隆。

1. 先不讲公式：什么叫 Behavior Cloning？

假设一个人正在操作机器人。

在某一个时刻：

复制代码

机器人看到：
物体在前方

机器人状态：
机械臂当前处于某个姿态

人类操作者：
让末端向前移动一点

我们把这一次记录下来：

复制代码

Observation → Human Action

然后再记录很多很多次：

复制代码

Observation 1 → Action 1
Observation 2 → Action 2
Observation 3 → Action 3
...
Observation N → Action N

最后得到一个数据集。

然后让神经网络学习：

当你以后看到类似 Observation 时，也输出类似 Action。

这就是 Behavior Cloning 最核心的思想。

2. 它其实和普通监督学习非常像

如果你以前见过图像分类：

复制代码

猫图片 → 猫
狗图片 → 狗
汽车图片 → 汽车

可以训练：

\ $\\text{Image}\\rightarrow\\text{Class} \\$

Behavior Cloning 做的事情非常类似：

复制代码

Observation → Action

也就是：

\ $\\text{Input}\\rightarrow\\text{Label} \\$

区别只是这里的"Label"不再是：

复制代码

猫
狗
汽车

而变成：

复制代码

机器人应该采取的动作

所以：

BC 本质上就是把模仿机器人专家操作的问题，转换成一个监督学习问题。

这是今天最核心的一句话。

3. 什么叫 Demonstration？

现在引入第一个正式术语：

Demonstration

中文：

示范数据 / 专家示范

假设人类遥操作机械臂完成了一次：

拿起方块。

机器人整个过程可能经历：

复制代码

t = 0
观察环境
→ 向物体靠近

t = 1
观察环境
→ 继续靠近

t = 2
观察环境
→ 向下移动

t = 3
观察环境
→ 关闭夹爪

t = 4
观察环境
→ 向上移动

这一整段就是一次：

Demonstration

也经常称作：

Trajectory

4. Trajectory 是什么？

Trajectory 可以写成：

\ $\\tau = (o_0,a_0,o_1,a_1,\\ldots,o_T,a_T) \\$

这里：

$\tau$：一条 trajectory；
$o_t$：第 $t$ 时刻的 observation；
$a_t$：第 $t$ 时刻专家执行的 action；
$T$：这一段轨迹的长度。

简单理解：

Trajectory 就是从任务开始到结束，按时间记录下来的一串 Observation 和 Action。

例如：

复制代码

Episode 001

Frame 0
image_000.png
state_000
action_000

Frame 1
image_001.png
state_001
action_001

Frame 2
image_002.png
state_002
action_002

...

以后看真实机器人数据集时，你会经常碰到：

Episode
Trajectory
Frame
Observation
Action
Timestamp

这些词。

5. Demonstration 从哪里来？

最常见的是：

复制代码

Human
 ↓
Teleoperation
 ↓
Robot

也就是：

人类遥操作机器人。

例如操作者通过：

手柄；
键盘；
主从机械臂；
VR 控制器；
3D 鼠标；
手持控制设备；

让机器人完成任务。

同时程序不断记录：

复制代码

Camera
Robot State
Action
Timestamp

最终形成训练数据。

6. 第一次认识 Robot Dataset

假设采集了 100 次抓取任务。

每一次都是一个 Episode：

复制代码

Dataset
│
├── Episode 000
│   ├── Frame 000
│   ├── Frame 001
│   ├── Frame 002
│   └── ...
│
├── Episode 001
│   ├── Frame 000
│   ├── Frame 001
│   └── ...
│
└── ...

某个 Frame 中可能包含：

复制代码

RGB Image
Robot State
Action
Timestamp

于是我们第一次建立：

\ $(o_t,a_t) \\$

训练样本。

7. BC 到底训练什么？

现在假设我们有：

\ $(o_t,a_t) \\$

其中 $a_t$ 是人类专家实际执行过的动作。

我们建立一个神经网络：

\ $\\pi_\\theta \\$

这里多出来了：

\ $\\theta \\$

它表示：

神经网络里所有可以学习的参数。

例如：

weight；
bias；
Transformer 参数；
Encoder 参数。

于是模型预测：

\ $\\hat a_t=\\pi_\\theta(o_t) \\$

注意：

\ $a_t \\$

和：

\ $\\hat a_t \\$

不是一个东西。

$a_t$

这是数据集中：

专家真正执行的 Action。

我们把它叫：

Ground Truth / Expert Action

$\hat a_t$

这是：

当前模型预测出来的 Action。

训练的目标就是：

\ $\\hat a_t\\approx a_t \\$

换句话说：

模型越来越像专家。

所以叫：

Behavior Cloning

行为克隆。

8. 第一个真正的 BC 数字例子

为了简单，假设 Action 只有两个维度：

\ $a_t= \[\\Delta x,\\Delta y$ \]

专家动作是：

\ $a_t= \[0.10,-0.05$ \]

但是当前神经网络预测：

\ $\\hat a_t= \[0.07,-0.01$ \]

那显然预测得不完全正确。

两个方向误差：

\ $0.07-0.10=-0.03 \\$

以及：

\ $-0.01-(-0.05)=0.04 \\$

模型需要根据这些误差进行调整。

这就是：

Loss

开始出现了。

9. BC 的 Loss 是干什么的？

Loss 可以理解为：

模型到底错得有多严重。

如果输出是连续 Action，可以使用一种非常简单的损失：

\ $L= \\\|\\hat a_t-a_t\\\|_2\^2 \\$

初学阶段先把它看成：

\ $L= (\\hat a_1-a_1)\^2+ (\\hat a_2-a_2)\^2+\\cdots \\$

也就是：

每个 Action 维度的预测误差平方，然后加起来。

例如：

\ $a=\[0.10,-0.05$ \]

预测：

\ $\\hat a=\[0.07,-0.01$ \]

那么：

\ $L= (0.07-0.10)\^2+ (-0.01+0.05)\^2 \\$

得到：

\ $L= (-0.03)\^2+(0.04)\^2 \\$ \ $L= 0.0009+0.0016 \\$ \ $L=0.0025 \\$

Loss 越小：

模型预测的 Action 越接近专家。

10. 所以 BC 的训练过程到底是什么？

现在第一次完整建立训练链路：

复制代码

Robot Dataset
      ↓
Observation
      ↓
Policy
      ↓
Predicted Action
      ↓
Compare with Expert Action
      ↓
Loss
      ↓
Backpropagation
      ↓
Update Parameters

数学上：

\ $\\hat a_t=\\pi_\\theta(o_t) \\$

计算：

\ $L(\\hat a_t,a_t) \\$

然后调整：

\ $\\theta \\$

使得 Loss 越来越小。

11. 这里第一次出现"训练"和"真正执行"的区别

这个地方非常重要。

训练时

模型拥有：

复制代码

Observation
+
正确答案 Action

也就是：

\ $o_t \\rightarrow \\pi_\\theta \\rightarrow \\hat a_t \\$

然后拿：

\ $\\hat a_t \\$

跟：

\ $a_t \\$

比较。

因此：

复制代码

模型预测
    ↓
和专家答案比较
    ↓
计算 Loss
    ↓
修改模型

12. 真正运行时却不一样

模型训练完成以后，真实执行：

复制代码

Observation
      ↓
Policy
      ↓
Predicted Action
      ↓
Robot executes it

这时候没有人告诉模型：

"正确答案应该是 0.1。"

也就是说：

Training

有专家答案：

\ $(o_t,a_t) \\$

Inference / Rollout

只有 Observation：

\ $o_t \\$

模型必须自己输出：

\ $\\hat a_t \\$

机器人随后真的执行这个预测结果。

13. 这一点为什么特别重要？

因为训练的时候：

你只是让模型"做题"。

执行的时候：

模型给出的答案会真的改变下一道题。

这一点是机器人学习和很多普通监督学习非常不同的地方。

14. 用一个例子理解

假设专家示范时：

复制代码

物体位于正前方
↓
专家向前移动 2 cm

模型学出来后预测：

复制代码

向前移动 2.2 cm

只差：

\ $0.2cm \\$

看起来非常小。

但是机器人真的执行以后：

它现在的位置已经和专家当时的位置不完全一样了。

于是下一帧：

\ $o_{t+1} \\$

也和训练数据里的专家 Observation 有一点不同。

然后模型又预测一次：

复制代码

专家本来应该向左 1 cm
模型却向左 0.7 cm

再次产生误差。

于是误差可能逐渐累积。

15. 这就是 BC 最经典的问题：Distribution Shift

今天第一次认识这个词。

Distribution

可以先理解成：

数据通常出现在哪些情况、长什么样。

训练数据来自专家操作。

所以训练阶段模型看到的大多数状态是：

专家正常操作时会到达的状态。

记作：

\ $p_{\\text{expert}}(o) \\$

但是模型真正控制机器人以后，自己会犯错。

于是它可能到达：

专家示范里从没出现过的奇怪状态。

这时候真实运行时观察的数据分布变成：

\ $p_{\\pi}(o) \\$

可能与专家数据不同：

\ $p_{\\pi}(o)\\neq p_{\\text{expert}}(o) \\$

这就是：

Distribution Shift

分布偏移。

16. 用开车理解 Distribution Shift

假设你只教一个学生：

复制代码

车永远在道路正中央的时候
方向盘应该怎么打

训练数据全是：

复制代码

车在正中央
→ 小幅调整

学生一开始可能只偏了 10 cm。

但是训练数据里面根本没有：

复制代码

车偏到左边 10 cm
该怎么纠正？

于是他继续操作错误。

变成：

复制代码

偏 20 cm

训练数据更没有这种状态。

继续错：

复制代码

偏 50 cm

最后冲出道路。

这个过程就是：

一点小错误把机器人带到了训练数据没覆盖的状态，模型在陌生状态继续犯错，最终误差越来越大。

17. BC 最大的问题并不是"训练 Loss 不够低"

这一点非常重要。

你以后很可能遇到：

复制代码

Training Loss 很低

但是：

复制代码

Robot Rollout 很差

这完全可能。

为什么？

因为：

训练时做得好，不代表闭环执行时做得好。

训练时模型面对的是：

\ $o_t\\sim D_{\\text{expert}} \\$

真正 Rollout 时：

\ $o_t\\sim D_{\\pi} \\$

两种数据分布可能逐渐不同。

18. 什么叫 Rollout？

又出现一个以后会非常高频的词：

Rollout

可以理解为：

让 Policy 真正连续执行一整段任务。

例如：

复制代码

Reset Environment
       ↓
Observation
       ↓
Policy
       ↓
Action
       ↓
Environment Changes
       ↓
New Observation
       ↓
Policy
       ↓
...
       ↓
Success / Failure

整个过程就叫一次：

Rollout

19. Training 和 Rollout 一定要分开

这两个词以后必须条件反射地区分。

Training

目的：

更新模型参数。

会发生：

复制代码

forward
loss
backward
optimizer.step()

Rollout

目的：

看这个 Policy 真正控制机器人能不能完成任务。

通常：

复制代码

model predicts action
↓
action executes
↓
new observation
↓
model predicts again

Rollout 通常不会做：

复制代码

loss.backward()optimizer.step()

20. 第一次认识 Offline Learning

经典 BC 通常可以先理解为：

Offline Learning

意思就是：

先把 Demonstration 收集好，再用这些固定数据训练。

流程：

复制代码

收集数据
   ↓
保存 Dataset
   ↓
结束数据采集
   ↓
训练 Policy
   ↓
部署 / Rollout

训练时并不要求机器人一边跑一边产生新的数据。

所以：

BC 是最典型、最基础的 Offline Imitation Learning 方法之一。

21. Behavior Cloning 和 Imitation Learning 是一回事吗？

不是严格等价。

关系更像：

复制代码

Imitation Learning
│
├── Behavior Cloning
├── DAgger
├── ...
└── 其他模仿学习方法

所以：

\ $\\text{Behavior Cloning}\\subset\\text{Imitation Learning} \\$

Imitation Learning 是更大的领域：

如何让智能体通过模仿专家学习行为。

BC 是里面最直接的一种：

把专家数据直接当监督学习数据训练。

22. BC 和 Reinforcement Learning 最大区别是什么？

先建立最简单的区别。

Behavior Cloning

老师直接告诉你：

这个状态下，正确动作是什么。

数据是：

\ $(o_t,a_t) \\$

模型模仿：

\ $o_t\\rightarrow a_t \\$

Reinforcement Learning

不一定告诉你正确 Action。

而是告诉你：

这个结果好不好。

例如：

复制代码

抓成功
Reward = +1

抓失败
Reward = 0

然后让 Policy 自己寻找：

什么 Action 能获得更高 Reward。

所以可以粗略理解：

复制代码

BC
老师给答案

RL
老师给分数

这个区别现在记住就够了。

23. 第一次建立 Tensor Shape

现在开始真正进入以后读代码时最重要的习惯。

假设：

batch size = $B$
RGB 图像大小 = $H\times W$
Robot State 维度 = $D_s$
Action 维度 = $D_a$

那么可能有：

\ $I_t\\in\\mathbb{R}\^{B\\times3\\times H\\times W} \\$ \ $s_t\\in\\mathbb{R}\^{B\\times D_s} \\$ \ $a_t\\in\\mathbb{R}\^{B\\times D_a} \\$

于是 Policy：

\ $\\pi_\\theta(I_t,s_t) \\rightarrow \\hat a_t \\$

输出：

\ $\\hat a_t\\in\\mathbb{R}\^{B\\times D_a} \\$

注意：

$D_s$ 和 $D_a$ 没有固定值。

以后必须根据具体 Dataset / Robot / Repository 确认。

24. 一个 Batch 到底是什么？

假设 Dataset 里有：

复制代码

Sample 1
Sample 2
Sample 3
...

训练时一般不会每次只拿一个。

比如一次拿：

\ $B=32 \\$

个样本。

那么：

复制代码

images
[B, 3, H, W]

states
[B, Ds]

actions
[B, Da]

这里的：

\ $B \\$

就是：

Batch Size

例如：

复制代码

images.shape
=
[32, 3, 224, 224]

意思就是：

现在一次输入神经网络 32 张 RGB 图像。

224 × 224 这里只是示例，不代表具体 VLA 的实际输入尺寸。

25. 最简单的 BC 神经网络长什么样？

先不考虑图片，只假设 Observation 是一串状态：

\ $o_t= \[x_1,x_2,\\ldots,x_{10}$ \]

也就是：

\ $D_o=10 \\$

Action：

\ $a_t= \[a_1,a_2,a_3$ \]

也就是：

\ $D_a=3 \\$

我们可以建立：

复制代码

Observation
[10]
 ↓
Linear
 ↓
ReLU
 ↓
Linear
 ↓
Action
[3]

也就是：

\ $\\mathbb{R}\^{10} \\rightarrow \\mathbb{R}\^{64} \\rightarrow \\mathbb{R}\^{3} \\$

26. 第一次看一个真正最小 BC PyTorch 模型

复制代码

import torchimport torch.nn as nnclass BCPolicy(nn.Module):    def __init__(self):        super().__init__()        self.net = nn.Sequential(            nn.Linear(10, 64),            nn.ReLU(),            nn.Linear(64, 3)        )    def forward(self, obs):        action = self.net(obs)        return action

现在不要急着自己写。

我们逐行看。

`class BCPolicy(nn.Module):`

定义一个类：

复制代码

BCPolicy

它继承：

复制代码

nn.Module

nn.Module 是 PyTorch 神经网络模块的基础类。

因此可以把：

复制代码

BCPolicy

理解成：

我们自己定义的一种神经网络。

`init`

复制代码

def __init__(self):

这是初始化函数。

当你真正创建：

复制代码

model = BCPolicy()

的时候，会调用它。

这里定义网络包含哪些层。

`nn.Linear(10, 64)`

表示：

\ $10\\rightarrow64 \\$

输入：

复制代码

[B, 10]

输出：

复制代码

[B, 64]

`nn.ReLU()`

加入非线性。

以后深度学习课会更系统地解释。

`nn.Linear(64, 3)`

把：

复制代码

[B, 64]

变成：

复制代码

[B, 3]

这三个数字就是预测 Action。

27. `forward()` 到底在干嘛？

复制代码

def forward(self, obs):    action = self.net(obs)    return action

输入：

复制代码

obs
[B, 10]

经过：

复制代码

self.net

输出：

复制代码

action
[B, 3]

所以：

\ $\[B,10$ \rightarrow BCPolicy \rightarrow $B,3$ \]

这就是我们前面一直讲的：

\ $\\text{Observation}\\rightarrow\\text{Action} \\$

第一次真正落到代码上。

28. Training 怎么写？

训练时可能出现：

复制代码

pred_action = model(obs)loss = loss_fn(pred_action, expert_action)optimizer.zero_grad()loss.backward()optimizer.step()

先只看数据流：

复制代码

obs
 ↓
model
 ↓
pred_action
 ↓
compare with expert_action
 ↓
loss
 ↓
backward
 ↓
update model

对应数学：

\ $\\hat a=\\pi_\\theta(o) \\$

然后：

\ $L(\\hat a,a) \\$

再利用梯度更新：

\ $\\theta \\$

29. 但是机器人图片怎么办？

刚才那个模型只有：

复制代码

state → action

实际 Robot Learning 往往还有：

复制代码

Image
+
Robot State

于是结构可能变成：

复制代码

RGB Image
   ↓
Vision Encoder
   ↓
Image Feature
        \
         \
Robot State → State Encoder
         /
        /
    Fusion
       ↓
    Policy
       ↓
    Action

数学上：

\ $z_I=f_{\\text{vision}}(I_t) \\$ \ $z_s=f_{\\text{state}}(s_t) \\$

然后融合：

\ $z=\[z_I;z_s$ \]

最终：

\ $\\hat a_t=f_{\\text{policy}}(z) \\$

现在只需要知道这个结构。

后面进入 ACT、Diffusion Policy、VLA 后，模型内部会越来越复杂，但基本数据流不会凭空消失。

30. 加上语言以后呢？

继续增加：

复制代码

Image
  ↓
Vision Encoder
  ↓
Vision Feature
       \
Language → Language Encoder
       \
Robot State → State Encoder
         ↓
       Fusion
         ↓
       Policy
         ↓
       Action

于是可以写：

\ $\\hat a_t = \\pi_\\theta(I_t,s_t,l) \\$

你现在应该能看懂这个公式了。

这就是第一课和第二课连起来的地方。

31. VLA 和 BC 的关系终于出现了

这里非常关键。

BC 并不是 VLA 的竞争对手。

很多 Robot Policy / VLA 的训练，本质上仍然在做：

给定 Observation 和 Instruction，模仿 Dataset 中正确的 Action。

也就是说：

\ $(I_t,s_t,l)\\rightarrow a_t \\$

模型再复杂：

Transformer；
VLM；
Action Chunk；
Diffusion；
Flow Matching；

都可能依然依赖大量 expert demonstration。

所以：

Behavior Cloning 是理解现代 Robot Learning 和 VLA 的地基之一。

32. 为什么不用 BC 永远解决所有问题？

因为 BC 有几个根本问题。

首先是刚才讲的：

Distribution Shift

模型犯一点错误后进入陌生状态。

其次：

数据覆盖问题

如果 Dataset 里没有：

复制代码

物体摆在左上角

模型可能不知道怎么办。

还有：

Demonstration Quality

如果专家数据很差：

复制代码

动作抖动
轨迹绕远
偶尔失败
操作不一致

模型也会把这些行为学进去。

所以：

BC 能学到什么，非常依赖数据。

33. 一句话概括 BC

现在应该能够自己说出：

Behavior Cloning 是一种监督式模仿学习方法，通过专家 Demonstration 中的 Observation-Action 对训练 Policy，使 Policy 在给定 Observation 时预测专家 Action。

数学上：

\ $\\hat a_t=\\pi_\\theta(o_t) \\$

训练：

\ $\\min_\\theta \\sum_t L\\left( \\pi_\\theta(o_t), a_t \\right) \\$

不要被这个公式吓到。

它只是说：

调整模型参数 $\theta$，让模型预测 Action 和专家 Action 的差距尽可能小。

34. 今天新增的核心术语

这一课至少要真正理解下面这些词：

术语	现在应该怎么理解
Demonstration	专家操作机器人产生的示范数据
Trajectory	按时间排列的一整段 Observation 和 Action
Episode	一次完整任务记录
Behavior Cloning	用监督学习模仿专家 Action
Expert Action	数据集中专家真正执行的 Action
Predicted Action	Policy 当前预测的 Action
Loss	衡量预测 Action 和专家 Action 有多大差距
Training	用 Loss 更新模型参数
Inference	模型根据新 Observation 预测 Action
Rollout	Policy 连续控制机器人完成一整段任务
Distribution Shift	运行时进入训练数据没覆盖的状态
Offline Learning	先收集固定数据，再进行训练

35. 把前两课合成完整链条

现在我们已经从：

复制代码

Camera
+
Robot State
+
Language

前进到了：

复制代码

Human Demonstration
        ↓
Robot Dataset
        ↓
Observation + Expert Action
        ↓
Train Policy
        ↓
Policy learns
Observation → Action
        ↓
Rollout
        ↓
Robot executes predicted Action
        ↓
New Observation
        ↓
Policy predicts again

这就是 Robot Learning 最基础的一条训练---执行闭环。

第二课自测

1

Behavior Cloning 为什么属于监督学习？

2

下面两个量有什么区别？

\ $a_t \\$

和：

\ $\\hat a_t \\$

3

一条：

\ $\\tau=(o_0,a_0,o_1,a_1,\\ldots,o_T,a_T) \\$

表示什么？

4

为什么：

复制代码

Training Loss 很低

却可能：

复制代码

Robot Rollout 很差

5

什么叫 Distribution Shift？请尽量不用定义，而是用"模型犯了一点错误以后发生什么"解释。

6

下面四件事应该按什么顺序发生？

复制代码

Loss
Predicted Action
Observation
Expert Action

7

假设：

复制代码

obs.shape    = [32, 10]
action.shape = [32, 7]

请解释：

32 是什么？
10 是什么？
7 是什么？

VLA 系统学习第 2 课：Behavior Cloning——机器人究竟怎么从示范中学动作？

Behavior Cloning

1. 先不讲公式：什么叫 Behavior Cloning？

2. 它其实和普通监督学习非常像

3. 什么叫 Demonstration？

Demonstration

4. Trajectory 是什么？

5. Demonstration 从哪里来？

6. 第一次认识 Robot Dataset

7. BC 到底训练什么？

\(a_t\)

\(\hat a_t\)

8. 第一个真正的 BC 数字例子

9. BC 的 Loss 是干什么的？

10. 所以 BC 的训练过程到底是什么？

11. 这里第一次出现"训练"和"真正执行"的区别

训练时

12. 真正运行时却不一样

Training

Inference / Rollout

13. 这一点为什么特别重要？

14. 用一个例子理解

15. 这就是 BC 最经典的问题：Distribution Shift

Distribution

16. 用开车理解 Distribution Shift

17. BC 最大的问题并不是"训练 Loss 不够低"

18. 什么叫 Rollout？

19. Training 和 Rollout 一定要分开

Training

Rollout

20. 第一次认识 Offline Learning

21. Behavior Cloning 和 Imitation Learning 是一回事吗？

22. BC 和 Reinforcement Learning 最大区别是什么？

Behavior Cloning

Reinforcement Learning

23. 第一次建立 Tensor Shape

24. 一个 Batch 到底是什么？

25. 最简单的 BC 神经网络长什么样？

26. 第一次看一个真正最小 BC PyTorch 模型

class BCPolicy(nn.Module):

__init__

nn.Linear(10, 64)

nn.ReLU()

nn.Linear(64, 3)

27. forward() 到底在干嘛？

28. Training 怎么写？

29. 但是机器人图片怎么办？

30. 加上语言以后呢？

31. VLA 和 BC 的关系终于出现了

32. 为什么不用 BC 永远解决所有问题？

Distribution Shift

数据覆盖问题

Demonstration Quality

33. 一句话概括 BC

34. 今天新增的核心术语

35. 把前两课合成完整链条

第二课自测

1

2

3

4

5

6

7

`class BCPolicy(nn.Module):`

`init`

`nn.Linear(10, 64)`

`nn.ReLU()`

`nn.Linear(64, 3)`

27. `forward()` 到底在干嘛？