大模型原理与训练 / 系统课时

运行 QLoRA 监督微调

运行 QLoRA 监督微调

这一节把 QLoRA 从配置推进到可重复的监督微调:固定与 LoRA 相同的数据切分和验收口径,完成 4-bit 基座加 LoRA 适配器训练,并同时记录峰值显存、有效 tokens/s、训练时间和验证损失,得到可直接比较的实验记录。

学习目标

  • 用 4-bit NF4 基座和 LoRA 适配器完成一次监督微调
  • 在同一训练口径下采集峰值显存、tokens/s、训练时间与验证指标
  • 用控制变量判断显存节省是否值得可能的速度或质量变化

固定可比的实验口径

QLoRA 的核心不是“把所有参数训练成 4-bit”,而是以 4-bit 形式加载并冻结基座权重,只更新低秩适配器。要判断它是否优于普通 LoRA,首先要让两次实验除了基座加载精度之外尽量一致,否则显存和质量差异无法归因。

至少固定训练集与验证集、提示模板、最大序列长度、随机种子、epoch、有效 batch size、LoRA 的秩与目标模块,以及验证时的生成参数。硬件、CUDA 与依赖版本也应记录,因为它们会影响吞吐和显存。

本节示例约定 train.jsonl 与 valid.jsonl 每行各有 instruction、response 两个字段。LoRA 基线也应使用同样的两个文件和同一验收提示集。

运行训练并采集指标

下面的脚本以单卡为例,使用 4-bit NF4、双重量化和 LoRA 训练。它会把用户提示部分的标签设为 -100,只对回答 token 计算监督损失,并在训练结束后输出四个核心指标。保存为 train_qlora.py 后,可用 python train_qlora.py --train train.jsonl --valid valid.jsonl 运行。

python
import argparse
import json
import time
from pathlib import Path

import torch
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from torch.utils.data import Dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    Trainer,
    TrainingArguments,
)

class JsonlSFTDataset(Dataset):
    def __init__(self, path, tokenizer, max_length):
        self.items = []
        for line in Path(path).read_text(encoding="utf-8").splitlines():
            record = json.loads(line)
            prompt = tokenizer.apply_chat_template(
                [{"role": "user", "content": record["instruction"]}],
                tokenize=False,
                add_generation_prompt=True,
            )
            full_text = tokenizer.apply_chat_template(
                [
                    {"role": "user", "content": record["instruction"]},
                    {"role": "assistant", "content": record["response"]},
                ],
                tokenize=False,
                add_generation_prompt=False,
            )
            prompt_ids = tokenizer(
                prompt,
                add_special_tokens=False,
                truncation=True,
                max_length=max_length,
            )["input_ids"]
            full = tokenizer(
                full_text,
                add_special_tokens=False,
                truncation=True,
                max_length=max_length,
            )
            input_ids = full["input_ids"]
            prompt_len = min(len(prompt_ids), len(input_ids))
            labels = [-100] * prompt_len + input_ids[prompt_len:]
            if all(x == -100 for x in labels):
                raise ValueError(f"{path} 中存在回答被 max_length 完全截断的样本")
            self.items.append(
                {
                    "input_ids": input_ids,
                    "attention_mask": full["attention_mask"],
                    "labels": labels,
                }
            )

    def __len__(self):
        return len(self.items)

    def __getitem__(self, index):
        return self.items[index]

def make_collator(pad_token_id):
    def collate(batch):
        max_len = max(len(x["input_ids"]) for x in batch)

        def pad(values, fill):
            return values + [fill] * (max_len - len(values))

        return {
            "input_ids": torch.tensor(
                [pad(x["input_ids"], pad_token_id) for x in batch],
                dtype=torch.long,
            ),
            "attention_mask": torch.tensor(
                [pad(x["attention_mask"], 0) for x in batch],
                dtype=torch.long,
            ),
            "labels": torch.tensor(
                [pad(x["labels"], -100) for x in batch],
                dtype=torch.long,
            ),
        }

    return collate

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--train", required=True)
    parser.add_argument("--valid", required=True)
    parser.add_argument("--model", default="Qwen/Qwen2.5-0.5B-Instruct")
    parser.add_argument("--max-length", type=int, default=512)
    args = parser.parse_args()

    if not torch.cuda.is_available():
        raise RuntimeError("QLoRA 4-bit 训练示例需要可用的 CUDA GPU")

    use_bf16 = torch.cuda.is_bf16_supported()
    compute_dtype = torch.bfloat16 if use_bf16 else torch.float16
    quant_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_use_double_quant=True,
        bnb_4bit_compute_dtype=compute_dtype,
    )

    tokenizer = AutoTokenizer.from_pretrained(args.model, use_fast=True)
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token_id = tokenizer.eos_token_id

    model = AutoModelForCausalLM.from_pretrained(
        args.model,
        quantization_config=quant_config,
        device_map={"": 0},
    )
    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)

    train_ds = JsonlSFTDataset(args.train, tokenizer, args.max_length)
    valid_ds = JsonlSFTDataset(args.valid, tokenizer, args.max_length)

    training_args = TrainingArguments(
        output_dir="outputs/qlora",
        per_device_train_batch_size=1,
        per_device_eval_batch_size=1,
        gradient_accumulation_steps=8,
        learning_rate=2e-4,
        num_train_epochs=1,
        max_grad_norm=0.3,
        gradient_checkpointing=True,
        optim="paged_adamw_8bit",
        logging_strategy="no",
        save_strategy="no",
        report_to="none",
        seed=42,
        data_seed=42,
        bf16=use_bf16,
        fp16=not use_bf16,
    )

    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_ds,
        eval_dataset=valid_ds,
        data_collator=make_collator(tokenizer.pad_token_id),
    )

    torch.cuda.empty_cache()
    torch.cuda.reset_peak_memory_stats()
    torch.cuda.synchronize()
    started = time.perf_counter()
    trainer.train()
    torch.cuda.synchronize()
    train_time = time.perf_counter() - started

    peak_gib = torch.cuda.max_memory_allocated() / (1024 ** 3)
    eval_metrics = trainer.evaluate()
    trainer.save_model("outputs/qlora/adapter")
    effective_tokens = sum(len(item["input_ids"]) for item in train_ds)
    metrics = {
        "peak_gpu_gib": round(peak_gib, 3),
        "tokens_per_s": round(effective_tokens / train_time, 2),
        "train_time_s": round(train_time, 2),
        "eval_loss": round(eval_metrics["eval_loss"], 4),
    }
    print(json.dumps(metrics, ensure_ascii=False))

if __name__ == "__main__":
    main()

预期输出

text
{"peak_gpu_gib": <PEAK_GIB>, "tokens_per_s": <TOKENS_PER_S>, "train_time_s": <TIME>, "eval_loss": <EVAL_LOSS>}

<PEAK_GIB>、<TOKENS_PER_S>、<TIME> 与 <EVAL_LOSS> 会被实际数值替换。这里的 tokens/s 按本次训练集的非 padding 输入 token 数除以实测训练时间计算,因此与 LoRA 基线比较时必须保持数据、序列长度和 epoch 一致。

读取结果而不是只看显存

峰值显存下降只是 QLoRA 的一个收益。4-bit 权重需要在计算路径中进行反量化,吞吐未必与显存同比改善,所以至少要把四个指标放在同一张记录表里。

指标 QLoRA 关注点 与 LoRA 比较时的判断
峰值显存 是否明显降低并留出更长序列或更大 batch 的空间 越低越好,但不能牺牲验收质量
tokens/s 量化与反量化是否拖慢训练 必须在同卡、同数据、同有效 batch 下比较
训练时间 完整训练成本是否可接受 结合 tokens/s 与总 step 一起看
验证损失 监督目标是否出现明显退化 只在同一验证集和同一标签策略下比较

验证损失相近并不等于生成效果必然相同。再准备一组固定提示,分别加载 LoRA 与 QLoRA 适配器,使用完全相同的解码参数检查事实正确性、格式遵循和重复生成。这样才能把“训练指标可比”补成“任务效果可比”。

做出取舍结论

如果 QLoRA 显著降低峰值显存,而验证损失和固定提示验收没有实质退化,即使 tokens/s 略有下降,也常常值得换取更低的硬件门槛或更大的上下文与 batch。反过来,如果节省的显存并未解除实际瓶颈,却带来明显吞吐下降或质量退化,就应保留普通 LoRA。

最终记录不要只写“QLoRA 更省显存”,而应保留同一口径下的四项数值、固定提示验收结果和硬件环境。下一次更换模型、序列长度或 GPU 时,这些数据仍能帮助判断量化训练是否真正划算。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

运行 QLoRA 监督微调

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通