rlpyt

PyTorch中的深度强化学习

新增：扩展文档已在https://rlpyt.readthedocs.io上线（截至2020年1月27日）

查看变更日志

在PyTorch中对常见深度强化学习算法的模块化、优化实现，提供统一的基础架构，支持无模型强化学习的三大主要类别：策略梯度、深度Q学习和Q函数策略梯度。旨在为中小规模研究提供高吞吐量的代码库（大规模指类似OpenAI Dota那样使用数百块GPU的场景）。关键功能包括：

• 以串行模式运行实验（有助于开发过程中的调试，或对于某些实验来说已足够）。
• 完全并行化运行实验，支持并行采样和/或多GPU优化。
  • 多GPU优化采用PyTorch的DistributedDataParallel，可在反向传播的同时进行梯度归约。
• 训练和/或环境采样期间的批量动作选择可使用CPU或GPU。
• 采样与优化可以同步或异步（通过回放缓冲区）。
• volle Unterstützung für rekurrente Agenten.
• Alle Agenten erhalten observation, prev_action, prev_reward.
• Trainingsdaten werden immer mit führenden Indizes als [Time, Batch] organisiert.
• Online- oder Offline-Bewertung von Agentendiagnosen während des Trainings.
• Startprogramme zum Stapeln/Warteschlangen von Experimenten auf gegebenen lokalen Hardware-Ressourcen (z.B. 40 Experimente auf einem 8-GPU-Rechner, jeweils ein Experiment pro GPU).
• Kompatibel mit der OpenAI Gym-Umgebungsschnittstelle.¹
• Modularität für einfache Modifikation / Wiederverwendung bestehender Komponenten.

Implementierte Algorithmen

Policy Gradient A2C, PPO.

Replay Buffers (unterstützt sowohl DQN + QPG) nicht-sequentiell und sequentiell (für rekurrente), n-Schritt-Renditen, uniforme oder priorisierte Wiederholungen, vollständige Beobachtung oder framebasierte Puffer (z.B. für Atari speichert nur einzigartige Frames, um Speicher zu sparen, rekonstruiert mehrere Frames).

Deep Q-Learning DQN + Varianten: Double, Dueling, Categorical (bis Rainbow ohne Noisy Nets), Recurrent (R2D2-Stil). Demnächst: Implicit Quantile Networks?

Q-Function Policy Gradient DDPG, TD3, SAC. Demnächst: Distributional DDPG?

Erste Schritte

Befolgen Sie die unten stehenden Installationsanweisungen und beginnen Sie dann im Beispielordner. Die Beispiel-Skripte sind nach steigendem Schwierigkeitsgrad geordnet.

Für Neueinsteiger in Deep RL kann es sinnvoll sein, sich zunächst anhand anderer Ressourcen mit den Algorithmen vertraut zu machen, beispielsweise dem hervorragenden OpenAI Spinning Up: Dokumentation, Code.

Neue Datenstruktur: namedarraytuple

Rlpyt führt neue Objektklassen namedarraytuple ein, um Sammlungen von NumPy-Arrays / Torch-Tensoren leichter zu organisieren. (siehe rlpyt/utils/collections.py). Ein namedarraytuple ist im Wesentlichen ein namedtuple, das indizierten oder geschnittenen Lese-/Schreibzugriff auf die Struktur ermöglicht. Betrachten wir beispielsweise das Schreiben in ein (ggf. verschachteltes) Wörterbuch mit Arrays:

for k, v in src.items():
  if isinstance(dest[k], dict):
    ..rekursiv..
  dest[k][slice_or_indexes] = v

Dieser Code wird durch Folgendes ersetzt:

dest[slice_or_indexes] = src

Wichtig ist, dass diese Syntax gleich aussieht, ob dest und src einzelne NumPy-Arrays oder beliebig strukturierte Sammlungen von Arrays sind (die Strukturen von dest und src müssen übereinstimmen, oder src kann ein einzelner Wert sein, oder None dient als leeres Platzhalter). Rlpyt verwendet diese Datenstruktur intensiv – verschiedene Teile der Trainingsdaten werden mit denselben führenden Dimensionen organisiert, wodurch der Zugriff auf gewünschte Zeit- oder Batch-Dimensionen erleichtert wird.

Dies soll auch Umgebungen mit multimodalen Beobachtungen oder Aktionen unterstützen. Statt beispielsweise Gelenkwinkel- und Kamerabildbeobachtungen in einen einzigen Beobachtungsvektor zu flachen, kann die Umgebung sie unverändert in einem namedarraytuple für die Beobachtung speichern, und im Forward-Verfahren des Modells können observation.joint und observation.image den entsprechenden Schichten zugeführt werden. Die darunterliegende Infrastruktur bleibt unverändert.

Zukünftige Entwicklungen.

Im Großen und Ganzen ist der Code stabil, könnte sich jedoch noch weiterentwickeln; Änderungen sind möglich. Wir freuen uns über Vorschläge und Beiträge zu weiteren etablierten Algorithmen oder anderen Entwicklungen, die mehr Anwendungsfälle unterstützen – bitte beachten Sie unsere einfachen Beitragsrichtlinien.

Visualisierung

Dieses Paket enthält keine eigene Visualisierung, da die protokollierten Daten mit früheren Versionen kompatibel sind (siehe unten). Für weitere Funktionen verwenden Sie https://github.com/vitchyr/viskit.

Installation

1. Klonen Sie dieses Repository auf Ihren lokalen Rechner.

2. Installieren Sie die für Ihren Rechner geeignete Anaconda-Umgebung.

conda env create -f linux_[cpu|cuda9|cuda10].yml
source activate rlpyt

3. Entweder A) Bearbeiten Sie den PYTHONPATH, um das rlpyt-Verzeichnis einzuschließen, oder B) Installieren Sie es als editierbares Python-Paket

#A
export PYTHONPATH=path_to_rlpyt:$PYTHONPATH

#B
pip install -e .

4. Installieren Sie alle Pakete bzw. Dateien, die für die gewünschten Umgebungen erforderlich sind (z. B. gym, mujoco). Atari ist bereits enthalten.

Hinweis: Für einen schnellen Zugriff fügen Sie Folgendes zu Ihrer ~/.bashrc hinzu (anstelle von source kann auch conda verwendet werden).

alias rlpyt="source activate rlpyt; cd path_to_rlpyt"

Erweiterte Hinweise

Weitere Informationen finden Sie im Whitepaper auf Arxiv. Wenn Sie dieses Repository in Ihrer Arbeit verwenden oder es anderweitig zitieren möchten, verweisen Sie bitte auf das Whitepaper.

代码组织

类的类型分别承担以下职责：

• Runner - 连接 sampler、agent 和 algorithm；管理训练循环及诊断信息的日志记录。
  • Sampler - 管理 agent 与 environment 的交互以收集训练数据，可初始化并行工作进程。
    • Collector - 步进 environments（并可能操作 agent），记录采样数据，隶属于 sampler。
      • Environment - 待学习的任务。
        • 观测空间/动作空间 - environment 向 agent 提供的接口规范。
      • TrajectoryInfo - 按轨迹级别记录的诊断信息。
  • Agent - 在 sampler 中为 environment 选择控制动作；由 algorithm 进行训练。与 model 对接。
    • Model - PyTorch 神经网络模块，隶属于 agent。
    • Distribution - 为随机性 agents 采样动作，并定义用于损失函数的相关公式，隶属于 agent。
  • Algorithm - 利用收集到的样本训练 agent（例如定义损失函数并执行梯度下降）。
    • Optimizer - 训练更新规则（如 Adam），隶属于 algorithm。
    • OptimizationInfo - 按训练批次级别记录的诊断信息。

历史、扩展性、接口

本代码是对 accel_rl 的修订和扩展，该库曾使用 Theano 探索 Atari 环境下的强化学习扩展问题。相关扩展结果已发表于：A. Stooke & P. Abbeel, “加速深度强化学习方法”。若需深入了解包括强化学习在内的深度学习中批量大小的扩展规律，可参阅 S. McCandlish 等人“大规模批量训练的经验模型”。

Accel_rl 受 rllab 的启发（此处的 logger 几乎是直接复制而来）。Rlpyt 沿用了 rllab 的接口规范：智能体输出 action, agent_info，环境输出 observation, reward, done, env_info。通常在 rlpyt 中，智能体的输入/输出为 PyTorch 张量，而环境的输入/输出为 NumPy 数组，两者之间的转换会自动完成。

1. 关于 OpenAI Gym 的兼容性，rlpyt 使用 namedtuple 来表示 env_info，而非 dict。这种方式更便于数据记录，但也要求每个环境步都必须输出相同的字段。为此提供了环境包装器。此外，还提供了将 Gym 空间转换为 rlpyt 空间的包装器，尤其是将 Dict 空间转换为 composite 空间。

致谢

感谢 Pieter Abbeel、Fannie and John Hertz 基金会、NVIDIA、Max Jaderberg、OpenAI 以及 BAIR 社区的支持与指导。也提前感谢所有贡献者！

祝大家强化学习愉快！

rlpyt 快速上手指南

rlpyt 是一个基于 PyTorch 的模块化、高性能深度强化学习（Deep RL）代码库。它支持策略梯度（如 PPO）、深度 Q 学习（如 DQN）以及基于 Q 函数的策略梯度（如 SAC）三大类算法，专为中小规模研究设计，支持多 GPU 并行训练和循环智能体。

环境准备

• 操作系统: Linux (推荐)
• Python 版本: 建议使用 Python 3.6+
• 核心依赖:
  • PyTorch (需匹配 CUDA 版本)
  • Anaconda/Miniconda (用于环境管理)
  • OpenAI Gym (用于环境接口)
  • MuJoCo / Atari (可选，视具体实验需求而定)

注意：本项目主要面向 Linux 环境开发，Windows 用户可能需要额外配置或使用 WSL。

安装步骤

1. 克隆仓库

将 rlpyt 源代码克隆到本地机器：

git clone https://github.com/astooke/rlpyt.git
cd rlpyt

2. 创建 Conda 环境

根据机器的硬件配置（CPU 或特定版本的 CUDA），创建相应的 conda 环境。项目提供了预定义的配置文件：

• CPU 版本:

  conda env create -f linux_cpu.yml
  

• CUDA 9 版本:

  conda env create -f linux_cuda9.yml
  

• CUDA 10 版本:

  conda env create -f linux_cuda10.yml
  

激活环境：

conda activate rlpyt

国内加速提示：如果 conda 下载速度慢，建议先配置清华或中科大镜像源：

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes

3. 安装 rlpyt 包

有两种方式将 rlpyt 添加到 Python 路径中，任选其一即可：

• 方式 A：设置环境变量 (临时或写入 ~/.bashrc)

  export PYTHONPATH=/path/to/rlpyt:$PYTHONPATH
  

• 方式 B：以可编辑模式安装 (推荐)

  pip install -e .
  

4. 安装环境依赖

安装你计划使用的具体强化学习环境包，例如 Gym 或 Atari：

pip install gym[atari]
# 如需使用 Mujoco，请自行安装 mujoco-py 并配置 license

基本使用

rlpyt 的设计理念是高度模块化。最简单的入门方式是运行 examples 文件夹中的示例脚本，这些脚本按复杂度递增排列。

运行示例脚本

假设你已经完成了安装，可以尝试运行一个基础的 PPO 算法在 CartPole 环境上的示例（具体文件名请参考 examples/ 目录）：

# 进入示例目录
cd examples

# 运行一个简单的串行模式实验 (适合调试)
python run_example_ppo_cartpole.py

代码结构简述

在编写自己的实验时，你需要组合以下核心组件：

1. Environment: 定义任务（如 Gym 环境）。
2. Agent & Model: 定义智能体及其神经网络结构。
3. Algorithm: 定义学习算法（如 PPO, DQN），负责计算损失和更新权重。
4. Sampler: 负责与环境交互收集数据，支持并行采样。
5. Runner: 连接上述所有组件，管理训练循环和日志记录。

简单代码逻辑示意

以下是一个概念性的代码组织方式，展示如何启动训练：

from rlpyt.runners.minibatch_rl import MinibatchRl
from rlpyt.samplers.parallel.cpu.sampler import CpuSampler
from rlpyt.algos.pg.ppo import PPO
from rlpyt.agents.pg.gaussian import PgGaussianAgent
from rlpyt.models.pg.mlp_policy import MlpPolicy
from rlpyt.envs.gym import make as gym_make

def build_and_train():
    # 1. 定义算法
    algo = PPO(optim_kwargs=dict(lr=3e-4))
    
    # 2. 定义智能体 (包含模型)
    agent = PgGaussianAgent(Model=MlpPolicy)
    
    # 3. 定义采样器
    sampler = CpuSampler(
        Env=gym_make("CartPole-v1"),
        batch_T=100,
        batch_B=4,
        max_decorrelation_steps=0,
    )
    
    # 4. 定义 Runner 并运行
    runner = MinibatchRl(
        algo=algo,
        agent=agent,
        sampler=sampler,
        n_steps=1e6,
        log_interval_steps=1e5,
    )
    runner.train()

if __name__ == "__main__":
    build_and_train()

更多详细用法、参数配置及高级功能（如多 GPU 训练、循环智能体），请参阅官方扩展文档：https://rlpyt.readthedocs.io。