算法#

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

算法	单智能体与多智能体	多 GPU（多节点）	动作空间
在线策略
PPO（近端策略优化）
离线策略
DQN/Rainbow（深度 Q 网络）
SAC（软 Actor Critic）
高吞吐量的在线和离线策略
APPO（异步近端策略优化）
IMPALA（重要性加权 Actor-Learner 架构）
基于模型的 RL
DreamerV3
离线 RL 和模仿学习
BC（行为克隆）
CQL（保守 Q-Learning）
IQL（隐式 Q-Learning）
MARWIL（单调优势重加权模仿学习）
算法扩展与插件
通过自监督预测的 Curiosity-driven Exploration

在线策略#

近端策略优化 (PPO)#

[论文] [实现]

../_images/ppo-architecture.svg — **PPO 架构：** 在一个训练迭代中，PPO 执行三个主要步骤：1. 采样一组 episode 或 episode 片段 1. 将它们转换为训练批次，并使用裁剪目标和对该批次的多次 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) → Self[source]#

设置与训练相关的配置。

参数:

use_critic – 是否使用 Critic 作为基线（否则不使用值基线；使用 GAE 所必需）。
use_gae – 如果为 True，则使用带值函数的广义优势估计器 (GAE)，参见 https://arxiv.org/pdf/1506.02438.pdf。
lambda – General Advantage Estimation (GAE) 的 lambda 参数。它定义了在多个时间步长之间，实际测量到的奖励与值函数估计之间的指数权重。具体来说，lambda_ 平衡了短期、低方差的估计与长期、高方差的收益。当 lambda_ 为 0.0 时，GAE 只依赖于即时奖励（以及从那里开始的值函数预测，从而降低方差，但增加偏差）；而当 lambda_ 为 1.0 时，它只包含在给定 episode 或 episode 块的截断点处的值函数预测（从而降低偏差，但增加方差）。
use_kl_loss – 是否在损失函数中使用 KL 项。
kl_coeff – KL 散度的初始系数。
kl_target – KL 散度的目标值。
vf_loss_coeff – 值函数损失的系数。重要提示：如果将模型配置中的 `vf_share_layers` 设置为 True，则必须调整此参数。
entropy_coeff – 熵系数（float）或熵系数计划，格式为 [[时间步，系数-值]，[时间步，系数-值]，……]。在计划的情况下，中间时间步将分配给线性插值的系数。计划配置的第一个条目必须以时间步 0 开始，即：[[0, 初始值]，[…]]。
clip_param – PPO 的裁剪参数。
vf_clip_param – 值函数的裁剪参数。请注意，这对于奖励的尺度很敏感。如果预期的 V 值很大，请增加此值。
grad_clip – 如果指定，则将梯度的全局范数裁剪为此值。

返回：

此更新后的 AlgorithmConfig 对象。

离线策略#

深度 Q 网络 (DQN, Rainbow, 参数化 DQN)#

[论文] [实现]

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

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

调优示例： PongDeterministic-v4, Rainbow 配置, {BeamRider,Breakout,Qbert,SpaceInvaders}NoFrameskip-v4, 使用 Dueling 和 Double-Q, 使用分布式 DQN。

提示

要完成 Rainbow 的设置，请对默认 DQN 配置进行以下更改："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) → Self[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 worker 收集的步数。我们是按代理步数还是环境步数计算此值取决于 config.multi_agent(count_steps_by=..)。
tau – 使用 au * policy + (1- au) * target_policy 更新目标。
num_atoms – 用于表示收益分布的原子数量。当此值大于 1 时，使用分布 Q-learning。
v_min – 最小值估计
v_max – 最大值估计
noisy – 是否使用噪声网络来辅助探索。这会向模型权重添加参数化噪声。
sigma0 – 控制噪声网络的初始参数噪声。
dueling – 是否使用 dueling DQN。
hiddens – 优势分支和值分支的密集层设置
double_q – 是否使用 double DQN。
n_step – N-step 目标更新。如果大于 1，则会对轨迹中的 sars’ 元组进行后处理，使其成为 sa[折扣总和 R][s t+n] 元组。整数将解释为固定的 n-step 值。如果在此处提供了 2 个整数的元组，则将从定义为 [n_step[0], n_step[1]] 的闭区间上的均匀分布中为训练批次中的每个样本 (!) 绘制 n-step 值。
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 -> 将确保回放+训练操作的执行频率是 rollout+insert 操作的 4 倍（4 * 250 = 1000）。详情请参阅：rllib/algorithms/dqn/dqn.py::calculate_rr_weights。
td_error_loss_fn – “huber” 或 “mse”。在 num_atoms 为 1 时用于计算 TD 误差的损失函数。请注意，如果 num_atoms 大于 1，则此参数将被忽略，并将使用 softmax 交叉熵损失。
categorical_distribution_temperature – 设置分类动作分布使用的温度参数。有效温度在 [0, 1] 范围内。请注意，这主要影响评估，因为 TD 误差在计算返回值时使用 argmax。
burn_in_len – 状态化 RLModule 的预热期。它允许 Learner 仅使用回放序列中的初始 burn_in_len 步来展开网络并建立典型的起始状态。然后，网络将在序列的剩余步数上进行更新。此过程有助于缓解初始状态不佳（零或过时的记录状态）带来的问题。如果您的状态化 RLModule 遇到收敛挑战或出现灾难性遗忘的迹象，请考虑将此参数设置为正整数。

返回：

此更新后的 AlgorithmConfig 对象。

软 Actor Critic (SAC)#

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

../_images/sac-architecture.svg — **SAC 架构：** SAC 使用一个回放缓冲区来临时存储 RLlib 从环境中收集的 episode 样本。在不同的训练迭代中，这些 episode 和 episode 片段会从缓冲区重新采样并用于模型更新，直到缓冲区达到容量并且新样本不断进入（FIFO）时才最终被丢弃。这种训练数据的重用使得 DQN 非常高效且是离线策略算法。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) → Self[source]#

设置与训练相关的配置。

参数:

twin_q – 使用两个Q网络（而不是一个）进行动作值估计。注意：每个Q网络将有自己的目标网络。
q_model_config – Q网络(s)的模型配置。这些将覆盖 MODEL_DEFAULTS。这被视为设置Q网络(s)（如果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 您还可以让SAC使用您的custom_model作为Q模型(s)，只需在下面的字典中指定 custom_model 子键（就像您在最顶层的 model 字典中所做的那样）。
policy_model_config – 策略函数的模型选项（有关详细信息，请参阅上面的 q_model_config）。与上面的 q_model_config 的区别在于，在post_fcnet堆栈之前不执行动作连接。
tau – 使用 au * policy + (1- au) * target_policy 更新目标。
initial_alpha – 用于熵权重 alpha 的初始值。
target_entropy – 目标熵下限。如果为“auto”，则设置为 -|A| （例如，离散(2)为 -2.0，Box(shape=(3,))为 -3.0）。这是奖励尺度的倒数，将自动优化。
n_step – N-step 目标更新。如果大于 1，则会对轨迹中的 sars’ 元组进行后处理，使其成为 sa[折扣总和 R][s t+n] 元组。整数将解释为固定的 n-step 值。如果在此处提供了 2 个整数的元组，则将从定义为 [n_step[0], n_step[1]] 的闭区间上的均匀分布中为训练批次中的每个样本 (!) 绘制 n-step 值。
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 – 策略的学习率（float）或学习率调度，格式为 [[时间步，学习率值]，[时间步，学习率值]，...]。在调度的情况下，中间时间步将被分配到线性插值的学习率值。调度配置的第一个条目必须以时间步 0 开始，即：[[0, 初始值]，[...]]。注意：通常的做法（双时间尺度方法）是使用比 critic 更低的学习率（policy）来确保 critic 提供足够的值来改进策略。注意：如果您需要 a) 多个优化器（每个 RLModule），b) 非 Adam 的优化器类型，c) 非上述线性插值、分段调度的学习率调度，或 d) 指定优化器的 c'tor 参数而不是学习率（例如 Adam 的 epsilon），那么您必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-5，比 critic 的相应学习率（参见 critic_lr）低一个数量级。
critic_lr – 评论员的学习率（float）或学习率调度，格式为 [[时间步，学习率值]，[时间步，学习率值]，...]。在调度的情况下，中间时间步将被分配到线性插值的学习率值。调度配置的第一个条目必须以时间步 0 开始，即：[[0, 初始值]，[...]]。注意：通常的做法（双时间尺度方法）是使用比策略更低的学习率（policy）来确保评论员提供足够的值来改进策略。注意：如果您需要 a) 多个优化器（每个 RLModule），b) 非 Adam 的优化器类型，c) 非上述线性插值、分段调度的学习率调度，或 d) 指定优化器的 c'tor 参数而不是学习率（例如 Adam 的 epsilon），那么您必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-4，比 actor（策略）的相应学习率（参见 actor_lr）高一个数量级。
alpha_lr – 超参数 alpha 的学习率（float）或学习率调度，格式为 [[时间步，学习率值]，[时间步，学习率值]，...]。在调度的情况下，中间时间步将被分配到线性插值的学习率值。调度配置的第一个条目必须以时间步 0 开始，即：[[0, 初始值]，[...]]。注意：如果您需要 a) 多个优化器（每个 RLModule），b) 非 Adam 的优化器类型，c) 非上述线性插值、分段调度的学习率调度，或 d) 指定优化器的 c'tor 参数而不是学习率（例如 Adam 的 epsilon），那么您必须覆盖您的 Learner 的 configure_optimizer_for_module() 方法并自行处理学习率调度。默认值为 3e-4，与评论员学习率（lr）相同。
target_network_update_freq – 每 target_network_update_freq 步更新目标网络。
num_steps_sampled_before_learning_starts – 在我们开始从回放缓冲区采样进行学习之前，我们从运行器收集的样本数（int）。我们计算的是代理步数还是环境步数取决于 config.multi_agent(count_steps_by=...) 的值。
_deterministic_loss – 损失是否应确定性地计算（不带随机动作采样步骤）。True 仅对连续动作和调试有用。
_use_beta_distribution – 使用 Beta 分布而不是 SquashedGaussian 来处理有界、连续的动作空间（不推荐；仅用于调试）。

返回：

此更新后的 AlgorithmConfig 对象。

高吞吐量的在线和离线策略#

异步近端策略优化 (APPO)#

提示

APPO 最初是以“IMPACT”的名称发布的。RLlib 的 APPO 与论文中描述的算法完全匹配。

[论文] [实现]

../_images/appo-architecture.svg — **APPO 架构：** APPO 是近端策略优化 (PPO) 的异步变体，基于 IMPALA 架构，但使用带有裁剪的代理策略损失，允许对每个收集的训练批次进行多次 SGD 迭代。在训练迭代中，APPO 异步请求所有 EnvRunners 的样本，并将收集的剧集样本作为 Ray 引用返回给主算法进程，而不是作为本地进程可用的实际对象。然后，APPO 将这些剧集引用传递给 Learner，以异步更新模型。RLlib 在获得新的模型版本后并不总是立即将权重同步回 EnvRunners。为了处理 EnvRunners 的离线策略，APPO 使用了一个称为 v-trace 的过程，该过程在 IMPALA 论文中进行了描述。APPO 在两个轴上都进行了扩展，支持多个 EnvRunners 进行样本收集和多个基于 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()

training(*, 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) → Self[source]#

设置与训练相关的配置。

参数:

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 个环境步（每个 Learner 上每 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 的样本，并将收集的剧集作为 Ray 引用返回给主算法进程，而不是作为本地进程可用的实际对象。IMPALA 然后将这些剧集引用传递给 Learner，以异步更新模型。RLlib 在获得新的模型版本后并不总是立即将权重同步回 EnvRunners。为了处理 EnvRunners 的离线策略，IMPALA 使用了一个称为 v-trace 的过程，该过程在论文中进行了描述。IMPALA 在两个轴上都进行了扩展，支持多个 EnvRunners 进行样本收集和多个基于 GPU 或 CPU 的 Learner 进行模型更新。#

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

../_images/impala.png — 多 GPU IMPALA 使用一对 V100 GPU 和 128 个 CPU 工作节点，可在约 3 分钟内扩展到解决 PongNoFrameskip-v4。最大训练吞吐量达到约 30k 转换/秒（约 120k 环境帧/秒）。#

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

class ray.rllib.algorithms.impala.impala.IMPALAConfig(algo_class=None)[source]#

定义一个可用于构建 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()

training(*, 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) → Self[source]#

设置与训练相关的配置。

参数:

vtrace – V-trace 参数 (请参阅 vtrace_tf/torch.py)。
vtrace_clip_rho_threshold
vtrace_clip_pg_rho_threshold
num_gpu_loader_threads – GPU 加载器线程数（每个 Learner 工作线程），用于在适用时将传入的（CPU）批次加载到 GPU。传入的批次由每个 Learner 的 LearnerConnector 流水线生成。在 GPU 上加载批次后，线程会将它们放入另一个队列，供 Learner 线程（每个 Learner 工作线程只有一个）拾取并执行 forward_train/loss 计算。
num_multi_gpu_tower_stacks – 对于每个多 GPU 塔堆栈，应预留多少个槽以供并行数据加载？将其设置为 >1 以并行加载数据到 GPU。这将按堆栈数量成比例地增加 GPU 内存使用量。示例：2 个 GPU 和 num_multi_gpu_tower_stacks=3：- 一个塔堆栈由 2 个 GPU 组成，每个 GPU 都有一个模型/图的副本。- 每个堆栈将在其每个 GPU 上创建 3 个批次数据槽，将每个 GPU 的内存要求提高 3 倍。- 这使我们能够在另一个堆栈执行梯度计算时预加载数据到这些堆栈。
minibatch_buffer_size – 应保留多少个训练批次用于小批量处理。仅当 num_epochs > 1 时，此配置才有效。
replay_proportion – 设置为 >0 以启用经验回放。保存的样本将以 p:1 的比例与新数据样本一起回放。
replay_buffer_num_slots – 要为回放存储的样本批次数。总共保存的转换数将是（replay_buffer_num_slots * rollout_fragment_length）。
learner_queue_size – 输入学习器的训练批次的 max 队列大小。
learner_queue_timeout – 在小批量缓冲区队列中等待训练批次可用的秒数。这可能需要增加，例如在与较慢的环境进行训练时。
timeout_s_sampler_manager – 等待工作线程采样结果的超时时间——通常如果太低，管理器将无法检索到已准备好的采样结果。
timeout_s_aggregator_manager – 等待回放工作线程结果的超时时间——通常如果太低，管理器将无法检索到已准备好的回放请求。
broadcast_interval – 在权重广播到在任何迭代中采样的 rollout 工作线程之前的训练步数调用。
grad_clip – 如果指定，则将梯度的全局范数裁剪为此值。
opt_type – “adam”或“rmsprop”。
lr_schedule – 学习率计划。格式为 [[时间步，学习率值]，[时间步，学习率值]，……] 中间时间步将被分配给插值的学习率值。计划应通常从时间步 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 以拥有两个单独的优化器来优化策略和价值网络。仅支持某些算法（APPO、IMPALA）在旧 API 栈上。
_lr_vf – 如果 _separate_vf_optimizer 为 True，则为价值网络定义单独的学习率。

返回：

此更新后的 AlgorithmConfig 对象。

基于模型的强化学习#

DreamerV3#

[论文] [实现] [RLlib readme]

另请参阅此处的 README 以获取有关如何运行 DreamerV3 实验的更多详细信息。

../_images/dreamerv3-architecture.svg — **DreamerV3 架构：** DreamerV3 以监督方式训练一个循环 WORLD_MODEL，使用从回放缓冲区采样的真实环境交互。世界模型的目的是正确预测强化学习环境的转换动态：下一个观察、奖励和一个布尔继续标志。DreamerV3 仅在合成轨迹上训练 actor 和 critic 网络，这些轨迹由 WORLD_MODEL “梦见”。该算法在两个轴上进行扩展，支持多个 `EnvRunner` actor 进行样本收集，以及多个基于 GPU 或 CPU 的 `Learner` actor 进行模型更新。它还可以用于不同类型的环境，包括具有图像或向量观察、连续或离散动作以及稀疏或密集奖励函数的环境。#

调优示例： Atari 100k、Atari 200M、DeepMind Control Suite

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

../_images/pong_1_2_and_4gpus.svg — Pong-v5 环境的平均回合奖励（在“100k”设置下，只允许 100k 个环境步数）：请注意，尽管样本效率稳定——由每个环境步数的恒定学习性能所示——但当我们从 1 个 GPU 扩展到 4 个 GPU 时，实际时间几乎呈线性增长。左：按采样环境时间步数计算的回合奖励。右：按实际时间计算的回合奖励。#

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

../_images/atari100k_1_vs_4gpus.svg — 在 1 个和 4 个 GPU 上各种 Atari 100k 任务的平均回合奖励。左：按采样环境时间步数计算的回合奖励。右：按实际时间计算的回合奖励。#

DeepMind Control Suite（视觉）结果（1 vs 4 个 GPU）:

../_images/dmc_1_vs_4gpus.svg — 在 1 个和 4 个 GPU 上各种 Atari 100k 任务的平均回合奖励。左：按采样环境时间步数计算的回合奖励。右：按实际时间计算的回合奖励。#

离线 RL 和模仿学习#

行为克隆 (BC)#

[论文] [实现]

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

调优示例： CartPole-v1 Pendulum-v1

BC 特定配置（另请参阅通用算法设置）

class ray.rllib.algorithms.bc.bc.BCConfig(algo_class=None)[source]#

定义一个可以从中构建新的 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/offline/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/offline/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()

training(*, 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) → Self#

设置与训练相关的配置。

参数:

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 特定配置（另请参阅通用算法设置）

class ray.rllib.algorithms.cql.cql.CQLConfig(algo_class=None)[source]#

定义一个可以从中构建 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()

training(*, 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) → Self[source]#

设置与训练相关的配置。

参数:

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

返回：

此更新后的 AlgorithmConfig 对象。

隐式 Q 学习 (IQL)#

[论文] [实现]

IQL 架构： IQL（隐式 Q 学习）是一种离线 RL 算法，它从不需要评估数据集之外的动作，但仍能通过泛化使学习到的策略在数据中的最佳行为上获得显著的改进。它不进行标准的 TD 误差最小化，而是引入一个通过分位回归训练的值函数，该函数产生对回报的保守估计。这使得策略可以通过优势加权行为克隆来改进，从而在仅使用数据集内的动作的情况下实现安全的泛化。

IQLLearner 将常规的基于 TD 的价值损失替换为分位回归损失，并训练策略模仿高优势动作——从而能够仅使用数据集内的动作，在行为策略上获得显著的性能提升。

调优示例： Pendulum-v1

IQL 特定配置（另请参阅通用算法设置）

class ray.rllib.algorithms.iql.iql.IQLConfig(algo_class=None)[source]#

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

from ray.rllib.algorithms.iql import IQLConfig
# Run this from the ray directory root.
config = IQLConfig().training(actor_lr=0.00001, gamma=0.99)
config = config.offline_data(
    input_="./rllib/offline/tests/data/pendulum/pendulum-v1_enormous")

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

from ray.rllib.algorithms.iql import IQLConfig
from ray import tune
config = IQLConfig()
# 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/offline/tests/data/pendulum/pendulum-v1_enormous"
)
# Set the config object's env, used for evaluation.
config.environment(env="Pendulum-v1")
# Use to_dict() to get the old-style python config dict
# when running with tune.
tune.Tuner(
    "IQL",
    param_space=config.to_dict(),
).fit()

设置与训练相关的配置。

参数:

beta – 用于缩放指数项中优势的温度。必须 >> 0.0。此参数越高，策略的贪婪性（剥削性）越低。这也意味着策略对数据集中的最佳动作的拟合度较低。
twin_q – 是否应使用双 Q 架构（建议）。
expectile – 在值函数的期望回归中使用的期望值。对于较高的期望值，值函数会尝试匹配 Q 值分布的上尾。
actor_lr – actor 网络学习率。actor 学习率大于 critic 学习率在实验中效果较好。
critic_lr – Q 网络学习率。critic 学习率大于值函数学习率在实验中效果较好。
value_lr – 值函数网络的学习率。
target_network_update_freq – 目标 Q 网络固定之间的时步数。请注意，过高的值可能会损害收敛性。目标网络通过 Polyak 平均更新。
tau – 目标 Q 网络 Polyak 平均的更新参数。此值越高，权重向实际 Q 网络移动的速度越快。

返回：

此更新的 AlgorithmConfig 对象。

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

[论文] [实现]

../_images/marwil-architecture.svg — **MARWIL 架构：** MARWIL 是一种混合模仿学习和策略梯度算法，适用于在批量历史数据上进行训练。当 `beta` 超参数设置为零时，MARWIL 目标会缩减为纯模仿学习（参见 BC）。MARWIL 使用 Ray. Data 来利用其并行数据处理能力。在一个训练迭代中，MARWIL 由 n 个 DataWorker 并行从离线文件（例如 parquet）读取剧集。Connector 流水线将这些剧集预处理成训练批次，并将它们作为数据迭代器直接发送给 n 个 Learner 进行模型更新。#

调优示例： CartPole-v1

MARWIL 特定配置（另请参阅通用算法设置）

class ray.rllib.algorithms.marwil.marwil.MARWILConfig(algo_class=None)[source]#

定义一个可以从中构建 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 / "offline/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 / "offline/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 的主要思想是（与“主”策略并行）训练一个世界模型来预测环境的动态。世界模型的损失是 `ICMLearner` 添加到环境（外部）奖励中的内部奖励。这确保了在环境中相对未知（世界模型在预测接下来会发生什么方面表现不佳）的区域，人工内部奖励很大，并且代理被激励去探索这些未知区域。RLlib 的好奇心实现与 RLlib 的任何算法都可以协同工作。请参阅此处关于在 PPO 和 DQN 之上实现的示例链接。ICM 按原样使用所选算法的 `training_step()`，然后在 `LearnerGroup.update` 期间执行以下附加步骤：复制“主”策略的训练批次，并使用它来执行 ICM 的自监督更新。使用 ICM 计算内部奖励，并将它们添加到外部（环境）奖励中。然后继续更新“主”策略。#

调优示例： 12x12 FrozenLake-v1