【DeepSeek】LLM强化学习GRPO Trainer详解

FF-Studio2025-01-29 20:26

GRPO 训练器概述

TRL 支持使用 GRPO 训练器来训练语言模型，正如 Zhihong Shao、Peiyi Wang、Qihao Zhu、Runxin Xu、Junxiao Song、Mingchuan Zhang、Y. K. Li、Y. Wu 和 Daya Guo 在论文 DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models 中所述。

以下是该论文的摘要：

数学推理因其复杂和结构化的性质，对语言模型提出了重大挑战。在本文中，我们介绍了 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 方法训练模型。我们使用 Qwen 0.5B 模型 作为基础模型，并使用 RM-Gemma-2B 模型 作为奖励模型。我们使用 TLDR 数据集 中的提示（忽略 completion 列！）。您可以在此处查看数据集中的数据：

以下是用以训练模型的脚本。我们使用 PEFT 来减少内存需求。

python 复制代码 
from datasets import load_dataset
from peft import LoraConfig
from trl import GRPOConfig, GRPOTrainer


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

training_args = GRPOConfig(
    output_dir="Qwen2-0.5B-GRPO",
    learning_rate=1e-5,
    logging_steps=10,
    gradient_accumulation_steps=16,
    max_completion_length=128,
)
trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs="weqweasdas/RM-Gemma-2B",
    args=training_args,
    train_dataset=dataset,
    peft_config=LoraConfig(task_type="CAUSAL_LM"),
)

trainer.train()

使用以下命令执行脚本：

bash 复制代码 
accelerate launch train_grpo.py

分布在 8 个 GPU 上，训练大约需要 1 天时间。

深入了解 GRPO 方法

GRPO 是一种在线学习算法，这意味着它通过在训练期间使用受训模型自身生成的数据来迭代改进。GRPO 目标背后的直觉是最大化生成补全的优势，同时确保模型保持接近参考策略。为了理解 GRPO 的工作原理，可以将其分解为四个主要步骤：生成补全 、计算优势 、估计 KL 散度 和计算损失。

生成补全

在每个训练步骤中，我们对一批提示进行采样，并为每个提示生成一组 G G G 个补全（表示为 o i o_i oi）。

计算优势

对于每个 G G G 序列，我们使用奖励模型计算奖励。为了与奖励模型的比较性质（通常在相同问题的输出之间进行比较的数据集上训练）保持一致，计算优势以反映这些相对比较。其归一化如下：
A ^ i , t = r i − mean ( r ) std ( r ) \hat{A}_{i,t} = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r})} A^i,t=std(r)ri−mean(r)

这种方法赋予了该方法其名称：群组相对策略优化 (GRPO)。

估计 KL 散度

KL 散度使用 Schulman 等人 (2020) 引入的近似器进行估计。该近似器定义如下：
D KL [ π θ ∥ π ref ] = π ref ( o i , t ∣ q , o i , < t ) π θ ( o i , t ∣ q , o i , < t ) − log ⁡ π ref ( o i , t ∣ q , o i , < t ) π θ ( o i , t ∣ q , o i , < t ) − 1 \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 DKL[πθ∥πref]=πθ(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t)−logπθ(oi,t∣q,oi,<t)πref(oi,t∣q,oi,<t)−1

计算损失

目标是最大化优势，同时确保模型保持接近参考策略。因此，损失定义如下：
L GRPO ( θ ) = − 1 G ∑ i = 1 G 1 ∣ o i ∣ ∑ t = 1 ∣ o i ∣ [ π θ ( o i , t ∣ q , o i , < t ) [ π θ ( o i , t ∣ q , o i , < t ) ] no grad A ^ i , t − β D KL [ π θ ∥ π ref ] ] \mathcal{L}{\text{GRPO}}(\theta) = -\frac{1}{G} \sum{i=1}^G \frac{1}{|o_i|} \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] LGRPO(θ)=−G1∑i=1G∣oi∣1∑t=1∣oi∣[[πθ(oi,t∣q,oi,<t)]no gradπθ(oi,t∣q,oi,<t)A^i,t−βDKL[πθ∥πref]]

其中第一项表示缩放后的优势，第二项通过 KL 散度惩罚偏离参考策略的行为。

在原始论文中，通过利用裁剪的替代目标函数 ，将此公式推广到考虑每次生成后的多次更新：
L GRPO ( θ ) = − 1 G ∑ i = 1 G 1 ∣ o i ∣ ∑ t = 1 ∣ o i ∣ [ min ⁡ ( π θ ( o i , t ∣ q , o i , < t ) π θ old ( o i , t ∣ q , o i , < t ) A ^ i , t ,   clip ( π θ ( o i , t ∣ q , o i , < t ) π θ old ( o i , t ∣ q , o i , < t ) , 1 − ϵ , 1 + ϵ ) A ^ i , t ) − β D KL [ π θ ∥ π ref ] ] \mathcal{L}{\text{GRPO}}(\theta) = - \frac{1}{G} \sum{i=1}^G \frac{1}{|o_i|} \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] LGRPO(θ)=−G1∑i=1G∣oi∣1∑t=1∣oi∣[min(πθold(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)A^i,t,clip(πθold(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t),1−ϵ,1+ϵ)A^i,t)−βDKL[πθ∥πref]]

其中 clip ( ⋅ , 1 − ϵ , 1 + ϵ ) \text{clip}(\cdot, 1 - \epsilon, 1 + \epsilon) clip(⋅,1−ϵ,1+ϵ) 通过将策略比率限制在 1 − ϵ 1 - \epsilon 1−ϵ 和 1 + ϵ 1 + \epsilon 1+ϵ 之间，确保更新不会过度偏离参考策略。然而，在 TRL 中，与原始论文一样，我们每次生成只进行一次更新，因此我们可以将损失简化为第一种形式。

记录的指标

GRPO 训练器记录以下指标：

  • completion_length：平均补全长度。
  • reward/{reward_func_name}：每个奖励函数计算的奖励。
  • reward：平均奖励。
  • reward_std：奖励组内的平均标准差。
  • kl：模型与参考模型之间在补全上计算的平均 KL 散度。

定制

使用自定义奖励函数

GRPOTrainer 支持使用自定义奖励函数来代替密集奖励模型。为了确保兼容性，您的奖励函数必须满足以下要求：

  1. 输入参数：

    • 函数必须接受以下内容作为关键字参数：

      • prompts（包含提示），
      • completions（包含生成的补全），
      • 数据集可能包含的所有列名（但prompt除外）。例如，如果数据集包含名为ground_truth的列，则将使用ground_truth作为关键字参数调用该函数。

      满足此要求的最简单方法是在函数签名中使用**kwargs。

    • 根据数据集格式，输入会有所不同：

      • 对于标准格式，prompts和completions将是字符串列表。
      • 对于对话格式，prompts和completions将是消息字典列表。

  2. 返回值：函数必须返回一个浮点数列表。每个浮点数代表对应于单个补全的奖励。

示例 1：奖励较长的补全

以下是一个针对标准格式的奖励函数示例，它奖励较长的补全：

python 复制代码 
def reward_func(completions, **kwargs):
    """奖励函数，对较长的补全给予更高的分数。"""
    return [float(len(completion)) for completion in completions]

您可以按如下方式进行测试：

python 复制代码 
>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> print(reward_func(prompts=prompts, completions=completions))
[6.0, 12.0]
示例 2：奖励具有特定格式的补全

以下是一个奖励函数示例，它检查补全是否具有特定格式。此示例的灵感来自论文 DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning 中使用的_格式奖励_函数。它是为对话格式设计的，其中提示和补全由结构化消息组成。

python 复制代码 
import re

def format_reward_func(completions, **kwargs):
    """奖励函数，检查补全是否具有特定格式。"""
    pattern = r"^&lt;think&gt;.*?&lt;/think&gt;&lt;answer&gt;.*?&lt;/answer&gt;$"
    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]

您可以按如下方式测试此函数：

python 复制代码 
>>> 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: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning 中使用的_准确性奖励_函数。此示例是为 标准格式 设计的，其中数据集包含名为ground_truth的列。

python 复制代码 
import re

def reward_func(completions, ground_truth, **kwargs):

    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]

    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]

您可以按如下方式测试此函数：

python 复制代码 
>>> 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]
将奖励函数传递给训练器

要使用您的自定义奖励函数，请将其传递给GRPOTrainer，如下所示：

python 复制代码 
from trl import GRPOTrainer

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

如果您有多个奖励函数，可以将它们作为列表传递：

python 复制代码 
from trl import GRPOTrainer

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

奖励将计算为每个函数奖励的总和。

请注意，GRPOTrainer 支持不同类型的多个奖励函数。有关更多详细信息，请参阅参数文档。

GRPOTrainer

trl.GRPOTrainer类

< source >

python 复制代码 
(
    # 模型，可以是字符串（模型ID或路径）或预训练模型对象
    model: typing.Union[str, transformers.modeling_utils.PreTrainedModel], 

    # 奖励函数，可以是单个或多个，支持字符串（模型ID或路径）、预训练模型对象、或自定义函数
    reward_funcs: typing.Union[
        str, 
        transformers.modeling_utils.PreTrainedModel, 
        typing.Callable[[list, list], list[float]], 
        list[
            typing.Union[
                str, 
                transformers.modeling_utils.PreTrainedModel, 
                typing.Callable[[list, list], list[float]]
            ]
        ]
    ], 

    # GRPOConfig配置类，包含训练的所有参数。如果未提供，则使用默认配置。
    args: GRPOConfig = None, 

    # 训练数据集，必须包含名为"prompt"的列，可以是Dataset或IterableDataset
    train_dataset: typing.Union[
        datasets.arrow_dataset.Dataset, 
        datasets.iterable_dataset.IterableDataset, 
        NoneType
    ] = None, 

    # 评估数据集，与训练数据集要求一致，可以是字典形式，用于支持多种评估集。
    eval_dataset: typing.Union[
        datasets.arrow_dataset.Dataset, 
        datasets.iterable_dataset.IterableDataset, 
        dict[
            str, 
            typing.Union[
                datasets.arrow_dataset.Dataset, 
                datasets.iterable_dataset.IterableDataset
            ]
        ], 
        NoneType
    ] = None, 

    # 数据处理器类，用于对训练和评估数据进行预处理
    processing_class: typing.Optional[
        transformers.tokenization_utils_base.PreTrainedTokenizerBase
    ] = None, 

    # 奖励函数对应的分词器，支持单个分词器或多个分词器的列表
    reward_processing_classes: typing.Union[
        transformers.tokenization_utils_base.PreTrainedTokenizerBase, 
        list[
            transformers.tokenization_utils_base.PreTrainedTokenizerBase
        ], 
        NoneType
    ] = None, 

    # 自定义训练回调列表，可扩展或覆盖默认的训练过程
    callbacks: typing.Optional[
        list[
            transformers.trainer_callback.TrainerCallback
        ]
    ] = None, 

    # 优化器和学习率调度器的元组，默认为使用AdamW和线性调度器
    optimizers: tuple = (None, None), 

    # PEFT配置，用于支持高效微调（如LoRA等方法），可选
    peft_config: typing.Optional[
        ForwardRef('PeftConfig')
    ] = None
)

参数

  • model (Union[str, PreTrainedModel]) --- 待训练的模型。可以是：

    • 字符串，即托管在 huggingface.co 上的模型仓库中的预训练模型的 模型 ID ，或使用 save_pretrained 保存的模型权重的 目录 的路径，例如 './my_model_directory/'。模型使用 from_pretrained 加载，并带有 args.model_init_kwargs 中的关键字参数。
    • PreTrainedModel 对象。仅支持因果语言模型。

  • reward_funcs (Union[RewardFunc, list[RewardFunc]]) --- 用于计算奖励的奖励函数。为了计算奖励，我们调用所有奖励函数，并使用提示和补全，并将奖励相加。可以是：

    • 单个奖励函数，例如：
      • 字符串：托管在 huggingface.co 上的模型仓库中的预训练模型的 模型 ID ，或使用 save_pretrained 保存的模型权重的 目录 的路径，例如 './my_model_directory/'。模型使用 from_pretrained 加载，并带有 num_labels=1 和 args.model_init_kwargs 中的关键字参数。
      • PreTrainedModel 对象：仅支持序列分类模型。
      • 自定义奖励函数：为函数提供提示和生成的补全，以及数据集中的任何其他列。它应该返回一个奖励列表。有关更多详细信息，请参阅使用自定义奖励函数。
    • 奖励函数列表，其中每个项目可以独立地是上述任何类型。允许在列表中混合不同类型（例如，字符串模型 ID 和自定义奖励函数）。

  • args (GRPOConfig，可选 ，默认为 None) --- 此训练器的配置。如果为 None，则使用默认配置。

  • train_dataset (Dataset 或 IterableDataset) --- 用于训练的数据集。它必须包含名为 "prompt" 的列。将忽略数据集中的任何其他列。样本的格式可以是：

    • 标准格式：每个样本包含纯文本。
    • 对话格式：每个样本包含结构化消息（例如，角色和内容）。

  • eval_dataset (Dataset，IterableDataset 或 dict[str, Union[Dataset, IterableDataset]]) --- 用于评估的数据集。它必须满足与 train_dataset 相同的要求。

  • processing_class (PreTrainedTokenizerBase，可选 ，默认为 None) --- 用于处理数据的处理类。填充侧必须设置为 "left"。如果为 None，则使用 from_pretrained 从模型名称加载处理类。

  • reward_processing_classes (Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]，可选 ，默认为 None) --- 对应于 reward_funcs 中指定的奖励函数的处理类。可以是：

    • 单个处理类：当 reward_funcs 仅包含一个奖励函数时使用。
    • 处理类列表：必须与 reward_funcs 中奖励函数的顺序和长度匹配。如果设置为 None，或者如果列表中对应于 PreTrainedModel 的元素为 None，则会使用 from_pretrained 自动加载模型的分词器。对于 reward_funcs 中是自定义奖励函数（不是 PreTrainedModel）的元素，将忽略 reward_processing_classes 中的相应条目。

  • callbacks (TrainerCallback 列表，可选 ，默认为 None) --- 用于自定义训练循环的回调列表。会将这些添加到此处详细介绍的默认回调列表中。

    如果要删除使用的默认回调之一，请使用 remove_callback 方法。

  • optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]，可选 ，默认为 (None, None)) --- 包含要使用的优化器和调度器的元组。默认情况下，将在您的模型上使用 AdamW 的实例，并使用由 args 控制的 get_linear_schedule_with_warmup 给出的调度器。

  • peft_config (~peft.PeftConfig，可选 ，默认为 None) --- 用于包装模型的 PEFT 配置。如果为 None，则不包装模型。

用于群组相对策略优化 (GRPO) 方法的训练器。该算法最初在论文 DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models 中提出。

示例：

python 复制代码 
from datasets import load_dataset
from trl import GRPOTrainer

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

trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs="weqweasdas/RM-Gemma-2B",
    train_dataset=dataset,
)

trainer.train()
create_model_card

< source >

(model_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, tags: typing.Union[str, list[str], NoneType] = None)

参数

  • model_name (str 或 None，可选 ，默认为 None) --- 模型的名称。
  • dataset_name (str 或 None，可选 ，默认为 None) --- 用于训练的数据集的名称。
  • tags (str、list[str] 或 None，可选 ，默认为 None) --- 要与模型卡关联的标签。

使用 Trainer 可用的信息创建模型卡草稿。

GRPOTrainer

类 trl.GRPOTrainer

< source >

python 复制代码 
(
    # 模型：可以是字符串（模型ID或路径）或一个预训练模型对象。
    model: typing.Union[str, transformers.modeling_utils.PreTrainedModel], 

    # 奖励函数：单个或多个奖励函数，用于计算生成结果的奖励。
    # 支持以下三种类型：
    # 1. 字符串：HuggingFace仓库中的模型ID或本地路径。
    # 2. 预训练模型对象：如因果语言模型或分类模型。
    # 3. 自定义函数：接受提示和补全作为输入，返回奖励值的列表。
    reward_funcs: typing.Union[
        str, 
        transformers.modeling_utils.PreTrainedModel, 
        typing.Callable[[list, list], list[float]], 
        list[
            typing.Union[
                str, 
                transformers.modeling_utils.PreTrainedModel, 
                typing.Callable[[list, list], list[float]]
            ]
        ]
    ], 

    # 配置：GRPOConfig对象，包含训练和优化的参数设置。
    # 如果未提供，将使用默认的配置。
    args: GRPOConfig = None, 

    # 训练数据集：必须包含 "prompt" 列，格式可以是标准文本或对话式结构。
    train_dataset: typing.Union[
        datasets.arrow_dataset.Dataset, 
        datasets.iterable_dataset.IterableDataset, 
        NoneType
    ] = None, 

    # 评估数据集：与训练数据集要求一致，可以是单一数据集或多数据集的字典。
    eval_dataset: typing.Union[
        datasets.arrow_dataset.Dataset, 
        datasets.iterable_dataset.IterableDataset, 
        dict[
            str, 
            typing.Union[
                datasets.arrow_dataset.Dataset, 
                datasets.iterable_dataset.IterableDataset
            ]
        ], 
        NoneType
    ] = None, 

    # 数据处理器：处理训练和评估数据的分词器，支持左侧填充。
    # 如果未指定，将自动根据模型加载。
    processing_class: typing.Optional[
        transformers.tokenization_utils_base.PreTrainedTokenizerBase
    ] = None, 

    # 奖励处理器：与奖励函数匹配的分词器，可为单个分词器或分词器列表。
    # 如果为None，将根据模型自动加载分词器。
    reward_processing_classes: typing.Union[
        transformers.tokenization_utils_base.PreTrainedTokenizerBase, 
        list[
            transformers.tokenization_utils_base.PreTrainedTokenizerBase
        ], 
        NoneType
    ] = None, 

    # 回调函数：用于训练过程中的自定义操作，支持多个回调。
    # 可以扩展默认回调或移除不需要的回调。
    callbacks: typing.Optional[
        list[
            transformers.trainer_callback.TrainerCallback
        ]
    ] = None, 

    # 优化器和调度器：默认使用AdamW优化器和线性学习率调度器。
    # 用户可以提供自定义的优化器或调度器。
    optimizers: tuple = (None, None), 

    # PEFT（参数高效微调）配置：用于轻量化微调模型的配置。
    # 如果不需要PEFT功能，可以设置为None。
    peft_config: typing.Optional[
        ForwardRef('PeftConfig')
    ] = None
)

参数

  • model (Union[str, PreTrainedModel]) --- 待训练的模型。可以是以下两种：

    • 字符串形式的预训练模型的 模型 ID ，该模型托管在 huggingface.co 的模型仓库中；或者包含模型权重的 本地目录 路径（这些权重使用 save_pretrained 保存），例如 './my_model_directory/'。模型使用 from_pretrained 加载，并使用 args.model_init_kwargs 中的关键字参数。
    • PreTrainedModel 对象。仅支持因果语言模型。

  • reward_funcs (Union[RewardFunc, list[RewardFunc]]) --- 用于计算奖励的奖励函数。我们将调用所有奖励函数，并传入提示和补全，然后将所有奖励函数的返回值相加作为最终奖励。可以是以下两种：

    • 单个奖励函数，例如：
      • 字符串：预训练模型的 模型 ID （托管在 huggingface.co 的模型仓库中），或保存模型权重的 本地目录 路径（使用 save_pretrained 保存），例如 './my_model_directory/'。模型使用 from_pretrained 加载，并使用 num_labels=1 和 args.model_init_kwargs 中的关键字参数。
      • PreTrainedModel 对象：仅支持序列分类模型。
      • 自定义奖励函数：该函数接收提示、生成的补全以及数据集中任何其他列作为输入。它应该返回一个奖励值的列表。更多详细信息，请参阅使用自定义奖励函数。
    • 奖励函数列表，其中每个元素可以独立地是上述任何类型。允许在列表中混合使用不同类型的奖励函数（例如，字符串形式的模型 ID 和自定义奖励函数）。

  • args (GRPOConfig，可选 ，默认为 None) --- 此训练器的配置。如果为 None，则使用默认配置。

  • train_dataset (Dataset 或 IterableDataset) --- 用于训练的数据集。它必须包含名为 "prompt" 的列。数据集中的任何其他列都将被忽略。样本的格式可以是以下两种：

    • 标准格式：每个样本包含纯文本。
    • 对话格式：每个样本包含结构化的消息（例如，角色和内容）。

  • eval_dataset (Dataset，IterableDataset 或 dict[str, Union[Dataset, IterableDataset]]) --- 用于评估的数据集。它必须满足与 train_dataset 相同的要求。

  • processing_class (PreTrainedTokenizerBase，可选 ，默认为 None) --- 用于处理数据的处理类。填充方向必须设置为 "left"。如果为 None，则使用 from_pretrained 从模型名称加载处理类。

  • reward_processing_classes (Union[PreTrainedTokenizerBase, list[PreTrainedTokenizerBase]]，可选 ，默认为 None) --- 对应于 reward_funcs 中指定的奖励函数的处理类。可以是以下两种：

    • 单个处理类：当 reward_funcs 仅包含一个奖励函数时使用。
    • 处理类列表：必须与 reward_funcs 中奖励函数的顺序和长度匹配。如果设置为 None，或者列表中与 PreTrainedModel 对应的元素为 None，则将使用 from_pretrained 自动加载模型的分词器。对于 reward_funcs 中的自定义奖励函数（非 PreTrainedModel 对象），reward_processing_classes 中的对应条目将被忽略。

  • callbacks ( TrainerCallback 列表，可选 ，默认为 None) --- 用于自定义训练循环的回调列表。这些回调将被添加到这里详细介绍的默认回调列表中。 如果要移除已使用的默认回调，请使用 remove_callback 方法。

  • optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]，可选 ，默认为 (None, None)) --- 包含要使用的优化器和学习率调度器的元组。默认情况下，将针对你的模型使用 AdamW 的实例，并使用由 args 控制的 get_linear_schedule_with_warmup 创建的学习率调度器。

  • peft_config (~peft.PeftConfig，可选 ，默认为 None) --- 用于包装模型的 PEFT 配置。如果为 None，则不包装模型。

用于群组相对策略优化 (GRPO) 方法的训练器。该算法最初在论文 DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models 中提出。

示例：

python 复制代码 
from datasets import load_dataset
from trl import GRPOTrainer

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

trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs="weqweasdas/RM-Gemma-2B",
    train_dataset=dataset,
)

trainer.train()
create_model_card

< source >

(model_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, tags: typing.Union[str, list[str], NoneType] = None)

参数

  • model_name (str 或 None，可选 ，默认为 None) --- 模型的名称。
  • dataset_name (str 或 None，可选 ，默认为 None) --- 用于训练的数据集的名称。
  • tags (str、list[str] 或 None，可选 ，默认为 None) --- 要与模型卡关联的标签。

使用训练器可用的信息创建模型卡草稿。

相关推荐
英国翰思教育几秒前
留学毕业论文如何利用不同问题设计问卷
人工智能·深度学习·学习·算法·学习方法·论文笔记
gaoenyang76052535 分钟前
探索高效图像识别：基于OpenCV的形状匹配利器
人工智能·opencv·计算机视觉
背太阳的牧羊人1 小时前
分词器的词表大小以及如果分词器的词表比模型的词表大，那么模型的嵌入矩阵需要被调整以适应新的词表大小。
开发语言·人工智能·python·深度学习·矩阵
人工智能教学实践1 小时前
无人机红外热成像：应急消防的“透视眼”
人工智能·目标跟踪
QQ_7781329742 小时前
ChatGPT高效处理图片技巧使用详解
人工智能·chatgpt
MYT_flyflyfly3 小时前
计算机视觉之三维重建-单视几何
人工智能·数码相机·计算机视觉
知识鱼丸3 小时前
machine learning自定义数据集使用框架的线性回归方法对其进行拟合
人工智能·机器学习·线性回归
老六哥_AI助理指南4 小时前
探索AI（chatgpt、文心一言、kimi等）提示词的奥秘
人工智能·chatgpt·文心一言
新加坡内哥谈技术4 小时前
DeepSeek：硅谷AI格局的拐点？
人工智能·深度学习·学习·语言模型
爱研究的小牛4 小时前
Deepseek技术浅析（一）
人工智能·深度学习·自然语言处理·aigc
热门推荐
01小米路由器简单救砖02centos7 init.d 和system.d03Dell服务器升级ubuntu 22.04失败解决04使用Gradio构建生成式AI应用程序； Stability AI推出Stable Diffusion XL 1.005xgboost: Why not implement distributed XGBoost on top of spark06半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)07MIT S081 Lab 2 System Calls08密码学原理技术-第六章-introduction to pulibc-key cryptography09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10flask-admin 在modelview 默认视图下重写create_model_actions来实现列表数据的批量处理actions