3.1 Prefix Tuning

Prefix Tuning的核心思想是在每一层的输入序列前添加可训练的前缀向量（Prefix Vectors）。这些前缀向量本质上是连续的虚拟令牌，在训练过程中被优化以引导模型生成合适的输出。

Prefix Tuning的形式为 [PREFIX; x; y]，其中PREFIX是可训练的前缀参数。训练时，原始模型参数完全冻结，仅更新前缀向量。

3.2 Prompt Tuning

Prompt Tuning是Prefix Tuning的轻量版——仅在输入层添加可训练的提示向量（soft prompts），而非每一层。因此，Prompt Tuning的参数规模更小——以7B模型为例，新增参数占比通常小于0.1%。

1
# Prompt Tuning的简化示意
2
class PromptTuning(nn.Module):
3
    def __init__(self, num_virtual_tokens: int, embed_dim: int):
4
        super().__init__()
5
        # 可训练的软提示嵌入
6
        self.prompt_embeddings = nn.Parameter(
7
            torch.randn(num_virtual_tokens, embed_dim)
8
        )
9

10
    def forward(self, input_embeds):
11
        # 将软提示拼接到输入嵌入前面
12
        return torch.cat([self.prompt_embeddings, input_embeds], dim=0)

Prefix Tuning和Prompt Tuning的共同优势是参数效率极高——仅需更新0.1%以下的参数即可获得不错的性能。但缺点也同样明显：性能上限有限，在复杂任务上往往不及LoRA等方法。

4.1 关键假设

LoRA的核心洞察基于一个关键假设：模型在适应下游任务时，权重更新矩阵 $\Delta W$ 本质上是低秩的。也就是说，模型适应新任务时，权重的变化并不需要满秩矩阵来描述，核心变化可以通过低秩矩阵来近似。

这个发现意味着如果微调时的权重更新本质上是低秩的，那可以用两个小矩阵的乘积来近似这个更新，而不是去更新整个庞大的权重矩阵。

在原论文中，LoRA主要应用于Transformer的注意力权重矩阵（特别是 $W_q$ 和 $W_v$）。实验表明，在查询（Query）和值（Value）投影上应用LoRA效果最好，而在键（Key）投影上应用的效果相对有限。

4.2 数学原理

对于预训练模型中的一个线性层，其原始计算为：

$y = W_0 x$

其中 $W_0 \in \mathbb{R}^{d \times k}$ 是预训练的权重矩阵。

全参数微调会直接更新 $W_0$，而LoRA的做法是冻结 $W_0$，转而学习一个更新矩阵 $\Delta W \in \mathbb{R}^{d \times k}$，使得微调后的输出为：

$y = W_0 x + \Delta W x$

LoRA的核心创新在于将 $\Delta W$ 分解为两个低秩矩阵的乘积：

$\Delta W = B \cdot A$

其中 $B \in \mathbb{R}^{d \times r}$，$A \in \mathbb{R}^{r \times k}$，且秩 $r \ll \min(d, k)$。

这样一来，原本需要学习 $d \times k$ 个参数，现在只需要学习 $r \times (d + k)$ 个参数。参数量从 $O(dk)$ 降至 $O(r(d+k))$。

前向传播的计算变为：

$y = W_0 x + \Delta W x = W_0 x + B A x$

在训练过程中，$W_0$ 被冻结（不计算梯度），仅更新 $A$ 和 $B$。

引入缩放系数后，完整的前向计算为：

$y = W_0 x + \frac{\alpha}{r} \cdot B A x$

其中 $\alpha$ 是缩放因子，用于控制LoRA更新的强度。实际更新幅度为 $\alpha/r$。在实际调参中，$\alpha$ 通常设置为 $r$ 的2倍。这个缩放机制允许我们在改变 $r$ 时保持更新幅度的相对稳定。

4.3 梯度传播

反向传播时，梯度仅流向低秩矩阵：

$\frac{\partial \mathcal{L}}{\partial A} = \left(\frac{\partial \mathcal{L}}{\partial \Delta W}\right)^T \cdot B^T , \quad \frac{\partial \mathcal{L}}{\partial B} = \frac{\partial \mathcal{L}}{\partial \Delta W} \cdot A^T$

这种设计使得基础模型参数的梯度恒为零，反向传播的计算复杂度从 $O(d^2)$ 降至 $O(dr)$。

4.4 初始化策略

LoRA采用精心设计的初始化策略以保证训练稳定性：

• 矩阵 $A$ 使用随机高斯分布初始化
• 矩阵 $B$ 使用全零初始化
• 这样，在训练开始时 $\Delta W = BA = 0$，模型的行为与原始预训练模型完全一致，避免了训练初期的剧烈扰动。

4.5 秩的选择策略

秩 $r$ 是LoRA最核心的超参数，需要在表达能力与计算效率之间权衡：

实验表明，在LLaMA-7B上微调代码生成任务时，$r=16$ 即可达到全参数微调 92% 的效果，而参数量减少了 98%。

5.1 Python代码实现LoRA

1
import torch
2
import torch.nn as nn
3

4
class LoRALinear(nn.Module):
5
    def __init__(self, in_features, out_features, rank=8, alpha=16):
6
        super().__init__()
7
        self.rank = rank
8
        self.scaling = alpha / rank  # 缩放系数
9

10
        # 冻结原始权重（不可训练）
11
        self.weight = nn.Parameter(
12
            torch.randn(out_features, in_features),
13
            requires_grad=False
14
        )
15
        self.bias = nn.Parameter(
16
            torch.zeros(out_features),
17
            requires_grad=False
18
        )
19

20
        # 可训练的低秩矩阵
21
        # A矩阵：随机初始化
22
        self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
23
        # B矩阵：零初始化，确保训练初期 ΔW = 0
24
        self.lora_B = nn.Parameter(torch.zeros(out_features, rank))
25

26
    def forward(self, x):
27
        # 原始输出（冻结权重）
28
        base_output = x @ self.weight.T + self.bias
29
        # LoRA增量
30
        # 注意：实际计算顺序是 x @ A^T @ B^T
31
        lora_output = (x @ self.lora_A.T) @ self.lora_B.T * self.scaling
32
        return base_output + lora_output

5.2 使用HuggingFace PEFT库

在实际工程中，我们通常使用HuggingFace的PEFT库，它封装了LoRA及其变体的完整实现：

1
from transformers import AutoModelForCausalLM
2
from peft import LoraConfig, get_peft_model, TaskType
3

4
# 加载预训练模型
5
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-3B-Instruct")
6

7
# 配置LoRA
8
peft_config = LoraConfig(
9
    r=16,                    # 秩
10
    lora_alpha=32,           # 缩放因子
11
    task_type=TaskType.CAUSAL_LM,
12
    target_modules=["q_proj", "v_proj"]  # 指定要应用LoRA的模块
13
)
14

15
# 包装模型
16
model = get_peft_model(model, peft_config)
17
model.print_trainable_parameters()
18
# 输出：trainable params: 3,686,400 || all params: 3,089,625,088 || trainable%: 0.1193

5.3 推理时的权重合并

在部署阶段，可以将LoRA权重合并回原始模型，消除额外的计算开销：

1
# 加载LoRA适配器
2
from peft import PeftModel
3
model = PeftModel.from_pretrained(base_model, "path/to/lora-adapter")
4
# 合并权重
5
model = model.merge_and_unload()  # 现在 ΔW 已合并到 W0 中

6.1 QLoRA：当量化遇上LoRA

QLoRA（Quantized Low-Rank Adaptation） 是LoRA的量化增强版，其核心思想用公式概括为QLoRA = 4-bit量化基座 + 全精度LoRA适配器

QLoRA将预训练模型的权重从32位或16位浮点数量化为4位精度，同时保持LoRA适配器为全精度。这种“双重优化”策略带来了显著的显存节省——QLoRA可以在单张48GB显存的GPU上微调65B参数的模型。

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

4
# 4-bit量化配置
5
bnb_config = BitsAndBytesConfig(
6
    load_in_4bit=True,
7
    bnb_4bit_quant_type="nf4",           # NormalFloat 4-bit
8
    bnb_4bit_compute_dtype=torch.bfloat16,
9
)
10

11
# 加载量化模型
12
model = AutoModelForCausalLM.from_pretrained(
13
    "meta-llama/Llama-2-70b",
14
    quantization_config=bnb_config,
15
    device_map="auto",
16
)
17

18
# 应用LoRA（适配器保持全精度）
19
lora_config = LoraConfig(r=8, lora_alpha=16, target_modules=["q_proj", "v_proj"])
20
peft_model = get_peft_model(model, lora_config)

QLoRA的工程价值在于极大地降低了微调大模型的硬件门槛，使得在消费级GPU上进行百亿参数模型的微调成为可能。

6.2 AdaLoRA：自适应秩分配

标准LoRA在所有层和所有模块上均匀分配参数预算。然而，不同层、不同模块对微调的重要性是不同的。AdaLoRA（Adaptive LoRA） 通过奇异值分解（SVD） 参数化增量更新，并根据各权重矩阵的重要性动态分配秩预算。

AdaLoRA采用三阶段训练调度，在训练过程中动态调整各模块的秩，从而在相同参数预算下获得更好的性能。

6.3 IA3：通过抑制与放大内部激活进行微调

IA3（Infused Adapter by Inhibiting and Amplifying Inner Activations） 是一种极简的PEFT方法，通过在注意力机制的Key和Value以及前馈模块中注入可学习的缩放向量来调整激活值。

IA3的新增参数极少，但性能在某些场景下会显著下降。它代表了PEFT在极端参数效率方向上的探索。