GSPO

版本依赖：ms-swift >= 3.11

Megatron GSPO 当前已支持以下功能：

训练模式：全参数训练与 LoRA 微调
并行策略：支持上下文并行（CP）、流水线并行（PP）、张量并行（TP）和专家并行（EP）
推理加速：支持 vLLM 的 colocate 模式和 server 模式
模型支持：兼容 Megatron Swift 中的 LLM 及 MLLM（多模态大模型）
算法支持：涵盖 swift GRPO 的大部分功能（GSPO 基于 GRPO 算法）

解释一下：

TP (Tensor Parallelism) - 张量并行。将单个层的权重矩阵按列或行切分到多个 GPU，每个 GPU 计算一部分。适合：单层参数很大的模型。
PP (Pipeline Parallelism) - 流水线并行。将模型的不同层分配到不同的 GPU。例如：GPU 0 处理前 10 层，GPU 1 处理中间 10 层，GPU 2 处理后 10 层。
CP (Context Parallelism) - 上下文并行。将长序列按长度切分到多个 GPU。例如：一个 4096 token 的序列被分成 4 段，每段 1024 tokens，分别在不同 GPU 上处理。适合：处理超长序列（如 32K、128K tokens）。
EP (Expert Parallelism) - 专家并行。用于 MoE（Mixture of Experts）模型。将不同的专家（Expert）分配到不同的 GPU。例如：8 个专家分别放在 8 个 GPU 上。适合：MoE 架构模型（如 Mixtral、Qwen2.5-MoE）。

以下参数或功能将在后续版本中逐步支持：

Entropy 相关配置：如 top_entropy_quantile、log_entropy
Reward Model / Reward Model Plugin
多轮 Rollout 调度机制（multi_turn_scheduler）：实现多轮对话策略优化
虚拟流水线并行（VPP）
参考模型同步更新（sync_ref_model）
Async Generate (async_generate)
num_iterations
日志同步 SwanLab

⚠️ 注意：以下参数在 Megatron GSPO 中不生效：

use_vllm：Megatron GSPO 仅使用 vLLM 进行 Rollout 推理。
move_model_batches：该参数专用于 DeepSpeed ZeRO-3 优化，在 Megatron 架构下无效。

与 ms-swift GRPO 相同，Megatron GSPO batch size 相关的参数均以 completion-level 为单位，即表示模型生成的 completion 数量，而非 prompt 数量。

参数对比

下表对比了 ms-swift 和 Megatron-SWIFT 中批量相关参数的对应关系：

ms-swift 参数	Megatron-SWIFT 参数	说明
`per_device_train_batch_size`	`micro_batch_size`	每张 GPU 的训练批次大小（completion-level）
`gradient_accumulation_steps`	-	梯度累积步数，在 Megatron-SWIFT 中已包含在 `global_batch_size` 的计算中
-	`global_batch_size`	全局批次大小（completion-level） Megatron-SWIFT: `micro_batch_size × dp_size × gradient_accumulation_steps` ms-swift: `per_device_train_batch_size × world_size × gradient_accumulation_steps`
`num_generations`	`num_generations`	每个 prompt 生成的 completion 数量
`steps_per_generation`	`steps_per_generation`	Rollout 批次大小相对于训练批次大小的倍数注意：在 ms-swift 中需为 `gradient_accumulation_steps` 的整数倍
`generation_batch_size`	`generation_batch_size`	Rollout 阶段的批次大小（completion-level），需为 `global_batch_size` 的整数倍

以下公式用于计算 Megatron GSPO 中的批量：

数据并行大小：dp_size = world_size / (TP × PP × CP)
全局批次大小：global_batch_size = micro_batch_size × dp_size × gradient_accumulation_steps
生成批次大小：generation_batch_size = global_batch_size × steps_per_generation
Rollout Prompt 数量：num_rollout_prompts = generation_batch_size / num_generations
训练 Prompt 数量：num_train_prompts = global_batch_size / num_generations
每个 DP group 的训练 Prompt 数量：num_prompts_per_dp_group = global_batch_size / num_generations / dp_size

注意：在 Megatron GSPO 中，每个 DP group 的训练 Prompt 数量须满足 num_prompts_per_dp_group 是 micro_batch_size的整数倍，以确保训练批次能够正确分配。

Megatron GSPO 参数设置指南

本文档详细讲解 Megatron GSPO 的训练机制、参数含义和设置方法，帮助您正确配置训练参数。

GSPO 训练机制概述

训练流程

Megatron GSPO 的训练过程分为两个主要阶段：

阶段 1: Rollout（采样阶段）

数据准备：从数据集中采样 num_rollout_prompts 个 prompt
生成 Completions：对每个 prompt，使用当前策略模型生成 num_generations 个不同的 completion
计算奖励：使用奖励模型（Reward Model）或奖励函数对每个 completion 进行评分
计算优势：基于组内相对优势计算每个 token 的优势值


展开代码
Rollout 阶段示例：
- 输入：8 个 prompts
- 生成：每个 prompt 生成 4 个 completions
- 总计：8 × 4 = 32 个 completions（generation_batch_size）
- 奖励计算：对 32 个 completions 分别计算奖励
- 优势计算：在每个 prompt 的 4 个 completions 组内计算相对优势

阶段 2: Training（训练阶段）

数据分组：将生成的 completions 按照对应的 prompt 分组
损失计算：使用 GSPO 损失函数计算每个 token 的损失
梯度更新：反向传播并更新模型参数


展开代码
Training 阶段示例：
- 输入：32 个 completions（来自 8 个 prompts，每个 4 个）
- 训练批次：global_batch_size = 16 个 completions
- 每个训练步骤处理 16 个 completions
- 需要 2 个训练步骤才能处理完所有 32 个 completions

训练循环


展开代码
for epoch in range(max_epochs):
    for step in range(num_training_steps):
        # 每 steps_per_generation 步执行一次 Rollout
        if step % steps_per_generation == 0:
            # Rollout 阶段
            prompts = sample_prompts(num_rollout_prompts)
            completions = generate_completions(prompts, num_generations)
            rewards = calculate_rewards(completions)
            advantages = calculate_advantages(rewards)
        
        # Training 阶段
        batch = get_training_batch(completions, advantages)
        loss = compute_gspo_loss(batch)
        optimizer.step()

核心概念理解

1. Completion-level vs Prompt-level

重要：Megatron GSPO 中所有批次大小参数均以 completion-level 为单位，即表示模型生成的 completion 数量，而非 prompt 数量。

Completion：模型对单个 prompt 生成的一个完整响应
Prompt：输入给模型的提示文本

关系：

\text{num\_completions} = \text{num\_prompts} \times \text{num\_generations}

代码表示：


展开代码
num_completions = num_prompts × num_generations

2. 并行策略

Megatron GSPO 支持多种并行策略：

TP (Tensor Parallelism)：张量并行，将模型参数在多个 GPU 间切分
PP (Pipeline Parallelism)：流水线并行，将模型层在多个 GPU 间切分
CP (Context Parallelism)：上下文并行，将序列长度在多个 GPU 间切分
DP (Data Parallelism)：数据并行，将数据批次在多个 GPU 间切分

数据并行大小计算：

\text{dp\_size} = \frac{\text{world\_size}}{\text{TP} \times \text{PP} \times \text{CP}}

代码表示：


展开代码
dp_size = world_size / (TP × PP × CP)

3. 批次大小层次

GSPO 中有三个层次的批次大小：

Micro Batch Size (micro_batch_size)：每个 GPU 每次处理的 completion 数量
Global Batch Size (global_batch_size)：全局训练批次大小（completion-level）
Generation Batch Size (generation_batch_size)：Rollout 阶段的批次大小（completion-level）

参数计算公式

基础公式

1. 数据并行大小

\text{dp\_size} = \frac{\text{world\_size}}{\text{TP} \times \text{PP} \times \text{CP}}

其中：

TP = tensor_model_parallel_size（张量并行大小）
PP = pipeline_model_parallel_size（流水线并行大小）
CP = context_parallel_size（上下文并行大小）

代码表示：


展开代码
dp_size = world_size / (tensor_model_parallel_size × pipeline_model_parallel_size × context_parallel_size)

2. 全局批次大小

\text{global\_batch\_size} = \text{micro\_batch\_size} \times \text{dp\_size} \times \text{gradient\_accumulation\_steps}

注意：在 Megatron-SWIFT 中，gradient_accumulation_steps 已包含在 global_batch_size 的计算中，通常不需要单独设置。

代码表示：


展开代码
global_batch_size = micro_batch_size × dp_size × gradient_accumulation_steps

3. 生成批次大小

\text{generation\_batch\_size} = \text{global\_batch\_size} \times \text{steps\_per\_generation}

或者直接设置 generation_batch_size，此时：

\text{steps\_per\_generation} = \frac{\text{generation\_batch\_size}}{\text{global\_batch\_size}}

注意：generation_batch_size 和 steps_per_generation 不能同时设置，只能设置其中一个。

代码表示：


展开代码
generation_batch_size = global_batch_size × steps_per_generation
# 或
steps_per_generation = generation_batch_size / global_batch_size

4. Rollout Prompt 数量

\text{num\_rollout\_prompts} = \frac{\text{generation\_batch\_size}}{\text{num\_generations}}

含义：Rollout 阶段需要采样的 prompt 数量。

代码表示：


展开代码
num_rollout_prompts = generation_batch_size / num_generations

5. 训练 Prompt 数量

\text{num\_train\_prompts} = \frac{\text{global\_batch\_size}}{\text{num\_generations}}

含义：每个训练步骤处理的 prompt 数量。

代码表示：


展开代码
num_train_prompts = global_batch_size / num_generations

6. 每个 DP Group 的训练 Prompt 数量

\text{num\_prompts\_per\_dp\_group} = \frac{\text{global\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}}

含义：每个数据并行组在训练阶段处理的 prompt 数量。

代码表示：


展开代码
num_prompts_per_dp_group = global_batch_size / num_generations / dp_size

7. 每个 DP Group 的 Rollout Prompt 数量

\text{num\_rollout\_prompts\_per\_dp\_group} = \frac{\text{generation\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}}

含义：每个数据并行组在 Rollout 阶段处理的 prompt 数量。

代码表示：


展开代码
num_rollout_prompts_per_dp_group = generation_batch_size / num_generations / dp_size

训练迭代次数

每个训练步骤中，Rollout 阶段的迭代次数：

\text{num\_iters\_per\_step} = \frac{\text{generation\_batch\_size}}{\text{dp\_size} \times \text{num\_generations} \times \text{micro\_batch\_size}}

代码表示：


展开代码
num_iters_per_step = (generation_batch_size / dp_size / num_generations) / micro_batch_size

参数关系总览

所有参数之间的关系可以用以下公式链表示：

\begin{aligned} \text{dp\_size} &= \frac{\text{world\_size}}{\text{TP} \times \text{PP} \times \text{CP}} \\ \text{global\_batch\_size} &= \text{micro\_batch\_size} \times \text{dp\_size} \\ \text{generation\_batch\_size} &= \text{global\_batch\_size} \times \text{steps\_per\_generation} \\ \text{num\_rollout\_prompts} &= \frac{\text{generation\_batch\_size}}{\text{num\_generations}} \\ \text{num\_train\_prompts} &= \frac{\text{global\_batch\_size}}{\text{num\_generations}} \end{aligned}

参数约束条件

约束 1: num_rollout_prompt 必须能被 dp_size 整除

\text{num\_rollout\_prompt} \bmod \text{dp\_size} = 0

即：

\frac{\text{generation\_batch\_size}}{\text{num\_generations}} \bmod \text{dp\_size} = 0

原因：每个 DP group 需要处理相同数量的 prompts，以确保数据并行的一致性。

示例：

generation_batch_size = 32
num_generations = 4
num_rollout_prompt = 32 / 4 = 8
dp_size = 8
$8 \bmod 8 = 0$ ✓ 满足条件

如果 dp_size = 4，则 $8 \bmod 4 = 0$ ✓ 也满足条件。

约束 2: per_device_num_rollout_prompt 必须 ≥ 1

\text{per\_device\_num\_rollout\_prompt} = \frac{\text{num\_rollout\_prompt}}{\text{dp\_size}} \geq 1

即：

\frac{\text{generation\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \geq 1

原因：每个 DP group 至少需要处理 1 个 prompt。

约束 3: per_device_num_rollout_prompt 必须能被 micro_batch_size 整除

\text{per\_device\_num\_rollout\_prompt} \bmod \text{micro\_batch\_size} = 0

即：

\frac{\text{generation\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \bmod \text{micro\_batch\_size} = 0

原因：确保每个训练迭代能够均匀分配数据。

示例：

per_device_num_rollout_prompt = 8
micro_batch_size = 1
$8 \bmod 1 = 0$ ✓ 满足条件

如果 micro_batch_size = 2，则 $8 \bmod 2 = 0$ ✓ 也满足条件。

约束 4: num_prompts_per_dp_group 必须能被 micro_batch_size 整除

\text{num\_prompts\_per\_dp\_group} = \frac{\text{global\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}}

\text{num\_prompts\_per\_dp\_group} \bmod \text{micro\_batch\_size} = 0

原因：确保训练阶段的数据能够正确分配到各个 micro batch。

约束 5: generation_batch_size 必须能被 global_batch_size 整除

\text{generation\_batch\_size} \bmod \text{global\_batch\_size} = 0

即：

\text{generation\_batch\_size} = k \times \text{global\_batch\_size}, \quad k \in \mathbb{Z}^+

其中 $k = \text{steps\_per\_generation}$ 。

原因：Rollout 阶段生成的 completions 需要能够被训练阶段均匀处理。

约束 6: num_generations 必须 ≥ 2

\text{num\_generations} \geq 2

原因：GSPO 算法需要至少 2 个 completions 才能计算组内相对优势。

约束 7: per_device_generation_batch_size 必须 ≥ 1

\text{per\_device\_generation\_batch\_size} = \frac{\text{generation\_batch\_size}}{\text{world\_size}} \geq 1

原因：每个 GPU 至少需要处理 1 个 completion。

约束条件总结

所有约束条件可以用以下不等式组表示：

\begin{cases} \frac{\text{generation\_batch\_size}}{\text{num\_generations}} \bmod \text{dp\_size} = 0 \\ \frac{\text{generation\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \geq 1 \\ \frac{\text{generation\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \bmod \text{micro\_batch\_size} = 0 \\ \frac{\text{global\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \geq 1 \\ \frac{\text{global\_batch\_size}}{\text{num\_generations} \times \text{dp\_size}} \bmod \text{micro\_batch\_size} = 0 \\ \text{generation\_batch\_size} \bmod \text{global\_batch\_size} = 0 \\ \text{num\_generations} \geq 2 \\ \frac{\text{generation\_batch\_size}}{\text{world\_size}} \geq 1 \end{cases}

配置示例

示例 1: 单节点 8 GPU 训练

硬件配置：

1 个节点，8 个 GPU
world_size = 8

并行配置：

bash
展开代码
CONTEXT_PARALLEL_SIZE=1
TENSOR_MODEL_PARALLEL_SIZE=2
PIPELINE_MODEL_PARALLEL_SIZE=1

计算：


展开代码
dp_size = 8 / (1 × 2 × 1) = 4

批次配置：

bash
展开代码
MICRO_BATCH_SIZE=1
GLOBAL_BATCH_SIZE=16
STEPS_PER_GENERATION=2
NUM_GENERATIONS=4

验证：

\begin{aligned} \text{generation\_batch\_size} &= 16 \times 2 = 32 \\ \text{num\_rollout\_prompt} &= \frac{32}{4} = 8 \\ 8 \bmod 4 &= 0 \quad \checkmark \\ \text{per\_device\_num\_rollout\_prompt} &= \frac{8}{4} = 2 \\ 2 &\geq 1 \quad \checkmark \\ 2 \bmod 1 &= 0 \quad \checkmark \\ \text{num\_prompts\_per\_dp\_group} &= \frac{16}{4 \times 4} = 1 \\ 1 \bmod 1 &= 0 \quad \checkmark \end{aligned}

示例 2: 多节点 2×8 GPU 训练

硬件配置：

2 个节点，每个节点 8 个 GPU
world_size = 16

并行配置：

bash
展开代码
CONTEXT_PARALLEL_SIZE=1
TENSOR_MODEL_PARALLEL_SIZE=2
PIPELINE_MODEL_PARALLEL_SIZE=1

计算：


展开代码
dp_size = 16 / (1 × 2 × 1) = 8

批次配置：

bash
展开代码
MICRO_BATCH_SIZE=1
GLOBAL_BATCH_SIZE=16
STEPS_PER_GENERATION=2
NUM_GENERATIONS=4

验证：

\begin{aligned} \text{generation\_batch\_size} &= 16 \times 2 = 32 \\ \text{num\_rollout\_prompt} &= \frac{32}{4} = 8 \\ 8 \bmod 8 &= 0 \quad \checkmark \\ \text{per\_device\_num\_rollout\_prompt} &= \frac{8}{8} = 1 \\ 1 &\geq 1 \quad \checkmark \\ 1 \bmod 1 &= 0 \quad \checkmark \\ \text{num\_prompts\_per\_dp\_group} &= \frac{16}{4 \times 8} = 0.5 \quad \times \end{aligned}

问题：num_prompts_per_dp_group = 0.5 < 1，不满足约束。

解决方案：增加 global_batch_size 或 steps_per_generation：

方案 A：增加 global_batch_size

bash
展开代码
GLOBAL_BATCH_SIZE=32
STEPS_PER_GENERATION=1

\begin{aligned} \text{generation\_batch\_size} &= 32 \times 1 = 32 \\ \text{num\_rollout\_prompt} &= \frac{32}{4} = 8 \\ \text{num\_prompts\_per\_dp\_group} &= \frac{32}{4 \times 8} = 1 \quad \checkmark \end{aligned}

方案 B：增加 steps_per_generation

bash
展开代码
GLOBAL_BATCH_SIZE=16
STEPS_PER_GENERATION=4

\begin{aligned} \text{generation\_batch\_size} &= 16 \times 4 = 64 \\ \text{num\_rollout\_prompt} &= \frac{64}{4} = 16 \\ \text{num\_prompts\_per\_dp\_group} &= \frac{16}{4 \times 8} = 0.5 \quad \times \end{aligned}

仍然不满足，需要进一步调整。

方案 C：同时调整

bash
展开代码
GLOBAL_BATCH_SIZE=32
STEPS_PER_GENERATION=2

\begin{aligned} \text{generation\_batch\_size} &= 32 \times 2 = 64 \\ \text{num\_rollout\_prompt} &= \frac{64}{4} = 16 \\ 16 \bmod 8 &= 0 \quad \checkmark \\ \text{num\_prompts\_per\_dp\_group} &= \frac{32}{4 \times 8} = 1 \quad \checkmark \end{aligned}

示例 3: 使用更大的 micro_batch_size

配置：

bash
展开代码
MICRO_BATCH_SIZE=2
GLOBAL_BATCH_SIZE=32
STEPS_PER_GENERATION=2
NUM_GENERATIONS=4
dp_size = 8

验证：

\begin{aligned} \text{generation\_batch\_size} &= 32 \times 2 = 64 \\ \text{num\_rollout\_prompt} &= \frac{64}{4} = 16 \\ 16 \bmod 8 &= 0 \quad \checkmark \\ \text{per\_device\_num\_rollout\_prompt} &= \frac{16}{8} = 2 \\ 2 \bmod 2 &= 0 \quad \checkmark \\ \text{num\_prompts\_per\_dp\_group} &= \frac{32}{4 \times 8} = 1 \\ 1 \bmod 2 &= 0 \quad \times \end{aligned}

问题：num_prompts_per_dp_group = 1 不能被 micro_batch_size = 2 整除。

解决方案：增加 global_batch_size 或 num_generations：

方案 A：增加 global_batch_size

bash
展开代码
GLOBAL_BATCH_SIZE=64

\text{num\_prompts\_per\_dp\_group} = \frac{64}{4 \times 8} = 2, \quad 2 \bmod 2 = 0 \quad \checkmark

方案 B：减少 num_generations

bash
展开代码
NUM_GENERATIONS=2

\text{num\_prompts\_per\_dp\_group} = \frac{32}{2 \times 8} = 2, \quad 2 \bmod 2 = 0 \quad \checkmark

常见问题与解决方案

问题 1: ValueError: num_rollout_prompt must be divisible by dp_size

错误信息：


展开代码
ValueError: num_rollout_prompt (4) = generation_batch_size (16) // num_generations (4) 
must be divisible by dp_size (8). Please adjust generation_batch_size/steps_per_generation/num_generations.

原因：num_rollout_prompt = 4 不能被 dp_size = 8 整除。

解决方案：

增加 steps_per_generation，使 generation_batch_size 增大
减少 num_generations，使 num_rollout_prompt 增大
调整 global_batch_size 和 steps_per_generation 的组合

示例修复：

bash
展开代码
# 原配置
GLOBAL_BATCH_SIZE=16
STEPS_PER_GENERATION=1
NUM_GENERATIONS=4

# 修复：增加 steps_per_generation
STEPS_PER_GENERATION=2  # generation_batch_size = 32, num_rollout_prompt = 8

问题 2: per_device_num_rollout_prompt must be greater than 1

错误信息：


展开代码
AssertionError: per_device_num_rollout_prompt (0) must be greater than 1

原因：每个 DP group 分配的 prompt 数量小于 1。

解决方案：

增加 generation_batch_size（通过增加 global_batch_size 或 steps_per_generation）
减少 num_generations
减少 dp_size（调整并行配置）

问题 3: Per-device rollout prompt count must be divisible by micro_batch_size

错误信息：


展开代码
ValueError: Per-device rollout prompt count (3) must be divisible by micro_batch_size (2)

原因：per_device_num_rollout_prompt = 3 不能被 micro_batch_size = 2 整除。

解决方案：

调整 micro_batch_size 使其能整除 per_device_num_rollout_prompt
调整 generation_batch_size 和 num_generations 使 per_device_num_rollout_prompt 能被 micro_batch_size 整除

问题 4: num_prompts_per_dp_group must be divisible by micro_batch_size

错误信息：


展开代码
ValueError: num_prompts_per_dp_group (1) must be divisible by micro_batch_size (2)

原因：训练阶段每个 DP group 的 prompt 数量不能被 micro_batch_size 整除。

解决方案：

增加 global_batch_size
减少 num_generations
调整 micro_batch_size

问题 5: 如何选择合适的参数值？

参数选择策略：

确定硬件配置
- 计算 world_size（总 GPU 数）
- 确定并行策略（TP、PP、CP）
- 计算 dp_size
确定基础批次大小
- 根据 GPU 显存确定 micro_batch_size（通常为 1-4）
- 根据训练需求确定 global_batch_size（通常为 16-128）
确定生成参数
- 根据任务复杂度确定 num_generations（通常为 4-8）
- 根据 Rollout 需求确定 steps_per_generation（通常为 1-4）
验证约束条件
- 计算所有中间值
- 检查所有约束条件
- 如不满足，调整参数

参数调优建议：

显存充足：可以增大 micro_batch_size 和 global_batch_size，提高训练效率
显存紧张：保持 micro_batch_size = 1，通过增加 dp_size 或 steps_per_generation 来增大有效批次大小
需要更多样本：增大 num_generations 和 steps_per_generation
训练速度优先：减小 num_generations 和 steps_per_generation

参数设置检查清单

在开始训练前，请确保以下所有条件都满足：

目录

GSPO

参数对比

Megatron GSPO 参数设置指南

目录

GSPO 训练机制概述

训练流程

阶段 1: Rollout（采样阶段）

阶段 2: Training（训练阶段）

训练循环

核心概念理解

1. Completion-level vs Prompt-level

2. 并行策略

3. 批次大小层次

参数计算公式

基础公式

1. 数据并行大小

2. 全局批次大小

3. 生成批次大小

4. Rollout Prompt 数量

5. 训练 Prompt 数量

6. 每个 DP Group 的训练 Prompt 数量

7. 每个 DP Group 的 Rollout Prompt 数量

训练迭代次数

参数关系总览

参数约束条件

约束 1: num_rollout_prompt 必须能被 dp_size 整除

约束 2: per_device_num_rollout_prompt 必须 ≥ 1

约束 3: per_device_num_rollout_prompt 必须能被 micro_batch_size 整除

约束 4: num_prompts_per_dp_group 必须能被 micro_batch_size 整除

约束 5: generation_batch_size 必须能被 global_batch_size 整除

约束 6: num_generations 必须 ≥ 2

约束 7: per_device_generation_batch_size 必须 ≥ 1

约束条件总结

配置示例

示例 1: 单节点 8 GPU 训练

示例 2: 多节点 2×8 GPU 训练

示例 3: 使用更大的 micro_batch_size

常见问题与解决方案

问题 1: ValueError: num_rollout_prompt must be divisible by dp_size

问题 2: per_device_num_rollout_prompt must be greater than 1

问题 3: Per-device rollout prompt count must be divisible by micro_batch_size

问题 4: num_prompts_per_dp_group must be divisible by micro_batch_size

问题 5: 如何选择合适的参数值？

参数设置检查清单