MotrixLab训练营第五周学习笔记:Go1四足机器人平地行走
MotrixLab 强化学习实战(五):让 Go1 四足机器人学会走路 —— 训练、回放与 action_scale 对照实验
系列进度:第一~二周装环境 → 第三周读 CartPole 源码 → 第四周训练 CartPole / Pendulum / Acrobot → 第五周 训练 Unitree Go1 四足机器人平地行走
本文环境:MotrixLab v0.4.0b1、skrl 2.x(PPO)、PyTorch CPU 版、Windows 笔记本(无独显)
0. 这篇笔记讲什么
本周任务从"玩具级"环境(CartPole、Pendulum)跳到了真实机器人:宇树 Go1 四足机器狗,12 个驱动关节,要在平地上跟踪速度指令走路。任务分三块:
| 模块 | 内容 | 我实际做了什么 |
|---|
| 实操 | 跑通「训练 → TensorBoard → 回放」闭环 | 12000 次迭代、27 分 21 秒、平均回报 0 → 40.72、Value loss → 0.0015 |
| 实验 | action_scale 0.1 vs 0.05 的 A/B 对照 | 同一 checkpoint 回放两组,计算 + 画面双重验证 |
最终训练出的策略:16 只机器狗同框齐步走,四条腿交替摆动、躯干轻微起伏、无摔倒。
读完这篇你会得到:一套可以照抄的四足机器人训练流程、一份 49 维观测的完整拆解、以及一个关于"改一个配置数字到底会怎样"的诚实结论。
1. 前置知识速查(看不懂术语先看这里)
1.1 强化学习的最小循环
| 名词 | 英文 | 一句话解释 |
|---|---|---|
| 智能体 | Agent | 做决策的那一方,这里就是一个神经网络(策略) |
| 环境 | Environment | 被交互的世界,这里是物理仿真器 + 机器狗模型 |
| 观测 | Observation (obs) | 智能体每一步能"看到"的数值向量 |
| 动作 | Action | 智能体每一步输出的控制量 |
| 奖励 | Reward | 环境给的标量评分,越大越好 |
| 回合 | Episode | 从 reset 到终止的一整段,可能几十步也可能几千步 |
| 策略 | Policy π(a|s) | 给定观测输出动作(或动作分布)的函数 |
一句话:观测进 → 策略出动作 → 环境走一步 → 给奖励 + 新观测 → 循环。
1.2 terminated 和 truncated 的区别(上周踩过,这周还在用)
- terminated:任务真的结束了(机器人摔了),这个状态之后不该再被估值。
- truncated:只是时间到了被强行掐断(比如撑满 20 秒),状态本身没问题。
两者要分开返回,否则价值函数会把"被掐断"误当成"失败"来学。Go1 这里的 terminated 判据是机身"上向量"的 z 分量:
# motrix_envs/src/motrix_envs/locomotion/quadruped/walk_np.py :: compute_transition
terminated = self.get_gravity()[:, 2] <= self.cfg.termination_min_up_z
get_gravity() 返回的是世界坐标系里"上"这个方向在本体坐标系的投影。正常站直时它约等于 [0, 0, 1],机身一旦倾斜超过阈值,z 分量掉下去 → 判定摔倒。
1.3 PPO 与 Actor-Critic
- PPO(Proximal Policy Optimization):目前最常用的策略梯度算法。核心是"每次更新别走太远",用 clip 把新旧策略的概率比限制在
[1-ε, 1+ε],训练更稳。 - Actor:输出动作的那张网络(“怎么走”)。
- Critic:估计状态价值 V(s) 的网络(“现在这个局面好不好”)。它只参与训练,不参与执行。
- 价值损失 Value loss:
(预测价值 - 实际回报)²。它收敛到很小,说明 Critic 已经能准确估价了。
本周配置(configs/task/go1-walk-flat/skrl.ppo.yaml):
algo:
models:
policy:
initial_log_std: -0.6931471805599453 # 初始动作标准差 = exp(-0.693) = 0.5
hiddens: [512, 256, 128] # MLP 三层
value:
hiddens: [512, 256, 128]
separate: true # Actor 与 Critic 不共享权重
agent:
rollouts: 24 # 每次迭代每个环境采 24 步
learning_epochs: 5 # 同一批数据重复训 5 轮
mini_batches: 4 # 分 4 个小批
learning_rate: 0.0003
entropy_loss_scale: 0.001
value_loss_scale: 1.0
trainer:
timesteps: 12000
1.4 并行环境、rollout、iteration
- num_envs(并行环境数):同时开 1024 个(配置默认)或 256 个(我改成这个)仿真副本一起跑,数据产出成倍增加。CPU 上不是越多越好,要看吞吐。
- iteration(迭代):一次"采样 → 算优势 → 更新网络"的循环。进度条上的
12000/12000就是这个。 - timesteps:环境步数计数。本仓库把它当作迭代上限使用。
1.5 仿真与关节控制
| 名词 | 解释 |
|---|---|
| MJCF | MuJoCo 的 XML 模型格式,描述刚体、关节、执行器、碰撞。Go1 的模型是 go1.xml |
| DOF(自由度) | 这里 12 个 = 4 条腿 × 3 个关节(髋外摆、髋俯仰、膝) |
| 执行器 actuator | 把"控制量"变成"力/力矩"的元件。ctrl 就是写给执行器的目标值 |
| PD 控制器 | 用 τ = Kp·(目标角 − 当前角) + Kd·(0 − 当前角速度) 去追目标位置。Go1 这里 stiffness=80、damping=1 |
| ctrl_dt | 控制周期,本任务 0.02 s(= 50 Hz)。策略每 20 ms 决策一次 |
关键点:策略输出的不是力矩,也不是关节角,而是"关节角目标的偏移量"。这个偏移量要经过 action_scale 缩放再叠加到默认站姿上,才成为 ctrl。这就是下一节要讲的残差控制。
1.6 四足机器人特有概念
① 速度指令跟踪(velocity tracking)
任务不是"往前走",而是"按我给的指令走"。环境每回合随机采样一个指令 [vx, vy, ωz](前进速度、侧移速度、转向角速度),奖励主要看实际速度与指令的吻合度。这样训出来的策略能接受不同速度,而不是只会一种步频。
② 步态相位(feet_phase,4 维)
一个 0→1 循环推进的相位量,用来告诉策略"现在该抬哪条腿"。四条腿按对角步态分组,相位相差 0.5:
# walk_np.py :: _advance_phase
np.fmod(phase + self.cfg.ctrl_dt * self.cfg.gait_frequency, 1.0, out=phase)
phase[standing] = 0.0 # 指令速度接近 0(站立)时相位清零
③ 残差控制(residual control)与 action_scale
θ_target = action × action_scale + θ_default
默认站姿 θdefault\theta_{\text{default}}θdefault 是人手工给的(大腿 0.9 rad),策略只学"往哪边多推一点"。好处是策略不用从零学"腿该摆成什么形状",搜索空间小得多。本周的 A/B 实验就是动这个 action_scale。
④ 非对称 Actor-Critic(asymmetric AC)
Actor 只能看"真机上传感器也能拿到"的信息(49 维),Critic 额外多拿 3 维本体线速度(52 维)——因为训练时仿真器可以直接读,真机上却很难测准。这叫特权信息(privileged information),只给 Critic 用,帮它估得更准。
1.7 工程名词
| 名词 | 解释 |
|---|---|
| uv | Python 包管理器(比 pip 快很多),uv run 直接在项目虚拟环境里执行命令 |
| Git LFS | 大文件存储。模型/贴图/场景资产是 LFS 指针文件,没 lfs pull 拉下来就是几个字节的文本,渲染出来是空气 |
| Hydra | 配置系统,支持命令行点号覆盖:algo.trainer.timesteps=12000 |
| checkpoint | 训练中保存的网络权重文件(.pt),best_agent.pt 是评估最好的那个 |
| TensorBoard tag | 曲线在事件文件里的名字。名字写错就永远找不到曲线(本周踩过) |
2. 环境准备:从 v0.3.0 升到 v0.4.0b1
上周用的是 v0.3.0(还打过补丁)。本周任务要求 0.4.0b1,先切分支——注意上周改过的文件要先 stash,否则切不过去。
cd MotrixLab
git fetch --tags
git stash -u -m "week4 patches" # 暂存上周的 pendulum 补丁
git checkout v0.4.0b1
git log --oneline -1
拉资产(必须,否则机器狗渲染不出来)。LFS 全量拉很慢,按目录精确拉:
GIT_LFS_SKIP_SMUDGE=1 git lfs pull \
--include="motrix_robots/src/motrix_robots/assets/go1/**,motrix_envs/src/motrix_envs/assets/**"
同步依赖:
uv sync
两个好消息:
- 0.4.0b1 默认就装 CPU 版 torch,上周那个"CUDA 源被网络屏蔽导致
uv sync失败"的坑这次不用再 patch 了。 go1-walk-flat任务、配置、训练脚本都是开箱即用的。
顺手补一个画图依赖(venv 里默认没有 matplotlib):
uv pip install matplotlib
3. 第一步:先体检环境,再决定训练规模
拿到一个新环境,不要急着开训。先写一个探针脚本,把维度、动作范围、控制频率、吞吐全部打出来——这四个数决定后面所有超参怎么定。
3.1 探针脚本(hw_week5/probe_go1.py 全文)
# -*- coding: utf-8 -*-
"""体检 go1-walk-flat:实例化、维度、每步耗时,用于估算 CPU 训练规模。"""
import sys, time
import numpy as np
import motrix_envs # noqa: F401 registers built-in environments
from motrix_env_core import registry
num_envs = int(sys.argv[1]) if len(sys.argv) > 1 else 16
env = registry.make("go1-walk-flat", num_envs=num_envs, mode="train")
obs = env.reset(np.arange(num_envs))
cfg = env.cfg
print("num_envs =", num_envs)
print("action_space =", env.action_space)
print("policy obs shape =", obs["policy"].shape if isinstance(obs, dict) else getattr(obs, "shape", None))
print("policy_obs_dim =", env._policy_obs_dim())
print("value_obs_dim =", env._value_obs_dim())
print("action_scale =", cfg.control_config.action_scale)
print("default_angles =", np.round(env.default_angles, 2))
print("max_episode_seconds =", cfg.max_episode_seconds, " ctrl_dt =", cfg.ctrl_dt)
print("reward terms =", [f"{k}={v}" for k, v in vars(cfg.reward_config.scales).items() if v][:8])
n = 200
env.reset(np.arange(num_envs))
t0 = time.perf_counter()
for i in range(n):
acts = env.action_space.sample()
state = env.step(acts)
dt = (time.perf_counter() - t0) / n
print(f"avg step time = {dt*1000:.1f} ms ({num_envs} envs) => {num_envs/dt:.0f} transitions/s")
3.2 两个踩过的坑
import motrix_envs # 少这行,registry.make 会报"环境未注册"
env.reset(np.arange(num_envs)) # 0.4 的 reset 需要显式传 env_ids
state = env.step(acts) # 0.4 的 step 返回 state 对象,不是 4 元组
0.4 版本把 gym 风格的 obs, rew, done, info = env.step(a) 改成了返回统一的 ArrayEnvState,字段用属性访问(state.obs、state.reward、state.terminated)。继续用四元组解包会直接报错。
# obs 也不是普通 ndarray,而是 NpObs 对象:能索引、没有 .shape
obs["policy"].shape # ✅ (num_envs, 49)
obs.shape # ❌ 打印出来是 None
3.3 实测输出
num_envs = 16
action_space = Box([ -8.63 -15.86 -10.18 -8.63 -15.86 -10.18 ...],
[ 8.63 36.01 9.12 8.63 36.01 9.12 ...], (12,), float32)
policy_obs_dim = 49
value_obs_dim = 52
action_scale = 0.1
default_angles = [ 0. 0.9 -1.8 0. 0.9 -1.8 0. 0.9 -1.8 0. 0.9 -1.8]
max_episode_seconds = 20.0 ctrl_dt = 0.02
avg step time = 4.1 ms (16 envs) => 3856 transitions/s
这几个数直接对上了作业里的选择题:动作 12 维、Actor 观测 49 维、Critic 52 维、action_scale=0.1。用脚本量一遍比翻文档可靠。
两个容易被忽略的细节:
① 动作空间不是 (-inf, inf),而是有界的、而且上下界明显不对称(−15.86 到 +36.01)。因为这个空间是由 asymmetric_residual_action_space(joint_limits, default_angles, action_scale) 按关节位置限位反推出来的:动作能取多大,取决于"这个关节离它的物理限位还有多远,除以 action_scale"。默认角离限位越远,动作空间那一边就越宽。
② 默认角是 [0, 0.9, -1.8] 循环 4 次,不是 12 个 0.9。每条腿三个关节依次是:髋外摆 0(腿朝正下方)、髋俯仰 0.9(大腿前抬)、膝 -1.8(小腿回折)。所以 §8.2 那个"默认角 0.9"的计算,指的是第二个关节(大腿)。
3.4 吞吐 → 训练规模
CPU 上并行环境数和吞吐近乎线性(16 → 64 → 256 逐步测),到 256 时训练实测稳定在 7.1~7.8 it/s。配置默认 num_envs=1024,那是给 GPU 机器准备的,我直接砍到 256:
12000 次迭代 ÷ 7.31 it/s ≈ 1641 s ≈ 27 min
先跑 30 次迭代验证管线,确认能出 checkpoint 再上正式训练——不然跑 20 分钟才发现配置写错,很亏。
4. 关键源码解析
4.1 配置在哪:go1.py 第 33 行
# motrix_envs/src/motrix_envs/locomotion/quadruped/go1.py
@registry.envcfg("go1-walk-flat")
@configclass
class Go1WalkDirectEnvCfg(QuadrupedWalkEnvCfg):
"""Track walking commands with Unitree Go1 on flat ground."""
render_spacing: float = 0.0
spawn_xy_range: float = 4.0
control_config: ControlConfig = ControlConfig(action_scale=0.1) # ← 就是这一行
reward_config: RewardConfig = RewardConfig(
scales=RewardScales(
similar_to_default=-0.03,
swing_contact=-1.0,
),
tracking_ang_vel_sigma=0.05, # 收紧偏航跟踪,避免走出弧线
base_height_target=0.275,
)
scene: QuadrupedSceneCfg = QuadrupedSceneCfg(
objs=StandardSceneObjsCfg(
floor=FlatTerrainCfg(material="mat_ground", friction=(0.6, 0.005, 0.0001)),
robot=UnitreeGo1Robot(),
),
)
一个容易看漏的点:ControlConfig 类本身的默认值其实是 0.25:
# motrix_envs/src/motrix_envs/locomotion/quadruped/cfg.py
@configclass
class ControlConfig:
# action scale: target angle = action_scale * action + default_angle
action_scale: float = 0.25
simulate_action_latency: bool = False
go1-walk-flat 把它覆写成 0.1。所以"这个任务的 action_scale 是多少"不能看类定义,要看具体 env 的 cfg——这也是本周无数人答错那道计算题的原因。
顺便,类定义上面的那行注释就是官方的公式说明,和下面 apply_action 里的代码完全对应:
θ_target = action_scale × action + θ_default
4.2 动作怎么变成关节目标:apply_action
# walk_np.py :: apply_action(第 331–344 行)
def apply_action(self, actions: np.ndarray, state: ArrayEnvState) -> ArrayEnvState:
actions = np.asarray(actions, dtype=np.float32)
self._last_actions[:] = self._current_actions
self._current_actions[:] = actions
if self._randomize_action_delay:
use_last = self._action_delay_steps == 1
exec_actions = np.where(use_last[:, None], self._last_actions, actions)
else:
exec_actions = self._last_actions if self.cfg.control_config.simulate_action_latency else actions
targets = exec_actions * self.cfg.control_config.action_scale + self.default_angles # ← 第 340 行
ctrl = self._ctrl_writes.buffer("ctrl")
ctrl[:] = targets.astype(np.float32, copy=False)
self._ctrl_writes.execute()
return state
读这段代码能确认三件事:
- 动作 → 目标角:就是一次乘加,没有别的隐藏操作。
- 动作延迟(
simulate_action_latency/simulate_action_delay):可以模拟真机上"指令发出到执行"的延迟,用上一步的动作代替当前动作。默认关闭。 - 写进
ctrl的是目标角,不是力矩。力矩由仿真器内部的 PD 控制器根据stiffness=80、damping=1算出来。这一点极其关键——它决定了下一节的实验结论。
4.3 观测 49 维是怎么拼出来的
# walk_np.py :: _policy_obs_dim
def _policy_obs_dim(self) -> int:
# gyro(3) + gravity(3) + dof_diff(A) + dof_vel(A) + last_actions(A)
# + command(3) + feet_phase(num_feet)
return 3 + 3 + 3 * self._num_action + 3 + self._num_feet
def _value_obs_dim(self) -> int:
return self._policy_obs_dim() + 3 # + local linvel(3)
代入 num_action = 12、num_feet = 4:
| # | 分量 | 维度 | 物理含义 |
|---|---|---|---|
| 1 | gyro | 3 | 机身角速度(IMU 陀螺仪) |
| 2 | −gravity | 3 | 机身姿态(上向量取负,见下方说明) |
| 3 | dof_diff | 12 | 关节角相对默认站姿的偏差 |
| 4 | dof_vel | 12 | 关节角速度 |
| 5 | last_actions | 12 | 上一步的动作(让策略知道自己刚做了什么) |
| 6 | command | 3 | 速度指令 [vx, vy, ωz] |
| 7 | feet_phase | 4 | 四条腿的步态相位 |
| 合计 | 49 |
Critic 再多 3 维 local_linvel(本体坐标系下的线速度)= 52。
观测拼装代码:
# walk_np.py :: compute_observation
policy = np.concatenate([
noisy_gyro, # 加噪后的角速度
-noisy_gravity, # 注意这个负号
noisy_diff, # dof_pos - default_angles
noisy_dof_vel,
last_actions,
command,
feet_phase,
], axis=1).astype(np.float32, copy=False)
value = np.concatenate([policy, noisy_linvel], axis=1).astype(np.float32, copy=False)
两个细节值得记:
-gravity为什么取负:upvector正常是[0,0,1],取负变[0,0,-1],让"投影方向"符合"重力指向下"的直觉。符号不影响可学习性,但读代码时不理解这个负号会以为有 bug。- 观测全部加噪:
scale_joint_angle=0.03、scale_joint_vel=0.5、scale_gyro=0.2、scale_gravity=0.05、scale_linvel=0.1。这是传感器噪声建模,让策略别过度依赖精确测量,缩小 sim-to-real 差距。
4.4 奖励设计:10 项加权求和
# walk_np.py :: _compute_reward 里的 reward_fns
reward_fns = {
"tracking_lin_vel": self._reward_tracking_lin_vel, # 线速度跟踪
"tracking_ang_vel": self._reward_tracking_ang_vel, # 角速度跟踪
"lin_vel_z": self._reward_lin_vel_z, # 竖直方向速度(惩罚弹跳)
"ang_vel_xy": self._reward_ang_vel_xy, # 横滚/俯仰角速度(惩罚摇晃)
"base_height": self._reward_base_height, # 机身高度偏离目标
"action_rate": self._reward_action_rate, # 动作变化率(惩罚抖动)
"similar_to_default": self._reward_similar_to_default, # 偏离默认站姿
"contact": self._reward_contact, # 足端接触
"swing_feet_z": self._reward_swing_feet_z, # 摆动腿抬升高度
"swing_contact": self._reward_swing_contact, # 摆动腿不该着地
}
权重(RewardScales 默认值 + 本任务覆写):
| 奖励项 | 默认权重 | 本任务 | 作用 |
|---|---|---|---|
| tracking_lin_vel | 1.0 | 1.0 | 正奖励,跟住指令速度 |
| tracking_ang_vel | 1.0 | 1.0 | 正奖励,跟住转向指令 |
| lin_vel_z | −5.0 | −5.0 | 重罚上下弹跳 |
| ang_vel_xy | −0.1 | −0.1 | 罚横滚/俯仰晃动 |
| base_height | −100.0 | −100.0 | 重罚机身高度偏离 0.275 m |
| action_rate | −0.1 | −0.1 | 罚动作抖动,鼓励平滑 |
| similar_to_default | −0.1 | −0.03 | 放松"必须接近默认站姿"的约束 |
| contact | 0.24 | 0.24 | 鼓励足端稳定着地 |
| swing_feet_z | 2.0 | 2.0 | 鼓励抬腿足够高 |
| swing_contact | −1.0 | −1.0 | 罚摆动腿着地(防拖脚) |
看到这张表就明白四足行走为什么难:奖励项之间有冲突。抬腿高(swing_feet_z +2)容易导致机身晃动(ang_vel_xy 罚)、抬太高落地砸(lin_vel_z −5 罚)。策略本质上是在一堆互相拉扯的约束里找一个平衡点。
4.5 终止条件只有一个
terminated = self.get_gravity()[:, 2] <= self.cfg.termination_min_up_z
机身倾斜过大(上向量 z 分量过小)才算摔倒。没有"走偏了终止"或"速度不达标终止"——那些都交给奖励去引导。这是 locomotion 任务的常见设计:只把"物理上不可恢复"的状态当终止,其他都用 soft 奖励约束。
5. 训练
5.1 命令
cd MotrixLab
# 先短跑 30 次迭代验证管线
uv run python scripts/train.py task=go1-walk-flat/skrl.ppo num_envs=256 \
algo.trainer.timesteps=30 play=false seed=1
# 正式训练
uv run python scripts/train.py task=go1-walk-flat/skrl.ppo num_envs=256 seed=1 play=false
参数说明:
| 参数 | 含义 |
|---|---|
task=go1-walk-flat/skrl.ppo | 选任务 + 选算法(同目录还有 rslrl.ppo.yaml,用另一个后端) |
num_envs=256 | 覆盖配置里的 1024,适配 CPU |
algo.trainer.timesteps=30 | Hydra 点号覆盖,只跑 30 次迭代 |
seed=1 | 固定随机种子,保证可复现 |
play=false | 只训练,不进入交互回放 |
5.2 训练输出
Training startup: resolving train backend for skrl/ppo
Training startup: resolved train backend 'torch' in 28.1s (env=go1-walk-flat, num_envs=256)
Training startup: created run context (run_dir=runs\go1-walk-flat\skrl\torch\ppo\26-11-18_10-57-22-365085)
[skrl:INFO] Seed: 1
3%| 360/12000 [00:38<20:18, 7.79it/s]
60%| 7210/12000 [18:07<11:12, 7.15it/s]
100%|██████████| 12000/12000 [27:21<00:00, 7.31it/s]
[skrl:INFO] Closing environment
Closing environment
[skrl:INFO] Environment closed
"正常结束"的证据:进度条走满 12000/12000、出现 Closing environment / Environment closed 两行(分别来自 skrl 和本仓库)、进程退出码 0。如果中途报错,这三样都不会齐。
每次迭代采样 rollouts(24) × num_envs(256) = 6144 个环境步,12000 次迭代约 7400 万步经验。这个量级在 CPU 上跑 27 分钟,算是很实惠了。
5.3 run 目录结构
runs/go1-walk-flat/skrl/torch/ppo/
└── 26-11-18_10-57-22-365085/
├── checkpoints/
│ ├── agent_100.pt agent_200.pt ... agent_12000.pt (共 121 个)
│ ├── best_agent.pt ← 回放用这个
│ ├── latest.pt
│ └── manifest.json
├── events.out.tfevents.1794995873.LAPTOP-LK3RQ463.22692.0 ← TensorBoard 事件
├── metadata.json
├── task_config.yaml ← 本次训练的完整配置快照
└── play_video.mp4 ← 回放录制输出
interval: 100 决定每 100 次迭代存一个 checkpoint。task_config.yaml 是个好东西——事后想复现某次训练,直接看这个文件就知道当时所有参数。
6. 看训练曲线:先解决 tag 名对不上的问题
6.1 坑:作业里说的 tag 名不是真实名字
作业让你看 Loss/value 和 Train/mean_reward。但在本仓库的 TensorBoard 事件文件里,它们实际叫:
| 作业/文档里写的 | 实际 tag |
|---|---|
Loss/value | Loss / Value loss |
Train/mean_reward | Reward / Total reward (mean) |
斜杠两边有空格,首字母大写。名字对不上,在 TensorBoard 里翻半天也找不到。
排查方法:直接把所有 tag 打出来看。
tensorboard --logdir runs/go1-walk-flat
或者用脚本读取(下面这个更快,不用开浏览器)。
6.2 画曲线脚本(hw_week5/scripts/plot_curves5.py 全文)
# -*- coding: utf-8 -*-
"""HW5:从 TensorBoard 事件文件画 Loss/value 与 Train/mean_reward 曲线。"""
import argparse
import os
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt # noqa: E402
import numpy as np # noqa: E402
from tensorboard.backend.event_processing.event_accumulator import EventAccumulator # noqa: E402
def main():
p = argparse.ArgumentParser()
p.add_argument("run_dir")
p.add_argument("--out", required=True)
p.add_argument("--num-envs", type=int, default=256)
args = p.parse_args()
acc = EventAccumulator(args.run_dir)
acc.Reload()
available = acc.Tags()["scalars"]
print("available tags:", available)
fig, axes = plt.subplots(1, 2, figsize=(13, 5), dpi=150)
specs = [("Loss / Value loss", "#d62728"), ("Reward / Total reward (mean)", "#2c82d2")]
for ax, (want, color) in zip(axes, specs):
tag = want if want in available else None
if tag is None:
matches = [t for t in available if want.lower() in t.lower()]
if not matches:
ax.set_title(f"{want} (not found)")
continue
tag = matches[0]
events = acc.Scalars(tag)
steps = np.array([e.step for e in events])
vals = np.array([e.value for e in events])
ax.plot(steps, vals, linewidth=1.5, color=color)
ax.set_xlabel("Iteration")
ax.set_title(f"{tag} ({len(events)} pts, last={vals[-1]:.3f})")
ax.grid(alpha=0.3)
print(f"{tag}: {len(events)} points, last={vals[-1]:.4f}")
fig.suptitle(f"Go1 walk-flat PPO training — TensorBoard (num_envs={args.num_envs})", y=1.0)
fig.tight_layout()
fig.savefig(args.out, bbox_inches="tight")
print("saved:", args.out)
if __name__ == "__main__":
main()
用法:
uv run python scripts/plot_curves5.py \
runs/go1-walk-flat/skrl/torch/ppo/26-11-18_10-57-22-365085 \
--out images/tb_curves.png
6.3 结果
Loss / Value loss: 120 points, last=0.0015
Reward / Total reward (mean): 22 points, last=40.7227
- Value loss:120 个点(每次迭代都记),从高位一路掉到 0.0015 —— Critic 估价已经很准了。
- Total reward:只有 22 个点(记录频率低),最终 40.72。
两个点值得注意:
- 曲线点数不一样多,说明不同 scalar 的记录频率不同。画图时不要假设"点数相同才能对比"。
- reward 曲线上点稀疏,用平滑(
tensorboard --smoothing 0.9)更容易看清趋势。
7. 回放与录制:play.py 自带离屏录屏
7.1 命令
uv run python scripts/play.py env=go1-walk-flat \
policy=runs/go1-walk-flat/skrl/torch/ppo/26-11-18_10-57-22-365085/checkpoints/best_agent.pt \
num_envs=16 seed=1 \
record_video=true record_seconds=10 record_width=1280 record_height=720
| 参数 | 作用 |
|---|---|
policy=<path> | 指定 checkpoint,不写就加载最近一次 |
num_envs=16 | 回放并行 16 个,画面里就是 16 只狗 |
seed=1 | 与训练同种子,方便对照 |
record_video=true | 开启离屏录制 |
record_seconds=10 | 录 10 秒 |
record_width/height | 分辨率,默认只有 256×256,一定要手动调大 |
| 输出 | 自动写到 run_dir/play_video.mp4 |
7.2 输出日志
Using specified policy: runs\go1-walk-flat\skrl\torch\ppo\26-11-18_10-57-22-365085\checkpoints\best_agent.pt
Using policy metadata: skrl.ppo (torch)
[skrl:INFO] Seed: 1
那堆 mjcf_parser: These fields are not support yet 和 Camera mode 'trackcom' is not supported yet 是 MJCF 转内部格式时的警告,不影响运行。Failed to create CudaContext 也正常——本来就没 GPU。
7.3 观察结果
抽三帧看行为(约 1.7 s / 5 s / 9.3 s):
- 腿部:三条支撑腿 + 一条摆动腿,交替切换,不是四条腿同时动(不是蹦,是走)
- 位移:三帧之间机身相对地面的位置明显前移
- 躯干:上下有约一个身高的十分之一幅度起伏,属于正常步态,没有侧翻
- 稳定性:10 秒内 16 只狗全部站立行走,无一摔倒
8. A/B 实验:把 action_scale 从 0.1 改成 0.05
8.1 实验设计
控制变量,只改一个数字:
| 项目 | A 组 | B 组 |
|---|---|---|
| checkpoint | best_agent.pt | 同一个 |
| num_envs / seed | 16 / 1 | 16 / 1 |
| 录制参数 | 10 s, 1280×720 | 完全相同 |
| action_scale | 0.1 | 0.05 |
为什么要用同一个 checkpoint:这是个干预实验——问的是"同一个已经训好的策略,换一个执行参数会怎样"。如果重新训练,策略本身就会适应新参数,那比较的是两个不同的东西,不是参数的影响。
8.2 理论计算
取大腿关节(默认角 0.9 rad)、动作值 0.5:
| 组别 | action_scale | 关节位置目标 | 相对默认角的偏移 |
|---|---|---|---|
| A | 0.1 | 0.9 + 0.5 × 0.1 = 0.95 rad | 0.05 rad |
| B | 0.05 | 0.9 + 0.5 × 0.05 = 0.925 rad | 0.025 rad |
B 组偏移 = A 组 × (0.05 / 0.1) = A 组 × 0.5,正好减半(差 0.025 rad ≈ 1.43°)。
改动前的预测:位移幅度变小、步态更保守、可能前进变慢;但策略是闭环的,可能部分补偿,行为差异不一定剧烈。
8.3 执行步骤
关键是两组不能在同一个进程里接着跑,必须各起一个新进程,保证从干净状态开始:
# ① A 组(默认配置)
uv run python scripts/play.py env=go1-walk-flat policy=<ckpt> num_envs=16 seed=1 \
record_video=true record_seconds=10 record_width=1280 record_height=720
cp runs/go1-walk-flat/.../play_video.mp4 ../hw_week5/videos/play_A_scale0.1.mp4
# ② 改配置
sed -i 's/ControlConfig(action_scale=0.1)/ControlConfig(action_scale=0.05)/' \
motrix_envs/src/motrix_envs/locomotion/quadruped/go1.py
# ③ B 组(同一条命令)
uv run python scripts/play.py ...(与 A 组完全一致)...
cp runs/go1-walk-flat/.../play_video.mp4 ../hw_week5/videos/play_B_scale0.05.mp4
# ④ 恢复
sed -i 's/ControlConfig(action_scale=0.05)/ControlConfig(action_scale=0.1)/' \
motrix_envs/src/motrix_envs/locomotion/quadruped/go1.py
git diff --stat motrix_envs/src/motrix_envs/locomotion/quadruped/go1.py # 应该无输出
8.4 参数生效验证(别只看代码,要看实际读到的值)
改完文件不代表生效——可能改错位置、可能改到没被注册的类、可能有缓存。用 registry 实际读一遍:
uv run python -c "
import motrix_envs
from motrix_env_core import registry
print('action_scale =', registry.make_env_config('go1-walk-flat').control_config.action_scale)"
action_scale = 0.1 # ← A 组
action_scale = 0.05 # ← B 组(改完 go1.py 之后)
这一步做了,实验才有说服力。恢复默认后同样再读一次,确认是 0.1、git diff 干净。
8.5 观察结果
方向对、幅度小:
- B 组关节目标偏移确实减半(计算已验证)
- 画面里 B 组抬腿/摆动幅度略小,步态更拘谨一点
- 但前进能力没有按 50% 比例恶化,两组肉眼差异不剧烈,都能正常走完 10 秒
8.6 为什么"目标偏移减半"不等于"运动减半"
三个原因叠在一起:
① apply_action 给的只是"目标",不是"结果"
ctrl = targets 之后,真正的力矩由仿真器内部 PD 控制器算:
τ = Kp × (θ_target − θ) + Kd × (0 − θ̇) Kp = 80, Kd = 1
目标角只是闭环里的一个参考输入,实际关节运动还受地面接触、机身重力、其他三条腿的支撑反作用力影响。目标挪 1.43°,足端位置不一定跟着挪同样的比例。
② 策略本身是闭环的,会自己补偿
观测里有 dof_diff(关节角相对默认站的偏差)和 last_actions。策略看到"我出的动作产生的实际结果比预期小",下一拍就会输出更大幅度的动作。负反馈把一部分损失补回来了。
③ 策略是在 0.1 下训练的
它的输出分布(initial_log_std=-0.693 → 初始标准差 0.5)已经跟 0.1 这个缩放系数形成了配套。突然改成 0.05,等于把它的"动作有效量程"砍掉一半——但网络参数一点没变,它并不知道这件事。
8.7 方法论收获(这条比结论更值钱)
干预实验 ≠ 重新训练实验
- 拿同一个 checkpoint 改配置跑 = 看"这个策略对参数有多敏感" → 反映的是鲁棒性
- 用新参数从头训一遍 = 看"这个参数本身好不好" → 反映的是参数优劣
两者要回答的问题完全不同,不能拿前者的结果去下后者的结论。如果真想知道 0.05 这个参数值好不好,必须重新训一次,用同样的评估标准比较最终回报。
9. 踩坑清单
| # | 坑 | 现象 | 解决 |
|---|---|---|---|
| 1 | 忘记 import motrix_envs | registry.make 报环境未注册 | 显式 import 触发注册 |
| 2 | 0.4 的 step 返回变了 | 四元组解包直接报错 | 改成 state = env.step(a),用 state.obs/reward/terminated |
| 3 | reset() 需要 env_ids | TypeError 或什么都不发生 | env.reset(np.arange(num_envs)) |
| 4 | LFS 资产没拉 | 机器狗渲染成空气,只剩地面 | git lfs pull --include="...assets/go1/**",用 ls -la 确认不是指针文件 |
| 5 | TensorBoard tag 名不对 | 曲线找不到 | 先 print(acc.Tags()["scalars"]) 打印全部 tag 再匹配 |
| 6 | 视频默认 256×256 | 糊到看不清腿 | record_width=1280 record_height=720 |
| 7 | 配置类默认值 ≠ 任务生效值 | 计算题算错 | 用 registry.make_env_config(...) 实读,别看类定义 |
| 8 | 改配置后不验证 | 以为改了其实没生效 | 每次改完都用 make_env_config 打印一次 |
10. 复现清单
# ---------- 环境 ----------
cd MotrixLab
git fetch --tags && git checkout v0.4.0b1
GIT_LFS_SKIP_SMUDGE=1 git lfs pull --include="motrix_robots/src/motrix_robots/assets/go1/**,motrix_envs/src/motrix_envs/assets/**"
uv sync
uv pip install matplotlib
# ---------- 体检 ----------
uv run python ../hw_week5/probe_go1.py 16
uv run python ../hw_week5/probe_go1.py 256
# ---------- 训练 ----------
uv run python scripts/train.py task=go1-walk-flat/skrl.ppo num_envs=256 seed=1 play=false
# ---------- 曲线 ----------
uv run python ../hw_week5/scripts/plot_curves5.py \
runs/go1-walk-flat/skrl/torch/ppo/<RUN_ID> --out ../hw_week5/images/tb_curves.png
# ---------- 回放(A 组,scale=0.1)----------
uv run python scripts/play.py env=go1-walk-flat \
policy=runs/go1-walk-flat/skrl/torch/ppo/<RUN_ID>/checkpoints/best_agent.pt \
num_envs=16 seed=1 record_video=true record_seconds=10 \
record_width=1280 record_height=720
# ---------- B 组:改 0.05 → 同命令回放 → 改回 0.1 → git diff 确认干净 ----------
11. 小结
这周最直观的感受:任务规模变了,方法论没变。
| 第四周(CartPole) | 第五周(Go1) | |
|---|---|---|
| 观测 | 4 维 | 49 维 |
| 动作 | 1 维 | 12 维 |
| 网络参数 | 几千 | 几万 |
| 训练时长 | 5 分钟 | 27 分钟 |
| 核心难点 | 概念清晰 | 奖励项之间的权衡 |
但底层循环永远是那一套:观测进 → 策略出动作 → 环境走一步 → 给奖励 → 更新网络。真正变复杂的是人对任务的理解——49 维里每一维为什么存在、10 项奖励为什么互相冲突、action_scale 为什么是"残差"而不是"绝对角度"。
三个想记住的点:
- 新环境先体检:维度、控制频率、吞吐量,四个数决定所有超参。
- 配置类默认值 ≠ 任务生效值:必须用
make_env_config实读,这也是计算题最容易错的地方。 - 干预实验和重训实验是两回事:用同一个 checkpoint 改参数,只能说明鲁棒性,不能说明参数好坏。
下周继续~
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐


所有评论(0)