一、问题背景:为什么要在24GB卡上纠结LoRA和QLoRA

先说结论:不是所有团队都有A100 80G。我手上的机器是一张RTX 4090,24GB显存,要微调一个7B模型做垂直领域问答。全参数微调7B,哪怕用bf16,光模型权重就14GB,加上优化器状态和梯度,24GB根本不够,除非上DeepSpeed ZeRO-3加CPU offload,但那个速度慢到没法迭代。

所以LoRA是必选项。但LoRA本身不解决权重加载的显存问题——7B模型bf16加载还是14GB,加上激活值和KV cache,训练时峰值很容易顶到20GB以上,batch size只能开到1,稍微长一点的样本就OOM。这时候QLoRA的价值就出来了:把基座模型量化成4bit NF4加载,权重占用降到约4.5GB,剩下的显存可以留给更大的batch和更长的序列。

我这篇文章就是把两条路都走一遍,用同一份数据、同一套超参,把显存、loss、推理效果都量化对比出来。代码基于transformers + peft + bitsandbytes,全部可复现。

二、环境与版本

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

  • Python 3.10.13
  • torch 2.3.1 + cu121
  • transformers 4.42.4
  • peft 0.11.1
  • bitsandbytes 0.43.1
  • accelerate 0.31.0
  • datasets 2.20.0
  • trl 0.9.6(只用了SFTTrainer的数据打包逻辑,训练循环自己写的,原因后面说)

模型选的是Qwen2.5-7B-Instruct,7.6B参数,32层,hidden 3584。选它是因为中文领域数据上基座本身不差,微调前后对比更明显。

提醒一句:bitsandbytes 0.43.x 对 cu121 的兼容性比 0.42 好很多,如果你在 4090 上遇到 CUDA error: invalid argument,先查 bnb 版本。另外 peft 0.11 之后 LoraConfig 的 task_type 对 causal LM 要显式写 "CAUSAL_LM",不然保存的 adapter 加载时会报 key 不匹配。

三、方案设计

整体思路是控制变量:数据、超参、评估集完全一致,只改基座加载精度和 LoRA 注入方式。

数据准备:1.2万条领域问答对,格式是 alpaca 风格的三字段(instruction / input / output),清洗掉长度超过2048 token的样本(占3%左右),按 9:1 切训练/验证。对话模板直接用 Qwen 官方的 ChatML 格式,自己拼,不用 tokenizer 的 apply_chat_template 在数据预处理阶段做,避免训练时反复计算。

LoRA 配置:r=16,alpha=32,dropout=0.05,target_modules 覆盖 q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj。注意很多人只挂 attention 的 q/v,实测在领域数据上挂上 MLP 层效果提升明显,可训练参数从 0.08% 涨到 0.6% 左右,但值得。

QLoRA 配置:在 LoRA 基础上,基座用 BitsAndBytesConfig 做 NF4 双重量化,bnb_4bit_compute_dtype=torch.bfloat16,bnb_4bit_use_double_quant=True。LoRA 层本身仍是 bf16 训练。

训练超参:batch size 4(QLoRA 可以开到 8),gradient accumulation 4,等效 batch 16;lr 2e-4,cosine schedule,warmup ratio 0.03;3 个 epoch;max_length 1024;bf16 混合精度;gradient checkpointing 开启(这个对显存影响很大,后面细说)。

四、核心实现

先给数据格式化和 tokenize 的代码。这里的关键是 label 只对 output 部分计算 loss,instruction 部分 mask 成 -100,不然模型会去学怎么复述问题,浪费容量。

import torch
from datasets import load_dataset
from transformers import AutoTokenizer

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

def format_and_tokenize(example, max_len=1024):
    system = "你是一个专业的领域助手,请基于知识准确回答。"
    prompt = (
        f"system\n{system}\n"
        f"user\n{example['instruction']}\n{example['input']}\n"
        f"assistant\n"
    )
    answer = example["output"] + tokenizer.eos_token

    prompt_ids = tokenizer(prompt, add_special_tokens=False)["input_ids"]
    answer_ids = tokenizer(answer, add_special_tokens=False)["input_ids"]

    input_ids = (prompt_ids + answer_ids)[:max_len]
    labels = ([-100] * len(prompt_ids) + answer_ids)[:max_len]

    return {
        "input_ids": input_ids,
        "labels": labels,
        "attention_mask": [1] * len(input_ids),
    }

ds = load_dataset("json", data_files={"train": "train.jsonl", "valid": "valid.jsonl"})
train_ds = ds["train"].map(format_and_tokenize, remove_columns=ds["train"].column_names)
valid_ds = ds["valid"].map(format_and_tokenize, remove_columns=ds["valid"].column_names)

然后是模型加载和 LoRA 注入,两种方案只差一个 quantization_config:

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

lora_cfg = 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",
)

def build_model(use_qlora: bool):
    kwargs = dict(trust_remote_code=True, device_map={"": 0})
    if use_qlora:
        bnb = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_use_double_quant=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
        )
        model = AutoModelForCausalLM.from_pretrained(model_path, quantization_config=bnb, **kwargs)
        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
    else:
        model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, **kwargs)
        model.gradient_checkpointing_enable()

    model = get_peft_model(model, lora_cfg)
    model.print_trainable_parameters()
    return model

训练循环我用的是自己写的,没用 Trainer,原因是 Trainer 对动态 padding 和 label mask 的处理在多轮对话数据上偶尔会出问题,而且我想精确控制显存峰值。核心逻辑就是标准的 accelerate 封装:

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

collator = DataCollatorForSeq2Seq(tokenizer, padding=True, pad_to_multiple_of=8, label_pad_token_id=-100)
loader = DataLoader(train_ds, batch_size=4, shuffle=True, collate_fn=collator)

optimizer = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=2e-4)
total_steps = len(loader) * 3 // 4  # grad accum 4
scheduler = get_cosine_schedule_with_warmup(optimizer, int(total_steps*0.03), total_steps)

model.train()
global_step = 0
for epoch in range(3):
    for step, batch in enumerate(loader):
        batch = {k: v.to("cuda") for k, v in batch.items()}
        out = model(**batch)
        loss = out.loss / 4
        loss.backward()
        if (step + 1) % 4 == 0:
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step(); scheduler.step(); optimizer.zero_grad()
            global_step += 1

五、踩坑与优化

第一个坑是 gradient checkpointing 和 use_cache 冲突。开启 checkpointing 后必须 model.config.use_cache = False,否则前向会报错或者显存反而涨。这个在 Qwen 上尤其要注意,它默认 use_cache=True。

第二个坑是 QLoRA 下 prepare_model_for_kbit_training 会把 LayerNorm 转成 fp32,显存会多出几百MB,但这是必要的,不然 4bit 训练数值不稳,loss 会抖。我一开始图省事没开,loss 在第 200 步直接飙到 3.5 然后不降,排查了半天。

第三个坑是 padding 侧。Qwen 是 decoder-only,必须 left padding,tokenizer.padding_side = "left"。用 DataCollatorForSeq2Seq 默认是 right padding,短样本的 loss 会被 pad token 干扰。改成 left 之后验证 loss 曲线平滑了很多。

显存优化上最有效的一招其实是 pad_to_multiple_of=8 加 max_length=1024 的硬截断。我试过 2048,LoRA 方案直接 OOM,QLoRA 能跑但吞吐掉 40%,性价比不高,领域问答 1024 基本够用。

六、效果数据

训练过程 loss 曲线(验证集,每 100 步评估一次):

  • LoRA:起始 1.87 → 第 1 epoch 末 1.21 → 第 2 epoch 末 0.98 → 第 3 epoch 末 0.94,后期基本平了,说明 3 epoch 够了,再多过拟合。
  • QLoRA:起始 1.89 → 1.24 → 1.01 → 0.97。整体比 LoRA 高 0.03 左右,符合 4bit 量化的预期损失,但曲线形状几乎一致,收敛行为没有异常。

显存与吞吐(4090 24GB,batch 4,seq 1024):

指标 LoRA (bf16) QLoRA (NF4)
训练峰值显存 19.3 GB 11.8 GB
可训练参数 约 40M (0.53%) 约 40M (0.53%)
每步耗时 1.42 s 1.65 s
3 epoch 总时长 约 3.6 h 约 4.2 h

推理效果对比,用 200 条人工标注的领域测试集,按“答案要点覆盖 + 无事实错误”双维度打分:

  • 基座模型:准确率 52%,典型问题是答得太泛、术语用错、爱加免责声明。
  • LoRA 微调后:86%,术语准确,回答结构贴近业务话术。
  • QLoRA 微调后:84%,比 LoRA 低 2 个点,主要体现在个别数字类问题上偶有偏差,但整体可用。

推理延迟上,合并 adapter 后 LoRA 方案与原模型几乎一致(+2%),QLoRA 需要先反量化或者用 bnb 的 4bit 推理,实测首 token 延迟增加约 8%,吞吐下降 6% 左右,在可接受范围。

七、总结

如果你的卡是 24GB 且数据量在万级,我的建议是:优先 LoRA bf16,显存刚好卡在 19GB 出头,能跑就别量化,效果上限更高;如果显存只有 16GB,或者想把 batch 开大、序列拉长,QLoRA 是唯一现实选择,代价是 2 个点左右的精度和 15% 左右的训练时间。两者的 loss 收敛行为高度一致,说明 4bit 量化对 LoRA 微调的优化景观影响很小,这一点比预期乐观。

代码里最值得抄走的是 label mask 那段和 left padding 的设置,这两个细节对最终效果的影响比调 r 和 alpha 大得多。下一步我打算试试 r=32 加 DoRA,看看在同样显存下能不能把那 2 个点追回来。