GRPO 訓練器

概述

TRL 支援 GRPO 訓練器用於訓練語言模型，如論文 DeepSeekMath: 推動開放語言模型數學推理的極限 所述，作者為 Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y. K. Li, Y. Wu, Daya Guo。

論文摘要如下：

數學推理因其複雜和結構化的性質，對語言模型構成了重大挑戰。在本文中，我們介紹了 DeepSeekMath 7B，它在 DeepSeek-Coder-Base-v1.5 7B 的基礎上繼續預訓練，使用了來自 Common Crawl 的 1200 億個數學相關標記，以及自然語言和程式碼資料。DeepSeekMath 7B 在競賽級別的 MATH 基準測試中取得了令人印象深刻的 51.7% 的分數，而無需依賴外部工具包和投票技術，其效能水平接近 Gemini-Ultra 和 GPT-4。DeepSeekMath 7B 在 64 個樣本上進行自洽性測試，在 MATH 上達到了 60.9%。DeepSeekMath 的數學推理能力歸因於兩個關鍵因素：首先，我們透過精心設計的資料選擇管道，充分利用了公開網路資料的巨大潛力。其次，我們引入了組相對策略最佳化（GRPO），這是近端策略最佳化（PPO）的一個變體，它在增強數學推理能力的同時，優化了 PPO 的記憶體使用。

此後訓練方法由 Quentin Gallouédec 貢獻。

快速入門

此示例演示瞭如何使用 GRPO 方法訓練模型。我們使用 TLDR 資料集 中的提示（忽略完成列！）訓練了一個 Qwen 0.5B Instruct 模型。你可以在此處檢視資料集中的資料

以下是訓練模型的指令碼。

# train_grpo.py
from datasets import load_dataset
from trl import GRPOConfig, GRPOTrainer

dataset = load_dataset("trl-lib/tldr", split="train")

# Define the reward function, which rewards completions that are close to 20 characters
def reward_len(completions, **kwargs):
    return [-abs(20 - len(completion)) for completion in completions]

training_args = GRPOConfig(output_dir="Qwen2-0.5B-GRPO")
trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=reward_len,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

使用以下命令執行指令碼

accelerate launch train_grpo.py

在 8 個 GPU 上分散式訓練大約需要 1 天。

深入瞭解 GRPO 方法

GRPO 是一種線上學習演算法，這意味著它透過使用訓練好的模型在訓練期間生成的資料進行迭代改進。GRPO 目標的直覺是最大化生成完成的優勢，同時確保模型保持接近參考策略。要理解 GRPO 的工作原理，可以將其分解為四個主要步驟：**生成完成**、**計算優勢**、**估計 KL 散度**和**計算損失**。

生成完成

在每個訓練步驟中，我們取樣一批提示並生成一組$G$每個提示的完成（表示為$o_i$).

計算優勢

對於每個$G$序列，我們使用獎勵模型計算獎勵。為了與獎勵模型的比較性質保持一致——通常在相同問題的輸出之間進行比較的資料集上進行訓練——優勢的計算方式反映了這些相對比較。其標準化如下：$$\hat{A}_{i,t} = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r})}$$

這種方法因此得名：**群組相對策略最佳化 (GRPO)**。

估計 KL 散度

KL 散度使用 Schulman et al. (2020) 引入的近似器進行估計。近似器定義如下：$$\mathbb{D}_{\text{KL}}\left[\pi_\theta \|\pi_{\text{ref}}\right] = \frac{\pi_{\text{ref}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} - \log \frac{\pi_{\text{ref}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} - 1,$$

計算損失

目標是最大化優勢，同時確保模型保持接近參考策略。因此，損失定義如下：$$\mathcal{L}_{\text{GRPO}}(\theta) = -\frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \left[ \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\left[\pi_\theta(o_{i,t} \mid q, o_{i,< t})\right]_{\text{no grad}}} \hat{A}_{i,t} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right],$$

其中第一項代表縮放後的優勢，第二項透過 KL 散度懲罰與參考策略的偏差。

在原始論文中，此公式被泛化以考慮每次生成後的多次更新（表示為$\mu$，可在 GRPOConfig 中使用 num_iterations 設定），透過利用裁剪替代目標$$\mathcal{L}_{\text{GRPO}}(\theta) = - \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \left[ \min \left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \hat{A}_{i,t}, \, \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}, 1 - \epsilon, 1 + \epsilon \right) \hat{A}_{i,t} \right) - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right],$$

其中$\text{clip}(\cdot, 1 - \epsilon, 1 + \epsilon)$確保更新不會過度偏離參考策略，透過限制策略比率在以下範圍之間：$1 - \epsilon$和$1 + \epsilon$。當$\mu = 1$（TRL中的預設值）時，裁剪的替代目標簡化為原始目標。

損失型別

文獻中提出了幾種目標函式形式。最初，GRPO的目標函式定義如下：$$\mathcal{L}_{\text{GRPO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} l_{i,t},$$

其中$$l_{i,t} = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\left[\pi_\theta(o_{i,t} \mid q, o_{i,< t})\right]_{\text{no grad}}} \hat{A}_{i,t} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right].$$

DAPO論文強調了GRPO演算法在長CoT場景中樣本級損失的侷限性，即較長的響應受到懲罰不足，導致輸出質量較差。提出的解決方案是token級歸一化，它透過為單個token分配更平衡的獎勵，更好地處理較長序列，而不管響應長度如何：$$\mathcal{L}_{\text{DAPO}}(\theta) = - \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} l_{i,t},$$

此外，在理解R1-Zero類訓練：一個批判性視角論文中，作者指出原始GRPO公式引入了響應長度偏差。他們表明，雖然DAPO公式減少了這種偏差，但並未完全消除。為了完全消除這種偏差，他們提出用一個常數而不是序列長度進行除法，從而得到以下公式：$$\mathcal{L}_{\text{Dr. GRPO}}(\theta) = - \frac{1}{LG} \sum_{i=1}^G \sum_{t=1}^{|o_i|} l_{i,t},$$

這個常數建議設定為最大完成長度。要使用此公式，請在GRPOConfig中將loss_type設定為"dr_grpo"。

記錄指標

• num_tokens：迄今為止處理的令牌總數，包括提示和完成。
• completions/mean_length：生成的完成的平均長度。
• completions/min_length：生成的完成的最小長度。
• completions/max_length：生成的完成的最大長度。
• completions/mean_terminated_length：以EOS終止的生成的完成的平均長度。
• completions/min_terminated_length：以EOS終止的生成的完成的最小長度。
• completions/max_terminated_length：以EOS終止的生成的完成的最大長度。
• completions/clipped_ratio：截斷（裁剪）完成的比例。
• reward/{reward_func_name}/mean：特定獎勵函式的平均獎勵。
• reward/{reward_func_name}/std：特定獎勵函式的獎勵標準差。
• reward：應用獎勵權重後的總平均獎勵。
• reward_std：應用獎勵權重後，每個批次內總獎勵的標準差。
• frac_reward_zero_std：生成批次中獎勵標準差為零的樣本比例，這意味著該提示的多樣性很小（所有答案都正確或不正確）。
• entropy：生成的完成中token預測的平均熵。（如果`mask_truncated_completions=True`，則排除被掩碼的序列token。）
• kl：模型與參考模型之間的平均KL散度，在生成的完成上計算。僅當`beta`不為零時記錄。
• clip_ratio/region_mean：GRPO目標被裁剪以保持在信任區域內的token（或序列，如果importance_sampling_level="sequence"）機率的平均比率$$\text{clip}\left( r_{i,t}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \qquad r_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}\,.$$值越高意味著裁剪的token越多，這限制了策略$\pi_\theta$可以改變的幅度。
• clip_ratio/low_mean：在信任區域下限被裁剪的token（或序列，如果importance_sampling_level="sequence"）機率的平均比率$r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}$
• clip_ratio/low_min：在信任區域下限被裁剪的token（或序列，如果importance_sampling_level="sequence"）機率的最小比率$r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}$
• clip_ratio/high_mean：在信任區域上限被裁剪的token（或序列，如果importance_sampling_level="sequence"）機率的平均比率$r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}$
• clip_ratio/high_max：在信任區域上限被裁剪的token（或序列，如果importance_sampling_level="sequence"）機率的最大比率$r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}$.

定製化

透過vLLM加速訓練中的生成過程

在使用線上方法進行訓練時，生成通常是主要的瓶頸。為了加速生成，您可以使用vLLM，一個用於LLM的高吞吐量、低延遲推理引擎。要啟用它，首先透過以下方式安裝軟體包：

pip install trl[vllm]

我們支援兩種在訓練期間使用 vLLM 的方式：**伺服器模式**和**共置模式**。

🔌 選項 1：伺服器模式

在此模式下，vLLM 在單獨的程序中（並使用單獨的 GPU）執行，並透過 HTTP 與訓練器通訊。如果您有專用的 GPU 用於推理，此模式是理想選擇。

1. 啟動 vLLM 伺服器:

   已複製

   trl vllm-serve --model <model_name>

2. 在您的訓練指令碼中啟用伺服器模式:

   已複製

   from trl import GRPOConfig
   
   training_args = GRPOConfig(
       ...,
       use_vllm=True,
       vllm_mode="server",  # default value, can be omitted
   )

🧩 選項 2：並置模式

在此模式下，vLLM 在訓練器程序內執行，並與訓練模型共享 GPU 記憶體。這避免了啟動單獨的伺服器，可以提高 GPU 利用率，但也可能導致訓練 GPU 上的記憶體爭用。

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    use_vllm=True,
    vllm_mode="colocate",
)

有關更多資訊，請參閱 使用 vLLM 加速訓練。

大規模 GRPO：在多個節點上訓練 70B+ 模型

當訓練像 Qwen2.5-72B 這樣的大模型時，您需要一些關鍵的最佳化來使其在多個 GPU 和節點上高效且可擴充套件。這些最佳化包括

• DeepSpeed ZeRO Stage 3：ZeRO 利用資料並行來將模型狀態（權重、梯度、最佳化器狀態）分佈到多個 GPU 和 CPU 上，從而減少每個裝置的記憶體和計算要求。由於大模型無法在單個 GPU 上執行，因此訓練此類模型需要使用 ZeRO Stage 3。有關更多詳細資訊，請參閱 DeepSpeed 整合。
• Accelerate：Accelerate 是一個簡化跨多個 GPU 和節點分散式訓練的庫。它提供了一個簡單的 API 來啟動分散式訓練，並處理分散式訓練的複雜性，例如資料並行、梯度累積和分散式資料載入。有關更多詳細資訊，請參閱 分散式訓練。
• vLLM：請參閱上一節，瞭解如何使用 vLLM 加速生成。

以下是在多個節點上使用 GRPO 訓練 70B 模型的 SLURM 指令碼示例。此指令碼在 4 個節點上訓練模型，並使用第 5 個節點進行 vLLM 驅動的生成。

#!/bin/bash
#SBATCH --nodes=5
#SBATCH --gres=gpu:8

# Get the list of allocated nodes
NODELIST=($(scontrol show hostnames $SLURM_JOB_NODELIST))

# Assign the first 4 nodes for training and the 5th node for vLLM
TRAIN_NODES="${NODELIST[@]:0:4}"  # Nodes 0, 1, 2, 3 for training
VLLM_NODE="${NODELIST[4]}"  # Node 4 for vLLM

# Run training on the first 4 nodes (Group 1)
srun --nodes=4 --ntasks=4 --nodelist="${NODELIST[@]:0:4}" accelerate launch \
     --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
     --num_processes 32 \
     --num_machines 4 \
     --main_process_ip ${NODELIST[0]} \
     --machine_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     train_grpo.py \
     --server_ip $VLLM_NODE &

# Run vLLM server on the 5th node (Group 2)
srun --nodes=1 --ntasks=1 --nodelist="${NODELIST[4]}" trl vllm-serve --model Qwen/Qwen2.5-72B --tensor_parallel_size 8 &

wait

import argparse

from datasets import load_dataset
from trl import GRPOTrainer, GRPOConfig

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--vllm_server_host", type=str, default="", help="The server IP")
    args = parser.parse_args()

    # Example dataset from TLDR
    dataset = load_dataset("trl-lib/tldr", split="train")

    # Dummy reward function: count the number of unique characters in the completions
    def reward_num_unique_chars(completions, **kwargs):
        return [len(set(c)) for c in completions]

    training_args = GRPOConfig(
        output_dir="Qwen2.5-72B-GRPO",
        per_device_train_batch_size=4,
        bf16=True,
        gradient_checkpointing=True,
        use_vllm=True,
        vllm_server_host=args.vllm_server_host.replace("ip-", "").replace("-", "."),  # from ip-X-X-X-X to X.X.X.X
    )

    trainer = GRPOTrainer(model="Qwen/Qwen2.5-72B", args=training_args, reward_funcs=reward_num_unique_chars, train_dataset=dataset)
    trainer.train()

if __name__=="__main__":
    main()

使用自定義獎勵函式

GRPOTrainer 支援使用自定義獎勵函式而不是密集獎勵模型。為確保相容性，您的獎勵函式必須滿足以下要求

1. 輸入引數:

   • 函式必須接受以下作為關鍵字引數

     • prompts（包含提示），
     • completions（包含生成的補全），
     • completions_ids（包含標記化的補全），
     • trainer_state（TrainerState）：訓練器的當前狀態。這可用於實現動態獎勵函式，例如課程學習，其中獎勵根據訓練進度進行調整。
     • 資料集可能具有的所有列名（prompt 除外）。例如，如果資料集包含名為 ground_truth 的列，則函式將以 ground_truth 作為關鍵字引數呼叫。

     滿足此要求的最簡單方法是在函式簽名中使用 **kwargs。

   • 根據資料集格式，輸入將有所不同

     • 對於 標準格式，prompts 和 completions 將是字串列表。
     • 對於 對話格式，prompts 和 completions 將是訊息字典列表。

2. 返回值：函式必須返回一個浮點數列表。每個浮點數代表與單個補全對應的獎勵。

示例 1：獎勵更長的補全

下面是一個標準格式的獎勵函式示例，它獎勵更長的補全

def reward_func(completions_ids, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of token count)."""
    return [float(len(ids)) for ids in completions_ids]

您可以按如下方式測試它

>>> prompts = ["The sky is", "The sun is"]  # not used in the reward function, but the trainer will pass it
>>> completions = [" blue.", " in the sky."]  # not used in the reward function, but the trainer will pass it
>>> completions_ids = [[6303, 13], [304, 279, 12884, 13]]
>>> reward_func(prompts=prompts, completions=completions, completions_ids=completions_ids)
[2.0, 4.0]

示例 1.1：獎勵更長的補全（基於字元數）

與上一個示例相同，但這次獎勵函式基於字元數而不是標記。

def reward_func(completions, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of character count)."""
    return [float(len(completion)) for completion in completions]

您可以按如下方式測試它

>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> completions_ids = [[6303, 13], [304, 279, 12884, 13]]  # not used in the reward function, but the trainer will pass it
>>> reward_func(prompts=prompts, completions=completions, completions_ids=completions_ids)
[6.0, 12.0]

示例 2：獎勵具有特定格式的補全

下面是一個獎勵函式示例，它檢查補全是否具有特定格式。此示例的靈感來自論文 DeepSeek-R1：透過強化學習激勵 LLM 的推理能力 中使用的*格式獎勵*函式。它專為對話格式設計，其中提示和補全由結構化訊息組成。

import re

def format_reward_func(completions, **kwargs):
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<think>.*?</think><answer>.*?</answer>$"
    completion_contents = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, content) for content in completion_contents]
    return [1.0 if match else 0.0 for match in matches]

您可以按如下方式測試此功能

>>> prompts = [
...     [{"role": "assistant", "content": "What is the result of (1 + 2) * 4?"}],
...     [{"role": "assistant", "content": "What is the result of (3 + 1) * 2?"}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": "<think>The sum of 1 and 2 is 3, which we multiply by 4 to get 12.</think><answer>(1 + 2) * 4 = 12</answer>"}],
...     [{"role": "assistant", "content": "The sum of 3 and 1 is 4, which we multiply by 2 to get 8. So (3 + 1) * 2 = 8."}],
... ]
>>> format_reward_func(prompts=prompts, completions=completions)
[1.0, 0.0]

示例 3：根據參考獎勵補全

以下是一個獎勵函式示例，它檢查補全是否正確。此示例的靈感來自論文 DeepSeek-R1：透過強化學習激勵 LLM 的推理能力 中使用的*準確性獎勵*函式。此示例專為 標準格式 設計，其中資料集包含名為 ground_truth 的列。

import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]
    # Reward 1 if the content is the same as the ground truth, 0 otherwise
    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]

您可以按如下方式測試此功能

>>> prompts = ["Problem: Solve the equation $2x + 3 = 7$. Solution:", "Problem: Solve the equation $3x - 5 = 10$."]
>>> completions = [r" The solution is \boxed{2}.", r" The solution is \boxed{6}."]
>>> ground_truth = ["2", "5"]
>>> reward_func(prompts=prompts, completions=completions, ground_truth=ground_truth)
[1.0, 0.0]

示例 4：多工獎勵函式

以下是在 GRPOTrainer 中使用多個獎勵函式的示例。在此示例中，我們定義了兩個特定於任務的獎勵函式：math_reward_func 和 coding_reward_func。math_reward_func 根據正確性獎勵數學問題，而 coding_reward_func 根據解決方案是否有效獎勵編碼問題。

from datasets import Dataset
from trl import GRPOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": "What is 2+2?", "task": "math"},
        {"prompt": "Write a function that returns the sum of two numbers.", "task": "code"},
        {"prompt": "What is 3*4?", "task": "math"},
        {"prompt": "Write a function that returns the product of two numbers.", "task": "code"},
    ]
)

# Math-specific reward function
def math_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "math":
            # Calculate math-specific reward
            correct = check_math_solution(prompt, completion)
            reward = 1.0 if correct else -1.0
            rewards.append(reward)
        else:
            # Return None for non-math tasks
            rewards.append(None)
    return rewards

# Coding-specific reward function
def coding_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "coding":
            # Calculate coding-specific reward
            works = test_code_solution(prompt, completion)
            reward = 1.0 if works else -1.0
            rewards.append(reward)
        else:
            # Return None for non-coding tasks
            rewards.append(None)
    return rewards

# Use both task-specific reward functions
trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=[math_reward_func, coding_reward_func],
    train_dataset=dataset,
)

trainer.train()

在此示例中，math_reward_func 和 coding_reward_func 旨在與包含數學和編碼問題的混合資料集一起使用。資料集中的 task 列用於確定將哪個獎勵函式應用於每個問題。如果資料集中沒有與樣本相關的獎勵函式，則獎勵函式將返回 None，GRPOTrainer 將繼續使用有效的函式和任務。這允許 GRPOTrainer 處理具有不同適用性的多個獎勵函式。

請注意，GRPOTrainer 將忽略獎勵函式返回的 None 獎勵，只考慮相關函式返回的獎勵。這確保模型在相關任務上進行訓練，並忽略沒有相關獎勵函式的任務。

將獎勵函式傳遞給訓練器

要使用您的自定義獎勵函式，請按如下方式將其傳遞給 GRPOTrainer

from trl import GRPOTrainer

trainer = GRPOTrainer(
    reward_funcs=reward_func,
    ...,
)

如果您有多個獎勵函式，可以將其作為列表傳遞

from trl import GRPOTrainer

trainer = GRPOTrainer(
    reward_funcs=[reward_func1, reward_func2],
    ...,
)

獎勵將計算為每個函式的獎勵之和，如果配置中提供了 reward_weights，則為加權和。

請注意，GRPOTrainer 支援不同型別的多個獎勵函式。有關更多詳細資訊，請參閱引數文件。

視覺語言模型 (VLM) 訓練

GRPO 支援在包含文字和影像的多模態資料集上訓練視覺語言模型 (VLM)。

支援的模型

已測試的型號：

• Gemma3 — 例如，google/gemma-3-4b-it
• LLaVA-NeXT — 例如，llava-hf/llava-v1.6-mistral-7b-hf
• Qwen2-VL — 例如，Qwen/Qwen2-VL-2B-Instruct
• Qwen2.5-VL — 例如，Qwen/Qwen2.5-VL-3B-Instruct
• SmolVLM2 — 例如，HuggingFaceTB/SmolVLM2-2.2B-Instruct

快速入門

使用 grpo_vlm.py 對 VLM 進行微調。在 lmms-lab/multimodal-open-r1-8k-verified 上訓練的示例命令

accelerate launch \
  --config_file=examples/accelerate_configs/deepspeed_zero3.yaml \
  examples/scripts/grpo_vlm.py \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir grpo-Qwen2.5-VL-3B-Instruct \
  --learning_rate 1e-5 \
  --gradient_checkpointing \
  --torch_dtype bfloat16 \
  --max_prompt_length 2048 \
  --max_completion_length 1024 \
  --use_vllm \
  --vllm_mode colocate \
  --use_peft \
  --lora_target_modules "q_proj", "v_proj" \
  --log_completions

配置提示

• 在視覺-語言投影層上使用 LoRA
• 啟用 4 位量化以減少記憶體使用
• VLM 是記憶體密集型的——從較小的批次大小開始
• 大多數模型與 vLLM 相容（server 和 colocate 模式）

資料集格式

每個訓練樣本應包括

• prompt：透過處理器聊天模板格式化的文字
• image：單個影像（PIL 或 NumPy 陣列）

訓練器透過模型的影像處理器自動處理影像到張量的轉換。

GRPOTrainer

from datasets import load_dataset
from trl import GRPOTrainer

dataset = load_dataset("trl-lib/tldr", split="train")


def reward_func(completions, **kwargs):
    # Dummy reward function that rewards completions with more unique letters.
    return [float(len(set(completion))) for completion in completions]


trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=reward_func,
    train_dataset=dataset,
)

trainer.train()

GRPOConfig