2026-06-16

HIL-SERL 在 pi0.5 上的在线强化学习部署

面向完全不了解强化学习术语的读者。本文先用直观语言解释整体系统，再解释每个术语，最后给出必要的理论公式。

面向完全不了解强化学习术语的读者。本文先用直观语言解释整体系统，再解释每个术语，最后给出必要的理论公式和一段可以直接用于汇报的讲解稿。

1. 一句话概括

本项目想做的是：让 pi0.5 先给机器人一个“基础动作”，再让 HIL-SERL 在线学习一个“小修正动作”，并允许人在机器人做错时接管；系统会把人的接管数据立刻变成新的训练数据，让机器人边执行边变好。

可以把它理解成三层：

1. pi0.5 / VLA 基础策略：根据图像和任务指令，给出一个大体合理的动作。

2. SERL 强化学习策略：学习一个残差动作，用来补偿真实世界误差、任务差异和 pi0.5 不够精确的地方。

3. HIL 人类干预：人看到机器人要失败时接管，系统记录人的动作，并把它当成高质量示范继续训练。

2. 先看整体架构图

flowchart LR
  subgraph RobotSide[机器人端 / Actor]
    Cam[相机图像<br/>head / wrist]
    RobotState[机器人状态<br/>关节 / 夹爪]
    Task[任务指令<br/>例如: pick the cube]
    Pi05[pi0.5 基础策略<br/>输出 base_action]
    SERLActor[SERL Actor 策略<br/>输出 residual_action]
    Merge[动作合成<br/>final_action = base + residual]
    Human[人类操作者<br/>键盘 / SpaceMouse / 示教]
    Env[真实机器人或仿真环境]
  end
  subgraph LearnerSide[训练端 / Learner]
    Replay[在线 Replay Buffer<br/>机器人刚采到的数据]
    Demo[Demo Buffer<br/>离线示范 + 人类接管数据]
    SAC[SAC / RLPD 更新<br/>训练 actor 和 critic]
    Params[最新策略参数]
  end
  Cam --> Pi05
  RobotState --> Pi05
  Task --> Pi05
  Pi05 -->|base_action| SERLActor
  Cam --> SERLActor
  RobotState --> SERLActor
  SERLActor -->|residual_action| Merge
  Pi05 -->|base_action| Merge
  Merge --> Env
  Human -->|必要时接管| Env
  Env -->|transition 轨迹数据| Replay
  Env -->|intervention 数据| Demo
  Replay --> SAC
  Demo --> SAC
  SAC --> Params
  Params -->|广播新参数| SERLActor

图中最重要的是这个闭环：

采样数据 → 训练更新 → 下发新策略 → 再采样更好的数据 → 再训练

这就是“在线强化学习”。

3. 本项目代码中对应哪些部分

注意：当前 realworld_finetune_pi05 分支里 config.get_environment() 固定返回 mock/stub 环境。也就是说，代码结构已经为 pi0.5 接入预留好了观测和动作格式，但真实部署时还需要把 stub 环境替换成真实的 pi0.5 + 机器人控制环境。

4. 初学者术语表

4.1 强化学习 RL

强化学习，英文 Reinforcement Learning，简称 RL。它解决的问题是：

一个智能体 agent 在环境 environment 里不断行动，环境给它奖励 reward，智能体通过试错学习什么动作更好。

最简单例子：

• 状态 state：机器人看到的图像、关节角、夹爪状态。

• 动作 action：机器人下一步移动多少、夹爪开还是关。

• 奖励 reward：任务成功给 +1，失败或无进展给 0 或负数。

• 策略 policy：从状态到动作的函数，即“机器人看到当前情况后应该怎么动”。

4.2 Agent / Environment

4.3 Policy / Actor

Policy 是策略，通常记作：

含义是：

在状态 s 下，策略用参数 θ 决定选择动作 a 的概率。

在深度强化学习里 πθ 通常是一个神经网络。Actor 有两个含义：

1. 算法里，actor 指输出动作的策略网络。

2. 分布式训练里，actor 指机器人端采集数据的进程。

本项目两个含义都会出现。为了避免混淆：

• actor 网络：SAC 里的策略网络。

• actor 进程：机器人端运行 run_actor_exp.sh 的进程。

4.4 Critic / Q 函数

Critic 是评价者，它不直接控制机器人，而是估计一个动作好不好。它学习的是 Q 函数：

含义是：

在状态 s 执行动作 a，未来总共能拿到多少奖励。

如果 Q(s, a) 很大，说明这个动作可能很好；如果很小，说明这个动作可能不好。

4.5 Replay Buffer

Replay Buffer 是经验池。机器人每执行一步，会产生一条 transition：

(observation, action, reward, next_observation, done)

也就是：

我在什么状态 → 做了什么动作 → 得到什么奖励 → 到了什么新状态 → 是否结束

这些 transition 会被放进 replay buffer，learner 训练时从里面随机抽样。本项目中有两个核心 buffer：

1. Replay Buffer：在线采集到的所有机器人经验。

2. Demo Buffer：离线示范数据 + 人类在线接管数据。

4.6 Demo / Demonstration

Demo 是人类或已有策略做出的示范轨迹。例如人用遥操作器完成一次任务，系统记录每一步图像、机器人状态和动作，这条轨迹就是 demo。

Demo 很重要，因为真实机器人不适合从零乱试：

• 从零探索效率低。

• 容易撞坏物体或机器人。

• 稀疏奖励任务很难随机成功。

所以本项目先用 demo 启动训练，再在线继续改进。

4.7 Online RL

在线强化学习是指：

机器人一边运行，一边把新数据传给 learner；learner 一边训练，一边把新策略发回机器人。

和离线训练相比：

4.8 HIL

HIL 是 Human-in-the-Loop，人类在环。意思是：

训练和部署时，人不是只在旁边看，而是可以实时介入系统。

在本项目中，人类介入有两个作用：

1. 安全：机器人要撞、要失败、要做错时，人可以接管。

2. 学习：接管动作被记录下来，变成新的专家示范。

所以 HIL 不是简单的“人工遥控”，而是把人的纠正动作转化为训练信号。

4.9 SERL

SERL 通常指 Sample Efficient Robotic Reinforcement Learning，即样本高效的机器人强化学习框架。本项目里的 SERL 主要特点是：

• 使用 demo 数据帮助启动学习。

• 使用 replay buffer 提高数据利用率。

• 使用视觉编码器处理相机图像。

• 支持机器人端 actor 和训练端 learner 分布式运行。

• 支持人类干预数据进入 demo buffer。

4.10 RLPD

RLPD 可以理解成：

Reinforcement Learning with Prior Data，用已有示范数据加速在线强化学习。

本项目的核心做法是训练 batch 一半来自在线 replay，一半来自 demo：

batch = 50% online replay data + 50% demo data

这样既能学习当前机器人真实遇到的新情况，又不会忘掉人类示范中的正确行为。

4.11 SAC

SAC 是 Soft Actor-Critic，是一种常用的连续控制强化学习算法。它适合机器人控制，因为机器人动作通常是连续值，例如：

关节 1 增加 0.01 rad 关节 2 减少 0.02 rad 夹爪闭合一点

SAC 的特点是：

• 有 actor：负责输出动作。

• 有 critic：负责评价动作好坏。

• 有 entropy：鼓励策略保持一定探索性，不要过早僵化。

• 是 off-policy 算法：可以反复使用 replay buffer 里的旧数据。

4.12 pi0.5 / VLA

pi0.5 可以理解成一个 VLA 模型。VLA 是 Vision-Language-Action：

例如输入：

图像：桌上有一个方块 语言：pick up the cube

pi0.5 输出：

机械臂下一步应该往哪里动，夹爪应该怎么动

在本文方案里，pi0.5 不是被强化学习完全替代，而是作为基础策略提供 base_action。

4.13 Residual RL

Residual RL 是残差强化学习。它不让 RL 从零学习完整动作，而是学习一个修正量：

其中：

• a_base：pi0.5 输出的基础动作。

• Δa：SERL 学出来的残差动作。

• λ：残差缩放系数，防止修正太大。

• a_final：最终发给机器人的动作。

这样做的好处：

1. pi0.5 负责“会做大概动作”。

2. SERL 负责“适配当前真实场景”。

3. 人类干预负责“防止坏动作并提供纠正”。

5. pi0.5 接入本项目的数据形式

当前 realworld_finetune_pi05 配置中，观测和动作已经按 residual RL 思路设计。

5.1 观测 Observation

一条观测可以理解为：

observation = { images: { wrist_1: 左腕相机 RGB 图像, head: 头部相机 RGB 图像 }, state: { joint_positions: 6 维关节位置, gripper_pose: 1 维夹爪状态, base_action: pi0.5 当前输出的 7 维基础动作 } }

在配置里：

• wrist_1 对应 left_wrist_image。

• head 对应 head_image。

• base_action 是 pi0.5 / VLA 输出的当前基础动作。

5.2 动作 Action

当前 pi0.5 实验的动作空间是 8 维：

action[0:6] = 6 个关节 residual action[6] = 夹爪 residual action[7] = hybrid grasp 分支占位或辅助维度

可以画成：

flowchart TB
  A[pi0.5 输出 base_action<br/>7 维: 6 关节 + 夹爪] --> C[动作合成]
  B[SERL 输出 residual_action<br/>8 维: 7 维 residual + grasp 辅助维] --> C
  C --> D[final_action<br/>发送给机器人控制器]

真实部署时可以把最终控制写成：

其中 clip 用来保证动作不超过安全范围。

6. 在线训练时每一步发生了什么

下面用一个完整 episode 说明。

sequenceDiagram participant Robot as 机器人/Actor participant Pi05 as pi0.5 participant Human as 人类操作者 participant Learner as Learner/GPU participant Buffer as Replay & Demo Buffer Robot->>Pi05: 输入图像、状态、任务指令 Pi05-->>Robot: 输出 base_action Robot->>Robot: SERL policy 输出 residual_action Robot->>Robot: 合成 final_action 并执行 Human-->>Robot: 如果要失败则接管 Robot->>Robot: 记录 transition Robot->>Learner: episode 结束后发送整条轨迹 Learner->>Buffer: 普通数据进入 replay buffer Learner->>Buffer: 人类接管数据额外进入 demo buffer Learner->>Learner: SAC/RLPD 训练更新 Learner-->>Robot: 广播最新 policy 参数

每一步产生的数据叫 transition：

transition = { observations: 当前观测, actions: 实际执行动作, next_observations: 下一步观测, rewards: 奖励, masks: 是否继续训练 bootstrap, dones: episode 是否结束, grasp_penalty: 夹爪相关辅助惩罚 }

如果人类接管：

actions = 人类接管动作 intervened = True

如果没有人类接管：

actions = policy 动作 intervened = False

7. 理论基础：MDP

强化学习通常建模为 MDP，中文叫马尔可夫决策过程。一个 MDP 包含：

各项含义：

在时间 t：

含义是：

机器人在状态 s_t 执行动作 a_t，环境变成 s_{t+1}，并返回奖励 r_t。

8. 强化学习目标函数

机器人希望最大化未来累计奖励：

解释：

• π 是策略。

• r(s_t, a_t) 是当前奖励。

• γ^t 是折扣，越远的奖励权重越小。

• 期望 Eπ 表示动作由策略 π 采样产生。

为什么要有 γ？如果没有折扣，机器人可能过度追求很遥远、不确定的奖励；加入 γ 后，近期奖励更重要，但长期结果仍然会被考虑。

9. Q 函数和 Bellman 方程

Q 函数表示：

也就是：

当前做动作 a_t 后，未来能拿到的总奖励。

它可以拆成“当前奖励 + 下一步未来价值”：

这就是 Bellman 方程。直观理解：

这个动作好不好 = 当前有没有好处 + 做完之后未来还会不会好

10. SAC 的目标：奖励 + 探索

SAC 的全称是 Soft Actor-Critic。它和普通 RL 的区别是：它不仅追求高奖励，还鼓励策略保持探索性。SAC 优化目标是：

其中：

• H(π) 是熵 entropy，表示策略有多随机。

• α 是温度系数，控制探索的重要程度。

如果熵很大，策略不会每次都死板地选同一个动作，而是会探索其他可能动作。对机器人来说，这很重要，因为早期策略并不知道什么动作最好。

11. SAC 的 critic 更新公式

SAC 会学习 Q 网络，也就是 critic。对一条 transition：

(s, a, r, s', done)

先构造目标值：

其中：

• a' ~ πθ(·|s')，下一状态下由当前策略采样的动作。

• Q_{\bar{φ}} 是 target critic，参数更新更慢，用来稳定训练。

• min_i 表示使用两个 critic 中较小的估计，减少 Q 值过高的问题。

• done=1 时，episode 已结束，不再看未来。

critic 的损失函数：

直观理解：

critic 当前预测的 Q(s,a) 要尽量接近 Bellman 目标 y。

11.1 从 loss 往前看

更简单地看，critic 的最终 loss 是：

loss = (critic 当前猜的 Q - 目标 Q)^2

也就是：

loss_t = (Q(s_t, a_t) - y_t)^2

其中 Q(s_t, a_t) 是当前 critic 对这条 transition 的打分，y_t 是用奖励和下一状态构造出来的参考答案。

对一条样本：

(s_t, a_t, r_t, s_{t+1}, done_t)

目标值可以理解为：

y_t = 这一刻的 reward + 折扣后的未来价值

也就是：

future_value 来自下一状态 \(s_{t+1}\)：

所以完整链路是：

actor(s_{t+1}) -> a_{t+1} target critic(s_{t+1}, a_{t+1}) -> future_value r_t + gamma * future_value -> y_t critic(s_t, a_t) -> Q(s_t, a_t) loss_t = (Q(s_t, a_t) - y_t)^2

如果 \(\text{done}_t = 1\)，episode 已结束：

因为没有未来可以继续 bootstrap。训练时不是只拿一条 transition 更新，而是随机抽一个 batch。当前项目的 RLPD 采样方式是：

batch = 1/2 online replay buffer + 1/2 demo buffer

默认 batch_size = 256，所以一次更新大致是：

128 条 online replay transition + 128 条 demo / intervention transition = 256 条 transition

最后的 critic loss 是这些单步 loss 的平均：

因此公式里的期望：

在本项目里可以理解成对混合经验分布采样：

这里的 replay_buffer 存在线执行和历史执行数据，demo_buffer 存离线示范和人类接管数据。注意：loss 不是对 pi0.5 模型本身求的，也不是对 pi0.5 的动作分布直接求的。pi0.5 只影响数据如何被采集：它给出 base_action，SERL 给出 residual，环境执行后产生 transition。SAC 更新时使用的是 buffer 里的 transition 分布。

当前代码里 continuous critic 的 target 默认 backup_entropy=False，所以实际 target 更接近：

其中 \(\text{mask}_t = 1 - \text{done}_t\)。

12. SAC 的 Actor 更新公式

actor 的目标是选出 critic 认为好的动作，同时保持一定探索。SAC actor 损失通常写作：

训练时最小化 \(L_\pi\)。为什么是这个形式？

• \(-Q(s,a)\)：最小化它等价于最大化 Q，也就是让动作更有价值。

• \(\alpha \log \pi(a|s)\)：控制策略随机性，避免过早变得确定。

直观理解：

actor 想找一个 critic 评分高的动作，但又不能完全失去探索能力。

13. SAC 的温度 \(\alpha\)

\(\alpha\) 控制探索强度。

• 如果 \(\alpha\) 大：

• 策略更随机。

• 探索更多。

• 但动作可能不稳定。

• 如果 \(\alpha\) 小：

• 策略更确定。

• 利用当前最优动作更多。

• 但可能陷入局部最优。

SAC 通常会自动调节 \(\alpha\)，让策略熵接近一个目标熵：

14. RLPD 的数学形式

本项目不是只用在线数据训练，而是混合两类数据：

• \(\mathcal{D}_{\text{online}}\) 表示机器人在线采到的数据。

• \(\mathcal{D}_{\text{demo}}\) 表示离线示范和人类干预数据。

训练 batch 来自混合分布：

本项目中可以理解为：

也就是：

一半 demo，一半 online。

对应训练损失可以写成：

虽然代码里不是显式写成这个公式，但通过拼接两个 half batch 实现了等价效果。

15. HIL 干预如何进入公式

定义一个干预变量：

其中：

• \(I_t = 0\)：没有人类接管。

• \(I_t = 1\)：人类接管。

策略动作：

人类动作：

实际执行动作是：

也就是：

• 没接管时执行 policy 动作。

• 接管时执行 human 动作。

存入 replay 的 transition 是：

如果 \(I_t=1\)，这条 transition 还会额外进入 demo buffer：

直观意义：

人类越频繁接管的地方，越说明当前策略不会做；这些地方的数据会被更强地用于后续训练。

16. pi0.5 + Residual RL 的公式

设 pi0.5 的基础策略是：

其中：

• \(o_t\) 是视觉和机器人观测。

• \(l\) 是语言指令。

• \(a^{\text{base}}\) 是 pi0.5 生成的基础动作。

SERL residual 策略是：

最终动作：

这个公式非常关键。它表达了：

1. pi0.5 提供通用能力。

2. SERL 学习当前任务和当前机器人上的修正。

3. clip 保证动作在安全范围内。

如果人类接管，则最终执行动作变为：

完整链路是：

flowchart LR
  O[观测 o_t<br/>图像 + 状态] --> P[pi0.5]
  L[语言指令 l] --> P
  P -->|a_base| R[SERL residual policy]
  O --> R
  R -->|Δa| M[base + residual]
  P -->|a_base| M
  M -->|a_final| H{人类是否接管?}
  Human[人类动作 a_human] --> H
  H -->|否| E[执行 a_final]
  H -->|是| EH[执行 a_human]

17. 为什么不直接强化学习完整动作

直接让 RL 学完整机器人动作有几个问题：

1. 探索空间太大：机器人从零不知道该往哪动。

2. 真实机器人数据昂贵：每次试错都要占用真实设备时间。

3. 安全风险高：随机动作可能碰撞。

4. 稀疏奖励难学：比如插入任务，随机试到成功的概率很低。

用 pi0.5 + residual 的好处是：

pi0.5 负责“会做” SERL 负责“做准” HIL 负责“纠错和保安全”

这比从零 RL 更适合真实机器人在线部署。

18. 为什么要一半 Demo 一半 Online

如果只用 demo：

• 策略可能只能模仿已有数据。

• 遇到新场景不会自我改进。

如果只用 online：

• 初期容易学坏。

• 可能忘掉人类示范里的好行为。

所以本项目使用混合训练：

demo 数据提供稳定先验 online 数据提供真实适应

对应图示：

flowchart TB
  Demo[Demo Buffer<br/>离线示范 + 人类接管] --> Batch[训练 batch]
  Online[Online Replay Buffer<br/>机器人实时采样] --> Batch
  Batch --> SAC[SAC 更新]
  SAC --> Better[更好的策略]
  Better --> Online

19. 本项目中的 Actor / Learner 分布式结构

19.1 Actor

actor 是机器人端进程，负责：

1. 接收 learner 下发的策略参数。

2. 读取机器人观测。

3. 调用策略输出动作。

4. 执行动作。

5. 记录数据。

6. episode 结束后把轨迹发给 learner。

启动脚本：

./run_actor_[exp.sh](http://exp.sh)

19.2 Learner

learner 是训练端进程，负责：

1. 加载 demo 数据。

2. 接收 actor 发来的在线轨迹。

3. 把数据放进 replay/demo buffer。

4. 训练 SAC。

5. 保存 checkpoint。

6. 把最新策略参数广播给 actor。

启动脚本：

./run_learner_[exp.sh](http://exp.sh)

19.3 Collector

collector 是只收数据不训练的进程，用于数据采集或调试。 启动脚本：

./run_collector_[exp.sh](http://exp.sh)

20. 从代码角度看训练闭环

20.1 Actor 侧

核心逻辑是：

while training: obs = 当前观测 action = agent.sample_actions(obs) next_obs, reward, done, info = env.step(action) 如果 info 里有 intervene_action: action = intervene_action 标记为人类干预 保存 transition 如果 episode 结束: 把整条 episode 发给 learner 从 learner 拉取或接收新参数

20.2 Learner 侧

核心逻辑是：

启动 server 等待 replay buffer 至少有 training_starts 条数据 发布初始网络给 actor while training: 从 replay buffer 抽 batch_size/2 从 demo buffer 抽 batch_size/2 拼接成完整 batch 更新 critic 更新 actor / critic / temperature 每隔 steps_per_update 步发布新网络给 actor 定期保存 checkpoint

21. 奖励 Reward 怎么理解

奖励函数告诉机器人什么是好行为。简单任务可以用稀疏奖励：

成功: reward = 1 未成功: reward = 0

也可以加入惩罚：

其中：

• \(r^{\text{success}}\) 表示任务成功奖励。

• \(r^{\text{grasp_penalty}}\) 表示夹爪或抓取相关惩罚。

• \(\beta\) 控制惩罚权重。

在真实机器人任务中，奖励设计很关键。奖励太稀疏，学习慢；奖励太复杂，可能导致机器人钻空子。

21.1 reward 是按 step 还是按完整动作打分

SAC 训练时的基本样本是一条单步 transition：

(s_t, a_t, r_t, s_{t+1}, done_t)

所以 replay buffer 里每一步都有一个 reward 字段：

transition = { observations: s_t, actions: a_t, rewards: r_t, next_observations: s_{t+1}, masks: 1 - done_t, dones: done_t, }

这不代表每一步都必须人工判断一次“好”或“不好”。常见做法是稀疏奖励：

中间步骤: reward = 0 成功最后一步: reward = 1 失败最后一步: reward = 0 或 -1

例如一条成功 episode：

step 0: reward = 0 step 1: reward = 0 step 2: reward = 0 ... step T: reward = 1, done = True

虽然只有最后一步有正奖励，但 Q-learning 会通过 Bellman target 把成功价值往前传：

也就是说，前面的 step 虽然 reward = 0，但如果它们后面能通向成功，critic 仍然会学到这些 step 的 Q 值较高。

也可以使用 dense reward，每一步都打一点分：

靠近目标: +0.01 动作太大: -0.01 碰撞或越界: -0.1 成功: +1

dense reward 往往学得更快，但设计不当时也更容易让机器人学到错误捷径。

21.2 demo、人类修正和在线数据的 reward

本项目里 learner 会混合采样：

1/2 online replay buffer + 1/2 demo buffer

无论数据来自哪里，critic loss 都是按单步 transition 计算：

区别只在于这些 transition 是怎么来的。

在线执行数据：

s_t = 当前真实观测 a_t = 策略实际执行的动作 r_t = 环境返回的 reward s_{t+1} = 执行后的真实下一观测

人类接管数据：

s_t = 接管前观测 a_t = 人类实际执行的动作 r_t = 环境返回的 reward s_{t+1} = 执行人类动作后的下一观测

这条数据通常同时进入 replay buffer 和 demo buffer，因此后续训练中会被更频繁采样。但人类接管本身不一定自动等于 reward = 1，除非奖励函数这样设计。更常见的是：接管动作按真实任务结果得到 reward，最终成功时在最后一步给正奖励。

离线 demo 数据也一样。demo buffer 只是提高示范数据的采样比例，真正告诉 critic 这些动作“好不好”的仍然是 transition 里的 reward。

• 如果是成功 demo，常见设置是：

中间 demo step: reward = 0 最后成功 step: reward = 1

• 如果是失败 demo 或无标签 demo：

所有 step: reward = 0

这样的 demo 只能提供状态动作分布，不能明确告诉 critic 它们会导致成功。

当前 realworld_finetune_pi05 分支里还没有真正实现任务 reward：mock 环境使用随机小噪声 reward，离线转换脚本也把 demo reward 写成 0。因此真实训练前需要补齐任务成功判断和 reward 写入逻辑。

21.3 pi0.5 chunk 与 transition 的关系

如果 pi0.5 一次输出 chunk_size = 50 的基础动作，推荐仍然拆成 50 条低层 transition：

第 0 步: base_action_0 + residual_0 -> 执行 -> r_0, s_1 第 1 步: base_action_1 + residual_1 -> 执行 -> r_1, s_2 ... 第 49 步: base_action_49 + residual_49 -> 执行 -> r_49, s_50

每一步都存：

(s_t, residual_t, r_t, s_{t+1}, done_t)

其中：

s_t.state 里包含 base_action_t s_{t+1}.state 里包含 base_action_{t+1}

不要把 50 个低层动作合成一个大动作只算一次 reward，除非明确想做高层 RL。对 residual fine-tuning 来说，按低层 step 存 transition 更容易让 critic 学到每个修正动作的价值。

22. 视觉输入和编码器

机器人使用相机图像作为输入，但神经网络不能直接理解“这是一块积木”这种概念。所以需要视觉编码器 encoder，把图像变成特征向量。本项目配置使用：

encoder_type = resnet-pretrained

可以理解为：

flowchart LR
  Image[RGB 图像] --> ResNet[ResNet 视觉编码器]
  ResNet --> Feature[图像特征向量]
  State[机器人状态] --> Concat[拼接]
  Feature --> Concat
  Concat --> Policy[Actor / Critic 网络]

也就是说，actor 和 critic 不是只看关节状态，还会看相机图像。

23. Checkpoint 是什么

Checkpoint 是模型参数快照。它的作用是：

1. 训练中断后可以恢复。

2. actor 可以保存收到的最新策略。

3. 可以评估不同训练步数的模型表现。

本项目中 learner 会定期保存 checkpoint，actor 也可以保存 learner 下发的最新参数。

24. 当前分支的状态：哪些已实现，哪些需要真实接入

已实现

• actor / learner / collector 三种运行模式。

• SAC / hybrid SAC 训练逻辑。

• replay buffer 和 demo buffer。

• RLPD 的 50/50 batch 混合。

• 人类干预数据进入 demo buffer。

• hdf5 episode 保存和恢复。

• pi0.5 residual 所需的观测字段 base_action。

• pi0.5 residual 所需的动作空间设计：8 维 residual action。

当前是 mock/stub 的部分

• 当前 realworld_finetune_pi05 环境默认是 mock 环境。

• 图像、状态、奖励目前由 stub 环境模拟。

• pi0.5 真实推理还没有在 get_environment() 中实际调用。

• 最终动作发送真实机器人控制器的逻辑需要替换 stub。

真实部署需要补齐

1. 接入真实相机，输出 head 和 wrist_1 图像。

2. 接入真实机器人状态，输出关节位置和夹爪状态。

3. 调用 pi0.5，得到 7 维 base_action。

4. 把 base_action 放进 SERL observation。

5. SERL 输出 residual action。

6. 合成 final_action = base_action + residual。

7. 把 final_action 转成机器人控制命令。

8. 实现奖励函数和 episode 终止条件。

9. 接入人类干预设备，并在接管时写入 intervene_action。

25. 部署时推荐的模块划分

flowchart TB
  subgraph RealEnv[RealPi05SERLEnv]
    Sensor[SensorAdapter<br/>相机 + 机器人状态]
    Pi[Pi05Adapter<br/>pi0.

建议真实环境类实现 Gymnasium 接口：

class RealPi05SERLEnv(gym.Env): def reset(self): ... return observation, info def step(self, residual_action): ... return next_observation, reward, done, truncated, info

其中 step() 内部做：

1. 读取当前传感器

2. 调用 pi0.5 得到 base_action

3. SERL 传入 residual_action

4. 合成 final_action

5. 如果人类接管，用 human_action 替换 final_action

6. 执行动作

7. 计算 reward / done

8. 返回 next_observation 和 info

26. 安全性为什么重要

在线 RL 在真实机器人上有风险，因为策略会探索。因此真实部署建议加入多层安全限制：

1. 动作限幅：每一步最大关节变化不能太大。

2. 工作空间限制：末端不能离开安全区域。

3. 速度限制：避免突然高速运动。

4. 力/碰撞检测：接触力异常时停止。

5. 人类急停：操作者可以随时停止或接管。

6. residual 缩放 λ 从小开始，比如只允许 SERL 做小修正。

在 pi0.5 + residual RL 中，安全性更容易控制，因为 RL 不是直接输出完整动作，而是输出小残差。

27. 训练指标怎么看

常见指标：

特别是 HIL-SERL，除了成功率，还要看：

人类接管次数是否逐渐减少

如果成功率上升、接管次数下降，说明策略正在学会人类纠正过的行为。

28. 一段可以直接汇报的话

可以这样讲：

我们的系统采用 pi0.5 + HIL-SERL 的在线强化学习框架。pi0.5 作为基础 VLA 策略，根据多视角图像和任务指令输出一个基础动作；SERL 不从零学习完整机器人动作，而是在 pi0.5 动作上学习一个 residual 修正量，最终动作是 base action 加 residual action。这样可以保留 pi0.5 的通用能力，同时让强化学习适配当前真实机器人和具体任务。\ 训练采用 actor-learner 分布式架构。actor 在机器人端运行，负责采集图像、调用 pi0.5、执行 SERL 修正后的动作，并把每个 episode 的轨迹发送给 learner。learner 在 GPU 端维护两个 buffer：一个是在线 replay buffer，存机器人实时采集的数据；另一个是 demo buffer，存离线示范和人类在线接管数据。训练时使用 RLPD 思路，每个 batch 一半来自 demo buffer，一半来自 online replay buffer，然后用 SAC 更新 actor 和 critic。learner 每隔固定步数把最新策略参数广播回 actor，从而形成边执行、边收集、边训练、边更新的在线闭环。\ HIL 的作用是安全和加速学习。当机器人动作有风险或要失败时，人类可以接管。系统会把实际执行动作替换为人类动作，并标记为 intervention；这些数据除了进入普通 replay buffer，还会额外进入 demo buffer，作为高质量纠正示范参与后续训练。因此，策略会逐渐减少需要人类接管的情况，提高任务成功率。

29. 用更口语的话解释给非技术人员

如果面对完全不懂强化学习的人，可以这样说：

pi0.5 像一个已经会做很多任务的机器人助手，但它在具体硬件和具体场景上不一定非常准。SERL 像一个在线教练，它不重新教机器人所有动作，只教它怎么微调 pi0.5 的动作。人在旁边看着，如果机器人要做错，就马上接管并演示正确动作。系统会把这次纠正记录下来，马上加入训练。训练电脑学完以后，会把新的策略发回机器人。这样机器人每做一批任务，就能从自己的经验和人的纠正里继续进步。

30. 最后总结

这个系统的核心不是单独的 pi0.5，也不是单独的 RL，而是三者组合：

pi0.5 基础能力 + SERL 在线 residual 强化学习 + HIL 人类安全纠正 = 可部署的真实机器人在线学习系统

从理论上看：

• MDP 描述机器人和环境的交互。

• SAC 通过 actor-critic 最大化“奖励 + 探索”。

• RLPD 用 demo 和 online 数据混合训练，提高样本效率。

• HIL 把人类接管转化为额外专家数据。

• Residual RL 把学习目标从“完整动作”变成“修正 pi0.5 动作”。

从工程上看：

• actor 负责真实机器人采样。

• learner 负责 GPU 训练。

• replay buffer 和 demo buffer 负责存数据。

• checkpoint 和参数广播负责让机器人实时使用最新策略。

• 真实部署时需要把当前 mock 环境替换成 pi0.5 推理、真实相机、机器人控制器和奖励函数。