2026年大模型解析：从训练到应用，你不可不知的AI核心！

大家好，我是讯享网，很高兴认识大家。这里提供最前沿的Ai技术和互联网信息。

1. 为什么你需要关注GRPO训练？

如果你最近在玩大模型，尤其是尝试让模型按照特定格式输出答案，比如让它把推理过程放在标签里，把最终答案放在标签里，那你可能已经发现，光靠指令微调（SFT）有时候不太够用。模型要么格式不对，要么干脆“放飞自我”，答非所问。这时候，强化学习（RL）就该上场了。

而 GRPO，全称是 Group Relative Policy Optimization，是 Hugging Face 的 trl 库提供的一种强化学习算法。它特别适合我们这种“小作坊”式的实验，因为它不像传统的 PPO 那样需要单独训练一个复杂的奖励模型（Reward Model）。GRPO 的核心思想是，在同一批数据（一个组）里，让模型生成多个回复，然后根据我们自定义的奖励函数（Reward Function）给这些回复打分，通过比较组内回复的相对好坏来优化模型。说白了，就是“矮子里面拔将军”，让模型学会朝着我们定义的“好”的方向去生成内容。

DeepSeek-R1 这个模型之所以引起大家关注，正是因为它展示了通过 GRPO 训练，能让一个基础模型在数学推理和格式遵循上取得显著提升。今天，我就带你手把手走一遍这个流程，从准备数据、设计奖励函数，到跑通训练、验证效果。我会用最直白的话，把每个步骤的“坑”和“窍门”都讲清楚，保证你跟着做就能复现出来。我们用的基座模型是 Qwen2.5-0.5B-Instruct，数据是 GSM8K，全程在一张消费级显卡（比如 RTX 4090）上就能跑起来，非常亲民。

2. 环境搭建与数据准备：万事开头细

2.1 安装依赖：别在版本上栽跟头

第一步，咱们先把环境弄好。我强烈建议你创建一个新的虚拟环境，避免包版本冲突。这里我用 conda 举例，用 pipenv 或者 venv 也一样。

conda create -n grpo_demo python=3.10 conda activate grpo_demo

接下来安装核心的 trl 库。这里有个小坑，trl 正在快速迭代，为了确保我们用的 GRPOTrainer 是最新且稳定的，最好直接从源码的主分支安装。同时，我们还需要 transformers 和 datasets 库。

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 根据你的CUDA版本调整 pip install git+https://github.com/huggingface/trl pip install transformers datasets accelerate peft

安装完后，可以跑个 pip list | grep trl 看看版本，我写这篇文章时用的是 trl==0.8.0。版本对不上可能导致某些 API 用法有差异，如果你遇到问题，记得先检查版本。

2.2 理解并处理GSM8K数据

我们用的数据集是 OpenAI 的 GSM8K，这是一个小学数学应用题数据集，每个样本包含一个 question 和一个 answer。answer 比较特别，它由推理过程和最终答案数字组成，用 # 分隔。比如：

Question: "Natalia sold clips to 48 of her friends..." Answer: "Natalia sold clips to 48 of her friends in April. In May, she sold half as many as in April, which is 48 / 2 = 24 clips. Altogether, she sold 48 + 24 = 72 clips. # 72"

我们的目标是把数据整理成模型训练需要的格式。GRPO 训练时，每条数据需要两部分：

prompt: 一个消息列表，通常包含系统提示词（System Prompt）和用户问题（User Question）。
answer: 标准答案（仅数字），用于后续奖励计算。

系统提示词是关键，它规定了模型输出的格式。我们完全模仿 DeepSeek-R1 的风格：

SYSTEM_PROMPT = """ Respond in the following format: 
  
    
    
      ...你的推理过程... 
     
  
    
    
      ...最终答案数字... 
     """

接下来是数据处理函数。我们需要从原始答案中提取出最终的数字答案，并构建 prompt 列表。

from datasets import load_dataset import re def extract_answer(text): """从GSM8K的答案文本中提取最终的数字答案。""" # 答案通常在 '#' 后面 if '#' in text: answer = text.split('#')[-1].strip() else: answer = text.strip() # 清理一下，只保留数字和可能的负号、小数点 match = re.search(r'-?d+(.d+)?', answer) return match.group(0) if match else "" # 加载数据集 dataset = load_dataset("openai/gsm8k", "main") train_data = dataset['train'] # 构建训练样本 formatted_data = [] for item in train_data: d = { 'prompt': [ {'role': 'system', 'content': SYSTEM_PROMPT}, {'role': 'user', 'content': item['question']} ], 'answer': extract_answer(item['answer']) # 这里是字符串形式的数字，如 "72" } formatted_data.append(d) print(f"总共处理了 {len(formatted_data)} 条数据。") print("第一条数据示例:", formatted_data[0])

处理完后，你应该有大约 7473 条训练数据。每条数据都像下面这样，模型看到这样的 prompt，就知道应该用指定的 XML 标签格式来回复。

{ "prompt": [ {"role": "system", "content": " Respond in the following format: 
  
    
    
      ... 
     
  
    
    
      ... 
     "}, ], "answer": "72" }

3. 设计奖励函数：告诉模型什么是“好”

GRPO 训练的核心在于奖励函数。我们可以设计多个奖励函数，从不同维度评价模型生成的好坏，最后把分数加起来。这就像考试，有卷面分、格式分、附加分。DeepSeek-R1 的实现里用了 5 个奖励函数，我们来逐一拆解，我会告诉你每个函数的设计意图和实际编码时要注意的细节。

3.1 答案正确性奖励：一票否决权

correctness_reward_func 是最硬核的奖励。模型生成的标签里的数字，必须和标准答案完全一致，才能得 2 分，否则就是 0 分。这是任务成功的根本。

def correctness_reward_func(completions, answers, kwargs): """ completions: 模型生成的内容列表，每个元素是一个消息列表（通常我们取第一个消息的content）。 answers: 对应的标准答案列表。 """ rewards = [] for completion, answer in zip(completions, answers): # 从模型生成的内容中提取 
  
    
    
      标签内的数字 generated_text = completion[0]["content"] # 使用正则匹配 
     
       标签内容 match = re.search(r' 
      
        ?(.*?) ? 
      ', generated_text, re.DOTALL) if match 
      : pred_answer = match.group(1).strip() # 简单比较字符串（因为答案都是数字字符串）。更健壮的做法可以尝试转换为数值再比较。 if pred_answer == answer 
      : rewards.append(2.0) else 
      : rewards.append(0.0) else 
      : # 连 
      
        标签都没找到，肯定是0分 rewards.append(0.0) return rewards

注意：这里比较的是字符串。对于 GSM8K，答案都是整数或简单小数，所以问题不大。如果你的任务答案格式复杂，可能需要更精细的匹配逻辑（比如数值比较、容忍空格等）。

3.2 格式奖励：从宽松到严格

接下来的几个函数都是关于格式的。为什么格式这么重要？因为结构化的输出便于后续程序自动解析和使用。我们设计了不同严格程度的格式检查。

int_reward_func 是最基础的检查：标签里的内容是不是一个纯数字（整数或浮点数）？是的话加 0.5 分。这能过滤掉模型在答案位置胡言乱语的情况。

soft_format_reward_func 检查模型输出是否包含和这两个标签，且顺序基本正确。它用的正则比较宽松：pattern = r" .*? s* .*? "。只要这两个标签出现了，中间内容任意，就算过关，奖励 0.5 分。这个函数鼓励模型“记得”要用这两个标签。

strict_format_reward_func 就严格多了。它要求输出必须精确地以开头，以结尾，中间不能有多余的杂音。正则表达式是：pattern = r"^ .*? .*? $"。这强制模型输出非常干净、标准的格式。符合则奖励 0.5 分。

xmlcount_reward_func 则是一种更精细、带惩罚的格式奖励。它检查标签出现的次数和位置：

每个正确的开始标签（、）和结束标签（、）只出现一次，各奖励 0.125 分（共 0.5 分）。
但是，如果标签后面有多余的文本，会进行惩罚（每多一个字符扣 0.001 分）。这能有效防止模型在给出答案后还继续“啰嗦”。

def xmlcount_reward_func(completions, kwargs): def count_xml(text): count = 0.0 if text.count(" 
  
    
    
      ") == 1 
     : count += 0.125 if text.count(" 
     ") == 1: count += 0.125 if text.count(" 
  
    
    
      ") == 1 
     : count += 0.125 # 惩罚 
     标签后的多余文本 if text.count(" ") == 1: count += 0.125 # 计算最后一个 之后的字符长度（减1是为了忽略结尾的换行符？这里根据实际情况调整） trailing_text = text.split(" ")[-1] count -= len(trailing_text) * 0.001 return count contents = [completion[0]["content"] for completion in completions] return [count_xml(c) for c in contents]

我的经验：在实际训练中，strict_format_reward_func 和 xmlcount_reward_func 对于让模型学会“干净利落”地结束输出特别有效。初期模型经常在后面还生成一堆无关内容，这两个函数能很好地纠正这个坏习惯。

4. 配置与启动GRPO训练

万事俱备，只欠训练。这部分我们来看看如何把模型、分词器、数据、奖励函数和训练参数组装起来，并启动训练过程。

4.1 加载模型与分词器

我们使用 Qwen2.5-0.5B-Instruct 作为基座模型。这个模型大小适中，在消费级显卡上训练速度可以接受。记得使用与模型配套的分词器。

from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "Qwen/Qwen2.5-0.5B-Instruct" model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, # 使用BF16节省显存 device_map="auto", # 自动分配设备 trust_remote_code=True) # Qwen模型需要这个参数 tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) # 设置padding token（如果tokenizer没有的话） if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token

4.2 准备训练数据集

我们需要把之前处理好的字典列表格式的数据，转换成 trl 库需要的格式。这里我们使用 datasets 库的 Dataset 对象。

from datasets import Dataset # 假设 formatted_data 是我们之前处理好的列表 train_dataset = Dataset.from_list(formatted_data)

4.3 定义训练参数

训练参数（TrainingArguments）控制着训练的方方面面。以下是关键参数解析，我结合自己的踩坑经验加了注释：

from trl import GRPOConfig training_args = GRPOConfig( output_dir="./qwen_grpo_output", # 模型和日志输出目录 num_train_epochs=1, # 训练轮数，GSM8K数据量不大，1-3轮通常足够 per_device_train_batch_size=4, # 每张显卡的批次大小。根据你的显存调整，0.5B模型在24G显存上可以设到8 gradient_accumulation_steps=4, # 梯度累积步数。相当于增大有效批次大小 = 4 * 4 = 16 learning_rate=5e-6, # 学习率。RL训练的学习率通常比SFT小，从5e-6到1e-5尝试 logging_steps=10, # 每10步记录一次日志 save_steps=500, # 每500步保存一次检查点 eval_strategy="no", # 我们这里不做验证，专注于训练 bf16=True, # 使用BF16混合精度训练，大幅节省显存并加速 tf32=True, # 在Ampere架构及以后的GPU上启用TF32，加速计算 gradient_checkpointing=True, # 梯度检查点，用时间换空间，能训练更大的模型或使用更大的批次 optim="adamw_8bit", # 使用8-bit AdamW优化器，进一步节省显存 report_to="tensorboard", # 使用TensorBoard记录日志，方便可视化 remove_unused_columns=False, # 重要！GRPO需要原始数据列，不能自动移除 )

重点提示：per_device_train_batch_size 和 gradient_accumulation_steps 的乘积是有效批次大小。GRPO 训练对批次大小比较敏感，太小了训练不稳定，太大了显存放不下。对于 0.5B 的模型，有效批次大小在 16 到 32 之间是个不错的起点。remove_unused_columns=False 这个参数必须设置，因为 GRPO 内部需要访问我们数据中的 prompt 和 answer 字段。

4.4 初始化训练器并开始训练

最后，把所有的组件塞进 GRPOTrainer。

from trl import GRPOTrainer trainer = GRPOTrainer( model=model, processing_class=tokenizer, # 注意这里参数名是 processing_class，传入tokenizer reward_funcs=[ xmlcount_reward_func, soft_format_reward_func, strict_format_reward_func, int_reward_func, correctness_reward_func ], args=training_args, train_dataset=train_dataset, ) print("开始训练...") trainer.train()

训练启动后，你会看到日志输出。一开始，模型输出可能是一堆乱码或者完全不符合格式，各项奖励（rewards/xxx）基本都是 0，损失（loss）也可能很高。这是正常的！随着训练进行，你会观察到 rewards/correctness_reward_func（答案正确率）和格式相关的奖励分数逐渐上升，loss 逐渐下降。训练过程可能会输出一些采样结果，你可以看到模型从胡言乱语慢慢变得“有模有样”。

5. 训练过程监控与问题排查

训练启动后，可不能撒手不管。盯着点日志和显存，能帮你及时发现问题。

5.1 理解训练日志

训练日志里有很多关键信息：

loss: 策略梯度损失。这个值在训练初期波动可能很大，整体趋势下降就好。
rewards/xxx: 各个奖励函数的平均得分。这是最直观的指标。你会看到 correctness_reward_func 从 0 慢慢增长，格式奖励也逐渐非零。
reward 和 reward_std: 所有奖励加总后的平均奖励和标准差。平均奖励上升是好事。
kl: KL散度，衡量当前模型策略和原始模型策略的差异。如果这个值突然变得极大，说明训练可能不稳定了。
grad_norm: 梯度范数，过大可能意味着梯度爆炸。

在我的实验中，使用一张 A800（或类似级别的卡），完整训练一遍 GSM8K（约7500条数据）需要 1.5 到 2.5 小时，具体取决于批次大小等超参。你可以用 TensorBoard 来可视化这些指标，更直观地观察趋势。

tensorboard --logdir ./qwen_grpo_output/runs

5.2 常见问题与解决方案

显存不足（OOM）：这是最常见的问题。
- 降低批次大小：减小 per_device_train_batch_size。
- 启用梯度检查点：确保 gradient_checkpointing=True。
- 使用内存更友好的优化器：optim="adamw_8bit" 或 optim="adamw_bnb_8bit"。
- 使用更低精度：确保 bf16=True 或 fp16=True。
- 清理内存：在训练循环开始前，可以加 torch.cuda.empty_cache()。
训练不稳定，奖励不上升：
- 调小学习率：尝试将 learning_rate 从 5e-6 降到 1e-6。
- 增大有效批次大小：通过增加 gradient_accumulation_steps 来增大有效批次大小，有时能稳定训练。
- 检查奖励函数：确保你的奖励函数逻辑正确，没有 bug。可以写个小脚本，用一些模拟的输出单独测试每个奖励函数。
- 奖励尺度：确保各个奖励函数的分数在同一个数量级，不要有的奖励是100分，有的奖励是0.1分，这会导致优化方向被大分数的奖励主导。
模型输出始终是乱码或重复字符：
- 在训练初期这很正常。如果很长时间（比如好几个epoch）都没有改善，可能是学习率太高，或者模型初始权重有问题（可以尝试从不同的检查点开始）。另外，确保你的 SYSTEM_PROMPT 在数据预处理时被正确拼接到了每条样本中。

6. 模型验证与效果对比：看看训练成果

训练完成后，我们最激动的时刻就是验证效果了。加载保存的模型，对比一下训练前后的表现。

6.1 加载训练好的模型

训练器会自动在 output_dir 指定的目录下保存检查点。我们加载最终模型（通常是 checkpoint-xxxx 文件夹里最后一个）。

from transformers import pipeline # 加载训练好的模型和分词器 model_path = "./qwen_grpo_output/checkpoint-1868" # 根据你的实际路径修改 trained_model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True) trained_tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) # 创建一个简单的文本生成管道 pipe = pipeline("text-generation", model=trained_model, tokenizer=trained_tokenizer, device="cuda:0")

6.2 设计测试问题并进行对比

我们准备几个测试问题，分别用原始基座模型和训练后的模型生成回答。

test_questions = [ "Xiao Ming bought 4 apples, ate 1, and gave 1 to his sister. How many apples were left?", "A bakery sells cookies for $2 each and muffins for $3 each. If Sarah buys 2 cookies and 3 muffins, how much does she spend?", "There are 5 shelves. Each shelf holds 8 books. How many books are there in total?" ] def generate_response(pipe, system_prompt, question): """辅助函数，生成回复""" messages = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": question} ] # 将消息列表转换为模型接受的文本格式（具体格式取决于tokenizer的chat_template） text = trained_tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) outputs = pipe(text, max_new_tokens=256, do_sample=False) # 为了对比，先不用随机采样 return outputs[0]['generated_text'] # 使用相同的系统提示词 SYSTEM_PROMPT = """Respond in the following format: 
  
    
    
      ...你的推理过程... 
     
  
    
    
      ...最终答案数字... 
     """ print("=== 原始基座模型输出 ===") original_model = pipeline("text-generation", model="Qwen/Qwen2.5-0.5B-Instruct", tokenizer=tokenizer, device="cuda:0") for q in test_questions: resp = generate_response(original_model, SYSTEM_PROMPT, q) print(f"Q: {q}") print(f"A: {resp} {'-'*50}") print(" === GRPO训练后模型输出 ===") for q in test_questions: resp = generate_response(pipe, SYSTEM_PROMPT, q) print(f"Q: {q}") print(f"A: {resp} {'-'*50}")

6.3 效果分析

运行上面的代码，你会看到明显的差异。以第一个问题“小明有4个苹果…”为例：

训练前，模型可能完全忽略格式要求，生成一段自由文本的推理，甚至答非所问，比如跑去回答另一个关于“Natalia骑车”的问题（这在原始文章的输出中出现了，说明基座模型在没有强化学习约束时，很容易“跑偏”）。

训练后，模型输出大概率会严格遵循格式：

 
  
    
    
      小明最初有4个苹果。他吃了1个，剩下 4 - 1 = 3 个苹果。然后他给了妹妹1个，剩下 3 - 1 = 2 个苹果。 
     
  
    
    
      2

不仅格式工整，答案也正确。对于另外两个数学问题，训练后的模型也能保持格式一致性和答案准确性。这种转变正是 GRPO 训练的魔力所在——它通过我们设计的奖励函数，将“遵循指定格式并给出正确答案”这个复杂目标，成功地灌输给了模型。

7. 进阶思考与调优建议

走通整个流程只是第一步。如果你想进一步提升效果，或者把这个方法用到自己的任务上，这里有一些我的经验之谈。

奖励函数的设计是门艺术。GSM8K 的例子中，奖励函数相对简单。在你的实际任务中，可能需要设计更复杂的奖励。例如：

代码生成任务：可以加入代码语法检查奖励（用 ast.parse）、代码执行结果奖励（在安全沙箱中运行代码比较输出）、代码风格奖励（是否符合 PEP 8）。
安全性和无害性：可以加入一个基于敏感词过滤的负面奖励（惩罚），当模型输出包含不良内容时扣分。
奖励的权重：trl 的 GRPOTrainer 目前似乎不支持直接设置不同奖励函数的权重。但你可以通过调整每个函数返回的分值范围来间接实现加权。比如，你认为答案正确性最重要，就让它返回 10 分，而格式奖励只返回 1 分。

超参数调优：学习率（learning_rate）、批次大小（per_device_train_batch_size * gradient_accumulation_steps）和训练轮数（num_train_epochs）对最终效果影响很大。没有银弹，需要你在自己的任务和数据上做实验。一个实用的方法是，先用小规模数据（比如 1000 条）跑几个不同的超参组合，看看哪个组合下奖励上升最快、最稳定，然后再用全量数据训练。

基座模型的选择：我们用的是指令微调过的模型（Qwen2.5-0.5B-Instruct）。这很重要，因为指令微调让模型已经具备了遵循人类指令的初步能力。GRPO 是在此基础上进行“精雕细琢”。如果你用一个完全没有指令微调过的原始预训练模型做 GRPO，效果可能会很差，因为它连基本的指令理解都做不到。

处理更长的输出：我们的例子中，模型输出较短。如果任务需要生成长篇内容（如写故事、长摘要），你需要调整 max_length 或 max_new_tokens 参数，同时也要注意奖励函数是否能对长文本的质量进行有效评估。可能需要设计分段评估或基于整体连贯性、主题相关性的奖励。

最后，别忘了，强化学习训练有一定随机性，同样的配置跑两次结果可能略有不同。多跑几次，取平均效果，或者保存多个检查点选择最好的那个，都是稳妥的做法。这个过程虽然有些繁琐，但当你看到模型从“乱写”变得“规规矩矩”并且“答得正确”时，那种成就感是非常棒的。希望这篇详细的解析能帮你顺利上手 GRPO，训练出更听话、更能干的大模型。