1、RL 开源系统
在 LLM 迈向人类认知水平与复杂任务泛化能力的进程中，RLHF 和推理能力的突破性提升，已成为技术进化的两大核心驱动力。然而，我们也面对两个问题：如何在算法效率与系统灵活性之间找到平衡，同时打破技术复现的壁垒？
当前，RLHF 虽被广泛用于模型对齐，但其分布式训练与生成阶段复杂的计算图拓扑、控制器调度冗余、通信开销高昂等问题，使得传统框架难以适配大规模 LLM 训练需求。另一方面，尽管推理能力被视为 LLM 智能涌现的关键，但主流技术报告的 “黑箱化” 却让社区陷入复现困境 —— 缺乏透明的技术细节与可扩展的工程实践，阻碍了领域研究的迭代速度。
本文聚焦于针对 RLHF 的分布式计算效率问题，提出的混合流（HybridFlow）框架，以及针对推理强化学习的技术复现困境，开源 DAPO 算法与全栈训练系统两项工作。
2、HybridFlow：一个灵活且高效的 RLHF 框架
RLHF 在 LLM 校准方面得到了广泛应用。传统的强化学习可以建模为一种数据流，其中每个节点代表一个神经网络（NN）的计算过程，每条边表示神经网络之间的数据依赖关系。RLHF 通过将每个节点扩展为一个分布式的 LLM 训练或生成程序，将每条边扩展为多对多的组播，从而使数据流变得更加复杂。传统的强化学习框架使用单个控制器来执行数据流，该控制器既负责指示节点内的计算，又负责节点间的通信。在 RLHF 中，由于分布式节点内计算的控制调度开销较大，这种方式可能效率不高。现有的 RLHF 系统采用多控制器范式，由于分布式计算和数据通信的嵌套，这种范式可能不够灵活。
混合流（HybridFlow），以混合的方式结合了单控制器和多控制器范式，以便能够灵活地表示 RLHF 数据流，并高效地执行该数据流。研究员精心设计了一组分层的 API，这些接口对复杂的 RLHF 数据流中的计算和数据依赖关系进行了解耦和封装，从而实现了高效的操作编排，以实现 RLHF 算法，并能够将计算灵活地映射到各种设备上。
研究员进一步设计了一个三维混合引擎（3D-HybridEngine），用于在训练和生成阶段之间高效地对演员模型（actor model）进行重分片，实现零内存冗余，并显著降低通信开销。
2.1、引言
RLHF 建立在传统的强化学习算法之上，例如 PPO 和 REINFORCE。被广泛采用的 PPO-based RLHF 系统通常由四个 LLM 组成：一个策略网络（actor）、一个价值网络（critic）、一个参考策略网络和一个奖励模型。PPO-based RLHF 以迭代的方式进行，每次迭代包含三个阶段：
- 使用策略网络模型和一批提示生成回复
- 通过价值网络、参考策略网络和奖励模型的一次前向传播对生成的回复进行评分，从而准备训练数据
- 通过前向和反向计算更新策略网络和价值网络，从人类偏好中学习
其他 RLHF 变体遵循类似的阶段，但涉及不同数量的模型以及模型之间不同的数据依赖关系。
传统的强化学习可以建模为一种数据流，它是一个有向无环图（DAG）：强化学习数据流中的每个节点代表一个神经网络的计算过程（例如，策略网络或价值网络，它们可以是卷积神经网络（CNN）或多层感知机（MLP））；每条边表示神经网络计算之间的数据依赖关系（例如，价值网络的输出用作策略网络训练的输入）。
RLHF 数据流更为复杂，涉及更复杂的模型（例如，用于策略网络 / 价值网络 / 参考网络 / 奖励模型的 LLM），每个模型都运行不同的计算，并且它们之间的数据依赖关系更加多样（即，分布式模型分区之间的多对多组播）。在 RLHF 数据流中，LLM 的训练和生成需要分布式计算（例如，使用张量并行 / 流水线并行 / 数据并行）。因此，RLHF 数据流中的每个节点都是一个复杂的分布式程序，对应于各个 LLM 的分布式计算。不同节点中的模型由于其工作负载不同，通常会使用不同的并行策略。边代表数据重分片，这通常是一种多对多的组播。因此，对复杂且资源密集型的 RLHF 进行灵活表示和高效执行势在必行。
诸如 RLLib 和 RLLib Flow 等传统的强化学习框架利用分层单控制器范式来运行强化学习数据流。一个集中式控制器将数据流中的节点分配给不同的进程，并协调它们的执行顺序。每个节点进程可以进一步生成更多的工作进程来执行计算，同样遵循单控制器范式。然而，它们仅提供用于数据并行训练的原语，并且局限于最大规模为几百兆字节的神经网络。在 RLHF 数据流中，每个节点对应一个 LLM，该模型包含多达数十亿个操作，需使用一些复杂的并行方式进行计算。由于将操作调度到分布式加速器上的开销巨大，单控制器范式的效率并不高。
现有的 RLHF 系统采用多控制器范式来管理节点内的计算和节点间的数据重分片。每个控制器独立管理一个设备的计算，并使用多个点对点操作来协调不同节点之间的数据依赖关系。在执行 LLM 计算时，这种多控制器范式引入的调度开销可以忽略不计。
然而，由于缺乏中央控制，实现各种 RLHF 数据流时不够灵活，因为修改单个节点以适应不同的数据依赖关系需要更改所有依赖节点的实现，这阻碍了代码的复用。
为了解决这些限制，研究员提出了混合流（HybridFlow），这是一个灵活且高效的 RLHF 框架，能够轻松表示和执行各种 RLHF 数据流，并实现高吞吐量。
其关键发现是，在节点间层面使用单控制器范式能够以最小的开销灵活表达各种数据依赖关系，并轻松协调节点间的数据重分片，而在节点内计算中集成多控制器范式则可大幅提高计算效率。
HybridFlow 提倡使用分层混合编程模型来生成 RLHF 数据流。在节点层面，提供了多个模型类，这些类将数据流中不同 LLM 的分布式计算（训练、推理和生成）封装到 API 中。这些 API 可以无缝支持现有 LLM 框架中的各种并行策略，包括三维并行、ZeRO 和 PyTorch FSDP，并在多控制器范式下执行分布式计算。在节点之间，设计了一组传输协议，以在单个控制器的协调下，向用户隐藏数据重分片的复杂性。这种编程模型抽象掉了分布式计算的复杂性，使用户能够用几行代码实现一个RLHF数据流，并通过单控制器的单个进程运行 RLHF。它还有效地解耦了节点内的计算和节点间的数据传输，允许对每个模型进行独立优化，而无需更改数据流中其他模型的代码。
在 RLHF 数据流中，策略网络模型的训练和生成是主要的计算任务。同时进一步设计了一个三维混合引擎（3D-HybridEngine），以高效执行策略网络模型的训练和生成任务，在训练阶段和生成阶段之间的模型参数重分片过程中实现零内存冗余，并显著降低通信开销。混合编程模型还便于将模型灵活地放置在相同或不同的一组 GPU 设备上。这使其能够提供一种有效的算法，针对任何 RLHF 数据流，对不同规模和不同工作负载的模型，优化 GPU 的分配和放置。HybridFlow 总结如下：
- 提出了一种分层混合编程模型，用于方便地构建 RLHF 数据流。这种编程模型能够针对各种 RLHF 算法，高效地分布式执行节点内的计算，并灵活地进行节点间的数据重分片和传输
- 设计了一个三维混合引擎（3D-HybridEngine），它能够高效地执行策略网络模型的训练和生成任务，并在训练阶段和生成阶段之间实现零冗余转换
- 设计了一种有效的映射算法，用于自动确定 RLHF 数据流中每个节点（模型）的优化 GPU 分配和放置方案
2.2、背景和动机
2.2.1、RLHF
RLHF 工作流程：如上图工作流程可以分解为三个阶段，以 PPO 为例：
- 生成阶段：策略网络使用自回归生成方法，根据一批提示生成回复
- 准备阶段：利用提示和生成的回复，价值网络计算它们的值，参考策略网络计算它们的参考对数概率，奖励模型计算它们的奖励，所有这些计算都是通过各自模型的一次前向传播来完成的
- 学习 / 训练阶段：使用前几个阶段生成的一批数据以及损失函数，通过 Adam 优化算法来更新策略网络和价值网络
其他 RLHF 算法在很大程度上也遵循这三个阶段的工作流程（上图 (b)(c)）。Safe-RLHF 在近端策略优化带预训练扩展（PPO-ptx）的基础上引入了一个辅助预训练损失项，并且加入了一个额外的成本模型，以便同时拟合人类偏好和安全标签。基于最大回报的RLHF（ReMax）需要额外进行一次生成过程以减少方差，并在数据流中去除了价值网络模型。
并行策略：LLM 在训练和使用时采用数据并行、流水线并行和张量并行策略。采用数据并行（DP）时，输入数据被划分为多个子集；每个子集由一个单独的设备（例如，一块 GPU）进行处理。
ZeRO 是一种针对数据并行训练的内存优化解决方案，它逐步在多个 GPU 之间对优化器状态、梯度和模型参数进行分片。流水线并行（PP）和张量并行（TP）则在多个 GPU 之间分配模型参数、梯度和优化器状态。像 Megatron-LM 和 MegaScale 这样的现代分布式训练框架采用三维并行或 PTD 并行，其中 P、T、D 分别代表流水线并行、张量并行和数据并行。在三维并行中，流水线并行的规模表示模型训练中流水线阶段的数量，张量并行的规模指的是一个张量被划分成的分片数量，数据并行的规模是模型副本的数量。LLM 的服务系统采用与训练时类似的三维并行方式，不过仅对模型参数和键值缓存 KVCache 进行分片。
在 RLHF 数据流中的 LLM 可能会执行不同的计算任务，包括训练（一次前向传播、一次反向传播和模型更新）、推理（一次前向传播）和生成（具有多次前向传播的自回归生成）。特别地，训练和生成是在策略网络模型上执行的，训练和推理在价值网络上执行，而推理在参考策略网络和奖励模型上执行。对于不同的计算任务，可以对不同的模型应用不同的并行策略，以实现最佳的吞吐量。
2.2.2、分布式机器学习编程模型
单控制器：采用一个集中式控制器来管理分布式程序的整体执行流程。借助集中式控制逻辑，用户能够将数据流的核心功能构建为一个单一进程（上图(b)），而控制器会自动生成分布式工作节点来执行计算任务。单控制器范式具备对硬件和数据流图的全局视角，因而可以在数据流任务之间实现灵活且优化的资源映射和执行顺序协调。然而，协调消息需要从控制器传递到所有工作节点，当在大型集群上执行庞大的数据流图时，这会产生显著的调度开销。
多控制器：每个设备（又称工作节点）都有其各自的控制器。最先进的分布式 LLM 训练和服务系统采用多控制器范式，这是因为它具有可扩展性且调度开销较低（控制消息主要通过快速的 PCIe 链路从 CPU 传递到 GPU）。如上图(a)中采用多控制器进行 RLHF 实现的示例所示，每个模型运行一个独立的程序，并且一个模型的所有工作节点都执行相同的程序。每个工作节点仅拥有系统状态的局部视角，并且需要在两个模型之间进行点对点通信（蓝色代码和箭头），以协调模型的执行顺序。为了在多控制器架构中实现 RLHF 工作流程，用户必须精心整合在每个设备上运行的程序中用于集合通信、计算以及点对点数据传输的代码。这就导致了计算和数据传输的代码深度嵌套，给开发、维护和优化带来了挑战。在上图(a)中，每个模型执行局部计算和全收集（all_gather）操作（黑色代码），而 actor 模型必须显式管理向 critic 模型和 reward 模型的发送操作，而 critic 模型和 reward 模型则必须在其程序中的精确位置相应地实现接收操作。
2.2.3、RLHF 特性
异构模型工作负载：在 RLHF 中，actor 模型、critic 模型、参考（reference）模型和奖励（reward）模型可能在不同阶段执行训练、推理或生成操作，它们具有不同的内存占用和计算需求。对于参考策略模型和奖励模型，由于它们仅执行前向传播计算，因此只需要将其模型参数存储在 GPU 内存中。对于 actor 模型和 critic 模型，由于它们要进行模型训练，因此其模型参数、梯度和优化器状态都必须存储。此外，在 RLHF 中，一个较小的 actor 模型（例如，一个 70 亿参数的预训练/微调 LLM ）可以与较大的 critic 模型和奖励模型（例如，700 亿参数的 LLM ）搭配使用，以实现更好的校准。鉴于这种异构性，在 RLHF 过程中运行每个模型时，需要不同的并行策略和针对性的优化措施。
actor 模型训练与生成之间的计算不平衡：在 RLHF 数据流中，actor 模型的训练和生成由两个节点表示（图 1），在每次 RLHF 迭代中，这两个操作通常构成了大部分工作负载（例如，使用 HybridFlow 时，占 RLHF 总时间的 58.9%）。actor 模型的训练受限于计算能力，通常需要更大的模型并行（MP）规模（即模型被划分的分区数量），并将工作负载分配到更多的 GPU 上，例如，将一个 70 亿参数的模型划分为8个分区，在 8 个 GPU 上运行。由于生成操作受限于内存，如果使用相同的并行策略（例如，相同的模型并行规模）进行生成操作，可能会导致 GPU 计算资源的利用率不足。先前的研究表明，将较大的数据并行（DP）规模与较小的模型并行规模相结合（混合数据并行和模型并行），例如，将一个 70 亿参数的模型划分为两个分区，并在 8 个 GPU 上复制 4 次，可以提高生成吞吐量。尽管为 actor 模型的训练和生成使用不同的并行策略可能会优化两个阶段的吞吐量，但在这两个阶段之间的运行时对 actor 模型的权重进行重新分片，可能会产生显著的通信和内存开销。例如，校准一个 700 亿参数的 actor 模型，每次 RLHF 迭代需要从训练阶段到生成阶段传输 140GB 的模型权重，当这两个阶段在不同设备上时，这可能占用迭代时间的 36.4%。
多样化的模型放置要求：根据模型的计算工作负载和数据依赖关系，在 RLHF 数据流中有策略地放置模型是很有必要的。图 3 给出了一个模型放置计划示例以及相应的 RLHF 执行流程。如果不存在数据依赖关系，放置在不同设备组上的模型可以并行执行。放置在同一组 GPU 上的模型（称为共置模型）共享 GPU 内存，并且以分时方式顺序执行，因为如果共置的 LLM 同时执行，很容易发生内存不足（OOM）错误。
鉴于 RLHF 中模型是分阶段执行的，将模型放置在不同设备上可以实现并行处理，但可能不可避免地会导致一些 GPU 处于空闲状态。在图 3 中，actor 模型和 critic 模型分别放置，可以并行进行训练，但在 RLHF 的其他阶段，它们的 GPU 有三分之一的时间处于空闲状态。支持各种放置策略并最大限度地提高设备利用率，对于在任何模型规模和集群规模下优化 RLHF 性能至关重要。
2.2.4、现有 RLHF 系统的局限性
对各种 RLHF 数据流图的支持缺乏灵活性：现有的 RLHF 系统采用多控制器范式来实现数据流。为了实现各种 RLHF 算法，用户必须梳理和管理混合了集合通信、模型计算（可能使用各种分布式训练 / 服务框架）以及点对点数据传输的代码。这种代码结构缺乏模块化 / 功能封装，使得 RLHF 系统与特定的 LLM 训练和服务框架紧密耦合。因此，用户需要针对不同的 RLHF 数据流逐个进行实现和优化，这阻碍了代码复用，并增加了出错的风险。现有的 RLHF 框架仅支持近端策略优化（PPO）算法。此外，由于实现的复杂性，所支持的并行策略有限。例如，为了在 DeepSpeed-Chat 中纳入用于 LLM 训练和生成的三维并行策略，由于代码结构混合，可能不得不重新实现整个系统。
RLHF 执行效率低下：表 1 总结了现有 RLHF 系统所采用的并行策略、模型放置方式和执行模式。DeepSpeed-Chat 和 OpenRLHF 在 actor 模型训练时采用 ZeRO-3 方法，在 actor 模型生成时采用张量并行（TP）方法。OpenRLHF 在不同设备上使用 actor 模型的不同副本进行训练和生成，这导致了内存的冗余使用以及设备之间频繁的权重同步。DeepSpeed-Chat 在同一组设备上为训练和生成维护 actor 模型的相同副本，并在训练和生成之间对模型权重进行重新分片（因为两个阶段使用了不同的并行策略），对于大型模型来说，这仍然可能会产生大量的内存和通信开销。NeMo-Aligner 在 actor 模型的训练和生成中使用相同的三维并行配置，其生成吞吐量较低。
如表 1 所示，现有的 RLHF 框架局限于一种模型放置计划，因此也局限于一种 RLHF 执行模式。实现不同的放置方式很困难，需要改变模型初始化的内部逻辑和节点间的数据传输，如图 2 中蓝色突出显示的部分。OpenRLHF 和 NeMo-Aligner 允许在准备阶段和学习阶段进行并发模型计算；在生成阶段，除 actor 模型外的其他模型都处于空闲状态，浪费了它们所占用的 GPU 资源。DeepSpeed-Chat 将所有模型共置在同一组设备上，并且每个设备根据 RLHF 数据流顺序运行每个模型。由于模型之间的工作负载不平衡，这种放置方式在资源利用方面可能效率低下。
2.2.5、设计考虑因素
为了解决现有系统的局限性，关键问题是：
如何设计一个灵活高效的编程模型来实现 RLHF 数据流？单控制器设计在节点间层面具有特别的优势，因为它在协调不同模型的分布式计算之间的数据传输、执行顺序和资源虚拟化方面具有灵活性。RLHF 数据流图通常只包含几个节点。与数据流中节点（模型）所需的分布式计算相比，从单控制器向不同节点发送控制消息所产生的开销可以忽略不计。多控制器范式以其向加速器调度算子的低延迟而著称，可以在每个模型的分布式计算中加以利用。基于这些见解，作者提出了一种分层混合编程模型来实现 RLHF 数据流。关键设计原则是以混合的方式结合单控制器和多控制器范式。这种设计确保了 RLHF 数据流的灵活表达和高效执行，在节点间和节点内层面都保持较低的控制开销。
如图 2(b) 所示，这种范式将节点内的分布式计算与节点间的数据传输解耦，使每个模型能够专注于本地计算，而无需管理节点间的通信。
2.3、HybridFlow概述
上图展示了 HybridFlow 的架构，它主要由三个部分组成：混合编程模型、三维混合引擎（3D-HybridEngine）和自动映射算法。混合编程模型包含一组分层的 API，可实现对 RLHF 数据流的灵活表达，以及对数据流中模型的高效计算。3D-HybridEngine 是专门为 actor 模型的高效训练和生成而设计的，它允许在两个阶段采用不同的三维并行配置，并能在两个阶段的转换过程中实现零内存冗余和最小化的通信开销。自动映射算法可确定每个模型的优化设备放置方案，以最大化 RLHF 的吞吐量。
RLHF 系统的工作流程如下。用户提供以下输入来启动 RLHF 系统：
(i) 模型规格，包括 RLHF 数据流中 actor / critic /参考策略/奖励模型的架构和规模；
(ii) 数据流中模型的设备放置方案，这是在给定的 GPU 集群配置下运行自动映射算法得到的；
(iii) 每个阶段中运行每个模型的并行策略，例如，对于三维并行策略，用一个元组 (p, t, d) 表示，其中 p、t、d 分别代表流水线并行（PP）规模、张量并行（TP）规模和数据并行（DP）规模。
单控制器程序接收这些输入，以初始化 RLHF 数据流中的模型和虚拟化资源池，根据放置方案将操作/模型调度到设备上，并调用设备上多个控制器运行的函数来执行每个模型的分布式计算。
多控制器程序实现了并行工作节点（Parallel-Worker）类：它根据每个模型的并行策略，在分配的设备中构建每个模型的并行组，调用 3D-HybridEngine 进行 actor 模型的训练和生成，并且可以与现有的 LLM 引擎 无缝集成，用于其他模型的训练、推理和生成。传输协议由单控制器程序协调，以支持在具有不同并行策略的模型之间对数据（包括 RLHF 中的提示、响应和其他模型输出）进行重新分片。actor 模型在训练和生成阶段之间的数据重新分片由 3D-HybridEngine。
2.4、混合编程模型
2.4.1 分层 API
节点内：封装分布式程序。对于 RLHF 不同阶段中每个模型的分布式计算，作者提供了一个基类，即三维并行工作节点（3DParallelWorker）。在给定已分配设备的情况下，它有助于分布式模型权重的初始化，并为每个模型建立三维并行组。一个并行组包含一组 GPU，用于承载模型特定的并行维度，例如，张量并行中的不同张量分片以及数据并行中的不同模型副本。图5(a)展示了使用我们的API对 actor 模型进行初始化的过程，其他模型的初始化过程类似。
作者提供了几个分别对应 actor 、critic、参考和奖励模型的模型类，它们都继承自三维并行工作节点类。这些模型类中的每一个都封装了 API，以实现模型的分布式前向和反向计算、自回归生成以及优化器更新，将分布式计算代码与其他模型的数据依赖关系解耦。这些 API 可以通过复用现有 LLM 系统中的计算脚本来轻松实现。例如，actor 工作节点类（ActorWorker，actor 模型的类）中 update_actor 函数所涉及的计算过程与 Megatron-LM 中的预训练脚本类似。一个模型类封装了用于实现各种 RLHF 算法的基本操作，例如， actor 模型类中的 generate_sequences 函数用于根据提示生成响应，奖励模型类中的 compute_reward 函数用于通过前向传播评估响应。
除了实现三维并行的基类三维并行工作节点外，作者还进一步提供了用于 PyTorch 全分片数据并行（FSDP，即 FSDPWorker）和 ZeRO（即 ZeROWorker）的基类，以及继承每个基类的相应模型类，以支持模型计算中不同的并行策略。图4 中的 ParallelWorker 表示这些基类中的一个。
节点间：统一模型间的数据重新分片实现。在不同设备上采用不同并行策略的模型之间进行数据传输时，会涉及多对多多播操作。作者通过使用 @register 将每个模型类中的每个操作与一个传输协议相关联，来统一这种数据传输的实现方式。每个传输协议由一个收集函数和一个分发函数组成，用于根据每个模型的并行策略聚合输出数据并分发输入数据。
在 图5(a) 的示例中，update_actor 操作被注册到传输协议 3D_PROTO，因为 actor 模型的训练采用了三维并行策略。在 3D_PROTO 中，收集函数会将每个数据并行（DP）组中相应模型函数的所有输出数据（例如，从 update_actor 返回的损失标量）收集到单控制器中，而分发函数会将输入数据（例如，update_actor 所需的优势值）分发给每个数据并行组中的已注册函数。通过使用源模型的输出收集函数和目标模型的输入分发函数来实现数据的重新分片。图5(b) 展示了 actor 模型（生成阶段）和 critic 模型（推理阶段）之间的数据重新分片过程，其中两个模型的计算采用了不同的三维并行策略。单控制器使用 actor 模型的 3D_PROTO 中的收集函数收集数据期货（步骤 1 - 3），并将其发送给 critic 模型（步骤 4）；critic 模型使用其 3D_PROTO 中的分发函数将接收到的数据期货分发给每个数据并行组（步骤 5）。然后，从 actor 模型到 critic 模型检索远程数据，critic 模型的每个 GPU仅根据其数据并行等级获取 actor 模型输出数据中所需的本地批次数据（步骤6）。实际的数据传输仅发生在 GPU之间，避免了任何中心瓶颈问题。
作者提供了 8 种传输协议，包括 3D_PROTO、DP_PROTO、ONE_TO_ALL 等，这些协议涵盖了大多数数据重新分片的场景。用户可以通过实现自定义的收集和分发函数来进一步扩展传输协议。
促进灵活的模型放置。作者提供了一个ResourcePool类，它对一组 GPU设备进行了虚拟化。当将一个ResourcePool实例应用于一个模型类时（图5(a)），该模型的分布式计算将被映射到这些设备上。使用相同ResourcePool实例的模型会被共置于同一组 GPU上；当在不同模型类中应用不同的ResourcePool实例时，模型会被放置在不同的设备组上。我们假设不同的ResourcePool实例之间没有重叠。
异步数据流执行。当模型被放置在不同的设备组上时，一旦它们的输入可用，其执行就会自动触发。在图 5(b) 中，actor 模型的数据期货在控制器调用后会立即返回（步骤 1 - 3）；然后控制器会发起对 critic 模型的新调用，并按照传输协议分发这些期货（步骤 4 - 5）。当一些模型被放置在同一组设备上时，它们会根据调用顺序依次执行。通过编程模型，HybridFlow 能够灵活地支持各种分布式执行模式，而无需对 RLHF 算法进行任何代码更改（图 6）。
2.4.2、不同 RLHF 算法的实现
API 能够简化各种 RLHF 算法（数据流）的开发。用户可以用几行代码将一个 RLHF 算法实现为一个在单控制器上运行的单进程程序，这涉及一系列对原始 API 的调用，以调用模型的分布式计算。图6 给出了 PPO、ReMax 和 Safe-RLHF 算法的示例。通过调用包括 compute_values 和 generate_sequences 等模型操作，PPO 算法仅用 8 行代码即可实现，这些操作在多个 GPU 上的多控制器范式下执行。为了适应 Safe-RLHF 算法（该算法集成了一个额外的成本模型来评估安全偏好以及 actor 模型的预训练损失），只需在 PPO 算法实现的基础上再添加 5 行代码。为了适应 ReMax 算法，只需要额外调用一次 actor 模型的生成操作，并且可以删除与 critic 模型相关的代码。
实现灵活性。这种扩展的灵活性对于研究人员探索不同的 RLHF 算法至关重要：他们可以复用每个模型类中封装的分布式计算，并根据特定算法（如广义优势估计（GAE）以及 actor 模型和 critic 模型的 compute_advantage 函数和损失函数中的 KL 散度）简单地调整数值计算的代码。这种简化的开发得益于混合编程模型。模块化 API 设计简化了开发过程，促进了广泛的代码复用，并能够直接整合现有 LLM 训练/服务框架的代码库。它还将模型计算与模型之间的数据传输解耦。分布式框架中的任何变化都不会影响 RLHF 算法的代码（图6），从而能够对每个模型的执行进行个性化优化。支持对具有不同工作负载的模型进行灵活放置，能够将 RLHF 数据流优化映射到各种设备上。
2.5、3D-HybridEngine
三维混合引擎（3D-HybridEngine），旨在支持 actor （actor）模型的高效训练和生成，目标是大幅提升 RLHF 的吞吐量。
2.5.1、并行组
为了消除 actor 模型的冗余副本，作者主张在同一组设备（分配给 actor 模型的 $N_a$ 个 GPU）上部署 actor 模型的训练和生成阶段，并在 actor 模型权重的同一副本上依次执行这两个阶段的操作。尽管如此，actor 模型的训练和生成很可能采用不同的三维并行策略，也就是说，与训练阶段相比，生成阶段通常需要更小的张量并行（TP）规模和流水线并行（PP）规模，但需要更大的数据并行（DP）规模。在这种情况下，三维混合引擎能够在同一组设备上，在 actor 模型的训练和生成阶段之间实现高效的模型参数重新分片。
令 $p-t-d$ 表示为 actor 模型训练构建的三维并行组，它对应于一组用于承载 $p$ 个流水线阶段、 $t$ 个张量分片和 $d$ 个模型副本的 GPU。三维混合引擎根据 actor 模型训练和生成阶段不同的三维并行策略，分别为这两个阶段构建不同的并行组。用 $p_g$ 、 $t_g$ 和 $d_g$ 分别表示生成阶段中生成流水线并行组的规模、生成张量并行组的规模和微数据并行组的规模。$d_g$ 表示生成阶段中模型副本数量与训练阶段中模型副本数量的比例，也就是说，训练阶段中的每个数据并行副本会变成 $d_g$ 个微数据并行副本，以处理 $d_g$ 个微批次的提示和响应。有 $N_a = p×t×d = p_g×t_g×d_g×d$ ，因此 $d_g = \frac{pt}{p_gt_g}$ 。微数据并行组专门用于 actor 模型的生成阶段，以实现更大的数据并行规模，从而充分利用设备资源。生成阶段的并行组表示为 $p_g-t_g-d_g-d$ 。
2.5.2、3D-HybridEngine 工作流程
在 RLHF 的第 $i$ 次迭代中的 actor 模型训练阶段和第 $i + 1$ 次迭代中的 actor 模型生成阶段之间，需要根据这两个阶段的并行组配置，对 actor 模型参数进行重新分片，并分发提示数据。在 RLHF 的第 $i + 1$ 次迭代中，三维混合引擎收集在第 $i$ 次迭代中更新的 actor 模型参数（图 7 中的步骤 1），以便在每个微数据并行组内进行生成操作。然后，将一批提示数据加载到每个模型副本中（步骤 2），并生成响应（RLHF 的生成阶段）。在此之后，三维混合引擎对每个微数据并行组内的生成结果执行全收集（all-gather）操作（步骤 3），并根据 actor 模型训练的三维并行策略对模型参数进行重新划分（步骤 4）。在正确重新分配了模型权重、提示和响应之后，计算 actor 模型的损失，并按照 RLHF 算法更新 actor 模型的权重（步骤 5），即第 $i + 1$ 次迭代的 actor 模型训练阶段。
2.5.3、零冗余模型重新分片
三维并行中的并行分组方法通常如下：流水线并行组和张量并行组分别通过为流水线阶段和张量分片分配连续的等级来形成；数据并行组通过以固定间隔选择等级来构建，间隔由流水线并行规模和张量并行规模的乘积决定。
在图 8(a) 中， actor 模型训练使用 $1-4-2$ 的三维并行组：所有 GPU 构成一个流水线并行组（为了说明清楚）；张量并行组是 $[G1, G2, G3, G4]$ 、 $[G5, G6, G7, G8]$ ，数据并行组是 $[G1, G5]$ 、 $[G2, G6]$ 、 $[G3, G7]$ 、 $[G4, G8]$ 。假设使用相同的并行分组方法，但并行规模不同，例如图8(a)中生成阶段使用 $1-2-2-2$ 的并行规模。在从训练阶段过渡到生成阶段的过程中，三维混合引擎在模型并行组之间应用全收集操作来聚合所有参数，然后根据设备所属的并行组，仅在每个设备上保留用于生成操作的一部分模型权重。在一些 GPU （例如 $G2$ 、 $G3$ 、 $G6$ 、 $G7$）上，训练阶段和生成阶段的模型权重没有重叠，并且还需要单独的内存来保存后续训练所需的权重（图 8(a) 中的灰色框）。当三维混合引擎在两个阶段都使用上述常规并行分组方法时，将该系统称为 HybridFlow-V。
进一步为三维混合引擎设计一种新的并行分组方法，用于生成阶段，该方法消除了权重存储中的冗余，并由于 actor 模型在训练和生成阶段之间的重新分片，使得内存占用和通信开销降至最低。具体来说，通过以 $\frac{t}{t_g}$ 和 $\frac{p}{p_g}$ 确定的固定间隔选择等级来形成生成阶段的张量并行组和流水线并行组，并通过沿着生成阶段的张量并行或流水线并行维度顺序分配等级来构建微数据并行组。在图 8(b) 中，生成阶段使用 $1-2-2-2$ 的并行组：生成阶段的张量并行组是 $[G1, G3]$ 、 $[G2, G4]$ 、 $[G5, G7]$ 、 $[G6, G8]$ ；微数据并行组是 $[G1, G2]$ 、 $[G3, G4]$ 、 $[G5, G6]$ 、 $[G7, G8]$ 。这种对生成阶段并行组的策略性重新排列，使得每个设备上训练阶段和生成阶段的模型权重产生重叠，从而能够在生成阶段复用训练阶段的权重，并且由于模型重新分片，设备内存使用中实现零冗余。此外，三维混合引擎同时进行多个全收集操作，每个微数据并行组内进行一个，这大大减少了通信开销。
2.5.4、过渡开销
在 表 2 中，比较了不同 actor 模型引擎设计在训练和生成阶段之间的过渡过程中的通信开销和内存占用情况。
假设 actor 模型的规模为 $M$ ，并且使用 $N_a$ 个 GPU 进行其训练和生成操作。DeepSpeed-Chat 中的 actor 模型引擎在过渡过程中对所有 GPU 执行全收集操作；HybridFlow-V 在训练阶段的张量并行组和流水线并行组内执行此全收集操作。根据计算，这些操作的通信量对于 DeepSpeed-Chat 是 $\frac{N_a - 1}{N_a}M = \frac{t_pd - 1}{t_pd}M$ ，对于HybridFlow-V是 $\frac{t_p - 1}{t_p}M$ 。这两个引擎在随后根据生成阶段的并行组划分模型状态之前，都会在每个 GPU 的内存中聚合所有模型参数，从而导致模型参数的峰值内存使用量为 $M$ 。由于它们在一些 GPU 上无法在生成阶段复用训练阶段的权重，因此需要在这些处理器上保留训练阶段的权重，这分别导致了 $\frac{1}{t_pd}$ 和 $\frac{1}{t_p}$ 的冗余内存消耗。
通过为生成阶段设计的并行分组方法，HybridFlow 将全收集操作限制在每个微数据并行组内。通信开销降低到 $\frac{d_g - 1}{t_p}M = \frac{t_p - t_gt_p}{t_gt_pt_p}M$ 。每个 GPU 只需在其微数据并行组内收集远程参数，并且可以在生成阶段复用训练阶段的权重。因此，HybridFlow 中模型参数的峰值内存使用量恰好与生成阶段每个 GPU 上的模型分区大小匹配，消除了 GPU 内存使用中的任何冗余。
2.6、自动设备映射
混合编程模型要求用户输入以下配置，这些配置被称为 RLHF 数据流到给定设备的映射：(a) 数据流中模型的设备放置方案；(b) 每个阶段中运行每个模型的相应并行策略。
作者为用户提供了一种高效的算法（算法 1），用于确定在给定的设备集群上执行 RLHF 数据流的优化映射，该映射可使每次 RLHF 迭代的端到端延迟最小化。
给定一个数据流 $D$ ，首先在给定的集群中探索所有可能的模型放置方案 $P$ （第 3 行）。例如，近端策略优化（PPO）算法涉及四个模型，这会产生 15 种可能的放置方案（根据贝尔划分问题），范围从所有模型都放置在不同设备上的完全独立放置方案（例如 OpenRLHF 的放置方案）到所有模型都共置于同一组设备上的方案（例如 DeepSpeed-Chat 的放置方案）。将同一组 GPU 上的共置模型称为一个共置集合。一个共置集合中的模型可以在同一组 GPU 上采用不同的并行策略。根据共置模型的内存消耗，确定分配给每个共置模型集合的最小 GPU 数量 $A_{min}$ ，以确保不会出现内存不足错误（第9行）。
接下来，从 $A_{min}$ 中的最小 GPU 分配量开始，列举分配给每个共置模型集合的所有可行设备分配方案（第 10 - 12 行）。给定对共置集合的设备分配 $A$ 以及该集合中模型的计算工作负载 $W$ ，在自动并行（auto_parallel）模块中为每个模型探索优化的并行策略，以使模型执行延迟最小化。工作负载 $W$ 包括每个模型的输入和输出形状以及计算操作（训练、推理或生成）。在自动并行模块中，使用一个模拟器模块 $simu$ 来估计不同并行策略的延迟。
$d_cost$ 模块通过遍历数据流图中的所有阶段并将所有阶段的延迟相加，来估计在给定的模型放置方案和并行策略下 RLHF 数据流的端到端延迟（第17、25行）。对于同一共置集合中且在同一阶段涉及计算操作的模型（例如在 RLHF 训练阶段中 actor 模型和 critic 模型都执行模型更新操作），将它们的执行延迟相加（第 32 行）。对于不同共置集合中的模型，它们在同一阶段的执行可以并行化，该阶段的延迟由不同集合中的最大执行时间决定（第 33 行）。确定模型的最佳设备放置方案及其相应的并行策略，以实现每次 RLHF 迭代的最小执行时间（第 18-23 行）。
算法 1 的时间复杂度为 $O(\frac{(N - 1)!}{(k - 1)!(N - k)!})$ ，其中 $k$ 是数据流中模型的数量， $N$ 是运行该数据流的设备总数。这是列举一种放置策略（即独立放置策略）的所有可能设备分配方案的最坏情况复杂度，通过将 $N$ 个设备分配给 $k$ 个模型来计算（称为整数划分问题）。为了提高效率，缓存为每个模型在一定数量的设备 $A$ 上确定的并行策略，以便在不同放置策略中模型被放置在不同的 $A$ 个 GPU 设备组上时，消除对相同并行策略的冗余搜索。
尽管在运行自动映射算法时假设 $N$ 个 GPU 是同构的，但算法 1 可以通过在 $simu$ 和自动并行模块中考虑异构设备，轻松扩展以优化异构设备上的模型映射。
2.7、实现
HybridFlow 大约用 12000 行 Python 代码（LoC）实现。
混合编程模型。分层 API 用 1800 行代码实现。集中式单控制器构建在 Ray 之上，并使用 RPC 来协调不同模型的执行顺序，并按照数据流在模型之间传输数据。这些中间数据存储在 TensorDict 中。在用于分布式计算的多控制器范式中，每个模型函数在不同设备上的单独进程中运行，控制消息从每个控制器的 CPU 进程中继到相应的 GPU 。实现支持 Megatron-LM、PyTorch FSDP 和 DeepSpeed 作为 LLM 训练和推理引擎，以及 vLLM 用于自回归生成。在 vLLM 中，用分布式管理器替换了集中式键值缓存（KVCache）管理器，以与多控制器范式保持一致。
三维混合引擎。其主要逻辑在 Megatron-LM 和 vLLM 之上用 2400 行代码实现。将 actor 模型训练和生成阶段的权重存储在单独的内存缓冲区中，在训练阶段将生成阶段的权重卸载到 CPU 内存中，在过渡阶段将生成阶段的权重重新加载回 GPU 内存中，并在生成阶段同时使用这两个缓冲区。在训练和生成阶段之间的过渡过程中，使用 NVIDIA 集合通信库（NCCL）通信原语来收集和连接每个微数据并行组中的模型参数。在生成阶段之后将键值缓存卸载到 CPU 内存中，并在下一次迭代中将其重新加载回 GPU 内存中。
自动映射算法用 1900 行代码实现，同时还有用于训练、推理和生成工作负载的三个模拟器。该算法在 CPU 上启动 RLHF 数据流之前运行，以生成用于数据流初始化的设备映射和并行策略。
3、DAPO：开源 LLM 强化学习系统
Test-time scaling（如 OpenAI 的 o1 和 DeepSeek 的 R1）为 LLMs 带来了深刻的范式变革。Test-time scaling 支持更长的思维链（Chain-of-Thought）推理并催生复杂推理行为，使模型在 AIME 数学竞赛和 Codeforces 编程竞赛等竞争性任务中表现优异。
推动这一变革的核心技术是大规模强化学习（RL），它能激发自我验证、迭代优化等复杂推理行为。然而，现有推理模型的技术报告均未公开可扩展 RL 训练的具体算法和关键方法，其实际细节仍不为人知。如下本文揭示了大规模 RL 训练中的重大挑战，并开源了一个包含完整算法、训练代码和数据集的可扩展RL系统，为业界级 RL 成果提供了普惠解决方案。
以 Qwen2.5-32B 作为 RL 预训练模型开展实验。在初始 GRPO 训练中，模型仅在 AIME 竞赛中获得 30 分，显著低于 DeepSeek RL 模型的 47 分。深入分析表明，简单的 GRPO 基线存在熵坍缩、奖励噪声、训练不稳定等关键问题。学术界在复现深度求索结果时也遭遇类似挑战，这暗示 R1 论文可能省略了构建工业级、大规模、可复现 RL 系统所需的关键训练细节。
为填补这一空白，作者开源了先进的大规模 LLM RL 系统 —— 基于 Qwen2.5-32B 模型在 AIME 2024 中取得 50 分，仅用 50% 训练步数即超越 DeepSeek-R1-Zero-Qwen-32B 模型的 47 分。作者提出解耦裁剪与动态采样策略优化算法（DAPO），并引入 4 项关键技术以实现长思维链 RL 场景下的高效训练：
- Clip-Higher：提升系统多样性，避免熵坍缩；
- 动态采样：提高训练效率与稳定性；
- Token 级策略梯度损失：长思维链 RL 场景的关键技术；
- 超长奖励塑形：降低奖励噪声，稳定训练过程。
DAPO 的实现基于 verl 框架（verl 介绍在本博客第二章节，即上节）。
3.1、预备知识
3.1.1、近端策略优化（PPO）
PPO 为策略优化引入了裁剪替代目标函数。通过使用裁剪操作将策略更新约束在前策略的邻近区域内，PPO 稳定了训练过程并提升了样本效率。具体而言，PPO 通过最大化以下目标函数来更新策略：
\[\mathcal{J}_{PPO}(\theta) = \mathbb{E}_{(q, a) \sim \mathcal{D}, o_{\leq t} \sim \pi_{\theta_{old}}(\cdot \mid q)} \left[ \min \left( \frac{\pi_{\theta}(o_t \mid q, o_{<t})}{\pi_{\theta_{old}}(o_t \mid q, o_{<t})} \hat{A}_t, \operatorname{clip} \left( \frac{\pi_{\theta}(o_t \mid q, o_{<t})}{\pi_{\theta_{old}}(o_t \mid q, o_{<t})}, 1 - \varepsilon, 1 + \varepsilon \right) \hat{A}_t \right) \right], \tag{1}\]其中：
- $(q, a)$ 是来自数据分布 $\mathcal{D}$ 的一个问答对
- $\varepsilon$ 是重要性采样比率的裁剪范围
- $\hat{A}_t$ 是时间步 $t$ 的优势估计值
此外，给定价值函数 $V$ 和奖励函数 $R$，$\hat{A}_t$ 使用广义优势估计（GAE）计算：
\[\hat{A}_t^{GAE(\gamma, \lambda)} = \sum_{l=0}^{\infty} (\gamma \lambda)^l \delta_{t+l}, \tag{2}\]其中：
\[\delta_l = R_l + \gamma V(s_{l+1}) - V(s_l), \quad 0 \leq \gamma, \lambda \leq 1. \tag{3}\]3.1.2、组相对策略优化（GRPO）
与 PPO 相比，GRPO 移除了值函数，并以组相对方式估计优势值。对于特定问答对 $(q, a)$，行为策略 $\pi_{\theta_{\text{old}}}$ 采样生成一组 $G$ 个个体响应 \(\{o_i\}_{i=1}^G\)。然后，第 $i$ 个响应的优势值通过对组级奖励 \(\{R_i\}_{i=1}^G\) 进行归一化计算：
\[\hat{A}_{i,t} = \frac{r_i - \text{mean}(\{R_i\}_{i=1}^G)}{\text{std}(\{R_i\}_{i=1}^G)}. \tag{4}\]与 PPO 类似，GRPO 采用裁剪目标函数，并直接引入 KL 惩罚项：
\[\mathcal{J}_{\text{GRPO}}(\theta) = \mathbb{E}_{(q,a) \sim \mathcal{D}, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot|q)} \left[ \frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \min\left( r_{i,t}(\theta) \hat{A}_{i,t}, \text{clip}\left(r_{i,t}(\theta), 1 - \epsilon, 1 + \epsilon\right) \hat{A}_{i,t} \right) - \beta D_{\text{KL}}(\pi_\theta \| \pi_{\text{ref}}) \right], \tag{5}\]其中，
\[r_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}. \tag{6}\]值得注意的是，GRPO 在样本级别计算目标函数。具体而言，GRPO 首先计算每个生成序列的平均损失，再对不同样本的损失取平均。这种差异可能影响算法性能。
3.1.3 移除 KL 散度
KL 惩罚项用于约束在线策略与固定参考策略之间的散度。在 RLHF 场景中，RL 的目标是对齐模型行为，同时避免偏离初始模型过远。然而，在长思维链（long-CoT）推理模型的训练过程中，模型分布可能会与初始模型产生显著差异，因此这一约束并非必要。因此，作者在提出的算法中移除了 KL 项。
3.1.4、基于规则的奖励建模
使用奖励模型通常会面临奖励博弈问题（reward hacking problem）。为此，作者直接将可验证任务的最终准确率作为结果奖励，通过以下规则计算：
\[R(\hat{y}, y) = \begin{cases} 1, & \text{is_equivalent}(\hat{y}, y) \\ -1, & \text{otherwise} \end{cases} \tag{7}\]其中 $y$ 是真实答案，$\hat{y}$ 是预测答案。实践证明，这种方法能有效激活基础模型的推理能力，已在自动定理证明、计算机编程、数学竞赛等多个领域得到验证。
3.2、DAPO 算法
作者提出解耦裁剪与动态采样策略优化算法（Decouple Clip and Dynamic sAmpling Policy Optimization, DAPO）。对于每个带答案 $a$ 的问题 $q$，DAPO 采样一组输出 ${o_i}_{i=1}^G$，并通过以下目标函数优化策略：
\[\mathcal{J}_{\text{DAPO}}(\theta) = \mathbb{E}_{(q,a) \sim \mathcal{D}, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot|q)} \left[ \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \min\left( r_{i,t}(\theta) \hat{A}_{i,t}, \text{clip}\left(r_{i,t}(\theta), 1 - \epsilon_{\text{low}}, 1 + \epsilon_{\text{high}}\right) \hat{A}_{i,t} \right) \right]\] \[\text{s.t. } 0 < \left|\{o_i \mid \text{is_equivalent}(a, o_i)\}\right| < G, \tag{8}\]其中，
\[r_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}, \quad \hat{A}_{i,t} = \frac{R_i - \text{mean}(\{R_i\}_{i=1}^G)}{\text{std}(\{R_i\}_{i=1}^G)}. \tag{9}\]完整算法见算法 1。本节将介绍 DAPO 的关键技术。
3.2.1 提升上限：Clip-Higher 策略
在使用简单 PPO 或 GRPO 的初始实验中，作者观察到熵坍缩现象：随着训练进行，策略的熵值快速下降（下图1 b）。特定组的采样响应趋于几乎相同，表明探索能力有限且策略过早确定性化，这会阻碍规模扩展过程。
作者提出 Clip-Higher 策略以解决这一问题。裁剪近端策略优化（PPO-Clip）引入对重要性采样比率的裁剪，以限制信任区域并增强强化学习的稳定性。作者发现，上裁剪边界会限制策略的探索能力 —— 相比提升低概率 “探索性 token” 的概率，使高概率 “利用性 token” 的概率更高显然更容易。
具体而言，当 $\epsilon = 0.2$（多数算法的默认值）时，考虑两个概率分别为 $\pi_{\theta_{old}}(o_i \mid q) = 0.01$ 和 $0.9$ 的动作，其更新后的最大可能概率 $\pi_\theta(o_{i} \mid q)$ 分别为 0.012 和 1.08。这意味着高概率 token（如 0.9）受约束更小，而低概率 token 要实现显著的概率提升则困难得多。实验中也观察到，裁剪后 token 的最大概率约为 $\pi_{\theta}(o_{i} \mid q) < 0.2$（下图 2a），这支持了之前的分析：上裁剪阈值确实限制了低概率 token 的概率增长，从而可能制约系统多样性。
遵循 Clip-Higher 策略，将上下裁剪范围解耦为 $\epsilon_{low}$ 和 $\epsilon_{high}$：
\[\mathcal{J}_{\text{DAPO}}(\theta) = \mathbb{E}_{(q,a) \sim \mathcal{D}, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot|q)} \left[ \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \min\left( r_{i,t}(\theta) \hat{A}_{i,t}, \text{clip}\left(r_{i,t}(\theta), 1 - \textcolor{red}{\epsilon_{\text{low}}}, 1 + \textcolor{red}{\epsilon_{\text{high}}}\right) \hat{A}_{i,t} \right) \right]\] \[\text{s.t. } 0 < \left|\{o_i \mid \text{is_equivalent}(a, o_i)\}\right| < G. \tag{10}\]增大 $\epsilon_{high}$ 的值，为低概率 token 的概率提升留出更多空间。如上图 1 所示，这一调整有效提升了策略的熵值，并促进生成更多样化的样本。作者选择保持 $\epsilon_{low}$ 相对较小，因为增大 $\epsilon_{low}$ 会将这些 token 的概率压制至 0，导致采样空间坍缩。
3.2.2 多多益善：动态采样
当某些提示的准确率为 1 时，现有 RL 算法会面临梯度衰减问题。以 GRPO 为例，若某个提示的所有输出 $\{{o_i}_{i=1}^G\}$ 均正确并获得相同奖励 1，则该组的优势值为零。优势值为零会导致策略更新时无梯度，从而降低样本效率。实验显示，准确率为 1 的样本数量持续增加（图 2b），这意味着每批提示的有效数量不断减少，可能导致梯度方差增大并削弱模型训练的梯度信号。
为此，作者提出对准确率为 1 和 0 的提示进行过采样和过滤（如公式 11 所示），使每批提示均包含有效梯度并保持固定数量。训练前，持续采样直至批次中充满准确率既非 0 也非 1 的样本：
\[\mathcal{J}_{\text{DAPO}}(\theta) = \mathbb{E}_{(q,a) \sim \mathcal{D}, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot|q)} \left[ \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \min\left( r_{i,t}(\theta) \hat{A}_{i,t}, \text{clip}\left(r_{i,t}(\theta), 1 - \epsilon_{\text{low}}, 1 + \epsilon_{\text{high}}\right) \hat{A}_{i,t} \right) \right]\] \[\text{s.t. } \textcolor{red}{0 < \left|\{o_i \mid \text{is_equivalent}(a, o_i)\}\right| < G}. \tag{11}\]值得注意的是，该策略未必降低训练效率 —— 若 RL 系统同步且生成阶段未流水线化，生成时间通常由长尾样本主导。此外，如图 5 所示，动态采样使实验更快达到相同性能。
3.2.3 重新平衡：Token 级策略梯度损失
原始 GRPO 算法采用样本级损失计算：先对每个样本内的 token 损失求平均，再聚合跨样本的损失。此方法中，每个样本在最终损失计算中权重相同。然而，作者发现这种损失归约方法在长思维链（long-CoT）RL 场景中引入若干挑战。
由于所有样本在损失计算中权重相同，长响应（包含更多 token）中的 token 对总损失的贡献可能不成比例地降低，导致两个负面影响：
其一，高质量长样本的推理相关模式可能难以被模型学习；
其二，过长样本常出现无意义内容、重复词汇等低质量模式，而样本级损失计算无法有效惩罚这些模式，导致熵值和响应长度异常增加（图 3a、3b）。
为解决上述问题，在长思维链 RL 场景中引入Token 级策略梯度损失：
\[\mathcal{J}_{\text{DAPO}}(\theta) = \mathbb{E}_{(q,a) \sim \mathcal{D}, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}(\cdot|q)} \left[ \frac{1}{\textcolor{red}{\sum_{i=1}^G |o_i|}} \textcolor{red}{\sum_{i=1}^G \sum_{t=1}^{|o_i|}} \min\left( r_{i,t}(\theta) \hat{A}_{i,t}, \text{clip}\left(r_{i,t}(\theta), 1 - \epsilon_{\text{low}}, 1 + \epsilon_{\text{high}}\right) \hat{A}_{i,t} \right) \right]\] \[\text{s.t. } 0 < \left|\{o_i \mid \text{is_equivalent}(a, o_i)\}\right| < G. \tag{12}\]在此设定下，长序列对整体梯度更新的影响大于短序列。此外，从单个 token 的角度，无论其所在响应长度如何，若某生成模式能增加或减少奖励，均会被同等激励或抑制。
3.2.4、捉迷藏：超长奖励塑形
在强化学习训练中，通常会设置生成的最大长度，过长样本会被相应截断。作者发现，对截断样本的不当奖励塑形会引入奖励噪声，严重干扰训练过程。
默认情况下，对截断样本赋予惩罚性奖励。这种方法可能向训练过程中引入噪声 —— 合理的推理过程可能仅因长度过长而受罚，此类惩罚可能使模型对自身推理过程的有效性产生混淆。
为研究这种奖励噪声的影响，作者首先应用超长过滤策略（Overlong Filtering strategy），即屏蔽截断样本的损失。如图 4 所示，该方法显著稳定了训练并提升了性能。
此外，作者提出软超长惩罚（Soft Overlong Punishment，公式 13），一种长度感知的惩罚机制，用于塑造截断样本的奖励。具体而言，当响应长度超过预设最大值时，定义一个惩罚区间。在此区间内，响应越长，惩罚力度越大。该惩罚项被添加到基于规则的原始正确性奖励中，从而向模型传递避免生成过长响应的信号：
\[R_{\text{length}}(y) = \begin{cases} 0, & |y| \leq L_{\text{max}} - L_{\text{cache}} \\ \frac{(L_{\text{max}} - L_{\text{cache}}) - |y|}{L_{\text{cache}}}, & L_{\text{max}} - L_{\text{cache}} < |y| \leq L_{\text{max}} \\ -1, & L_{\text{max}} < |y| \end{cases} \tag{13}\]
3.2.5、数据集转换
数据集通过网络爬虫与人工标注相结合，从 AoPS1 网站和官方竞赛主页获取。数学数据集的答案通常有多种格式（如表达式、公式、数字等），这使得设计通用规则解析答案极具挑战性。为通过规则提供准确的奖励信号并减少公式解析器引入的误差，受 AIME 启发，筛选答案并将其转换为便于解析的整数。例如，若原始答案为 $\frac{a+\sqrt{b}}{c}$，会指示 LLM 修改问题，使预期答案变为 $a + b + c$。经筛选和转换后，得到 DAPO-Math-17K 数据集，包含 1.7 万个提示，每个提示均配对一个整数作为答案。
3.3、实验
3.3.1、训练细节
本研究聚焦数学任务以评估算法，其可轻松迁移至其他任务。作者采用 verl 框架进行训练，以简单 GRPO 作为基线算法，通过组奖励归一化估计优势值。
超参数设置：使用 AdamW 优化器，学习率固定为 $1 \times 10^{-6}$，包含 20 个 rollout 步骤的线性预热。Rollout 阶段，提示批次大小为 512，每个提示采样 16 个响应。训练时，小批次大小设为 512，即每个 rollout 步骤进行 16 次梯度更新。超长奖励塑形中，预设最大长度为 16,384 tokens，额外分配 4,096 tokens 作为软惩罚缓冲区间，因此生成的最大 token 数设为 20,480。Clip-Higher 机制中，裁剪参数 $\epsilon_{low}$ 设为 0.2，$\epsilon_{high}$ 设为 0.28，有效平衡探索与利用。AIME 评估时，重复测试集 32 次，报告 avg@32 以保证结果稳定性，推理超参数设为温度 1.0 和 topp 0.7。
3.3.2、主要结果
AIME 2024 实验表明，DAPO 成功将 Qwen-32B 基础模型训练为强大推理模型，性能超越 DeepSeek 使用 R1 方法在 Qwen2.5-32B 上的实验结果。AIME 2024 准确率从接近 0% 提升至 50%，且仅用 DeepSeek-R1-Zero-Qwen-32B 所需训练步骤的 50% 即实现这一突破。
下表详细分析了各训练技术的贡献，结果显示这些技术在 RL 训练中均有效，每项技术均为 AIME 2024 准确率提升贡献多个百分点。值得注意的是，在原始 GRPO 设置下，基于 Qwen2.5-32B 基础模型训练仅能达到 30% 准确率。
Token 级损失虽性能提升幅度较小，但显著增强了训练稳定性，使响应长度增长更健康。动态采样时，尽管因过滤零梯度数据需采样更多数据，但整体训练时间未受显著影响。如图 5 所示，虽然采样实例数量增加，但因所需训练步骤减少，模型收敛时间甚至缩短。
3.3.3、训练动态
大语言模型强化学习不仅是前沿研究方向，更是本质复杂的系统工程挑战，其各子系统相互依赖。对任一子系统的修改可能引发系统级连锁反应，因组件间复杂交互导致意外结果。即使初始条件的微小变化（如数据和超参数差异），也可能通过迭代强化学习过程放大，导致结果显著偏差。
这种复杂性使研究者常面临困境：即使经过细致分析并预期某修改能优化训练过程，实际结果仍可能偏离预期轨迹。因此，实验中监控关键中间结果至关重要，可快速定位差异根源并优化系统。
- 生成响应长度：如图 6a 所示，该指标与训练稳定性和性能密切相关。长度增加为模型提供更大探索空间，允许采样更复杂推理行为并通过训练逐步强化。但需注意，训练中长度并非持续增长，在相当长时期内可能停滞甚至下降。通常结合长度与验证准确率评估实验是否恶化
- 训练奖励动态：如图 6b 所示，奖励变化趋势是强化学习的关键监控指标之一。多数实验中，奖励增长趋势相对稳定，未因实验设置调整而显著波动或下降，表明在可靠奖励信号下，语言模型能稳健拟合训练集分布。但作者发现训练集最终奖励与验证集准确率几乎无关，提示存在过拟合
- Actor 模型熵与生成概率：二者与模型探索能力相关，是实验中密切监控的关键指标。直观上，模型熵需维持在合适范围——熵过低表明概率分布过锐，丧失探索能力；熵过高常伴随过度探索问题（如无意义内容、重复生成）。生成概率则相反，Clip-Higher 策略有效解决了熵坍缩问题。后续实验发现，保持熵的缓慢上升趋势有助于模型性能提升（图 6c、6d）
3.3.4、案例研究
RL 训练过程中，作者观察到有趣现象：Actor 模型的推理模式随时间动态演变。算法不仅强化现有有助于正确解题的推理模式，还逐渐催生初始不存在的全新推理模式。这一发现揭示了 RL 算法的适应性和探索能力，为理解模型学习机制提供新视角。
例如，模型训练初期几乎不出现对先前推理步骤的检查和反思，但随着训练推进，模型表现出明显的反思和回溯行为（下表）。这为深入探索 RL 中推理能力的涌现提供了启示，相关研究留待未来工作。
