从 SFT 到 LoRA

§1SFT 到底是什么

SFT 用的损失函数和预训练一模一样——都是 next-token 交叉熵：

关键差别只有两点：

• 数据少而精：从万亿 token 的网络爬虫，缩到几千到几十万对人工写好的 (指令, 答案)。
• 只对答案算 loss：把 prompt 部分的 label 设成 $-100$（PyTorch 的 ignore_index），让模型学怎么答，而不是学怎么问。

labels = input_ids.clone()
# Mask the prompt portion so CE loss skips it
labels[: prompt_len] = -100

常见 SFT 数据格式 · Alpaca 风

{
  "instruction": "用一句话解释什么是低秩矩阵。",
  "input": "",
  "output": "低秩矩阵的列空间维度远小于其形状所允许的最大维度。"
}

Stanford Alpaca 用 52K 条这样的样本就把 LLaMA 7B 调出了类 ChatGPT 风格。 [source]

§2把全部参数都改一遍？显存先崩

给 $N$ 参数的模型做全参数 SFT，每个可训练参数大约需要：

• $2$ 字节存权重（fp16 / bf16）
• $2$ 字节存梯度
• $8$ 字节存 Adam 的两个动量 $m, v$（fp32）

合计 约 $16$ 字节 / 参数。再加上前向激活、KV cache、梯度累积，实际显存往往是参数量的 $20$ 倍。

结果：$7\mathrm{B}$ 模型全参 SFT 已经吃掉一张 A100 80G，$175\mathrm{B}$ 直接劝退个人玩家。

§3关键直觉 · 微调改的东西本来就"很瘦"

线性代数里，一个 $d \times k$ 矩阵的秩 (rank) 等于它的列向量张成空间的维度。秩越低，这个矩阵"压缩"得越狠——把整个空间压成一个低维子空间。

论文实验显示，在 $175\mathrm{B}$ 的 GPT-3 上，把 $\Delta W$ 约束到 秩 $1$ 或 $2$ 都几乎不掉点。 [Hu et al. 2021]

§4LoRA 的数学 · 把 $\Delta W$ 拆成两小块

LoRA 把前向公式改写成：

它在做什么

原本你要训练一个 $d \times k$ 的"修改量" $\Delta W$，这是 $dk$ 个参数。LoRA 说：

参数量从 $dk$ 变成 $r(d+k)$。当 $d = k = 4096,\; r = 8$ 时：

• 原本：$4096 \times 4096 \,=\, 16\,777\,216$
• LoRA：$8 \times (4096 + 4096) \,=\, 65\,536$
• 缩减 $256\times$（仅一层；模型有上百层，整体缩减更夸张）

形状一眼看懂

$B$ 又高又瘦，$A$ 又扁又长——它们的乘积是一个秩最多为 $r$ 的"瘦扁"矩阵 $\Delta W$。

§5训练时冻结，推理时合并

LoRA 与 Adapter 类方法最大的区别在于推理时可以合并权重，不引入任何额外延迟。

§6动手 · 20 行 PEFT + TRL

来源：HF PEFT 文档 · TRL SFTTrainer · QLoRA。

from datasets import load_dataset
from peft import LoraConfig
from trl import SFTTrainer, SFTConfig

dataset = load_dataset("tatsu-lab/alpaca", split="train")

peft_config = LoraConfig(
    r=8,                                  # 秩，常用 8/16/32
    lora_alpha=16,                        # alpha = 2r 经验法则
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "v_proj"],  # 或 "all-linear"
)

trainer = SFTTrainer(
    model="meta-llama/Llama-3.2-1B",
    train_dataset=dataset,
    args=SFTConfig(
        output_dir="lora-alpaca",
        num_train_epochs=1,
        per_device_train_batch_size=2,
        learning_rate=2e-4,               # LoRA 用 ~10x 于全参微调
    ),
    peft_config=peft_config,
)
trainer.train()

import torch
import torch.nn as nn

class LoRALinear(nn.Module):
    def __init__(self, base: nn.Linear, r=8, alpha=16):
        super().__init__()
        self.base = base
        for p in self.base.parameters():
            p.requires_grad = False            # freeze W0
        d, k = base.out_features, base.in_features
        self.A = nn.Parameter(torch.randn(r, k) * 0.01)  # Gaussian init
        self.B = nn.Parameter(torch.zeros(d, r))         # zero init -> BA = 0
        self.scale = alpha / r

    def forward(self, x):
        return self.base(x) + self.scale * (x @ self.A.T @ self.B.T)

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

bnb = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",                # NF4 quantization
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,           # extra savings
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B", quantization_config=bnb)
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, LoraConfig(
    r=16, lora_alpha=32,
    target_modules="all-linear",
    task_type="CAUSAL_LM"))

# 8B model + QLoRA fits on a single 16 GB consumer card.

§7超参数 · 七寸在哪

r:            16
lora_alpha:   32
lora_dropout: 0.05
target:       all-linear
lr:           2e-4
epochs:       1-3
batch:        越大越好（用 grad-accum）

§8LoRA 大家族

从 2021 的 LoRA 出发，一个迅速膨胀的工具谱系。每张卡一句话讲清卖点，详细看论文。

§9一句话总结