一、问题背景:为什么要自己微调一个7B模型

先说结论:不是所有场景都需要微调,但当你遇到下面这三种情况时,微调几乎是唯一解。

我们做的是一个工业设备运维助手,需要模型回答"XX型号泵体振动超标怎么排查"这类问题。直接调用通用7B模型的API或本地部署,输出有两个稳定问题:一是回答太"泛",永远从"检查电源、检查接线"开始讲;二是格式不稳定,让它按"现象-原因-处置"三段式输出,十个回答里有三个会跑偏。

试过few-shot prompt,塞4个示例进上下文,效果有改善但token成本上去了,而且长上下文下模型对示例的遵循度会衰减。最后决定走LoRA微调:数据我们自己有(历史工单+专家整理的问答对),算力只有一张4090 24GB,全量微调7B(bf16权重约15GB+优化器状态)根本放不下,所以QLoRA是唯一现实的选择。

这里先明确一个预期:LoRA不是万灵药。它擅长的是改变输出风格、格式、领域术语习惯,对注入大量新知识的效果有限。我们的目标是前者,所以这次实践的目标很明确——让模型稳定按三段式输出,并且用我们行业里的说法。

二、环境与版本

环境这块踩过版本坑,先把最终能跑通的组合贴出来:

  • GPU:RTX 4090 24GB(单卡)
  • CUDA 12.1,驱动 535.104.05
  • Python 3.10.13
  • torch 2.4.0 + cu121
  • transformers 4.44.2
  • peft 0.13.2
  • bitsandbytes 0.43.3
  • trl 0.9.6(只用了SFTTrainer的数据整理部分,训练循环是自己写的)
  • datasets 2.21.0
  • 基座模型:Qwen2.5-7B-Instruct

提醒一句:bitsandbytes 在 0.43.x 之前对 CUDA 12.1 的支持有坑,load_in_4bit=True 时会报 CUDA Setup failed despite GPU being available,我一开始用的 0.41.1 就中招了,升级到 0.43.3 解决。另外 peft 0.13 之后 LoraConfig 的 target_modules 支持正则匹配,配起来比早期版本省事。

三、方案设计

整体思路四步:

  1. 数据准备:从工单系统导出原始记录,清洗成 instruction/input/output 三段结构,统一输出格式为"现象 / 原因 / 处置"三段式,共3200条,按 9:1 切训练/验证。
  2. 量化加载:基座模型用 4-bit NF4 量化加载,双重量化(double quant)开启,计算类型用 bf16。这样权重显存从约15GB压到约4.5GB。
  3. LoRA注入:只在 attention 的 q/k/v/o 和 MLP 的 gate/up/down 上挂 LoRA,r=16,alpha=32,dropout=0.05。可训练参数约 29.4M,占全量的 0.42%。
  4. 训练与评估:单卡 batch=2,梯度累积8(等效batch 16),cosine调度,lr=2e-4,3个epoch。每200步记一次loss,验证集每epoch跑一次。

为什么 r 选16而不是8或32?我做了个小对比:r=8 时验证loss收敛到0.78就平了,格式遵循率约91%;r=16 收敛到0.71,格式遵循率97%;r=32 提升到0.70但显存多吃了1.8GB,性价比不高。所以16是这张卡上的甜点。

四、核心实现

4.1 数据准备

原始工单是脏的,先做清洗和模板化。关键点是:输出必须严格按目标格式写,模型学的是你给的样子,数据里混进10%的随意格式,输出就会有10%的概率跑偏。

import json
import random
from datasets import Dataset

SYSTEM = "你是工业设备运维助手。回答必须严格按【现象】【原因】【处置】三段式输出,每段不超过80字。"

def build_sample(raw):
    # raw: {"question": ..., "symptom": ..., "cause": ..., "action": ...}
    output = (
        f"【现象】{raw['symptom'].strip()}\n"
        f"【原因】{raw['cause'].strip()}\n"
        f"【处置】{raw['action'].strip()}"
    )
    return {
        "messages": [
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": raw["question"].strip()},
            {"role": "assistant", "content": output},
        ]
    }

with open("raw_tickets.jsonl", encoding="utf-8") as f:
    raws = [json.loads(line) for line in f]

# 基础过滤:丢掉过短、缺字段、输出不含三段式标记的样本
cleaned = []
for r in raws:
    if not all(k in r and r[k] and len(r[k]) > 5 for k in ("question", "symptom", "cause", "action")):
        continue
    cleaned.append(build_sample(r))

random.seed(42)
random.shuffle(cleaned)
n_val = int(len(cleaned) * 0.1)
train_ds = Dataset.from_list(cleaned[n_val:])
val_ds = Dataset.from_list(cleaned[:n_val])
train_ds.to_json("train.jsonl")
val_ds.to_json("val.jsonl")
print(f"train={len(train_ds)}, val={len(val_ds)}")
# 实际输出: train=2880, val=320

清洗后剩3200条,比我预期的少——原始工单里有近四成缺"原因"字段,这部分只能人工补或者丢弃。我的建议是宁可少而精,3000条高质量数据对LoRA来说足够改变风格了。

4.2 量化加载与LoRA配置

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

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

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

tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    quantization_config=bnb_config,
    device_map={"": 0},
    trust_remote_code=True,
)
model = prepare_model_for_kbit_training(model)
model.config.use_cache = False

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 29,425,664 || all params: 7,061,000,192 || trainable%: 0.4167

prepare_model_for_kbit_training 这步别省,它会把 LayerNorm 等层转成 fp32 并开启梯度检查点,不加的话训练loss会出现 NaN——我第一次跑就撞上了,loss 在第30步直接变 nan。

4.3 训练配置与循环

数据整理部分用 collate 手动做,把 messages 套 chat template 后拼成一条序列,只对 assistant 部分计算 loss:

from torch.utils.data import DataLoader
from transformers import get_cosine_schedule_with_warmup

MAX_LEN = 1024

def collate_fn(batch):
    input_ids_list, label_list = [], []
    for item in batch:
        msgs = item["messages"]
        prompt_text = tokenizer.apply_chat_template(
            msgs[:-1], tokenize=False, add_generation_prompt=True)
        full_text = prompt_text + msgs[-1]["content"] + tokenizer.eos_token
        prompt_ids = tokenizer(prompt_text, add_special_tokens=False)["input_ids"]
        full_ids = tokenizer(full_text, add_special_tokens=False,
                             truncation=True, max_length=MAX_LEN)["input_ids"]
        labels = [-100] * len(prompt_ids) + full_ids[len(prompt_ids):]
        labels = labels[:MAX_LEN]
        input_ids_list.append(full_ids)
        label_list.append(labels)

    max_len = max(len(x) for x in input_ids_list)
    input_ids = torch.tensor([
        x + [tokenizer.pad_token_id] * (max_len - len(x)) for x in input_ids_list])
    labels = torch.tensor([x + [-100] * (max_len - len(x)) for x in label_list])
    attention_mask = (input_ids != tokenizer.pad_token_id).long()
    return {"input_ids": input_ids, "labels": labels, "attention_mask": attention_mask}

train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, collate_fn=collate_fn)

optimizer = torch.optim.AdamW(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=2e-4, betas=(0.9, 0.999), weight_decay=0.01)

GRAD_ACCUM = 8
EPOCHS = 3
total_steps = len(train_loader) * EPOCHS // GRAD_ACCUM
scheduler = get_cosine_schedule_with_warmup(
    optimizer, num_warmup_steps=int(total_steps * 0.03),
    num_training_steps=total_steps)

model.train()
global_step = 0
for epoch in range(EPOCHS):
    for step, batch in enumerate(train_loader):
        batch = {k: v.to("cuda") for k, v in batch.items()}
        out = model(**batch)
        loss = out.loss / GRAD_ACCUM
        loss.backward()
        if (step + 1) % GRAD_ACCUM == 0:
            torch.nn.utils.clip_grad_norm_(
                filter(lambda p: p.requires_grad, model.parameters()), 1.0)
            optimizer.step()
            scheduler.step()
            optimizer.zero_grad()
            global_step += 1
            if global_step % 200 == 0:
                print(f"epoch={epoch} step={global_step} "
                      f"loss={out.loss.item():.4f} lr={scheduler.get_last_lr()[0]:.2e}")

关键配置汇总:lr=2e-4、warmup=3%、cosine、grad_clip=1.0、grad_accum=8、max_len=1024、bf16。lr 我试过 1e-4 和 3e-4,前者3个epoch收敛不够(loss停在0.83),后者第2个epoch就开始轻微震荡,2e-4最稳。

五、踩坑与优化

坑1:loss 变 NaN。 前面提过,原因是没做 prepare_model_for_kbit_training,4-bit 权重下的 LayerNorm 在 fp16 里数值溢出。加上之后消失。

坑2:验证集 loss 不降反升。 第2个epoch末尾验证loss从0.79升到0.81,典型过拟合。3200条数据对7B模型来说还是偏少。处理办法:把 lora_dropout 从0.05提到0.1,同时早停——实际我只用了前2.5个epoch的checkpoint。

坑3:显存峰值超预期。 一开始 max_len 设的2048,显存直接冲到23.1GB,OOM边缘。分析后发现是 batch=2 时序列padding到2048,attention 的中间激活太大。改成1024后峰值降到18.6GB,而且我们的问答对95%都在600 token以内,截断损失很小。

坑4:推理时输出带prompt残留。 保存LoRA权重后直接用 model.generate,忘了合并或加载adapter,输出的是基座模型的结果,白高兴一场。正确做法是用 PeftModel.from_pretrained 加载,或者 merge_and_unload() 合并后单独存。

优化后的显存与耗时数据:峰值显存18.6GB,单epoch约52分钟(2880条 / 等效batch16 ≈ 180步,每步约17秒),3个epoch合计约2.6小时。这个速度在单卡4090上属于正常水平,瓶颈在4-bit反量化的计算开销。

六、效果数据

Loss曲线(训练loss,每200步记录):

```
step 200: 1.8231
step 400: 1.3105
step 600: 1.0422
step 800: 0.9104 数据数量。3200条严格格式化的数据,效果远好于后来补充的8000条松散数据(我试过,格式遵循率反而掉到88%)。
4. 一定要看验证loss,不要只信最后checkpoint。这次如果直接用 epoch 3 的权重,过拟合会让输出变得"死板",遇到没见过的问法容易硬套模板。
5. 明确LoRA的能力边界:改风格、改格式、学术语,它很强;灌新知识,它不行,那需要RAG或者继续预训练。

代码和配置都已在上文给出,环境版本对得上就能直接跑。下一步我打算试试用 DPO 在LoRA基础上做一轮偏好对齐,把"回答冗余"这个问题再压一压,有结果再写一篇。