开放权重模型强化学习微调实战：从GRPO原理到工程落地

近两年大模型的应用落地方式发生了明显变化：越来越多团队不再执着于从零预训练基座模型，而是基于已有开源权重模型做领域微调。相比全参微调，这种方式资源开销更可控，迭代速度更快。但在实际项目里，如果只用 SFT（监督微调）做领域适应，经常会遇到模型“学会了格式，却没学会策略”的问题——比如模型能生成工整的 JSON，却不会在正确答案和错误答案之间做选择；能写出一段代码，却不会根据测试用例自动修复。

答案往往出现在强化学习（RL）微调这一步。将 RL 与开源权重模型结合，本质上是把“模仿人类标注”升级为“根据奖励信号自主探索”，让模型在推理、编程、工具调用等任务上具备更强的泛化能力。

这篇文章将围绕“RL Framework for Finetuning Openweight Models”这一主题，讲解什么是 RL 微调、底层的关键原理、主流的开源 RL 框架选型，并给出一套可落地的完整微调案例，同时覆盖训练中的高频报错和工程化最佳实践。无论你是刚接触大模型微调的新手，还是已经在做 SFT 想进一步优化模型效果的开发者，本文都适用。

1. 背景与核心概念

1.1 什么是 Openweight Models

Openweight Models 通常指“开放权重模型”，即权重文件公开可下载、可商用或研究使用的大语言模型，典型代表包括 Llama、Qwen、Mistral、DeepSeek 系列等。严格来说，“开放权重”不等于“完全开源”，因为训练数据、训练代码和完整实验记录并不一定全部公开，但权重本身已经足够支撑二次开发和私有化部署。

这类模型的价值在于：它给中小团队提供了站在巨人肩膀上做应用的机会。你不需要拥有千卡集群，也不需要处理 PB 级数据，只需要基于一个几十 B 甚至 7B/14B 的开放权重模型，用领域数据做针对性训练，就能得到一个满足业务需求的专属模型。

1.2 什么是 RL 微调

RL（Reinforcement Learning，强化学习）微调，是指在预训练或 SFT 的基础上，使用强化学习算法继续训练模型。核心思想是：模型不再只看标注好的“标准答案”，而是通过与环境交互产生多个候选输出，再由奖励模型或规则函数评估这些输出的好坏，最终让模型学会“如何行动才能获得更高奖励”。

和 SFT 相比，RL 微调的差异非常明显：

1.3 RL 微调解决什么问题

一个很典型的例子是数学推理。用 SFT 微调模型时，如果训练集中只包含标准解法，模型很容易记住题目的“表面形式”，换一道同类变式题就会出错。而 RL 微调会让模型在训练中自己产生多条解题路径，通过奖励信号区分正确与错误路径，逐步强化“探索正确步骤”的能力。

再比如 agent 场景。模型需要学会调用工具、读取返回结果、决定下一步动作。这类序列决策过程很难构造 SFT 标准答案，但很容易定义奖励函数——只要最终任务完成就是高分，否则低分。这种场景天然适合 RL。

1.4 RL 微调中的关键角色

在 RL 微调中，通常有四个核心角色：

• Actor Model：被训练的模型，负责生成动作或答案。
• Reference Model：参考模型，通常是 SFT 后的模型快照，用于约束 Actor 的更新幅度，防止模型输出崩塌。
• Reward Model / Reward Function：奖励模型或规则奖励函数，负责给生成结果打分。
• Critic / Value Model：价值模型，在 PPO 类算法中用于估计状态价值，降低策略梯度方差。

对于开源权重模型，Actor 和 Reference 通常都来自同一个 SFT 模型。Reward Model 可以是一个单独训练的好恶模型，也可以是一个规则函数，比如“输出是否通过单元测试”“答案是否与标准答案一致”。

2. RL 微调的底层原理拆解

2.1 策略梯度思想

RL 微调的核心数学基础是策略梯度。记当前模型参数为 θ，模型在输入 x 下生成输出 y 的概率为 π_θ(y|x)，奖励为 R(x, y)。训练目标可以写成最大化期望奖励：

J(θ) = E_{y ~ π_θ(·|x)} [R(x, y)]

对 θ 求梯度，可以得到：

∇J(θ) = E [ R(x, y) · ∇ log π_θ(y|x) ]

通俗理解就是：如果一条输出路径获得的奖励高，就增大这条路径的生成概率；奖励低，就减少这条路径的概率。这就是“策略梯度”最朴素的含义。

但直接使用上述梯度存在一个问题：如果模型一条路径采样到的奖励总是偏高或偏低，梯度的方差会很大，训练不稳定。因此实际算法通常会引入 baseline 来降低方差。

2.2 PPO 与 GRPO 的区别

PPO（Proximal Policy Optimization）是目前最常用的 RL 微调算法之一。它通过裁剪（clip）策略更新的幅度，防止模型在一次更新中变化过大。

PPO 的损失函数中有一个重要部分：

L = min( r_t(θ) · A_t, clip(r_t(θ), 1-ε, 1+ε) · A_t )

其中 r_t(θ) 是新旧策略的概率比，A_t 是优势函数。这个公式保证了策略更新不会“步子迈得太大”。

PPO 通常需要为每个样本估计价值函数 V(s)。这意味着要额外维护一个 Critic 模型，显存开销比较大。为了解决这个问题，DeepSeek 团队提出了 GRPO（Group Relative Policy Optimization），中文可以理解为“组相对策略优化”。

GRPO 的核心思想是：对同一个问题采样多组输出（例如每组 8 条），然后用组内相对奖励作为基线，代替 Critic 模型估计的优势值。公式近似为：

A_i = (R_i - mean(R_group)) / std(R_group)

也就是说，GRPO 不再显式训练价值网络，而是用同一组内输出的奖励均值作为 baseline，大幅减少了显存占用和训练复杂度。当前很多开源 RL 框架都已经支持 GRPO，这也是本文实战部分采用的算法。

2.3 奖励模型与奖励函数

在 RL 微调中，“奖励从哪来”决定了整个训练的上限。常见方案有两类：

规则奖励（Rule-Based Reward）

直接通过程序判断输出是否正确。典型场景：

• 数学题：对比最终答案是否与标准答案一致。
• 编程题：运行模型生成的代码，看是否通过单元测试。
• 格式要求：输出是否包含指定字段或 JSON 结构。

规则奖励的优点是可解释、零成本、不会引入奖励模型本身的偏差；缺点是只能覆盖可自动评判的任务。

模型奖励（Reward Model）

训练一个单独的奖励模型，输入是“问题 + 回答”，输出是标量分数。训练数据是人工偏好标注，即标注员对多条回答做排序。RM 的输出分布学的是“人类偏好”，适合主观性强的任务，比如对话质量、内容安全性。

一个稳妥的做法是在训练初期使用规则奖励，在模型具备基本能力后再引入 RM，避免 RM 噪声干扰模型早期探索。

2.4 KL 散度约束的作用

RL 训练过程中，模型完全有可能发现一条“作弊”路径：生成的输出人类几乎看不懂，但规则奖励函数给了高分。这种现象被称为 reward hacking。为了防止模型输出严重偏离正常语言分布，标准做法是在奖励中减去与参考模型的 KL 散度惩罚。

KL 散度衡量的是 Actor 模型和 Reference 模型输出分布的差异。训练时每轮更新都会计算：

reward_adjusted = reward - β · KL(π_θ || π_ref)

β 是 KL 惩罚系数。β 太小，模型容易跑飞；β 太大，模型学不到新策略。实战中 β 通常在 0.01 到 0.1 之间，需要根据训练日志动态调整。

3. 主流 RL 微调框架选型

目前围绕 RL 微调开源权重模型，社区已经有多个成熟框架。选型时主要看三个维度：支持的算法、显存优化能力、社区活跃度。

3.1 TRL（Transformer Reinforcement Learning）

TRL 是 Hugging Face 官方维护的强化学习训练库，基于 transformers 和 accelerate 构建。它封装了 PPO、GRPO 等算法，API 风格非常接近 huggingface 生态，适合已经习惯使用 transformers 训练模型的团队。

优点：

• 文档完善，示例丰富。
• 与 peft 深度集成，支持 LoRA 微调。
• 单卡和单机多卡都能跑。
• 使用门槛低，代码改动量小。

缺点：

• 大规模分布式训练能力较弱，不太适合百亿级以上模型。
• 自定义奖励函数需要自己写训练循环或回调。

TRL 适合 7B~14B 规模模型的快速验证和中小型项目落地。

3.2 OpenRLHF

OpenRLHF 是一个面向大规模 RL 训练的框架，基于 Ray 和 vLLM 实现高性能分布式训练。它支持 PPO、GRPO 等算法，并且在显存优化上做了大量工程化处理。

优点：

• 支持大规模模型训练。
• 通过 vLLM 加速采样，生成效率高。
• 对显存占用做了深度优化。

缺点：

• 安装和配置相对复杂。
• 需要分布式训练基础。

OpenRLHF 适合 14B 以上模型或者追求训练吞吐速度的团队。

3.3 veRL（Volcano Engine Reinforcement Learning）

veRL 是字节跳动开源的混合式 RL 训练框架，主打灵活性和高性能。它将生成、训练、奖励计算三个环节解耦，允许用户自定义策略。

与 OpenRLHF 类似，veRL 也属于高阶框架，适合有算法研发能力的团队进行二次开发。如果你的目标只是快速跑通 RL 微调流程，建议优先从 TRL 开始。

3.4 框架选型建议

需要特别说明的是，框架版本迭代非常快，具体安装方式和 API 以官方仓库 README 为准。

4. 环境准备与依赖说明

4.1 硬件环境

RL 微调对显存的要求比 SFT 更高，因为训练过程中除了 Actor 模型，还需要加载 Reference 模型，同时要缓存采样输出。以 7B 模型为例，建议显存不低于 40GB，最好使用 A100 40G 或同等显存以上的显卡。

如果显存不足，可以开启 LoRA 微调模式，此时显存需求会大幅下降，7B 模型在 24GB 显存的消费级显卡上也能尝试。本文实战以 LoRA + GRPO 为例，保证更多读者可以复现。

4.2 软件环境

下面给出一个常用环境组合，版本请根据你实际安装时的最新稳定版调整：

Python 3.10+ CUDA 12.1+ PyTorch 2.1+ transformers 4.40+ trl 0.13+ datasets 2.18+ peft 0.11+ accelerate 1.0+

使用 conda 创建虚拟环境：

conda create -n rl_finetune python=3.10 -y conda activate rl_finetune pip install torch --index-url https://download.pytorch.org/whl/cu121 pip install transformers datasets trl peft accelerate

安装完成后，可以通过下面命令验证环境：

python -c "import trl, transformers, torch; print('trl:', trl.__version__); print('transformers:', transformers.__version__); print('torch:', torch.__version__)"

4.3 基座模型选择

本文选择 Qwen2.5-7B-Instruct 作为示例，原因是：

• 开源权重可下载，社区活跃，资料齐全。
• 7B 规模适中，单卡可训练。
• Instruct 版本本身具备对话能力，适合 RL 微调快速见效。

你可以根据业务场景换成其他模型，比如 Llama-3-8B-Instruct、Qwen2.5-14B-Instruct 等，但要注意在加载模型时修改模型的 dtype、设备映射等参数。

5. 实战案例：使用 TRL 对 7B 模型进行 GRPO 微调

下面进入本文的核心环节。我们将使用 TRL 框架，基于 Qwen2.5-7B-Instruct 模型，在一个简化版数学推理数据集上执行 GRPO 微调。

5.1 创建项目结构

首先创建项目目录：

mkdir rl_finetune_project cd rl_finetune_project mkdir -p scripts data output results

目录结构如下：

rl_finetune_project/ ├── scripts/ │ ├── prepare_data.py │ ├── grpo_train.py │ └── evaluate.py ├── data/ ├── output/ └── results/

5.2 准备数据集

RL 微调的数据格式与 SFT 不同。每一条样本通常包含：

• prompt：给模型的输入，通常是一个问题。
• answer：标准答案，用于规则奖励中判断对错。

本文构造一个简单的数学加减乘除数据集，每条样本要求模型输出“最终答案”。数据量控制在 200 条左右，便于快速跑通流程。

编写数据准备脚本：

# 文件路径：scripts/prepare_data.py import json import random random.seed(42) questions = [ "What is 12 + 37?", "What is 45 - 18?", "What is 6 * 7?", "What is 144 / 12?", "What is 23 + 56 - 19?", "What is 8 * 9 + 15?", "What is (100 - 32) / 4?", "What is 17 * 3 + 24 / 6?", "What is 250 / 5 * 2?", "What is 99 - 27 + 14?", ] def build_dataset(num_samples=200): samples = [] for i in range(num_samples): q = random.choice(questions) # 这里用真实计算得到标准答案 # 实际应用中应准备更丰富的题目生成逻辑 samples.append({ "prompt": q + "\nPlease provide the final answer only.", "answer": str(eval(q.split("?")[0].replace("What is ", "").replace("?", ""))), }) return samples if __name__ == "__main__": data = build_dataset(200) with open("data/train.jsonl", "w", encoding="utf-8") as f: for item in data: f.write(json.dumps(item, ensure_ascii=False) + "\n") print(f"Generated {len(data)} samples to data/train.jsonl")

注意：上面的 eval 仅用于示例，真实项目中不要对不可信字符串使用 eval。生产环境请使用安全计算库或解析器。

5.3 定义奖励函数

GRPO 训练中，奖励函数是核心。本文使用最简单的“答案匹配”规则奖励：

# 写进 grpo_train.py 中的奖励函数 import re def extract_answer(text: str) -> str: """从模型输出中提取最后一个数字或数学表达式结果。""" text = text.strip() # 匹配最后一个等号后的数字 patterns = [ r"[-+]?\d+\.?\d*$", # 以数字结尾 r"final answer is\s*[-+]?\d+\.?\d*", r"answer:\s*[-+]?\d+\.?\d*", ] for pattern in patterns: match = re.search(pattern, text, re.IGNORECASE) if match: return match.group(0) return "" def reward_fn(prompt, completion, answer, **kwargs): """规则奖励：模型输出与标准答案一致得 1 分，否则 0 分。""" extracted = extract_answer(completion) if extracted == str(answer): return 1.0 return 0.0

这里使用了简单的正则表达式，真实项目中可能需要更健壮的提取逻辑，尤其当模型输出很长时。

5.4 编写 GRPO 训练脚本

下面编写完整的训练脚本。为了便于复现，使用 LoRA 微调，基座模型选择 Qwen2.5-7B-Instruct。

# 文件路径：scripts/grpo_train.py import torch from datasets import load_dataset from transformers import AutoModelForCausalLM, AutoTokenizer from trl import GRPOConfig, GRPOTrainer from peft import LoraConfig import re # 1. 数据集加载 dataset = load_dataset("json", data_files="../data/train.jsonl", split="train") # 2. 模型与 tokenizer 加载 model_name = "Qwen/Qwen2.5-7B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True, ) # 3. LoRA 配置 lora_config = LoraConfig( r=16, lora_alpha=32, lora_dropout=0.05, target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], task_type="CAUSAL_LM", ) # 4. GRPO 训练参数配置 training_args = GRPOConfig( output_dir="../output/grpo_qwen25_7b_math", learning_rate=5e-6, per_device_train_batch_size=2, # 每个设备一次处理的 prompt 数 gradient_accumulation_steps=4, max_steps=200, logging_steps=10, save_steps=50, save_total_limit=2, bf16=True, gradient_checkpointing=True, report_to="none", max_prompt_length=256, max_completion_length=256, num_generations=8, # GRPO 每组采样 8 条回复 temperature=0.7, beta=0.04, # KL 惩罚系数 ) # 5. 奖励函数处理 def extract_answer(text: str) -> str: text = text.strip() patterns = [ r"[-+]?\d+\.?\d*$", r"final answer is\s*[-+]?\d+\.?\d*", r"answer:\s*[-+]?\d+\.?\d*", ] for pattern in patterns: match = re.search(pattern, text, re.IGNORECASE) if match: return match.group(0) return "" def reward_fn(prompt, completion, answer, **kwargs): extracted = extract_answer(completion) if extracted == str(answer): return 1.0 return 0.0 # 6. 创建 GRPO Trainer trainer = GRPOTrainer( model=model, processing_class=tokenizer, reward_funcs=[reward_fn], args=training_args, train_dataset=dataset, peft_config=lora_config, ) # 7. 开始训练 trainer.train() # 8. 保存最终模型 trainer.save_model("../output/grpo_qwen25_7b_math_final") tokenizer.save_pretrained("../output/grpo_qwen25_7b_math_final")

5.5 运行训练

在项目根目录执行：

cd scripts accelerate launch grpo_train.py

如果显存不足，可以将 per_device_train_batch_size 调为 1，或者启用更小的 LoRA 秩。

训练过程中会输出类似下面的日志：

Step 10: loss=0.5234, reward_mean=0.1250, kl_coef=0.0400 Step 20: loss=0.4812, reward_mean=0.2500, kl_coef=0.0400 Step 30: loss=0.4401, reward_mean=0.3750, kl_coef=0.0400

reward_mean 逐步上升，说明模型正在学会生成符合标准答案格式的回复。

5.6 结果验证

训练完成后，编写一个简单的推理脚本验证效果：

# 文件路径：scripts/evaluate.py import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_path = "../output/grpo_qwen25_7b_math_final" tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_path, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True, ) prompt = "What is 123 + 456?\nPlease provide the final answer only." messages = [ {"role": "user", "content": prompt}, ] input_ids = tokenizer.apply_chat_template( messages, add_generation_prompt=True, return_tensors="pt", ).to(model.device) output_ids = model.generate( input_ids, max_new_tokens=128, temperature=0.2, do_sample=True, ) response = tokenizer.decode(output_ids[0][input_ids.shape[1]:], skip_special_tokens=True) print("Q:", prompt) print("A:", response)

预期输出中应该包含数字 579，完整回答可能是：

Q: What is 123 + 456? Please provide the final answer only. A: The final answer is 579.

6. 常见问题与排查思路

RL 微调比 SFT 更容易出现训练异常。这里整理一些高频问题及排查方向。

6.1 训练过程中 reward_mean 始终为 0

排查建议：在训练脚本中增加回调，每训练 20 步打印一条未被选择的模型输出，直观看到模型回答格式与奖励函数是否匹配。

6.2 训练中出现 NaN loss

NaN loss 通常由以下原因导致：

• 模型精度设置不稳定：建议排查 bf16 和 fp16 的使用场景，如果显卡不支持 bf16，改用 fp32。
• 学习率过大：GRPO 训练中学习率建议从 1e-6 到 5e-6 起步，不宜超过 1e-5。
• 梯度裁剪缺失：确认框架是否默认启用了梯度裁剪。如果 options 中没有，可以设置 max_grad_norm 为 1.0。

解决方案优先级从低到高：降低学习率、开启梯度裁剪、切换为 fp32 混合精度。

6.3 OOM（显存不足）

RL 微调显存占用明显高于 SFT，OOM 是常见问题。排查顺序如下：

1. 降低 per_device_train_batch_size，从 2 降为 1。
2. 开启 gradient_checkpointing。
3. 使用 LoRA 微调，而非全参微调。
4. 调低 num_generations，例如从 8 降为 4。
5. 尝试使用 4-bit 量化加载模型，但会降低训练精度。

6.4 输出退化成重复话术

RL 训练后期，模型可能找到一条“高奖励”的捷径：不管输入什么问题，都输出同一个固定答案。这种模式很容易骗过简单规则奖励。排查方法：

• 观察 KL 散度是否异常下降，如果 KL 过小说明模型与参考模型分布差异很小，没有学到新东西；如果 KL 突然飙升，则说明模型开始偏离正常语言分布。
• 适当增大 β 值，加强 KL 惩罚。
• 在奖励函数中增加长度惩罚或格式惩罚，不允许输出过短或重复内容。

6.5 训练集 reward 高，测试集效果差

这是典型的过拟合信号。应对方式：

• 增加数据多样性，不要只使用模板化题目。
• 降低训练步数，early stopping 很重要。
• 增加 eval 集，每训练若干步在验证集上评测 reward_mean。

7. 最佳实践与工程建议

7.1 先 SFT 再 RL，不要跳过中间步骤

RL 微调不是万能药。如果模型连基本答案格式都生成不出来，RL 探索效率会非常低。稳妥的路线是：

1. 构造少量高质量 SFT 数据，让模型学会“回答问题的基本格式”。
2. 使用 SFT 模型作为 Reference Model。
3. 再执行 RL 微调，让模型学会“选择更优策略”。

很多项目中 SFT 数据只需要几百到几千条，目标是“学会答题格式”，而不是“学会知识”。知识仍然来自基座模型和 RL 探索。

7.2 奖励函数要简单、可解释、可调试

在设计奖励函数时，尽量遵循以下原则：

• 奖励值范围固定，例如 0 到 1，避免奖励尺度波动。
• 每个奖励维度单独记录，不要混合成一个不可解释的分数。
• 给奖励函数写单元测试，确保答案匹配逻辑正确。
• 在正式大规模训练前，先用 100 条小数据跑通流程。

7.3 监控训练状态：不只盯着 loss

RL 微调中最重要的监控指标不是 loss，而是：

• reward_mean：平均奖励值，反映策略提升速度。
• completion_length：模型输出长度，异常增加可能是奖励黑客行为。
• kl_divergence：与参考模型的 KL 散度，反映更新强度。
• response_entropy：输出熵，过大说明模型不稳定，过小说明模型collapse。

建议训练过程中持续记录这些指标。在 TRL 中可以设置 report_to="wandb" 或自定义回调，在 OpenRLHF 中有内置的监控面板。

7.4 控制训练轮数与步数

RL 微调步数不是越多越好。常见的问题是在训练后期，模型在训练集上 reward 还在上升，但实际能力已经下降。实践建议：

• 使用验证集监控 reward_mean，达到峰值后停止训练。
• 保存 checkpoints 选择最优版本。
• 当 KL 散度超过设定阈值时，提前终止。

7.5 关于模型安全与合规边界

在使用开源权重模型进行 RL 微调时，需要特别注意：

• 确保模型权重和数据集具备合法的使用许可。不同模型许可证差异较大，有些只允许研究用途，不可以在生产环境商用。
• RL 训练过程中，模型可能探索出一些意外输出。训练前应对提示词集合做安全过滤，并对奖励函数设定“安全护栏”，例如当输出包含不安全内容时给最低分。
• 涉及生成代码的场景，必须对模型生成的代码进行安全审查，不能直接在生产环境执行。

7.6 多做消融实验

RL 微调的超参数非常多，包括学习率、num_generations、β、采样温度等。建议每次只改动一个变量，通过小规模实验确定最优组合。

例如，先用 100 条数据分别测试 β=0.01、0.04、0.08 对训练稳定性的影响，再选择最优参数进行全量训练。这能省下大量试错成本。

8. 总结与下一步学习方向

本文从概念、原理、框架选型和工程实践四个层面，系统梳理了 RL Framework for Finetuning Openweight Models 的完整链路。读者应该已经掌握以下关键点：

• Openweight Models 是当前模型应用落地的务实选择，RL 微调能突破 SFT 的能力边界。
• PPO 和 GRPO 是主流 RL 微调算法，GRPO 通过组内相对奖励省去 Critic 模型，显存开销更低。
• 奖励函数设计决定了 RL 微调效果上限，规则奖励和模型奖励各自的适用场景不同。
• 使用 TRL 框架可以在单卡环境下快速完成 7B 模型的 GRPO 微调实战。
• 训练监控、KL 约束、超参数选择和过拟合控制，是保证训练稳定性的关键。

下一步建议按以下顺序深入：

1. 用本文代码替换更大的数学数据集，观察模型在 GSM8K、MATH 等评测集上的表现。
2. 尝试用 OpenRLHF 对 14B 以上模型做 RL 微调，理解规模化训练中的显存优化策略。
3. 引入 Reward Model，替换规则奖励函数，在对话生成任务上试验 RL 微调。
4. 研究 Agent 场景中 RL 微调的应用，例如 ReAct 模式的工具调用，这是目前业界关注度很高的方向。

RL 微调水很深，但入口并不复杂。建议读者一定要动手跑通最小案例，再逐步扩大规模和复杂度。过程中遇到问题，多打印模型输出、多观察 KL 和 reward 曲线、多对比不同超参组合，很快就能建立直觉。希望本文能帮助你在开放权重模型的 RL 微调之路上少走一些弯路。