RLlib二：强化学习（RLlib）的关键概念

在本页中，我们将介绍关键概念，以帮助您了解RLlib的工作原理以及如何使用它。在RLlib中，您可以使用算法来学习如何解决问题环境。算法使用策略来选择动作。给定一个策略，通过环境进行迭代会产生经验样本批次（或轨迹）。"。您还可以自定义RL实验的training_steps。

• Algorithm：算法
• environment：环境，对需要解决问题的模拟
• policies：策略
• rollouts：迭代
• sample batches：样本批次，采样批次
• trajectories：诡计
• training_steps：训练步骤

Environments 环境

在RL中解决问题始于环境。
在RL的最简单定义中：代理与环境交互并获得奖励。
RL中的环境：代理的世界，它是对要解决的问题的模拟。

RLlib环境包括：

1. 所有可能的动作（动作空间） (action space)
2. 环境的完整描述，没有隐藏（状态空间） (state space)
3. 智能体对状态某些部分的观察（观察空间）(observation space)
4. 奖励，这是代理每次操作收到的唯一反馈。reward

策略：试图最大化所有未来奖励的预期总和的模型。
策略是将环境的观察映射到要采取的行动的函数，通常写为π（s（t））->a（t）。
下面是RL迭代学习过程的图。

RL模拟反馈循环针对一个（单代理案例）或多个（多代理案例）策略重复收集数据，根据这些收集的数据训练策略，并确保策略的权重保持同步。因此，收集的环境数据包含观察、采取的行动、获得的奖励和所谓的完成标志，指示代理在模拟中扮演的不同情节的边界。

动作->奖励->下一个状态->训练->重复的模拟迭代，直到结束状态，称为一个迭代 episode ，或者在RLlib中称为 推动 rollout。
定义环境的最常见的API是Farama-Foundation Gymnasium API，我们也在大多数示例中使用它。

算法

算法将所有RLlib组件聚集在一起，使得通过RLlib的Python API及其命令行界面（CLI）可以学习不同的任务。每个算法类Algorithm 都由其各自的算法配置AlgorithmConfig管理，例如要配置PPO实例，您应该使用PPOConfig类。
算法设置其迭代工人和优化器，并收集训练指标。
算法还实现了Tune Trainable API，以便于实验管理。

你有三种与算法交互的方式，你可以使用基本的Python API或命令行来训练它，或者你可以使用Ray Tune来调优你的强化学习算法的超参数。下面的示例显示了与PPO交互的三种等效方式，它在RLlib中实现了PPO算法。

1. 基本用法

# Configure.
from ray.rllib.algorithms.ppo import PPOConfig
config = PPOConfig().environment(env="CartPole-v1").training(train_batch_size=4000)

# Build.
algo = config.build()

# Train.
print(algo.train())

2. 集成Tune

from ray import tune

# Configure.
from ray.rllib.algorithms.ppo import PPOConfig
config = PPOConfig().environment(env="CartPole-v1").training(train_batch_size=4000)

# Train via Ray Tune.
tune.run("PPO", config=config)

3. RLlib命令行

rllib train --run=PPO --env=CartPole-v1 --config='{"train_batch_size": 4000}'

RLlib算法类协调运行部署和优化策略的分布式工作流。算法类利用并行迭代器来实现所需的计算模式。下图显示了同步采样，这些模式中最简单的一种：

RLlib使用Ray参与者将训练从单个核心扩展到集群中的数千个核心。您可以通过更改num_workers参数来配置用于训练的并行性。在此处查看我们的扩展指南以获取更多详细信息。

RL模块

RLModules是特定于框架的神经网络容器。简而言之，它们携带神经网络，并定义如何在强化学习中发生的三个阶段使用它们：探索、推理和训练。

一个最小的RL模块可以包含单个神经网络，并定义其探索、推理和训练逻辑，以仅将观察映射到动作。由于RL模块可以将观察映射到动作，因此它们自然地在RLlib中实现强化学习策略，因此可以在RolloutWorker中找到，其中它们的探索和推理逻辑用于从环境中采样。

RLlib中RL模块经常出现的第二个地方是Learner，其中它们的训练逻辑用于训练神经网络。

RL模块扩展到多智能体案例，其中单个MultiAgentRLModule包含多个RL模块。下图是上述内容在实践中的粗略草图：

RL模块目前处于alpha阶段。它们被包装在遗留的Policy对象中，以便在RolloutWorker中使用以进行采样。这对用户来说应该是透明的，但以下策略评估部分仍然引用这些遗留的Policy对象。

策略评估

给定一个环境和策略，策略评估会产生经验的批次batches of experiences。这是您的经典“环境交互循环”。高效的策略评估可能会很麻烦，尤其是在利用矢量化、RNN或在多代理环境中运行时。RLlib提供了一个RolloutWorker类来管理所有这些，这个类用于大多数RLlib算法。

您可以单独使用迭代工作人员rollout workers来生成批量体验。这可以通过在工作实例上调用worker.sample()或在作为Ray参与者创建的工作实例上并行调用 worker.sample.remote() 来完成（请参阅WorkerSet）。

下面是创建一组迭代工作者并使用它们并行收集经验的示例。轨迹被连接起来，策略学习轨迹批处理，然后我们将策略权重广播给工作者以进行下一轮展开：

# Setup policy and rollout workers.
env = gym.make("CartPole-v1")
policy = CustomPolicy(env.observation_space, env.action_space, {})
workers = WorkerSet(
    policy_class=CustomPolicy,
    env_creator=lambda c: gym.make("CartPole-v1"),
    num_workers=10)

while True:
    # Gather a batch of samples.
    T1 = SampleBatch.concat_samples(
        ray.get([w.sample.remote() for w in workers.remote_workers()]))

    # Improve the policy using the T1 batch.
    policy.learn_on_batch(T1)

    # The local worker acts as a "parameter server" here.
    # We put the weights of its `policy` into the Ray object store once (`ray.put`)...
    weights = ray.put({"default_policy": policy.get_weights()})
    for w in workers.remote_workers():
        # ... so that we can broacast these weights to all rollout-workers once.
        w.set_weights.remote(weights)

样本批次

无论是在单个进程还是大型集群中运行，RLlib中的所有数据都以样本批次的形式交换。

样本批次对轨迹的一个或多个片段进行编码。

通常，RLlib从迭代工作人员那里收集rollout_fragment_length大小的批次，并将这些批次中的一个或多个批次连接成一个大小train_batch_size的批次，作为SGD的输入。

总结时，典型的样本批次如下所示。由于所有值都保存在数组中，因此可以通过网络进行高效编码和传输：

sample_batch = { 'action_logp': np.ndarray((200,), dtype=float32, min=-0.701, max=-0.685, mean=-0.694),
    'actions': np.ndarray((200,), dtype=int64, min=0.0, max=1.0, mean=0.495),
    'dones': np.ndarray((200,), dtype=bool, min=0.0, max=1.0, mean=0.055),
    'infos': np.ndarray((200,), dtype=object, head={}),
    'new_obs': np.ndarray((200, 4), dtype=float32, min=-2.46, max=2.259, mean=0.018),
    'obs': np.ndarray((200, 4), dtype=float32, min=-2.46, max=2.259, mean=0.016),
    'rewards': np.ndarray((200,), dtype=float32, min=1.0, max=1.0, mean=1.0),
    't': np.ndarray((200,), dtype=int64, min=0.0, max=34.0, mean=9.14)
}

在多智能体模式下，为每个单独的策略单独收集样本批次。这些批次一起包装在MultiAgentBatch中，作为各个代理的样本批次的容器。

Training Step Method (Algorithm.training_step())

在阅读本节之前，了解基本的ray核心方法非常重要。
此外，我们利用了SampleBatch（及其更高级的兄弟姐妹：MultiAgentBatch）、RolloutWorker和算法等概念，这些概念可以在本页和推出工作参考文档中阅读。
最后，希望实现自定义算法的开发人员应该熟悉Policy和Model类。

什么是training_step()

算法类的**training_step()**方法定义了位于任何算法核心的可重复执行逻辑。将其视为研究论文中算法伪代码的python实现。您可以使用training_step（）来表达您希望如何协调从环境中收集样本、将这些数据移动到算法的其他部分，以及跨不同分布式组件更新和管理策略权重。

简而言之，如果开发人员想要对现有算法进行自定义更改、从头开始编写自己的算法或从论文中实现一些算法，他们将需要覆盖/修改“training_step”方法。

什么时候用training_step()

算法的training_step（）在以下时候被调用：

1. 当调用算法的train（）方法时（例如，由构建了算法实例的用户“手动”调用）。
2. 当光线调谐运行RLlib算法时。training_step（）将被连续调用，直到满足光线调谐停止条件。

关键子概念

下面，使用VPG（“vanilla策略梯度”）的例子，我们将尝试说明如何使用training_step（）方法在RLlib中实现该算法。
"vanilla策略梯度"算法可以被认为是一系列重复步骤或数据流：

1. 采样（从环境中收集数据）
2. 更新政策（了解行为）
3. 广播更新策略的权重（以确保所有分布式单元再次具有相同的权重）
4. 指标报告（返回上述所有操作中有关性能和运行时的相关统计信息）
   VPG的示例实现如下所示：

def training_step(self) -> ResultDict:
    # 1. Sampling.
    train_batch = synchronous_parallel_sample(
                    worker_set=self.workers,
                    max_env_steps=self.config["train_batch_size"]
                )

    # 2. Updating the Policy.
    train_results = train_one_step(self, train_batch)

    # 3. Synchronize worker weights.
    self.workers.sync_weights()

    # 4. Return results.
    return train_results

请注意，training_step方法与深度学习框架无关。这意味着您不应该在此模块中编写PyTorch或TensorFlow特定代码，从而允许严格分离关注点，并使我们能够对算法的TF和PyTorch版本使用相同的training_step（）方法。DL框架特定代码只能添加到策略（例如在其损失函数中）和模型（例如tf. keras或torch.nn神经网络代码）类中。

看到这里了，给辛苦搬运的博主助力一杯奶茶，或者一个免费的赞吧。