参数高效微调深度解析：从 LoRA 到 QLoRA 的全面指南

1. 引言：为什么需要参数高效微调？#

1.1 全参数微调的困境#

想象一下你要微调一个拥有 700 亿参数的 LLaMA-2 模型：

1
全参数微调的资源消耗：
2

3
  模型: LLaMA-2 70B
4
  参数: 70,000,000,000 (700 亿)
5

6
  存储:
7
  - 模型权重: 140 GB (FP16)
8
  - 优化器状态: 280 GB (Adam 状态)
9
  - 梯度: 140 GB
10
  - 总计: ~560 GB 显存
11

12
  成本:
13
  - A100 80GB × 8 = ~$40,000/月（云端）
14
  - 或购买 8 张 A100 40GB = ~$160,000
15

16
  现实：
17
  → 个人开发者几乎不可能
18
  → 中小企业也难以承受
19
  → 每训练一个任务都需要复制全量权重

1.2 PEFT 的核心思想#

参数高效微调（PEFT） 的核心洞察是：微调时不需要更新所有参数，只需要更新一小部分参数。

1
class PEFTCoreIdea:
2
    """
3
    PEFT 的核心思想
4

5
    全参数微调:
6
    θ_new = θ_old - lr * ∇L(θ_old)
7

8
    PEFT (LoRA):
9
    W_new = W_old + ΔW
10
    ΔW = B @ A  (低秩矩阵)
11

12
    关键：只训练 A 和 B，W_old 冻结
13
    """
14

15
    def full_finetuning(self):
16
        """
17
        全参数微调
18

19
        所有参数都是可训练的:
20
        - 70B 参数 → 70B 可训练
21

22
        优点: 表达能力最强
23
        缺点: 资源消耗巨大
24
        """
25
        return {
26
            "trainable_params": "100%",
27
            "显存需求": "~560GB (70B 模型)",
28
            "适用场景": "有充足资源 + 最高性能要求",
29
        }
30

31
    def lora(self):
32
        """
33
        LoRA
34

35
        只训练低秩适配矩阵:
36
        - W ∈ R^(d×k)
37
        - A ∈ R^(r×k), B ∈ R^(d×r)
38
        - 只训练 r×(d+k) << d×k 参数
39

40
        70B 模型示例:
41
        - r=8, d=4096, k=4096
42
        - 可训练参数: 8 × (4096+4096) = ~65K
43
        - 仅为原来的 0.0001%
44
        """
45
        return {
46
            "trainable_params": "~0.01% - 0.1%",
47
            "显存需求": "~few GB",
48
            "适用场景": "资源受限 + 快速实验",
49
        }

1.3 PEFT 方法全景#

1
┌─────────────────────────────────────────────────────────────┐
2
│                      PEFT 方法全景                           │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  1. 适配器方法 (Adapter-based)                              │
6
│     ├─ Adapter (Houlsby et al., 2019)                       │
7
│     ├─ Compacter (Mahabadi et al., 2021)                    │
8
│     └─ AdapterDrop (Rücklé et al., 2020)                     │
9
│                                                              │
10
│  2. 增量表示方法 (Additive)                                 │
11
│     ├─ Prefix Tuning (Li & Liang, 2021)                      │
12
│     ├─ Prompt Tuning (Lester et al., 2021)                   │
13
│     └─ P-Tuning (Liu et al., 2021)                          │
14
│                                                              │
15
│  3. 低秩分解方法 (Low-rank)                                 │
16
│     ├─ LoRA (Hu et al., 2021)  ← 主流                     │
17
│     ├─ QLoRA (Dettmers et al., 2023)                        │
18
│     ├─ DoRA (Liu et al., 2024)                              │
19
│     ├─ LoRA+ (Hayou et al., 2024)                           │
20
│     └─ PiSSA (Meng et al., 2024)                            │
21
│                                                              │
22
│  4. 混合方法                                                │
23
│     └─ MoL (Mix-of-LoRA)                                   │
24
│                                                              │
25
└─────────────────────────────────────────────────────────────┘

1.4 本系列文章关联#

文章	关联
后训练深度解析	PEFT 在后训练中的位置
数据构建深度解析	微调数据的构建方法

2. LoRA：低秩自适应#

2.1 LoRA 的核心原理#

LoRA（Low-Rank Adaptation，Hu et al., 2021）的核心发现是：预训练语言模型的权重更新具有低内在秩。

1
class LoRA原理:
2
    """
3
    LoRA 原理
4

5
    假设：对于预训练模型权重 W₀ ∈ R^(d×k)，
6
    微调后的权重更新 ΔW 也可以用低秩矩阵近似。
7

8
    W_new = W₀ + ΔW
9
           = W₀ + BA
10

11
    其中:
12
    - B ∈ R^(d×r)
13
    - A ∈ R^(r×k)
14
    - r << min(d, k)
15

16
    关键洞察：
17
    ΔW 是低秩的 → 用 BA 近似 ΔW
18
    """
19

20
    def __init__(self, d, k, r):
21
        self.d = d      # 输出维度
22
        self.k = k      # 输入维度
23
        self.r = r      # 秩
24

25
        # 冻结原始权重
26
        self.W0 = None
27

28
        # 可训练的低秩矩阵
29
        self.A = nn.Parameter(torch.randn(r, k) * 0.01)  # 用小随机值初始化
30
        self.B = nn.Parameter(torch.zeros(d, r))  # 用零初始化
31

32
    def forward(self, x):
33
        """
34
        前向传播
35

36
        h = W₀x + BAx
37
          = W₀x + ΔWx
38
        """
39
        return self.W0 @ x + (self.B @ self.A) @ x
40

41
    def compute_trainable_params(self):
42
        """
43
        计算可训练参数数量
44
        """
45
        trainable = self.r * (self.d + self.k)
46
        total = self.d * self.k
47

48
        ratio = trainable / total * 100
49

50
        print(f"Total: {total:,} params")
51
        print(f"Trainable: {trainable:,} params")
52
        print(f"Ratio: {ratio:.4f}%")
53

54
        return trainable

2.2 LoRA 的数学推导#

1
LoRA 的数学推导：
2

3
Step 1: 问题形式化
4

5
  给定预训练权重 W₀ ∈ R^(d×k)，
6
  我们想学习一个更新 ΔW，使得：
7

8
  W_new = W₀ + ΔW
9

10
  直接学习 ΔW 需要优化 d×k 个参数。
11

12
Step 2: 低秩假设
13

14
  假设 ΔW 的秩 r << min(d, k)，
15
  则存在分解：
16

17
  ΔW = BA, 其中 B ∈ R^(d×r), A ∈ R^(r×k)
18

19
  可训练参数: r×(d+k) << d×k
20

21
Step 3: 为什么低秩有效？
22

23
  预训练语言模型的知识是"过参数化"的。
24
  微调时，重要的知识改变发生在低秩子空间中。
25

26
  数学解释：
27
  - W₀ 捕获通用语言知识
28
  - ΔW 捕获特定任务知识
29
  - 任务特定知识可以用低秩表示
30

31
Step 4: 初始化策略
32

33
  A 的初始化: 随机小值（~N(0, 0.02)）
34
  B 的初始化: 零矩阵
35

36
  这样初始化确保 ΔW = BA = 0 初始状态。
37
  训练从 W₀ 开始，逐渐学习 ΔW。

2.3 LoRA 的实现#

1
class LoRALinear(nn.Module):
2
    """
3
    LoRA 线性层实现
4
    """
5

6
    def __init__(self, in_features, out_features, rank=4, alpha=1.0, dropout=0.0):
7
        super().__init__()
8

9
        self.in_features = in_features
10
        self.out_features = out_features
11
        self.rank = rank
12
        self.alpha = alpha
13
        self.scaling = alpha / rank  # 缩放因子
14

15
        # 原始权重（冻结）
16
        self.weight = nn.Parameter(
17
            torch.randn(out_features, in_features),
18
            requires_grad=False
19
        )
20
        self.bias = nn.Parameter(
21
            torch.zeros(out_features),
22
            requires_grad=False
23
        )
24

25
        # LoRA 参数
26
        self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
27
        self.lora_B = nn.Parameter(torch.zeros(out_features, rank))
28

29
        # Dropout（可选）
30
        self.dropout = nn.Dropout(p=dropout)
31

32
        # 标记哪些参数是 LoRA 的
33
        self.lora_dropout = nn.Identity()
34

35
    def forward(self, x):
36
        """
37
        前向传播
38
        """
39
        # 原始输出
40
        output = F.linear(x, self.weight, self.bias)
41

42
        # LoRA 输出
43
        # h = Wx + (α/r) * BAx
44
        lora_output = (self.dropout(x) @ self.lora_A.T @ self.lora_B.T) * self.scaling
45

46
        return output + lora_output
47

48
    def merge_weights(self):
49
        """
50
        合并权重
51

52
        将 LoRA 权重合并到原始权重中
53
        用于推理阶段，消除额外计算
54
        """
55
        # W_new = W + (α/r) * BA
56
        merged_weight = self.weight + (self.alpha / self.rank) * (self.lora_B @ self.lora_A)
57

58
        return merged_weight

2.4 哪些层应该应用 LoRA？#

1
class LoRALayerSelection:
2
    """
3
    LoRA 层选择策略
4
    """
5

6
    # 不同配置的实验结果（来自论文）
7
    EXPERIMENTS = {
8
        "llama_7b": {
9
            # 只有 Query 注意力
10
            "q": {"trainable": 0.09, "average": 91.2},
11

12
            # Query + Value
13
            "qkv": {"trainable": 0.27, "average": 93.1},
14

15
            # 所有注意力层
16
            "qkv_proj": {"trainable": 0.39, "average": 93.5},
17

18
            # 包含 MLP
19
            "all": {"trainable": 1.07, "average": 93.9},
20

21
            # 包含所有线性层
22
            "all_linear": {"trainable": "3.2%", "average": 94.1},
23
        },
24

25
        "llama_65b": {
26
            "qkv": {"trainable": 0.06, "average": 92.7},
27
            "all_linear": {"trainable": "0.8%", "average": 94.1},
28
        },
29
    }
30

31
    def recommended_config(self, model_size="7b"):
32
        """
33
        推荐配置
34
        """
35
        configs = {
36
            "7b": {
37
                "target_modules": ["q_proj", "v_proj", "k_proj", "o_proj"],
38
                "rank": 8,
39
                "alpha": 16,
40
                "dropout": 0.05,
41
            },
42
            "13b": {
43
                "target_modules": ["q_proj", "v_proj", "k_proj", "o_proj"],
44
                "rank": 8,
45
                "alpha": 16,
46
                "dropout": 0.05,
47
            },
48
            "70b": {
49
                "target_modules": ["q_proj", "v_proj"],
50
                "rank": 8,
51
                "alpha": 16,
52
                "dropout": 0.05,
53
            },
54
        }
55

56
        return configs.get(model_size, configs["7b"])

层选择策略对比：

配置	可训练参数	性能	建议
仅 Q	~0.03%	中等	极端资源受限
Q, V	~0.09%	良好	常用推荐
Q, K, V, O	~0.39%	更好	推荐
Q, K, V, O + MLP	~1.07%	最好	有条件时使用

3. QLoRA：量化感知的 LoRA#

3.1 QLoRA 的核心思想#

QLoRA（Quantized LoRA，Dettmers et al., 2023）将量化与 LoRA 结合，在 4-bit 量化基础上微调。

1
class QLoRA:
2
    """
3
    QLoRA: Quantized Low-Rank Adaptation
4

5
    核心创新：
6
    1. 4-bit NormalFloat (NF4) 量化
7
    2. 双重量化（对量化常数也量化）
8
    3. 分页优化器（处理内存峰值）
9
    """
10

11
    def __init__(self, model, rank=64, alpha=16):
12
        self.model = model
13
        self.rank = rank
14
        self.alpha = alpha
15

16
        # Step 1: 4-bit 量化基础模型
17
        self.quantized_base = self.quantize_model(model)
18

19
        # Step 2: 添加 LoRA 适配器（16-bit，精度）
20
        self.lora_adapters = self.add_lora_adapters()
21

22
    def quantize_model(self, model):
23
        """
24
        量化模型
25

26
        方法：NF4 (4-bit NormalFloat)
27
        """
28
        from bitsandbytes import BitsAndBytesConfig
29

30
        quantization_config = BitsAndBytesConfig(
31
            load_in_4bit=True,
32
            bnb_4bit_compute_dtype=torch.bfloat16,
33
            bnb_4bit_use_double_quant=True,  # 双重量化
34
            bnb_4bit_quant_type="nf4",  # NormalFloat4
35
        )
36

37
        quantized_model = model.from_pretrained(
38
            model_path,
39
            quantization_config=quantization_config,
40
        )
41

42
        return quantized_model
43

44
    def add_lora_adapters(self):
45
        """
46
        添加 LoRA 适配器
47

48
        LoRA 参数保持 16-bit，不量化
49
        """
50
        from peft import get_peft_model, LoraConfig
51

52
        lora_config = LoraConfig(
53
            r=self.rank,
54
            lora_alpha=self.alpha,
55
            target_modules=["q_proj", "v_proj"],
56
            lora_dropout=0.05,
57
            bias="none",
58
            task_type="CAUSAL_LM",
59
        )
60

61
        model = get_peft_model(self.quantized_base, lora_config)
62
        model.print_trainable_parameters()
63

64
        return model

3.2 NF4 量化原理#

1
class NF4Quantization:
2
    """
3
    NF4 (4-bit NormalFloat) 量化
4

5
    关键思想：
6
    1. 对权重按 abs 值分组
7
    2. 用归一化的分位数量化
8
    3. 保持重要权重（大幅值）的精度
9
    """
10

11
    def __init__(self, n_bits=4):
12
        self.n_bits = n_bits
13
        self.num_values = 2 ** n_bits  # 16 个离散值
14

15
    def quantize(self, weights):
16
        """
17
        NF4 量化
18
        """
19
        # Step 1: 计算绝对值
20
        abs_weights = torch.abs(weights)
21

22
        # Step 2: 确定量化常数（分位数）
23
        # NF4 使用特殊的分位数量化表
24
        quantiles = self.compute_quantiles(abs_weights, self.num_values)
25

26
        # Step 3: 量化
27
        quantized = self.assign_quantized_values(weights, quantiles)
28

29
        return quantized, quantiles
30

31
    def compute_quantiles(self, values, num_bins):
32
        """
33
        计算分位数
34

35
        对于 k-bit 量化，我们需要 2^k 个量化值。
36
        NF4 使用归一化的分位数，确保每个 bin 有相同数量的权重。
37
        """
38
        # 展平
39
        flat = values.flatten().float()
40

41
        # 计算分位数
42
        # 使用特殊的 NF4 分位数量化表
43
        # 这里简化实现
44
        probs = torch.linspace(0, 1, num_bins + 1)[1:-1]
45
        quantiles = torch.quantile(flat, probs)
46

47
        return quantiles
48

49
    def dequantize(self, quantized, quantiles):
50
        """
51
        反量化
52
        """
53
        # 找到最近的量化值
54
        indices = self.find_nearest_indices(quantized, quantiles)
55

56
        # 重建
57
        reconstructed = quantiles[indices]
58

59
        return reconstructed

3.3 QLoRA vs LoRA 显存对比#

1
QLoRA 显存节省：
2

3
  模型: LLaMA-2 65B
4

5
  全参数微调:
6
  - 权重: 130 GB (FP16)
7
  - 梯度: 130 GB
8
  - 优化器: 260 GB
9
  - 总计: 520 GB
10

11
  LoRA (FP16):
12
  - 权重: 130 GB (冻结)
13
  - LoRA 参数: ~150 MB
14
  - 梯度: ~500 MB
15
  - 优化器: ~1 GB
16
  - 总计: ~132 GB
17

18
  QLoRA (4-bit):
19
  - 量化权重: 32 GB (NF4)
20
  - LoRA 参数: ~150 MB (BF16)
21
  - 梯度: ~200 MB
22
  - 优化器: ~400 MB
23
  - 总计: ~33 GB
24

25
  节省: 520GB → 33GB (94% 减少!)
26

27
  可用硬件:
28
  - 全参数: 需要 A100 80GB × 8
29
  - LoRA: 需要 A100 40GB × 1
30
  - QLoRA: 需要 A100 40GB × 1 (甚至 3090!)

4. LoRA 的变体#

4.1 DoRA：权重分解自适应#

1
class DoRA:
2
    """
3
    DoRA: Weight-Decomposed Low-Rank Adaptation (Liu et al., 2024)
4

5
    核心思想：
6
    将权重更新分解为幅度和方向两部分。
7

8
    原始 LoRA:
9
    W_new = W₀ + BA
10

11
    DoRA:
12
    W_new = W₀ + m·(BA / ||BA||_F)
13

14
    其中 m 是可学习的幅度，BA/||BA||_F 是方向。
15
    """
16

17
    def __init__(self, in_features, out_features, rank=4):
18
        self.in_features = in_features
19
        self.out_features = out_features
20
        self.rank = rank
21

22
        # 原始权重（冻结）
23
        self.W0 = None
24

25
        # 方向（LoRA）
26
        self.A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
27
        self.B = nn.Parameter(torch.zeros(out_features, rank))
28

29
        # 幅度
30
        self.m = nn.Parameter(torch.ones(out_features, in_features))
31

32
    def forward(self, x):
33
        """
34
        DoRA 前向传播
35
        """
36
        # 原始输出
37
        base_output = F.linear(x, self.W0)
38

39
        # LoRA 方向
40
        delta_W = self.B @ self.A
41

42
        # 幅度归一化
43
        normalized_delta = delta_W / (torch.norm(delta_W, p='fro') + 1e-8)
44

45
        # 加幅度
46
        weighted_delta = self.m * normalized_delta
47

48
        return base_output + weighted_delta * x

DoRA vs LoRA 对比：

方面	LoRA	DoRA
更新方式	联合更新 BA	分解为幅度+方向
可解释性	差	好
性能	基准	更高
收敛速度	中等	更快

4.2 PiSSA：主成分初始化#

1
class PiSSA:
2
    """
3
    PiSSA: Principal Singular Values Adaptation (Meng et al., 2024)
4

5
    核心思想：
6
    用 SVD 对权重矩阵进行分解，
7
    只对最重要的奇异分量应用 LoRA。
8

9
    优势：
10
    1. 更好的初始化
11
    2. 更快的收敛
12
    3. 更好的性能
13
    """
14

15
    def __init__(self, weight, rank=4):
16
        self.weight = weight  # 原始权重
17
        self.rank = rank
18

19
        # Step 1: SVD 分解
20
        U, S, Vh = torch.linalg.svd(weight.float(), full_matrices=False)
21

22
        # Step 2: 选择主成分
23
        # 只对前 r 个奇异分量应用 LoRA
24
        self.U_main = U[:, :rank]  # 保留主要方向
25
        self.S_main = S[:rank]
26
        self.Vh_main = Vh[:rank, :]
27

28
        # Step 3: 初始化 LoRA
29
        # 用主成分的权重初始化
30
        self.A = nn.Parameter(self.Vh_main)
31
        self.B = nn.Parameter(self.U_main @ torch.diag(self.S_main))
32

33
        # 剩余奇异值作为偏置
34
        self.remaining = U[:, rank:] @ torch.diag(S[rank:]) @ Vh[rank:, :]
35

36
    def forward(self, x):
37
        """
38
        PiSSA 前向传播
39
        """
40
        # 主成分部分用 LoRA
41
        lora_part = (self.B @ self.A) @ x
42

43
        # 剩余部分（冻结）
44
        remaining_part = self.remaining @ x
45

46
        # 偏置部分
47
        bias_part = self.weight.bias @ x if hasattr(self.weight, 'bias') else 0
48

49
        return lora_part + remaining_part + bias_part

4.3 LoRA+#

1
class LoRAPlus:
2
    """
3
    LoRA+: Different Learning Rates for A and B (Hayou et al., 2024)
4

5
    核心思想：
6
    A 和 B 应该有不同的学习率。
7

8
    原始 LoRA:
9
    lr_A = lr_B = lr
10

11
    LoRA+:
12
    lr_A = lr / λ_A
13
    lr_B = lr * λ_B
14

15
    推荐: λ_A = r, λ_B = 1
16
    """
17

18
    def configure_optimizers(self, model, base_lr=1e-4, r=8):
19
        """
20
        配置优化器
21
        """
22
        # A 的学习率（通常较小）
23
        lr_A = base_lr / r
24

25
        # B 的学习率（标准）
26
        lr_B = base_lr
27

28
        # 其他参数（LoRA 以外）
29
        lr_other = base_lr * 0.1
30

31
        optimizer_grouped_parameters = [
32
            # LoRA A
33
            {"params": model.lora_A, "lr": lr_A},
34
            # LoRA B
35
            {"params": model.lora_B, "lr": lr_B},
36
            # 其他（冻结）
37
            {"params": model.other_params, "lr": 0},
38
        ]
39

40
        return torch.optim.AdamW(optimizer_grouped_parameters)

4.4 LoRA 变体对比#

方法	核心创新	性能提升	计算开销
LoRA	低秩分解	基准	低
DoRA	幅度+方向分解	+2-5%	极低
PiSSA	SVD 初始化	+3-8%	低
LoRA+	自适应学习率	+2-5%	极低
QLoRA	4-bit 量化	接近 FP16	中等

5. 其他 PEFT 方法#

5.1 Adapter#

1
class Adapter:
2
    """
3
    Adapter (Houlsby et al., 2019)
4

5
    结构：逐层添加瓶颈网络
6

7
    h = W₀x + adapter(W₀x)
8

9
    adapter: d → r → d (bottleneck: r << d)
10
    """
11

12
    def __init__(self, d_model, r=64, alpha=16):
13
        self.d_model = d_model
14
        self.r = r  # bottleneck 维度
15

16
        # 下投影
17
        self.down = nn.Linear(d_model, r)
18

19
        # 上投影
20
        self.up = nn.Linear(r, d_model)
21

22
        # 非线性
23
        self.act = nn.GELU()
24

25
        # LayerNorm
26
        self.layer_norm = nn.LayerNorm(d_model)
27

28
        # 残差缩放
29
        self.alpha = alpha
30

31
    def forward(self, x):
32
        """
33
        Adapter 前向传播
34
        """
35
        # 原始残差
36
        residual = x
37

38
        # Adapter
39
        adapter_output = self.up(self.act(self.down(x)))
40

41
        # 残差连接（带缩放）
42
        output = self.layer_norm(residual + (self.alpha / self.r) * adapter_output)
43

44
        return output

5.2 Prefix Tuning#

1
class PrefixTuning:
2
    """
3
    Prefix Tuning (Li & Liang, 2021)
4

5
    核心思想：
6
    在每层注意力之前添加可学习的前缀。
7

8
    不修改模型权重，只添加前缀参数。
9
    """
10

11
    def __init__(self, num_layers, num_heads, head_dim, prefix_len=10):
12
        self.num_layers = num_layers
13
        self.num_heads = num_heads
14
        self.head_dim = head_dim
15
        self.prefix_len = prefix_len
16

17
        # 可学习的前缀
18
        # 每层有独立的 prefix
19
        self.prefixes = nn.ParameterList([
20
            nn.Parameter(torch.randn(prefix_len, num_heads * head_dim) * 0.01)
21
            for _ in range(num_layers)
22
        ])
23

24
    def forward(self, layer_idx, q, k, v):
25
        """
26
        应用 Prefix Tuning
27

28
        在 Key 和 Value 前面拼接可学习的 prefix
29
        """
30
        # 获取该层的前缀
31
        prefix = self.prefixes[layer_idx]
32

33
        # 分割 head
34
        prefix_q = prefix[:, :self.num_heads * self.head_dim]
35
        prefix_k = prefix[:, :self.num_heads * self.head_dim]
36
        prefix_v = prefix[:, :self.num_heads * self.head_dim]
37

38
        # Reshape
39
        batch_size = q.shape[0]
40
        prefix_len = prefix.shape[0]
41

42
        prefix_q = prefix_q.unsqueeze(0).expand(batch_size, -1, -1)
43
        prefix_k = prefix_k.unsqueeze(0).expand(batch_size, -1, -1)
44
        prefix_v = prefix_v.unsqueeze(0).expand(batch_size, -1, -1)
45

46
        # 拼接
47
        k_full = torch.cat([prefix_k, k], dim=1)
48
        v_full = torch.cat([prefix_v, v], dim=1)
49

50
        return k_full, v_full

5.3 Prompt Tuning#

1
class PromptTuning:
2
    """
3
    Prompt Tuning (Lester et al., 2021)
4

5
    核心思想：
6
    只添加可学习的 soft prompt，完全不修改模型。
7

8
    参数量：prefix_len × embedding_dim
9
    """
10

11
    def __init__(self, vocab_size, embed_dim, num_tokens=20):
12
        self.vocab_size = vocab_size
13
        self.embed_dim = embed_dim
14
        self.num_tokens = num_tokens
15

16
        # 可学习的 soft prompt
17
        self.prompt = nn.Parameter(
18
            torch.randn(1, num_tokens, embed_dim) * 0.01
19
        )
20

21
    def forward(self, input_ids, embedding_layer):
22
        """
23
        获取带 prompt 的 embedding
24
        """
25
        # 输入 embedding
26
        inputs_embeds = embedding_layer(input_ids)
27

28
        # 拼接 prompt
29
        batch_size = inputs_embeds.shape[0]
30
        prompt = self.prompt.expand(batch_size, -1, -1)
31

32
        full_embeds = torch.cat([prompt, inputs_embeds], dim=1)
33

34
        # 记录 prompt 长度（用于 mask）
35
        prompt_length = self.num_tokens
36

37
        return full_embeds, prompt_length

5.4 方法对比#

方法	引入参数	位置	推理开销	性能
LoRA	~0.1-1%	权重矩阵旁	低（可合并）	高
Adapter	~0.5-5%	残差连接中	中	高
Prefix Tuning	~0.1%	输入前	中	中
Prompt Tuning	~0.01%	嵌入层前	低	较低
QLoRA	~0.1%	权重矩阵旁	中	接近全参数

6. 秩的选择与调优#

6.1 秩的理论分析#

1
class RankSelection:
2
    """
3
    LoRA 秩的选择
4
    """
5

6
    # 不同秩的实验结果（来自论文）
7
    EXPERIMENTS = {
8
        "WikiSQL": {
9
            "r=1": 74.2,
10
            "r=2": 75.6,
11
            "r=4": 77.2,
12
            "r=8": 78.5,
13
            "r=16": 79.3,
14
            "r=32": 79.8,
15
            "r=64": 80.1,
16
            "r=128": 80.2,
17
        },
18
        "MNLI": {
19
            "r=1": 82.6,
20
            "r=4": 84.1,
21
            "r=8": 84.8,
22
            "r=16": 85.3,
23
            "r=64": 85.9,
24
        },
25
    }
26

27
    def analyze_scaling(self):
28
        """
29
        性能-秩关系分析
30

31
        观察：
32
        1. 性能随秩增加而提升（边际递减）
33
        2. r=8 是一个常用的"甜点"
34
        3. r=64 之后提升很小
35
        """
36
        return {
37
            "conclusion": "边际收益递减",
38
            "recommended_range": "r ∈ [4, 64]",
39
            "sweet_spot": "r=8 for most tasks",
40
            "rule_of_thumb": "r = α/2, where α is typical attention dimension ratio",
41
        }
42

43
    def adaptive_rank(self, model, task_complexity):
44
        """
45
        自适应秩选择
46
        """
47
        rank_map = {
48
            "simple_classification": 4,
49
            "ner": 8,
50
            "question_answering": 16,
51
            "summarization": 32,
52
            "code_generation": 64,
53
            "complex_reasoning": 128,
54
        }
55

56
        return rank_map.get(task_complexity, 8)

6.2 秩与任务复杂度的关系#

1
秩选择指南：
2

3
  简单任务（分类、NER）：
4
    建议 r = 4-8
5
    理由：任务简单，低秩足以捕捉更新
6

7
  中等任务（QA、翻译）：
8
    建议 r = 8-16
9
    理由：需要更多能力
10

11
  复杂任务（代码生成、复杂推理）：
12
    建议 r = 32-64
13
    理由：任务复杂，需要更高表达能力
14

15
  极端情况（多任务、微调整个模型）：
16
    建议 r = 64-128
17
    理由：最大程度保持性能

6.3 缩放因子 α#

1
class AlphaScaling:
2
    """
3
    缩放因子 α 的作用
4

5
    实际缩放 = α / r
6
    """
7

8
    def __init__(self, rank, alpha=16):
9
        self.scaling = alpha / rank
10

11
    def experiment_results(self):
12
        """
13
        实验结果（来自论文）
14
        """
15
        return {
16
            "alpha=r": "平衡设置",
17
            "alpha=2r": "更保守的更新",
18
            "alpha=r/2": "更激进的更新（不推荐）",
19
            "recommendation": "α = 2r 是一个好的起点",
20
        }

7. 实战指南#

7.1 使用 Hugging Face PEFT#

1
from peft import (
2
    get_peft_model,
3
    LoraConfig,
4
    TaskType,
5
    PeftType,
6
    prepare_model_for_kbit_training,
7
)
8

9
def create_lora_model(model, config=None):
10
    """
11
    创建 LoRA 模型
12
    """
13
    # 默认配置
14
    if config is None:
15
        config = {
16
            "r": 8,
17
            "lora_alpha": 16,
18
            "target_modules": ["q_proj", "v_proj"],
19
            "lora_dropout": 0.05,
20
            "bias": "none",
21
            "task_type": TaskType.CAUSAL_LM,
22
        }
23

24
    # 创建配置
25
    lora_config = LoraConfig(**config)
26

27
    # 应用 LoRA
28
    model = get_peft_model(model, lora_config)
29

30
    # 打印可训练参数
31
    model.print_trainable_parameters()
32

33
    return model
34

35
def train_with_peft(model, train_dataset, eval_dataset):
36
    """
37
    PEFT 训练
38
    """
39
    from transformers import Trainer, TrainingArguments
40

41
    training_args = TrainingArguments(
42
        output_dir="./output",
43
        num_train_epochs=3,
44
        per_device_train_batch_size=4,
45
        gradient_accumulation_steps=4,
46
        learning_rate=1e-4,
47
        warmup_ratio=0.03,
48
        lr_scheduler_type="cosine",
49
        logging_steps=10,
50
        save_steps=500,
51
        eval_steps=500,
52
        evaluation_strategy="steps",
53
        fp16=True,
54
        optim="paged_adamw_32bit",  # 页面优化器
55
    )
56

57
    trainer = Trainer(
58
        model=model,
59
        args=training_args,
60
        train_dataset=train_dataset,
61
        eval_dataset=eval_dataset,
62
        data_collator=data_collator,
63
    )
64

65
    trainer.train()
66

67
    return model
68

69
def merge_and_save(model, output_path):
70
    """
71
    合并权重并保存
72
    """
73
    # 合并 LoRA 权重到基础模型
74
    merged_model = model.merge_and_unload()
75

76
    # 保存
77
    merged_model.save_pretrained(output_path)

7.2 QLoRA 完整示例#

1
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
2
from peft import prepare_model_for_kbit_training, get_peft_model, LoraConfig
3

4
def load_qloRA_model(model_name):
5
    """
6
    加载 QLoRA 模型
7
    """
8
    # Step 1: 量化配置
9
    bnb_config = BitsAndBytesConfig(
10
        load_in_4bit=True,
11
        bnb_4bit_use_double_quant=True,
12
        bnb_4bit_quant_type="nf4",
13
        bnb_4bit_compute_dtype=torch.bfloat16,
14
    )
15

16
    # Step 2: 加载量化模型
17
    model = AutoModelForCausalLM.from_pretrained(
18
        model_name,
19
        quantization_config=bnb_config,
20
        device_map="auto",
21
        trust_remote_code=True,
22
    )
23

24
    # Step 3: 准备训练
25
    model = prepare_model_for_kbit_training(model)
26

27
    # Step 4: 应用 LoRA
28
    lora_config = LoraConfig(
29
        r=64,
30
        lora_alpha=16,
31
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
32
        lora_dropout=0.05,
33
        bias="none",
34
        task_type=TaskType.CAUSAL_LM,
35
    )
36

37
    model = get_peft_model(model, lora_config)
38

39
    model.print_trainable_parameters()
40
    # 输出: "trainable params: 83,886,080 || all params: 33,杂,杂,杂 || trainable%: 0.2414%"
41

42
    return model
43

44
# 使用示例
45
model = load_qloRA_model("meta-llama/Llama-2-70b-hf")
46
trainer = Trainer(model=model, ...)
47
trainer.train()

7.3 多 LoRA 组合#

1
class MultiLoRA:
2
    """
3
    多 LoRA 组合
4
    """
5

6
    def __init__(self, base_model):
7
        self.base_model = base_model
8
        self.lora_weights = {}
9

10
    def add_task_lora(self, task_name, lora_path):
11
        """
12
        添加任务的 LoRA
13
        """
14
        from peft import PeftModel
15

16
        # 加载 LoRA
17
        lora_model = PeftModel.from_pretrained(
18
            self.base_model,
19
            lora_path,
20
            adapter_name=task_name,
21
        )
22

23
        self.lora_weights[task_name] = lora_model
24

25
    def switch_lora(self, task_name):
26
        """
27
        切换到指定任务的 LoRA
28
        """
29
        for name, model in self.lora_weights.items():
30
            if name == task_name:
31
                model.set_adapter(task_name)
32
            else:
33
                model.disable_adapter()
34

35
    def weighted_merge(self, weights):
36
        """
37
        加权合并多个 LoRA
38

39
        用于多任务学习
40
        """
41
        # 获取所有 LoRA 权重
42
        lora_weights = []
43
        for name in weights.keys():
44
            lora_weights.append(self.lora_weights[name])
45

46
        # 加权平均
47
        # 实际实现需要更复杂的逻辑
48
        pass

8. 高级主题#

8.1 权重合并与卸载#

1
class WeightMerging:
2
    """
3
    权重合并与卸载
4
    """
5

6
    def merge_weights(self, model):
7
        """
8
        合并 LoRA 权重
9

10
        合并后：
11
        - 推理速度更快（无需额外的矩阵乘法）
12
        - 模型大小不变
13
        """
14
        # 合并所有 LoRA 适配器
15
        merged_model = model.merge_and_unload()
16

17
        return merged_model
18

19
    def merge_and_quantize(self, model):
20
        """
21
        合并后量化
22

23
        将合并的模型量化以节省空间
24
        """
25
        # 合并
26
        merged = model.merge_and_unload()
27

28
        # 量化
29
        quantized = self.quantize(merged, bits=4)
30

31
        return quantized
32

33
    def unload_and_reload(self, model):
34
        """
35
        卸载 LoRA，保留原始模型
36
        """
37
        # 卸载所有 LoRA 适配器
38
        model.unload()
39

40
        return model

8.2 持续预训练与微调的结合#

1
class ContinualPretraining:
2
    """
3
    持续预训练 + 微调
4
    """
5

6
    def combined_training(self, base_model, pretrain_data, finetune_data):
7
        """
8
        组合训练策略
9

10
        阶段 1: 持续预训练（领域适应）
11
        阶段 2: 指令微调（任务适应）
12
        """
13
        # 阶段 1: 预训练
14
        pretrain_model = self.pretrain(base_model, pretrain_data)
15

16
        # 阶段 2: 微调
17
        # 复用同一个 LoRA 或创建新的
18
        finetune_model = self.finetune(pretrain_model, finetune_data)
19

20
        return finetune_model
21

22
    def pretrain(self, model, data):
23
        """
24
        持续预训练
25
        """
26
        # LoRA 配置（可以是不同的模块）
27
        config = LoraConfig(
28
            r=16,
29
            target_modules=["q_proj", "v_proj", "k_proj", "mlp"],
30
        )
31

32
        model = get_peft_model(model, config)
33

34
        # 训练
35
        trainer = Trainer(model=model, data=data, ...)
36
        trainer.train()
37

38
        return model
39

40
    def finetune(self, model, data):
41
        """
42
        指令微调
43
        """
44
        # 冻结预训练 LoRA
45
        for param in model.parameters():
46
            if "lora_" not in param.name:
47
                param.requires_grad = False
48

49
        # 添加新的 LoRA 或继续训练现有 LoRA
50
        # ...

8.3 分布式训练#

1
class DistributedLoRA:
2
    """
3
    分布式 LoRA 训练
4
    """
5

6
    def train_distributed(self, model, data):
7
        """
8
        分布式训练
9
        """
10
        # FSDP (Fully Sharded Data Parallel)
11
        from torch.distributed.fsdp import (
12
            FullyShardedDataParallel as FSDP,
13
            MixedPrecision,
14
            ShardingStrategy,
15
        )
16

17
        # 包装模型
18
        model = FSDP(
19
            model,
20
            sharding_strategy=ShardingStrategy.FULL_SHARD,
21
            mixed_precision=MixedPrecision(
22
                param_dtype=torch.bfloat16,
23
                reduce_dtype=torch.float32,
24
            ),
25
        )
26

27
        # 训练
28
        trainer = Trainer(model=model, ...)
29
        trainer.train()
30

31
    def ZeRO_LoRA(self, model, data):
32
        """
33
        ZeRO 优化
34
        """
35
        # DeepSpeed ZeRO
36
        from transformers import DeepSpeedConfig
37

38
        ds_config = {
39
            "zero_optimization": {
40
                "stage": 3,
41
                "offload_optimizer": {
42
                    "device": "cpu",
43
                },
44
            },
45
            "bf16": {"enabled": True},
46
        }
47

48
        # 训练
49
        trainer = Trainer(
50
            model=model,
51
            args=training_args,
52
            ds_config=ds_config,
53
            ...
54
        )

9. 核心公式汇总#

9.1 LoRA 权重更新#

\mathbf{W}_{\text{new}} = \mathbf{W}_0 + \frac{\alpha}{r} \mathbf{B}\mathbf{A}

其中 $\mathbf{A} \in \mathbb{R}^{r \times k}$ ， $\mathbf{B} \in \mathbb{R}^{d \times r}$ 。

9.2 可训练参数比例#

\frac{\text{trainable}}{\text{total}} = \frac{r(d + k)}{dk} \approx \frac{r}{\min(d, k)}

9.3 LoRA 梯度#

\frac{\partial \mathcal{L}}{\partial \mathbf{A}} = \frac{\alpha}{r} \mathbf{B}^\top \frac{\partial \mathcal{L}}{\partial \mathbf{W}_{\text{new}}}

\frac{\partial \mathcal{L}}{\partial \mathbf{B}} = \frac{\alpha}{r} \frac{\partial \mathcal{L}}{\partial \mathbf{W}_{\text{new}}} \mathbf{A}^\top

9.4 NF4 量化#

\mathbf{W}_Q = \text{quantize}(\mathbf{W}, Q) = \left\lfloor \frac{\mathbf{W} - c}{s} \right\rceil

其中 $c$ 是偏移， $s$ 是缩放因子。

10. 总结#

10.1 方法选择指南#

1
┌─────────────────────────────────────────────────────────────┐
2
│                   PEFT 方法选择指南                            │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  资源情况                                                     │
6
│    │                                                         │
7
│    ├── 消费级 GPU (RTX 3090/4090, 24GB)                     │
8
│    │     └── QLoRA (4-bit) + r=32-64                       │
9
│    │                                                         │
10
│    ├── 单卡 A100 (40-80GB)                                  │
11
│    │     ├── 小模型 (<13B): LoRA + r=8-16                   │
12
│    │     └── 大模型 (>=13B): QLoRA + r=64                   │
13
│    │                                                         │
14
│    └── 多卡 A100                                            │
15
│          └── 全参数微调 或 LoRA + r=64                       │
16
│                                                              │
17
│  任务复杂度                                                   │
18
│    │                                                         │
19
│    ├── 简单分类                                             │
20
│    │     └── LoRA r=4-8                                     │
21
│    │                                                         │
22
│    ├── NER/QA                                              │
23
│    │     └── LoRA r=8-16                                    │
24
│    │                                                         │
25
│    ├── 代码生成                                             │
26
│    │     └── LoRA r=32-64                                   │
27
│    │                                                         │
28
│    └── 多任务/复杂推理                                      │
29
│          └── LoRA r=64-128 或 全参数微调                    │
30
│                                                              │
31
└─────────────────────────────────────────────────────────────┘

10.2 最佳实践#

1
┌─────────────────────────────────────────────────────────────┐
2
│                   LoRA 最佳实践                               │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  1. 模块选择                                                 │
6
│     → 默认: q_proj, v_proj                                  │
7
│     → 更好: + k_proj, o_proj                                │
8
│     → 最好: + mlp.gate_proj, mlp.up_proj, mlp.down_proj    │
9
│                                                              │
10
│  2. 秩选择                                                  │
11
│     → 常用: r=8 (简单任务), r=64 (复杂任务)                  │
12
│     → α 通常设为 2r                                          │
13
│                                                              │
14
│  3. Dropout                                                 │
15
│     → 训练时: lora_dropout=0.05                              │
16
│     → 推理时: 不使用 dropout                                 │
17
│                                                              │
18
│  4. 优化器                                                  │
19
│     → AdamW (paged 版本防止峰值)                             │
20
│     → 学习率: 1e-4 到 3e-4                                  │
21
│     → Warmup: 3% 到 6%                                      │
22
│                                                              │
23
│  5. 权重合并                                                │
24
│     → 推理前合并权重以提高速度                               │
25
│     → 如果需要切换 LoRA，保持分开                            │
26
│                                                              │
27
│  6. 持久化                                                  │
28
│     → 保存: 只保存 LoRA 权重 (~10-100MB)                    │
29
│     → 加载: 需要基础模型 + LoRA 权重                         │
30
│                                                              │
31
└─────────────────────────────────────────────────────────────┘

10.3 性能对比#

1
┌─────────────────────────────────────────────────────────────┐
2
│                   65B 模型性能对比                           │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  方法                    可训练参数    MMLU     HumanEval    │
6
│  ─────────────────────────────────────────────────────────  │
7
│  全参数微调              65B          68.0      62.0         │
8
│  LoRA (r=64, all)       666M         67.5      61.5         │
9
│  LoRA (r=8, qkv)        83M          66.8      60.2         │
10
│  QLoRA (r=64, NF4)      666M         67.6      61.8         │
11
│  Adapter (r=64)         666M         67.2      61.0         │
12
│  Prefix Tuning          19M          63.5      58.0         │
13
│  ─────────────────────────────────────────────────────────  │
14
│                                                              │
15
│  结论: LoRA/QLoRA 接近全参数微调性能                          │
16
│                                                              │
17
└─────────────────────────────────────────────────────────────┘

参考资料#

Hu, E. J., et al. (2021). “LoRA: Low-Rank Adaptation of Large Language Models.” ICLR.
Dettmers, T., et al. (2023). “QLoRA: Efficient Finetuning of Quantized LLMs.” NeurIPS.
Liu, S., et al. (2024). “DoRA: Weight-Decomposed Low-Rank Adaptation.” arXiv.
Meng, F., et al. (2024). “PiSSA: Principal Singular Values Adaptation.” arXiv.
Hayou, S., et al. (2024). “LoRA+: Efficient Low Rank Adaptation of LLMs.” arXiv.
Houlsby, N., et al. (2019). “Parameter-Efficient Transfer Learning for NLP.” ICML.
Li, X. L., & Liang, P. (2021). “Prefix-Tuning: Optimizing Continuous Prompts.” ACL.
Lester, B., et al. (2021). “The Power of Scale for Parameter-Efficient Prompt Tuning.” EMNLP.
Mahabadi, R. K., et al. (2021). “Compacter: Efficient Low-Rank Hypercomplex Adapter Layers.” NeurIPS.
Rücklé, A., et al. (2020). “AdapterDrop: On the Efficiency of Adapters in Transformers.” EMNLP.
Aghajanyan, A., et al. (2020). “Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning.” ACL.
Lialin, V., et al. (2023). “Hierarchical LoRA for Multi-task Fine-tuning.” arXiv.