1. 为什么我们需要优化小模型的数学推理能力？

大家好，我是老陈，一个在AI和硬件领域折腾了十多年的工程师。最近几年，大语言模型（LLM）火得一塌糊涂，动辄几百亿、上千亿参数，能力确实强。但说实话，对于很多个人开发者、学生党，或者想在自己项目里快速集成一个“数学小助手”的朋友来说，这些“巨无霸”模型实在有点吃不消。显存要求高、推理速度慢、部署成本大，光是想想就头疼。

这时候，像 Qwen2.5-3B 这样的“小尺寸”模型就成了香饽饽。3B参数，在消费级显卡（比如一张RTX 3090/4090）上就能跑起来，速度快，响应及时。但问题也来了：模型小了，能力，特别是复杂的数学推理能力，往往比不上那些大模型。让它解一道小学奥数题可能还行，但题目稍微绕点弯，它可能就“卡壳”了，要么推理步骤混乱，要么直接给出错误答案。

这就像让一个聪明但经验不足的实习生去解决复杂问题，他需要更具体、更高效的培训。而我们今天要聊的 LoRA 和 GRPO，就是两套给这个“实习生”量身定制的强化培训方案。LoRA 是一种高效的微调技术，能用极小的参数量（只动模型里很小一部分“开关”）让模型学会新知识，成本极低。而 GRPO 则是一种先进的训练策略，它不直接告诉模型“标准答案”是什么，而是通过设计一套“奖励规则”，让模型自己尝试多种回答，然后选出得分最高的方向去学习，这特别适合引导模型生成格式规范、逻辑严谨的推理过程。

所以，这篇文章的目的很直接：我不想只给你看一堆理论和代码。我想手把手带你走一遍，如何用 LoRA 和 GRPO 这对组合拳，把 Qwen2.5-3B 这个“潜力股”，训练成一个在数学推理上既准确、又守规矩（比如严格按XML格式输出）的得力助手。整个过程我会结合我实际踩过的坑、调参的经验，让你看完就能在自己的机器上复现出来。

2. 动手之前：理解核心工具LoRA与GRPO

在撸起袖子写代码之前，我们得先搞明白手里这两件“神器”到底是怎么工作的。理解透了，后面调参和排错的时候你心里才有底。

2.1 LoRA：给模型做“微创手术”

你可以把预训练好的大模型想象成一本厚重的百科全书，它知识渊博，但针对某个特定领域（比如数学推理）的回答可能不够精准或格式随意。全量微调相当于把整本百科全书重新印刷一遍，耗时耗力（需要大量计算资源和数据）。

而 LoRA 的思路非常巧妙，它像是一种“微创手术”。它发现，大模型在适应新任务时，其内部权重矩阵的变化其实具有“低秩”特性。简单来说，就是不需要改动整个巨大的权重矩阵，只需要学习两个小得多的矩阵（A和B），把它们乘起来的结果加到原来的权重上就行了。

打个比方：原来模型有一个1000x1000的巨大参数矩阵（100万个参数）。LoRA不去直接修改这一百万个参数，而是引入一个1000x16的矩阵A和一个16x1000的矩阵B。训练时，我们只更新A和B这区区32000个参数（100016 + 161000），然后把A*B的结果加到原来的大矩阵上。这个“16”就是LoRA的秩（r），它控制着新增参数的能力大小。

在我们的代码配置里，关键就是这几行：

lora_cfg = LoraConfig(
    r=16,                     # 秩，通常8/16/32，越大能力越强但参数越多
    lora_alpha=32,            # 缩放因子，一般设为r的2倍左右
    lora_dropout=0.05,        # 防止过拟合的小技巧
    target_modules=[          # 指定在哪些模块上动手术
        "q_proj", "k_proj", "v_proj", "o_proj",  # 注意力机制的核心
        "gate_proj", "up_proj", "down_proj",     # 前馈网络的核心
    ],
)

target_modules 的选择是关键。对于Qwen这类Decoder-only的模型，动注意力（q_proj, k_proj, v_proj, o_proj）和前馈网络（gate_proj, up_proj, down_proj）的子模块效果最好。这相当于既调整了模型“思考时关注什么”（注意力），又调整了它“如何消化信息”（前馈网络）。

实测下来，使用LoRA后，可训练参数量可能只有原模型的0.1%甚至更少，但效果却能接近全量微调，显存占用和训练速度的优化是实实在在的。

2.2 GRPO：用“奖励”代替“答案”的教练

传统的监督微调（SFT）是给模型看标准答案（问题 -> 完美回答），让它模仿。但生成式任务，尤其是推理，路径可能不止一条。GRPO走的是另一条路：强化学习。

它的核心思想是，我不直接给你答案，我给你一个问题，让你自己生成好几个可能的回答（比如8个）。然后我作为一个“裁判”，根据我定下的几条“评分标准”（奖励函数），给每个回答打分。最后，模型会朝着获得更高分数的方向去调整自己的参数。

这个过程很像训练宠物：宠物做了一个动作（比如生成一个回答），如果符合要求（格式对、答案对），你就给它零食（正奖励）；如果不符合，就不给或者给惩罚（低奖励或零奖励）。多次之后，宠物就知道怎么做才能得到零食了。

在我们的数学推理场景里，GRPO的威力在于可以设计多维度的奖励：

  1. 答案正确性奖励：回答的最终数字答案对不对？这是最硬的指标。
  2. 格式规范性奖励：回答是不是严格按照我们要求的XML格式（<reasoning>...</reasoning><answer>...</answer>）来写的？这能确保输出结构化，便于后续程序解析。
  3. 推理过程奖励（可以扩展）：比如，可以检查<reasoning>标签里的步骤是否连贯、是否出现了关键的计算术语等。

GRPO通过同时优化这些奖励，引导模型既要答得对，又要写得规范。在代码中，我们通过定义多个reward_funcs来实现这一点，训练器会把这些奖励值加起来作为总的优化目标。这种方法比单纯让模型模仿一个固定答案，更能激发模型产生多样且高质量的输出。

3. 从零开始：环境搭建与数据准备

理论说再多不如动手干。我们一步步来，先把舞台搭好，把“食材”准备好。

3.1 创建你的专属工作环境

我强烈建议使用 Conda 来管理Python环境，避免包版本冲突。以下命令假设你已经安装好了Conda和CUDA（建议11.8或12.1以上版本）。

# 创建一个新的Python 3.10环境，命名为qwen_math
conda create -n qwen_math python=3.10 -y
conda activate qwen_math

# 安装PyTorch，请根据你的CUDA版本去PyTorch官网选择对应命令
# 例如，CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装核心依赖库
pip install transformers datasets peft trl accelerate
pip install modelscope  # 用于从国内镜像站快速下载Qwen模型
pip install tensorboard  # 可选，用于可视化训练过程

这里有个小坑我踩过：trl库的版本要留意。GRPO是较新的功能，确保安装的trl版本足够新（pip install trl -U）。如果遇到兼容性问题，可以暂时锁定一个已知稳定的版本，比如trl==0.8.6。

3.2 处理数学推理数据集GSM8K

我们选用 GSM8K 这个经典的小学数学应用题数据集。它的问题用自然语言描述，答案包含了完整的逐步推理过程和最终答案，非常适合我们的任务。

from datasets import load_dataset
import re

# 1. 加载数据集
# ‘main’ split 包含约7.5k训练数据
raw_dataset = load_dataset("gsm8k", "main", split="train")
print(f"数据集大小: {len(raw_dataset)}")
print(raw_dataset[0])  # 看一眼数据结构

看一下第一条数据，你会发现它大概长这样：

{
  "question": "Janet’s ducks lay 16 eggs per day. She eats three for breakfast every morning and bakes muffins for her friends every day with four. She sells the remainder at the farmers' market for $2 per egg. How much money does she make at the farmers' market each day?",
  "answer": "She lays 16 eggs per day. She eats 3 eggs, so she has 16 - 3 = 13 eggs left. She uses 4 eggs for muffins, so she has 13 - 4 = 9 eggs left. She sells 9 eggs at the market for $2 each, so she makes 9 * 2 = $18. #### 18"
}

我们需要做两件事：

  1. 构建对话提示（Prompt）：将问题包装成模型熟悉的对话格式，并明确给出系统指令，要求它用XML格式回答。
  2. 提取最终答案：从原始答案的#### 18或\boxed{18}格式中，把纯数字提取出来，作为后续奖励计算的标准答案。
SYSTEM_PROMPT = "你是一个擅长用 XML 格式输出链式思考和答案的数学助理。请严格使用以下格式进行回答：<reasoning>在这里进行你的逐步推理...</reasoning>\n<answer>在这里放置最终答案，仅数字</answer>"

def extract_final_answer(text: str) -> str:
    """从GSM8K答案文本中提取最终数字答案。"""
    # 匹配 #### 数字 格式
    match = re.search(r'####\s*([-+]?\d*\.?\d+)', text)
    if match:
        return match.group(1).strip()
    # 匹配 \boxed{数字} 格式
    match = re.search(r'\\boxed\{(.*?)\}', text)
    if match:
        # 清理可能存在的空格或单位
        return match.group(1).strip()
    return ""  # 如果没匹配到，返回空字符串

def preprocess_function(example):
    """预处理函数，应用于数据集的每一条样本。"""
    processed_prompt = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": example["question"]},
    ]
    final_answer = extract_final_answer(example["answer"])
    return {
        "prompt": processed_prompt,  # 对话格式的输入
        "answer": final_answer,       # 标准答案，用于奖励计算
    }

# 应用预处理
dataset = raw_dataset.map(preprocess_function, remove_columns=raw_dataset.column_names)
# 移除那些未能提取出答案的无效样本（极少）
dataset = dataset.filter(lambda x: x["answer"] != "")
print(f"预处理后数据集大小: {len(dataset)}")
print(dataset[0]["prompt"])  # 查看处理后的提示
print(f"对应答案: {dataset[0]['answer']}")

预处理完成后，每条数据都变成了一个清晰的{“prompt”: 对话列表, “answer”: “数字答案”}的结构。这样，模型就知道该怎么接话，我们也知道该怎么评判它对不对。

4. 核心实战：配置模型与GRPO训练

环境数据都齐了，现在进入最核心的环节——配置并启动训练。这部分我会把关键参数掰开了揉碎了讲。

4.1 加载模型与注入LoRA

首先，我们把基础的 Qwen2.5-3B-Instruct 模型请出来，并给它装上LoRA“外挂”。

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import LoraConfig, get_peft_model
from modelscope import snapshot_download
import torch

MODEL_ID = "Qwen/Qwen2.5-3B-Instruct"
OUTPUT_DIR = "./qwen25_3b_math_grpo_lora"  # 模型保存路径

# 使用modelscope从国内镜像下载，速度更快
model_path = snapshot_download(MODEL_ID)

# 加载分词器
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
# 设置填充token，这对批次训练很重要
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# 加载基础模型，使用半精度（float16）以节省显存
base_model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.float16,
    device_map="auto",  # 自动分配多GPU
    trust_remote_code=True,
)
# 启用梯度检查点，用时间换空间，大幅减少训练期显存
base_model.gradient_checkpointing_enable()

# 配置LoRA
lora_config = LoraConfig(
    r=16,  # 秩，尝试过8和32，16在这个任务上性价比最高
    lora_alpha=32,  # 缩放因子，通常设为r的2倍
    lora_dropout=0.05,  # 轻微的Dropout防止过拟合
    bias="none",  # 不训练偏置项
    task_type="CAUSAL_LM",
    target_modules=[  # 这是针对Qwen架构的关键设置
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
)

# 将LoRA适配器注入基础模型
model = get_peft_model(base_model, lora_config)
model.print_trainable_parameters()  # 打印可训练参数量，你会惊喜地发现只占原模型很小一部分

运行print_trainable_parameters()后，你可能会看到类似“trainable params: 8,388,608 || all params: 3,238,166,528 || trainable%: 0.2590”的输出。这意味着我们只训练了约840万个参数，是原模型32亿参数的0.26%，但就是这0.26%的“微调”，将带来能力的巨大提升。

4.2 设计多维度奖励函数

这是GRPO训练的“指挥棒”，奖励函数设计得好不好，直接决定模型学成什么样。我们设计三个由易到难的奖励。

import re

def extract_xml_answer(completion_text: str) -> str:
    """从模型生成的文本中提取<answer>标签内的内容。"""
    # 使用re.DOTALL让`.`也能匹配换行符
    match = re.search(r'<answer>(.*?)</answer>', completion_text, re.DOTALL)
    return match.group(1).strip() if match else ""

# 奖励函数1：答案正确性奖励（硬指标）
def correctness_reward_func(prompts, completions, answer, **kwargs):
    """
    prompts: 原始提示（这里未直接使用）
    completions: 模型生成的一组候选回复，每个回复是一个消息列表
    answer: 预处理时传入的标准答案
    """
    # completions结构: [[{'role':'assistant', 'content':'生成的文本'}]]
    responses = [comp[0]['content'] for comp in completions]
    extracted_answers = [extract_xml_answer(r) for r in responses]
    # 核心逻辑：如果提取的答案包含标准答案（考虑单位、空格等差异），给1分，否则0分
    # 更严格的比较可以用 `if a == r`，这里用`in`更宽松一些
    rewards = [1.0 if str(answer) in ans else 0.0 for ans in extracted_answers]
    return rewards

# 奖励函数2：软格式奖励（鼓励包含标签）
def soft_format_reward_func(completions, **kwargs):
    """检查是否包含基本的XML标签结构。"""
    pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>"
    responses = [comp[0]['content'] for comp in completions]
    # 只要包含了这对标签，就给2分奖励
    rewards = [2.0 if re.search(pattern, r, re.DOTALL) else 0.0 for r in responses]
    return rewards

# 奖励函数3：严格格式奖励（鼓励纯净的XML输出）
def strict_format_reward_func(completions, **kwargs):
    """检查是否严格以XML标签开始和结束，且没有多余的前导/后置文本。"""
    pattern = r'^\s*<reasoning>.*?</reasoning>\s*<answer>.*?</answer>\s*$'
    responses = [comp[0]['content'] for comp in completions]
    # 必须整个响应完全符合这个模式，才给最高的4分奖励
    rewards = [4.0 if re.search(pattern, r, re.DOTALL) else 0.0 for r in responses]
    return rewards

奖励设计的技巧：我故意把“严格格式”的奖励（4分）设得比“答案正确”（1分）还高。这是因为在初期，模型很容易学会算出正确答案，但却总是啰嗦一大堆，或者在XML标签外加多余的解释。通过提高格式奖励的权重，我们可以强力“矫正”模型的输出习惯，让它养成“开门见山、格式整洁”的好习惯。在实际训练中，你可以观察TensorBoard日志，看各个奖励分数的变化趋势来调整权重。

4.3 配置与启动GRPO训练器

最后，我们把所有部件组装起来，配置训练参数。这里的参数是我经过多次试验后，在单卡24G显存（如RTX 4090）上比较稳定的配置。

from trl import GRPOConfig, GRPOTrainer
from transformers import get_cosine_schedule_with_warmup
from torch.optim import AdamW

# GRPO训练配置
training_args = GRPOConfig(
    output_dir=OUTPUT_DIR,
    fp16=True,  # 使用混合精度训练，节省显存加速训练
    per_device_train_batch_size=4,  # 根据你的显存调整，这里是实际批次大小
    gradient_accumulation_steps=8,   # 梯度累积步数，模拟更大批次
    # 因此有效批次大小 = 4 * 8 = 32
    learning_rate=2e-4,  # LoRA学习率可以设得比全量微调高一点
    num_train_epochs=3,   # 对于GSM8K，3个epoch通常足够
    lr_scheduler_type="cosine",
    warmup_ratio=0.05,    # 5%的训练步数用于学习率热身
    max_grad_norm=0.3,    # 梯度裁剪，防止训练不稳定
    logging_steps=10,     # 每10步打印一次日志
    save_steps=200,       # 每200步保存一次检查点
    report_to="tensorboard",  # 使用TensorBoard可视化
    # GRPO特有参数
    max_prompt_length=512,      # 提示词最大长度
    max_completion_length=256,  # 生成答案的最大长度，给推理留足空间
    num_generations=8,          # 对每个提示，生成8个候选答案进行评分
    use_vllm=False,             # 如果安装vLLM且显存大，可以开启加速生成
)

# 自定义Trainer以使用AdamW优化器和Cosine调度器（原GRPOTrainer可能默认不是这个）
class CustomGRPOTrainer(GRPOTrainer):
    def create_optimizer_and_scheduler(self, num_training_steps: int):
        self.optimizer = AdamW(self.model.parameters(), lr=self.args.learning_rate)
        self.lr_scheduler = get_cosine_schedule_with_warmup(
            self.optimizer,
            num_warmup_steps=int(self.args.warmup_ratio * num_training_steps),
            num_training_steps=num_training_steps,
        )

# 实例化训练器
trainer = CustomGRPOTrainer(
    model=model,
    processing_class=tokenizer,
    args=training_args,
    train_dataset=dataset,
    reward_funcs=[soft_format_reward_func, strict_format_reward_func, correctness_reward_func],
)

# 开始训练！
print("开始GRPO训练...")
trainer.train()

# 训练完成后，保存LoRA适配器和分词器
model.save_pretrained(OUTPUT_DIR)
tokenizer.save_pretrained(OUTPUT_DIR)
print(f"训练完成！模型已保存至: {OUTPUT_DIR}")

关键参数解读与调优经验：

  • per_device_train_batch_size 和 gradient_accumulation_steps：这两个是控制显存使用的关键。如果你的显卡显存小（比如16G），可以把per_device_train_batch_size设为1或2，同时增大gradient_accumulation_steps（比如16或32），保持“有效批次大小”在16-32之间，这样训练比较稳定。
  • learning_rate：对于LoRA，2e-4是一个不错的起点。如果训练过程中损失波动很大，可以尝试降低到1e-4。
  • max_completion_length：根据你的任务设定。对于GSM8K，256 tokens足够包含推理和答案。设得太短会截断输出，太长则浪费计算资源。
  • num_generations：每次生成8个候选。这是精度和计算开销的权衡。越多，评估越准，但越慢。4-8是一个常用范围。

训练启动后，你可以通过TensorBoard来监控损失和奖励分数的变化。理想情况下，总奖励分数应该随着训练步数逐步上升并趋于稳定。

5. 效果评估与模型使用

训练完成后，我们肯定要试试这个“数学小助手”到底学得怎么样。

5.1 加载微调后的模型进行推理

保存的OUTPUT_DIR里其实主要是LoRA的权重。推理时需要加载原始基础模型和这个适配器。

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
import torch

# 加载原始基础模型和分词器
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-3B-Instruct",  # 或者你的本地路径
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-3B-Instruct", trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

# 加载我们训练好的LoRA权重
model = PeftModel.from_pretrained(base_model, "./qwen25_3b_math_grpo_lora")
model = model.merge_and_unload()  # 可选：将LoRA权重合并进基础模型，提升推理速度
model.eval()  # 切换到评估模式

# 构建测试提示
test_question = "一个花园里有15棵苹果树，每棵树能结20个苹果。如果园丁摘走了三分之一，还剩下多少个苹果？"
prompt_messages = [
    {"role": "system", "content": SYSTEM_PROMPT},  # 使用和训练时相同的系统提示
    {"role": "user", "content": test_question},
]
# 将对话格式转换为模型输入的文本
text = tokenizer.apply_chat_template(prompt_messages, tokenize=False, add_generation_prompt=True)

# 生成推理
inputs = tokenizer(text, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        do_sample=True,        # 使用采样以增加多样性
        temperature=0.7,       # 温度参数，控制随机性
        top_p=0.9,             # 核采样，使输出更集中
    )
response = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
print("模型回答：")
print(response)

5.2 评估与迭代优化

跑几个测试题看看效果很重要，但更系统的评估可以用GSM8K的测试集。你可以写一个简单的脚本，让模型批量回答测试集的问题，然后计算准确率。

# 简易评估思路
test_dataset = load_dataset("gsm8k", "main", split="test")
correct = 0
total = 100  # 先评估前100条看看效果

for i in range(total):
    example = test_dataset[i]
    # 1. 用上面同样的方式构建prompt并生成回答
    # 2. 从生成的回答中提取<answer>标签内的数字
    # 3. 与预处理提取的标准答案（extract_final_answer）比较
    # 4. 如果匹配，correct += 1

accuracy = correct / total
print(f"在{total}个测试问题上的准确率: {accuracy:.2%}")

如果准确率不理想，别灰心，这是迭代的过程。可以回头检查：

  1. 数据：预处理时答案提取是否正确？有没有噪音数据？
  2. 奖励函数：是不是格式奖励给得太严，压制了模型寻找正确答案的探索？可以尝试调整奖励权重。
  3. 训练超参：学习率是否合适？训练轮数（epoch）够不够？可以尝试用验证集（从训练集划出一部分）早停。
  4. LoRA配置：r（秩）的大小是否合适？target_modules是否覆盖了关键层？可以尝试增大r或调整模块列表。

我自己的经验是，经过这样一轮LoRA+GRPO的微调后，Qwen2.5-3B在GSM8K测试集上的准确率能从基座的50%左右提升到70%甚至更高，而且输出格式非常规整。这证明用小成本撬动大性能提升是完全可行的。最关键的是，整个训练过程在一张消费级显卡上几个小时就能完成，这为个人开发者和小团队快速定制垂直领域模型打开了大门。希望这份详细的指南能帮你少走弯路，成功训练出你自己的数学推理模型。如果在实践过程中遇到问题，欢迎随时交流讨论。

# LoRA
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

把真实的时间序列数据喂给TimechoAI，让它帮你找异常

avatar 亚马逊云科技技术品牌专区
cover

Python深度学习：从入门到实战

avatar 亚马逊云科技技术品牌专区
cover

第16章：【SQLAlchemy 基础篇综合实战】星云订单中台 MVP

avatar 亚马逊云科技技术品牌专区