第三课标准答案：Robot Dataset

1. 为什么 100 个 Episode 不代表只有 100 个训练样本？

因为：

Episode 是一次完整任务，而训练样本可以来自 Episode 内部的每个时间点。

例如：

\[ 100\text{ episodes} \]

每个 Episode 有：

\[ 100\text{ frames} \]

那么最简单情况下就可能有约：

\[ 100\times100=10000 \]

个：

\[ (o_t,a_t) \]

训练对。

所以：

\[ \boxed{ Episode数量\neq Sample数量 } \]

---

2. dataset[10] 和 dataloader 分别负责什么？

dataset[10]：

从 Dataset 中获取第 10 个 Sample。

它通常触发：

__getitem__(10)

例如得到：

{    "image": image,    "state": state,    "action": action}

而 DataLoader：

从 Dataset 中不断获取多个 Sample，并把它们组织成 Batch。

所以：

Dataset
→ 一个Sample怎么取

DataLoader
→ 多个Sample怎么组织、批量送入训练

---

3. 为什么

\[ [3,224,224] \]

会变成：

\[ [32,3,224,224] \]

？

因为：

\[ [3,224,224] \]

是一张 RGB 图片。

如果 DataLoader 一次取 32 个样本：

image1 [3,224,224]
image2 [3,224,224]
...
image32 [3,224,224]

把它们堆起来：

\[ [32,3,224,224] \]

最前面的：

\[ 32 \]

就是 Batch Dimension。

---

4. 为什么 Training 有 Expert Action，但 Rollout 没有？

Training 使用的是提前收集好的专家 Dataset。

所以数据本身包含：

\[ (o_t,a_t) \]

模型可以拿：

\[ a_t \]

作为正确答案。

但 Rollout 时面对的是实时环境：

Environment
↓
Observation
↓
Policy

没有专家在旁边实时告诉模型：

这一刻正确动作应该是什么。

所以模型必须自己产生：

\[ \hat a_t \]

并真正执行它。

---

5. 为什么训练和推理的 normalization 要一致？

假设训练时：

\[ x'= \frac{x-\mu}{\sigma} \]

模型从来没有直接看到原始 \(x\)。

它看到的都是：

\[ x' \]

如果推理时突然把原始数据：

\[ x \]

直接送进去，那么模型面对的数据尺度发生变化。

例如训练阶段它习惯：

\[ [-1,1] \]

推理阶段却突然输入：

\[ [-180,180] \]

模型当然可能表现很差。

所以：

\[ \boxed{ \text{训练时怎么处理输入} \approx \text{推理时怎么处理输入} } \]

---

6. 从机器人示范到 model(obs) 的完整过程

应该能够说出：

人类操作机器人
↓
记录很多Episode
↓
每个时间点记录Observation和Expert Action
↓
保存到磁盘
↓
Dataset读取数据
↓
__getitem__返回一个Sample
↓
DataLoader收集多个Sample
↓
组成Batch
↓
取出Observation
↓
送入model

所以：

pred_action = model(obs)

里的 obs

其实已经经过了很长的数据准备链。

---

四、VLA 系统学习第 4 课：一个 Batch 进入神经网络后，模型到底是怎么“学会”的？

现在我们已经成功走到了：

for batch in dataloader:    obs = batch["observation"]    action = batch["action"]

假设：

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

现在出现真正关键的问题：

这 32 个训练样本进入神经网络以后，模型为什么会发生变化？

也就是：

\[ \boxed{ Batch \rightarrow Forward \rightarrow Prediction \rightarrow Loss \rightarrow Backward \rightarrow Optimizer \rightarrow Parameters\ Updated } \]

这条链，是 PyTorch 训练最核心的一条链。

---

1. 首先搞清楚：模型真正“学”的是什么？

看一个最简单模型：

model = nn.Linear(10, 7)

它表示：

\[ \mathbb R^{10} \rightarrow \mathbb R^7 \]

也就是：

10维Observation
↓
Linear
↓
7维Action

数学上：

\[ \hat a=xW+b \]

这里：

• \(x\)：Observation；
• \(W\)：权重；
• \(b\)：偏置；
• \(\hat a\)：模型预测的 Action。

真正训练过程中被修改的，不是：

\[ x \]

也不是：

\[ a \]

而是：

\[ \boxed{W,b} \]

这些统称：

\[ \theta \]

所以：

\[ \pi_\theta \]

中的：

\[ \theta \]

就是模型里所有可以学习的参数。

---

2. 先看一个只有一个数字的模型

先不直接上矩阵。

假设模型特别简单：

\[ \hat y=wx \]

只有一个参数：

\[ w \]

现在训练数据告诉我们：

\[ x=2 \]

正确答案：

\[ y=6 \]

假设初始：

\[ w=1 \]

那么模型第一次预测：

\[ \hat y=wx \]

得到：

\[ \hat y=1\times2=2 \]

但是正确答案是：

\[ 6 \]

明显错了。

于是我们需要回答：

应该怎么修改 \(w\)，才能让下一次预测更接近 6？

这就是训练问题的核心。

---

3. Forward：先让当前模型做一次预测

模型目前：

\[ w=1 \]

输入：

\[ x=2 \]

运行：

\[ \hat y=wx \]

得到：

\[ \hat y=2 \]

这个过程叫：

Forward

也就是：

从输入开始，按照神经网络当前参数一路向前计算，最终得到预测结果。

在 PyTorch：

pred = model(x)

就是在进行 Forward。

放回 BC：

\[ \hat A=\pi_\theta(O) \]

代码：

pred_action = model(obs)

就是：

用当前 Policy 对这一批 Observation 预测 Action。

---

4. Forward 以后为什么还不能训练？

因为现在只知道：

\[ \hat y=2 \]

模型还不知道：

2 到底好不好？

必须拿正确答案：

\[ y=6 \]

进行比较。

于是需要：

Loss

例如使用平方误差：

\[ L=(\hat y-y)^2 \]

代入：

\[ L=(2-6)^2 \]

所以：

\[ L=16 \]

现在我们有了一个数字：

\[ 16 \]

它告诉我们：

当前模型预测得有多差。

但是仍然没有解决：

\(w\) 应该往哪个方向改？

---

5. 真正核心问题：怎么知道参数应该变大还是变小？

现在：

\[ \hat y=wx \]

同时：

\[ L=(wx-y)^2 \]

这里 Loss 其实是参数 \(w\) 的函数：

\[ L(w) \]

我们的目标就是：

\[ \boxed{\text{让 }L(w)\text{ 尽可能小}} \]

于是我们要问：

如果 \(w\) 稍微变大一点，Loss 会变大还是变小？

这就是：

梯度 Gradient

开始出现的地方。

---

6. 先不用微积分理解梯度

现在：

\[ w=1 \]

Loss：

\[ L=16 \]

试着把 \(w\) 调大一点：

\[ w=1.1 \]

那么：

\[ \hat y=1.1\times2=2.2 \]

Loss：

\[ L=(2.2-6)^2=14.44 \]

发现：

\[ 16\rightarrow14.44 \]

Loss 下降了。

说明：

当前这个位置，把 \(w\) 往大的方向调整是对的。

如果一直调：

\[ w=3 \]

那么：

\[ \hat y=3\times2=6 \]

Loss：

\[ L=0 \]

于是训练就找到了一个非常好的参数。

问题是：

真正的神经网络有几百万甚至几十亿参数，不可能一个一个试。

所以我们需要一个数学工具直接告诉每个参数：

你应该增加还是减少，以及大概改多少。

这个东西就是：

\[ \frac{\partial L}{\partial w} \]

也就是 Loss 对参数的：

Gradient

---

7. Gradient 到底表达什么？

\[ \frac{\partial L}{\partial w} \]

初学阶段可以先读成：

如果 \(w\) 稍微变化一点，Loss 会朝哪个方向、变化多快？

例如：

\[ \frac{\partial L}{\partial w}>0 \]

说明：

\(w\) 增大，会使 Loss 增大。

那我们为了让 Loss 下降，就应该让：

\[ w \]

减小。

反过来：

\[ \frac{\partial L}{\partial w}<0 \]

说明增加 \(w\) 会让 Loss 下降。

---

8. 为什么更新参数时有一个负号？

经典梯度下降：

\[ w_{\text{new}} = w_{\text{old}} - \eta \frac{\partial L}{\partial w} \]

这里：

\[ \eta \]

叫：

Learning Rate

学习率。

核心就是那个负号：

\[ - \]

因为梯度告诉你：

Loss 上升最快的方向。

我们想让 Loss 下降，所以反着走。

因此叫：

Gradient Descent

梯度下降。

---

9. Backward 到底干什么？

现在回到 PyTorch。

我们已经：

pred_action = model(obs)

得到预测。

然后：

loss = loss_fn(pred_action, action)

得到 Loss。

接下来：

loss.backward()

这里不是：

把数据倒着跑一遍。

它真正做的是：

利用反向传播算法，计算 Loss 对模型中所有可训练参数的梯度。

也就是计算很多：

\[ \frac{\partial L}{\partial \theta_1}, \frac{\partial L}{\partial \theta_2}, \ldots \]

假设网络里有：

1000000 个参数

PyTorch 会帮你计算：

第1个参数应该怎么变
第2个参数应该怎么变
...
第1000000个参数应该怎么变

严格来说，它计算的是这些参数对应的：

gradient

并把结果存在参数的：

parameter.grad

里面。

---

10. 一个非常容易混淆的问题：backward() 会修改参数吗？

不会。

这点一定要记住。

loss.backward()

只是：

\[ \boxed{\text{计算梯度}} \]

例如模型当前参数：

\[ w=1 \]

调用：

loss.backward()

以后：

\[ w \]

本身仍然可能还是：

\[ 1 \]

只是现在多得到：

\[ w.grad \]

告诉我们它应该往哪个方向改。

真正改参数的是下一步。

---

11. optimizer.step() 才真正修改参数

例如：

optimizer.step()

Optimizer 会读取：

parameter.grad

再按照自己的更新规则修改参数。

最简单可以理解成：

\[ \theta_{\text{new}} = \theta_{\text{old}} - \eta\nabla_\theta L \]

所以：

backward()
→ 算应该怎么改

optimizer.step()
→ 真的去改

这两个职责一定要分开。

---

12. 为什么还需要 optimizer.zero_grad()？

现在 PyTorch 经典训练代码通常是：

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

其中最奇怪的可能是：

optimizer.zero_grad()

为什么要清零？

因为 PyTorch 中梯度默认会：

累加。

假设第一次：

\[ grad=2 \]

下一次又算出：

\[ grad=3 \]

如果不清空，可能变成：

\[ grad=5 \]

但普通训练通常希望：

当前 Batch 只根据当前 Batch 的梯度更新。

所以每一轮先：

optimizer.zero_grad()

把上一个 Batch 留下的梯度清掉。

---

13. 现在完整理解这五行

终于可以完整解释：

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

它们不是五个需要死记的命令。

而是一条非常严密的数据链：

第一步

optimizer.zero_grad()

清除上一批数据留下的梯度。

---

第二步

pred_action = model(obs)

Forward：

\[ O \rightarrow \pi_\theta \rightarrow \hat A \]

用当前参数进行预测。

---

第三步

loss = loss_fn(pred_action, action)

比较：

\[ \hat A \]

和：

\[ A \]

得到：

\[ L \]

---

第四步

loss.backward()

计算：

\[ \nabla_\theta L \]

也就是每个模型参数对应的梯度。

---

第五步

optimizer.step()

利用梯度真正更新：

\[ \theta \]

于是模型和刚才相比已经变了一点。

下一批数据进来的时候：

\[ \pi_{\theta_{\text{new}}} \]

已经不是刚才那个 Policy 了。

---

14. 把一个 Batch 真正串起来

假设：

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

进入：

pred_action = model(obs)

得到：

\[ pred\_action.shape=[32,7] \]

也就是：

32个样本
每个样本预测7维Action

然后：

loss = loss_fn(pred_action, action)

比较：

\[ [32,7] \]

与：

\[ [32,7] \]

Loss 函数把这一批预测误差综合起来，最终通常得到一个标量：

\[ L\in\mathbb R \]

例如：

loss = 0.032

然后：

loss.backward()

从这个标量 Loss 一路反向追踪：

Loss
↓
Predicted Action
↓
最后一层
↓
前面的隐藏层
↓
第一层

计算各层参数的 Gradient。

最后：

optimizer.step()

修改这些参数。

这就是：

\[ \boxed{ [32,10] \rightarrow [32,7] \rightarrow Loss \rightarrow Gradient \rightarrow Parameter Update } \]

---

15. 为什么 Loss 最后通常是一个数？

因为模型可能一次预测：

\[ 32\times7=224 \]

个数字。

每个数字都有误差。

如果每个误差都单独存在，我们就很难用一句话描述：

当前模型到底有多差？

所以 Loss 函数通常把很多误差：

样本1的误差
样本2的误差
...
所有Action维度误差

汇总成一个标量：

\[ L \]

这样才能明确做优化：

\[ \min_\theta L \]

也就是：

找到一组模型参数，让总体 Loss 尽可能小。

---

16. Epoch 又是怎么来的？

假设 Dataset 一共有：

\[ 3200 \]

个 Sample。

Batch Size：

\[ 32 \]

那么大约有：

\[ \frac{3200}{32}=100 \]

个 Batch。

程序执行：

for batch in dataloader:

把这 100 个 Batch 都训练一遍。

这叫：

1 Epoch

也就是：

整个训练 Dataset 大体被模型看过一遍。

然后继续第二次：

Epoch 2

第三次：

Epoch 3

模型不断重复学习数据。

---

17. Step 和 Epoch 不要混淆

例如：

Dataset = 3200 samples
Batch Size = 32

那么：

\[ 100\text{ batches} \]

每执行一次：

optimizer.step()

通常称为一个：

Training Step

于是：

\[ 1\text{ Epoch}\approx100\text{ Steps} \]

如果训练：

\[ 10\text{ Epochs} \]

大约就是：

\[ 1000\text{ Steps} \]

当然实际情况还会受 drop_last、sampler 等影响，后面再讲。

现在理解基本关系即可。

---

18. 为什么模型不是一次就学会？

因为刚开始：

\[ \theta \]

通常是随机初始化，或者来自预训练模型。

第一次看到一个 Batch 后只进行一次小更新：

\[ \theta_0 \rightarrow \theta_1 \]

下一批：

\[ \theta_1 \rightarrow \theta_2 \]

再下一批：

\[ \theta_2 \rightarrow \theta_3 \]

经过很多 Step：

\[ \theta_0 \rightarrow \theta_1 \rightarrow \cdots \rightarrow \theta_N \]

模型才逐渐形成：

\[ Observation\rightarrow Action \]

之间的映射。

所以所谓：

“神经网络在学习”

从最底层看，并不神秘。

实际上就是：

\[ \boxed{ 不断计算误差 \rightarrow 计算梯度 \rightarrow 一点一点修改参数 } \]

---

19. 一段真正完整的最小 BC Training Loop

现在再来看代码，就能把前四课串起来：

for batch in dataloader:    obs = batch["observation"]    action = batch["action"]    optimizer.zero_grad()    pred_action = model(obs)    loss = loss_fn(pred_action, action)    loss.backward()    optimizer.step()

完整调用逻辑：

Dataset
↓
__getitem__()
↓
Sample
↓
DataLoader
↓
Batch
↓
obs / expert action
↓
model(obs)
↓
Forward
↓
predicted action
↓
Loss
↓
Backward
↓
Gradient
↓
optimizer.step()
↓
Model Parameters Updated

这就是目前为止我们建立起来的第一条完整 Robot Learning 训练链。

---

20. 训练完以后发生了什么？

训练结束以后，模型内部已经保存了一组学到的参数：

\[ \theta^\* \]

我们把它保存下来：

Checkpoint

之后推理时：

New Observation
↓
Model with θ*
↓
Predicted Action

这时：

• 不需要 Expert Action；
• 不需要计算 Loss；
• 不需要 backward()；
• 不需要 optimizer.step()。

因为现在不是训练，而是在：

Inference / Rollout

所以：

Training
需要：
Forward + Loss + Backward + Update

而：

Inference
主要需要：
Forward

这是一个非常重要的区别。

---

第四课整章链路回看

到这里你应该能够连续说出：

\[ \boxed{ Robot\ Demonstration \rightarrow Dataset \rightarrow DataLoader \rightarrow Batch \rightarrow Forward \rightarrow Predicted\ Action \rightarrow Loss \rightarrow Backward \rightarrow Gradient \rightarrow Optimizer \rightarrow Parameter\ Update } \]

其中：

\[ \theta \]

是模型真正学习的参数；

\[ \hat A=\pi_\theta(O) \]

是 Forward；

\[ L(\hat A,A) \]

衡量模型预测和专家动作之间的差距；

\[ \nabla_\theta L \]

告诉我们参数应该如何改变；

loss.backward() 负责计算梯度；

optimizer.step() 才真正修改参数。

---

第四课自测

1. loss.backward() 和 optimizer.step() 的职责有什么区别？

2. 为什么每个 Batch 前通常要调用 optimizer.zero_grad()？

3. 模型真正“学到”的东西存在哪里？Observation、Loss 还是参数 \(\theta\)？

4. 如果：

\[ obs:[32,10] \]

经过 Policy 输出：

\[ pred\_action:[32,7] \]

Expert Action 是：

\[ action:[32,7] \]

那么 Loss 最后通常是什么 Shape？

5. 一个 Dataset 有 6400 个 Sample，Batch Size 是 64。忽略特殊情况，一个 Epoch 大约有多少个 Training Step？

6. Training 和 Inference 为什么都需要 Forward，但只有 Training 需要 Backward？