一、为什么要在24GB卡上折腾7B模型

先说背景。我们团队有一个垂直领域的问答场景,基座直接用Qwen2.5-7B-Instruct效果能用但不够稳:专业术语经常答偏,格式要求(比如必须输出结构化字段)遵守率只有六成左右。全参数微调7B在单卡24GB上基本没戏——FP16权重就要14GB,加上优化器状态和梯度,40GB起步。所以LoRA是唯一现实的选择,而QLoRA能把基座量化到4-bit,进一步把门槛压到消费级显卡。

这篇文章不吹概念,只讲我实际跑通的一条链路:数据怎么攒、参数怎么定、loss不对劲怎么查、最后效果到底提升了多少。环境是Ubuntu 22.04 + 单张RTX 4090(24GB)。

二、环境与版本

版本这东西必须写清楚,不然复现时全是坑:

  • Python 3.10.13
  • torch 2.3.1 + cu121
  • transformers 4.42.3
  • peft 0.11.1
  • bitsandbytes 0.43.1
  • trl 0.9.6
  • accelerate 0.31.0
  • datasets 2.20.0

模型用的是 Qwen/Qwen2.5-7B-Instruct。选它是因为中文能力和指令跟随都不错,而且chat template现成,省得自己拼prompt。

三、数据准备:3200条是怎么来的

数据是这件事里最耗时的部分,也是最影响效果的。我的做法:

  1. 从业务日志里抽出约800条真实用户问题,人工标注标准答案;
  2. 用GPT-4o对每条问题做改写扩增,生成3-4个同义变体,人工抽检20%剔除低质样本;
  3. 补充约600条"边界样本"——模型容易答错、答偏、格式不合规的case,这类样本对纠正行为特别有效。

最终得到3217条,按 92/8 划分训练集和验证集。格式统一成对话式,用chat template包一层:

# data_prepare.py
import json
from transformers import AutoTokenizer

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

def build_sample(q, a):
    messages = [
        {"role": "system", "content": "你是XX领域的专业助手,回答需准确、简洁,涉及参数时必须给出单位。"},
        {"role": "user", "content": q},
        {"role": "assistant", "content": a},
    ]
    text = tokenizer.apply_chat_template(messages, tokenize=False)
    return {"text": text}

raw = [json.loads(l) for l in open("raw_qa.jsonl", encoding="utf-8")]
samples = [build_sample(r["q"], r["a"]) for r in raw]

with open("train.jsonl", "w", encoding="utf-8") as f:
    for s in samples[:2960]:
        f.write(json.dumps(s, ensure_ascii=False) + "\n")
with open("val.jsonl", "w", encoding="utf-8") as f:
    for s in samples[2960:]:
        f.write(json.dumps(s, ensure_ascii=False) + "\n")

# 统计token长度,决定max_length
lens = [len(tokenizer(s["text"]).input_ids) for s in samples]
lens.sort()
print("p50:", lens[len(lens)//2], "p95:", lens[int(len(lens)*0.95)], "max:", lens[-1])

实测 p95 约 780,max 1120。所以 max_length 定 1024,超出截断,截断率不到1.5%,可以接受。

四、方案设计与核心实现

4.1 LoRA参数怎么定

关键参数和我的取舍:

  • r=16:先试了8,验证loss下降偏慢;32在24GB卡上batch size要压到1,性价比不高。16是折中。
  • lora_alpha=32:按 alpha=2r 的惯例。
  • lora_dropout=0.05:数据量不大,加点正则防过拟合。
  • target_modules:只挂 q_proj, k_proj, v_proj, o_proj 四个注意力投影。试过把 MLP 的 gate_proj, up_proj, down_proj 也加上,可训练参数从 40M 涨到 160M,训练变慢但效果提升不到1个点,放弃。
  • 4-bit量化:load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True。

可训练参数约 40.4M,占全量的 0.56%。

4.2 训练配置

batch size 设为 2 + 梯度累积 8,等效 batch 16;学习率 2e-4,cosine 调度,warmup 比例 0.03;3个epoch;优化器用 paged_adamw_8bit(这是省显存的关键之一,普通adamw在4-bit场景下容易OOM)。

下面是完整可运行的训练脚本:

# train_lora.py
import torch
from datasets import load_dataset
from transformers import (AutoTokenizer, AutoModelForCausalLM,
                          BitsAndBytesConfig, TrainingArguments)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer

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

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)
model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    bias="none",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 40,370,176 || all params: 7,655,986,688 || trainable%: 0.5273

train_ds = load_dataset("json", data_files="train.jsonl", split="train")
val_ds = load_dataset("json", data_files="val.jsonl", split="train")

args = TrainingArguments(
    output_dir="./lora_out",
    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,
    eval_strategy="steps",
    eval_steps=100,
    save_strategy="steps",
    save_steps=200,
    save_total_limit=2,
    bf16=True,
    optim="paged_adamw_8bit",
    report_to="none",
    gradient_checkpointing=True,
)

trainer = SFTTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    tokenizer=tokenizer,
    dataset_text_field="text",
    max_seq_length=1024,
    packing=False,
)

trainer.train()
trainer.model.save_pretrained("./lora_adapter")
tokenizer.save_pretrained("./lora_adapter")

实测显存峰值 7.1GB(nvidia-smi 采样),相比不量化LoRA的 22.4GB 降了约 68%。3个epoch、约1.85万step(含累积),实际耗时 4小时37分,平均每步约 0.9 秒。

五、踩坑与优化:loss曲线不对劲怎么办

第一次跑的时候,train loss 从 1.82 一路降到 0.31,但 val loss 在第2个epoch中段开始反弹,从 0.94 涨到 1.13,典型的过拟合。排查过程:

  1. 先怀疑数据重复。去重后发现有约40条近似重复,删掉影响不大。
  2. 再调 dropout,从 0.05 提到 0.1,val loss 反弹点延后了一点,但没根治。
  3. 最后发现真正问题是 epoch 太多 + 学习率偏高。改成 2个epoch、lr 1.5e-4、warmup 0.05,val loss 单调下降到 0.87 后平稳,不再反弹。

另一个坑是 packing。一开始开了 packing=True 想提高吞吐,结果发现不同样本被拼进同一条序列后,模型在样本边界处学出了奇怪的续写行为,推理时偶尔会"串台"。关掉后正常。这个坑网上提得不多,但实际影响不小。

还有一个细节:prepare_model_for_kbit_training 会把 LayerNorm 转成 fp32,别忘了调,否则训练不稳定,loss 会抖。

最终loss曲线形态:train loss 1.82 → 0.42(2 epoch),val loss 1.21 → 0.87,两条线在前1.5个epoch基本平行下降,之后train继续降、val趋平,属于健康形态。

六、推理效果对比

评估集是单独构造的50条测试问题,覆盖术语准确性、格式合规、拒答边界三类,人工打分。

推理时把adapter合并回基座(merge)再跑,比动态加载快不少:

# infer_merge.py
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

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

base = AutoModelForCausalLM.from_pretrained(
    base_id, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
)
model = PeftModel.from_pretrained(base, "./lora_adapter")
model = model.merge_and_unload()   # 合并后就是普通模型,推理无额外开销
model.eval()

def chat(q):
    messages = [
        {"role": "system", "content": "你是XX领域的专业助手,回答需准确、简洁,涉及参数时必须给出单位。"},
        {"role": "user", "content": q},
    ]
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(text, return_tensors="pt").to(model.device)
    with torch.no_grad():
        out = model.generate(**inputs, max_new_tokens=512, temperature=0.2, do_sample=False)
    return tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)

print(chat("XX设备的额定工作温度范围是多少?超出后如何处理?"))

对比结果(50条,人工评分):

指标 基座模型 LoRA微调后
领域问答准确率 61% 87%
格式合规率 64% 94%
术语使用正确率 72% 91%
通用能力(另取20条常识题) 90% 86%
平均首token延迟 0.31s 0.33s

结论很明确:领域任务提升显著,格式合规率提升最大(+30个点),这与训练数据里塞了大量结构化样本直接相关。代价是通用能力回退了约4个点,属于LoRA微调的常见现象,如果在意可以用少量通用数据混训来缓解,我试了混入10%通用指令数据,回退缩到1.5个点左右,领域指标基本不变。

推理延迟几乎无变化,因为adapter已经merge进权重,模型结构和基座完全一致。

七、总结

几点可以带走的经验:

  1. QLoRA + paged_adamw_8bit 是24GB卡跑7B的黄金组合,显存7GB出头,留足余量。
  2. LoRA秩16、只挂注意力四个投影,对这类领域适配任务够用,参数0.53%,没必要贪大。
  3. 数据质量 > 数据数量。3200条里那600条边界样本贡献了大部分格式合规的提升。
  4. loss曲线要看val,train loss降到底不代表好事;epoch 2-3足够,再多就是过拟合。
  5. packing 在短样本场景下慎开,样本边界污染是真实存在的。
  6. merge后再推理,省去adapter加载开销,部署上和普通模型没区别。

整个流程从数据到上线大概两周,其中数据占了一周半。如果你也在单卡上折腾7B,希望这篇能帮你少踩几个坑。代码都是可直接跑的,版本号对上了基本不会出问题。