# 強化学習（RL）ガイド

強化学習とは、"エージェント"が環境と相互作用しながら決定を下し、 **フィードバック** を **報酬** または **罰則**.

* **行動:** モデルが生成するもの（例: 文章）。
* **報酬:** モデルの行動がどれだけ良かったか、あるいは悪かったかを示す信号（例: 応答は指示に従っていたか？役に立ったか？）。
* **環境:** モデルが取り組んでいるシナリオやタスク（例: ユーザーの質問に答えること）。

### :sloth:学べること

1. RLとは？RLVR？PPO？GRPO？RLHF？RFT？ <mark style="background-color:green;">**"Luck is All You Need?"**</mark> はRL向け？
2. 環境とは？エージェント？行動？報酬関数？報酬？

この記事では、GRPO、強化学習（RL）、報酬関数について、初心者から上級者まで知っておくべきことをすべて解説し、ヒントやGRPOを使うための基礎も含めて、さらに [Unsloth](https://github.com/unslothai/unsloth)での基本的な使い方も紹介します。GRPOを使うための手順付きチュートリアルを探しているなら、ガイドを [こちら](/docs/jp/meru/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md).

{% hint style="success" %}
**2026年1月15日更新:** [超長文コンテキストRL](/docs/jp/meru/reinforcement-learning-rl-guide/grpo-long-context.md) が登場！380Kコンテキストウィンドウでgpt-ossを学習できます。

**2025年11月26日更新:** UnslothでFP8精度のRLとGRPOを導入します！ [ブログを読む](/docs/jp/meru/reinforcement-learning-rl-guide/fp8-reinforcement-learning.md)
{% endhint %}

## :question:強化学習（RL）とは？

RLの目標は次のとおりです:

1. **見られる可能性を高める&#x20;**<mark style="background-color:green;">**"良い"**</mark>**&#x20;結果。**
2. **見られる可能性を下げる&#x20;**<mark style="background-color:red;">**"悪い"**</mark>**&#x20;結果。**

**それだけです！** "良い"と"悪い"の意味、またそれをどうやって"増やす"または"減らす"のか、あるいはそもそも"結果"とは何を意味するのかには、細かな違いがあります。

{% columns %}
{% column width="50%" %}
たとえば、 **パックマンゲーム**:

1. では、 <mark style="background-color:green;">**環境**</mark> はゲームの世界です。
2. では、 <mark style="background-color:blue;">**行動**</mark> として取れるのは、上、左、右、下です。
3. では、 <mark style="background-color:purple;">**報酬**</mark> クッキーを食べれば良く、うねうねした敵の1体にぶつかれば悪いです。
4. RLでは、取るべき"最善の行動"は分かりませんが、中間ステップや最終的なゲーム状態（勝ちか負けか）を観測できます。
   {% endcolumn %}

{% column %}

<figure><img src="/files/bc21442345ab723899d7b60d94d7a1adee43031e" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

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

<figure><img src="/files/586923b247a29565a8b3588e03018bb377dc9c11" alt=""><figcaption></figcaption></figure>
{% endcolumn %}

{% column %}
別の例として、次の質問が与えられたとします: <mark style="background-color:blue;">**"2 + 2 はいくつですか？"**</mark> （4）整列されていない言語モデルは、3、4、C、D、-10など、文字通り何でも出力します。

1. 数字のほうがCやDより良いですよね？
2. 3を得るのは、たとえば8より良いですよね？
3. 4を得るのは間違いなく正解です。

私たちはちょうど <mark style="background-color:orange;">**報酬関数**</mark>!
{% endcolumn %}
{% endcolumns %}

### :person\_running:を設計したのです

{% columns %}
{% column %}

<figure><img src="/files/8d138eec2cb02cb1062570cfee3d1d665e232d2b" alt=""><figcaption></figcaption></figure>
{% endcolumn %}

{% column %}
RLHFからPPO、GRPO、RLVRへ [OpenAIは](https://en.wikipedia.org/wiki/Reinforcement_learning_from_human_feedback) RLHF <mark style="background-color:red;">**（人間のフィードバックからの強化学習）という概念を普及させました。ここでは、**</mark> "エージェント" <mark style="background-color:yellow;">**であるモデルを学習させ、質問に対する出力（**</mark>状態

）を、人間にとってより有用だと評価されるようにします。たとえばChatGPTの高評価・低評価ボタンは、RLHFのプロセスで使えます。
{% endcolumn %}
{% endcolumns %}

{% columns %}
{% column %}

<figure><img src="/files/ff2b2605a5405ec415db20c35ff03e23287bd4b9" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/bbe9435114f8dec7c669809fec8b69caec33cbe4" alt=""><figcaption><p>PPOの式</p></figcaption></figure>

clip(..., 1-e, 1+e) の項は、PPOが大きすぎる変化を取らないようにするために使われます。また、beta を > 0 に設定した KL 項もあり、モデルがあまり逸脱しないようにします。
{% endcolumn %}

{% column %}
RLHFを行うために、 [<mark style="background-color:red;">**PPO**</mark>](https://en.wikipedia.org/wiki/Proximal_policy_optimization) （近接方策最適化）が開発されました。この場合、 <mark style="background-color:blue;">**エージェント**</mark> は言語モデルです。実際には3つのシステムで構成されています:

1. では、 **生成方策（現在学習中のモデル）**
2. では、 **参照方策（元のモデル）**
3. では、 **価値モデル（平均報酬推定器）**

私たちは **報酬モデル** を使って現在の環境に対する報酬を計算し、私たちの目標はそれを **最大化すること**!

です。PPOの式がかなり複雑に見えるのは、安定性を重視して設計されたからです。PPOのより詳しい数学的導出については、2025年に行った私たちの [AI Engineerの講演](https://docs.unsloth.ai/ai-engineers-2025) をご覧ください。
{% endcolumn %}
{% endcolumns %}

{% columns %}
{% column %}

<figure><img src="/files/f85603680966e5900a03c5295e37bf9ebab4154f" alt=""><figcaption></figcaption></figure>
{% endcolumn %}

{% column %}
DeepSeekは [<mark style="background-color:red;">**GRPO**</mark>](https://unsloth.ai/blog/grpo) （Group Relative Policy Optimization）を開発し、R1推論モデルの学習に用いました。PPOとの主な違いは次のとおりです:

1. では、 **価値モデルが削除され、** 報酬モデルを複数回呼び出して得た統計に置き換えられます。
2. では、 **報酬モデルが削除され、** 代わりにカスタム報酬関数だけが使われ、 <mark style="background-color:blue;">**RLVR**</mark> が利用できます。
   {% endcolumn %}
   {% endcolumns %}

つまり、GRPOは非常に効率的です。以前のPPOでは複数のモデルを学習する必要がありましたが、今では報酬モデルと価値モデルが不要になったことで、メモリを節約し、全体を高速化できます。

<mark style="background-color:orange;">**RLVR（検証可能な報酬を用いた強化学習）**</mark> により、解を容易に検証できるタスクに基づいてモデルへ報酬を与えられます。たとえば:

1. 数式は簡単に検証できます。例: 2+2 = 4。
2. コード出力は、正しく実行されたかどうかを検証できます。
3. 検証可能な報酬関数を設計するのは難しいことがあり、そのため多くの例は数学かコードになります。
4. GRPOの用途はコードや数学だけではありません。推論プロセスは、メール自動化、データベース検索、法律、医療などのタスクを改善でき、データセットと報酬関数に基づく精度を大きく向上させます。コツは、 <mark style="background-color:yellow;">**ルーブリック、つまり最終的な単一報酬ではなく、より小さく検証可能な報酬の一覧を定義することです。**</mark> OpenAIはこれを [強化学習によるファインチューニング（RFT）](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) の提供で普及させました。

{% columns %}
{% column %} <mark style="background-color:red;">**なぜ"Group Relative"なのか？**</mark>

GRPOは価値モデルを完全に取り除きますが、それでも <mark style="background-color:yellow;">**"平均報酬"**</mark> を現在の状態に基づいて推定する必要があります。

では、 **コツはLLMをサンプリングすること**です！その後、複数の異なる質問にわたるサンプリング過程の統計から平均報酬を計算します。
{% endcolumn %}

{% column %}

<figure><img src="/files/99dad4199cac590a4f729156abb91c0fbce60c6d" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

{% columns %}
{% column %}
たとえば "2+2 は？" に対して4回サンプリングします。4、3、D、Cが得られるかもしれません。次にこれら各回答の報酬を計算し、 **平均報酬** と **標準偏差**を求め、さらに <mark style="background-color:red;">**Zスコアで標準化**</mark> します！

すると <mark style="background-color:blue;">**利点A**</mark>が得られ、これを価値モデルの代わりに使います。これで大幅にメモリを節約できます！
{% endcolumn %}

{% column %}

<figure><img src="/files/78738fef746819c101cfde6d307081e0cc8df81c" alt=""><figcaption><p>GRPOの利得計算</p></figcaption></figure>
{% 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\*\*\*\*\*\*\*\*&#x20;**<mark style="color:が緑色に;">**すると突然 4**</mark>**.***

***報酬信号は0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\*\*\*\*\*\*\*\*&#x20;**<mark style="color:が緑色に;">**その後突然1になります。**</mark>*

つまり、運と偶然によって、RLは複数の <mark style="background-color:yellow;">**ロールアウト**</mark>を通じて正解を見つけることができました。私たちの目標は、良い答えの4をより多く見せ、残りの（悪い答えを）ずっと少なくすることです。

<mark style="color:青;">**したがってRLの目標は忍耐強くあることです。極限では、正解の確率が少しでも0より大きければ、あとは待つだけです。極限では100%確実に正解に遭遇します。**</mark>

<mark style="background-color:blue;">**だから私はRLを"Luck Is All You Need"と呼びたくなります。**</mark>

<mark style="background-color:orange;">**まあ、RLにもっと適した表現は"Patience is All You Need"です。**</mark>

<figure><img src="/files/1c0054f0f14d689b7a9907aec1e6e8d4adceeaa7" alt="" width="375"><figcaption></figcaption></figure>

RLは本質的に私たちにコツを与えてくれます。単に無限に待つのではなく、私たちは"悪いシグナル"、つまり悪い答えを得るので、それを使ってモデルが悪い解を出さないようにすでに"導く"ことができます。つまり、"良い"答えが出るのを長く待っていたとしても、モデルはすでに悪い答えを出さないよう最善を尽くすよう変化しているのです。

"2+2 は？" の例では - ***0, cat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31\*\*\*\*\*\*\*\*&#x20;**<mark style="color:が緑色に;">**すると突然 4**</mark>**.***

悪い答えが得られたので、RLはモデルが悪い答えを出さないように影響します。つまり時間とともに、モデルの出力分布を悪い答えから慎重に"剪定"したり、遠ざけたりしています。これはRLが <mark style="color:青;">**効率的**</mark>であることを意味します。無限に待つのではなく、モデルをできるだけ"正解空間"へ押し込むよう積極的に試みているからです。

{% hint style="danger" %}
**確率が常に0なら、RLは決してうまくいきません**。これが、人々がすでに指示にある程度従える、指示チューニング済みのモデルからRLを行うのを好む理由でもあります。そうすることで、確率をおそらく0より十分大きくできます。
{% endhint %}

## :sloth:UnslothがRLで提供するもの

* 15GBのVRAMで、UnslothはLlama 3.1 (8B)、Phi-4 (14B)、Mistral (7B)、Qwen2.5 (7B)のような最大170億パラメータの任意のモデルを推論モデルへ変換できます。
* **Unslothは現在** [**Vision/マルチモーダル向けRL**](/docs/jp/meru/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) **モデルをサポートしています！**
* **最小要件:** たった5GBのVRAMで、ローカルで自分の推論モデルを学習するのに十分です（15億パラメータ以下の任意のモデル）

{% columns %}
{% column %}
{% content-ref url="/pages/db5a7a83b913f48723eb2d7a67636b192c105cd3" %}
[Tutorial: GRPO Training](/docs/jp/meru/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="/pages/01cdfed2f29f2821ff712fcb0ccb837f8ba4baf3" %}
[Vision RL](/docs/jp/meru/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

{% hint style="info" %}
について **高度なGRPO** のバッチ処理、生成、学習パラメータに関するドキュメントは、 [ガイドをお読みください！](/docs/jp/meru/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) - Vision GSPO | [Gemma 3 (4B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision-GRPO.ipynb) - Vision GSPO         |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Qwen3.5 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)_Vision_GRPO.ipynb) **- Vision -&#x20;*****新規***   | [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/jp/meru/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) で自分だけの"アハ体験"を得ることができましたが、2枚のA100 GPU（160GB VRAM）が必要でした。今ではUnslothを使えば、たった1枚の5GB VRAM GPUで同じ"アハ体験"を達成できます。
* 以前はGRPOはフルファインチューニングでのみサポートされていましたが、QLoRAとLoRAでも動作するようにしました
* で [**20Kのコンテキスト長**](#grpo-requirement-guidelines) を例にすると、プロンプトごとに8世代生成した場合、UnslothはLlama 3.1 (8B)でVRAMを54.3GBしか使用しませんが、標準実装（+ Flash Attention 2）は **510.8GB（Unslothは90%少ない）**.
* を必要とします。ご注意ください。これは、DeepSeekのR1蒸留モデルを微調整したり、R1の蒸留データを使って調整したりすることではありません。Unslothはすでにそれをサポートしています。これは、標準モデルをGRPOを使って本格的な推論モデルに変換するものです。

テスト例では、GRPOでPhi-4を100ステップだけ学習したにもかかわらず、結果はすでに明確です。GRPOなしのモデルには思考トークンがありませんが、GRPOで学習したモデルには思考トークンがあり、さらに正解も持っています。

<figure><img src="/files/4041fe92a35e09acbf920f72fd286c48ff65df7a" alt=""><figcaption></figcaption></figure>

## :computer:GRPOでの学習

UnslothとGRPOを使って任意のオープンLLMを推論モデルへ変換する方法のチュートリアルは、 [こちらをご覧ください](/docs/jp/meru/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md).

{% hint style="success" %}
について **高度なGRPO** のバッチ処理、生成、学習パラメータに関するドキュメントは、 [ガイドをお読みください！](/docs/jp/meru/reinforcement-learning-rl-guide/advanced-rl-documentation.md)
{% endhint %}

### **GRPOがモデルをどのように学習するか**

1. 各質問と回答のペアごとに、モデルは複数の可能な応答を生成します（例: 8種類）。
2. 各応答は報酬関数を使って評価されます。
3. 学習ステップ:
   * データが300行あれば、それは300学習ステップです（3エポックで学習すれば900ステップ）。
   * 質問ごとの生成応答数を増やせます（例: 8から16へ）。
4. モデルは各ステップで重みを更新することで学習します。

{% hint style="warning" %}
GRPOモデルが学習しない問題があるなら、ぜひ私たちの [高度なGRPOノートブック](/docs/jp/meru/unsloth-notebooks.md#grpo-reasoning-notebooks) を使うことを強くおすすめします。こちらのほうが報酬関数がはるかに優れており、結果もずっと速く、頻繁に得られるはずです。
{% endhint %}

### 基礎/ヒント

* 少なくとも **300ステップ** は、報酬が実際に増加するのを待ってください。十分な結果を得るには、最低12時間ほど試行する必要があるかもしれません（これがGRPOの仕組みです）。ただし、いつでも停止できるので必須ではありません。
* 最適な結果のためには少なくとも **500行のデータ**を用意してください。10行でも試せますが、より多いほうが良いです。
* 各学習実行は、モデル、データ、報酬関数/検証器などによって必ず異なります。そのため、300ステップを最低限として書いていますが、場合によっては1000ステップ以上必要になることもあります。つまり、さまざまな要因によります。
* UnslothをローカルでGRPOに使う場合、エラーが出たら "pip install diffusers" も実行してください。vLLMの最新バージョンも使ってください。
* GRPOを少なくとも **15億パラメータ** 以上のモデルに適用することを推奨します。小さなモデルでは思考トークンを正しく生成できない場合があるためです。
* 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の最大の利点は、そんなに多くのデータがなくてもよいことです。必要なのは優れた報酬関数/検証器だけで、学習に費やす時間が長いほどモデルは良くなります。時間の経過とともに、報酬対ステップがこのように増加することを期待してください:

  <figure><img src="/files/43fee5defbf977c33501f04af6f85f96f0a74f60" alt="" width="563"><figcaption></figcaption></figure>
* GRPOの学習損失の追跡は現在Unslothに直接組み込まれており、wandbなどの外部ツールは不要です。総合された報酬関数そのものを含め、すべての報酬関数の完全なログが含まれています。

<figure><img src="/files/97008ac918d9b01b147705eddd2f29bf4f8efc7a" alt=""><figcaption></figcaption></figure>

### 非対応モデルでのRL:

vLLMがサポートしていないモデルでも、UnslothでRLを実行できます。たとえば [Qwen3.5](/docs/jp/moderu/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は **次の単語を予測するだけではなく、報酬関数を最適化します** 。
* あなたは **データを再利用する** ことができます、複数のエポックにわたって。
* **デフォルトの報酬関数** は、幅広い用途で使えるよう事前定義しておくこともできますし、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`、例: `<start_working_out></end_working_out>`
* 近接ベースのスコアリングを適用する — モデルはより近い答えほど多くの報酬を得ます（例: 10ではなく9を予測するほうが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タグがちょうど1回ずつあることを保証します。

## :abacus:vLLMの使用

現在、 [vLLM](https://github.com/vllm-project/vllm/) をファインチューニングスタックに直接使えます。これによりスループットが大幅に向上し、同時にモデルのファインチューニングと推論が可能になります！ 1x A100 40GBでは、UnslothのLlama 3.2 3B Instructの動的4bit量子化で、およそ4000トークン/秒が期待できます。16GBのTesla T4（無料Colab GPU）では、300トークン/秒が得られます。\
\
また、vLLMとUnslothを一緒に読み込む際の二重メモリ使用を魔法のように解消し、Llama 3.1 8Bで約5GB、Llama 3.2 3Bで3GBの節約を実現しました。Unslothは元々、Llama 3.3 70B Instructを1x 48GB GPUでファインチューニングでき、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のコンテキスト長で、プロンプトごとに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向けの新しいメモリ効率の高い線形カーネルにより、メモリ使用量を8倍以上削減できます。torch.compileの助けもあり、実際にはさらに高速です！
3. 私たちは賢い [Unsloth gradient checkpointing](https://unsloth.ai/blog/long-context) アルゴリズムも活用しています。これは少し前に公開したもので、わずか1%遅くなるだけで、中間活性を非同期にシステムRAMへ賢くオフロードします。これで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実装では、GRPO損失を計算するためにサイズ(8. 20K)のlogitsを2つ作成する必要があります。これは 2 \* 2 bytes \* 8 (生成数) \* 20K (コンテキスト長) \* 128256 (語彙サイズ) = 78.3GB のVRAMを消費します。

Unslothは長文コンテキストGRPOのメモリ使用量を8倍削減するため、20Kコンテキスト長では追加VRAMはわずか9.8GBで済みます！

また、KVキャッシュを16bitで保持する必要があります。Llama 3.1 8Bは32層あり、KとVはいずれもサイズ1024です。したがって20Kコンテキスト長でのメモリ使用量は 2 \* 2 bytes \* 32 layers \* 20K context length \* 1024 = 2.5GB/バッチ です。VRAM節約のため、vLLMのバッチサイズは8に設定できますが、ここでは計算上1のままにします。そうしないとKVキャッシュだけで20GB必要になります。

## 🎥 Unsloth RL 3時間ワークショップ動画

{% embed url="<https://www.youtube.com/watch?v=OkEGJ5G3foU>" %}

## :mortar\_board:さらに読む

1. Nathan LambertのRLHF Bookは必読です！ <https://rlhfbook.com/c/11-policy-gradients.html>
2. Yannic KilcherのGRPO YouTube動画も必見です！ <https://www.youtube.com/watch?v=bAWV_yrqx4w>
3. AI Engineer World's Fair 2025で3時間のワークショップを行いました。スライドやその他の資料はこちらです: <https://docs.unsloth.ai/ai-engineers-2025>
4. Unsloth経由の高度なGRPOノートブック。 <https://docs.unsloth.ai/basics/reinforcement-learning-guide/tutorial-train-your-own-reasoning-model-with-grpo>
5. ベースモデルからのGRPOノートブック: <https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb>

## 動画チュートリアル

ここでは、私たちが素晴らしいと思う、すばらしいYouTuberたちによって作成された動画チュートリアルをいくつか紹介します！

{% embed url="<https://www.youtube.com/watch?v=9t-BAjzBWj8>" %}

{% columns %}
{% column width="50%" %}
{% embed url="<https://www.youtube.com/watch?t=3289s&v=bbFEYPx9Hpo>" %}
データセットの準備方法や、強化学習 + GRPOの基礎に関する説明を学ぶのに最適です
{% endembed %}

{% embed url="<https://www.youtube.com/watch?v=oF0_eMhzRaQ>" %}
{% endcolumn %}

{% column width="50%" %}
{% embed url="<https://www.youtube.com/watch?v=juOh1afy-IE>" %}

{% embed url="<https://www.youtube.com/watch?v=SoPE1cUz3Hs>" %}
自分のデバイスでローカルGRPO
{% endembed %}
{% endcolumn %}
{% endcolumns %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/jp/meru/reinforcement-learning-rl-guide.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
