RLlib一：RLlib入门

链接: Getting Started with RLlib

在本指南中，我们将首先引导您使用RLlib CLI运行您的第一个实验，然后更详细地讨论我们的Python API。

在高层次上，RLlib提供了一个包含环境交互策略的算法类。通过算法的接口，您可以训练策略计算操作，或者存储您的算法。在多智能体训练中，算法一次管理多个策略的查询和优化。

Using the Python API - 使用python API

Python API为将RLlib应用于新问题提供了所需的灵活性。例如，如果您希望使用带有RLlib的自定义环境、预处理器或模型，则需要使用此API。

方式一：PPOConfig

下面是一个基本用法的示例。我们首先创建一个PPOConfig并向其添加属性，例如我们想要使用的环境，或者我们想要用于训练的资源。在我们从其配置构建算法后，我们可以对其进行多次训练（这里是10集），并定期保存生成的策略（这里是每5集）。

from ray.rllib.algorithms.ppo import PPOConfig
from ray.tune.logger import pretty_print

algo = (
    PPOConfig()
    .rollouts(num_rollout_workers=1)
    .resources(num_gpus=0)
    .environment(env="CartPole-v1")
    .build()
)

for i in range(10):
    result = algo.train()
    print(pretty_print(result))

    if i % 5 == 0:
        checkpoint_dir = algo.save().checkpoint.path
        print(f"Checkpoint saved in directory {checkpoint_dir}")

方式二：Tune API

所有RLlib算法都与Tune API兼容。这使它们能够轻松地用于Ray Tune的实验。例如，以下代码执行PPO的简单超参数扫描。

import ray
from ray import train, tune

ray.init()

config = PPOConfig().training(lr=tune.grid_search([0.01, 0.001, 0.0001]))

tuner = tune.Tuner(
    "PPO",
    run_config=train.RunConfig(
        stop={"episode_reward_mean": 150},
    ),
    param_space=config,
)

tuner.fit()

Tuner.fit() 返回一个ResultGrid对象，该对象允许进一步分析训练结果并检索经过训练的代理的检查点。

# ``Tuner.fit()`` allows setting a custom log directory (other than ``~/ray-results``)
tuner = ray.tune.Tuner(
    "PPO",
    param_space=config,
    run_config=train.RunConfig(
        stop={"episode_reward_mean": 150},
        checkpoint_config=train.CheckpointConfig(checkpoint_at_end=True),
    ),
)

results = tuner.fit()

# Get the best result based on a particular metric.
best_result = results.get_best_result(metric="episode_reward_mean", mode="max")

# Get the best checkpoint corresponding to the best result.
best_checkpoint = best_result.checkpoint

从检查点加载和恢复经过训练的算法很简单。假设您有一个名为checkpoint_path的本地检查点目录。要加载较新的RLlib检查点（版本>=1.0），请使用以下代码：

from ray.rllib.algorithms.algorithm import Algorithm
algo = Algorithm.from_checkpoint(checkpoint_path)

Computing Actions - 计算动作

从经过训练的代理以编程方式计算动作的最简单方法是使用算法compute_single_action()。
此方法在将观察值传递给代理策略之前对其进行预处理和过滤。
以下是测试一集经过训练的代理的简单示例：

# Note: `gymnasium` (not `gym`) will be **the** API supported by RLlib from Ray 2.3 on.
try:
    import gymnasium as gym

    gymnasium = True
except Exception:
    import gym

    gymnasium = False

from ray.rllib.algorithms.ppo import PPOConfig

env_name = "CartPole-v1"
env = gym.make(env_name)
algo = PPOConfig().environment(env_name).build()

episode_reward = 0
terminated = truncated = False

if gymnasium:
    obs, info = env.reset()
else:
    obs = env.reset()

while not terminated and not truncated:
    action = algo.compute_single_action(obs)
    if gymnasium:
        obs, reward, terminated, truncated, info = env.step(action)
    else:
        obs, reward, terminated, info = env.step(action)
    episode_reward += reward

Accessing Policy State - 读取策略状态

通常需要访问算法的内部状态，例如设置或获取模型权重。

在RLlib算法中，状态会在集群中的多个展开工作人员（Ray参与者）之间复制。但是，您可以通过Algorithm.workers.foreach_worker() 或者Algorithm.workers.foreach_worker_with_index()在调用 train() 之间轻松获取和更新此状态。
这些函数采用与工作人员一起应用的lambda函数作为参数。这些函数以列表的形式返回每个工作人员的值。

您也可以通过Algorithm.get_policy（）或Algorithm.workers.local_worker（）访问算法状态的“master”副本，但请注意，此处的更新可能不会立即反映在您的推出工作人员中（如果您已配置num_rollout_workers>0）。以下是如何访问模型状态的快速示例：

from ray.rllib.algorithms.dqn import DQNConfig

algo = DQNConfig().environment(env="CartPole-v1").build()

# Get weights of the default local policy
algo.get_policy().get_weights()

# Same as above
algo.workers.local_worker().policy_map["default_policy"].get_weights()

# Get list of weights of each worker, including remote replicas
algo.workers.foreach_worker(lambda worker: worker.get_policy().get_weights())

# Same as above, but with index.
algo.workers.foreach_worker_with_id(
    lambda _id, worker: worker.get_policy().get_weights()
)

Accessing Model State - 读取模型状态

与访问策略状态类似，您可能希望获得对正在训练的底层神经网络模型的引用。例如，您可能希望单独对其进行预训练，或者在RLlib之外更新其权重。这可以通过访问策略的模型来完成。

预处理观测以输入到模型中

try:
    import gymnasium as gym

    env = gym.make("ALE/Pong-v5")
    obs, infos = env.reset()
except Exception:
    import gym

    env = gym.make("PongNoFrameskip-v4")
    obs = env.reset()

# RLlib uses preprocessors to implement transforms such as one-hot encoding
# and flattening of tuple and dict observations.
from ray.rllib.models.preprocessors import get_preprocessor

prep = get_preprocessor(env.observation_space)(env.observation_space)
# <ray.rllib.models.preprocessors.GenericPixelPreprocessor object at 0x7fc4d049de80>

# Observations should be preprocessed prior to feeding into a model
obs.shape
# (210, 160, 3)
prep.transform(obs).shape
# (84, 84, 3)

查询策略的动作分布

# Get a reference to the policy 获取对策略的引用
import numpy as np
from ray.rllib.algorithms.dqn import DQNConfig

algo = (
    DQNConfig()
    .environment("CartPole-v1")
    .framework("tf2")
    .rollouts(num_rollout_workers=0)
    .build()
)
# <ray.rllib.algorithms.ppo.PPO object at 0x7fd020186384>

policy = algo.get_policy()
# <ray.rllib.policy.eager_tf_policy.PPOTFPolicy_eager object at 0x7fd020165470>

# Run a forward pass to get model output logits. Note that complex observations
# must be preprocessed as in the above code block.
# 运行前向传递以获取模型输出日志。请注意，复杂的观察
# 必须像上面的代码块一样进行预处理。
logits, _ = policy.model({"obs": np.array([[0.1, 0.2, 0.3, 0.4]])})
# (<tf.Tensor: id=1274, shape=(1, 2), dtype=float32, numpy=...>, [])

# Compute action distribution given logits 给定logits计算动作分布
policy.dist_class
# <class_object 'ray.rllib.models.tf.tf_action_dist.Categorical'>
dist = policy.dist_class(logits, policy.model)
# <ray.rllib.models.tf.tf_action_dist.Categorical object at 0x7fd02301d710>

# Query the distribution for samples, sample logps 查询样本分布，样本日志
dist.sample()
# <tf.Tensor: id=661, shape=(1,), dtype=int64, numpy=..>
dist.logp([1])
# <tf.Tensor: id=1298, shape=(1,), dtype=float32, numpy=...>

# Get the estimated values for the most recent forward pass 获取最新前向传递的估计值
policy.model.value_function()
# <tf.Tensor: id=670, shape=(1,), dtype=float32, numpy=...>

policy.model.base_model.summary()
"""
Model: "model"
_____________________________________________________________________
Layer (type)               Output Shape  Param #  Connected to
=====================================================================
observations (InputLayer)  [(None, 4)]   0
_____________________________________________________________________
fc_1 (Dense)               (None, 256)   1280     observations[0][0]
_____________________________________________________________________
fc_value_1 (Dense)         (None, 256)   1280     observations[0][0]
_____________________________________________________________________
fc_2 (Dense)               (None, 256)   65792    fc_1[0][0]
_____________________________________________________________________
fc_value_2 (Dense)         (None, 256)   65792    fc_value_1[0][0]
_____________________________________________________________________
fc_out (Dense)             (None, 2)     514      fc_2[0][0]
_____________________________________________________________________
value_out (Dense)          (None, 1)     257      fc_value_2[0][0]
=====================================================================
Total params: 134,915
Trainable params: 134,915
Non-trainable params: 0
_____________________________________________________________________
"""

Configuring RLlib Algorithms - 配置RLlib算法

您可以通过使用所谓的算法配置对象以模块化方式配置RLlib算法。本质上，您首先创建一个config = AlgorithmConfig() 对象，然后调用它的方法来设置所需的配置选项。
每个RLlib算法都有自己的配置类，这些配置类继承自AlgorithmConfig。例如，要创建PPO算法，您从一个PPOConfig对象开始，要使用DQN算法，您从一个DQNConfig对象开始，等等。

每种算法都有其特定的设置，但大多数配置选项是共享的。我们在下面讨论常见选项，并参考RLlib算法指南了解算法特定的属性。算法的训练设置主要不同。

下面您可以找到算法配置类的基本签名，以及一些高级使用示例：
RLlib算法配置从给定配置构建RLlib算法。

from ray.rllib.algorithms.ppo import PPOConfig
from ray.rllib.algorithms.callbacks import MemoryTrackingCallbacks
# Construct a generic config object, specifying values within different
# sub-categories, e.g. "training".
#构造一个通用配置对象，指定不同内部的子类别，例如“培训”
config = (PPOConfig().training(gamma=0.9, lr=0.01)
        .environment(env="CartPole-v1")
        .resources(num_gpus=0)
        .rollouts(num_rollout_workers=0)
        .callbacks(MemoryTrackingCallbacks)
    )
# A config object can be used to construct the respective Algorithm.
# 配置对象可用于构建相应的算法。
rllib_algo = config.build()

from ray.rllib.algorithms.ppo import PPOConfig
from ray import tune
# In combination with a tune.grid_search:
#与tune.grid_search结合
config = PPOConfig()
config.training(lr=tune.grid_search([0.01, 0.001]))
# Use `to_dict()` method to get the legacy plain python config dict
# for usage with `tune.Tuner().fit()`.
# 使用 `to_dict()` 方法获取遗留的普通 python 配置字典，以便与 `tune.Tuner().fit()` 一起使用。
tune.Tuner("PPO", param_space=config.to_dict())

由于 RLlib 算法相当复杂，因此它们具有许多配置选项。为了让事情变得更简单，算法的共同属性自然分为以下几类：

training options,训练选项
environment options,环境选项
deep learning framework options,深度学习框架选项
rollout worker options,部署工作选项
evaluation options,评估选项
exploration options,探索选项
options for training with offline data,使用离线数据进行训练的选项
options for training multiple agents,训练多个代理的选项
reporting options,报告选项
options for saving and restoring checkpoints,保存和恢复检查点的选项
debugging options,调试选项
options for adding callbacks to algorithms,添加选项算法回调
Resource options,资源选项
options for experimental features,实验功能选项

指定训练选项

对于单个算法，这可能是最相关的配置组，因为这是所有特定于算法的选项所在的位置。但一个 AlgorithmConfig 用于training 的基本配置实际上非常小：

AlgorithmConfig.training(*, 
gamma: Optional[float] = <ray.rllib.utils.from_config._NotProvided object>, 
lr: Optional[Union[float, List[List[Union[int, float]]]]] = <ray.rllib.utils.from_config._NotProvided object>, 
grad_clip: Optional[float] = <ray.rllib.utils.from_config._NotProvided object>, 
grad_clip_by: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
train_batch_size: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
model: Optional[dict] = <ray.rllib.utils.from_config._NotProvided object>, 
optimizer: Optional[dict] = <ray.rllib.utils.from_config._NotProvided object>, 
max_requests_in_flight_per_sampler_worker: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
learner_class: Optional[Type[Learner]] = <ray.rllib.utils.from_config._NotProvided object>, 
_enable_learner_api: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>
) → AlgorithmConfig

• gamma – 指定马尔可夫决策过程的折扣因子的浮点数。
• lr – 学习率（浮点）或学习率计划，格式为 [[timestep, lr-value], [timestep, lr-value], …] 在计划的情况下，中间时间步将被分配给线性插值学习率值。计划配置的第一个条目必须以时间步长 0 开始，即：[[0，initial_value]，[…]]。
  注意：如果您需要 a) 多个优化器（每个 RLModule），b) 不是 Adam 的优化器类型，c) 学习率计划不是如上所述的线性插值、分段计划，或 d) 指定 c’如果优化器的参数不是学习率（例如 Adam 的 epsilon），那么您必须重写 Learner 的 configure_optimizer_for_module() 方法并自行处理 lr 调度。
• grad_clip-如果无，则不应用梯度裁剪。否则，根据grad_clip_by的设置，grad_clip的（浮点）值将具有以下效果：如果grad_clip_by=value：将在区间[-grad_clip，+‘grad_clip’]内单独裁剪所有计算的梯度。如果grad_clip_by=范数，将单独计算每个权重/偏置梯度张量的L2范数，然后裁剪所有梯度，使得这些L2范数不超过grad_clip。张量的L2范数通过： sqrt（SUM（w0^2，w12，…，wn^{2））计算，其中w[i]是张量的元素（无论这个张量的形状是什么）。如果grad_clip_by=global_norm，将单独计算每个权重/偏置梯度张量的L2范数的平方，在所有给定的梯度张量（例如要更新的整个模块）上求和所有这些平方的L2范数，平方根该总和，然后剪辑所有梯度，使得该全局L2范数不超过给定值。张量列表（例如W和V）上的全局L2范数通过以下方式计算：sqrt[SUM（w0}2， w1^2，…，wn2）+SUM（v0^2，v12，…，vm^2）]，其中w[i]和v[j]是张量W和V的元素（无论这些张量的形状如何）。
• grad_clip_by-请参阅grad_clip此设置对渐变裁剪的影响。允许的值是值、范数和global_norm。
• train_batch_size – 训练批量大小（如果适用）
• model-传递到策略模型的参数。有关可用模型选项的完整列表，请参阅模型/catalog.py。TODO：提供ModelConfig对象而不是字典。
• optimizer - 传递给策略优化器的参数。_enable_new_api_stack=True时不使用此设置。
• max_requests_in_flight_per_sampler_worker - 对每个采样工作人员的最大机上请求数。有关更多详细信息，请参阅FaultTolerantActorManager类。在运行大样本批次实验时，调整这些值很重要，其中存在对象存储可能会填满的风险，导致对象溢出到磁盘。这可能会导致任何异步请求变得非常慢，使您的实验运行也很慢。您可以在实验期间通过调用头节点上的射线内存来检查对象存储，并使用射线仪表板。如果您看到对象存储正在填满，请关闭飞行中的远程请求数量，或者在时间步长实验中启用压缩。
• Returns：此更新的算法配置对象。

指定环境

AlgorithmConfig.environment(
env: Optional[Union[str, Any]] = <ray.rllib.utils.from_config._NotProvided object>, 
*, 
env_config: Optional[dict] = <ray.rllib.utils.from_config._NotProvided object>, 
observation_space: Optional[gymnasium.spaces.Space] = <ray.rllib.utils.from_config._NotProvided object>, 
action_space: Optional[gymnasium.spaces.Space] = <ray.rllib.utils.from_config._NotProvided object>, 
env_task_fn: Optional[Callable[[dict, Any, ray.rllib.env.env_context.EnvContext], Any]] = <ray.rllib.utils.from_config._NotProvided object>, 
render_env: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
clip_rewards: Optional[Union[bool, float]] = <ray.rllib.utils.from_config._NotProvided object>, normalize_actions: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
clip_actions: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, disable_env_checking: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
is_atari: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, auto_wrap_old_gym_envs: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
action_mask_key: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>
) → ray.rllib.algorithms.algorithm_config.AlgorithmConfig

• env : 环境说明符。这可以是通过tune.register_env（[name]， lambdaenv_ctx：[env object]）注册的环境，也可以是RLlib支持的类型的字符串说明符。在后一种情况下，RLlib将尝试将说明符解释为Farama-Foundation健身房环境、PyBullet环境、ViZDoomGym环境或Env类的完全限定类路径，例如“ray.rllib.example.env.random_env.随机环境”。
• env_config – 作为 EnvContext 对象传递给 env 创建者的参数字典（这是一个字典加上属性：num_rollout_workers、worker_index、vector_index 和 remote）。
• Observation_space – 该算法的策略的观察空间。
• action_space – 该算法的策略的操作空间。
• env_task_fn – 一个可调用函数，将最后一个训练结果、基本环境和环境上下文作为参数，并返回一个新任务来设置环境。 env 必须是 TaskSettableEnv 子类才能正常工作。有关示例，请参阅 Examples/curriculum_learning.py。
• render_env – 如果为 True，则尝试在本地工作线程或工作线程 1 上渲染环境（如果 num_rollout_workers > 0）。对于矢量化环境，这通常意味着仅渲染第一个子环境。为了使其工作，您的环境必须实现 render() 方法，该方法：a) 处理窗口生成并渲染本身（返回 True）或 b) 返回形状为 [height x width x 3 ( RGB）]。
• clip_rewards – 是否在策略后处理期间剪辑奖励。无（默认）：仅适用于 Atari 的剪辑 (r=sign®)。 True：r=sign®：固定奖励 -1.0、1.0 或 0.0。错误：切勿剪辑。 [浮点值]：在-值和+值处剪辑。 Tuple[value1, value2]：在 value1 和 value2 处剪辑。
• normalize_actions – 如果为 True，RLlib 将完全在标准化动作空间内学习（0.0 以小 stddev 为中心；仅影响 Box 组件）。在将动作发送回环境之前，我们会将动作（以及剪辑，以防万一）压缩到环境动作空间的边界。
• clip_actions – 如果为 True，RLlib 将根据环境的边界剪辑操作，然后将它们发送回环境。 TODO: (sven) 这个选项应该被弃用并始终为 False。
• disable_env_checking – 如果为 True，则禁用环境预检查模块。
• is_atari – 此配置可用于显式指定环境是否为 Atari 环境。如果未指定，RLlib 将尝试自动检测这一点。
• auto_wrap_old_gym_envs – 是否自动包装旧的gym环境（使用0.24之前的gym API，例如reset()返回单个obs并且没有信息字典）。如果为True，RLlib将自动使用gym提供的兼容性包装器（gym.wrappers.EnvCompatibility）包装给定的gym环境类。如果为 False，RLlib 将生成一个描述性错误，说明要执行哪些步骤来升级到gymnasium（或将此标志切换为 True）。
• Returns：此更新的 AlgorithmConfig 对象。

指定框架选项

AlgorithmConfig.framework(
framework: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
*, 
eager_tracing: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
eager_max_retraces: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
tf_session_args: Optional[Dict[str, Any]] = <ray.rllib.utils.from_config._NotProvided object>, 
local_tf_session_args: Optional[Dict[str, Any]] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_learner: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_learner_what_to_compile: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_learner_dynamo_mode: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_learner_dynamo_backend: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_worker: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_worker_dynamo_backend: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
torch_compile_worker_dynamo_mode: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>
) → ray.rllib.algorithms.algorithm_config.AlgorithmConfig

• framework – torch: PyTorch; tf2: TensorFlow 2.x (如果eager_tracing=True，则急于执行或跟踪); tf: TensorFlow (静态图);
• eager_tracing – 在 eager 模式下启用跟踪。这极大地提高了性能（加速约 2 倍），但使调试变得稍微困难​​，因为 Python 代码在最初的 eager pass 之后不会被评估。仅当框架 = tf2 时才可能。
• eager_max_retraces – 引发运行时错误之前 tf.function 重新跟踪的最大次数。这是为了防止对 _eager_traced 策略内的方法进行不被注意的回溯，这可能会使执行速度减慢 4 倍，而用户不会注意到导致速度减慢的根本原因是什么。仅对于framework=tf2 是必需的。设置为 None 以忽略重新跟踪计数并且从不抛出错误。
• tf_session_args – 默认情况下将 TF 配置为单进程操作。
• torch_compile_learner-如果为True，则编译学习器上的TorchRLModule上的FORWARD_TRAIN方法。如果未指定，则默认为在学习者上编译前向训练。
• torch_compile_learner_what_to_compile – TorchCompileWhatToCompile 模式指定如果 torch_compile_learner 为 True 则在学习器端编译什么。有关其使用的详细信息和建议，请参阅 TorchCompileWhatToCompile。
• torch_compile_learner_dynamo_backend-torch 计算器模式使用的学习者。
• torch_compile_worker – 如果为 True，则编译工作人员上 TorchRLModule 的前向探索和推理方法。如果未指定，默认情况下不会在工作线程上编译前向方法，因为回溯可能会很昂贵。
• torch_compile_worker_dynamo_backend – 用于工作人员的 torch 计算器后端。
• torch_compile_worker_dynamo_mode – 用于工作人员的 torch 计算器模式。
• Returns - 返回此更新的 AlgorithmConfig 对象

Torch Dynamo 的作用是从 PyTorch 应用中抓取计算图

指定 Rollout Worker

AlgorithmConfig.rollouts(*, 
env_runner_cls: Optional[type] = <ray.rllib.utils.from_config._NotProvided object>, 
num_rollout_workers: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
num_envs_per_worker: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
create_env_on_local_worker: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
sample_collector: Optional[Type[ray.rllib.evaluation.collectors.sample_collector.SampleCollector]] = <ray.rllib.utils.from_config._NotProvided object>, 
sample_async: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
enable_connectors: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
use_worker_filter_stats: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
update_worker_filter_stats: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
rollout_fragment_length: Optional[Union[int, str]] = <ray.rllib.utils.from_config._NotProvided object>, 
batch_mode: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
remote_worker_envs: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
remote_env_batch_wait_ms: Optional[float] = <ray.rllib.utils.from_config._NotProvided object>, 
validate_workers_after_construction: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
preprocessor_pref: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
observation_filter: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
compress_observations: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
enable_tf1_exec_eagerly: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
sampler_perf_stats_ema_coef: Optional[float] = <ray.rllib.utils.from_config._NotProvided object>, 
ignore_worker_failures=-1, recreate_failed_workers=-1, 
restart_failed_sub_environments=-1, 
num_consecutive_worker_failures_tolerance=-1, 
worker_health_probe_timeout_s=-1, worker_restore_timeout_s=-1, synchronize_filter=-1
) → ray.rllib.algorithms.algorithm_config.AlgorithmConfig

• env_runner_cls – 用于环境部署（数据收集）的 EnvRunner 类。
• num_rollout_workers – 为并行采样创建的 rollout 工作参与者的数量。将其设置为 0 将强制在本地工作线程（驱动程序进程或使用 Tune 时算法的参与者）中完成部署。
• num_envs_per_worker – 每个工作线程进行向量评估的环境数量。这支持模型推理批处理，从而可以提高推理瓶颈工作负载的性能。
• sample_collector – SampleCollector 类，用于收集和检索环境、模型和采样器数据。重写 SampleCollector 基类以实现您自己的收集/缓冲/检索逻辑。
• create_env_on_local_worker – 当 num_rollout_workers > 0 时，驱动程序 (local_worker;worker-idx=0) 不需要环境。这是因为它不必采样（由remote_workers完成；worker_indices > 0）也不必评估（由评估工作者完成；见下文）。
• sample_async – 使用后台线程进行采样（稍微偏离策略，通常不建议打开，除非您的环境特别需要它）。
• enable_connectors – 使用基于连接器的环境运行器，以便所有 obs 的预处理和操作的后处理都在代理和操作连接器中完成。
• use_worker_filter_stats – 是否使用WorkerSet中的worker来更新中央过滤器（由本地worker持有）。如果为 False，则不会使用并丢弃来自工作人员的统计数据。
• update_worker_filter_stats – 是否将过滤器更新从中央过滤器（由本地工作人员保存）推送到远程工作人员的过滤器。将其设置为 True 在评估配置中可能很有用，以便禁用评估轨迹来同步中央过滤器（用于训练）。
• rollout_fragment_length – 在推出期间将剧集分为多个步骤的片段。这种大小的轨迹是从 rollout 工作线程中收集的，并组合成更大的一批 train_batch_size 来进行学习。例如，给定 rollout_fragment_length=100 和 train_batch_size=1000： 1. RLlib 从 rollout 工作线程收集 10 个片段，每个片段有 100 个步骤。 2. 这些片段被连接起来，我们执行一个 SGD 纪元。当每个工作人员使用多个环境时，片段大小将乘以 num_envs_per_worker。这是因为我们并行地从多个环境收集步骤。例如，如果 num_envs_per_worker=5，则部署工作人员将以 5*100 = 500 个步骤的块形式返回经验。这里的数据流可能因算法而异。例如，PPO 进一步将训练批次划分为多个小批次，以实现多轮 SGD。设置为“auto”以使 RLlib 计算精确的 rollout_fragment_length 以匹配给定的批量大小。
• batch_mode – 如何使用 EnvRunner 构建单独的批次。来自分布式 EnvRunner 的批次通常会连接起来形成训练批次。请注意，下面的“步骤”可能意味着不同的事物（环境步骤或代理步骤），并且取决于 count_steps_by 设置，可通过 AlgorithmConfig.multi_agent(count_steps_by=…) 进行调整： 1) “truncate_episodes”：每次调用 EnvRunner.sample () 将返回最多 rollout_fragment_length * num_envs_per_worker 大小的批次。如果后处理不更改批量大小，则批量的大小将恰好为 rollout_fragment_length * num_envs 。为了满足此大小要求，剧集可能会被截断。此模式保证均匀大小的批次，但会增加方差，因为现在必须在截断边界估计未来回报。 2) “complete_episodes”：每次调用 EnvRunner.sample() 将返回一批大小至少为 rollout_fragment_length * num_envs_per_worker 的批次。剧集不会被截断，但多个剧集可能会打包在一批中以满足（最小）批量大小。请注意，当 num_envs_per_worker > 1 时，情节步骤将被缓冲，直到情节完成，因此批次可能包含大量非策略数据。
• remote_worker_envs – 如果使用 num_envs_per_worker > 1，是否在远程进程中而不是在同一工作进程中创建这些新环境。这会增加开销，但如果您的环境需要很长时间来执行/重置（例如，对于星际争霸），则可能是有意义的。请谨慎使用；间接费用很大。
• Remote_env_batch_wait_ms – 轮询环境时远程工作人员等待的超时时间。 0（当至少一个环境准备就绪时继续）是一个合理的默认值，但可以通过测量环境步骤/重置和模型推理性能来获得最佳值。
• validate_workers_after_construction – 是否验证每个创建的远程工作人员在构建过程后是否健康。
• preprocessor_pref – 默认情况下是否使用“rllib”或“deepmind”预处理器。设置为 None 表示不使用预处理器。在这种情况下，模型将必须处理来自环境的可能复杂的观察结果。
• **observation_filter ** – 按元素观察过滤器，“NoFilter”或“MeanStdFilter”。
• compress_observations – 是否 LZ4 压缩在推出期间收集的 SampleBatches 中的各个观测值。
• enable_tf1_exec_eagerly – 显式告诉 rollout Worker 启用 TF eager 执行。例如，当框架是“torch”，但需要恢复 TF2 策略以进行评估或基于联盟的目的时，这非常有用。
• Sampler_perf_stats_ema_coef – 如果指定，性能统计数据以 EMA 为单位。这是新数据点对平均值的贡献程度的系数。默认值为“无”，它使用简单的全局平均值。 EMA更新规则为：updated = (1 - ema_coef) * old + ema_coef * new
• Returns - 此更新的 AlgorithmConfig 对象。

指定评估选项

AlgorithmConfig.evaluation(*, 
evaluation_interval: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_duration: Optional[Union[int, str]] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_duration_unit: Optional[str] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_sample_timeout_s: Optional[float] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_parallel_to_training: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_config: Optional[Union[ray.rllib.algorithms.algorithm_config.AlgorithmConfig, dict]] = <ray.rllib.utils.from_config._NotProvided object>, 
off_policy_estimation_methods: Optional[Dict] = <ray.rllib.utils.from_config._NotProvided object>, 
ope_split_batch_by_episode: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
evaluation_num_workers: Optional[int] = <ray.rllib.utils.from_config._NotProvided object>, 
custom_evaluation_function: Optional[Callable] = <ray.rllib.utils.from_config._NotProvided object>, 
always_attach_evaluation_results: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
enable_async_evaluation: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, evaluation_num_episodes=-1
) → ray.rllib.algorithms.algorithm_config.AlgorithmConfig

• evaluation_interval – 在每个evaluation_interval训练迭代中进行评估。评估统计数据将在“评估”指标键下报告。请注意，对于 Ape-X 指标，仅报告最低 epsilon 工作人员（最少随机工作人员）。设置为 None（或 0）表示不进行评估。
• evaluation_duration – 每个evaluation_interval运行评估的持续时间。持续时间的单位可以通过evaluation_duration_unit设置为“episodes”（默认）或“timesteps”。如果使用多个评估工作人员 (evaluation_num_workers > 1)，要运行的负载将在这些工作人员之间分配。如果值为“auto”： - 对于valuation_parallel_to_training=True：将运行适合（并行）训练步骤的尽可能多的episode/timesteps。 - 对于valuation_parallel_to_training=False：错误。
• evaluation_duration_unit – 用于计算评估持续时间的单位。 “episodes”（默认）或“timesteps”。
• evaluation_sample_timeout_s – ray.get 调用远程评估工作程序的sample() 方法的超时（以秒为单位）。在此之后，用户将收到警告和有关如何解决问题的说明。这可以是为了确保剧集结束、增加超时或切换到 evaluation_duration_unit=timesteps。
• evaluation_parallel_to_training – 是否使用线程与 Algorithm.train() 调用并行运行评估。默认=假。例如。 evaluation_interval=2 -> 对于每个其他训练迭代，Algorithm.train() 和 Algorithm.evaluate() 调用并行运行。注意：这是实验性的。可能的陷阱可能是评估循环开始时权重同步的竞争条件。
• evaluation_config – 典型用法是将额外的参数传递给评估环境创建者，并通过计算确定性操作来禁用探索。重要提示：策略梯度算法能够找到最佳策略，即使这是随机策略。此处设置“explore=False”将导致评估工作人员不使用此最优策略！
• off_policy_estimation_methods – 指定如何评估当前策略以及任何可选配置参数。这仅在阅读离线体验时有效（“输入”不是“采样器”）。可用键： {ope_method_name: {“type”: ope_type, …}} 其中 ope_method_name 是用户定义的字符串，用于保存 OPE 结果，ope_type 可以是 OffPolicyEstimator 的任何子类，例如ray.rllib.offline.estimators.is::ImportanceSampling 或您自己的自定义子类，或子类的完整类路径。您还可以添加其他配置参数以传递给字典中的 OffPolicyEstimator，例如{“qreg_dr”：{“类型”：DoublyRobust，“q_model_type”：“qreg”，“k”：5}}
• ope_split_batch_by_episode – 是否使用SampleBatch.split_by_episode()将输入批次分割为多个剧集以在估计ope指标之前。在bandits的情况下，你应该将此设置为False以提高ope评估速度。在bandits的情况下，不分割剧集也是可以的，因为每个记录已经是一个时间步长了。默认值为True
• evaluation_num_workers – 用于评估的并行工作线程数。请注意，默认设置为零，这意味着评估将在算法进程中运行（仅当评估间隔不为 None 时）。如果增加此值，则会增加算法的 Ray 资源使用量，因为评估工作线程是与部署工作线程（用于对训练数据进行采样）分开创建的。
• custom_evaluation_function – 自定义评估方法。这必须是签名的函数（algo：算法，eval_workers：WorkerSet）->指标：dict。请参阅 Algorithm.evaluate() 方法以查看默认实现。该算法保证所有 eval 工作线程在调用此函数之前都具有最新的策略状态。
• always_attach_evaluation_results – 确保最新的可用评估结果始终附加到步骤结果字典中。如果 Tune 或其他一些元控制器需要始终访问评估指标，这可能很有用。
• enable_async_evaluation – 如果为 True，则为评估工作人员使用 AsyncRequestsManager，并使用此管理器向评估工作人员发送sample() 请求。这样，算法对于长时间运行的事件和/或失败（和重新启动）的工作程序变得更加稳健。
• Returns - 此更新的 AlgorithmConfig 对象。

指定探索选项

AlgorithmConfig.exploration(*, 
explore: Optional[bool] = <ray.rllib.utils.from_config._NotProvided object>, 
exploration_config: Optional[dict] = <ray.rllib.utils.from_config._NotProvided object>)
 → ray.rllib.algorithms.algorithm_config.AlgorithmConfig

• explore – 默认探索行为，当且仅当explore=None 被传递到compute_action(s) 中时。设置为 False 表示没有探索行为（例如，用于评估）。
• explore_config – 指定 Exploration 对象配置的字典。
• Returns - 返回此更新的 AlgorithmConfig 对象。

RLlib 扩展指南

以下是使用 RLlib 进行扩展训练的一些经验法则。

1. 如果环境很慢并且无法复制（例如，因为它需要与物理系统交互），那么您应该使用样本高效的离策略算法，例如 DQN 或 SAC。对于单进程操作，这些算法默认为 num_workers: 0。如果您想使用 GPU，请确保设置 num_gpus: 1。还可以考虑使用离线数据 API 进行批量 RL 训练。
2. 如果环境速度快且模型较小（大多数 RL 模型都是如此），请使用省时的算法，例如 PPO 或 IMPALA。这些可以通过增加 num_workers 来添加 rollout 工作人员来扩展。启用向量化进行推理也可能有意义。如果您想使用 GPU，请确保设置 num_gpus: 1。如果学习器成为瓶颈，可以通过设置 num_gpus > 1来使用多个 GPU 进行学习
3. 如果模型是计算密集型的（例如，大型深度残差网络）并且推理是瓶颈，请考虑通过设置 num_gpus_per_worker: 1 来为工作线程分配 GPU。如果您只有一个 GPU，请考虑 num_workers: 0 以使用学习器 GPU推理。为了有效利用 GPU 时间，请使用少量 GPU 工作线程，并为每个工作线程使用大量环境。
4. 最后，如果模型和环境都是计算密集型的，则通过设置remote_worker_envs：True和可选的remote_env_batch_wait_ms来启用具有异步批处理的远程工作环境。这会在 rollout 工作线程中对 GPU 进行批量推理，同时让 env 在单独的 actor 中异步运行，类似于 SEED 架构。应调整工作人员数量和每个工作人员的环境数量，以最大限度地提高 GPU 利用率。

如果您使用大量工作线程 (num_workers >> 10) 并且您观察到工作线程由于某种原因而失败，这通常会中断您的 RLlib 训练运行，请考虑使用配置设置ignore_worker_failures=True、recreate_failed_workers=True 或 restart_failed_sub_environments=True：

• ignore_worker_failures：当设置为 True 时，您的算法不会因单个工作人员错误而崩溃，而是只要至少有一个功能工作人员剩余，就会继续运行。
• recreate_failed_workers：当设置为 True 时，您的算法将尝试用新创建的工作人员替换/重新创建任何失败的工作人员。这样，你的工人数量就永远不会减少，即使其中一些人时不时地失败。
• restart_failed_sub_environments：当设置为 True 并且您的工作人员之一的矢量化子环境之一出现故障时，工作人员将尝试仅重新创建失败的子环境并将新创建的子环境重新集成到您的矢量化环境堆栈中在那名工人身上。

请注意，只有ignore_worker_failures 或recreate_failed_workers 之一可以设置为True（它们是互斥的设置）。但是，您可以将其中的每一个与 restart_failed_sub_environments=True 设置结合起来。使用这些选项将使您的训练运行更加稳定和强大，以应对工作人员本身或环境中偶尔出现的 OOM 或其他类似的“偶尔”错误。

调试 RLlib 实验

Gym监视器

“monitor”： true配置可用于将Gym剧集视频保存到结果目录。例如：

rllib train --env=PongDeterministic-v4 \
    --run=A2C --config '{"num_workers": 2, "monitor": true}'

# videos will be saved in the ~/ray_results/<experiment> dir, for example
openaigym.video.0.31401.video000000.meta.json
openaigym.video.0.31401.video000000.mp4
openaigym.video.0.31403.video000000.meta.json
openaigym.video.0.31403.video000000.mp4

Eager模式

使用build_tf_policy构建的策略（大多数参考算法是）可以通过设置"framework"：“tf2”/“eager_tracing”： true config选项或使用 rllib train --config ‘{“framework”: “tf2”}’ [–trace].。这将告诉RLlib在急切模式下执行模型前向传递、动作分布、损失和统计函数。
Eager 模式使调试变得更加容易，因为您现在可以使用带有断点的逐行调试或 Python print() 来检查中间张量值。但是，除非启用跟踪，否则 eager 可能比图形模式慢。

使用PyTorch

具有已实现TorchPolicy的算法将允许您使用命令行–Framework=torch标志运行rllib训练。在这种情况下，还没有torch版本的算法会报错。

episode痕迹

您可以使用数据输出API保存episode痕迹以进行调试。例如，以下命令将运行PPO，同时将剧集跟踪保存到 /tmp/debug.

rllib train --run=PPO --env=CartPole-v1 \
    --config='{"output": "/tmp/debug", "output_compress_columns": []}'

# episode traces will be saved in /tmp/debug, for example
output-2019-02-23_12-02-03_worker-2_0.json
output-2019-02-23_12-02-04_worker-1_0.json

日志详细程度

您可以通过“log_level”标志控制日志级别。有效值为“DEBUG”、“INFO”、“WARN”（默认值）和“ERROR”。这可用于增加或减少内部日志记录的详细程度。
默认日志级别为WARN。我们强烈建议至少使用INFO级别的日志记录进行开发。
您还可以使用-v和-vv标志。例如，以下两个命令是等效的：

rllib train --env=PongDeterministic-v4 \
    --run=A2C --config '{"num_workers": 2, "log_level": "DEBUG"}'

rllib train --env=PongDeterministic-v4 \
    --run=A2C --config '{"num_workers": 2}' -vv

堆栈跟踪

您可以使用ray stack命令将所有Python工作人员的堆栈跟踪转储到单个节点上。这对于调试意外挂起或性能问题很有用。

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