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 仿真与关节控制

名词解释
MJCFMuJoCo 的 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 工程名词

名词解释
uvPython 包管理器(比 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

两个好消息:

  1. 0.4.0b1 默认就装 CPU 版 torch,上周那个"CUDA 源被网络屏蔽导致 uv sync 失败"的坑这次不用再 patch 了。
  2. 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

读这段代码能确认三件事:

  1. 动作 → 目标角:就是一次乘加,没有别的隐藏操作。
  2. 动作延迟(simulate_action_latency / simulate_action_delay):可以模拟真机上"指令发出到执行"的延迟,用上一步的动作代替当前动作。默认关闭。
  3. 写进 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:

#分量维度物理含义
1gyro3机身角速度(IMU 陀螺仪)
2−gravity3机身姿态(上向量取负,见下方说明)
3dof_diff12关节角相对默认站姿的偏差
4dof_vel12关节角速度
5last_actions12上一步的动作(让策略知道自己刚做了什么)
6command3速度指令 [vx, vy, ωz]
7feet_phase4四条腿的步态相位
合计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_vel1.01.0正奖励,跟住指令速度
tracking_ang_vel1.01.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放松"必须接近默认站姿"的约束
contact0.240.24鼓励足端稳定着地
swing_feet_z2.02.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=30Hydra 点号覆盖,只跑 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/valueLoss / Value loss
Train/mean_rewardReward / 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。

两个点值得注意:

  1. 曲线点数不一样多,说明不同 scalar 的记录频率不同。画图时不要假设"点数相同才能对比"。
  2. 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 组
checkpointbest_agent.pt同一个
num_envs / seed16 / 116 / 1
录制参数10 s, 1280×720完全相同
action_scale0.10.05

为什么要用同一个 checkpoint:这是个干预实验——问的是"同一个已经训好的策略,换一个执行参数会怎样"。如果重新训练,策略本身就会适应新参数,那比较的是两个不同的东西,不是参数的影响。

8.2 理论计算

取大腿关节(默认角 0.9 rad)、动作值 0.5:

组别action_scale关节位置目标相对默认角的偏移
A0.10.9 + 0.5 × 0.1 = 0.95 rad0.05 rad
B0.050.9 + 0.5 × 0.05 = 0.925 rad0.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_envsregistry.make 报环境未注册显式 import 触发注册
20.4 的 step 返回变了四元组解包直接报错改成 state = env.step(a),用 state.obs/reward/terminated
3reset() 需要 env_idsTypeError 或什么都不发生env.reset(np.arange(num_envs))
4LFS 资产没拉机器狗渲染成空气,只剩地面git lfs pull --include="...assets/go1/**",用 ls -la 确认不是指针文件
5TensorBoard 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 为什么是"残差"而不是"绝对角度"。

三个想记住的点:

  1. 新环境先体检:维度、控制频率、吞吐量,四个数决定所有超参。
  2. 配置类默认值 ≠ 任务生效值:必须用 make_env_config 实读,这也是计算题最容易错的地方。
  3. 干预实验和重训实验是两回事:用同一个 checkpoint 改参数,只能说明鲁棒性,不能说明参数好坏。

下周继续~

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐