Stable Baselines3 与 RSL-RL 强化学习库全面技术文档

文档概述：本文档系统整理了当前主流的两个强化学习框架——Stable Baselines3（SB3）与 RSL-RL（Robotic Systems Lab RL）的技术细节。SB3 面向通用强化学习，提供丰富的算法实现和简洁的 API；RSL-RL 专注于机器人运动控制，以 GPU 加速和高吞吐量为核心特色。文档涵盖安装配置、快速入门、API 参考和算法核心内容，适合不同层次开发者参考。

第一部分：Stable Baselines3

1. 核心功能与技术规格

1.1 项目概述

Stable Baselines3（简称 SB3）是一个基于 PyTorch 的强化学习算法实现库，作为 Stable Baselines 的下一代版本，提供了多种经典强化学习算法的高质量、可靠实现。由德国航空航天中心（DLR-RM）维护，其设计目标是让研究者和工业界能够轻松复现、改进和识别新想法，同时为构建项目提供良好的基线。

1.2 核心特性

• 统一架构：所有算法采用一致的代码结构和接口设计，遵循 sklearn 风格的 API 规范
• 生产级代码质量：严格遵循 PEP8 规范，包含完整的类型提示，确保代码可读性和可维护性
• 算法丰富：内置 A2C、DDPG、DQN、HER、PPO、SAC、TD3 等多种经典算法
• 全面兼容性：支持离散/连续动作空间、字典观测空间、自定义环境和策略
• 高性能实现：优化的神经网络结构和数据处理流程，支持多进程训练和向量化环境
• 丰富工具集：内置环境检查器、回调函数系统、TensorBoard 集成和模型导出功能
• 完善文档：每个函数和类都有详细说明文档，包含全面的测试用例和高代码覆盖率

1.3 支持的算法

算法	动作空间	算法类型	简介
A2C	离散/连续	On-Policy	Advantage Actor-Critic，同步版本
DDPG	连续	Off-Policy	Deep Deterministic Policy Gradient
DQN	离散	Off-Policy	Deep Q-Network，含多种扩展
HER	—	Off-Policy	Hindsight Experience Replay，与 Off-Policy 算法联合使用
PPO	离散/连续	On-Policy	Proximal Policy Optimization，极其稳定
SAC	连续	Off-Policy	Soft Actor-Critic，高性能
TD3	连续	Off-Policy	Twin Delayed DDPG，减少过高估计

1.4 生态系统

SB3 拥有丰富的扩展生态：

• SB3 Contrib：实验性算法仓库，包含循环 PPO、CrossQ、TQC、TRPO 等前沿算法实现
• SBX：SB3 的 Jax 实现版本，训练速度提升可达 20 倍
• RL Baselines3 Zoo：完整的训练框架，提供训练/评估脚本、超参数调优和预训练模型
• 环境集成：支持 Gymnasium、Atari 游戏、MuJoCo 物理引擎等主流环境

1.5 环境要求

• Python 3.9+
• PyTorch >= 2.3

2. 安装和配置指南

2.1 pip 安装

最简便的安装方式：

pip install stable-baselines3

如需安装可选依赖（TensorBoard、OpenCV 等）：

pip install stable-baselines3[extra]

注意：部分 Shell（如 Zsh）需要用引号包裹括号：pip install 'stable-baselines3[extra]'

2.2 开发版本安装

git clone https://github.com/DLR-RM/stable-baselines3
cd stable-baselines3
pip install -e .[docs,tests,extra]

安装前沿版本（master 分支）：

pip install git+https://github.com/DLR-RM/stable-baselines3

2.3 Docker 安装

SB3 提供预构建的 Docker 镜像：

# GPU 镜像
docker pull stablebaselines/stable-baselines3

# CPU 镜像
docker pull stablebaselines/stable-baselines3-cpu

运行 GPU 容器：

docker run -it --runtime=nvidia --rm --network host \
  --ipc=host --name test \
  --mount src="$(pwd)",target=/home/mamba/stable-baselines3,type=bind \
  stablebaselines/stable-baselines3

2.4 安装 SB3 Contrib

# 先安装 master 版本的 SB3
pip install git+https://github.com/DLR-RM/stable-baselines3

# 再安装 SB3 Contrib
pip install sb3-contrib

3. 快速入门教程（含代码示例）

3.1 极简示例：一行代码训练

from stable_baselines3 import PPO

# 一行代码完成训练
model = PPO("MlpPolicy", "CartPole-v1").learn(10_000)

3.2 标准训练流程

以下是一个完整的训练与推理示例：

import gymnasium as gym
from stable_baselines3 import A2C

# 1. 创建环境
env = gym.make("CartPole-v1", render_mode="rgb_array")

# 2. 实例化算法
model = A2C("MlpPolicy", env, verbose=1)

# 3. 训练
model.learn(total_timesteps=10_000)

# 4. 推理与评估
vec_env = model.get_env()
obs = vec_env.reset()
for i in range(1000):
    action, _state = model.predict(obs, deterministic=True)
    obs, reward, done, info = vec_env.step(action)
    vec_env.render("human")

3.3 PPO 算法示例

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.env_util import make_vec_env

# 创建向量化环境（4 个并行环境）
vec_env = make_vec_env("CartPole-v1", n_envs=4, seed=0)

# 训练
model = PPO("MlpPolicy", vec_env, verbose=1)
model.learn(total_timesteps=25_000)

# 保存模型
model.save("ppo_cartpole")

# 加载模型
loaded_model = PPO.load("ppo_cartpole", env=vec_env)

3.4 DQN 算法示例（含评估）

import gymnasium as gym
from stable_baselines3 import DQN
from stable_baselines3.common.evaluation import evaluate_policy

# 创建环境
env = gym.make("LunarLander-v3", render_mode="rgb_array")

# 实例化算法
model = DQN("MlpPolicy", env, verbose=1)

# 训练并显示进度条
model.learn(total_timesteps=200_000, progress_bar=True)

# 评估
mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10)
print(f"平均奖励: {mean_reward:.2f} +/- {std_reward:.2f}")

# 保存与加载
model.save("dqn_lunar")
loaded_model = DQN.load("dqn_lunar", env=env)

3.5 使用回调函数

from stable_baselines3 import PPO
from stable_baselines3.common.callbacks import EvalCallback, StopTrainingOnRewardThreshold

# 创建评估回调
stop_callback = StopTrainingOnRewardThreshold(reward_threshold=200, verbose=1)
eval_callback = EvalCallback(
    env,
    best_model_save_path="./logs/",
    log_path="./logs/",
    eval_freq=500,
    callback_on_new_best=stop_callback,
)

# 训练时使用回调
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10_000, callback=eval_callback)

3.6 自定义策略网络

import torch.nn as nn
from stable_baselines3 import PPO
from stable_baselines3.common.torch_layers import BaseFeaturesExtractor

# 自定义特征提取器
class CustomCNN(BaseFeaturesExtractor):
    def __init__(self, observation_space, features_dim=256):
        super().__init__(observation_space, features_dim)
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=8, stride=4),
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, stride=1),
            nn.ReLU(),
            nn.Flatten(),
        )
        # 计算展平后的维度
        with torch.no_grad():
            n_flatten = self.cnn(
                torch.as_tensor(observation_space.sample()[None]).float()
            ).shape[1]
        self.linear = nn.Sequential(nn.Linear(n_flatten, features_dim), nn.ReLU())

    def forward(self, observations):
        return self.linear(self.cnn(observations))

# 使用自定义特征提取器
policy_kwargs = dict(features_extractor_class=CustomCNN)
model = PPO("CnnPolicy", env, policy_kwargs=policy_kwargs, verbose=1)

4. API 参考文档

4.1 核心 API 架构

SB3 采用模块化架构，核心组件包括：

• BaseAlgorithm：所有算法的基类，定义统一的接口
• BasePolicy：策略网络的抽象基类
• OnPolicyAlgorithm / OffPolicyAlgorithm：On-Policy 与 Off-Policy 算法的中间基类
• RolloutBuffer / ReplayBuffer：经验回放缓冲区

4.2 主要 API 方法

通用算法方法（所有算法均继承自 BaseAlgorithm）：

方法	说明
learn(total_timesteps, callback=None, log_interval=1, progress_bar=False)	训练模型指定时间步
predict(observation, state=None, deterministic=False)	使用训练好的策略预测动作
save(path)	保存模型到指定路径
load(path, env=None, **kwargs)	从文件加载模型
get_env()	获取算法内部使用的向量化环境
set_env(env)	替换算法使用的环境

常见参数说明：

• policy：策略网络类型，如 "MlpPolicy" 或 "CnnPolicy"
• env：Gymnasium 环境实例或注册名称字符串
• learning_rate：学习率（可为常量或调度函数）
• buffer_size：回放缓冲区大小（Off-Policy 算法）
• batch_size：小批量大小

4.3 策略网络类型

策略名称	适用场景	说明
MlpPolicy	一维观测空间	使用多层感知机处理向量观测
CnnPolicy	图像观测空间	使用 CNN 提取图像特征
MultiInputPolicy	字典观测空间	使用 CombinedExtractor 处理多模态输入

4.4 常用工具模块

模块	路径	功能
环境检查器	stable_baselines3.common.env_checker.check_env()	验证环境是否符合 Gym 接口规范
环境工具	stable_baselines3.common.env_util.make_vec_env()	便捷创建向量化环境
评估工具	stable_baselines3.common.evaluation.evaluate_policy()	评估策略性能
环境包装器	stable_baselines3.common.vec_env.VecNormalize	观测/奖励归一化
监控包装器	stable_baselines3.common.monitor.Monitor	训练指标收集

4.5 SB3 Contrib 扩展 API

SB3 Contrib 提供额外的前沿算法：

• ARS：Augmented Random Search
• Maskable PPO：支持动作掩码的 PPO
• Recurrent PPO：支持循环网络的 PPO
• QR-DQN：Quantile Regression DQN
• TQC：Truncated Quantile Critics
• TRPO：Trust Region Policy Optimization

5. 算法核心内容

5.1 整体架构设计

SB3 的训练循环由两个核心阶段构成，形成一个持续迭代的闭环系统：

1. 经验收集阶段：通过 collect_rollouts() 方法，使用当前策略在环境中执行动作，将交互数据存储到缓冲区
2. 策略更新阶段：调用 train() 方法，从缓冲区采样数据优化网络参数
3. 迭代控制：重复上述过程，直到达到预设的总时间步数

5.2 算法结构详解

每个算法目录包含算法定义和策略定义两个核心文件：

• algo.py：算法主体实现
• policies.py：该算法专用的策略网络定义

On-Policy 与 Off-Policy 算法的主要区别：

特性	On-Policy（如 PPO, A2C）	Off-Policy（如 DQN, SAC, TD3）
数据来源	仅使用当前策略收集的数据	可使用历史经验回放数据
缓冲区	RolloutBuffer（更新后丢弃）	ReplayBuffer（可复用）
采样效率	较低	较高
稳定性	一般更稳定	需要精细调节

5.3 策略网络结构

SB3 中的“策略”包含所有与训练相关的网络模块：

• Actor（演员） ：负责根据观测预测动作
• Critic（评论家） ：负责估计状态价值或 Q 值
• Target Networks（目标网络） ：用于稳定训练的延迟更新网络（Off-Policy 算法）

策略命名机制："MlpPolicy" 和 "CnnPolicy" 分别表示使用 MLP 或 CNN 特征提取的通用策略名称，导入 [algorithm]/policies.py 时自动为该算法注册相应的策略类。

5.4 重点算法详解

PPO（Proximal Policy Optimization）

PPO 是 SB3 中最推荐的全能算法，适用于离散和连续动作空间。其核心特点包括：

• 裁剪目标函数：限制策略更新幅度，防止破坏性的大步更新
• 多轮更新：在同一批数据上进行多次梯度更新（可配置轮数）
• 高度稳定：对超参数不敏感，适用于机器人控制、游戏 AI 等多种场景

# PPO 关键超参数
model = PPO(
    "MlpPolicy",
    env,
    n_steps=2048,          # 每次更新前收集的步数
    batch_size=64,          # 小批量大小
    n_epochs=10,            # 每批数据上的更新轮数
    gamma=0.99,             # 折扣因子
    gae_lambda=0.95,        # GAE 参数
    clip_range=0.2,         # 裁剪范围
    learning_rate=3e-4,     # 学习率
)

SAC（Soft Actor-Critic）

SAC 是一种最大熵 Off-Policy 算法，适用于连续控制任务，性能优秀：

model = SAC(
    "MlpPolicy",
    env,
    learning_rate=3e-4,
    buffer_size=1_000_000,  # 回放缓冲区大小
    batch_size=256,
    tau=0.005,              # 目标网络软更新系数
    gamma=0.99,
)

TD3（Twin Delayed DDPG）

TD3 针对 DDPG 的过高估计问题做了三个关键改进：

• 双 Critic 网络：取两个 Critic 的较小值，减少过高估计
• 延迟策略更新：Critic 更新频率高于 Actor
• 目标策略平滑：在目标动作上添加噪声，防止策略过拟合

5.5 预处理与数据流

环境观测的预处理流程：

1. 图像空间处理：自动检测图像空间，使用 VecTransposeImage 将通道末位格式转换为 PyTorch 的通道首位格式
2. 离散观测编码：对离散观测空间进行 one-hot 编码
3. 字典空间处理：使用 CombinedExtractor 对多模态输入进行联合特征提取

5.6 概率分布系统

策略网络根据不同动作空间自动选择对应的概率分布：

动作空间	概率分布	说明
离散	CategoricalDistribution	类别分布，输出每个动作的概率
多离散	MultiCategoricalDistribution	多个独立类别分布的笛卡尔积
连续	DiagGaussianDistribution	对角高斯分布，输出均值和标准差
有界连续	SquashedDiagGaussianDistribution	经 tanh 压缩的高斯分布
伯努利	BernoulliDistribution	伯努利分布，用于多二进制动作

6. 实用技巧与常见问题

6.1 环境兼容性检查

from stable_baselines3.common.env_checker import check_env

# 检查自定义环境是否符合 SB3 要求
check_env(my_custom_env)

6.2 观测归一化

对于连续控制任务，观测归一化至关重要：

from stable_baselines3.common.vec_env import VecNormalize, DummyVecEnv

# 创建并包装归一化环境
env = DummyVecEnv([lambda: gym.make("HalfCheetah-v5")])
env = VecNormalize(env, norm_obs=True, norm_reward=True)

# 训练
model = PPO("MlpPolicy", env)
model.learn(total_timesteps=1_000_000)

# 保存归一化统计量
model.save("model")
env.save("vec_normalize.pkl")

6.3 常见问题解决

Q: 训练过程中出现 NaN 值怎么办？
A: 检查是否忘记归一化观测空间或动作空间，使用 VecNormalize 包装器可自动处理数据标准化。

Q: 如何判断环境是否符合 SB3 要求？
A: 使用 stable_baselines3.common.env_checker.check_env() 工具验证。

7. 学术引用

@article{stable-baselines3,
  author = {Antonin Raffin and Ashley Hill and Adam Gleave and
            Anssi Kanervisto and Maximilian Ernestus and Noah Dormann},
  title  = {Stable-Baselines3: Reliable Reinforcement Learning
            Implementations},
  journal = {Journal of Machine Learning Research},
  year   = {2021},
  volume = {22},
  number = {268},
  pages  = {1-8},
  url    = {http://jmlr.org/papers/v22/20-1364.html}
}

第二部分：RSL-RL

1. 核心功能与技术规格

1.1 项目概述

RSL-RL（Robotic Systems Lab Reinforcement Learning）是由苏黎世联邦理工学院（ETH Zurich）的 Robotic Systems Lab 开发的一款 GPU 加速、轻量级强化学习库，专为机器人研究设计。该库源自 NVIDIA Isaac Gym 中的 rl-pytorch 代码演进而来，以其紧凑的代码设计允许研究者快速原型和测试新想法，而无需修改大型复杂库的开销。

1.2 核心特性

• 极简代码库：代码量小，结构清晰，扩展点明确，便于快速原型开发
• 机器人优先方法：原生支持 PPO 和 Teacher-Student 蒸馏，并提供 Robot-Specific 辅助技术
• GPU 加速：整个训练循环在 GPU 上运行，支持数千个并行环境的 rollout 收集
• 原生多 GPU 训练：内建多 GPU 支持，实现高吞吐量训练
• 非对称 Actor-Critic：支持 Critic 网络观察比 Actor 更多的信息（如特权信息）
• GAE 优势估计：高效的 On-Policy 训练，支持广义优势估计
• 轻量依赖：最小化外部依赖，与 Isaac Lab 紧密集成

1.3 支持的算法

RSL-RL 目前提供两大核心算法：

算法	类型	说明
PPO	On-Policy	Proximal Policy Optimization，机器人学习的标准选择，鲁棒且简单
BC（含 DAgger 风格）	Offline	行为克隆，支持 Teacher-Student 知识蒸馏框架

1.4 学习环境与生态

RSL-RL 与以下主流机器人仿真库深度集成：

• Isaac Lab：基于 NVIDIA Isaac Sim 的高保真仿真框架
• Legged Gym：基于 NVIDIA Isaac Gym 的足式机器人训练环境
• mjlab：基于 MuJoCo Warp 的仿真环境
• MuJoCo Playground：基于 MuJoCo MJX 和 Warp 的训练平台

1.5 环境要求

• Python 3.9+
• PyTorch（建议使用最新版本）
• 推荐在虚拟环境中安装

2. 安装和配置指南

2.1 pip 安装

pip install rsl-rl-lib

2.2 开发版本安装

git clone https://github.com/leggedrobotics/rsl_rl
cd rsl_rl
pip install -e .

2.3 与 Isaac Lab 集成安装

RSL-RL 通常与 Isaac Lab 一起使用，Isaac Lab 会自动管理 RSL-RL 作为依赖。Isaac Lab 中 RSL-RL 的训练脚本位于：

scripts/reinforcement_learning/rsl_rl/train.py

2.4 验证安装

import rsl_rl

print(f"RSL-RL 版本: {rsl_rl.__version__}")

3. 快速入门教程（含代码示例）

3.1 完整训练示例：人形机器人运动控制

以下以在 Isaac Lab 中训练 Unitree H1 人形机器人为例，展示 RSL-RL 的完整工作流程：

任务配置：

属性	值
环境 ID	Isaac-Velocity-Rough-H1-v0
机器人	Unitree H1（19 个驱动关节，双足人形）
地形	程序化生成的崎岖地形（斜坡、台阶、障碍物）
目标	跟踪指令前进速度、横向速度和偏航角速度
观测空间	关节位置、关节速度、重力投影、速度指令、历史动作
动作空间	所有驱动关节的目标关节位置

启动训练：

cd ~/IsaacLab
./isaaclab.sh -p scripts/reinforcement_learning/rsl_rl/train.py \
    --task=Isaac-Velocity-Rough-H1-v0 \
    --headless

训练过程中的典型输出：

Learning iteration 15/3000
  Computation: 65955 steps/s (collection: 1.256s, learning 0.235s)
  Mean action noise std: 1.04
  Mean value_function loss: 0.0911
  Mean surrogate loss: 0.0003
  Mean entropy loss: 27.6371
  Mean reward: -5.35
  Mean episode length: 61.42

3.2 最小化训练脚本

以下是一个使用 RSL-RL 的最小化 PPO 训练示例：

# Step 1: 环境设置
# 使用 Isaac Lab 提供的环境
from isaaclab.app import AppLauncher

# 启动仿真应用
app_launcher = AppLauncher(headless=True)
simulation_app = app_launcher.app

# 导入环境
import isaaclab_tasks  # 注册环境
from isaaclab.rl.env import ManagerBasedRLEnv

# 创建环境
env = ManagerBasedRLEnv(cfg=env_cfg)

# Step 2: 配置字典
# RSL-RL 使用字典配置训练参数
train_cfg = {
    "runner": "OnPolicyRunner",
    "algorithm": "PPO",
    "model": {
        "class_name": "MLPModel",
        "actor_hidden_dims": [512, 256, 128],
        "critic_hidden_dims": [512, 256, 128],
        "activation": "elu",
    },
    "runner_config": {
        "num_iterations": 3000,
        "num_steps_per_env": 24,
        "save_interval": 100,
    },
    "algorithm_config": {
        "learning_rate": 1e-3,
        "num_learning_epochs": 5,
        "num_mini_batches": 4,
        "discount_factor": 0.99,
        "gae_lambda": 0.95,
        "clip_param": 0.2,
        "entropy_coef": 0.01,
    },
}

# Step 3: 初始化 Runner
from rsl_rl.runners import OnPolicyRunner

runner = OnPolicyRunner(env, train_cfg, log_dir="./logs", device="cuda:0")

# Step 4: 运行训练
runner.learn(num_iterations=3000)

# 保存模型
runner.save("./models/final_model.pt")

3.3 加载与评估训练好的模型

Isaac Lab 提供了专门的推理脚本：

./isaaclab.sh -p scripts/reinforcement_learning/rsl_rl/play.py \
    --task=Isaac-Velocity-Rough-H1-v0 \
    --checkpoint=./models/final_model.pt

或通过代码加载：

from rsl_rl.runners import OnPolicyRunner

# 加载之前保存的 runner
runner = OnPolicyRunner(env, train_cfg, log_dir="./logs", device="cuda:0")

# 恢复训练或评估
obs = env.reset()
for _ in range(1000):
    actions = runner.get_inference_policy(obs)
    obs, _, dones, _ = env.step(actions)

4. API 参考文档

4.1 核心架构

RSL-RL 由三大主要组件构成：

• Runners：训练协调器，管理训练循环、日志记录和模型检查点
• Algorithms：算法实现（目前主要为 PPO）
• Networks：神经网络模型定义

4.2 核心类 API

OnPolicyRunner

训练循环的主控制器，管理 PPO 算法的完整训练流程。

class OnPolicyRunner:
    def __init__(
        self,
        env: VecEnv,                    # 向量化环境
        train_cfg: dict,                # 训练配置字典
        log_dir: Optional[str] = None,  # 日志目录
        device: str = "cuda:0"          # 计算设备
    ):
        ...

    def learn(
        self,
        num_iterations: int,            # 训练迭代次数
        init_at_random_ep_len: bool = False  # 是否从随机 episode 长度开始
    ) -> None:
        ...

    def save(self, path: str) -> None:
        ...

    def load(self, path: str) -> None:
        ...

VecEnv（环境接口）

所有 RSL-RL 兼容环境必须实现的抽象基类：

属性	类型	说明
num_envs	int	并行环境实例数量
num_actions	int	动作空间维度
max_episode_length	int 或 Tensor	每 episode 最大步数
episode_length_buf	Tensor	当前 episode 长度的缓冲区
device	torch.device	环境数据所在的设备

抽象方法：

方法	返回值	说明
get_observations()	tuple[torch.Tensor, dict]	获取当前观测而不推进环境
reset()	tuple[torch.Tensor, dict]	重置所有环境实例到初始状态
step(actions)	tuple[torch.Tensor, torch.Tensor, torch.Tensor, dict]	执行动作并返回 (观测, 奖励, 终止标志, extras)

MLPModel

RSL-RL 的基础神经网络模型：

方法	用途	返回值
forward(obs, masks, hidden_state, stochastic_output)	主前向传播（支持随机输出）	torch.Tensor
get_latent(obs, masks, hidden_state)	提取并归一化观测特征	torch.Tensor
update_normalization(obs)	更新观测归一化的运行统计量	None
get_output_log_prob(outputs)	计算输出动作的对数概率	torch.Tensor
as_jit()	导出为 Torch JIT 格式	_TorchMLPModel
as_onnx(verbose)	导出为 ONNX 格式	_OnnxMLPModel
reset(dones, hidden_state)	为前馈模型兼容的 no-op	None
get_hidden_state()	返回 None（前馈模型无隐藏状态）	None

4.3 extras 字典结构

环境接口的 extras 字典是 RSL-RL 的重要特性：

保留键	说明
observations.critic	传递给 Critic 网络的额外观测（用于非对称 Actor-Critic）
observations.rnd_state	用于 RND 的观测
time_outs	标识哪些环境因时间限制（而非失败）而终止
log	日志和调试指标字典（键以 “/” 开头命名空间化）

4.4 模型架构支持

模型类	适用场景	说明
MLPModel	一维向量观测	基础 MLP 架构，处理 1D 观测组
CNNModel	图像观测	扩展 MLPModel，添加卷积编码器
RNNModel	时序序列观测	扩展 MLPModel，添加 LSTM/GRU 层

5. 算法核心内容

5.1 PPO 训练流程

RSL-RL 的 PPO 训练每轮迭代包含三个主要阶段：

阶段一：数据收集（Collection Phase）

Runner 执行 num_steps_per_env 步环境交互：

1. alg.act(obs) → 从 Actor 网络采样动作
2. env.step(actions) → 推进仿真，返回新观测
3. alg.process_env_step() → 更新归一化器，将转移数据添加到存储
4. 如启用 RND（Random Network Distillation），在此阶段计算内在奖励并添加到外在奖励中

存储的转移数据包括：观测（TensorDict）、动作、动作对数概率、价值估计、奖励（外在 + 内在）、终止标志、隐藏状态（循环策略）。

阶段二：回报计算（Return Computation Phase）

收集完 num_steps_per_env 条转移后，使用 GAE（Generalized Advantage Estimation）计算回报和优势：

• 使用 GAE-λ 结合价值函数估计计算每个时间步的优势
• 将时序差分误差按时间回溯加权，平衡偏差和方差

阶段三：策略更新（Update Phase）

使用 PPO 裁剪目标进行多轮策略优化：

• 将收集的数据划分为多个 mini-batch
• 计算 PPO 裁剪损失、价值损失和熵奖励
• 进行 num_learning_epochs 轮梯度更新

5.2 观测组与模型配置

RSL-RL 的 MLPModel 使用 obs_groups 配置来选择处理哪些观测组件，实现 Actor 和 Critic 使用不同信息量：

obs_groups = {
    "actor": ["proprioception", "commands"],           # Actor 仅使用本体感知和指令
    "critic": ["proprioception", "commands", "privileged_state"],  # Critic 可使用特权信息
    "student": ["proprioception", "commands"]          # 学生策略（蒸馏场景）
}

obs_set 参数在初始化时确定使用哪组观测（例如 "actor"、"critic"、"student"）。

5.3 非对称 Actor-Critic

这是 RSL-RL 在机器人领域的重要特性：

• Actor（演员） 只能访问机器人自身传感器可获得的真实观测（本体感知、指令等）
• Critic（评论家） 可以在训练时访问额外的“特权信息”（如地面摩擦力、物体位置等）
• 推理时，仅需 Actor 网络，不需要特权信息
• 通过 extras 字典中的 observations.critic 键向 Critic 传递额外观测

这种设计使得在仿真中训练的策略可以直接部署到真实机器人上（因为推理只需要真实可观测的信息）。

5.4 Random Network Distillation (RND)

RND 是一种探索增强机制，帮助克服稀疏奖励问题：

• 维护一个随机初始化且固定的目标网络和一个可训练的网络
• 内在奖励定义为两个网络预测差异的 MSE
• 新颖状态产生高内在奖励，鼓励探索
• 位于 rsl_rl/modules/rnd.py 中的 RandomNetworkDistillation 类实现

5.5 Student-Teacher 蒸馏框架

RSL-RL 支持知识蒸馏框架：

• 教师策略：使用特权信息训练的大型高性能策略（如访问完整环境状态）
• 学生策略：仅使用有限观测的轻量级策略，可通过行为克隆（BC）学习
• 教师策略通过 DAgger 算法（类似数据聚合）指导学生策略
• 典型应用场景：将大型策略网络的知识迁移到轻量级网络中，用于实际部署

5.6 训练配置关键参数

参数	典型值	说明
num_iterations	1000-5000	训练总迭代次数
num_steps_per_env	24-48	每次迭代每环境的交互步数
num_learning_epochs	5	每批数据上的策略更新轮数
num_mini_batches	4	Mini-batch 划分数量
learning_rate	1e-3	初始学习率
discount_factor	0.99	折扣因子 γ
gae_lambda	0.95	GAE 的 λ 参数
clip_param	0.2	PPO 裁剪参数 ε
entropy_coef	0.01-0.02	熵正则化系数
actor_hidden_dims	[512, 256, 128]	Actor 网络隐藏层维度
critic_hidden_dims	[512, 256, 128]	Critic 网络隐藏层维度
activation	“elu”	激活函数类型

6. 日志与监控

RSL-RL 支持多种日志后端：

日志后端	能力
TensorBoard	可视化训练指标（损失、奖励等）、网络权重分布
WandB	云端实验追踪、团队协作、超参数对比
CSV	简单轻量、易于分析、无需额外依赖

日志后端通过训练配置中的 logger 键选择。

7. 学术引用

@article{schwarke2025rslrl,
  title   = {RSL-RL: A Learning Library for Robotics Research},
  author  = {Schwarke, Clemens and Mittal, Mayank and Rudin, Nikita
             and Hoeller, David and Hutter, Marco},
  journal = {arXiv preprint arXiv:2509.10771},
  year    = {2025}
}

第三部分：SB3 与 RSL-RL 对比总览

适用场景对比

维度	Stable Baselines3	RSL-RL
目标领域	通用强化学习（游戏、控制、调度等）	机器人运动控制（足式、人形机器人）
设计理念	算法完备、接口统一、文档详尽	极简轻量、GPU 原生、快速迭代
算法数量	7+ 核心算法，更多通过 Contrib 扩展	专注于 PPO 和 BC/蒸馏
代码规模	中等，模块化架构	极小，便于深度定制
仿真支持	Gymnasium、Atari、MuJoCo 等	Isaac Lab、Legged Gym、MuJoCo Playground
GPU 加速	支持并行环境（CPU 多进程）	完整 GPU 训练管线，数千并行环境
学习曲线	低，sklearn 风格 API，文档完善	中等，需理解机器人仿真集成
适用人群	RL 初学者、研究者、通用 ML 工程师	机器人研究者、运动控制工程师

何时选用哪个库？

选择 Stable Baselines3 当你需要：

• 快速学习和实验经典 RL 算法
• 多算法对比实验
• 非机器人领域的通用 RL 任务
• 需要丰富文档和社区支持
• 原型验证新算法思路

选择 RSL-RL 当你需要：

• 训练足式机器人或人形机器人的运动策略
• GPU 加速的大规模并行训练（数千环境）
• 使用 Isaac Lab/Isaac Sim 仿真平台
• Teacher-Student 蒸馏策略部署
• 对代码库有深度定制需求
• 非对称 Actor-Critic（特权信息）架构

联合使用

在实际项目中，两个库可以互补使用：

1. SB3 用于离线分析和算法探索阶段
2. RSL-RL 用于大规模机器人策略训练
3. SB3 的通用性结合 RSL-RL 的机器人专用优化形成完整工作流

---

相关链接：

• Stable Baselines3 官方文档：https://stable-baselines3.readthedocs.io
• Stable Baselines3 GitHub：https://github.com/DLR-RM/stable-baselines3
• SB3 Contrib：https://sb3-contrib.readthedocs.io
• RSL-RL GitHub：https://github.com/leggedrobotics/rsl_rl
• RSL-RL PyPI：https://pypi.org/project/rsl-rl-lib/
• Isaac Lab：https://github.com/isaac-sim/IsaacLab