> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide.md). # 强化学习（RL）指南全面了解强化学习（RL），以及如何使用 Unsloth 和 GRPO 训练你自己的 DeepSeek-R1 推理模型。从入门到高级的完整指南。强化学习是指“智能体”通过与环境交互并接收反馈来学习做决策的过程 **反馈** 以 **奖励** 或 **惩罚**. * **动作：** 模型生成的内容（例如一句话）。 * **奖励：** 表示模型动作有多好或多差的信号（例如，回复是否遵循指令？是否有帮助？）。 * **环境：** 模型正在处理的场景或任务（例如回答用户的问题）。 ### :sloth:你将学到什么 1. 什么是 RL？RLVR？PPO？GRPO？RLHF？是 **“Luck is All You Need?”** 适用于 RL？ 2. 什么是环境？智能体？动作？奖励函数？奖励？本文涵盖了你需要了解的关于 GRPO、强化学习（RL）和奖励函数的一切内容（从入门到高级），并附带技巧，以及使用 GRPO 的基础知识 [Unsloth](https://github.com/unslothai/unsloth)。如果你正在寻找使用 GRPO 的分步教程，请查看我们的指南 [这里](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md). {% hint style="success" %} **2026年1月15日更新：** [超长上下文 RL](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/grpo-long-context.md) 来了！使用 380K 上下文窗口训练 gpt-oss。 **2025年11月26日更新：** 我们正在 Unsloth 中引入 FP8 精度 RL 和 GRPO！ [阅读博客](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/fp8-reinforcement-learning.md) {% endhint %} ## :question:什么是强化学习（RL）？ RL 的目标是： 1. **增加看到 ****“好”**** 结果的概率。** 2. **降低看到 ****“坏”**** 结果的概率。** **就这么简单！** 其中“好”和“坏”意味着什么、我们如何去“增加”或“减少”它，甚至“结果”到底指什么，里面都有很多细节。 {% columns %} {% column width="50%" %} 例如，在 **吃豆人游戏**: 1. “ **环境中，** 就是游戏世界。 2. “ **动作** 可以是向上、向左、向右和向下。 3. “ **奖励** 如果你吃到饼干是好的，如果碰到那些扭来扭去的敌人就是坏的。 4. 在 RL 中，你无法知道自己能采取的“最佳动作”，但你可以观察中间步骤，或最终的游戏状态（赢或输） {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column width="50%" %}

{% endcolumn %} {% column %} 另一个例子是，假设你被问到： **“2 + 2 等于多少？”** （4）一个未对齐的语言模型可能会输出 3、4、C、D、-10，真的什么都可能。 1. 数字总比 C 或 D 好，对吧？ 2. 得到 3 总比比如 8 好，对吧？ 3. 得到 4 当然是正确的。我们刚刚设计了一个 **奖励函数**! {% endcolumn %} {% endcolumns %} ### :person\_running:从 RLHF、PPO 到 GRPO 和 RLVR {% columns %} {% column %}

{% endcolumn %} {% column %} OpenAI 普及了 [RLHF](https://en.wikipedia.org/wiki/Reinforcement_learning_from_human_feedback) （来自人类反馈的强化学习）的概念，在这种方法中，我们训练一个 **“智能体”** 根据一个问题（ **状态**）生成由人类认为更有用的输出。例如，ChatGPT 里的点赞和点踩就可以用于 RLHF 过程。 {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

clip(..., 1-e, 1+e) 项用于强制 PPO 不进行过大的变化。另外还有一个 KL 项，将 beta 设为 > 0，以强制模型不要偏离太远。 {% endcolumn %} {% column %} 为了进行 RLHF， [**PPO**](https://en.wikipedia.org/wiki/Proximal_policy_optimization) （近端策略优化，Proximal Policy Optimization）被提出。 **智能体** 在这里就是语言模型。实际上它由 3 个系统组成： 1. “ **生成策略（当前训练中的模型）** 2. “ **参考策略（原始模型）** 3. “ **价值模型（平均奖励估计器）** 我们使用 **奖励模型** 用于计算当前环境下的奖励，我们的目标是 **最大化这个奖励**! PPO 的公式看起来相当复杂，因为它是为了稳定性而设计的。请查看我们的 [AI 工程师演讲](https://docs.unsloth.ai/ai-engineers-2025) ，我们在 2025 年就 RL 所做的分享，以获得更深入的 PPO 数学推导。 {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

{% endcolumn %} {% column %} DeepSeek 开发了 [**GRPO**](https://unsloth.ai/blog/grpo) （组相对策略优化）来训练他们的 R1 推理模型。与 PPO 的关键区别是： 1. “ **价值模型被移除，** 改为使用多次调用奖励模型得到的统计量。 2. “ **奖励模型被移除** 并替换为自定义奖励函数， **RLVR** 可以使用。 {% endcolumn %} {% endcolumns %} 这意味着 GRPO 极其高效。过去 PPO 需要训练多个模型——现在移除了奖励模型和价值模型后，我们可以节省内存并加快一切速度。 **RLVR（可验证奖励强化学习）** 让我们能够根据那些有简单可验证解的任务来奖励模型。例如： 1. 数学方程可以很容易验证。例如 2+2 = 4。 2. 代码输出可以验证是否正确执行。 3. 设计可验证的奖励函数可能很难，所以大多数例子都来自数学或代码。 4. GRPO 的应用场景不只是代码或数学——它的推理过程还能增强电子邮件自动化、数据库检索、法律和医学等任务，并根据你的数据集和奖励函数大幅提升准确率——诀窍是定义一个 **评分标准——也就是一组较小、可验证的奖励，而不是一个最终包揽一切的单一奖励。** OpenAI 在他们的 [强化学习微调（RFT）](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) 产品中普及了这一点，例如。 {% columns %} {% column %} **为什么是“Group Relative（组相对）”？** GRPO 完全移除了价值模型，但我们仍然需要估计 **“平均奖励”** ，这是在当前状态下得到的。 “ **诀窍是对 LLM 进行采样**！然后我们通过跨多个不同问题的采样过程统计来计算平均奖励。 {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} 例如，对于“2+2 等于多少？”，我们采样 4 次。可能得到 4、3、D、C。然后我们为这些答案分别计算奖励，再计算 **平均奖励** 和 **标准差**，然后 **做 Z 分数标准化** ！这就产生了 **优势 A**，我们会用它来替代价值模型。这能节省大量内存！ {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} ### :fingers\_crossed:Luck（好吧，耐心）就是你所需要的一切 RL 的诀窍其实只需要 2 件事： 1. 一个问题或指令，例如“2+2 等于多少？”、“用 Python 创建一个 Flappy Bird 游戏” 2. 一个奖励函数和验证器，用来验证输出是好还是坏。只要这 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 的目标就是要有耐心——从极限意义上说，如果正确答案的概率至少是一个很小的数（不为 0），那就只是等待游戏——最终你 100% 一定会遇到正确答案。** **所以我喜欢把 RL 称为“Luck Is All You Need”。** **不过更好的说法是：RL 的“Patience is All You Need”。**

RL 本质上给了我们一个技巧——我们不只是傻等到无限，而是会拿到“坏信号”，也就是错误答案，然后我们实际上可以“引导”模型尽量不要生成坏的解。这意味着，尽管你要等很久才会冒出一个“好”答案，模型本身已经被改变成尽可能不要输出坏答案。在“2+2 等于多少？”这个例子中—— ***0, cat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31\*\*\*\*\*\*\*\* ****然后突然变成 4****.*** 由于我们得到了坏答案，RL 会影响模型尽量不要输出坏答案。这意味着随着时间推移，我们正在小心地“剪枝”或把模型的输出分布从坏答案中移开。这意味着 RL 是 **高效的**，因为我们并不是只是等到无限，而是在主动尝试把模型尽可能“推向”“正确答案空间”。 {% hint style="danger" %} **如果概率始终是 0，那么 RL 永远不会起作用**。这也是为什么人们喜欢在一个已经经过指令微调、能够在一定程度上合理遵循指令的模型上做 RL——这会把概率很可能提升到 0 以上。 {% endhint %} ## :sloth:Unsloth 为 RL 提供了什么 * 使用 15GB VRAM，Unsloth 允许你把任何参数规模最高达 17B 的模型，如 Llama 3.1（8B）、Phi-4（14B）、Mistral（7B）或 Qwen2.5（7B），转换成推理模型 * **Unsloth 现在支持** [**视觉/多模态的 RL**](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) **模型！** * **最低要求：** 仅需 5GB VRAM，就足以在本地训练你自己的推理模型（适用于参数量为 1.5B 或更少的模型） {% columns %} {% column %} {% content-ref url="/pages/289d4338990d56fc4202e77bbae62bb949a7b439" %} [Tutorial: GRPO Training](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md) {% endcontent-ref %} {% endcolumn %} {% column %} {% content-ref url="/pages/1d7550c0346dc79003c120cca2e0063a9addf768" %} [Vision RL](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) {% endcontent-ref %} {% endcolumn %} {% endcolumns %} {% hint style="info" %} 对于 **高级 GRPO** 关于批处理、生成和训练参数的文档， [阅读我们的指南！](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/advanced-rl-documentation.md) {% endhint %} ### GRPO 笔记本： | [**Gemma 4 E2B**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_$E2B$_Reinforcement_Learning_Sudoku_Game.ipynb) - **新的** | [Qwen3-VL-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_VL_$8B$-Vision-GRPO.ipynb) - 视觉 GSPO | [Gemma 3（4B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_$4B$-Vision-GRPO.ipynb) - 视觉 GSPO | | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | | [**Qwen3.5（4B）**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_$4B$_Vision_GRPO.ipynb) **- 视觉 - *****新的*** | [gpt-oss-20b](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-$20B$-GRPO.ipynb) GSPO | [Llama 3.2（3B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Advanced_Llama3_2_$3B$_GRPO_LoRA.ipynb) - 高级 | | [Qwen3（4B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_$4B$-GRPO.ipynb) - 高级 | [Phi-4（14B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Phi_4_$14B$-GRPO.ipynb) | [DeepSeek-R1-0528-Qwen3-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/DeepSeek_R1_0528_Qwen3_$8B$_GRPO.ipynb) | | [Mistral v0.3（7B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Mistral_v0.3_$7B$-GRPO.ipynb) | [Llama 3.1（8B）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.1_$8B$-GRPO.ipynb) | [Qwen3-8B - **FP8**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_8B_FP8_GRPO.ipynb) （L4） | {% hint style="success" %} 我们支持 [**GSPO**](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/advanced-rl-documentation/gspo-reinforcement-learning.md) 以及大多数其他新的 GRPO 技术。你可以在 GRPOConfig 中尝试以下参数来启用： ```python epsilon=0.2, epsilon_high=0.28, # 单边 delta=1.5 # 双边 loss_type='gspo', # 或： loss_type='grpo', # 或： loss_type='dr_grpo', mask_truncated_completions=True, ``` {% endhint %} * 如果你没有得到任何推理过程，请确保你的训练步数足够，并确认你的 [奖励函数/验证器](#reward-functions-verifier) 正在正常工作。我们为奖励函数提供了示例 [这里](#reward-function-examples). * 之前的演示表明，你可以用 Qwen2.5（3B）实现自己的“aha”时刻——但这需要 2xA100 GPU（160GB VRAM）。现在，借助 Unsloth，你只需一块 5GB VRAM 的 GPU 就能实现同样的“aha”时刻。 * 以前，GRPO 只支持全参数微调，但我们已经让它与 QLoRA 和 LoRA 配合工作 * 在 [**20K 上下文长度**](#grpo-requirement-guidelines) 下，例如每个 prompt 生成 8 个结果时，Unsloth 仅使用 Llama 3.1（8B）的 54.3GB VRAM，而标准实现（+ Flash Attention 2）需要 **510.8GB（Unsloth 少 90%）**. * 请注意，这不是在微调 DeepSeek 的 R1 蒸馏模型，也不是使用来自 R1 的蒸馏数据进行调优——这些 Unsloth 已经支持。这是在使用 GRPO 将标准模型转换为完整的推理模型。在一个测试示例中，尽管我们只用 GRPO 训练了 Phi-4 100 步，结果已经很明显。没有使用 GRPO 的模型没有思考 token，而使用 GRPO 训练的模型不仅有思考 token，而且也给出了正确答案。

## :computer:使用 GRPO 训练想了解如何使用 Unsloth 和 GRPO 将任意开源 LLM 转换为推理模型的教程， [请看这里](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md). {% hint style="success" %} 对于 **高级 GRPO** 关于批处理、生成和训练参数的文档， [阅读我们的指南！](/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide/advanced-rl-documentation.md) {% endhint %} ### **GRPO 如何训练模型** 1. 对于每个问答对，模型会生成多个可能的回复（例如，8 个变体）。 2. 每个回复都会使用奖励函数进行评估。 3. 训练步骤： * 如果你有 300 行数据，那就是 300 个训练步骤（如果训练 3 个 epoch，则为 900 步）。 * 你可以增加每个问题生成的回复数量（例如，从 8 个增加到 16 个）。 4. 模型通过每一步更新权重来学习。 {% hint style="warning" %} 如果你遇到 GRPO 模型无法学习的问题，我们强烈建议你使用我们的 [高级 GRPO 笔记本](/docs/zh/kuai-su-kai-shi/unsloth-notebooks.md#grpo-reasoning-notebooks) 因为它拥有更好的奖励函数，你应该会更快、更频繁地看到结果。 {% endhint %} ### 基础/提示 * 至少等待 **300 步** 让奖励真正上升。为了得到像样的结果，你可能需要至少投入 12 小时（这就是 GRPO 的工作方式），但请记住这不是强制性的，因为你可以随时停止。 * 为了获得最佳结果，至少要有 **500 行数据**。你甚至可以只用 10 行数据试试，但更多会更好。 * 每次训练运行都会因模型、数据、奖励函数/验证器等不同而不同。因此，尽管我们写 300 步作为最低值，但有时可能需要 1000 步或更多。所以，这取决于各种因素。 * 如果你在本地使用 Unsloth 的 GRPO，并且遇到错误，请也执行“pip install diffusers”。同时请使用最新版本的 vLLM。 * 建议将 GRPO 应用于至少 **1.5B 参数** 的模型，以正确生成思考 token，因为更小的模型可能做不到。 * 关于 GRPO 的 [**GPU VRAM 需求**](#grpo-requirement-guidelines) **对于 QLoRA 4-bit**，一般规则是：模型参数量 = 你需要的 VRAM 量（你也可以用更少的 VRAM，但这里只是为了安全起见）。你设置的上下文长度越大，所需 VRAM 越多。LoRA 16-bit 至少会使用 4 倍以上的 VRAM。 * **持续微调是** 可行的，你可以把 GRPO 放在后台继续运行。 * 在示例笔记本中，我们使用 [**GSM8K 数据集**](#gsm8k-reward-functions)，这是目前最受欢迎的 R1 风格训练选择。 * 如果你使用的是基础模型，请确保你有一个聊天模板。 * 你用 GRPO 训练得越多越好。GRPO 最棒的一点是，你甚至不需要太多数据。你只需要一个很棒的奖励函数/验证器，而且训练时间越长，你的模型就会越好。预计你的 reward vs step 会随着时间推移像这样上升：

* GRPO 的训练损失跟踪现在已直接内置到 Unsloth 中，不再需要 wandb 等外部工具。它现在包含所有奖励函数的完整日志细节，包括总的聚合奖励函数本身。

### 在不受支持的模型上进行 RL：你也可以在 vLLM 不支持的模型上使用 Unsloth 运行 RL，例如 [Qwen3.5](/docs/zh/mo-xing/qwen3.5/fine-tune.md)。只需设置 `fast_inference=False` 在加载模型时。 ```python from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name="unsloth/Qwen3.5-4B", fast_inference=False, ) ``` ## :clipboard:奖励函数 / 验证器在强化学习中，一个 **奖励函数** 和一个 **验证器** 在评估模型输出时承担不同角色。一般来说，你可以把它们理解为同一回事，不过从技术上讲它们并不相同，但这没那么重要，因为它们通常是一起使用的。 **验证器**: * 判断生成的回复是正确还是错误。 * 它不会给出数值分数——它只是验证正确性。 * 例如，如果模型对“2+2”生成了“5”，验证器会检查并把它标记为“错误”（因为正确答案是 4）。 * 验证器还可以执行代码（例如 Python）来验证逻辑、语法和正确性，而不需要人工评估。 **奖励函数**: * 将验证结果（或其他标准）转换为数值分数。 * 例如，如果答案错误，可能会给予惩罚（-1、-2 等）；而正确答案则可能得到正分（+1、+2）。 * 它也可以根据正确性之外的标准进行惩罚，例如过长或可读性差。 **关键区别**: * 一个 **验证器** 检查正确性，但不打分。 * 一个 **奖励函数** 给出分数，但不一定自行验证正确性。 * 一个奖励函数 *可以* 会使用验证器，但从技术上讲它们并不相同。 ### **理解奖励函数** GRPO 的主要目标是最大化奖励并学习答案是如何得出的，而不仅仅是记住并复现训练数据中的回复。 * 每一步训练中，GRPO 都会 **调整模型权重** 以最大化奖励。这个过程会逐步微调模型。 * **普通微调** （没有 GRPO）只会 **最大化下一个词的预测概率** 但不会针对奖励进行优化。GRPO **优化的是奖励函数** 而不只是预测下一个词。 * 你可以 **复用数据** 跨多个 epoch。 * **默认奖励函数** 可以预先定义，以用于广泛的使用场景；或者你也可以让 ChatGPT/本地模型帮你生成。 * 设计奖励函数或验证器并没有唯一正确的方法——可能性是无限的。不过，它们必须设计得好且有意义，因为糟糕的奖励设计会无意中降低模型性能。 ### :coin:奖励函数示例你可以参考下面的示例。你可以把你的生成结果输入像 ChatGPT 4o 或 Llama 3.1（8B）这样的 LLM，并设计一个奖励函数和验证器来评估它。例如，把你的生成结果输入你选择的 LLM，并设置一条规则：“如果答案听起来太像机器人，就扣 3 分。”这有助于根据质量标准优化输出 #### **示例 #1：简单算术任务** * **问题：** `"2 + 2"` * **答案：** `"4"` * **奖励函数 1：** * 如果检测到数字 → **+1** * 如果未检测到数字 → **-1** * **奖励函数 2：** * 如果数字与正确答案匹配 → **+3** * 如果错误 → **-3** * **总奖励：** *所有奖励函数之和* #### **示例 #2：电子邮件自动化任务** * **问题：** 收到的邮件 * **答案：** 发出的邮件 * **奖励函数：** * 如果答案包含必需的关键词 → **+1** * 如果答案与理想响应完全匹配 → **+1** * 如果回复过长 → **-1** * 如果包含收件人姓名 → **+1** * 如果包含签名块（电话、电子邮件、地址）→ **+1** ### Unsloth 基于接近度的奖励函数如果你看过我们的 [**高级 GRPO Colab 笔记本**](#grpo-notebooks)，你会注意到我们创建了一个 **自定义的基于接近度的奖励函数** ，它完全从零构建，旨在奖励更接近正确答案的输出。这个灵活的函数可应用于广泛的任务。 * 在我们的示例中，我们在 Qwen3（Base）中启用推理，并引导它朝向特定任务 * 应用预微调策略，避免 GRPO 默认倾向于只学习格式 * 使用基于正则表达式的匹配提高评估准确率 * 创建超越通用提示词的自定义 GRPO 模板，例如 `think`，例如， `` * 应用基于接近度的评分——模型对更接近的答案会获得更多奖励（例如，预测 9 而不是 10 比预测 3 更好），而离群值会受到惩罚 #### GSM8K 奖励函数在我们其他示例中，我们使用由 [@willccbb](https://x.com/willccbb) 提供的现有 GSM8K 奖励函数，它很受欢迎，而且被证明相当有效： * **correctness\_reward\_func** – 奖励与标签完全匹配。 * **int\_reward\_func** – 鼓励只包含整数的答案。 * **soft\_format\_reward\_func** – 检查结构，但允许轻微的换行不匹配。 * **strict\_format\_reward\_func** – 确保回复结构与提示一致，包括换行。 * **xmlcount\_reward\_func** – 确保回复中每种 XML 标签都恰好出现一次。 ## :abacus:直接在你的微调栈中使用 vLLM 你现在可以使用 [vLLM](https://github.com/vllm-project/vllm/) ，这能带来更高的吞吐量，并允许你同时对模型进行微调和推理！在 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 VRAM。如果我们不移除双重内存占用，那么同时加载 Unsloth 和 vLLM 时就需要 >= 80GB 的 VRAM。\ \ 但借助 Unsloth，你仍然可以在 48GB 以下的 VRAM 中完成微调，并享受快速推理的一体化优势！要使用快速推理，先安装 vllm，然后用 fast\_inference 实例化 Unsloth： ```python # pip install unsloth vllm from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name = "unsloth/Llama-3.2-3B-Instruct", fast_inference = True, ) ``` ## :white\_check\_mark:GRPO 要求指南当你使用 Unsloth 进行 GRPO 时，我们通过多种技巧，相比使用 Flash Attention 2 的标准实现，智能地将 VRAM 使用量降低超过 90%！例如在 20K 上下文长度、每个 prompt 8 个生成的情况下，Unsloth 仅使用 **Llama 3.1 8B 的 54.3GB VRAM**，而标准实现需要 **510.8GB（Unsloth 少 90%）**. 1. 关于 GRPO 的 **QLoRA 4-bit 的 GPU VRAM 需求**，一般规则是：模型参数量 = 你需要的 VRAM 量（你也可以用更少的 VRAM，但这里只是为了安全起见）。你设置的上下文长度越大，所需 VRAM 越多。LoRA 16-bit 至少会使用 4 倍以上的 VRAM。 2. 我们为 GRPO 新开发的高内存效率线性 kernel 将内存使用量降低了 8 倍甚至更多。这节省了 68.5GB 内存，而且借助 torch.compile 实际上还更快！ 3. 我们利用了我们的智能 [Unsloth 梯度检查点](https://unsloth.ai/blog/long-context) 算法，这是我们之前发布的。它会以异步方式智能地把中间激活值卸载到系统 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 Cache（GB） | 2.5GB | 2.5GB | | 总内存使用量 | 54.33GB（少 90%） | 510.8GB | 在典型的标准 GRPO 实现中，你需要创建两个大小为（8，20K）的 logits 来计算 GRPO 损失。这需要 2 \* 2 字节 \* 8（生成数）\* 20K（上下文长度）\* 128256（词表大小）= 78.3GB VRAM。 Unsloth 将长上下文 GRPO 的内存使用量削减了 8 倍，所以在 20K 上下文长度下，我们只需要额外 9.8GB 的 VRAM！我们还需要以 16bit 形式存储 KV Cache。Llama 3.1 8B 有 32 层，K 和 V 的大小都是 1024。所以 20K 上下文长度的内存使用量 = 2 \* 2 字节 \* 32 层 \* 20K 上下文长度 \* 1024 = 每个 batch 2.5GB。我们会把 vLLM 的 batch size 设置为 8，但为了节省 VRAM，在这里的计算中我们将其保留为 1。否则，KV cache 需要 20GB。 ## 🎥 Unsloth RL 3 小时工作坊视频 {% embed url="" %} ## :mortar\_board:进一步阅读 1. Nathan Lambert 的 RLHF 书是必读！ 2. Yannic Kilcher 的 GRPO YouTube 视频也是必看！ 3. 我们在 2025 年 AI Engineer World's Fair 上做了一场 3 小时的工作坊。幻灯片和其他材料在 4. 通过 Unsloth 提供的高级 GRPO 笔记本。 5. 基于基础模型的 GRPO 笔记本： ## 视频教程以下是由一些出色的 YouTuber 制作的视频教程，我们认为他们非常棒！ {% embed url="" %} {% columns %} {% column width="50%" %} {% embed url="" %} 适合学习如何准备你的数据集，以及强化学习 + GRPO 基础知识背后的解释 {% endembed %} {% embed url="" %} {% endcolumn %} {% column width="50%" %} {% embed url="" %} {% embed url="" %} 在你自己的设备上进行本地 GRPO {% endembed %} {% endcolumn %} {% endcolumns %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/zh/kuai-su-kai-shi/reinforcement-learning-rl-guide.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.