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