算法#

注意

Ray 2.40 默认使用 RLlib 的新 API 栈。Ray 团队基本完成了将算法、示例脚本和文档迁移到新代码库的工作。

如果您仍在继续使用旧 API 栈，请参阅新 API 栈迁移指南了解如何迁移的详细信息。

下表概述了 RLlib 中所有可用的算法。请注意，所有算法都支持在 Ray（开源）的单个（GPU）节点上进行多 GPU 训练（）以及在使用 Anyscale 平台时在多节点（GPU）集群上进行多 GPU 训练（）。

算法	单智能体和多智能体	多 GPU（多节点）	动作空间
On-Policy
PPO (近端策略优化)
Off-Policy
DQN/Rainbow (深度 Q 网络)
SAC (软 Actor-Critic)
高吞吐量 On-Policy 和 Off-Policy
APPO (异步近端策略优化)
IMPALA (重要性加权 Actor-Learner 架构)
基于模型的强化学习
DreamerV3
离线 RL 和模仿学习
BC (行为克隆)
MARWIL (单调优势重加权模仿学习)
算法扩展和插件
基于自监督预测的好奇心驱动探索

On-Policy#

近端策略优化 (PPO)#

[论文] [实现]

../_images/ppo-architecture.svg — **PPO 架构：**在一个训练迭代中，PPO 执行三个主要步骤：1. 采样一组 episode 或 episode 片段 1. 将它们转换为训练批次，并使用 clipped objective 和多次 SGD 遍历该批次来更新模型 1. 将 Learner 的权重同步回 EnvRunner。PPO 在两个方向上都能扩展，支持多个 EnvRunner 进行样本收集，以及多个基于 GPU 或 CPU 的 Learner 更新模型。#

调优示例：Pong-v5、CartPole-v1、Pendulum-v1。

PPO 特有配置（另请参阅通用算法设置）

class ray.rllib.algorithms.ppo.ppo.PPOConfig(algo_class=None)[source]#

定义一个配置类，可以从中构建 PPO 算法。

from ray.rllib.algorithms.ppo import PPOConfig

config = PPOConfig()
config.environment("CartPole-v1")
config.env_runners(num_env_runners=1)
config.training(
    gamma=0.9, lr=0.01, kl_coeff=0.3, train_batch_size_per_learner=256
)

# Build a Algorithm object from the config and run 1 training iteration.
algo = config.build()
algo.train()

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

config = (
    PPOConfig()
    # Set the config object's env.
    .environment(env="CartPole-v1")
    # Update the config object's training parameters.
    .training(
        lr=0.001, clip_param=0.2
    )
)

tune.Tuner(
    "PPO",
    run_config=tune.RunConfig(stop={"training_iteration": 1}),
    param_space=config,
).fit()

training(*, use_critic: bool | None = <ray.rllib.utils.from_config._NotProvided object>, use_gae: bool | None = <ray.rllib.utils.from_config._NotProvided object>, lambda_: float | None = <ray.rllib.utils.from_config._NotProvided object>, use_kl_loss: bool | None = <ray.rllib.utils.from_config._NotProvided object>, kl_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, kl_target: float | None = <ray.rllib.utils.from_config._NotProvided object>, vf_loss_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, entropy_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, entropy_coeff_schedule: ~typing.List[~typing.List[int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, clip_param: float | None = <ray.rllib.utils.from_config._NotProvided object>, vf_clip_param: float | None = <ray.rllib.utils.from_config._NotProvided object>, grad_clip: float | None = <ray.rllib.utils.from_config._NotProvided object>, lr_schedule: ~typing.List[~typing.List[int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, vf_share_layers=-1, **kwargs) → PPOConfig[source]#

设置与训练相关的配置。

参数：

use_critic – 是否使用 critic 作为基线（否则不使用价值基线；使用 GAE 时必需）。
use_gae – 如果为 True，则使用价值函数和广义优势估计器 (GAE)，详见 https://arxiv.org/pdf/1506.02438.pdf。
lambda – 广义优势估计 (GAE) 的 lambda 参数。定义了在多个时间步长上实际测量奖励与价值函数估计之间使用的指数权重。具体来说，lambda_ 平衡了短期、低方差估计与长期、高方差回报。一个 lambda_ 为 0.0 使 GAE 仅依赖于即时奖励（以及此后的 vf 预测，减少方差，但增加偏差），而一个 lambda_ 为 1.0 仅包含给定 episode 或 episode 块截断点处的 vf 预测（减少偏差，但增加方差）。
use_kl_loss – 是否在损失函数中使用 KL 项。
kl_coeff – KL 散度的初始系数。
kl_target – KL 散度的目标值。
vf_loss_coeff – 价值函数损失的系数。重要提示：如果在模型的 config 中设置 vf_share_layers=True，则必须对此进行调优。
entropy_coeff – 熵系数（浮点数）或熵系数调度，格式为 [[时间步, coeff 值], [时间步, coeff 值], …]。如果是调度，则中间的时间步长将被赋予线性插值的系数数值。调度配置的第一个条目必须以时间步长 0 开头，例如：[[0, initial_value], […]]。
clip_param – PPO 的 clip 参数。
vf_clip_param – 价值函数的 clip 参数。请注意，此对此取决于奖励的规模。如果您的预期 V 值较大，请增加此值。
grad_clip – 如果指定，则将梯度的全局范数裁剪到此值。

返回：

此更新后的 AlgorithmConfig 对象。

Off-Policy#

深度 Q 网络 (DQN, Rainbow, Parametric DQN)#

[论文] [实现]。

../_images/dqn-architecture.svg — **DQN 架构：**DQN 使用回放缓冲区临时存储 RLlib 从环境中收集的 episode 样本。在不同的训练迭代中，这些 episode 和 episode 片段会从缓冲区中重新采样并重新用于更新模型，最终在缓冲区达到容量且新样本不断进入时被丢弃 (FIFO)。这种训练数据的重用使得 DQN 的样本效率很高且是离策略的。DQN 在两个方向上都能扩展，支持多个 EnvRunner 进行样本收集，以及多个基于 GPU 或 CPU 的 Learner 更新模型。#

Rainbow 中评估的所有 DQN 改进都可用，但并非所有都默认启用。另请参阅如何在 DQN 中使用 parametric-actions。

调优示例：PongDeterministic-v4、Rainbow 配置、{BeamRider,Breakout,Qbert,SpaceInvaders}NoFrameskip-v4、带 Dueling 和 Double-Q、带 Distributional DQN。

提示

对于完整的 rainbow 设置，请对默认 DQN config 进行以下更改： "n_step": [1 到 10 之间], "noisy": True, "num_atoms": [大于 1], "v_min": -10.0, "v_max": 10.0 （根据您预期的回报范围设置 v_min 和 v_max）。

DQN 特有配置（另请参阅通用算法设置）

class ray.rllib.algorithms.dqn.dqn.DQNConfig(algo_class=None)[source]#

定义一个配置类，可以从中构建 DQN 算法。

from ray.rllib.algorithms.dqn.dqn import DQNConfig

config = (
    DQNConfig()
    .environment("CartPole-v1")
    .training(replay_buffer_config={
        "type": "PrioritizedEpisodeReplayBuffer",
        "capacity": 60000,
        "alpha": 0.5,
        "beta": 0.5,
    })
    .env_runners(num_env_runners=1)
)
algo = config.build()
algo.train()
algo.stop()

from ray.rllib.algorithms.dqn.dqn import DQNConfig
from ray import tune

config = (
    DQNConfig()
    .environment("CartPole-v1")
    .training(
        num_atoms=tune.grid_search([1,])
    )
)
tune.Tuner(
    "DQN",
    run_config=tune.RunConfig(stop={"training_iteration":1}),
    param_space=config,
).fit()

training(*, target_network_update_freq: int | None = <ray.rllib.utils.from_config._NotProvided object>, replay_buffer_config: dict | None = <ray.rllib.utils.from_config._NotProvided object>, store_buffer_in_checkpoints: bool | None = <ray.rllib.utils.from_config._NotProvided object>, lr_schedule: ~typing.List[~typing.List[int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, epsilon: float | ~typing.List[~typing.List[int | float]] | ~typing.List[~typing.Tuple[int, int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, adam_epsilon: float | None = <ray.rllib.utils.from_config._NotProvided object>, grad_clip: int | None = <ray.rllib.utils.from_config._NotProvided object>, num_steps_sampled_before_learning_starts: int | None = <ray.rllib.utils.from_config._NotProvided object>, tau: float | None = <ray.rllib.utils.from_config._NotProvided object>, num_atoms: int | None = <ray.rllib.utils.from_config._NotProvided object>, v_min: float | None = <ray.rllib.utils.from_config._NotProvided object>, v_max: float | None = <ray.rllib.utils.from_config._NotProvided object>, noisy: bool | None = <ray.rllib.utils.from_config._NotProvided object>, sigma0: float | None = <ray.rllib.utils.from_config._NotProvided object>, dueling: bool | None = <ray.rllib.utils.from_config._NotProvided object>, hiddens: int | None = <ray.rllib.utils.from_config._NotProvided object>, double_q: bool | None = <ray.rllib.utils.from_config._NotProvided object>, n_step: int | ~typing.Tuple[int, int] | None = <ray.rllib.utils.from_config._NotProvided object>, before_learn_on_batch: ~typing.Callable[[~typing.Type[~ray.rllib.policy.sample_batch.MultiAgentBatch], ~typing.List[~typing.Type[~ray.rllib.policy.policy.Policy]], ~typing.Type[int]], ~typing.Type[~ray.rllib.policy.sample_batch.MultiAgentBatch]] = <ray.rllib.utils.from_config._NotProvided object>, training_intensity: float | None = <ray.rllib.utils.from_config._NotProvided object>, td_error_loss_fn: str | None = <ray.rllib.utils.from_config._NotProvided object>, categorical_distribution_temperature: float | None = <ray.rllib.utils.from_config._NotProvided object>, burn_in_len: int | None = <ray.rllib.utils.from_config._NotProvided object>, **kwargs) → DQNConfig[source]#

设置与训练相关的配置。

参数：

target_network_update_freq – 每隔 target_network_update_freq 个样本步长更新目标网络。
replay_buffer_config – 回放缓冲区配置。示例： { “_enable_replay_buffer_api”: True, “type”: “MultiAgentReplayBuffer”, “capacity”: 50000, “replay_sequence_length”: 1, } - 或 - { “_enable_replay_buffer_api”: True, “type”: “MultiAgentPrioritizedReplayBuffer”, “capacity”: 50000, “prioritized_replay_alpha”: 0.6, “prioritized_replay_beta”: 0.4, “prioritized_replay_eps”: 1e-6, “replay_sequence_length”: 1, } - 其中 - prioritized_replay_alpha: Alpha 参数控制缓冲区中优先级的程度。换句话说，当缓冲区样本具有较高的时序差分误差时，应以多大的概率抽取它来更新参数化的 Q 网络。0.0 对应于均匀概率。设置远高于 1.0 可能很快导致采样分布高度“尖锐”，熵较低。 prioritized_replay_beta: Beta 参数控制重要性采样的程度，它抑制了通过 alpha 参数和时序差分误差以更高概率采样的样本的梯度更新影响。 prioritized_replay_eps: Epsilon 参数设置采样的基线概率，以便即使样本的时序差分误差为零，仍然有机会抽取该样本。
store_buffer_in_checkpoints – 如果您希望缓冲区的内容也存储在任何保存的检查点中，请将其设置为 True。在以下情况下将生成警告： - 此值为 True 且从不包含缓冲区数据的检查点恢复。 - 此值为 False 且从确实包含缓冲区数据的检查点恢复。
epsilon – Epsilon 探索调度。格式为 [[时间步, 值], [时间步, 值], …]。调度必须从时间步 0 开始。
adam_epsilon – Adam 优化器的 epsilon 超参数。
grad_clip – 如果不为 None，则在优化期间将梯度裁剪到此值。
num_steps_sampled_before_learning_starts – 从 rollout workers 收集的时间步长数，之后我们才开始从回放缓冲区采样进行学习。我们是按智能体步长还是环境步长计算此值取决于 config.multi_agent(count_steps_by=..)。
tau – 通过 tau * policy + (1 - tau) * target_policy 更新目标网络。
num_atoms – 用于表示回报分布的 atoms 数量。当此值大于 1 时，使用分布式 Q-learning。
v_min – 最小价值估计
v_max – 最大价值估计
noisy – 是否使用 noisy network 辅助探索。这会给模型权重添加参数噪声。
sigma0 – 控制 noisy nets 的初始参数噪声。
dueling – 是否使用 dueling DQN。
hiddens – advantage 分支和 value 分支的密集层设置
double_q – 是否使用 double DQN。
n_step – N 步目标更新。如果 >1，轨迹中的 sars 元组将被后处理为 sa[折扣和 R][s t+n] 元组。整数将被解释为固定的 n 步值。如果在此处提供包含 2 个整数的元组，则训练批次中每个样本 (!) 的 n 步值将从 [n_step[0], n_step[1]] 定义的闭区间上的均匀分布中抽取。
before_learn_on_batch – 在对多智能体经验批次进行学习之前运行的回调。
training_intensity – 更新模型的强度（相对于从环境中收集样本）。如果为 None，则使用“自然”值： train_batch_size / (rollout_fragment_length x num_env_runners x num_envs_per_env_runner)。如果不是 None，将确保插入缓冲区和从缓冲区采样的步长之间的比率与给定值匹配。示例：training_intensity=1000.0 train_batch_size=250 rollout_fragment_length=1 num_env_runners=1 (或 0) num_envs_per_env_runner=1 -> 自然值 = 250 / 1 = 250.0 -> 将确保 replay+train 操作执行的频率是 rollout+insert 操作的 4 倍 (4 * 250 = 1000)。详情请参阅：rllib/algorithms/dqn/dqn.py::calculate_rr_weights。
td_error_loss_fn – “huber” 或 “mse”。当 num_atoms 为 1 时计算 TD error 的损失函数。请注意，如果 num_atoms > 1，此参数将被忽略，并使用 softmax 交叉熵损失。
categorical_distribution_temperature – 设置 Categorical action distribution 使用的 temperature 参数。有效温度范围为 [0, 1]。请注意，这主要影响评估，因为 TD error 使用 argmax 计算回报。
burn_in_len – 有状态 RLModule 的预热期 (burn-in period)。它允许 Learner 利用回放序列中的初始 burn_in_len 步长仅用于展开网络并建立典型的起始状态。然后，网络在序列的剩余步长上进行更新。此过程有助于缓解由不良初始状态（零或过时记录状态）引起的问题。如果您的有状态 RLModule 面临收敛挑战或出现灾难性遗忘迹象，请考虑将此参数设置为正整数。

返回：

此更新后的 AlgorithmConfig 对象。

软 Actor-Critic (SAC)#

[原始论文], [后续论文], [实现]。

../_images/sac-architecture.svg — **SAC 架构：**SAC 使用回放缓冲区临时存储 RLlib 从环境中收集的 episode 样本。在不同的训练迭代中，这些 episode 和 episode 片段会从缓冲区中重新采样并重新用于更新模型，最终在缓冲区达到容量且新样本不断进入时被丢弃 (FIFO)。这种训练数据的重用使得 SAC 的样本效率很高且是离策略的。SAC 在两个方向上都能扩展，支持多个 EnvRunner 进行样本收集，以及多个基于 GPU 或 CPU 的 Learner 更新模型。#

调优示例：Pendulum-v1、HalfCheetah-v3，

SAC 特有配置（另请参阅通用算法设置）

class ray.rllib.algorithms.sac.sac.SACConfig(algo_class=None)[source]#

定义一个配置类，可以从中构建 SAC 算法。

config = (
    SACConfig()
    .environment("Pendulum-v1")
    .env_runners(num_env_runners=1)
    .training(
        gamma=0.9,
        actor_lr=0.001,
        critic_lr=0.002,
        train_batch_size_per_learner=32,
    )
)
# Build the SAC algo object from the config and run 1 training iteration.
algo = config.build()
algo.train()

training(*, twin_q: bool | None = <ray.rllib.utils.from_config._NotProvided object>, q_model_config: ~typing.Dict[str, ~typing.Any] | None = <ray.rllib.utils.from_config._NotProvided object>, policy_model_config: ~typing.Dict[str, ~typing.Any] | None = <ray.rllib.utils.from_config._NotProvided object>, tau: float | None = <ray.rllib.utils.from_config._NotProvided object>, initial_alpha: float | None = <ray.rllib.utils.from_config._NotProvided object>, target_entropy: str | float | None = <ray.rllib.utils.from_config._NotProvided object>, n_step: int | ~typing.Tuple[int, int] | None = <ray.rllib.utils.from_config._NotProvided object>, store_buffer_in_checkpoints: bool | None = <ray.rllib.utils.from_config._NotProvided object>, replay_buffer_config: ~typing.Dict[str, ~typing.Any] | None = <ray.rllib.utils.from_config._NotProvided object>, training_intensity: float | None = <ray.rllib.utils.from_config._NotProvided object>, clip_actions: bool | None = <ray.rllib.utils.from_config._NotProvided object>, grad_clip: float | None = <ray.rllib.utils.from_config._NotProvided object>, optimization_config: ~typing.Dict[str, ~typing.Any] | None = <ray.rllib.utils.from_config._NotProvided object>, actor_lr: float | ~typing.List[~typing.List[int | float]] | ~typing.List[~typing.Tuple[int, int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, critic_lr: float | ~typing.List[~typing.List[int | float]] | ~typing.List[~typing.Tuple[int, int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, alpha_lr: float | ~typing.List[~typing.List[int | float]] | ~typing.List[~typing.Tuple[int, int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, target_network_update_freq: int | None = <ray.rllib.utils.from_config._NotProvided object>, _deterministic_loss: bool | None = <ray.rllib.utils.from_config._NotProvided object>, _use_beta_distribution: bool | None = <ray.rllib.utils.from_config._NotProvided object>, num_steps_sampled_before_learning_starts: int | None = <ray.rllib.utils.from_config._NotProvided object>, **kwargs) → SACConfig[source]#

设置与训练相关的配置。

参数：

twin_q – 使用两个 Q 网络（而不是一个）进行动作价值估计。注意：每个 Q 网络将拥有自己的目标网络。
q_model_config – Q 网络模型的配置。这些将覆盖 MODEL_DEFAULTS。在设置 Q 网络（如果 twin_q=True 则为 2 个）时，这被视为与顶级 model 字典相同。这意味着，对于不同的观察空间，您可以执行以下操作： obs=Box(1D) -> Tuple(Box(1D) + Action) -> concat -> post_fcnet obs=Box(3D) -> Tuple(Box(3D) + Action) -> vision-net -> concat w/ action -> post_fcnet obs=Tuple(Box(1D), Box(3D)) -> Tuple(Box(1D), Box(3D), Action) -> vision-net -> concat w/ Box(1D) and action -> post_fcnet 您还可以通过在下面的字典中简单指定 custom_model 子键（就像在顶级 model 字典中那样），让 SAC 使用您的 custom_model 作为 Q 模型。
policy_model_config – 策略函数的模型选项（详细信息请参阅上面的 q_model_config）。与上面的 q_model_config 不同之处在于，在 post_fcnet 堆栈之前不执行动作拼接。
tau – 通过 tau * policy + (1 - tau) * target_policy 更新目标网络。
initial_alpha – 用于熵权重 alpha 的初始值。
target_entropy – 目标熵下界。如果为“auto”，将设置为 -|A|（例如，对于 Discrete(2) 为 -2.0，对于 Box(shape=(3,)) 为 -3.0）。这是奖励尺度的倒数，将自动优化。
n_step – N 步目标更新。如果 >1，轨迹中的 sars 元组将被后处理为 sa[折扣和 R][s t+n] 元组。整数将被解释为固定的 n 步值。如果在此处提供包含 2 个整数的元组，则训练批次中每个样本 (!) 的 n 步值将从 [n_step[0], n_step[1]] 定义的闭区间上的均匀分布中抽取。
store_buffer_in_checkpoints – 如果您希望缓冲区的内容也存储在任何保存的检查点中，请将其设置为 True。在以下情况下将生成警告： - 此值为 True 且从不包含缓冲区数据的检查点恢复。 - 此值为 False 且从确实包含缓冲区数据的检查点恢复。
replay_buffer_config – 回放缓冲区配置。示例： { “_enable_replay_buffer_api”: True, “type”: “MultiAgentReplayBuffer”, “capacity”: 50000, “replay_batch_size”: 32, “replay_sequence_length”: 1, } - 或 - { “_enable_replay_buffer_api”: True, “type”: “MultiAgentPrioritizedReplayBuffer”, “capacity”: 50000, “prioritized_replay_alpha”: 0.6, “prioritized_replay_beta”: 0.4, “prioritized_replay_eps”: 1e-6, “replay_sequence_length”: 1, } - 其中 - prioritized_replay_alpha: Alpha 参数控制缓冲区中优先级的程度。换句话说，当缓冲区样本具有较高的时序差分误差时，应以多大的概率抽取它来更新参数化的 Q 网络。0.0 对应于均匀概率。设置远高于 1.0 可能很快导致采样分布高度“尖锐”，熵较低。 prioritized_replay_beta: Beta 参数控制重要性采样的程度，它抑制了通过 alpha 参数和时序差分误差以更高概率采样的样本的梯度更新影响。 prioritized_replay_eps: Epsilon 参数设置采样的基线概率，以便即使样本的时序差分误差为零，仍然有机会抽取该样本。
training_intensity – 更新模型的强度（相对于从环境中收集样本）。如果为 None，则使用“自然”值： train_batch_size / (rollout_fragment_length x num_env_runners x num_envs_per_env_runner)。如果不是 None，将确保插入缓冲区和从缓冲区采样的步长之间的比率与给定值匹配。示例：training_intensity=1000.0 train_batch_size=250 rollout_fragment_length=1 num_env_runners=1 (或 0) num_envs_per_env_runner=1 -> 自然值 = 250 / 1 = 250.0 -> 将确保 replay+train 操作执行的频率是 rollout+insert 操作的 4 倍 (4 * 250 = 1000)。详情请参阅：rllib/algorithms/dqn/dqn.py::calculate_rr_weights。
clip_actions – 是否裁剪动作。如果动作已归一化，应将此设置为 False。
grad_clip – 如果不为 None，则在优化期间将梯度裁剪到此值。
optimization_config – 优化配置字典。在此处设置支持的键 actor_learning_rate、critic_learning_rate 和 entropy_learning_rate。
actor_lr – 策略的学习率（浮点数）或学习率调度，格式为 [[时间步, lr 值], [时间步, lr 值], …]。如果是调度，则中间的时间步长将被赋予线性插值的学习率数值。调度配置的第一个条目必须以时间步长 0 开头，例如：[[0, initial_value], […]]。注意：一种常见做法（双时间尺度方法）是为策略使用比 critic 更小的学习率，以确保 critic 为改进策略提供足够的价值。注意：如果您需要 a) 每个 RLModule 有多个优化器，b) 非 Adam 类型的优化器，c) 不是如上所述的线性插值分段调度的学习率调度，或者 d) 指定非学习率的优化器构造函数参数（例如 Adam 的 epsilon），则必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-5，比 critic 的相应学习率小一个数量级（参见 critic_lr）。
critic_lr – Critic 的学习率（浮点数）或学习率调度，格式为 [[时间步, lr 值], [时间步, lr 值], …]。如果是调度，则中间的时间步长将被赋予线性插值的学习率数值。调度配置的第一个条目必须以时间步长 0 开头，例如：[[0, initial_value], […]]。注意：一种常见做法（双时间尺度方法）是为策略使用比 critic 更小的学习率，以确保 critic 为改进策略提供足够的价值。注意：如果您需要 a) 每个 RLModule 有多个优化器，b) 非 Adam 类型的优化器，c) 不是如上所述的线性插值分段调度的学习率调度，或者 d) 指定非学习率的优化器构造函数参数（例如 Adam 的 epsilon），则必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-4，比 actor（策略）的相应学习率高一个数量级（参见 actor_lr）。
alpha_lr – 超参数 alpha 的学习率（浮点数）或学习率调度，格式为 [[时间步, lr 值], [时间步, lr 值], …]。如果是调度，则中间的时间步长将被赋予线性插值的学习率数值。调度配置的第一个条目必须以时间步长 0 开头，例如：[[0, initial_value], […]]。注意：如果您需要 a) 每个 RLModule 有多个优化器，b) 非 Adam 类型的优化器，c) 不是如上所述的线性插值分段调度的学习率调度，或者 d) 指定非学习率的优化器构造函数参数（例如 Adam 的 epsilon），则必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-4，与 critic 学习率 (lr) 相同。
target_network_update_freq – 每隔 target_network_update_freq 步长更新目标网络。
_deterministic_loss – 损失是否应确定性计算（不包含随机动作采样步骤）。仅对连续动作和调试有用。
_use_beta_distribution – 对有界、连续动作空间使用 Beta 分布而不是 SquashedGaussian（不推荐；仅用于调试）。

返回：

此更新后的 AlgorithmConfig 对象。

高吞吐量 On-Policy 和 Off-Policy#

提示

APPO 最初以“IMPACT”名称发表。RLlib 的 APPO 与论文中描述的算法完全一致。

[论文] [实现]

../_images/appo-architecture.svg — **APPO 架构：**APPO 是基于 IMPALA 架构的近端策略优化 (PPO) 的异步变体，但使用带有 clipping 的代理策略损失，允许每收集一个训练批次进行多次 SGD 遍历。在一个训练迭代中，APPO 异步地从所有 EnvRunner 请求样本，收集到的 episode 样本作为 Ray 引用返回给主算法进程，而不是本地进程上可用的实际对象。然后 APPO 将这些 episode 引用传递给 Learner 进行模型的异步更新。RLlib 在新的模型版本可用后不会总是立即将权重同步回 EnvRunner。为了考虑 EnvRunner 是离策略的，APPO 使用 IMPALA 论文中描述的 v-trace 过程。APPO 在两个方向上都能扩展，支持多个 EnvRunner 进行样本收集，以及多个基于 GPU 或 CPU 的 Learner 更新模型。#

调优示例：Pong-v5 HalfCheetah-v4

APPO 特有配置（另请参阅通用算法设置）

class ray.rllib.algorithms.appo.appo.APPOConfig(algo_class=None)[source]#

定义一个配置类，可以从中构建 APPO 算法。

from ray.rllib.algorithms.appo import APPOConfig
config = (
    APPOConfig()
    .training(lr=0.01, grad_clip=30.0, train_batch_size_per_learner=50)
)
config = config.learners(num_learners=1)
config = config.env_runners(num_env_runners=1)
config = config.environment("CartPole-v1")

# Build an Algorithm object from the config and run 1 training iteration.
algo = config.build()
algo.train()
del algo

from ray.rllib.algorithms.appo import APPOConfig
from ray import tune

config = APPOConfig()
# Update the config object.
config = config.training(lr=tune.grid_search([0.001,]))
# Set the config object's env.
config = config.environment(env="CartPole-v1")
# Use to_dict() to get the old-style python config dict when running with tune.
tune.Tuner(
    "APPO",
    run_config=tune.RunConfig(
        stop={"training_iteration": 1},
        verbose=0,
    ),
    param_space=config.to_dict(),

).fit()

训练(*, vtrace: bool | None = <ray.rllib.utils.from_config._NotProvided object>, use_gae: bool | None = <ray.rllib.utils.from_config._NotProvided object>, lambda_: float | None = <ray.rllib.utils.from_config._NotProvided object>, clip_param: float | None = <ray.rllib.utils.from_config._NotProvided object>, use_kl_loss: bool | None = <ray.rllib.utils.from_config._NotProvided object>, kl_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, kl_target: float | None = <ray.rllib.utils.from_config._NotProvided object>, target_network_update_freq: int | None = <ray.rllib.utils.from_config._NotProvided object>, tau: float | None = <ray.rllib.utils.from_config._NotProvided object>, target_worker_clipping: float | None = <ray.rllib.utils.from_config._NotProvided object>, circular_buffer_num_batches: int | None = <ray.rllib.utils.from_config._NotProvided object>, circular_buffer_iterations_per_batch: int | None = <ray.rllib.utils.from_config._NotProvided object>, target_update_frequency=-1, use_critic=-1, **kwargs) → APPOConfig[源码]#

设置与训练相关的配置。

参数：

vtrace – 是否使用 V-trace 加权优势。如果为 false，则将改为使用 PPO GAE 优势。
use_gae – 如果为 true，使用带有值函数的广义优势估计器 (GAE)，参见 https://arxiv.org/pdf/1506.02438.pdf。仅在 vtrace=False 时适用。
lambda – GAE (lambda) 参数。
clip_param – PPO 代理裁剪参数。
use_kl_loss – 是否在损失函数中使用 KL 项。
kl_coeff – 用于加权 KL 损失项的系数。
kl_target – KL 项要达到的目标值（通过自动调整 kl_coeff）。
target_network_update_freq – 注意：此参数仅适用于新的 API 栈。从主训练策略网络更新目标策略网络的频率。使用的度量是 NUM_ENV_STEPS_TRAINED_LIFETIME，单位是 n（参见 [1] 4.1.1），其中：n = [circular_buffer_num_batches (N)] * [circular_buffer_iterations_per_batch (K)] * [train batch size]。例如，如果您设置 target_network_update_freq=2，且 N=4, K=2, train_batch_size_per_learner=500，则目标网络每训练 2*4*2*500=8000 个环境步骤（每个学习器每 16 个批次更新）更新一次。[1] 中的作者建议此设置对多种选择都具有鲁棒性（尝试 0.125 到 4 之间的值）。
target_network_update_freq – 更新目标策略和调整训练期间使用的 kl 损失系数的频率。设置此参数后，算法会等待至少 target_network_update_freq 个环境样本被训练后，再更新目标网络并调整 kl 损失系数。注意：此参数仅在使用 Learner API (enable_rl_module_and_learner=True) 时适用。
tau – 目标策略网络朝着当前策略网络更新的因子。范围在 0 到 1 之间。例如：updated_param = tau * current_param + (1 - tau) * target_param
target_worker_clipping – 用于计算 IS 比率的目标工作者裁剪的最大值，如 [1] 中所述：IS = min(π(i) / π(target), ρ) * (π / π(i))
circular_buffer_num_batches – 适合循环缓冲区的训练批次数。每个这样的训练批次最多可以采样 circular_buffer_iterations_per_batch 次进行训练。
circular_buffer_iterations_per_batch – 循环缓冲区中的任何训练批次可以被采样进行训练的次数。如果批次是缓冲区中最旧的批次并且添加了新批次，或者批次达到此最大采样次数，则它将从缓冲区中被逐出。

返回：

此更新后的 AlgorithmConfig 对象。

重要性加权 Actor-Learner 架构 (IMPALA)#

[论文] [实现]

../_images/impala-architecture.svg — **IMPALA 架构：**在一个训练迭代中，IMPALA 异步地向所有 EnvRunners 请求样本，并将收集到的 episode 作为 Ray 引用返回给主算法进程，而不是本地进程上可用的实际对象。然后 IMPALA 将这些 episode 引用传递给 Learners 进行模型的异步更新。当新的模型版本可用时，RLlib 并不会立即将权重同步回 EnvRunners。为了应对 EnvRunners 处于 off-policy 状态，IMPALA 使用了一种称为 v-trace 的过程，如论文中所述。IMPALA 在两个方面进行扩展，支持多个 EnvRunners 进行样本收集，以及多个基于 GPU 或 CPU 的 Learners 进行模型更新。#

优化示例：PongNoFrameskip-v4，向量化配置，多 GPU 配置，{BeamRider,Breakout,Qbert,SpaceInvaders}NoFrameskip-v4。

../_images/impala.png — 多 GPU IMPALA 使用一对 V100 GPU 和 128 个 CPU worker，在大约 3 分钟内扩展解决了 PongNoFrameskip-v4。达到的最大训练吞吐量约为每秒 3 万个过渡（每秒约 12 万个环境帧）。#

IMPALA 特有配置（另请参见通用算法设置）

类 ray.rllib.algorithms.impala.impala.IMPALAConfig(algo_class=None)[源码]#

定义一个配置类，可以从中构建一个 Impala 算法。

from ray.rllib.algorithms.impala import IMPALAConfig

config = (
    IMPALAConfig()
    .environment("CartPole-v1")
    .env_runners(num_env_runners=1)
    .training(lr=0.0003, train_batch_size_per_learner=512)
    .learners(num_learners=1)
)
# Build a Algorithm object from the config and run 1 training iteration.
algo = config.build()
algo.train()
del algo

from ray.rllib.algorithms.impala import IMPALAConfig
from ray import tune

config = (
    IMPALAConfig()
    .environment("CartPole-v1")
    .env_runners(num_env_runners=1)
    .training(lr=tune.grid_search([0.0001, 0.0002]), grad_clip=20.0)
    .learners(num_learners=1)
)
# Run with tune.
tune.Tuner(
    "IMPALA",
    param_space=config,
    run_config=tune.RunConfig(stop={"training_iteration": 1}),
).fit()

训练(*, vtrace: bool | None = <ray.rllib.utils.from_config._NotProvided object>, vtrace_clip_rho_threshold: float | None = <ray.rllib.utils.from_config._NotProvided object>, vtrace_clip_pg_rho_threshold: float | None = <ray.rllib.utils.from_config._NotProvided object>, num_gpu_loader_threads: int | None = <ray.rllib.utils.from_config._NotProvided object>, num_multi_gpu_tower_stacks: int | None = <ray.rllib.utils.from_config._NotProvided object>, minibatch_buffer_size: int | None = <ray.rllib.utils.from_config._NotProvided object>, replay_proportion: float | None = <ray.rllib.utils.from_config._NotProvided object>, replay_buffer_num_slots: int | None = <ray.rllib.utils.from_config._NotProvided object>, learner_queue_size: int | None = <ray.rllib.utils.from_config._NotProvided object>, learner_queue_timeout: float | None = <ray.rllib.utils.from_config._NotProvided object>, timeout_s_sampler_manager: float | None = <ray.rllib.utils.from_config._NotProvided object>, timeout_s_aggregator_manager: float | None = <ray.rllib.utils.from_config._NotProvided object>, broadcast_interval: int | None = <ray.rllib.utils.from_config._NotProvided object>, grad_clip: float | None = <ray.rllib.utils.from_config._NotProvided object>, opt_type: str | None = <ray.rllib.utils.from_config._NotProvided object>, lr_schedule: ~typing.List[~typing.List[int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, decay: float | None = <ray.rllib.utils.from_config._NotProvided object>, momentum: float | None = <ray.rllib.utils.from_config._NotProvided object>, epsilon: float | None = <ray.rllib.utils.from_config._NotProvided object>, vf_loss_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, entropy_coeff: float | ~typing.List[~typing.List[int | float]] | ~typing.List[~typing.Tuple[int, int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, entropy_coeff_schedule: ~typing.List[~typing.List[int | float]] | None = <ray.rllib.utils.from_config._NotProvided object>, _separate_vf_optimizer: bool | None = <ray.rllib.utils.from_config._NotProvided object>, _lr_vf: float | None = <ray.rllib.utils.from_config._NotProvided object>, num_aggregation_workers=-1, max_requests_in_flight_per_aggregator_worker=-1, **kwargs) → IMPALAConfig[源码]#

设置与训练相关的配置。

参数：

vtrace – V-trace 参数（参见 vtrace_tf/torch.py）。
vtrace_clip_rho_threshold
vtrace_clip_pg_rho_threshold
num_gpu_loader_threads – GPU 加载线程数（每个 Learner worker），用于将传入的 (CPU) 批次加载到 GPU（如果适用）。传入的批次由每个 Learner 的 LearnerConnector 管道生成。在 GPU 上加载批次后，线程将它们放入另一个队列，供 Learner 线程（每个 Learner worker 只有一个）获取并执行 forward_train/loss 计算。
num_multi_gpu_tower_stacks – 对于每个多 GPU tower 堆栈，应该为并行数据加载预留多少槽位？将其设置为 >1 以并行将数据加载到 GPU。这将按堆栈数量成比例地增加 GPU 内存使用量。示例：2 个 GPU 和 num_multi_gpu_tower_stacks=3：- 一个 tower 堆栈包含 2 个 GPU，每个 GPU 都有模型/图的副本。- 每个堆栈将在其每个 GPU 上创建 3 个用于批次数据的槽位，将每个 GPU 的内存需求增加 3 倍。- 这使我们能够在另一个堆栈执行梯度计算时，将数据预加载到这些堆栈中。
minibatch_buffer_size – 应保留多少训练批次用于 minibatching。此配置仅在 num_epochs > 1 时有效。
replay_proportion – 设置 >0 以启用经验回放。保存的样本将以 p:1 的比例与新数据样本一起回放。
replay_buffer_num_slots – 用于回放的样本批次存储数量。保存的总过渡数将为 (replay_buffer_num_slots * rollout_fragment_length)。
learner_queue_size – 输入到学习器的训练批次的最大队列大小。
learner_queue_timeout – 等待 minibatch 缓冲区队列中可用训练批次的时间（秒）。例如，在使用缓慢环境进行训练时，可能需要增加此值。
timeout_s_sampler_manager – 等待 worker 采样结果的超时时间（秒）——通常如果此值太低，管理器将无法检索到准备好的采样结果。
timeout_s_aggregator_manager – 等待回放 worker 结果的超时时间（秒）——通常如果此值太低，管理器将无法检索到准备好的回放请求。
broadcast_interval – 在将权重广播到任何迭代期间采样的 rollout workers 之前的训练步骤调用次数。
grad_clip – 如果指定，则将梯度的全局范数裁剪到此值。
opt_type – “adam” 或 “rmsprop” 之一。
lr_schedule – 学习率调度。格式为 [[时间步, lr-值], [时间步, lr-值], …]。中间时间步将分配插值学习率值。调度通常应从时间步 0 开始。
decay – RMSProp 优化器的衰减设置，当 opt_type=rmsprop 时。
momentum – RMSProp 优化器的动量设置，当 opt_type=rmsprop 时。
epsilon – RMSProp 优化器的 Epsilon 设置，当 opt_type=rmsprop 时。
vf_loss_coeff – 损失函数中值函数项的系数。
entropy_coeff – 损失函数中熵正则化项的系数。
entropy_coeff_schedule – 熵正则化器的衰减调度。
_separate_vf_optimizer – 将此设置为 true 以使用两个独立的优化器优化策略网络和值网络。仅在旧 API 栈上对某些算法（APPO、IMPALA）支持。
_lr_vf – 如果 _separate_vf_optimizer 为 True，则为值网络定义单独的学习率。

返回：

此更新后的 AlgorithmConfig 对象。

基于模型的强化学习#

DreamerV3#

[论文] [实现]

优化示例： Atari 100k，Atari 200M，DeepMind Control Suite

Pong-v5 结果（1、2 和 4 个 GPU）:

../_images/pong_1_2_and_4gpus.svg — Pong-v5 环境的平均 Episode 奖励（使用“100k”设置，其中只允许 10 万个环境步）：请注意，尽管样本效率稳定——表现为每个环境步的学习性能恒定——但从 1 个 GPU 增加到 4 个 GPU 时，实际运行时间几乎呈线性缩短。左图：每个采样环境时间步的 Episode 奖励。右图：每个实际运行时间的 Episode 奖励。#

Atari 100k 结果（1 对 4 个 GPU）:

../_images/atari100k_1_vs_4gpus.svg — 1 个 GPU 对 4 个 GPU 在各种 Atari 100k 任务上的平均 Episode 奖励。左图：每个采样环境时间步的 Episode 奖励。右图：每个实际运行时间的 Episode 奖励。#

DeepMind Control Suite (视觉) 结果（1 对 4 个 GPU）:

../_images/dmc_1_vs_4gpus.svg — 1 个 GPU 对 4 个 GPU 在各种 Atari 100k 任务上的平均 Episode 奖励。左图：每个采样环境时间步的 Episode 奖励。右图：每个实际运行时间的 Episode 奖励。#

离线强化学习和模仿学习#

行为克隆 (BC)#

[论文] [实现]

../_images/bc-architecture.svg — **BC 架构：**RLlib 的行为克隆 (BC) 使用 Ray Data 利用其并行数据处理能力。在一个训练迭代中，BC 由 n 个 DataWorkers 并行读取离线文件（例如 parquet）中的 episode。然后 Connector pipelines 将这些 episode 预处理成训练批次，并将这些批次作为数据迭代器直接发送给 n 个 Learners 以更新模型。RLlib 的 BC 实现直接源自其 MARWIL 实现，唯一的区别是 `beta` 参数（设置为 0.0）。这使得 BC 试图匹配生成离线数据的行为策略，而忽略任何由此产生的奖励。#

优化示例： CartPole-v1 Pendulum-v1

BC 特有配置（另请参见通用算法设置）

类 ray.rllib.algorithms.bc.bc.BCConfig(algo_class=None)[源码]#

定义一个配置类，可以从中构建一个新的 BC 算法。

from ray.rllib.algorithms.bc import BCConfig
# Run this from the ray directory root.
config = BCConfig().training(lr=0.00001, gamma=0.99)
config = config.offline_data(
    input_="./rllib/tests/data/cartpole/large.json")

# Build an Algorithm object from the config and run 1 training iteration.
algo = config.build()
algo.train()

from ray.rllib.algorithms.bc import BCConfig
from ray import tune
config = BCConfig()
# Print out some default values.
print(config.beta)
# Update the config object.
config.training(
    lr=tune.grid_search([0.001, 0.0001]), beta=0.75
)
# Set the config object's data path.
# Run this from the ray directory root.
config.offline_data(
    input_="./rllib/tests/data/cartpole/large.json"
)
# Set the config object's env, used for evaluation.
config.environment(env="CartPole-v1")
# Use to_dict() to get the old-style python config dict
# when running with tune.
tune.Tuner(
    "BC",
    param_space=config.to_dict(),
).fit()

训练(*, beta: float | None = <ray.rllib.utils.from_config._NotProvided object>, bc_logstd_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, moving_average_sqd_adv_norm_update_rate: float | None = <ray.rllib.utils.from_config._NotProvided object>, moving_average_sqd_adv_norm_start: float | None = <ray.rllib.utils.from_config._NotProvided object>, vf_coeff: float | None = <ray.rllib.utils.from_config._NotProvided object>, grad_clip: float | None = <ray.rllib.utils.from_config._NotProvided object>, **kwargs) → MARWILConfig#

设置与训练相关的配置。

参数：

beta – 优势在指数项中的缩放因子。当 beta 为 0.0 时，MARWIL 退化为行为克隆（模仿学习）；参见同一目录中的 bc.py 算法。
bc_logstd_coeff – 鼓励更高动作分布熵以进行探索的系数。
moving_average_sqd_adv_norm_update_rate – 更新优势范数平方移动平均 (c^2) 的速率。较高的速率会导致此移动平均更快地更新。
moving_average_sqd_adv_norm_start – 优势范数平方移动平均 (c^2) 的起始值。
vf_coeff – 平衡值估计损失和策略优化损失。
grad_clip – 如果指定，则将梯度的全局范数裁剪到此值。

返回：

此更新后的 AlgorithmConfig 对象。

保守 Q 学习 (CQL)#

[论文] [实现]

../_images/cql-architecture.svg — **CQL 架构：**CQL (保守 Q 学习) 是一种离线强化学习算法，它通过保守的 critic 估计来减轻数据集分布外部 Q 值的过高估计。它在标准的 Bellman 更新损失中添加了一个简单的 Q 正则化损失，确保 critic 不会输出过于乐观的 Q 值。`SACLearner` 将此保守修正项添加到基于 TD 的 Q 学习损失中。#

优化示例： Pendulum-v1

CQL 特有配置 和通用算法设置）

类 ray.rllib.algorithms.cql.cql.CQLConfig(algo_class=None)[源码]#

定义一个配置类，可以从中构建一个 CQL 算法。

from ray.rllib.algorithms.cql import CQLConfig
config = CQLConfig().training(gamma=0.9, lr=0.01)
config = config.resources(num_gpus=0)
config = config.env_runners(num_env_runners=4)
print(config.to_dict())
# Build a Algorithm object from the config and run 1 training iteration.
algo = config.build(env="CartPole-v1")
algo.train()

训练(*, bc_iters: int | None = <ray.rllib.utils.from_config._NotProvided object>, temperature: float | None = <ray.rllib.utils.from_config._NotProvided object>, num_actions: int | None = <ray.rllib.utils.from_config._NotProvided object>, lagrangian: bool | None = <ray.rllib.utils.from_config._NotProvided object>, lagrangian_thresh: float | None = <ray.rllib.utils.from_config._NotProvided object>, min_q_weight: float | None = <ray.rllib.utils.from_config._NotProvided object>, deterministic_backup: bool | None = <ray.rllib.utils.from_config._NotProvided object>, **kwargs) → CQLConfig[源码]#

设置与训练相关的配置。

参数：

bc_iters – 行为克隆预训练的迭代次数。
temperature – CQL 损失温度。
num_actions – 用于 CQL 损失采样的动作数量。
lagrangian – 是否对 Alpha Prime（在 CQL 损失中）使用拉格朗日乘子。
lagrangian_thresh – 拉格朗日阈值。
min_q_weight – 最小 Q 权重乘数。
deterministic_backup – Bellman 更新中的目标是否应具有熵备份。默认为 True。

返回：

此更新后的 AlgorithmConfig 对象。

单调优势重加权模仿学习 (MARWIL)#

[论文] [实现]

../_images/marwil-architecture.svg — **MARWIL 架构：**MARWIL 是一种混合模仿学习和策略梯度算法，适用于在批处理的历史数据上进行训练。当 `beta` 超参数设置为零时，MARWIL objective 退化为简单的模仿学习（参见 BC）。MARWIL 使用 Ray.Data 利用其并行数据处理能力。在一个训练迭代中，MARWIL 由 n 个 DataWorkers 并行读取离线文件（例如 parquet）中的 episode。Connector pipelines 将这些 episode 预处理成训练批次，并将这些批次作为数据迭代器直接发送给 n 个 Learners 以更新模型。#

优化示例： CartPole-v1

MARWIL 特有配置（另请参见通用算法设置）

类 ray.rllib.algorithms.marwil.marwil.MARWILConfig(algo_class=None)[源码]#

定义一个配置类，可以从中构建一个 MARWIL 算法。

import gymnasium as gym
import numpy as np

from pathlib import Path
from ray.rllib.algorithms.marwil import MARWILConfig

# Get the base path (to ray/rllib)
base_path = Path(__file__).parents[2]
# Get the path to the data in rllib folder.
data_path = base_path / "tests/data/cartpole/cartpole-v1_large"

config = MARWILConfig()
# Enable the new API stack.
config.api_stack(
    enable_rl_module_and_learner=True,
    enable_env_runner_and_connector_v2=True,
)
# Define the environment for which to learn a policy
# from offline data.
config.environment(
    observation_space=gym.spaces.Box(
        np.array([-4.8, -np.inf, -0.41887903, -np.inf]),
        np.array([4.8, np.inf, 0.41887903, np.inf]),
        shape=(4,),
        dtype=np.float32,
    ),
    action_space=gym.spaces.Discrete(2),
)
# Set the training parameters.
config.training(
    beta=1.0,
    lr=1e-5,
    gamma=0.99,
    # We must define a train batch size for each
    # learner (here 1 local learner).
    train_batch_size_per_learner=2000,
)
# Define the data source for offline data.
config.offline_data(
    input_=[data_path.as_posix()],
    # Run exactly one update per training iteration.
    dataset_num_iters_per_learner=1,
)

# Build an `Algorithm` object from the config and run 1 training
# iteration.
algo = config.build()
algo.train()

import gymnasium as gym
import numpy as np

from pathlib import Path
from ray.rllib.algorithms.marwil import MARWILConfig
from ray import tune

# Get the base path (to ray/rllib)
base_path = Path(__file__).parents[2]
# Get the path to the data in rllib folder.
data_path = base_path / "tests/data/cartpole/cartpole-v1_large"

config = MARWILConfig()
# Enable the new API stack.
config.api_stack(
    enable_rl_module_and_learner=True,
    enable_env_runner_and_connector_v2=True,
)
# Print out some default values
print(f"beta: {config.beta}")
# Update the config object.
config.training(
    lr=tune.grid_search([1e-3, 1e-4]),
    beta=0.75,
    # We must define a train batch size for each
    # learner (here 1 local learner).
    train_batch_size_per_learner=2000,
)
# Set the config's data path.
config.offline_data(
    input_=[data_path.as_posix()],
    # Set the number of updates to be run per learner
    # per training step.
    dataset_num_iters_per_learner=1,
)
# Set the config's environment for evalaution.
config.environment(
    observation_space=gym.spaces.Box(
        np.array([-4.8, -np.inf, -0.41887903, -np.inf]),
        np.array([4.8, np.inf, 0.41887903, np.inf]),
        shape=(4,),
        dtype=np.float32,
    ),
    action_space=gym.spaces.Discrete(2),
)
# Set up a tuner to run the experiment.
tuner = tune.Tuner(
    "MARWIL",
    param_space=config,
    run_config=tune.RunConfig(
        stop={"training_iteration": 1},
    ),
)
# Run the experiment.
tuner.fit()

设置与训练相关的配置。

参数：

beta – 优势在指数项中的缩放因子。当 beta 为 0.0 时，MARWIL 退化为行为克隆（模仿学习）；参见同一目录中的 bc.py 算法。
bc_logstd_coeff – 鼓励更高动作分布熵以进行探索的系数。
moving_average_sqd_adv_norm_update_rate – 更新优势范数平方移动平均 (c^2) 的速率。较高的速率会导致此移动平均更快地更新。
moving_average_sqd_adv_norm_start – 优势范数平方移动平均 (c^2) 的起始值。
vf_coeff – 平衡值估计损失和策略优化损失。
grad_clip – 如果指定，则将梯度的全局范数裁剪到此值。

返回：

此更新后的 AlgorithmConfig 对象。

算法扩展和插件#

基于自监督预测的好奇心驱动探索#

[论文] [实现]

../_images/curiosity-architecture.svg — **内在好奇心模型 (ICM) 架构：**ICM 的核心思想是训练一个世界模型（与“主”策略并行）来预测环境的 dynamics。世界模型的损失是 `ICMLearner` 添加到环境（外在）奖励中的内在奖励。这确保了当身处相对未知（世界模型在预测接下来发生的事情方面表现不佳）的环境区域时，人工内在奖励会很大，激励代理前往探索这些未知区域。RLlib 的好奇心实现适用于 RLlib 的任何算法。参见这些链接，了解在 PPO 和 DQN 之上的示例实现。ICM 按原样使用所选算法的 `training_step()`，但在 `LearnerGroup.update` 期间执行以下附加步骤：复制“主”策略的训练批次，并用它来执行 ICM 的自监督更新。使用 ICM 计算内在奖励，并将这些奖励添加到外在（环境）奖励中。然后继续更新“主”策略。#

优化示例： 12x12 FrozenLake-v1