一、为什么要微调,而不是继续堆Prompt

先说结论:Prompt工程能解决80%的问题,剩下20%交给微调。

我这次的场景是给一个内部知识库做问答助手,基座选的是Qwen2.5-7B-Instruct。前期用Prompt+RAG跑了一轮,发现两个绕不过去的问题:

  1. 格式不稳定。要求模型输出固定JSON结构时,7B模型大约有15%的概率会漏字段或者多输出解释性文字,用few-shot能压到8%左右,但还是不够。
  2. 领域术语理解偏差。内部有一批自造缩写(比如某些业务代号),模型经常按通用含义去理解,答非所问。

这两类问题本质上是"行为对齐"问题,Prompt的边际收益已经很低了。而全量微调7B模型,光是优化器状态就要吃掉80GB+显存,我们手上只有一张RTX 4090(24GB),只能走LoRA路线,显存再紧一点就上QLoRA。

所以这篇文章的重点不是"LoRA是什么",而是在24GB卡上把一个7B模型微调出可用效果,具体要调哪些参数、会遇到什么坑、最后效果到底提升多少。


二、环境与版本

环境这块我踩过版本坑,先把确定能跑通的组合列出来:

组件 版本
Python 3.10.13
PyTorch 2.3.1 + cu121
transformers 4.44.2
peft 0.12.0
bitsandbytes 0.43.3
accelerate 0.33.0
trl 0.9.6
GPU RTX 4090 24GB
基座模型 Qwen2.5-7B-Instruct

几个版本注意点:

  • bitsandbytes必须和CUDA版本对齐,0.43.x 对 cu121 支持是稳的,再往上0.44在某些驱动上会报 CUDA Setup failed。
  • peft 0.12 之后 LoraConfig 的 task_type 建议显式写,不写在某些组合下会走默认分支导致保存的adapter加载时警告。
  • transformers 4.44 对 Qwen2.5 的 chat template 支持是完整的,低于4.37会拿不到正确的template。

三、方案设计:LoRA 还是 QLoRA

先给结论:显存够就LoRA,不够就QLoRA,但QLoRA有精度代价,要评估。

我的设计思路是两条路线都跑一遍做对比:

  • 路线A(LoRA):基座以bf16加载,约14.5GB;LoRA只训练低秩矩阵,可训练参数约20M。batch_size=2,gradient_accumulation=8,等效batch=16,开启gradient_checkpointing。
  • 路线B(QLoRA):基座以NF4 4bit量化加载,约5.5GB;LoRA部分仍以bf16训练。同样的batch配置。

超参上两条路线保持一致,方便对比:

lora_r = 16
lora_alpha = 32
lora_dropout = 0.05
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
learning_rate = 2e-4
lr_scheduler = "cosine"
warmup_ratio = 0.03
num_train_epochs = 3
max_seq_length = 2048

关于 target_modules 的选择,这里多说一句:只挂 q_proj/v_proj 是BERT时代的习惯,对LLM来说把MLP层的 gate/up/down 也挂上,效果通常明显更好,代价是可训练参数从约4M涨到约20M,对7B模型完全可以接受。我实测过只挂attention的情况,最终测试集准确率低了约6个百分点,不值得省这点参数。


四、核心实现

4.1 数据准备

数据格式我用的是标准的对话格式,每条样本是一个messages列表,直接套Qwen的chat template。原始数据是1.2万条业务问答,清洗后剩11,468条,按 9:1 切训练/验证。

数据清洗做了三件事:去掉答案长度<20字符的、去掉问题重复的、把答案里残留的"根据您的问题"这类模板开头统一删掉。这一步很关键,模型会模仿数据里的废话,你数据里有多少套话,模型就学多少套话。

处理脚本核心逻辑:

import json
from transformers import AutoTokenizer

MODEL_PATH = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)

def build_sample(item):
    messages = [
        {"role": "system", "content": "你是内部知识库助手,回答需简洁准确,涉及业务代号时按内部定义解释。"},
        {"role": "user", "content": item["question"]},
        {"role": "assistant", "content": item["answer"]},
    ]
    # 关键:assistant部分才计算loss,system/user部分mask掉
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=False
    )
    prompt_text = tokenizer.apply_chat_template(
        messages[:-1], tokenize=False, add_generation_prompt=True
    )
    prompt_ids = tokenizer(prompt_text, add_special_tokens=False)["input_ids"]
    full_ids = tokenizer(text, add_special_tokens=False)["input_ids"]
    labels = [-100] * len(prompt_ids) + full_ids[len(prompt_ids):]
    return {"input_ids": full_ids, "labels": labels}

with open("train.jsonl") as f:
    raw = [json.loads(line) for line in f]

samples = [build_sample(x) for x in raw]
print(f"样本数: {len(samples)}, 平均长度: {sum(len(s['input_ids']) for s in samples)/len(samples):.0f}")
# 输出: 样本数: 11468, 平均长度: 486

这里有个容易忽略的点:labels的mask。如果不mask,模型会把system prompt和user问题也当作要预测的内容,loss曲线会好看但实际生成质量下降。上面用 -100 填充prompt部分,是HuggingFace的约定。

4.2 LoRA训练配置

训练脚本我基于 trl 的 SFTTrainer 封装,核心配置如下:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer, SFTConfig

MODEL_PATH = "Qwen/Qwen2.5-7B-Instruct"

# ---- 路线B:QLoRA 时打开这段 ----
# bnb_config = BitsAndBytesConfig(
#     load_in_4bit=True,
#     bnb_4bit_quant_type="nf4",
#     bnb_4bit_compute_dtype=torch.bfloat16,
#     bnb_4bit_use_double_quant=True,
# )
# model = AutoModelForCausalLM.from_pretrained(
#     MODEL_PATH, quantization_config=bnb_config,
#     device_map="auto", trust_remote_code=True,
# )
# model = prepare_model_for_kbit_training(model)

# ---- 路线A:LoRA 时用这段 ----
model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH, torch_dtype=torch.bfloat16,
    device_map="auto", trust_remote_code=True,
)
model.gradient_checkpointing_enable()
model.enable_input_require_grads()

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj","k_proj","v_proj","o_proj",
                    "gate_proj","up_proj","down_proj"],
    bias="none",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出: trainable params: 20,185,088 || all params: 7,635,689,472 || trainable%: 0.2643

sft_config = SFTConfig(
    output_dir="./output_lora",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    num_train_epochs=3,
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,
    gradient_checkpointing=True,
    max_seq_length=2048,
    dataset_text_field="text",
    report_to="none",
)

trainer = SFTTrainer(
    model=model,
    args=sft_config,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    peft_config=lora_config,
)
trainer.train()
trainer.model.save_pretrained("./lora_adapter")

注意 enable_input_require_grads() 这行,配合gradient checkpointing时必须调用,否则会报 element 0 of tensors does not require grad。这是LoRA+checkpointing组合里最高频的报错,没有之一。

4.3 Loss曲线

两条路线的loss走势(每10步记录一次,3个epoch共约2150步):

  • LoRA:起始loss 1.82,第1个epoch末降到0.71,第2个epoch末0.52,第3个epoch末0.44,验证集loss最低点出现在第2个epoch末的0.58,第3个epoch开始轻微回升到0.61。
  • QLoRA:起始loss 1.79,第1个epoch末0.78,第2个epoch末0.57,第3个epoch末0.49,验证集loss最低点0.63。

两个观察:

  1. 第3个epoch已经出现过拟合迹象(训练loss降但验证loss升),实际部署我选的是第2个epoch的checkpoint。如果数据量再小一些(比如3000条以内),建议直接2个epoch。
  2. QLoRA的loss整体略高于LoRA约0.03-0.05,这是4bit量化的固有精度损失,在预期之内。

五、踩坑与优化记录

坑1:OOM发生在eval阶段而不是train阶段。
训练时18.7GB很稳,但每次epoch结束做eval时爆显存。原因是SFTTrainer的eval默认batch和train一致,而eval没有gradient checkpointing省显存。解法是把 per_device_eval_batch_size 设成1,并且eval时用 torch.cuda.empty_cache()。这个坑很隐蔽,因为报错发生在"训练看起来正常"之后。

坑2:max_seq_length设太大拖慢训练。
一开始按习惯设了4096,结果发现数据平均长度才486,99分位也就1200左右。设2048之后单步时间从1.9s降到1.1s,整体训练时间少了40%。先统计你的数据长度分布再定这个参数,别拍脑袋。

坑3:学习率2e-4对LoRA偏高了一点点。
第一轮用2e-4,loss在第1个epoch内震荡比较明显。后来降到1.5e-4,曲线平滑很多,最终验证loss也低了约0.02。LoRA的常用区间是1e-4到2e-4,数据量小的时候往下取。

坑4:QLoRA保存adapter后直接merge会报错。
4bit量化的模型不能直接 merge_and_unload(),需要先把基座以bf16重新加载,再加载adapter合并。合并脚本:

from transformers import AutoModelForCausalLM
from peft import PeftModel
import torch

base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct", torch_dtype=torch.bfloat16, device_map="cpu"
)
model = PeftModel.from_pretrained(base, "./lora_adapter")
model = model.merge_and_unload()
model.save_pretrained("./merged_model", safe_serialization=True)

六、效果数据对比

测试集是200条人工标注的业务问答,评估两个维度:格式合规率(输出是否符合要求的JSON结构)和答案准确率(人工判定是否答对关键点)。

方案 格式合规率 答案准确率 训练峰值显存 3 epoch耗时
基座 + Prompt(few-shot) 92.0% 61.5% - -
基座 + RAG + Prompt 93.5% 74.0% - -
LoRA微调(r=16) 99.5% 86.5% 18.7GB 4h32m
QLoRA微调(NF4) 99.0% 85.0% 9.4GB 5h48m

几个值得说的点:

  • 格式合规率提升最明显,从92%到99.5%,基本解决了JSON漏字段的问题。这其实是微调最划算的收益——行为对齐类的问题,微调比Prompt稳定一个量级。
  • 准确率从74%到86.5%,提升主要来自领域术语的正确理解。但注意,微调不能替代RAG,涉及具体数字、版本号这类事实性内容,模型还是会编。我的最终方案是"微调模型 + RAG",准确率能到91%左右。
  • QLoRA相比LoRA掉了1.5个百分点准确率,显存省了一半。如果卡是16GB甚至12GB,QLoRA是唯一选择,这个精度代价可以接受。
  • QLoRA反而更慢(5h48m vs 4h32m),因为4bit反量化有额外开销。所以显存够的话没有理由用QLoRA。

推理速度上,合并后的LoRA模型和原模型完全一致(都是bf16),QLoRA如果保持4bit推理,首token延迟会低约15%,但生成质量就是上表那个数。


七、总结

把这次实践的结论压缩成几条,方便直接抄:

  1. 7B模型 + 24GB卡,LoRA(bf16基座)是首选,r=16、alpha=32、target_modules挂满attention+MLP,显存18.7GB,3个epoch约4.5小时。
  2. 显存低于16GB再考虑QLoRA,NF4+double quant能把显存压到9.4GB,代价是约1.5个点的准确率和更长的训练时间。
  3. 数据清洗和labels mask比调参重要,套话数据会直接教坏模型。
  4. max_seq_length按数据实际长度分布定,别默认4096。
  5. epoch别贪多,1万条量级的数据2-3个epoch就到顶了,看验证集loss选checkpoint。
  6. 微调解决行为问题,RAG解决事实问题,两者是叠加关系不是替代关系。

代码已经全部贴在上面,环境版本对齐的话可以直接跑。有问题欢迎评论区交流,尤其是bitsandbytes相关的报错,那个东西的坑我能写一整篇。