背景知识：从零理解 verl 框架¶
本文档面向完全没有强化学习和 verl 框架经验的研究生，系统介绍理解 verl 所需的全部背景知识。
目录¶
1. 强化学习基础¶
1.1 什么是强化学习（Reinforcement Learning, RL）¶
强化学习是机器学习的一个分支。与监督学习（给定输入和标准答案进行训练）不同，强化学习的核心思想是：一个智能体（Agent）通过与环境（Environment）交互，根据获得的奖励信号（Reward）来学习最优行为策略（Policy）。
用一个直观的比喻：想象你在训练一只小狗。你不会告诉它每一步该怎么做（这是监督学习），而是在它做对时给零食（正奖励），做错时不给零食（负奖励或零奖励）。小狗通过不断尝试，学会了哪些行为能获得更多零食。
1.2 基本概念¶
| 概念 | 英文 | 含义 | 在 LLM 中的对应 |
|---|---|---|---|
| 智能体 | Agent | 做出决策的主体 | 语言模型本身 |
| 环境 | Environment | 智能体所处的世界 | 用户的 prompt + 奖励模型 |
| 状态 | State | 环境的当前状况 | 已生成的文本序列 |
| 动作 | Action | 智能体采取的行为 | 生成下一个 token |
| 奖励 | Reward | 环境对动作的反馈 | 奖励模型的打分 |
| 策略 | Policy | 从状态到动作的映射 | 模型的参数（决定下一个 token 的概率分布） |
| 价值函数 | Value Function | 衡量某个状态有多"好" | Critic 模型的预测（预估从当前状态开始能获得的总奖励） |
1.3 马尔可夫决策过程（Markov Decision Process, MDP）¶
强化学习的数学框架是 MDP，由以下五元组定义：
- \(\mathcal{S}\): 状态空间 —— 所有可能的状态的集合
- \(\mathcal{A}\): 动作空间 —— 所有可能的动作的集合
- \(P(s'|s, a)\): 状态转移概率 —— 在状态 \(s\) 下采取动作 \(a\) 后转移到状态 \(s'\) 的概率
- \(R(s, a)\): 奖励函数 —— 在状态 \(s\) 下采取动作 \(a\) 获得的即时奖励
- \(\gamma\) (gamma): 折扣因子 —— 衡量未来奖励相对于当前奖励的重要性，取值 \([0, 1]\)
马尔可夫性质：下一个状态只取决于当前状态和动作，与历史无关。即"未来与过去独立，只取决于现在"。
在 LLM 的场景中： - 状态 = prompt + 已生成的 token 序列 - 动作 = 选择下一个 token - 奖励 = 通常只在生成完整回复后由奖励模型给出 - 策略 = 模型根据当前序列预测下一个 token 的概率分布
1.4 强化学习的目标¶
强化学习的核心目标是找到一个最优策略 \(\pi^*\)，使得累计期望奖励最大化：
\[
\max_{\pi} \; \mathbb{E}\left[\sum_{t=0}^{\infty} \gamma^t \cdot R(s_t, a_t)\right]
\]
即：我们希望智能体学会一种行为策略，使得它在长期内获得的奖励总和最大。
2. 大语言模型基础¶
2.1 Transformer 架构简述¶
Transformer 是当前所有主流大语言模型（GPT、LLaMA、Qwen 等）的基础架构，由 Vaswani 等人在 2017 年提出（"Attention is All You Need"）。
其核心组件包括：
输入文本
↓
[Token Embedding + Positional Encoding] ← 将文字转换为向量，并加入位置信息
↓
┌──────────────────────────────┐
│ Self-Attention Layer │ ← 每个 token 关注序列中所有其他 token
│ (多头注意力机制) │ 计算 Q(Query), K(Key), V(Value)
├──────────────────────────────┤
│ Feed-Forward Network │ ← 对每个位置独立做非线性变换
│ (前馈神经网络) │
├──────────────────────────────┤
│ Layer Normalization │ ← 稳定训练过程
│ + Residual Connection │ 残差连接防止梯度消失
└──────────────────────────────┘
↑ 重复 N 层（如 LLaMA-7B 有 32 层）
↓
[Output Layer] ← 预测下一个 token 的概率分布
自注意力机制（Self-Attention） 的直觉：当模型处理"他吃了一个苹果"这句话时，"吃"这个词需要关注"他"（谁在吃）和"苹果"（吃什么）。自注意力让每个词都能"看到"句子中的其他词，从而理解上下文。
2.2 预训练（Pre-training）¶
预训练是 LLM 训练的第一阶段：
- 目标: 在海量文本数据（互联网、书籍等）上训练模型，学会"语言"本身
- 方式: 自回归语言建模 —— 给定前面的 token，预测下一个 token
- 结果: 模型获得了通用的语言理解和生成能力
- 特点: 数据量极大（万亿级 token），计算成本极高
例如，给定"今天天气"，模型学会预测下一个 token 可能是"很"、"不"等。
2.3 微调（Fine-tuning）¶
预训练后的模型虽然"懂语言"，但不一定能很好地遵循人类指令。微调是在特定任务数据上继续训练：
- 监督微调 (SFT, Supervised Fine-Tuning): 用人工标注的高质量"问题-回答"对进行训练
- 目的: 让模型学会按照人类期望的格式和方式回答问题
- 数据量: 相比预训练少得多（通常几万到几十万条）
3. RLHF（人类反馈强化学习）¶
3.1 什么是 RLHF¶
RLHF（Reinforcement Learning from Human Feedback，人类反馈强化学习）是一种利用人类偏好来优化语言模型输出质量的技术。它是 ChatGPT 等产品背后的关键技术之一。
3.2 为什么需要 RLHF¶
仅靠预训练和 SFT 的模型存在以下问题：
- 有害内容: 模型可能生成有毒、偏见或不安全的内容
- 不真实: 模型可能"一本正经地胡说八道"（幻觉问题）
- 不符合人类偏好: 模型不知道什么是"好的回答"
- 难以用规则定义"好": "什么是好的回答"很难用简单的损失函数描述
RLHF 的核心思路：既然我们难以定义"好"的标准，那就让人类来判断，然后用这些判断训练一个奖励模型，再用奖励模型指导语言模型的优化。
3.3 RLHF 的三个阶段¶
阶段一：监督微调（SFT）¶
目标: 训练一个能遵循指令的基础模型
输入: 人工标注的高质量 (prompt, response) 对
方法: 标准的有监督学习，最小化交叉熵损失
输出: SFT 模型 (作为后续 RL 训练的起点)
阶段二：奖励模型训练（Reward Model Training）¶
目标: 训练一个模型来模拟人类的偏好判断
步骤:
1. 给定 prompt，让 SFT 模型生成多个不同的回答
2. 人类标注者对这些回答进行排序（哪个更好）
3. 用这些排序数据训练一个奖励模型（Reward Model, RM）
4. RM 学会给"好回答"打高分，给"差回答"打低分
输入: (prompt, response_win, response_lose) 三元组
损失函数: \(L = -\log\sigma\left(r(x, y_{\text{win}}) - r(x, y_{\text{lose}})\right)\)
输出: 奖励模型 RM
阶段三：RL 训练（PPO 训练）¶
目标: 用奖励模型的信号来优化语言模型
步骤:
1. 语言模型根据 prompt 生成回答 (rollout/generation)
2. 奖励模型对生成的回答打分
3. 用 PPO 算法根据奖励信号更新语言模型参数
4. 同时加入 KL 散度惩罚，防止模型偏离 SFT 模型太远
输入: prompts 数据集 + 训练好的奖励模型
输出: 经过 RL 优化的最终模型
3.4 RLHF 之外：基于规则的奖励¶
值得注意的是，除了训练奖励模型，还有一种更简单的方式 —— 基于规则的可验证奖励（Verifiable Reward）。例如在数学题中，可以直接验证模型的答案是否正确。verl 同时支持这两种奖励方式。
近年来流行的 GRPO（Group Relative Policy Optimization）、DAPO 等算法就大量使用了可验证奖励，在数学推理等任务上取得了很好的效果。
4. PPO 算法详解¶
4.1 策略梯度的基本思想¶
在讲 PPO 之前，需要理解策略梯度（Policy Gradient）的基本思想：
- 用当前策略 \(\pi\) 采样一些轨迹（在 LLM 中就是生成一些回复）
- 计算每条轨迹的奖励
- 奖励高的轨迹 → 增大其中动作的概率
- 奖励低的轨迹 → 减小其中动作的概率
数学上，策略梯度的公式为：
\[
\nabla J(\theta) = \mathbb{E}\left[\nabla \log \pi_\theta(a|s) \cdot A(s, a)\right]
\]
其中 \(A(s, a)\) 是优势函数（Advantage），衡量"这个动作比平均水平好多少"。
4.2 PPO 的核心思想¶
PPO（Proximal Policy Optimization，近端策略优化）是 OpenAI 在 2017 年提出的强化学习算法，因其稳定性和易用性而被广泛采用。
核心问题: 策略梯度方法中，如果一次更新步长太大，策略可能会剧烈变化，导致训练不稳定甚至崩溃。
PPO 的解决方案: 限制每次更新的幅度，确保新策略不会偏离旧策略太远。
4.3 重要性采样与策略比率¶
PPO 引入了策略比率（ratio）：
\[
r(\theta) = \frac{\pi_\theta(a|s)}{\pi_{\theta_{\text{old}}}(a|s)}
\]
- 如果 \(r(\theta) > 1\)：说明新策略比旧策略更倾向于选择这个动作
- 如果 \(r(\theta) < 1\)：说明新策略比旧策略更不倾向于选择这个动作
- 如果 \(r(\theta) = 1\)：新旧策略对这个动作的概率相同
4.4 Clip 机制（PPO-Clip）¶
PPO 的核心创新是 clip 机制：
\[
L_{\text{CLIP}}(\theta) = \mathbb{E}\left[\min\left(r(\theta) \cdot \hat{A}, \; \text{clip}\left(r(\theta),\; 1-\epsilon,\; 1+\epsilon\right) \cdot \hat{A}\right)\right]
\]
其中 \(\epsilon\) 是一个超参数（通常取 0.2）。
直觉理解：
- 当 \(\hat{A} > 0\)（这个动作比平均好）时：
- 我们希望增大 \(r(\theta)\)，即增大选择这个动作的概率
-
但 clip 限制了 \(r(\theta)\) 最大只能到 \(1+\epsilon\)，防止过度增大
-
当 \(\hat{A} < 0\)（这个动作比平均差）时：
- 我们希望减小 \(r(\theta)\)，即减小选择这个动作的概率
- 但 clip 限制了 \(r(\theta)\) 最小只能到 \(1-\epsilon\)，防止过度减小
clip 区间
←───────────→
──────────────┬─────────────┬──────────────
1-ε 1 1+ε
│ │
被裁剪 │ 正常更新 │ 被裁剪
(不再减小) │ 区域 │ (不再增大)
4.5 广义优势估计（GAE, Generalized Advantage Estimation）¶
优势函数 \(A(s, a)\) 衡量的是"在状态 \(s\) 下采取动作 \(a\)，比按照平均策略行动好多少"。GAE 是一种平衡偏差和方差的优势估计方法：
\[
\hat{A}_t^{\text{GAE}(\gamma,\lambda)} = \sum_{l=0}^{\infty} (\gamma\lambda)^l \cdot \delta_{t+l}
\]
其中时序差分误差（TD error）为：
\[
\delta_t = r_t + \gamma \cdot V(s_{t+1}) - V(s_t)
\]
- \(\gamma\) (gamma): 折扣因子，决定对未来奖励的重视程度
- \(\lambda\) (lambda): GAE 参数，控制偏差-方差权衡
- \(\lambda = 0\)：只用一步 TD 误差，偏差大但方差小
- \(\lambda = 1\)：相当于用蒙特卡洛回报，偏差小但方差大
- 通常取 \(\lambda = 0.95\) 作为折中
4.6 PPO 在 RLHF 中的完整流程¶
for each training iteration:
1. [Rollout] 用 Actor 模型（当前策略）对 prompts 生成回复
2. [Reward] 用 Reward Model 对回复打分
3. [Critic] 用 Critic 模型估计每个 token 位置的价值 \(V(s)\)
4. [GAE] 计算广义优势估计 \(\hat{A}_t\)
5. [Update] 用 PPO-Clip 损失更新 Actor 模型
6. [Update] 用价值函数损失更新 Critic 模型
7. [KL] 加入 KL 散度惩罚，防止模型偏离参考模型太远
4.7 GRPO：PPO 的简化变体¶
GRPO（Group Relative Policy Optimization）是近年来非常流行的变体，由 DeepSeek 提出。它的核心思想是：
- 去掉 Critic 模型，减少显存和计算开销
- 对同一个 prompt 生成多个回复（一组），用组内相对排名来估计优势
- 奖励高的回复在组内得到正的优势，奖励低的得到负的优势
verl 同时支持 PPO 和 GRPO 等多种 RL 算法。
5. 分布式训练基础¶
大语言模型参数量巨大（数十亿到数千亿参数），单张 GPU 无法容纳。分布式训练技术将计算和存储分散到多张 GPU 上。
5.1 数据并行（Data Parallelism, DP）¶
核心思想: 每张 GPU 持有完整的模型副本，但处理不同的数据批次。
训练数据
┌────┴────┐
Batch 1 Batch 2
↓ ↓
┌───────┐ ┌───────┐
│ GPU 0 │ │ GPU 1 │ ← 每个 GPU 有完整的模型
│模型副本│ │模型副本│
└───┬───┘ └───┬───┘
└────┬─────┘
All-Reduce ← 同步梯度
┌────┴────┐
┌───────┐ ┌───────┐
│ GPU 0 │ │ GPU 1 │ ← 用平均梯度更新参数
│更新参数│ │更新参数│
└───────┘ └───────┘
- 优点: 实现简单，几乎线性加速
- 缺点: 每张 GPU 必须放下完整模型，对大模型不适用
5.2 张量并行（Tensor Parallelism, TP）¶
核心思想: 将模型中的矩阵运算切分到多张 GPU 上并行计算。
[权重矩阵 W]
┌─────────┴─────────┐
[W 的左半] [W 的右半]
↓ ↓
GPU 0 GPU 1
计算部分结果 计算部分结果
└─────────┬─────────┘
合并结果
例如，一个大的线性层 Y = XW，可以将 W 按列切分到两张 GPU 上，各自计算一半，然后合并结果。
- 优点: 可以训练单卡放不下的模型
- 缺点: GPU 之间需要频繁通信，通常要求 GPU 在同一台机器上（用 NVLink 连接）
5.3 流水线并行（Pipeline Parallelism, PP）¶
核心思想: 将模型的不同层放到不同的 GPU 上，数据像流水线一样依次经过各层。
输入数据
↓
┌───────┐
│ GPU 0 │ ← Layer 0-7
└───┬───┘
↓
┌───────┐
│ GPU 1 │ ← Layer 8-15
└───┬───┘
↓
┌───────┐
│ GPU 2 │ ← Layer 16-23
└───┬───┘
↓
┌───────┐
│ GPU 3 │ ← Layer 24-31
└───┬───┘
↓
输出
- 优点: 可以训练非常深的模型
- 缺点: 存在"气泡"（pipeline bubble），部分 GPU 空闲等待
5.4 FSDP（Fully Sharded Data Parallelism）¶
FSDP 是 PyTorch 原生支持的分布式训练策略，结合了数据并行和模型分片的优点。
核心思想: 平时将模型参数分片存储到各个 GPU，需要计算时再临时收集完整参数。
平时（节省显存）:
GPU 0: [参数分片 0] [梯度分片 0] [优化器状态分片 0]
GPU 1: [参数分片 1] [梯度分片 1] [优化器状态分片 1]
计算时（临时收集）:
GPU 0: [完整参数] → 前向/反向计算 → 丢弃非本地参数
GPU 1: [完整参数] → 前向/反向计算 → 丢弃非本地参数
- 优点: 显著减少每张 GPU 的显存占用（参数、梯度、优化器状态都被分片）
- PyTorch 原生: 与 PyTorch 生态无缝集成，使用门槛较低
- verl 支持 FSDP 和更新的 FSDP2 作为训练后端
5.5 Megatron-LM¶
Megatron-LM 是 NVIDIA 开发的大规模 LLM 训练框架，将 TP、PP、DP 组合为 3D 并行。
- 优点: 高度优化，可以高效训练千亿级模型
- 缺点: 使用门槛较高，需要对模型代码进行改造
- verl 支持 Megatron-LM 作为训练后端，用于超大规模模型的训练
5.6 推理引擎：vLLM 和 SGLang¶
在 RL 训练的 rollout 阶段，需要用当前模型生成大量回复。专门的推理引擎可以极大加速这一过程：
- vLLM: 使用 PagedAttention 技术，高效管理 KV Cache 内存，大幅提高推理吞吐量
- SGLang: 支持高效的多轮对话和工具调用推理
verl 同时支持 vLLM 和 SGLang 作为 rollout 推理引擎。
6. verl 框架概述¶
6.1 verl 是什么¶
verl（Volcano Engine Reinforcement Learning for LLMs）是由字节跳动 Seed 团队发起并开源维护的大语言模型强化学习训练框架。它的论文标题为 "HybridFlow: A Flexible and Efficient RLHF Framework"，被系统领域顶会 EuroSys 2025 录用。
简单来说，verl 是一个帮你高效地用强化学习训练大语言模型的工具。
6.2 为什么需要 verl¶
RLHF 训练面临的挑战：
- 多模型协调: PPO 训练涉及 4 个模型（Actor、Critic、Reward Model、Reference Model），需要协调它们的执行
- 训练-推理交替: RL 训练需要在"生成回复"（推理模式）和"更新参数"（训练模式）之间反复切换
- 资源效率: 如何在有限的 GPU 上高效部署和运行这些模型
- 灵活性: 不同的 RL 算法有不同的数据流，框架需要足够灵活
6.3 核心设计理念：HybridFlow¶
verl 的核心设计理念叫做 HybridFlow（混合流编程模型），解决了灵活性和效率之间的矛盾。
单控制器（Single Controller）模式:
传统的分布式 RL 框架要么用单控制器（灵活但效率低），要么用多控制器（高效但不灵活）。verl 的创新在于：
- 控制层面: 使用单控制器（一个 driver 进程），方便编写和调试复杂的 RL 数据流
- 计算层面: 底层使用高效的分布式训练和推理引擎（FSDP、Megatron-LM、vLLM 等）
# verl 的编程模型示例（伪代码）：
# 在单个 driver 进程中，用简单的 Python 代码编排复杂的多模型 RL 训练
for batch in dataloader:
# 1. Actor 生成回复（调用分布式推理引擎）
responses = actor.generate(batch['prompts'])
# 2. Reward Model 打分（调用分布式计算）
rewards = reward_model.score(batch['prompts'], responses)
# 3. Critic 估值（调用分布式计算）
values = critic.estimate(batch['prompts'], responses)
# 4. 计算优势并更新 Actor 和 Critic（调用分布式训练引擎）
actor.update(responses, rewards, values)
critic.update(responses, rewards, values)
6.4 3D-HybridEngine¶
verl 的另一个重要创新是 3D-HybridEngine，它解决了训练和推理之间的模型切换问题：
- RL 训练中，Actor 模型需要在训练模式（用 FSDP/Megatron 做参数更新）和推理模式（用 vLLM/SGLang 做文本生成）之间切换
- 3D-HybridEngine 实现了高效的参数重分片（resharding），避免了内存冗余和不必要的通信
6.5 verl 支持的功能¶
| 类别 | 具体支持 |
|---|---|
| 训练后端 | FSDP、FSDP2、Megatron-LM |
| 推理引擎 | vLLM、SGLang、HuggingFace Transformers |
| RL 算法 | PPO、GRPO、DAPO、ReMax、REINFORCE++、RLOO、PRIME 等 |
| 奖励类型 | 模型奖励（Reward Model）、规则奖励（Verifiable Reward） |
| 模型支持 | Qwen 系列、LLaMA 系列、Gemma、DeepSeek 等 HuggingFace 模型 |
| 高级功能 | 多模态 RL（VLM）、多轮对话、LoRA、序列并行、专家并行 |
| 规模 | 支持 671B 参数模型，数百张 GPU |
6.6 verl 的代码结构概览¶
verl/
├── trainer/ # 训练主循环和算法实现
│ ├── main_ppo.py # PPO 训练入口
│ ├── ppo/ # PPO 具体实现
│ └── sft_trainer.py # SFT 训练器
├── workers/ # 各角色的 Worker 实现
│ ├── actor/ # Actor（策略模型）
│ ├── critic/ # Critic（价值模型）
│ ├── rollout/ # Rollout（推理生成）
│ └── reward_manager/# 奖励管理
├── single_controller/ # 单控制器编程模型
├── protocol.py # 数据协议（DataProto）
├── utils/ # 工具函数
└── models/ # 模型相关
7. 核心概念图¶
7.1 RLHF 训练完整流程¶
┌─────────────────────────────────────────────────────────────────────┐
│ RLHF 训练完整流程 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 阶段一: SFT (监督微调) │
│ ┌──────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 预训练模型 │ ──→ │ 高质量问答数据 │ ──→ │ SFT 模型 │ │
│ └──────────┘ └──────────────┘ └──────┬───────┘ │
│ │ │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ │ │
│ 阶段二: 奖励模型训练 │ │
│ ┌──────────┐ ┌──────────────┐ ┌──────┴───────┐ │
│ │ SFT 模型 │ ──→ │ 生成多个回复 │ ──→ │ 人类排序标注 │ │
│ └──────────┘ └──────────────┘ └──────┬───────┘ │
│ │ │
│ ┌──────┴───────┐ │
│ │ 奖励模型 RM │ │
│ └──────┬───────┘ │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ │ │
│ 阶段三: RL 训练 (PPO) │ │
│ ↓ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ PPO 训练循环 │ │
│ │ │ │
│ │ ┌─────────┐ 生成回复 ┌───────────┐ 打分 ┌─────────┐ │ │
│ │ │ Actor │ ────────→ │ Reward │ ────→ │ 计算 │ │ │
│ │ │ (策略) │ │ Model │ │ 优势 A │ │ │
│ │ └────┬────┘ └───────────┘ └────┬────┘ │ │
│ │ │ │ │ │
│ │ │ ┌───────────┐ │ │ │
│ │ │ │ Critic │ ← 估值 V(s) ──────┘ │ │
│ │ │ │ (价值函数) │ │ │
│ │ │ └─────┬─────┘ │ │
│ │ │ │ │ │
│ │ ↓ ↓ │ │
│ │ ┌─────────────────────────┐ │ │
│ │ │ PPO-Clip 更新参数 │ │ │
│ │ │ + KL 散度惩罚 │ ← Reference Model (SFT) │ │
│ │ └─────────────────────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
7.2 PPO 训练单次迭代的数据流¶
┌──────────────────────────────────────────────────────────────┐
│ PPO 单次迭代数据流 │
│ │
│ Prompts │
│ │ │
│ ▼ │
│ ┌────────┐ 生成回复 ┌──────────┐ │
│ │ Actor │ ──────────────→│ Responses│ │
│ │(Policy)│ (Rollout阶段) └─────┬────┘ │
│ └────────┘ │ │
│ ├──────────────┐ │
│ ▼ ▼ │
│ ┌───────────┐ ┌───────────┐ │
│ │ Reward │ │Reference │ │
│ │ Model │ │ Model │ │
│ └─────┬─────┘ └─────┬─────┘ │
│ │ │ │
│ ▼ ▼ │
│ rewards ref_log_probs │
│ │ │ │
│ ▼ ▼ │
│ ┌──────────────────────┐ │
│ │ Compute Advantage │ │
│ │ (GAE) │ │
│ ┌────────┐ │ + KL Penalty │ │
│ │ Critic │──→ values ──→ │ │ │
│ └────────┘ └──────────┬───────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ PPO Update │ │
│ │ Actor 参数 │ │
│ │ Critic 参数 │ │
│ └──────────────┘ │
│ │
└──────────────────────────────────────────────────────────────┘
7.3 verl 架构总览¶
┌─────────────────────────────────────────────────────────────────────┐
│ verl 架构总览 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ Single Controller (Driver 进程) │ │
│ │ │ │
│ │ 用户用 Python 编写 RL 训练逻辑 (如 PPO/GRPO dataflow) │ │
│ │ 控制各 Worker 的执行顺序和数据传递 │ │
│ └─────┬──────────┬──────────┬──────────┬────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────┐┌──────────┐┌──────────┐┌──────────────┐ │
│ │ Actor ││ Critic ││ Reward ││ Reference │ │
│ │ Worker ││ Worker ││ Worker ││ Worker │ │
│ └────┬─────┘└────┬─────┘└────┬─────┘└──────┬───────┘ │
│ │ │ │ │ │
│ ─ ─ ─│─ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 计算后端 (可灵活选择) │ │
│ │ │ │
│ │ 训练: FSDP / FSDP2 / Megatron-LM │ │
│ │ 推理: vLLM / SGLang / HF Transformers │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────┐ │ │
│ │ │ 3D-HybridEngine │ │ │
│ │ │ 训练模式 ←──参数重分片(Resharding)──→ 推理模式 │ │ │
│ │ │ (FSDP/Megatron) (vLLM) │ │ │
│ │ └────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ GPU 资源 (灵活设备映射) │ │
│ │ │ │
│ │ 方案A: Actor/Critic 共享 GPU (co-locate) │ │
│ │ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ │
│ │ │GPU 0 │ │GPU 1 │ │GPU 2 │ │GPU 3 │ │ │
│ │ │Actor │ │Actor │ │Actor │ │Actor │ │ │
│ │ │Critic │ │Critic │ │Critic │ │Critic │ │ │
│ │ │Reward │ │Reward │ │Reward │ │Reward │ │ │
│ │ └───────┘ └───────┘ └───────┘ └───────┘ │ │
│ │ │ │
│ │ 方案B: 不同模型使用不同 GPU (separate) │ │
│ │ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ │
│ │ │GPU 0 │ │GPU 1 │ │GPU 2 │ │GPU 3 │ │ │
│ │ │Actor │ │Actor │ │Critic │ │Reward │ │ │
│ │ └───────┘ └───────┘ └───────┘ └───────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
7.4 关键术语快速参考表¶
| 术语 | 含义 |
|---|---|
| Actor | 策略模型，即我们要训练的 LLM，负责生成回复 |
| Critic | 价值模型，估计每个状态的价值 \(V(s)\)，用于计算优势函数 |
| Reward Model (RM) | 奖励模型，模拟人类偏好，对回复打分 |
| Reference Model | 参考模型，通常是 SFT 模型的副本，用于计算 KL 散度 |
| Rollout | 用当前 Actor 模型生成回复的过程 |
| KL 散度 | 衡量两个概率分布差异的指标，用于防止策略偏离太远 |
| DataProto | verl 中的统一数据传输协议 |
| Worker | verl 中执行具体计算的分布式进程 |
| Resharding | 在训练和推理之间转换模型参数的分布方式 |
总结¶
理解 verl 需要以下知识链条：
强化学习基础 (RL)
↓
大语言模型 (LLM/Transformer)
↓
RLHF (将 RL 应用于 LLM)
↓
PPO/GRPO (具体的 RL 算法)
↓
分布式训练 (让训练跑在多 GPU 上)
↓
verl 框架 (把以上所有整合在一起的工具)
建议先对上述每个概念有一个大致理解，然后再深入 verl 的代码。不需要一开始就完全搞懂每个细节，在阅读代码的过程中可以反复回到本文档查阅。
下一步: 请阅读 01_guide.md 了解如何开始阅读 verl 的代码。