cyy/Motrixlab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: release v0.1.0

Browse Source 
(cherry picked from commit 82525f882f3924a332d9ce40bf64255d0d14f6a4)
This commit is contained in:
motphys-developers
2026-01-04 04:43:04 +00:00
parent 13cfbce9a7
commit 62011bb24f
390 changed files with 18897 additions and 626 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
docs/source/zh_CN/user_guide/demo/anymal_c.md Normal file
View File

@@ -0,0 +1,316 @@
# ANYmal-C Locomotion
## 概述
本文档详细描述了基于 ANYmal-C 四足机器人的导航任务环境。该环境是 MotrixLab 项目中导航任务集的一部分，提供了使用强化学习训练四足机器人执行目标位置和朝向导航的完整实现。
```{video} /_static/videos/anymal_c.mp4
:poster: _static/images/poster/anymal_c.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
---
## 环境描述
ANYmal-C 导航任务环境基于真实的 ANYmal-C 四足机器人构建，旨在训练机器人在平面环境中导航至指定的目标位置和朝向。该环境使用 MotrixSim 物理引擎进行仿真，提供高保真的动力学模拟。
### 机器人结构
ANYmal-C 是一个四足机器人，由以下主要部分组成：
- **基座（Base）**：机器人的核心躯干，包含 IMU 传感器、摄像头、激光雷达等传感器模块
- **四条腿**：每条腿包含三个关节
- HAA（Hip Abduction/Adduction）：髋部外展/内收关节
- HFE（Hip Flexion/Extension）：髋部屈伸关节
- KFE（Knee Flexion/Extension）：膝关节屈伸
- **四个足端（Feet）**：球形接触几何体，与地面产生摩擦接触
### 任务目标
机器人需要完成以下导航目标：
1. **位置导航**：移动到指定的目标位置（XY 平面坐标）
2. **朝向控制**：调整机器人朝向至目标航向角（yaw 角）
3. **稳定停止**：到达目标后保持稳定站立，线速度和角速度接近零
环境提供可视化标记：
- **绿色箭头**：指示目标位置和朝向
- **机器人上方绿色箭头**：当前实际运动方向
- **机器人上方蓝色箭头**：期望运动方向
---
## 动作空间
动作空间为 `Box(-1.0, 1.0, (12,), float32)`，表示施加到 12 个关节的位置控制指令（相对于默认站立姿态的偏移量）。
### 控制模式
环境使用位置控制模式，动作通过以下方式转换为关节目标位置：
```
目标关节角度 = 默认关节角度 + (动作值 × 动作缩放系数)
```
其中动作缩放系数由配置参数 `control_config.action_scale` 指定。
### 动作维度详细说明
| 编号 | 动作说明 | 控制范围 | 对应关节名称 | 关节类型 |
| ---- | ------------------- | ---------- | ------------ | -------- |
| 0 | 左前腿髋部外展/内收 | -1.0 ~ 1.0 | LF_HAA | hinge |
| 1 | 左前腿髋部屈伸 | -1.0 ~ 1.0 | LF_HFE | hinge |
| 2 | 左前腿膝关节屈伸 | -1.0 ~ 1.0 | LF_KFE | hinge |
| 3 | 右前腿髋部外展/内收 | -1.0 ~ 1.0 | RF_HAA | hinge |
| 4 | 右前腿髋部屈伸 | -1.0 ~ 1.0 | RF_HFE | hinge |
| 5 | 右前腿膝关节屈伸 | -1.0 ~ 1.0 | RF_KFE | hinge |
| 6 | 左后腿髋部外展/内收 | -1.0 ~ 1.0 | LH_HAA | hinge |
| 7 | 左后腿髋部屈伸 | -1.0 ~ 1.0 | LH_HFE | hinge |
| 8 | 左后腿膝关节屈伸 | -1.0 ~ 1.0 | LH_KFE | hinge |
| 9 | 右后腿髋部外展/内收 | -1.0 ~ 1.0 | RH_HAA | hinge |
| 10 | 右后腿髋部屈伸 | -1.0 ~ 1.0 | RH_HFE | hinge |
| 11 | 右后腿膝关节屈伸 | -1.0 ~ 1.0 | RH_KFE | hinge |
### PD 控制参数
底层使用位置执行器，PD 控制参数在 XML 文件中定义：
- **kp（比例增益）**：200
- **kv（微分增益）**：1
- **力矩限制**：-140 N·m ~ 140 N·m
---
## 观测空间
观测空间为 `Box(-inf, inf, (54,), float32)`，包含机器人的本体感知信息、任务相关信息和历史动作。
### 观测组成部分
观测向量由以下部分组成（按顺序）：
1. **本体感知状态（33 维）**
- 基座线速度（3 维）：机器人基座在世界坐标系中的线速度 [vx, vy, vz]
- 角速度（3 维）：从陀螺仪读取的角速度 [ωx, ωy, ωz]
- 投影重力（3 维）：重力向量在机器人本体坐标系中的投影
- 关节角度（12 维）：12 个关节相对于默认站立姿态的角度偏移
- 关节速度（12 维）：12 个关节的角速度
2. **历史动作（12 维）**
- 上一时刻执行的动作
3. **速度命令（3 维）**
- 期望线速度 XY（2 维）：根据位置误差计算的期望线速度
- 期望角速度 Z（1 维）：根据朝向误差计算的期望角速度
4. **任务状态（6 维）**
- 位置误差向量（2 维）：到目标位置的 XY 平面误差向量（归一化）
- 朝向误差（1 维）：到目标朝向的角度差（归一化到[-1, 1]）
- 距离（1 维）：到目标的欧氏距离（归一化）
- 到达标志（1 维）：是否同时满足位置和朝向到达条件（0 或 1）
- 停止就绪标志（1 维）：是否达到停止标准（到达且角速度接近零）
### 观测详细说明
| 编号 | 观测内容 | 最小值 | 最大值 | 归一化系数 | 单位 |
| ----- | --------------------------------- | ------ | ------ | --------------------- | ---------- |
| 0-2 | 基座线速度 (vx, vy, vz) | -inf | inf | normalization.lin_vel | m/s |
| 3-5 | 角速度 (ωx, ωy, ωz) | -inf | inf | normalization.ang_vel | rad/s |
| 6-8 | 投影重力 (gx, gy, gz) | -1 | 1 | 1.0 | 无量纲 |
| 9-20 | 关节角度偏移（12 个关节） | -inf | inf | normalization.dof_pos | rad |
| 21-32 | 关节角速度（12 个关节） | -inf | inf | normalization.dof_vel | rad/s |
| 33-44 | 上一时刻动作 | -1 | 1 | 1.0 | 无量纲 |
| 45-47 | 速度命令 (vx_cmd, vy_cmd, ωz_cmd) | -inf | inf | commands_scale | m/s, rad/s |
| 48-49 | 位置误差向量 (Δx, Δy) | -inf | inf | 1/5.0 | m |
| 50 | 朝向误差 | -1 | 1 | 1/π | rad |
| 51 | 到目标距离 | 0 | 1 | 1/5.0 (截断) | m |
| 52 | 到达标志 | 0 | 1 | 1.0 | 布尔值 |
| 53 | 停止就绪标志 | 0 | 1 | 1.0 | 布尔值 |
### 传感器信息
环境使用以下传感器获取状态：
- **framelinvel**（名称：base_linvel）：基座线速度传感器
- **gyro**（名称：base_gyro）：陀螺仪传感器，安装在 IMU 站点
---
## 奖励函数
奖励函数采用复合设计，根据机器人是否到达目标使用不同的奖励策略。
### 未到达目标时的奖励
总奖励 = 速度跟踪奖励 + 接近奖励 - 惩罚项
**主要奖励项：**
1. **线速度跟踪奖励**（权重：1.5）
- 计算公式：`1.5 × exp(-||v_xy - v_cmd||² / 0.25)`
- 激励机器人跟踪期望的 XY 平面线速度
2. **角速度跟踪奖励**（权重：0.3）
- 计算公式：`0.3 × exp(-(ωz - ωz_cmd)² / 0.25)`
- 激励机器人跟踪期望的偏航角速度
3. **接近奖励**
- 计算公式：`clip((历史最小距离 - 当前距离) × 4.0, -1.0, 1.0)`
- 奖励机器人每次距离目标更近时的进步
**惩罚项：**
- Z 轴线速度惩罚（权重：2.0）：`-2.0 × vz²`
- XY 轴角速度惩罚（权重：0.05）：`-0.05 × (ωx² + ωy²)`
- 力矩惩罚（权重：0.00001）：`-0.00001 × ||τ||²`
- 动作变化率惩罚（权重：0.001）：`-0.001 × ||Δa||²`
### 到达目标后的奖励
总奖励 = 停止奖励 + 首次到达奖励 - 惩罚项
**主要奖励项：**
1. **停止基础奖励**
- 计算公式：`2 × [0.8 × exp(-(v_xy/0.2)²) + 1.2 × exp(-(ωz/0.1)⁴)]`
- 激励机器人在到达后保持低速度和角速度
2. **零角速度奖励**（额外奖励：6.0）
- 条件：到达目标且 |ωz| < 0.05 rad/s
- 激励机器人完全停止旋转
3. **首次到达奖励**（一次性：10.0）
- 条件：首次同时满足位置和朝向到达条件
- 提供到达目标的明确信号
**惩罚项：**（与未到达时相同）
### 终止条件惩罚
以下情况会额外施加 -20.0 的惩罚：
- 关节速度超限（超过 `max_dof_vel` 配置值）
- 关节速度出现 NaN 或 Inf
- 机器人基座接触地面
- 机器人侧翻（倾斜角度超过 75°）
### 到达判定标准
- **位置到达**：距离目标 < 0.3 米
- **朝向到达**：朝向误差 < 15°
- **完全到达**：同时满足位置到达和朝向到达
- **停止就绪**：完全到达 且 |ωz| < 0.05 rad/s
### info 返回内容
每步返回的 info 字典包含以下调试信息：
- `pose_commands`：当前目标位置和朝向 [x, y, yaw]
- `last_actions`：上一时刻的动作
- `current_actions`：当前时刻的动作
- `steps`：当前回合步数
- `ever_reached`：是否曾经到达过目标
- `min_distance`：历史最小距离（用于计算接近奖励）
---
## 初始状态
### 机器人初始化
**位置初始化：**
机器人在世界坐标系中的初始位置由配置参数 `init_state.pos_randomization_range` 定义的范围内随机采样：
- X 坐标：在 [x_min, x_max] 范围内均匀随机采样
- Y 坐标：在 [y_min, y_max] 范围内均匀随机采样
- Z 坐标：固定在 0.56 米（避免坠落感）
**姿态初始化：**
- 机器人朝向（四元数）：初始化为单位四元数 [0, 0, 0, 1]，表示正向朝向
- 无随机噪声添加到四元数（保证初始稳定性）
**关节初始化：**
关节角度设置为默认站立姿态，由配置参数 `init_state.default_joint_angles` 定义。无随机噪声添加到关节角度（保证初始稳定站立）。
**速度初始化：**
所有线速度和角速度初始化为零，确保机器人从静止状态开始。
### 目标生成
**目标位置：**
目标位置相对于机器人初始位置生成：
```
目标位置 = 机器人初始位置 + 随机偏移
```
随机偏移在配置参数 `commands.pose_command_range` 定义的范围内采样：
- X 方向偏移：[pose_command_range[0], pose_command_range[3]]
- Y 方向偏移：[pose_command_range[1], pose_command_range[4]]
**目标朝向：**
目标朝向（yaw 角）在绝对参考系中随机生成：
- 朝向角度：[pose_command_range[2], pose_command_range[5]]
### 可视化标记初始化
- **目标标记**（绿色箭头）：设置为目标位置和朝向
- **运动方向箭头**：初始化在机器人上方 0.76 米高度处
---
## 回合终止
### 终止条件（Termination）
环境在以下任一条件满足时终止回合：
1. **超时终止**
- 条件：回合达到 `max_episode_second` 配置值
- 说明：防止无限回合
2. **关节速度异常**
- 条件：任一关节速度的绝对值超过 `max_dof_vel`
- 条件：关节速度出现 NaN、Inf 或超过 1e6
- 说明：防止数值发散和物理不稳定
3. **基座接触地面**
- 条件：机器人基座（配置参数 `terminate_after_contacts_on` 定义的几何体）与地面接触
- 说明：机器人跌倒或姿态失败
4. **侧翻倾覆**
- 条件：机器人倾斜角度超过 75°
- 计算：通过投影重力向量计算倾斜角 `arctan2(||g_xy||, |g_z|)`
- 说明：机器人严重侧翻
### 成功条件
虽然环境不会因成功而终止，但任务成功的定义为：
- 机器人到达目标位置和朝向（同时满足位置阈值 < 0.3m 和朝向阈值 < 15°）
- 机器人保持稳定停止（线速度 < 0.05 m/s，角速度 < 0.05 rad/s）

130
docs/source/zh_CN/user_guide/demo/bounce_ball.md Normal file
View File

@@ -0,0 +1,130 @@
# 乒乓球颠球
使用单臂机器人控制挡板颠球，实现连续弹跳并保持球在目标位置。
```{video} /_static/videos/bounce_ball.mp4
:poster: _static/images/poster/bounce_ball.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
Bounce Ball 是一个单臂机器人操作任务，使用 6 自由度的配天 AIR4-560 工业机械臂控制末端挡板（球拍）的位置。智能体通过控制机械臂 6 个关节的位置变化作为动作，使乒乓球在挡板上持续弹跳，并尽可能将球保持在目标高度和目标水平位置。
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-1.0, 1.0, (6,), float32)` |
| **维度** | 6 |
关节对应如下：
| 序号 | 动作含义（关节位置变化） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | -------------------------- | :----: | :----: | :-------------: |
| 0 | Joint1（基座旋转）位置变化 | -1 | 1 | `Joint1` |
| 1 | Joint2（大臂）位置变化 | -1 | 1 | `Joint2` |
| 2 | Joint3（小臂）位置变化 | -1 | 1 | `Joint3` |
| 3 | Joint4（手腕旋转）位置变化 | -1 | 1 | `Joint4` |
| 4 | Joint5（手腕俯仰）位置变化 | -1 | 1 | `Joint5` |
| 5 | Joint6（手腕旋转）位置变化 | -1 | 1 | `Joint6` |
---
## 观察空间
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (25,), float32)` |
| **维度** | 25 |
观察空间由以下部分组成（按顺序）：
| 部分 | 内容说明 | 维度 | 备注 |
| ----------- | -------------------- | ---- | --------------------------------------------------------------- |
| **dof_pos** | 各关节自由度位置信息 | 13 | 前 6 个为机械臂关节，后 7 个为球的自由关节（3 位置 + 4 四元数） |
| **dof_vel** | 各关节自由度速度信息 | 12 | 速度为位置导数 |
| 序号 | 观察量 | 最小值 | 最大值 | XML 名称 | 类型 (单位) |
| ----- | -------------- | ------ | ------ | ----------- | ---------------- |
| 0-5 | 机械臂关节角度 | -Inf | Inf | Joint1-6 | 角度 (rad) |
| 6 | 球 x 坐标 | -Inf | Inf | ball_x | 位置 (m) |
| 7 | 球 y 坐标 | -Inf | Inf | ball_y | 位置 (m) |
| 8 | 球 z 坐标 | -Inf | Inf | ball_z | 位置 (m) |
| 9-12 | 球姿态四元数 | -Inf | Inf | ball_qw/xyz | 四元数 (w,x,y,z) |
| 13-24 | 关节和球速度 | -Inf | Inf | - | 速度/角速度 |
---
## 奖励函数设计
奖励函数由以下几个部分组成：
```python
# 位置控制奖励：保持球在挡板中心上方
# 受控向上速度奖励：在球位置良好时奖励适中的向上速度
# 高度精度奖励：球接近目标高度
# 连续弹跳奖励：奖励连续成功的弹跳
# 总奖励 = 各项加权组合
```
---
## 初始状态
- **机械臂初始位置**：[0, 40, 110, 0, -60, 0] 度，带有随机噪声
- **球的初始位置**：挡板中心上方，带有随机噪声
- **球的初始速度**：[0.0, 0.0, 0.0] m/s
---
## Episode 终止条件
- **球掉落**：球的 z 坐标 < 0.05m（接近地面）
- **球过高**：球的 z 坐标 > 目标高度 + 1.0m（失去控制）
- **水平偏离过远**：球的 x 坐标绝对值 > 1.5m
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env bounce_ball
```
### 2. 开始训练
```bash
uv run scripts/train.py --env bounce_ball
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/bounce_ball
```
### 4. 测试训练结果
```bash
uv run scripts/play.py --env bounce_ball
```
---
## 预期训练结果
1. 连续弹跳：能够实现 3 次以上的连续弹跳
2. 位置控制：球的水平位置（x 坐标）稳定在目标位置 ± 0.05m 范围内
3. 高度控制：球的高度稳定在目标高度 0.8 ± 0.1m 范围内
4. 速度控制：球的向上速度保持在合理范围（0.1-1.5 m/s）内
5. 稳定控制：能够持续 20 秒的稳定弹跳而不掉落

153
docs/source/zh_CN/user_guide/demo/cartpole.md
View File

@@ -1,16 +1,89 @@
# 倒立摆训练示例
# 倒立摆
倒立摆（CartPole）是强化学习中的经典控制任务，目标是通过控制小车左右移动来保持杆子平衡。
![cartpole](/_static/images/poster/cartpole.jpg)
倒立摆（CartPole）是强化学习中的经典控制任务。其目标是训练一个通过控制小车左右移动来保持杆子平衡的智能体。
```{video} /_static/videos/cartpole.mp4
:poster: _static/images/poster/cartpole.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
- **状态空间**：小车位置、小车速度、杆子角度、杆子角速度
- **动作空间**：向左或向右施加力
- **奖励函数**：每一步保持杆子不倒下获得+1 奖励
- **终止条件**：杆子角度超过 ±15 度或 episode 长度超过 10 秒
CartPole 是一个经典的平衡控制任务。环境由一个小车和一根通过铰链连接在小车上的杆组成。智能体通过向左或向右施加力来控制小车移动，使杆子保持直立不倒。该任务要求精确的时序控制和平衡能力。
## 快速开始
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-3.0, 3.0, (1,), float32)` |
| **维度** | 1 |
动作对应如下：
| 序号 | 动作含义（施加在小车上的力） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | ---------------------------- | :----: | :----: | :-------------: |
| 0 | 水平方向的力 | -3.0 | 3.0 | `slider` |
---
## 观察空间
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-inf, inf, (4,), float32)` |
| **维度** | 4 |
CartPole 环境的观测空间由以下部分组成（按顺序）：
| 部分 | 内容说明 | 维度 | 备注 |
| -------- | -------------------- | ---- | -------------- |
| **qpos** | 小车位置和杆子角度 | 2 | 位置和角度信息 |
| **qvel** | 小车速度和杆子角速度 | 2 | 速度为位置导数 |
| 序号 | 观察量 | 最小值 | 最大值 | XML 名称 | 关节 | 类型 (单位) |
| ---- | ---------- | ------ | ------ | -------- | ----- | -------------- |
| 0 | 小车位置 | -Inf | Inf | slider | slide | 位置 (m) |
| 1 | 杆子角度 | -Inf | Inf | hinge | hinge | 角度 (rad) |
| 2 | 小车速度 | -Inf | Inf | slider | slide | 速度 (m/s) |
| 3 | 杆子角速度 | -Inf | Inf | hinge | hinge | 角速度 (rad/s) |
---
## 奖励函数设计
cartpole 的奖励函数设计如下：
```python
# 每步保持杆子不倒下获得 +1 奖励
reward = 1.0 # 每步固定奖励
```
---
## 初始状态
- **小车初始位置**：0.0 米（中心位置）
- **杆子初始角度**：0.0 弧度（直立）
- **初始速度**：均为 0
- 在初始状态上添加小幅随机噪声（`reset_noise_scale = 0.01`）以增加训练多样性
## Episode 终止条件
- 杆子角度超过 ±0.2 弧度（约 ±11.5 度）
- 小车位置超出 [-0.8, 0.8] 米范围
- 杆子角度出现 NaN 值
- Episode 最大时长：10 秒
---
## 使用指南
### 1. 环境预览
@@ -21,14 +94,7 @@ uv run scripts/view.py --env cartpole
### 2. 开始训练
```bash
# 使用默认参数训练
uv run scripts/train.py --env cartpole
# 自定义环境数量
uv run scripts/train.py --env cartpole --num-envs 1024
# 启用渲染（训练时可视化）
uv run scripts/train.py --env cartpole --render
```
### 3. 查看训练进度
@@ -40,60 +106,13 @@ uv run tensorboard --logdir runs/cartpole
### 4. 测试训练结果
```bash
# 自动寻找最佳策略测试（推荐）
uv run scripts/play.py --env cartpole
# 手动指定策略文件测试
uv run scripts/play.py --env cartpole --policy runs/cartpole/nn/best_agent.pickle
```
> **提示**：系统会自动在 `runs/cartpole/` 目录下寻找最新、最佳的策略文件进行测试。您也可以通过 `--policy` 参数手动指定特定的策略文件。
---
## 配置参数
## 预期训练结果
倒立摆环境的主要配置参数：
```python
@dataclass
class CartPoleEnvCfg(EnvCfg):
model_file: str = "path/to/inverted_pendulum.xml" # MJCF模型文件
reset_noise_scale: float = 0.01 # 重置噪声
max_episode_seconds: float = 10.0 # 最大episode长度
```
训练配置参数：
```python
@dataclass
class CartPoleRLCfg(BaseRLCfg):
num_envs: int = 2048 # 并行环境数量
learning_rate: float = 3e-4 # 学习率
batch_size: int = 2048 # 批大小
max_epochs: int = 500 # 最大训练轮数
```
## 自定义训练
您可以通过命令行参数覆盖默认配置：
```bash
uv run scripts/train.py --env cartpole \
--num-envs 1024 \
--train-backend jax \
--sim-backend np
```
## 预期结果
- 杆子角度大部分时间保持在 ±5 度以内
- 小车位移范围适中
## 故障排除
如果训练效果不佳，可以尝试：
1. 调整学习率（尝试 1e-4 到 1e-3）
2. 增加环境数量（更多并行训练）
3. 调整奖励函数权重
4. 检查物理参数设置是否合理
1. 杆子角度大部分时间保持在 ±5 度以内
2. Episode 时长接近或超过 10 秒
3. 小车在合理范围内移动以保持平衡

131
docs/source/zh_CN/user_guide/demo/dm_cheetah.md Normal file
View File

@@ -0,0 +1,131 @@
# 半猎豹机器人
半猎豹机器人(Cheetah)是 DeepMind Control Suite 中的经典连续控制任务。其目标是训练一个模拟的双足机器人，通过控制其关节力矩，实现高速、稳定地奔跑
```{video} /_static/videos/dm_cheetah.mp4
:poster: _static/images/poster/dm_cheetah.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
HalfCheetah 是一个二维半身猎豹奔跑任务。，由 7 个主要 Body 部位组成（1 个躯干和前后腿各 3 节），拥有 6 个受控关节(前后大腿[连接躯干]、胫骨[连接大腿]和脚[连接胫骨])，智能体通过向这些关节施加扭矩作为动作，让猎豹尽可能快速且稳定地向前奔跑。
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-1.0, 1.0, (6,), float32)` |
| **维度** | 6 |
关节对应如下：
| 序号 | 动作含义（施加在关节的力矩） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | ---------------------------- | :----: | :----: | :-------------: |
| 0 | 后腿大腿关节驱动扭矩 | -1 | 1 | `bthigh` |
| 1 | 后腿小腿关节驱动扭矩 | -1 | 1 | `bshin` |
| 2 | 后腿脚部关节驱动扭矩 | -1 | 1 | `bfoot` |
| 3 | 前腿大腿关节驱动扭矩 | -1 | 1 | `fthigh` |
| 4 | 前腿小腿关节驱动扭矩 | -1 | 1 | `fshin` |
| 5 | 前腿脚部关节驱动扭矩 | -1 | 1 | `ffoot` |
---
## 观察空间
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (17,), float32)` |
| **维度** | 17 |
HalfCheetah 环境的观测空间由以下部分组成（按顺序）：
| 部分 | 内容说明 | 维度 | 备注 |
| -------- | ------------- | -- | ------------ |
| **qpos** | 各身体关节与根部的位置信息 | 8 | 默认不包括根部 x 坐标 |
| **qvel** | 各身体关节与根部的速度信息 | 9 | 速度为位置导数 |
| 序号 | 观察量 | 最小值 | 最大值 | XML 名称 | 关节 | 类型 (单位) |
| -------- | --------------- | ------ | ------ | -------- | ----- | -------------- |
| 0 | 前端 z 坐标 | -Inf | Inf | rootz | slide | 位置 (m) |
| 1 | 前端角度 | -Inf | Inf | rooty | hinge | 角度 (rad) |
| 2 | 后腿大腿角度 | -Inf | Inf | bthigh | hinge | 角度 (rad) |
| 3 | 后腿小腿角度 | -Inf | Inf | bshin | hinge | 角度 (rad) |
| 4 | 后脚角度 | -Inf | Inf | bfoot | hinge | 角度 (rad) |
| 5 | 前腿大腿角度 | -Inf | Inf | fthigh | hinge | 角度 (rad) |
| 6 | 前腿小腿角度 | -Inf | Inf | fshin | hinge | 角度 (rad) |
| 7 | 前脚角度 | -Inf | Inf | ffoot | hinge | 角度 (rad) |
| 8 | 前端 x 坐标速度 | -Inf | Inf | rootx | slide | 速度 (m/s) |
| 9 | 前端 z 坐标速度 | -Inf | Inf | rootz | slide | 速度 (m/s) |
| 10 | 前端角速度 | -Inf | Inf | rooty | hinge | 角速度 (rad/s) |
| 11 | 后腿大腿角速度 | -Inf | Inf | bthigh | hinge | 角速度 (rad/s) |
| 12 | 后腿小腿角速度 | -Inf | Inf | bshin | hinge | 角速度 (rad/s) |
| 13 | 后脚角速度 | -Inf | Inf | bfoot | hinge | 角速度 (rad/s) |
| 14 | 前腿大腿角速度 | -Inf | Inf | fthigh | hinge | 角速度 (rad/s) |
| 15 | 前腿小腿角速度 | -Inf | Inf | fshin | hinge | 角速度 (rad/s) |
| 16 | 前脚角速度 | -Inf | Inf | ffoot | hinge | 角速度 (rad/s) |
| excluded | 前端 x 坐标 | -Inf | Inf | rootx | slide | 位置 (m) |
---
## 奖励函数设计
cheetah 的奖励函数由以下几个部分组成：
```python
# 速度奖励：追踪目标速度
# 姿势奖励：保持稳定的姿势
# 总奖励 = 速度奖励 + 姿势奖励
```
---
## 初始状态
- 重置所有有限关节角度到其允许范围内的随机值，并保持无限幅度关节默认状态。
- 通过多步物理模拟稳定躯干和腿部位置，生成初始观测向量返回。
## Episode 终止条件
- **无跌倒终止条件**（不会因失稳直接结束）
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env dm-cheetah
```
### 2. 开始训练
```bash
uv run scripts/train.py --env dm-cheetah
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/dm-cheetah
```
### 4. 测试训练结果
```bash
uv run scripts/play.py --env dm-cheetah
```
---
## 预期训练结果
1. 接近或超过 30.0 m/s 的稳定水平速度
2. 保持躯干直立且步态协调

149
docs/source/zh_CN/user_guide/demo/dm_hopper.md Normal file
View File

@@ -0,0 +1,149 @@
# 单脚跳跃机器人
单脚跳跃机器人（Hopper）是 DeepMind Control Suite 中的经典连续控制任务。其目标是训练一个模拟的单腿跳跃机器人，通过控制其关节力矩，实现站立平衡或向前跳跃。
```{video} /_static/videos/dm_hopper.mp4
:poster: _static/images/poster/dm_hopper.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
Hopper 是一个二维单腿跳跃机器人任务。由 5 段身体结构组成（torso 躯干、pelvis 骨盆、thigh 大腿、calf 小腿、foot 脚部），拥有 3 个受控关节（thigh_joint 大腿关节、leg_joint 小腿关节、foot_joint 脚部关节），智能体通过向这些关节施加扭矩作为动作，让机器人完成站立平衡或向前跳跃。
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-1.0, 1.0, (3,), float32)` |
| **维度** | 3 |
关节对应如下：
| 序号 | 动作含义（施加在关节的力矩） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | ---------------------------- | :----: | :----: | :-------------: |
| 0 | 大腿转子驱动扭矩 | -1 | 1 | `thigh_joint` |
| 1 | 小腿转子驱动扭矩 | -1 | 1 | `leg_joint` |
| 2 | 脚部转子驱动扭矩 | -1 | 1 | `foot_joint` |
---
## 观察空间
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (13,), float64)` |
| **维度** | 13 |
Hopper 环境的观测空间由以下部分组成（按顺序）：
| 部分 | 内容说明 | 维度 | 备注 |
| ------------------- | -------------------- | ---- | ------------------------------- |
| **qpos** | 关节角度与躯干高度 | 5 | 不包括 torso x 坐标（默认隐藏） |
| **qvel** | 关节角速度与躯干速度 | 6 | 所有关节及躯干的速度 |
| **contact sensors** | 脚尖与脚跟触地传感器 | 2 | 使用 `log1p` 正规化处理 |
| 序号 | 观察量 | 最小值 | 最大值 | XML 名称 | 关节 | 类型 (单位) |
| ---- | --------------- | ------ | ------ | ----------- | ------ | -------------- |
| 0 | 躯干 z 坐标 | -Inf | Inf | rootz | slide | 位置 (m) |
| 1 | 躯干角度 | -Inf | Inf | rooty | hinge | 角度 (rad) |
| 2 | 大腿关节角度 | -Inf | Inf | thigh_joint | hinge | 角度 (rad) |
| 3 | 小腿关节角度 | -Inf | Inf | leg_joint | hinge | 角度 (rad) |
| 4 | 脚部关节角度 | -Inf | Inf | foot_joint | hinge | 角度 (rad) |
| 5 | 躯干 x 坐标速度 | -Inf | Inf | rootx | slide | 速度 (m/s) |
| 6 | 躯干 z 坐标速度 | -Inf | Inf | rootz | slide | 速度 (m/s) |
| 7 | 躯干角速度 | -Inf | Inf | rooty | hinge | 角速度 (rad/s) |
| 8 | 大腿关节角速度 | -Inf | Inf | thigh_joint | hinge | 角速度 (rad/s) |
| 9 | 小腿关节角速度 | -Inf | Inf | leg_joint | hinge | 角速度 (rad/s) |
| 10 | 脚部关节角速度 | -Inf | Inf | foot_joint | hinge | 角速度 (rad/s) |
| 11 | 前脚触地传感器 | -Inf | Inf | touch_toe | sensor | 压力 (无量纲) |
| 12 | 后脚触地传感器 | -Inf | Inf | touch_heel | sensor | 压力 (无量纲) |
---
## 奖励函数设计
hopper 的奖励函数由以下几个部分组成：
### stand 任务（站立）
```python
# 站立奖励：维持目标站立高度稳定性
# 高度奖励：保持躯干在目标高度附近
# 总奖励 = 站立奖励
```
### hop 任务（跳跃）
```python
# 站立奖励：维持目标站立高度稳定性
# 跳跃奖励：达到目标前进速度
# 腿部运动奖励：适度的腿部摆动（抑制过度运动）
# 膝盖伸展奖励：适度的膝盖伸展动作
# 足部接触奖励：保持适当的足部接触力
# 总奖励 = 站立奖励 + 跳跃奖励 + 腿部运动奖励 + 膝盖伸展奖励 + 接触奖励
```
---
## 初始状态
- 重置部分关节角度到其允许范围内的随机值
- 保持有限幅度关节默认状态
## Episode 终止条件
- 机器人的状态观测值出现异常数值（NaN）
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env dm-hopper-stand
uv run scripts/view.py --env dm-hopper-hop
```
### 2. 开始训练
```bash
uv run scripts/train.py --env dm-hopper-stand
uv run scripts/train.py --env dm-hopper-hop
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/dm-hopper-hop
```
### 4. 测试训练结果
```bash
uv run scripts/play.py --env dm-hopper-stand
uv run scripts/play.py --env dm-hopper-hop
```
---
## 预期训练结果
### 站立任务 (dm-hopper-stand)
1. 保持机器人稳定站立
2. 躯干高度保持在 0.6 米附近
### 跳跃任务 (dm-hopper-hop)
1. 机器人实现稳定的向前跳跃
2. 跳跃运动达到 2.0 m/s 的目标速度
3. 步态协调，无明显摔倒

123
docs/source/zh_CN/user_guide/demo/dm_reacher.md Normal file
View File

@@ -0,0 +1,123 @@
# 双关节机械臂控制
双关节机械臂（Reacher）是 DeepMind Control Suite 中的经典操作任务。其目标是训练一个由两段连杆组成的机械臂，通过控制关节力矩，使末端执行器（fingertip）尽可能靠近随机生成的目标点。
```{video} /_static/videos/dm_reacher.mp4
:poster: _static/images/poster/dm_reacher.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
Reacher 是一个二维平面内的双关节机械臂控制任务。由两个通过铰链关节（hinge）连接的连杆组成，拥有 2 个受控关节（joint0 根部关节、joint1 中间关节），智能体通过向这些关节施加扭矩作为动作，使机械臂末端移动到目标点位置。目标点在每个 episode 初始化时随机采样。
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-1.0, 1.0, (2,), float32)` |
| **维度** | 2 |
动作对应如下：
| 序号 | 动作含义（施加在关节的力矩） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | ---------------------------- | :----: | :----: | :-------------: |
| 0 | 根部关节驱动扭矩 | -1 | 1 | `joint0` |
| 1 | 中间关节驱动扭矩 | -1 | 1 | `joint1` |
---
## 观察空间
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-inf, inf, (6,), float32)` |
| **维度** | 6 |
Reacher 环境的观测空间由以下部分组成（按顺序）：
| 部分 | 内容说明 | 维度 | 备注 |
| ---------------------- | -------------------- | ---- | ------------ |
| **qpos** | 2 个关节角度 | 2 | 关节位置信息 |
| **fingertip → target** | 末端到目标的向量差值 | 2 | x、y 两维 |
| **qvel** | 2 个关节角速度 | 2 | 关节速度信息 |
| 序号 | 观察量 | 最小值 | 最大值 | XML 名称 | 关节 | 类型 (单位) |
| ---- | ---------------------------- | ------ | ------ | ---------- | ----- | -------------- |
| 0 | 第一个关节角度 | -Inf | Inf | joint0_pos | hinge | 角度 (rad) |
| 1 | 第二个关节角度 | -Inf | Inf | joint1_pos | hinge | 角度 (rad) |
| 2 | fingertip - target 的 x 差值 | -Inf | Inf | NA | slide | 位置 (m) |
| 3 | fingertip - target 的 y 差值 | -Inf | Inf | NA | slide | 位置 (m) |
| 4 | 第一个关节角速度 | -Inf | Inf | joint0_vel | hinge | 角速度 (rad/s) |
| 5 | 第二个关节角速度 | -Inf | Inf | joint1_vel | hinge | 角速度 (rad/s) |
---
## 奖励函数设计
reacher 的奖励函数基于指尖与目标的距离：
```python
# 距离奖励：指尖越接近目标，奖励越高
reward = tolerance(|| fingertip - target ||)
# 其中 tolerance 是一个单调递减函数
# 距离为 0 时奖励最大，距离越大奖励越小
```
---
## 初始状态
初始状态通过随机分布采样：
- **手臂角度**：均匀分布
- **手臂角速度**：小范围随机值
- **目标点位置**：随机一个圆形区域
## Episode 终止条件
- 若观测中出现 `NaN` 值则终止
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env dm-reacher
```
### 2. 开始训练
```bash
uv run scripts/train.py --env dm-reacher
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/dm-reacher
```
### 4. 测试训练结果
```bash
uv run scripts/play.py --env dm-reacher
```
---
## 预期训练结果
1. 机械臂迅速精准触达目标
2. 末端与目标的平均距离小于 0.01 米
3. 动作平滑，无震荡

154
docs/source/zh_CN/user_guide/demo/dm_walker.md
View File

@@ -1,6 +1,6 @@
# 二维步行机器人训练示例
# 二维步行机器人
二维步行机器人（Walker2D）是基于 DeepMind Control Suite 的经典机器人控制任务，目标是通过控制机器人关节来实现站立、行走和奔跑。
二维步行机器人（Walker2D）是 DeepMind Control Suite 中的经典双足行走任务。其目标是训练一个模拟的双足机器人，通过控制其关节力矩，实现站立、行走和奔跑。
```{video} /_static/videos/dm_walker.mp4
:poster: _static/images/poster/dm_walker.jpg
@@ -14,89 +14,131 @@
## 任务描述
Walker2D 是一个二维平面的双足机器人，具有多个关节和执行器：
Walker2D 是一个二维平面的双足机器人任务。由多个身体部位组成，拥有多个受控关节，智能体通过向这些关节施加扭矩作为动作，让机器人实现站立平衡、向前行走或快速奔跑。该任务要求协调的双足步态和平衡控制能力。
- **状态空间**：包括机器人各部位的旋转角度、角速度、躯干高度和速度等
- **动作空间**：控制各个关节的力矩
- **奖励函数**：主要由保持站立、前进速度等组成
- **终止条件**：机器人摔倒或关节达到极限位置
---
### 三种任务模式
## 动作空间（Action Space）
1. **dm-stander**: 静止站立任务 (move_speed = 0.0)
| 项目 | 详细信息 |
| -------- | ------------------------------- |
| **类型** | `Box(-1.0, 1.0, (6,), float32)` |
| **维度** | 6 |
```bash
uv run scripts/train.py --env dm-stander
```
动作对应如下：
2. **dm-walker**: 行走任务 (move_speed = 1.0)
| 序号 | 动作含义（施加在关节的力矩） | 最小值 | 最大值 | 对应 XML 中名称 |
| ---: | ---------------------------- | :----: | :----: | :-------------: |
| 0 | 右大腿关节驱动扭矩 | -1 | 1 | `right_thigh` |
| 1 | 右小腿关节驱动扭矩 | -1 | 1 | `right_leg` |
| 2 | 右脚关节驱动扭矩 | -1 | 1 | `right_foot` |
| 3 | 左大腿关节驱动扭矩 | -1 | 1 | `left_thigh` |
| 4 | 左小腿关节驱动扭矩 | -1 | 1 | `left_leg` |
| 5 | 左脚关节驱动扭矩 | -1 | 1 | `left_foot` |
```bash
uv run scripts/train.py --env dm-walker
```
---
3. **dm-runner**: 奔跑任务 (move_speed = 5.0)
## 观察空间
```bash
uv run scripts/train.py --env dm-runner
```
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (17,), float32)` |
| **维度** | 17 |
## 配置参数
Walker2D 环境的观测空间由以下部分组成（按顺序）：
### 环境配置
| 部分 | 内容说明 | 维度 | 备注 |
| -------- | -------------------------- | ---- | -------------------- |
| **qpos** | 各身体关节与根部的位置信息 | 9 | 包括躯干高度和角度 |
| **qvel** | 各身体关节与根部的速度信息 | 8 | 所有关节及躯干的速度 |
```python
@dataclass
class WalkerEnvCfg(EnvCfg):
model_file: str = "walker.xml" # MJCF模型文件
max_episode_seconds: float = 25.0 # 最大episode长度
sim_dt: float = 0.0125 # 仿真时间步
ctrl_dt: float = 0.025 # 控制时间步
move_speed: float = 1.0 # 目标移动速度
stand_height: float = 1.2 # 目标站立高度
```
### 训练配置
```python
@dataclass
class WalkerRLCfg(BaseRLCfg):
num_envs: int = 512 # 并行环境数量
learning_rate: float = 3e-4 # 学习率
batch_size: int = 512 # 批大小
max_epochs: int = 1000 # 最大训练轮数
```
---
## 奖励函数设计
Walker2D 的奖励函数由以下几个部分组成：
walker 的奖励函数由以下几个部分组成：
### 基础站立奖励
```python
# 高度奖励：保持躯干在目标高度
# 直立奖励：保持躯干直立
# 总奖励 = 高度奖励 + 直立奖励
```
### 移动奖励（行走和奔跑任务）
```python
# 速度奖励：追踪目标速度
# 总奖励 = 站立奖励 * 移动权重
# 速度奖励：追踪目标前进速度
# 站立奖励：保持躯干在目标高度
# 直立奖励：保持躯干直立
# 总奖励 = 速度奖励 + 站立奖励 + 直立奖励
```
## 预期结果
---
1. **dm-stander**：
## 初始状态
- 躯干高度保持在 1.0-1.4m 范围
- 躯干直立角度偏差小于 15 度
- 重置所有有限关节角度到其允许范围内的随机值
- 保持无限幅度关节默认状态
2. **dm-walker**：
## Episode 终止条件
- 实际行走速度接近 1.0 m/s
- 步态协调，无明显摔倒
- 机器人的状态观测值出现异常数值（NaN）
- 机器人躯干接触地面（跌倒）
3. **dm-runner**：
- 奔跑速度达到 4.0-5.0 m/s
- 出现飞行相（双脚同时离地）
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env dm-stander
uv run scripts/view.py --env dm-walker
uv run scripts/view.py --env dm-runner
```
### 2. 开始训练
```bash
uv run scripts/train.py --env dm-stander
uv run scripts/train.py --env dm-walker
uv run scripts/train.py --env dm-runner
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/dm-walker
```
### 4. 测试训练结果
```bash
uv run scripts/play.py --env dm-stander
uv run scripts/play.py --env dm-walker
uv run scripts/play.py --env dm-runner
```
---
## 预期训练结果
### 站立任务 (dm-stander)
1. 躯干高度保持在 1.0-1.4m 范围
2. 躯干直立角度偏差小于 15 度
3. 能够稳定站立不倒
### 行走任务 (dm-walker)
1. 实际行走速度接近 1.0 m/s
2. 步态协调，无明显摔倒
3. 能够持续稳定行走
### 奔跑任务 (dm-runner)
1. 奔跑速度达到 4.0-5.0 m/s
2. 出现飞行相（双脚同时离地）
3. 步态协调稳定

255
docs/source/zh_CN/user_guide/demo/franka_lift_cube.md Normal file
View File

@@ -0,0 +1,255 @@
# Franka 抓取立方体
## 概述
本文档详细描述了基于 Franka Emika Panda 机械臂的抓取立方体任务环境。
```{video} /_static/videos/franka_lift_cube.mp4
:poster: _static/images/poster/franka_lift_cube.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
---
## 环境描述
Franka 抓取立方体任务环境基于真实的 Franka Emika Panda 7 自由度机械臂构建，旨在训练机器人在桌面上抓取立方体并将其提升到指定目标位置。
### 机器人结构
Franka Emika Panda 是一个 7 自由度机械臂，由以下主要部分组成：
- **基座（Base）**：固定在桌面上的机器人基座
- **7 个关节**：
- joint1 ~ joint4：肩部和臂部旋转关节
- joint5 ~ joint7：手腕部旋转关节
- **夹爪（Gripper）**：双指夹爪，包含两个手指关节
- finger_joint1：左指关节
- finger_joint2：右指关节
- **末端执行器（TCP）**：夹爪中心点，用于抓取操作
### 任务目标
机器人需要完成以下操作目标：
1. **接近目标**：从初始位置移动到立方体位置
2. **抓取立方体**：闭合夹爪抓取立方体
3. **提升立方体**：将立方体提升到目标高度
4. **精确定位**：将立方体移动到指定的目标位置（XYZ 三维坐标）
环境提供可视化辅助：
- **立方体**：可抓取的红色立方体，初始位于桌面上的随机位置
- **目标位置**：任务指定的立方体最终应到达的三维位置
---
## 动作空间
动作空间为 `Box(-inf, inf, (8,), float32)`，表示施加到 8 个关节的位置控制指令（相对于当前关节位置的偏移量）。
### 控制模式
环境使用位置控制模式，动作通过以下方式转换为关节目标位置：
```
目标关节角度 = 当前关节角度 + 动作值
```
### 动作维度详细说明
| 编号 | 动作说明 | 控制范围 | 对应关节名称 | 关节类型 |
| ---- | ---------------- | ---------- | -------------- | -------- |
| 0 | 关节 1 偏移量 | -inf ~ inf | joint1 | revolve |
| 1 | 关节 2 偏移量 | -inf ~ inf | joint2 | hinge |
| 2 | 关节 3 偏移量 | -inf ~ inf | joint3 | hinge |
| 3 | 关节 4 偏移量 | -inf ~ inf | joint4 | hinge |
| 4 | 关节 5 偏移量 | -inf ~ inf | joint5 | hinge |
| 5 | 关节 6 偏移量 | -inf ~ inf | joint6 | hinge |
| 6 | 关节 7 偏移量 | -inf ~ inf | joint7 | hinge |
| 7 | 夹爪动作（概率） | -inf ~ inf | finger_joint\* | hinge |
### 夹爪控制
夹爪动作使用概率控制：
1. **Sigmoid 映射**：将动作值映射到 [0, 1] 区间的概率
```
p = 1 / (1 + exp(-action))
```
2. **伯努利采样**：根据概率 p 进行随机采样
- 采样结果 < p：夹爪闭合（0.0）
- 采样结果 >= p：夹爪打开（0.04）
### 关节位置限制
所有关节位置在执行后被限制在以下范围内：
| 关节 | 最小值 | 最大值 |
| ---- | ------- | ------- |
| 1 | -2.8973 | 2.8973 |
| 2 | -1.7628 | 1.7628 |
| 3 | -2.8973 | 2.8973 |
| 4 | -3.0718 | -0.0698 |
| 5 | -2.8973 | 2.8973 |
| 6 | -0.0175 | 3.7525 |
| 7 | -π/2 | π/2 |
| 夹爪 | 0 | 0.04 |
---
## 观测空间
观测空间为 `Box(-inf, inf, (36,), float32)`，包含机器人的本体感知信息、物体状态和历史动作。
### 观测组成部分
观测向量由以下部分组成（按顺序）：
1. **关节角度（9 维）**
- 7 个机械臂关节相对于默认姿态的角度偏移
- 2 个夹爪关节角度
2. **关节速度（9 维）**
- 9 个关节的角速度
3. **立方体当前位姿（9 维）**
- 位置（3 维）：[x, y, z]
- 四元数（4 维）：[qx, qy, qz, qw]
- 旋转（Euler，2 维）：[roll, pitch]
4. **目标位置命令（7 维）**
- 目标 XYZ 坐标（3 维）
- 目标四元数（4 维）
5. **上一时刻动作（8 维）**
### 观测详细说明
| 编号 | 观测内容 | 维度 | 单位 |
| ----- | --------------------------- | ---- | ------ |
| 0-8 | 关节角度偏移（9 个关节） | 9 | rad |
| 9-17 | 关节角速度（9 个关节） | 9 | rad/s |
| 18-26 | 立方体当前位姿（位置+姿态） | 9 | rad |
| 27-33 | 目标位置命令（位置+四元数） | 7 | 无量纲 |
| 34-41 | 上一时刻动作（8 维） | 8 | 无量纲 |
---
## 奖励函数
奖励函数采用复合设计，包含多个奖励和惩罚项。
### 主要奖励项
1. **接近奖励**（权重：1.5）
- 计算公式：`1.5 × (1 - tanh(d_hand_cube / 0.1))`
- 激励机器人末端接近立方体
- d_hand_cube：末端到立方体的欧氏距离
2. **提升奖励**（权重：30）
- 条件：立方体高度 > 0.04m 且末端与立方体距离 < 0.05m
- 激励机器人抓取并提升立方体
3. **目标跟踪奖励**（变权重）
- **粗略跟踪**（权重：10）：使用 Sigmoid 函数，中心距离 0.3m
- **精细跟踪**（权重：20）：使用 tanh 函数，比例系数 0.4m
- **接近奖励**（权重：10）：距离 < 0.2m 时使用，比例系数 0.05m
- **接近加成**（权重：200）：额外奖励，鼓励接近目标
- 所有跟踪奖励仅在立方体高度 > 0.04m 且抓取成功时生效
### 惩罚项
惩罚项系数随训练进度调整：
| 惩罚项 | 前期权重（steps < 10000） | 后期权重（steps >= 10000） |
| ------------------ | ------------------------- | -------------------------- |
| 动作变化率惩罚 | 1e-4 | 1e-1 |
| 关节速度平方和惩罚 | 1e-4 | 1e-1 |
### 计算公式
```
动作变化率 = ||current_action - last_action||²
关节速度平方和 = ||joint_vel||²
```
---
## 初始状态
### 机器人初始化
**位置初始化：**
机器人在世界坐标系中的初始位置固定：
- 基座位置：固定在桌面上
- 关节角度：设置为默认姿态，并添加随机噪声
**关节角度噪声：**
每个关节角度在 `[-0.125, 0.125]` 弧度范围内添加均匀随机噪声。
**速度初始化：**
所有线速度和角速度初始化为零。
### 立方体初始化
立方体在桌面上的位置随机采样：
- X 坐标：`[-0.1, 0.1]`
- Y 坐标：`[-0.25, 0.25]`
- Z 坐标：固定为 0.05 桌面以上）
### 目标位置生成
目标位置在以下范围内随机采样：
- X 坐标：`[0.4, 0.6]`
- Y 坐标：`[-0.25, 0.25]`
- Z 坐标：`[0.25, 0.5]`
---
## 使用方法
### 训练
```bash
uv run scripts/train.py --env franka-lift-cube
```
### 策略评估
```bash
uv run scripts/play.py --env franka-lift-cube
```
### TensorBoard
```bash
uv run tensorboard --logdir runs/franka-lift-cube
```

250
docs/source/zh_CN/user_guide/demo/franka_open_cabinet.md Normal file
View File

@@ -0,0 +1,250 @@
# Franka 打开抽屉
## 概述
本文档详细描述了基于 Franka Emika Panda 机械臂的打开抽屉任务环境。
```{video} /_static/videos/franka_open_cabinet.mp4
:poster: _static/images/poster/franka_open_cabinet.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
---
## 环境描述
Franka 打开柜门任务环境基于真实的 Franka Emika Panda 7 自由度机械臂构建，旨在训练机器人接近柜门把手、抓取并拉开抽屉。
### 机器人结构
Franka Emika Panda 是一个 7 自由度机械臂，由以下主要部分组成：
- **基座（Base）**：固定在地面上的机器人基座
- **7 个关节**：
- joint1 ~ joint4：肩部和臂部旋转关节
- joint5 ~ joint7：手腕部旋转关节
- **夹爪（Gripper）**：双指夹爪，包含两个手指关节
- finger_joint1：左指关节，带有接触垫（left_finger_pad）
- finger_joint2：右指关节，带有接触垫（right_finger_pad）
- **末端执行器（TCP）**：夹爪中心点，用于抓取操作
### 环境物体
- **柜子**：包含一个可打开的抽屉
- **抽屉把手（drawer_top_handle）**：机器人需要抓取的目标部位
- **抽屉关节（drawer_top_joint）**：抽屉的滑动关节，1 个自由度
### 任务目标
机器人需要完成以下操作目标：
1. **接近把手**：从初始位置移动到抽屉把手位置
2. **姿态对齐**：调整末端姿态与把手对齐
3. **抓取把手**：闭合夹爪抓取抽屉把手
4. **拉开抽屉**：向后拉动抽屉将其打开
---
## 动作空间
动作空间为 `Box(-inf, inf, (8,), float32)`，表示施加到 8 个关节的位置控制指令（相对于当前关节位置的偏移量）。
### 控制模式
环境使用位置控制模式，动作通过以下方式转换为关节目标位置：
```
目标关节角度 = 当前关节角度 + 动作值
```
### 动作维度详细说明
| 编号 | 动作说明 | 控制范围 | 对应关节名称 | 关节类型 |
| ---- | ---------------- | ---------- | -------------- | -------- |
| 0 | 关节 1 偏移量 | -inf ~ inf | joint1 | revolve |
| 1 | 关节 2 偏移量 | -inf ~ inf | joint2 | hinge |
| 2 | 关节 3 偏移量 | -inf ~ inf | joint3 | hinge |
| 3 | 关节 4 偏移量 | -inf ~ inf | joint4 | hinge |
| 4 | 关节 5 偏移量 | -inf ~ inf | joint5 | hinge |
| 5 | 关节 6 偏移量 | -inf ~ inf | joint6 | hinge |
| 6 | 关节 7 偏移量 | -inf ~ inf | joint7 | hinge |
| 7 | 夹爪动作（概率） | -inf ~ inf | finger_joint\* | hinge |
### 夹爪控制
夹爪动作使用概率控制：
1. **Sigmoid 映射**：将动作值映射到 [0, 1] 区间的概率
```
p = 1 / (1 + exp(-action))
```
2. **伯努利采样**：根据概率 p 进行随机采样
- 采样结果 < p：夹爪闭合（0.0）
- 采样结果 >= p：夹爪打开（0.04）
---
## 观测空间
观测空间为 `Box(-5, 5, (25,), float32)`，包含机器人的本体感知信息、任务相关信息和抽屉状态。
### 观测组成部分
观测向量由以下部分组成（按顺序）：
1. **关节角度（8 维）**
- 7 个机械臂关节角度（归一化到 [-1, 1]）
- 归一化公式：`2 × (关节角度 - 下限) / (上限 - 下限) - 1`
2. **关节速度（8 维）**
- 8 个关节的角速度（除以 2 进行缩放）
3. **目标相对位姿（7 维）**
- 位置偏差（3 维）：把手位置 - 末端位置 [Δx, Δy, Δz]
- 姿态偏差（4 维）：把手姿态 - 末端姿态（四元数）
4. **抽屉关节位置（1 维）**
- 抽屉当前打开距离
5. **抽屉关节速度（1 维）**
- 抽屉当前打开速度
### 观测详细说明
| 编号 | 观测内容 | 维度 | 范围 | 单位 |
| ----- | -------------------------- | ---- | ------------ | ------ |
| 0-7 | 归一化关节角度（8 个关节） | 8 | [-1, 1] | 无量纲 |
| 8-15 | 归一化关节速度（8 个关节） | 8 | ≈[-π/2, π/2] | rad/s |
| 16-18 | 到把手的相对位置 | 3 | [-5, 5] | m |
| 19-22 | 到把手的相对姿态（四元数） | 4 | [-5, 5] | 无量纲 |
| 23 | 抽屉关节位置 | 1 | [-5, 5] | m |
| 24 | 抽屉关节速度 | 1 | [-5, 5] | m/s |
所有观测值被裁剪在 [-5, 5] 范围内以保持数值稳定性。
---
## 奖励函数
奖励函数采用复合设计，包含多个奖励和惩罚项。
### 主要奖励项
1. **距离奖励**（权重：10）
- 计算公式：`10 × (1 - tanh(d_gripper_handle / 0.1))`
- 激励机器人末端接近抽屉把手
- d_gripper_handle：末端到把手的欧氏距离
2. **姿态匹配奖励**
- 计算公式：四元数相似度函数
- 激励机器人末端姿态与把手姿态对齐
3. **夹爪闭合奖励**（条件奖励）
- 当距离 < 0.025m：闭合夹爪获得 +100 奖励
- 当距离 >= 0.025m：闭合夹爪获得 -20 惩罚
- 打开夹爪：无奖励（0）
- 激励机器人在接近时闭合夹爪抓取
4. **打开抽屉奖励**（指数奖励）
- 计算公式：`20 × (exp(open_dist) - 1)`
- open_dist：抽屉打开距离（裁剪在 [0, 1] 范围）
- 随着抽屉打开程度增加，奖励指数增长
5. **防止非法打开**
- 当抽屉已打开（open_dist > 0）但末端未接触把手（距离 > 0.03m）时，取消打开奖励
- 防止机器人使用其他方式强行打开抽屉
### 惩罚项
1. **动作变化率惩罚**
- 计算公式：`||current_action - last_action||²`
2. **关节速度惩罚**
- 计算公式：`||joint_vel||²`
3. **手指位置穿透惩罚**
- 当手指接触垫低于把手表面时施加惩罚
- 防止手指模型穿透抽屉
### 惩罚系数调度
惩罚项系数随训练进度调整：
| 惩罚项 | 前期权重（steps < 8000） | 后期权重（steps >= 8000） |
| -------------- | ------------------------ | ------------------------- |
| 动作变化率 | 1e-3 | 2e-3 |
| 关节速度平方和 | 0 | 2e-7 |
### 终止惩罚
当触发终止条件时，额外施加 -10.0 惩罚。
---
## 初始状态
### 机器人初始化
**位置初始化：**
机器人在世界坐标系中的初始位置固定：
- 基座位置：固定在地面上
- 关节角度：设置为默认姿态
**默认关节姿态：**
```
[0.0, -30°, 0°, -156°, 0.0, 186°, -45°, 0.04, 0.04] (弧度)
```
**关节角度噪声：**
每个关节角度在 `[-0.125, 0.125]` 弧度范围内添加均匀随机噪声。
**速度初始化：**
所有线速度和角速度初始化为零。
### 柜子初始化
柜子固定在地面上，抽屉处于关闭状态（关节位置为 0）。
---
## 使用方法
### 训练
```bash
uv run scripts/train.py --env franka-open-cabinet
```
### 策略评估
```bash
uv run scripts/play.py --env franka-open-cabinet
```
### TensorBoard
```bash
uv run tensorboard --logdir runs/franka-open-cabinet
```

147
docs/source/zh_CN/user_guide/demo/locomotion_unitree_go1.md
View File

@@ -1,4 +1,4 @@
# Unitree GO1 机器人行走训练示例
# Unitree GO1 平地行走
Unitree GO1 是一个四足机器人平台，本示例展示了如何训练 GO1 在平坦地形上实现稳定的步态行走。
@@ -14,68 +14,55 @@ Unitree GO1 是一个四足机器人平台，本示例展示了如何训练 GO1
## 任务描述
GO1 四足机器人具有 12 个自由度（每条腿 3 个关节），需要通过深度强化学习学习协调的步态控制：
GO1 四足机器人具有 12 个自由度（每条腿 3 个关节），需要通过深度强化学习学习协调的步态控制。该环境使用 MotrixSim 物理引擎进行仿真，提供高保真的动力学模拟。智能体通过控制各关节的目标位置（通过 PD 控制器转换为力矩）来实现速度跟踪和姿态稳定。
- **状态空间**：48 维，包含机器人线速度、角速度、姿态、关节角度、关节速度、动作和命令等
- **动作空间**：12 维，控制各个关节的目标位置（通过 PD 控制器转换为力矩）
- **奖励函数**：复合奖励，包含速度跟踪、姿态稳定、能量效率等多个组件
- **终止条件**：机器人躯干接触地面或其他不稳定状态
---
### 训练任务
## 动作空间（Action Space）
```bash
uv run scripts/train.py --env go1-flat-terrain-walk
```
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-1.0, 1.0, (12,), float32)` |
| **维度** | 12 |
## 配置参数
动作对应 12 个关节的位置控制指令（相对于默认站立姿态的偏移量），包括：
### 环境配置
| 序号 | 动作含义（关节位置变化） | 对应肢体 |
| ---: | -------------------------- | :------: |
| 0-2 | 髋关节、大腿关节、小腿关节 | 前左腿 |
| 3-5 | 髋关节、大腿关节、小腿关节 | 后左腿 |
| 6-8 | 髋关节、大腿关节、小腿关节 | 前右腿 |
| 9-11 | 髋关节、大腿关节、小腿关节 | 后右腿 |
```python
@dataclass
class Go1WalkNpEnvCfg(EnvCfg):
max_episode_seconds: float = 20.0 # 最大episode长度
model_file: str = "scene_motor_actuator.xml"
sim_dt: float = 0.01 # 仿真时间步
ctrl_dt: float = 0.01 # 控制时间步
```
---
### 控制配置
## 观察空间
```python
@dataclass
class ControlConfig:
stiffness = 80 # PD 控制器刚度 [N*m/rad]
damping = 1 # PD 控制器阻尼 [N*m*s/rad]
action_scale = 0.05 # 动作缩放因子
```
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (48,), float32)` |
| **维度** | 48 |
### 初始关节角度
GO1 环境的观测空间由以下部分组成（按顺序）：
```python
default_joint_angles = {
"FL_hip": 0.0, # 前左髋关节
"RL_hip": 0.0, # 后左髋关节
"FR_hip": -0.0, # 前右髋关节
"RR_hip": -0.0, # 后右髋关节
"FL_thigh": 0.9, # 前左大腿
"RL_thigh": 0.9, # 后左大腿
"FR_thigh": 0.9, # 前右大腿
"RR_thigh": 0.9, # 后右大腿
"FL_calf": -1.8, # 前左小腿
"RL_calf": -1.8, # 后左小腿
"FR_calf": -1.8, # 前右小腿
"RR_calf": -1.8, # 后右小腿
}
```
| 部分 | 内容说明 | 维度 | 备注 |
| --------------------- | ---------------- | ---- | ------------------ |
| **noisy_linvel** | 局部坐标系线速度 | 3 | 带噪声的线速度 |
| **noisy_gyro** | 陀螺仪数据 | 3 | 带噪声的角速度 |
| **local_gravity** | 局部重力方向 | 3 | 重力向量投影 |
| **noisy_joint_angle** | 关节角度 | 12 | 相对于默认值的偏差 |
| **noisy_joint_vel** | 关节速度 | 12 | 带噪声的关节速度 |
| **last_actions** | 上一帧动作 | 12 | 历史动作信息 |
| **command** | 速度命令 | 3 | [vx, vy, vyaw] |
---
## 奖励函数设计
GO1 的奖励函数是一个复杂的复合函数，包含多个组件：
### 主要奖励组件
```python
# 主要奖励组件
reward_config.scales = {
"tracking_lin_vel": 1.0, # 线速度跟踪奖励
"tracking_ang_vel": 0.5, # 角速度跟踪奖励
@@ -89,51 +76,57 @@ reward_config.scales = {
"hip_pos": -1, # 髋关节位置惩罚
"calf_pos": -0.3, # 腿关节位置惩罚
}
# 总奖励 = 加权组合以上所有项
```
### 关键奖励函数
---
#### 速度跟踪奖励
## 初始状态
```python
# 跟踪线速度命令（xy平面）
def _reward_tracking_lin_vel(self, data, commands):
- **机器人位置**：固定在初始位置
- **关节角度**：设置为默认站立姿态
- **关节角度噪声**：每个关节在 [-0.125, 0.125] 弧度范围内添加随机噪声
- **速度初始化**：所有线速度和角速度初始化为零
# 跟踪角速度命令（偏航）
def _reward_tracking_ang_vel(self, data, commands):
## Episode 终止条件
- **身体接触地面**：机器人躯干与地面发生非预期接触
- **速度异常**：线速度平方和超过阈值（1e8）
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env go1-flat-terrain-walk
```
#### 足部空中时间奖励
### 2. 开始训练
```python
def _reward_feet_air_time(self, commands, info):
```bash
uv run scripts/train.py --env go1-flat-terrain-walk
```
## 观察空间构成
### 3. 查看训练进度
GO1 的观察空间为 48 维，包含以下信息：
```python
obs = np.hstack([
noisy_linvel, # 3维：局部坐标系线速度
noisy_gyro, # 3维：陀螺仪数据
local_gravity, # 3维：局部重力方向
noisy_joint_angle, # 12维：关节角度（相对于默认值）
noisy_joint_vel, # 12维：关节速度
last_actions, # 12维：上一帧动作
command, # 3维：速度命令 [vx, vy, vyaw]
])
```bash
uv run tensorboard --logdir runs/go1-flat-terrain-walk
```
## 运动速度命令生成
### 4. 测试训练结果
训练过程中随机生成速度命令，确保智能体能够跟踪不同的移动速度：
```python
def resample_commands(self, num_envs: int):
```bash
uv run scripts/play.py --env go1-flat-terrain-walk
```
---
## 预期训练结果
1. 稳定的四足步态
2. 良好的速度跟踪
1. 稳定的四足步态（trot 步态或其他协调步态）
2. 良好的速度跟踪能力
3. 能够跟踪不同的速度命令（前进、转向）
4. 姿态稳定，无明显侧翻

198
docs/source/zh_CN/user_guide/demo/locomotion_unitree_go1_rough_terrain.md Normal file
View File

@@ -0,0 +1,198 @@
# Unitree GO1 复杂地形行走
Unitree GO1 复杂地形行走环境是一个四足机器人强化学习任务，旨在训练机器人在具有挑战性的地形上实现稳定行走。该环境包含两种主要的地形类型：粗糙地形和台阶地形。
```{video} /_static/videos/go1_rough_terrain_walk.mp4
:poster: _static/images/poster/go1_rough_terrain_walk.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
---
```{video} /_static/videos/go1_stairs_terrain_walk.mp4
:poster: _static/images/poster/go1_stairs_terrain_walk.jpg
:nocontrols:
:autoplay:
:playsinline:
:muted:
:loop:
:width: 100%
```
## 任务描述
训练 Unitree GO1 四足机器人在复杂地形上实现稳定、高效的双足行走。该环境使用 MotrixSim 物理引擎进行仿真，提供高保真的动力学模拟。智能体通过控制各关节的目标位置来实现速度跟踪和姿态稳定，同时适应不同的地形挑战。
### 任务目标
- **速度跟踪**：准确跟踪给定的线速度和角速度命令
- **姿态稳定**：在各种地形条件下保持身体姿态稳定
- **能量效率**：以最小的能耗实现行走任务
- **地形适应性**：适应粗糙地形和台阶地形的不同挑战
---
## 动作空间（Action Space）
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-1.0, 1.0, (12,), float32)` |
| **维度** | 12 |
动作对应 12 个关节的位置控制指令，包括四条腿的髋关节、大腿关节和小腿关节。
---
## 观察空间
### 粗糙地形观察空间（48 维）
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (48,), float32)` |
| **维度** | 48 |
| 部分 | 内容说明 | 维度 | 备注 |
| --------------------- | ------------------------ | ---- | -------------- |
| **noisy_linvel** | 机体坐标系下的线速度 | 3 | 带噪声的线速度 |
| **noisy_gyro** | 机体坐标系下的角速度 | 3 | 带噪声的角速度 |
| **local_gravity** | 局部坐标系下的重力方向 | 3 | 重力向量投影 |
| **noisy_joint_angle** | 关节角度与默认角度的偏差 | 12 | 12 个关节 |
| **noisy_joint_vel** | 关节角速度 | 12 | 带噪声的速度 |
| **last_actions** | 上一时间步的控制动作 | 12 | 历史动作 |
| **command** | 目标线速度和角速度 | 3 | [vx, vy, vyaw] |
### 台阶地形观察空间（60 维）
| 项目 | 详细信息 |
| -------- | -------------------------------- |
| **类型** | `Box(-inf, inf, (60,), float32)` |
| **维度** | 60 |
在粗糙地形基础上增加了：
| 部分 | 内容说明 | 维度 | 备注 |
| ---------------------- | -------------------- | ---- | ---------------------- |
| **feet_contact_force** | 四个足部的接触力向量 | 12 | 每足 3 维 (Fx, Fy, Fz) |
---
## 奖励函数设计
GO1 复杂地形的奖励函数采用多目标加权设计：
```python
# 核心奖励组件
reward_config.scales = {
"tracking_lin_vel": 1.0, # 线速度跟踪精度
"tracking_ang_vel": 0.5, # 角速度跟踪精度
"orientation": -0.0, # 身体姿态稳定性惩罚
"torques": -0.00001, # 关节力矩惩罚（能量效率）
"dof_acc": -2.5e-7, # 关节加速度惩罚
"action_rate": -0.001, # 动作平滑性惩罚
"feet_air_time": 1.0, # 足部空中时间奖励（鼓励大步幅）
"stand_still": 0.0, # 静止指令的关节位置保持
"hip_pos": -1, # 髋关节位置偏好
"calf_pos": -0.3, # 小腿关节位置偏好
"feet_stumble": -0.5, # 当足部横向触碰障碍物时施加惩罚
}
# 总奖励 = 加权组合以上所有项
```
---
## 初始状态
### 粗糙地形初始化
- **地形生成**：使用高度图生成随机地形
- **地形高度级别**：预设 -2.5m、0.5m、2.0m 三个高度级别
- **位置随机化**：在基础训练级别时机器人固定位置，高级别时按预设的 25 个位置周期循环随机选择
### 台阶地形初始化
- **地形类型**：连续地形上布置多种以台阶为主的小地块
- **位置随机化**：与粗糙地形类似的位置随机化策略
### 机器人初始化
- **关节角度**：设置为默认站立姿态，添加 [-0.125, 0.125] 弧度噪声
- **速度初始化**：所有线速度和角速度初始化为零
## Episode 终止条件
- **身体接触地面**：机器人躯干与地面发生非预期接触
- **速度异常**：线速度平方和超过阈值（1e8）
---
## 使用指南
### 1. 环境预览
```bash
uv run scripts/view.py --env go1-rough-terrain-walk
uv run scripts/view.py --env go1-stairs-terrain-walk
```
### 2. 开始训练
```bash
uv run scripts/train.py --env go1-rough-terrain-walk
uv run scripts/train.py --env go1-stairs-terrain-walk
```
### 3. 查看训练进度
```bash
uv run tensorboard --logdir runs/go1-rough-terrain-walk
```
### 4. 测试训练结果
由于粗糙地形场景中同时生成了了一个无限大平面和一个崎岖地形高度场，测试训练结果时会仿照训练过程先将智能体生成在平面上，完成一轮行走后再生成到崎岖地形上。用户需要主动调整相机视角和位置来观察智能体的状态。
```bash
uv run scripts/play.py --env go1-rough-terrain-walk
uv run scripts/play.py --env go1-stairs-terrain-walk
```
---
## 预期训练结果
### 粗糙地形任务 (go1-rough-terrain-walk)
1. 能够适应不同的粗糙地形高度
2. 速度跟踪精度高，姿态稳定
3. 步态协调，足部打滑少
### 台阶地形任务 (go1-stairs-terrain-walk)
1. 能够稳定上下台阶
2. 能够适应不同高度和宽度的台阶
3. 动作流畅，无明显卡顿
## 训练性能参考
### go1-rough-terrain-walk
| 操作系统 | 训练后端 | CPU | GPU | 环境数 | 训练时间 (30000 steps) |
| ------------ | -------- | ----------------- | ----------- | ------ | ---------------------- |
| Ubuntu 22.04 | JAX | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 7m20s |
| Ubuntu 22.04 | PyTorch | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 8m30s |
| Windows 11 | PyTorch | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 10m42s |
### go1-stairs-terrain-walk
| 操作系统 | 训练后端 | CPU | GPU | 环境数 | 训练时间 (30000 steps) |
| ------------ | -------- | ----------------- | ----------- | ------ | ---------------------- |
| Ubuntu 22.04 | JAX | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 7m18s |
| Ubuntu 22.04 | PyTorch | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 8m41s |
| Windows 11 | PyTorch | AMD Ryzen 7 9700X | RTX 5070 Ti | 2048 | 10m52s |