DPO 的天花板

你已经用 SFT + DPO 训练了一个能听懂指令的模型。但你发现了一个问题——

强化学习（RL）引入了一个新角色：Reward Model（奖励模型）。它给每次回答打分，模型通过试错，真正"学会什么是好"。

这个比喻只是为了帮你建立直观感受。在代码层面，Reward Model 是一个经过训练的神经网络，输入一段对话文本，输出一个浮点数（通常在 -3 到 +3 之间），代表对回答质量的评估。

训练三阶段

DPO 是"告诉你哪个更好"，RL 是"让你自己试，做对了奖励，做错了惩罚"。后者的探索空间大得多。

三种训练范式

Part 1: 核心概念

在写代码之前，先搞懂三个核心词：策略、奖励、优势。它们会在后面的代码里反复出现。

策略 Policy

定义

策略是一个条件概率分布。给定 Prompt x，它输出回答 y 的概率 P(y|x)。

白话

说白了，策略就是模型本身。它决定了"看到这个问题，我会怎么回答"。不同的模型权重 = 不同的策略 = 不同的回答风格。

代码

# train_grpo.py: 策略就是我们的 model
model, tokenizer = init_model(lm_config, base_weight, device=args.device)

# Reference Model 是训练前的原始策略，冻结不动
ref_model, _ = init_model(lm_config, base_weight, device=args.device)
ref_model = ref_model.eval().requires_grad_(False)

奖励 Reward

定义

奖励是一个标量分数，衡量回答质量。越高表示越好。

白话

就像老师给作文打分。分数高的回答，模型以后多生成；分数低的，少生成。RL 训练的目标就是让模型生成的回答获得的奖励越来越高。

这个比喻只是为了帮你建立直观感受。在代码中，奖励信号是一个数值标量，用于在策略梯度更新中缩放每个 token 的对数概率梯度。

代码

# train_grpo.py: calculate_rewards() —— 四种信号叠加
rewards = torch.zeros(len(responses), device=args.device)
rewards[i] += 0.5 if 20 <= len(response.strip()) <= 800 else -0.5  # 长度
rewards[i] -= rep_penalty(answer)                                 # 重复惩罚
score = reward_model.get_score(messages, answer)                  # RM 评分
rewards += reward_model_scores                                    # 汇总

优势函数

定义

优势衡量"这个回答比平均水平好多少"。它是策略更新的核心信号。

白话

班上平均分 70，你考了 90，优势就是 +20。优势为正，说明这个行为值得鼓励；为负，就该抑制。关键在于"比平均好多少"，而不是绝对分数。

GRPO 的计算方式

# train_grpo.py: 同一 Prompt 生成 6 个回答，组内标准化
grouped_rewards = rewards.view(-1, args.num_generations)  # [B, 6]
mean_r = grouped_rewards.mean(dim=1).repeat_interleave(args.num_generations)
std_r = grouped_rewards.std(dim=1, unbiased=False).repeat_interleave(args.num_generations)
advantages = (rewards - mean_r) / (std_r + 1e-4)  # 标准化

GRPO 的优势是"组内相对排名"——不需要额外模型，直接用同一组的均值和标准差来归一化。PPO 的优势则用 Critic 模型 + GAE 来估计，我们后面会详细讲。

Part 2: 训练循环

不管 GRPO 还是 PPO，训练循环都遵循同样的四步。理解这个循环，就理解了 RL 训练的骨架。

四步循环

这四步循环在每个 training step 中重复执行。第 3 步是 GRPO 和 PPO 的核心分歧点。

Step 1: 生成

从数据集取出 Prompt，让模型自己生成回答。同时记录下每个 token 的对数概率（old_logp）。

# train_grpo.py: rollout 阶段
rollout_result = rollout_engine.rollout(
    prompt_ids=prompt_inputs["input_ids"],
    attention_mask=prompt_inputs["attention_mask"],
    num_generations=args.num_generations,  # GRPO: 6, PPO: 1
    max_new_tokens=args.max_gen_len,
    temperature=0.8,  # 有一定随机性，让每次生成不同
)
outputs = rollout_result.output_ids         # [B*G, P+R] 完整序列
completions = rollout_result.completions    # List[str] 解码后的文本
old_per_token_logps = rollout_result.per_token_logps  # 旧策略的 log 概率

数据准备

RL 训练的数据只需要 Prompt，不需要标准答案。RLAIFDataset 会把对话渲染为模型输入格式，但 answer 字段留空——让模型自己生成。

# dataset/lm_dataset.py: RLAIFDataset
class RLAIFDataset(Dataset):
    def __init__(self, jsonl_path, tokenizer, max_length=1024, thinking_ratio=0.5):
        self.thinking_ratio = thinking_ratio  # 按概率开启 thinking
        self.samples = load_dataset('json', data_files=jsonl_path, split='train')

    def create_chat_prompt(self, conversations):
        conversations = pre_processing_chat(conversations)
        use_thinking = random.random() < self.thinking_ratio
        return self.tokenizer.apply_chat_template(
            conversations[:-1],         # 去掉最后一条（assistant 的回答）
            tokenize=False,
            open_thinking=use_thinking,  # 随机决定是否开启思考模式
            add_generation_prompt=True   # 添加 assistant 开头标记
        )

thinking_ratio=0.9 表示 90% 的 Prompt 会开启 <think>...</think> 思考模式，让模型同时学会"先想再答"和"直接回答"两种模式。

Part 3: 奖励信号

MiniMind 的奖励函数是四个信号的组合。前三个是规则性的辅助信号，第四个（Reward Model）是最核心的语义评分。

奖励组成全景

长度奖励

鼓励适度回答，惩罚敷衍或冗余：

# calculate_rewards() 中的长度奖励
rewards[i] += 0.5 if 20 <= len(response.strip()) <= 800 else -0.5

这是一个简单的阈值规则。它不是完美的——有些问题本来就该短回答——但作为辅助信号已经够用。真正的内容质量由 RM 评分来把关。

思考奖励

如果回答包含思考过程（</think> 标签），额外奖励格式规范的思考：

# calculate_rewards() 中的思考奖励
if '</think>' in response:
    thinking_content, answer_content = response.split('</think>', 1)
    # 思考内容长度 20~300 字符 → +1.0，否则 -0.5
    rewards[i] += 1.0 if 20 <= len(thinking_content.strip()) <= 300 else -0.5
    # </think> 标签恰好 1 个 → +0.25，否则 -0.25
    rewards[i] += 0.25 if response.count('</think>') == 1 else -0.25
    answer = answer_content.strip()  # 后续用 answer 去算 RM 分数

两个信号叠加：鼓励"适度思考 + 格式规范"，惩罚"思考太短/太长 + 标签乱写"。思考过程太长可能是模型在"胡思乱想"，太短则没有真正推理。

重复惩罚与 RM

# 重复惩罚：用 3-gram 重复率衡量，上限 0.5
def rep_penalty(text, n=3, cap=0.5):
    toks = re.findall(r"\w+|[^\w\s]", text.lower())
    grams = [tuple(toks[i:i + n]) for i in range(len(toks) - n + 1)]
    return min(cap, (len(grams) - len(set(grams))) * cap * 2 / len(grams)) if grams else 0.0

# Reward Model 评分：最核心的语义信号
score = reward_model.get_score(messages, answer)
reward_model_scores.append(score)
rewards += reward_model_scores  # 直接加到总奖励上

奖励数值示例

假设模型生成了一个包含思考过程的回答：

一个差的回答（太短 + 没有思考 + 重复 + RM 低分）可能得到 -1.5 左右的总 Reward。奖励的绝对值不重要，重要的是相对排名——这正是优势函数要做的。

Part 4: GRPO 算法

Group Relative Policy Optimization。MiniMind 的默认 RL 算法。它摒弃了 PPO 中复杂的 Critic 模型，用组内相对排名替代。

GRPO 核心思想

定义

GRPO 通过在同一 Prompt 下生成多个回答，用组内相对排名计算优势，无需训练额外的价值模型（Critic）。

白话

同一个问题让模型写 6 个答案，老师分别打分。分高的相对于平均有正优势，分低的有负优势。不需要额外的"Critic 模型"来预测"预期分数"——6 个回答的均值就是基准线。

代码

# train_grpo.py: rollout 阶段 —— 每个 Prompt 生成 6 个回答
rollout_result = rollout_engine.rollout(
    prompt_ids=prompt_inputs["input_ids"],
    attention_mask=prompt_inputs["attention_mask"],
    num_generations=args.num_generations,  # 默认 6
    max_new_tokens=args.max_gen_len,
    temperature=0.8,
)

组内相对优势

关键点：优势是组内相对的。同一个回答在不同的组里，优势值可能完全不同。这就像你的考试成绩好不好，取决于班级平均水平。

GRPO 更新策略

GRPO 的一次前向传播分为四步。在写代码之前，先理解每一步在做什么、为什么需要它：

GRPO 代码片段

对应上页流程图的四步，每步只保留核心代码：

# 步骤 1: 重新计算 new_logp（策略已经 rollout 后更新过）
per_token_logps = F.log_softmax(res.logits[:, :-1, :], dim=-1).gather(
    2, outputs[:, 1:].unsqueeze(-1)).squeeze(-1).gather(1, logp_pos)

# 步骤 2: 参考模型的 logp（冻结，用于计算 KL 散度）
with torch.no_grad():
    ref_per_token_logps = F.log_softmax(
        ref_model(outputs, ...).logits[:, :-1, :], dim=-1).gather(...)

# 步骤 3: 组内标准化得到优势
advantages = (rewards - mean_r) / (std_r + 1e-4)

# 步骤 4: ratio = 新旧概率之比，裁剪后计算损失
ratio = torch.exp(per_token_logps - old_per_token_logps)
clamped_ratio = torch.clamp(ratio, max=args.epsilon_high).detach()

步骤 1 和 2 都是在做"取 log 概率"，只是分别来自当前策略和参考模型。步骤 3 是 GRPO 区别于 PPO 的核心——不需要 Critic。步骤 4 的裁剪细节会在后面的损失函数一页展开。

KL 散度惩罚

定义

KL 散度衡量两个概率分布之间的"距离"。在 RL 训练中，它约束新策略不要偏离参考模型太远。

白话

想象你在学开车。教练（参考模型）说"方向盘应该这样握"，你可以调整握法，但不能完全另起炉灶——否则就是危险驾驶。KL 惩罚就是那个"教练在盯着你"的机制。

这个比喻只是为了帮你建立直观感受。在代码中，KL 散度是通过 token 级别的 log 概率差来计算的。

代码

# train_grpo.py: per-token KL 散度
kl_div = ref_per_token_logps - per_token_logps
per_token_kl = torch.exp(kl_div) - kl_div - 1  # [B*G, R]

公式是 exp(Δ) - Δ - 1，其中 Δ = ref_logp - new_logp。这个公式保证 KL ≥ 0，且 Δ=0 时 KL=0（策略没变时惩罚为零）。args.beta（默认 0.1）控制惩罚力度。

GRPO 损失函数

损失 = 策略损失 + KL 惩罚。策略损失通过 Clipped Objective 限制更新幅度。

# train_grpo.py: 两种变体
ratio = torch.exp(per_token_logps - old_per_token_logps)  # 新旧策略的比率

if args.loss_type == "cispo":  # 默认：CISPO 单裁剪（只裁上界）
    clamped_ratio = torch.clamp(ratio, max=args.epsilon_high).detach()
    per_token_loss = -(clamped_ratio * advantages.unsqueeze(1) * per_token_logps
                       - args.beta * per_token_kl)
else:  # 标准 GRPO：双裁剪（上下界都裁）
    clipped_ratio = torch.clamp(ratio, 1 - args.epsilon, 1 + args.epsilon)
    per_token_loss1 = ratio * advantages.unsqueeze(1)
    per_token_loss2 = clipped_ratio * advantages.unsqueeze(1)
    per_token_loss = -(torch.min(per_token_loss1, per_token_loss2)
                       - args.beta * per_token_kl)

最后对有效 token 求平均：

policy_loss = ((per_token_loss * completion_mask).sum(dim=1)
               / completion_mask.sum(dim=1).clamp(min=1)).mean()
loss = (policy_loss + aux_loss) / args.accumulation_steps

CISPO 变体

MiniMind 默认使用 CISPO（Clipped Importance Sampling Policy Optimization）。和标准 GRPO 的区别在于裁剪策略：

# 上下界都裁剪
clipped = torch.clamp(ratio,
    1 - 0.2, 1 + 0.2)  # [0.8, 1.2]

# 只裁上界
clamped = torch.clamp(ratio,
    max=5.0).detach()

GRPO 完整流程

掩码机制

GRPO 中有一个容易被忽略但非常重要的机制：completion_mask。它确保 loss 只计算有效 token，忽略 padding 和 EOS 之后的内容。

# 核心逻辑：找到 EOS 位置，只保留 EOS 之前且非 padding 的 token
is_eos = (completion_ids == tokenizer.eos_token_id) & completion_pad_mask
eos_idx = ...  # 每个 sample 中 EOS 的位置
completion_mask = (torch.arange(...) <= eos_idx.unsqueeze(1)) & completion_pad_mask

Part 5: PPO 算法

Proximal Policy Optimization，经典的 RL 算法。比 GRPO 多了一个 Critic 模型，优势估计更精细，但也更复杂、更吃显存。

Critic 模型

定义

Critic 模型用于估计"在当前状态下，未来能获得的期望总回报"，输出每个位置的价值 V(s)。

白话

Critic 是一个"预言家"。它不生成文字，只输出一个分数——"从当前这个位置看，最终能拿多少分"。有了这个预言家，我们就知道某个回答是"比预期好"还是"比预期差"。

代码

# train_ppo.py: Critic 继承 MiniMind，换掉最后的 lm_head
class CriticModel(MiniMindForCausalLM):
    def __init__(self, params):
        super().__init__(params)
        # 把语言模型头替换为价值头：输出单一标量
        self.value_head = nn.Linear(params.hidden_size, 1)

    def forward(self, input_ids=None, attention_mask=None, **kwargs):
        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask, **kwargs)
        hidden_states = self.model.norm(outputs[0])
        values = self.value_head(hidden_states).squeeze(-1)  # [B, seq_len]
        return values

Critic 和 Actor 共享 Transformer 基座权重，只是最后的"头"不同。Actor 用 lm_head 输出词表分布，Critic 用 value_head 输出标量价值。

Critic 初始化

Critic 从 Actor 的 SFT 权重初始化，加载预训练权重时 strict=False（因为 Critic 没有 lm_head，多了 value_head）：

# train_ppo.py: Critic 初始化
ckp = f'{args.save_dir}/{base_weight}_{lm_config.hidden_size}{moe_suffix}.pth'
state_dict = torch.load(ckp, map_location=args.device)

critic_model = CriticModel(lm_config)
critic_model.load_state_dict(state_dict, strict=False)  # 允许键不完全匹配
critic_model = critic_model.to(args.device)

Actor-Critic

GAE 直觉理解

GAE（Generalized Advantage Estimation）回答的问题是：生成序列中每个 token，究竟对最终奖励贡献了多少？

假设模型生成了 3 个 token，Critic 给出了每个位置的价值预测：

从后往前算 TD 误差 delta = r + gamma*V(next) - V(current)，其中末尾没有 V(next)，取 0：

GAE 代码实现

理解了上面的数值例子后，代码只是在做同样的事——从后往前迭代：

# train_ppo.py: GAE 反向迭代
lastgaelam = torch.zeros(B, device=args.device)
advs_rev = []
for t in reversed(range(gen_len)):
    nv = old_resp_values[:, t + 1] if t < gen_len - 1 else 0.0
    delta = token_rewards[:, t] + args.gamma * nv - old_resp_values[:, t]
    lastgaelam = delta + args.gamma * args.lam * lastgaelam
    advs_rev.append(lastgaelam)
advantages = torch.stack(advs_rev[::-1], dim=1)  # [B, R]
returns = advantages + old_resp_values  # Return = Advantage + Value

对照上页的数值例子：delta 就是 TD 误差，lastgaelam 就是累积优势。每一步把当前的 delta 加上衰减后的上一步优势，从末尾一路传递到开头。

GAE 反向过程

PPO 两个损失

PPO 同时训练两个模型，各有一个损失函数。它们的目标完全不同：

ratio = torch.exp(new_logp - old_logp)
clipped = torch.clamp(ratio,
    1-0.2, 1+0.2)
# 取 max 确保损失为正
policy_loss = torch.max(
    -advantages * ratio,
    -advantages * clipped)
# 加上 KL ref 惩罚
policy_loss += kl_coef * kl_penalty

value_loss = 0.5 * torch.max(
    # 普通 MSE
    (values - returns) ** 2,
    # 裁剪 MSE：限制 V 变化幅度
    (clamp(values,
     old_values - 0.2,
     old_values + 0.2)
     - returns) ** 2
)

总损失 = 策略损失 + vf_coef x 价值损失 + aux_loss。两个损失分别回传到 Actor 和 Critic 的参数。

PPO 早停机制

PPO 会对同一批数据更新多轮（ppo_update_iters=2）。但如果策略偏离太远，就要停下来：

# train_ppo.py: 早停判断
log_ratio = mb_resp_logp - old_resp_logp[inds]
approx_kl = (0.5 * (log_ratio ** 2) * resp_policy_mask[inds]).sum() \
         / resp_policy_mask[inds].sum().clamp(min=1)

if approx_kl_val > args.early_stop_kl:  # 默认 0.25
    stop_ppo = True

# 早停时截断 loss 但不中断 DDP 通信
if stop_ppo:
    loss = (policy_loss + args.vf_coef * value_loss + aux_loss) * 0.0
else:
    loss = (policy_loss + args.vf_coef * value_loss + aux_loss) / args.accumulation_steps
loss.backward()

PPO 多轮更新

PPO 对同一批 rollout 数据进行多轮 mini-batch 更新。这是 PPO 和 GRPO 的重要区别：

mb_size = max(1, min(args.mini_batch_size, B))
for ppo_epoch in range(args.ppo_update_iters):  # 默认 2 轮
    if stop_ppo: break
    b_inds = torch.randperm(B, device=args.device)  # 打乱顺序
    for i in range(0, B, mb_size):
        inds = b_inds[i:i + mb_size]
        # 在 mini-batch 上计算 loss 并 backward
        ...
        if grad_accum_step % args.accumulation_steps == 0:
            clip_grad_norm_(actor_model.parameters(), args.grad_clip)
            clip_grad_norm_(critic_model.parameters(), args.grad_clip)
            actor_optimizer.step()
            critic_optimizer.step()

PPO 完整流程

GRPO vs PPO

两种算法解决同一个问题（RL 对齐），但路线不同。现在你已经分别学完了两者，让我们做个全面对比。

模型数量对比

# train_grpo.py
model, tokenizer = init_model(...)       # Policy
ref_model, _ = init_model(...)           # Reference
reward_model = LMForRewardModel(...)     # 外部 RM（不训练）

# train_ppo.py
actor_model, tokenizer = init_model(...) # Actor
ref_model, _ = init_model(...)           # Reference
critic_model = CriticModel(...)          # Critic（额外）
reward_model = LMForRewardModel(...)     # 外部 RM（不训练）

全维度对比

架构对比图

如何选择

Part 7: Rollout 引擎

Rollout 引擎负责"生成回答"这一步。看似简单——不就是调 model.generate() 吗？但实际工程中，这层抽象解决了一个关键问题。

为什么需要引擎

训练小模型时，直接在训练代码里调用 model.generate() 就够了。但当模型变大、需要多卡训练时，问题出现了：

解决思路：把"生成"这件事抽离出来，做成可插拔的引擎。小模型用本地引擎（Torch），大模型用独立推理服务（SGLang），训练代码一行不改。

# 切换引擎只需改一个参数
python train_grpo.py --rollout_engine torch   # 本地推理
python train_grpo.py --rollout_engine sglang  # 独立推理服务

这就是抽象层存在的意义——让算法工程师专注算法，不用关心底层用什么方式推理。

引擎特性对比

对于 MiniMind 这样的小模型，Torch 引擎完全够用。SGLang 主要为未来扩展到更大模型预留。

Torch 引擎代码

TorchRolloutEngine 是默认引擎，核心逻辑只有三步：

# rollout_engine.py: TorchRolloutEngine 核心逻辑
class TorchRolloutEngine(RolloutEngine):
    def rollout(self, prompt_ids, attention_mask,
                num_generations, max_new_tokens, temperature=0.8):
        with torch.no_grad():
            # 关键：repeat_interleave 把每个 Prompt 复制 G 份
            output_ids = model.generate(
                input_ids=prompt_ids.repeat_interleave(num_generations, dim=0),
                max_new_tokens=max_new_tokens,
                do_sample=True, temperature=temperature,
            )
            per_token_logps = compute_per_token_logps(self.policy_model, output_ids, ...)
        return RolloutResult(output_ids, completion_ids, per_token_logps, completions, ...)

LogProb 计算

两个引擎都需要计算每个 token 的对数概率。这个函数是 Rollout 的核心工具：

# rollout_engine.py: 只计算最后 n_keep 个 token 的 logprob，节省计算
def compute_per_token_logps(model, input_ids, n_keep, attention_mask=None):
    unwrapped = model.module if isinstance(model, DistributedDataParallel) else model
    logits = unwrapped(input_ids, attention_mask=attention_mask,
                       logits_to_keep=n_keep + 1).logits[:, :-1, :]
    per_token_logps = []
    for logits_row, ids_row in zip(logits, input_ids[:, -n_keep:]):
        per_token_logps.append(
            torch.gather(logits_row.log_softmax(dim=-1), 1, ids_row.unsqueeze(1)).squeeze(1)
        )
    return torch.stack(per_token_logps)  # [B, n_keep]

Part 8: 动手实践

理论讲完了，让我们把代码跑起来。先从 GRPO 训练命令开始。

GRPO 训练

# 基础 GRPO 训练（CISPO 变体，默认推荐）
python trainer/train_grpo.py \
    --from_weight full_sft \
    --data_path ../dataset/rlaif.jsonl \
    --num_generations 6 \
    --batch_size 2 \
    --learning_rate 3e-7 \
    --loss_type cispo \
    --beta 0.1 \
    --epochs 1 \
    --thinking_ratio 0.9

训练开始后，日志会输出每个 step 的 Reward、KL_ref、Advantage 统计等关键指标：

Epoch:[1/1](1/50), Reward: 1.2341, KL_ref: 0.0087,
Adv Std: 1.1234, Adv Mean: 0.0000, Actor Loss: 0.4156,
Avg Response Len: 234.50, Learning Rate: 0.00000030

PPO 训练

python trainer/train_ppo.py \
    --from_weight full_sft \
    --data_path ../dataset/rlaif.jsonl \
    --batch_size 2 \
    --learning_rate 3e-7 \
    --critic_learning_rate 5e-7 \
    --ppo_update_iters 2 \
    --clip_epsilon 0.2 \
    --gamma 1.0 \
    --lam 0.95 \
    --early_stop_kl 0.25

PPO 多了几个关键超参数：

SGLang 加速

当模型较大或需要多卡训练时，可以用 SGLang 加速 rollout：

# 第一步：启动 SGLang 推理服务（独立终端）
python -m sglang.launch_server \
    --model-path ./minimind-model \
    --attention-backend triton \
    --host 0.0.0.0 --port 8998

# 第二步：用 SGLang 引擎训练（另一个终端）
python trainer/train_grpo.py \
    --from_weight full_sft \
    --rollout_engine sglang \
    --sglang_base_url http://localhost:8998 \
    --sglang_model_path ./minimind-model \
    --sglang_shared_path ./sglang_ckpt_grpo

超参数速查

调试模式

两个训练脚本都支持 --debug_mode，定期打印 Prompt 和生成内容，帮助排查问题：

python trainer/train_grpo.py \
    --from_weight full_sft \
    --debug_mode \
    --debug_interval 10  # 每 10 步打印一次

输出格式示例：

[DEBUG] step=10, sample[0]
============================== [DEBUG] sample[0] CONTEXT_BEGIN ==============================
<|im_start|>user\n请解释什么是机器学习。<|im_end|>
=============================== [DEBUG] sample[0] CONTEXT_END ===============================
============================ [DEBUG] gen[0] RESPONSE_BEGIN ============================
机器学习是人工智能的一个分支，它让计算机能够...
============================ [DEBUG] gen[0] RESPONSE_END ==============================
[DEBUG] gen[0] reward=2.3456

练习: 读代码

任务：打开 train_grpo.py，找到 grpo_train_epoch() 函数。回答以下问题：

1. old_per_token_logps 是在哪一步产生的？为什么后面要 .detach()？
2. 如果把 num_generations 从 6 改成 2，训练会出什么问题？
3. completion_mask 的作用是什么？如果去掉它，loss 会怎么变？

练习: 改超参

任务：基于以下训练命令，修改一个超参数并预测效果：

python trainer/train_grpo.py \
    --from_weight full_sft \
    --num_generations 6 \
    --beta 0.1 \
    --learning_rate 3e-7 \
    --loss_type cispo

1. 把 --beta 从 0.1 改成 0.0 会怎样？
2. 把 --learning_rate 从 3e-7 改成 3e-5 会怎样？
3. 把 --loss_type 从 cispo 改成 grpo 会怎样？

练习: PPO 排错

任务：阅读以下 PPO 日志片段，诊断问题：

Epoch:[1/1](5/50), Reward: -1.2341, KL_ref: 0.0001,
Approx KL: 0.0001, ClipFrac: 0.0000,
Critic Loss: 12.3456, Avg Response Len: 5.00

1. Reward 为负说明什么？
2. Avg Response Len 只有 5 说明什么？
3. ClipFrac 为 0 说明策略有在更新吗？

常见错误诊断

进阶排错

常见问题 FAQ

学完自测