💡强化学习(RL)指南

了解所有关于强化学习(RL)的内容,以及如何使用 Unsloth 和 GRPO 训练您自己的 DeepSeek-R1 推理模型。从初学到高级的完整指南。

强化学习是指一个“代理”通过与环境交互并接收 反馈 以…的形式 奖励惩罚.

  • 动作: 模型产生的内容(例如一句话)。

  • 奖励: 一个指示模型动作好坏的信号(例如:回答是否遵循指令?是否有帮助?)。

  • 环境: 模型正在处理的场景或任务(例如回答用户的问题)。

🦥你将学到的内容

  1. 什么是 RL?RLVR?PPO?GRPO?RLHF?RFT?是 “好运就是你所需要的一切?” 对于 RL?

  2. 什么是环境?代理?动作?奖励函数?奖励?

本文涵盖你需要了解的关于 GRPO、强化学习(RL)和奖励函数的一切(从入门到高级),并提供提示以及使用 GRPO 与 Unslotharrow-up-right的基础。如果你在寻找使用 GRPO 的逐步教程,请参见我们的指南 此处.

circle-check

什么是强化学习(RL)?

RL 的目标是:

  1. 增加看到 “良好” 结果的概率。

  2. 减少看到 “不良” 结果的概率。

结果的概率。 仅此而已!关于“良好”和“不良”是什么意思,或我们如何“增加”或“减少”它们,或者“结果”究竟意味着什么,存在很多细节。

例如,在 吃豆人游戏:

  1. 中, 环境 就是游戏世界。

  2. 中, 你可以采取的 动作是 上、左、右 和 下。

  3. 中, 奖励 如果你吃到饼干就是好的,或者如果你撞到那些弯曲的敌人就是不好的。

  4. 在 RL 中,你无法直接知道可以采取的“最佳动作”,但你可以观察到中间步骤或最终游戏状态(赢或输)。

另一个例子是想象你被问到: “2 + 2 等于多少?” (4)一个未对齐的语言模型可能会吐出 3、4、C、D、-10,几乎任何东西。

  1. 数字比 C 或 D 更好,对吧?

  2. 得到 3 比比如得到 8 要好,对吧?

  3. 得到 4 无疑是正确的。

我们刚刚设计了一个 奖励函数!

🏃从 RLHF、PPO 到 GRPO 和 RLVR

OpenAI 宣传了 RLHFarrow-up-right (来自人类反馈的强化学习),在该方法中我们训练一个 “代理” 对一个问题(即 状态)产生更被人类认为有用的输出。

例如 ChatGPT 中的点赞和点踩可以用于 RLHF 流程。

PPO 公式

clip(..., 1-e, 1+e) 项用于强制 PPO 不进行过大的参数变化。还有一个设置为 beta > 0 的 KL 项以强制模型不要偏离过多。

为了做 RLHF, PPOarrow-up-right (近端策略优化)被提出。这里的 代理 在此情况下是语言模型。事实上它由三个系统组成:

  1. 中, 生成策略(当前训练的模型)

  2. 中, 参考策略(原始模型)

  3. 中, 价值模型(平均奖励估计器)

我们使用 奖励模型 来计算当前环境的奖励,我们的目标是 最大化该奖励!

PPO 的公式看起来相当复杂,因为它被设计得很稳定。请参阅我们关于 RL 的 AI 工程师讲座arrow-up-right (我们在 2025 年做的),了解关于 PPO 更深入的数学推导。

DeepSeek 开发了 GRPOarrow-up-right (组相对策略优化)用于训练他们的 R1 推理模型。与 PPO 的关键区别是:

  1. 中, 价值模型被移除, 用多次调用奖励模型得到的统计数据取代。

  2. 中, 奖励模型被移除 并被仅由自定义奖励函数替代, 可以使用 RLVR

这意味着 GRPO 非常高效。之前 PPO 需要训练多个模型——现在移除奖励模型和价值模型后,我们可以节省内存并加速一切。

RLVR(具有可验证奖励的强化学习) 允许我们基于容易验证解答的任务来奖励模型。例如:

  1. 数学算式可以很容易验证。例如 2+2 = 4。

  2. 代码输出可以验证是否正确执行。

  3. 设计可验证的奖励函数可能很困难,因此大多数示例是数学或代码类的。

  4. GRPO 的用例不仅限于代码或数学——它的推理过程可以增强像电子邮件自动化、数据库检索、法律和医学等任务,基于你的数据集和奖励函数大幅提高准确性——关键是定义一个 评分标准(rubric)——即一系列较小且可验证的奖励,而不是一个最终的、涵盖一切的单一奖励。 OpenAI 在他们的 强化学习微调(RFT)arrow-up-right 服务中宣传了这一点,例如。

为什么称为“组相对(Group Relative)”?

GRPO 完全移除了价值模型,但我们仍需要估计当前状态下的 “平均奖励”

中, 技巧是对 LLM 进行采样!然后我们通过跨多个不同问题的采样过程的统计量来计算平均奖励。

例如对于“2+2 等于多少?”我们采样 4 次。可能得到 4、3、D、C。然后我们计算这些答案的每个奖励,接着计算 平均奖励标准差,然后 进行 Z 分数标准化

这产生了 优势 A,我们将用它来替代价值模型。这节省了大量内存!

GRPO 优势计算

🤞运气(或耐心)就是你所需要的一切

RL 的窍门是你只需要两样东西:

  1. 一个问题或指令,例如“2+2 等于多少?”、“用 Python 创建一个 Flappy Bird 游戏”

  2. 一个奖励函数和一个验证器,用来验证输出是好是坏。

仅有这两样,我们基本上可以 无限次调用一个语言模型 直到我们得到一个好答案。例如对于“2+2 等于多少?”,一个未训练的糟糕语言模型会输出:

0、cat、-10、1928、3、A、B、122、17、182、172、A、C、BAHS、%$、#、9、-192、12.31**** 然后突然出现 4.

奖励信号是 0、0、0、0、0、0、0、0、0、0、0、0、0、0、0**** 然后突然变成 1。

因此通过运气和机遇,RL 在多次 rollout中找到了正确答案。我们的目标是希望更多地看到正确答案 4,而其余(错误答案)显著减少。

所以 RL 的目标是要有耐心——在极限情况下,如果正确答案的概率至少是一个小的非零数,那这只是一个等待游戏——在极限下你肯定会遇到正确答案。

因此我喜欢把它称为“运气就是你所需要的一切”用于 RL。

更好的表达是对于 RL 而言“耐心就是你所需要的一切”。

RL 本质上给了我们一个技巧——我们不只是简单地等待无穷大,我们会得到“负信号”,即错误答案,而我们可以实质上“引导”模型尽量不生成错误解答。这意味着尽管你可能等待很久才出现一个“好”答案,模型已经被改变以尽力不输出错误答案。

在“2+2 等于多少?”的例子中—— 0、cat、-10、1928、3、A、B、122、17、182、172、A、C、BAHS、%$、#、9、-192、12.31**** 然后突然出现 4.

由于我们得到了错误答案,RL 会影响模型尝试不输出错误答案。这意味着随着时间推移,我们在小心地“修剪”或将模型的输出分布从错误答案移开。这意味着 RL 是 高效的,因为我们并不是仅仅等待无穷,而是在积极地“推动”模型尽可能进入“正确答案空间”。

triangle-exclamation

🦥Unsloth 为 RL 提供的功能

  • 在 15GB 显存下,Unsloth 允许你将任何最多 17B 参数的模型(如 Llama 3.1(8B)、Phi-4(14B)、Mistral(7B)或 Qwen2.5(7B))转换为推理模型

  • Unsloth 现在支持 用于视觉/多模态的 RL 模型!

  • 最低要求: 仅需 5GB 显存就足够在本地训练你自己的推理模型(任何参数量为 1.5B 或更小的模型)。

circle-info

有关 高级 GRPO 关于批处理、生成和训练参数的文档, 请阅读我们的指南!

GRPO 笔记本:

circle-check
  • 如果你没有获得任何推理输出,请确保你有足够的训练步数并确认你的 奖励函数/验证器 正在工作。我们提供奖励函数的示例 此处.

  • 之前的示范显示你可以用 Qwen2.5 (3B) 达到自己的“啊哈”时刻——但那需要 2 块 A100 GPU(160GB 显存)。现在,使用 Unsloth,你只需一块 5GB 显存的 GPU 就能达到相同的“啊哈”时刻。

  • 此前 GRPO 仅支持全量微调,但我们已使其可与 QLoRA 和 LoRA 一起工作

  • 20K 上下文长度 例如在每个提示生成 8 个序列的情况下,Unsloth 对于 Llama 3.1(8B)仅使用 54.3GB 显存,而标准实现(+ Flash Attention 2)需要 510.8GB(Unsloth 少 90%).

  • 请注意,这并不是微调 DeepSeek 的 R1 蒸馏模型或使用来自 R1 的蒸馏数据进行调优(Unsloth 已支持这些)。这是使用 GRPO 将标准模型转换为完整的推理模型。

在一个测试示例中,即使我们仅用 GRPO 对 Phi-4 进行了 100 步的训练,结果已经很明显。未使用 GRPO 的模型没有思考 token,而使用 GRPO 训练的模型有思考 token 并且也有正确答案。

💻使用 GRPO 训练

关于如何使用 Unsloth 与 GRPO 将任何开源 LLM 转换为推理模型的教程, 见此处.

circle-check

GRPO 如何训练模型

  1. 对于每个问答对,模型会生成多个可能的响应(例如 8 个变体)。

  2. 每个响应都用奖励函数进行评估。

  3. 训练步骤:

    • 如果你有 300 行数据,那就是 300 个训练步骤(或如果训练 3 个 epoch 则为 900 步)。

    • 你可以增加每个问题生成响应的数量(例如从 8 增加到 16)。

  4. 模型通过每一步更新其权重来学习。

circle-exclamation

基础/提示

  • 至少等待 300 步 以让奖励真正上升。为了获得不错的结果,你可能需要至少训练 12 小时(这就是 GRPO 的工作方式),但请记住这不是强制的,你可以随时停止。

  • 为了获得最佳效果至少要有 500 行数据。你可以尝试仅用 10 行数据,但更多数据更好。

  • 每次训练运行将始终根据你的模型、数据、奖励函数/验证器等有所不同,所以尽管我们写了 300 步作为最低,有时可能需要 1000 步或更多。这取决于各种因素。

  • 如果你在本地使用 Unsloth 与 GRPO,请在遇到错误时“pip install diffusers”。并请使用最新版本的 vLLM。

  • 建议将 GRPO 应用于至少有 1.5B 参数 的模型,以正确生成思考 token,因为较小的模型可能无法做到这一点。

  • 关于 GRPO 的 GPU 显存需求 对于 QLoRA 4-bit,通用规则是模型参数量 = 你将需要的显存量(你可以使用更少显存,但这是为了保险)。你设置的上下文长度越大,所需显存越多。LoRA 16-bit 最少会使用 4 倍以上的显存。

  • 持续微调是 可行的,你可以让 GRPO 在后台一直运行。

  • 在示例笔记本中,我们使用了 GSM8K 数据集,这是当前 R1 风格训练最受欢迎的选择。

  • 如果你使用的是基础模型,请确保你有一个聊天模板。

  • 你用 GRPO 训练得越多,效果越好。GRPO 最棒的部分是你甚至不需要那么多数据。你所需要的是一个优秀的奖励函数/验证器,训练时间越长,模型会变得越好。预期你的奖励随步数的变化会像这样上升:

  • GRPO 的训练损失跟踪现在直接内置于 Unsloth 中,消除了对 wandb 等外部工具的需求。它现在包含了所有奖励函数的完整日志细节,包括总体聚合的奖励函数本身。

在不受支持的模型上做 RL:

你也可以在 Unsloth 上对 vLLM 不支持的模型运行 RL,例如 Qwen3.5。只需在加载模型时设置 fast_inference=False 即可。

📋奖励函数 / 验证器

在强化学习中, 奖励函数验证器 在评估模型输出时承担不同的角色。一般而言,你可以把它们理解为相同的东西,但从技术上讲它们并不完全相同,不过这并不十分重要,因为它们通常是一起使用的。

验证器:

  • 确定生成的响应是正确还是错误。

  • 它不分配数值评分——它只是验证正确性。

  • 示例:如果模型对“2+2”生成“5”,验证器会检查并标记为“错误”(因为正确答案是 4)。

  • 验证器还可以执行代码(例如用 Python)来验证逻辑、语法和正确性,而无需人工评估。

奖励函数:

  • 将验证结果(或其他标准)转换为数值分数。

  • 示例:如果答案错误,可能会给予惩罚(-1、-2 等),而正确答案可能获得正分(+1、+2)。

  • 它也可以根据除正确性之外的标准进行惩罚,比如过长或可读性差。

关键区别:

  • 一个 验证器 用于检查正确性但不打分。

  • 一个 奖励函数 负责打分但不一定自行验证正确性。

  • 一个奖励函数 可以 使用验证器,但从技术上讲它们不是相同的东西。

理解奖励函数

GRPO 的主要目标是最大化奖励并学习答案是如何推导出来的,而不是简单地记忆和复现训练数据中的响应。

  • 在每个训练步骤中,GRPO 会 调整模型权重 以最大化奖励。这一过程逐步微调模型。

  • 常规微调 (不带 GRPO)仅仅 最大化下一个词的预测概率 但并不针对奖励进行优化。GRPO 针对奖励函数进行优化 而不是仅仅预测下一个词。

  • 你可以 在多个 epoch 间重用数据。 默认奖励函数

  • 可以预定义以用于各种用例,或者你可以让 ChatGPT/本地模型为你生成它们。 设计奖励函数或验证器没有单一正确的方法——可能性是无穷的。然而,它们必须设计良好且有意义,因为设计不当的奖励可能会无意中降低模型性能。

  • 奖励函数示例

🪙你可以参考下面的示例。你可以将生成内容输入诸如 ChatGPT 4o 或 Llama 3.1(8B)之类的 LLM,让其为你设计奖励函数和验证器。例如,将你的生成输入你选择的 LLM 并设定规则:“如果答案听起来太机械化,扣 3 分。”这有助于基于质量标准细化输出。

示例 #1:简单算术任务

问题:

  • 答案: "2 + 2"

  • 奖励函数 1: "4"

  • 如果检测到一个数字 →

    • 如果未检测到数字 → +1

    • 奖励函数 2: -1

  • 如果数字与正确答案匹配 →

    • 如果不正确 → +3

    • 总奖励: -3

  • 所有奖励函数的总和 示例 #2:电子邮件自动化任务

收件邮件

  • 答案: 发件邮件

  • 奖励函数 1: 奖励函数:

  • 如果答案包含必需关键词 →

    • 如果答案完全匹配理想响应 → +1

    • 如果响应过长 → +1

    • 如果包含收件人的名字 → -1

    • 如果包含签名块(电话、电子邮件、地址) → +1

    • Unsloth 基于接近度的奖励函数 +1

如果你查看了我们的

高级 GRPO Colab 笔记本 ,你会注意到我们创建了一个自定义的基于接近度的奖励函数 完全从头构建,旨在奖励更接近正确答案的回答。该灵活函数可应用于各种任务。 在我们的示例中,我们在 Qwen3(基础)中启用推理并将其引导到特定任务

  • 应用预微调策略以避免 GRPO 默认只学到格式化

  • 通过基于正则表达式的匹配提高评估准确性

  • 创建超越通用提示(例如

  • think )的自定义 GRPO 模板,例如,<start_working_out></end_working_out> 应用基于接近度的评分——模型对于更接近的答案获得更多奖励(例如预测 9 比 10 更接近比 3 更好),而离群值会被惩罚

  • GSM8K 奖励函数

在我们的其他示例中,我们使用了由

@willccbb 提供的现有 GSM8K 奖励函数,arrow-up-right 该函数很受欢迎并被证明相当有效:

  • correctness_reward_func – 奖励完全标签匹配。

  • int_reward_func – 鼓励仅使用整数答案。

  • soft_format_reward_func – 检查结构但允许轻微的换行不匹配。

  • strict_format_reward_func – 确保响应结构与提示匹配,包括换行符。

  • xmlcount_reward_func – 确保响应中每个 XML 标签恰好出现一次。

🧮使用 vLLM

你现在可以在微调堆栈中直接使用 vLLMarrow-up-right ,这可以带来更高吞吐量,并允许你同时对模型进行微调和推理!在 1x A100 40GB 上,使用 Unsloth 对 Llama 3.2 3B Instruct 的动态 4bit 量化,预期约 4000 tokens/s。在 16GB Tesla T4(Colab 免费 GPU)上,你可以获得约 300 tokens/s。 我们还神奇地消除了同时加载 vLLM 与 Unsloth 时的双倍内存使用,从而为 Llama 3.1 8B 节省约 5GB,为 Llama 3.2 3B 节省约 3GB 显存。Unsloth 最初可以在 1x 48GB GPU 上微调 Llama 3.3 70B Instruct,Llama 3.3 70B 权重占用 40GB 显存。如果我们不消除双倍内存使用,那么在同时加载 Unsloth 与 vLLM 时我们将需要 >= 80GB 显存。 但有了 Unsloth,你仍然可以在低于 48GB 显存的环境中同时获得微调和快速推理的好处!要使用快速推理,首先安装 vllm,并以 fast_inference 初始化 Unsloth:

GRPO 要求指南

当你使用 Unsloth 做 GRPO 时,通过使用多种技巧我们在与带 Flash Attention 2 的标准实现相比下智能地减少了超过 90% 的显存使用!例如在 20K 上下文长度且每个提示生成 8 个序列的情况下,Unsloth 对 Llama 3.1 8B 只使用 54.3GB 显存,而标准实现则需要 510.8GB(Unsloth 少 90%).

  1. 关于 GRPO 的 QLoRA 4-bit 的 GPU 显存需求,通用规则是模型参数量 = 你将需要的显存量(你可以使用更少显存,但这是为了保险)。你设置的上下文长度越大,所需显存越多。LoRA 16-bit 最少会使用 4 倍以上的显存。

  2. 我们新的内存高效线性核将 GRPO 的内存使用降低了 8 倍或更多。这削减了 68.5GB 的内存,同时在 torch.compile 的帮助下实际上还更快!

  3. 我们利用了我们以前发布的智能 Unsloth 梯度检查点arrow-up-right 算法。它智能地将中间激活异步卸载到系统 RAM,同时仅慢约 1%。这节省了 52GB 内存。

  4. Unsloth 还使用与底层推理引擎(vLLM)相同的 GPU / CUDA 内存空间,不像其他包的实现那样。这节省了 16GB 内存。

指标
Unsloth
标准 + FA2

训练内存成本(GB)

42GB

414GB

GRPO 内存成本(GB)

9.8GB

78.3GB

推理成本(GB)

0GB

16GB

20K 上下文长度的推理 KV 缓存(GB)

2.5GB

2.5GB

总内存使用

54.33GB(少 90%)

510.8GB

在典型的标准 GRPO 实现中,你需要创建两个大小为 (8, 20K) 的 logits 来计算 GRPO 损失。计算量为 2 * 2 字节 * 8(生成数) * 20K(上下文长度) * 128256(词汇表大小)= 78.3GB 显存。

Unsloth 为长上下文 GRPO 缩减了 8 倍的内存使用,因此在 20K 上下文长度下我们仅需额外 9.8GB 显存!

我们还需要将 KV 缓存以 16bit 形式取出。Llama 3.1 8B 有 32 层,且 K 与 V 的维度为 1024。因此 20K 上下文长度的内存使用 = 2 * 2 字节 * 32 层 * 20K 上下文长度 * 1024 = 每批次 2.5GB。我们会将 vLLM 的批大小设为 8,但为了节省显存在计算中我们将其设为 1。否则你将需要 20GB 的 KV 缓存。

🎥 Unsloth RL 3 小时研讨会视频

🎓进一步阅读

  1. Nathan Lambert 的 RLHF 书值得一读! https://rlhfbook.com/c/11-policy-gradients.htmlarrow-up-right

  2. Yannic Kilcher 的 GRPO 视频也很值得一看! https://www.youtube.com/watch?v=bAWV_yrqx4warrow-up-right

  3. 我们在 2025 年 AI 工程师世界博览会上做了一个 3 小时的研讨会。幻灯片和其他资料在 https://docs.unsloth.ai/ai-engineers-2025arrow-up-right

视频教程

以下是一些由我们认为很棒的 YouTuber 制作的视频教程,强烈推荐!

非常适合了解如何准备数据集以及强化学习 + GRPO 基础背后的解释
在你自己的设备上本地运行 GRPO

最后更新于

这有帮助吗?