20. PEFT 变体全家桶 —— Prompt / Prefix / P-Tuning / Adapter / LoRA 手搓对比¶
PEFT(Parameter-Efficient Fine-Tuning):冻结预训练大模型,只训练一小撮参数。 家族树(按"改哪里"分三类):
| 家族 | 改输入 | 改中间表示 | 改权重 |
|---|---|---|---|
| Prompt Tuning | 输入前加可学习 prompt 向量 | — | — |
| Prefix Tuning | — | 每层 K/V 前加可学习前缀 | — |
| P-Tuning v2 | — | 每层隐藏态加前缀(Prompt 的深层版) | — |
| Adapter | — | 层间插入小瓶颈模块(残差) | — |
| LoRA 家族 | — | — | 权重加低秩旁路 ΔW=BA(第 12 讲) |
本讲在同一个玩具任务上手搓全部 5 种(+ 全量对照),比可训练参数量与收敛效果,再讲 QLoRA/DoRA/AdaLoRA。
核心概念¶
(a) 🗂️ PEFT 全家桶:冻结大模型只训小参数¶
按注入点把 Prompt / Prefix / P-Tuning / Adapter / LoRA 五大家族放在同一个玩具任务上手搓对比,验证参数少 10~100 倍也能同样收敛,再讲 QLoRA/DoRA/AdaLoRA 进阶。
flowchart TB
A["💡 PEFT 思想<br/>冻结大模型只训小参数"] --> B["📝 Prompt Tuning<br/>输入前可学习向量"]
A --> C["🔑 Prefix/P-Tuning<br/>中间层注入前缀"]
A --> D["🧩 Adapter<br/>层间瓶颈残差"]
A --> E["⭐ LoRA<br/>权重低秩旁路 ΔW=BA"]
B --> F["📊 参数量对比<br/>O(p·d) vs O(d²)"]
C --> F
D --> F
E --> F
F --> G["✅ 收敛对比<br/>5 法同任务同数据"]
G --> H["🚀 LoRA 家族进阶<br/>QLoRA/DoRA/AdaLoRA"]
- 💡 PEFT 思想:冻结预训练大模型,只训练一小撮参数,一个任务一个小子集。
- 📝 Prompt Tuning:在输入前拼接可学习的 prompt 向量(Lester 2021)。
- 🔑 Prefix/P-Tuning:在每层 attention 的 K/V(或隐藏态)前加可学习前缀。
- 🧩 Adapter:层间插入小瓶颈模块 h' = h + W_up·σ(W_down·h)(Houlsby 2020)。
- ⭐ LoRA:权重加低秩旁路 ΔW=BA,只训 A/B(Hu 2021,第 12 讲核心)。
- 📊 参数量对比:可训练参数 O(p·d) 对比全量 O(d²),以 MiniMind 一个 FFN 为例。
- ✅ 收敛对比:同一玩具任务上 5 种方法参数少 10~100 倍仍与全量同样收敛。
- 🚀 LoRA 家族进阶:QLoRA 4-bit 基座、DoRA 幅度/方向分解、AdaLoRA 按重要性分配秩。
🕸️ 网络配图(Wikimedia Commons)
📷 来源:Wikimedia Commons · <a href="//commons.wikimedia.org/w/index.php?title=User:Softscore&ac…
1. 公式¶
Prompt Tuning(Lester 2021):可学习向量 $P\in\mathbb{R}^{p\times d}$ 拼在输入前 (toy 中退化为加性提示 $x' = x + p$):
$$x' = [P;\, x]\quad\text{或}\quad x' = x + p,\qquad \theta \leftarrow \{\text{只训 } P \text{ 或 } p\}$$
Prefix Tuning(Li & Liang 2021):每层 attention 的 key/value 拼接可学习前缀矩阵 $P_K, P_V\in\mathbb{R}^{p\times d}$:$K'=[P_K;\,K],\ V'=[P_V;\,V]$(toy 中在隐藏态拼接 $[h;\,P]$)。
Adapter(Houlsby 2020):子层输出过瓶颈再残差:$h' = h + f(x)\approx h+W_{up}\,\sigma(W_{down}\,h)$。
LoRA(Hu 2021):$W' = W_0 + BA$,只训 $A,B$。
共同点:可训练参数 $O(p\cdot d)$,远小于全量 $O(d^2)$。
✍️ §1.1 手算 Prompt Tuning:51K 参数怎么微调 7B 模型,前向/反传走一遍¶
Prompt Tuning 只学 $L\times d_{model}$ 个可学习向量——先算账本,再算一步前向+反传,理解"冻结大模型只训小参数"。
第 1 步:参数量账本($d_{model}=512$,$L=100$ 个 prompt token)
$$\text{参数量}=L\times d_{model}=100\times512=51{,}200=51.2\text{K}$$
- fp16 显存:$51200\times2\text{B}=102.4\text{KB}\approx0.10\,\text{MiB}$
- 对比 Llama-7B($7\times10^9$ 参数):$\frac{51200}{7\times10^9}=7.3\times10^{-6}=0.00073\%$
第 2 步:一步前向(简化 $d=2$、$L=2$、一个线性层)
可学习 prompt $p_1=(0.5,-0.5)$、$p_2=(0.2,0.8)$,输入 $x=(1,0)$,拼接后 $z=(0.5,-0.5,0.2,0.8,1,0)$,权重 $W=(0.4,0.3,0.2,0.1,0.5,0.4)$:
$$\text{logit}=0.5\times0.4+(-0.5)\times0.3+0.2\times0.2+0.8\times0.1+1\times0.5+0\times0.4=0.67$$
$$L=\tfrac12(\text{logit}-1)^2=\tfrac12(-0.33)^2=0.0544$$
第 3 步:一步反传(只更新 prompt,W 冻结;$\text{d}L/\text{d}\text{logit}=-0.33$)
$$\nabla_{p_1}=(-0.33)\times(0.4,\ 0.3)=-0.132\ \text{与}\ -0.099$$
$$p_1'=(0.5,-0.5)-0.1\times(-0.132,-0.099)=(0.513,-0.490)$$
手算收获:
- PEFT 的本质账本:全量微调 7B 要存 14 GB(fp16)梯度/优化器状态,prompt tuning 只需 0.1 MiB——差 5 个数量级
- 只更新注入的小参数:W(大模型权重)全程冻结,梯度只回传到 prompt 向量(第 3 步里 W 只是"读"的常量)
- 50K 参数在一张消费级 GPU 就能训完,且每任务只需存一个 100×512 的小向量——多任务 = 多份小向量,不复制模型
- 长度 $L$ 是超参:太短表达力不够,太长超过上下文预算——这就是 PEFT 家族(Prompt/Prefix/P-Tuning/LoRA)在"注入点×参数量"上互相区分的原因
下面 numpy 复算。
# ---- §1.1 验证:numpy 复算 Prompt Tuning ----
import numpy as np
# 账本
d_model, L = 512, 100
n_prompt = d_model * L
print(f'Prompt 参数 = {n_prompt:,}(51.2K),fp16 = {n_prompt*2/2**20:.2f} MiB')
print(f'占 7B 比例 = {n_prompt/7e9*100:.5f}%')
assert n_prompt == 51200
# 前向
z = np.array([0.5, -0.5, 0.2, 0.8, 1.0, 0.0])
W = np.array([0.4, 0.3, 0.2, 0.1, 0.5, 0.4])
logit = W @ z
loss = 0.5 * (logit - 1.0) ** 2
print(f'logit = {logit:.4f}, L = {loss:.4f}')
assert abs(logit - 0.67) < 1e-9 and abs(loss - 0.0544) < 1e-3
# 反传(只更新 prompt 部分,W 冻结)
dl = logit - 1.0
g_prompt = dl * W[:4]
p = np.array([0.5, -0.5, 0.2, 0.8])
p_new = p - 0.1 * g_prompt
print(f'prompt 梯度 = {np.round(g_prompt, 4)}')
print(f'p\' = {np.round(p_new, 4)}(手算 (0.513, -0.490, 0.207, 0.803))')
assert abs(g_prompt[0] + 0.132) < 1e-3 and abs(p_new[0] - 0.5132) < 1e-3
print('\n✓ 与手算一致:只训 51K prompt 参数,7B 权重全程冻结')
# ---- matplotlib 中文字体(防图内中文乱码)----
import matplotlib
matplotlib.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'Songti SC', 'Arial Unicode MS', 'DejaVu Sans']
matplotlib.rcParams['axes.unicode_minus'] = False
# -------------------------------------------
# 参数量对比(MiniMind:d=768;每层 FFN 的两个矩阵)
def p_full(d_out): # 全量:768×768 权重 + 偏置
return d_out * d_out + d_out
def p_lora(d, r):
return 2 * r * d # 每个矩阵的 A[d,r]+B[r,d]
def p_adapter(d, b):
return 2 * d * b + b + d # down[d,b]+up[b,d]+2 偏置
def p_prompt(d, p_len):
return p_len * d
def p_prefix(d, p_len):
return 2 * p_len * d # K、V 各一段前缀
d, r, b, p_len = 768, 8, 128, 20
rows = [('全量微调', p_full(d)), ('LoRA(r=8)', 2 * p_lora(d, r)), ('Adapter(b=128)', p_adapter(d, b)),
('Prompt(20 tok)', p_prompt(d, p_len)), ('Prefix(20 tok)', p_prefix(d, p_len))]
print('MiniMind 一个 FFN 权重的可训练参数:')
for name, n in rows:
print(f' {name:16s} {n:>10,} (占全量的 {n / p_full(d):.3%})')
full_n = p_full(d)
assert rows[1][1] < full_n / 10 and all(n < full_n / 2 for _, n in rows[1:])
print('LoRA < 全量 10%、全部 PEFT < 全量 50% -> PASS(Adapter 瓶颈比 LoRA 参数多,属正常)')
MiniMind 一个 FFN 权重的可训练参数: 全量微调 590,592 (占全量的 100.000%) LoRA(r=8) 24,576 (占全量的 4.161%) Adapter(b=128) 197,504 (占全量的 33.442%) Prompt(20 tok) 15,360 (占全量的 2.601%) Prefix(20 tok) 30,720 (占全量的 5.202%) LoRA < 全量 10%、全部 PEFT < 全量 50% -> PASS(Adapter 瓶颈比 LoRA 参数多,属正常)
参数量对比图¶
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False
names = [r[0] for r in rows]; nums = [r[1] for r in rows]
fig, ax = plt.subplots(figsize=(8.5, 4.4))
ax.bar(names, nums, color=['#C44E52', '#4C72B0', '#55A868', '#DD8452', '#8172B3'])
ax.set_yscale('log')
ax.set_ylabel('可训练参数量 (log)')
ax.set_title('同一个小权重:PEFT 方法 vs 全量(对数刻度)', fontsize=12)
for i, v in enumerate(nums):
ax.text(i, v * 1.4, f'{v:,}', ha='center', fontsize=9)
plt.tight_layout(); plt.show()
import torch
import torch.nn as nn
import torch.nn.functional as F
torch.manual_seed(0)
# ---- 玩具任务:8 维输入,标签 = 第一维符号(线性可分,各方法都能学) ----
n = 96
X = torch.randn(n, 8, dtype=torch.float64)
Y = (X[:, 0] > 0).double().unsqueeze(1)
def make_full():
return nn.Sequential(nn.Linear(8, 16, dtype=torch.float64), nn.Tanh(),
nn.Linear(16, 1, dtype=torch.float64))
# ---- 阶段0:全量"预训练"基座 200 步(模拟已有知识的预训练模型;PEFT 的前提) ----
base = make_full()
opt0 = torch.optim.AdamW(base.parameters(), lr=0.05)
for _ in range(200):
opt0.zero_grad()
loss = F.binary_cross_entropy_with_logits(base(X), Y)
loss.backward(); opt0.step()
acc0 = ((base(X).sigmoid() > 0.5).double() == Y).float().mean().item()
print(f'阶段0 预训练 200 步:基座 acc = {acc0:.2f}(PEFT 假设:基座已"会",只加小适配)')
def freeze(m):
for p in m.parameters(): p.requires_grad_(False)
# ---- 5 种方法:返回 (forward 函数, 可训练参数列表, 名称)。基座全部冻结。 ----
def w1b1(bs): return bs[0].weight.detach(), bs[0].bias.detach()
def w2b2(bs): return bs[2].weight.detach(), bs[2].bias.detach()
def method_full(bs):
m = make_full(); m.load_state_dict(bs.state_dict()) # 从预训练克隆,继续全量训练
return lambda x: m(x), list(m.parameters()), '全量'
def method_lora(bs):
A1 = nn.Parameter(torch.randn(8, 4, dtype=torch.float64) * 0.02)
B1 = nn.Parameter(torch.zeros(4, 16, dtype=torch.float64))
A2 = nn.Parameter(torch.randn(16, 4, dtype=torch.float64) * 0.02)
B2 = nn.Parameter(torch.zeros(4, 1, dtype=torch.float64))
W1, b1 = w1b1(bs); W2, b2 = w2b2(bs)
def fwd(x):
h = torch.tanh(x @ W1.T + b1 + (x @ A1) @ B1) # ΔW1 = B1A1 旁路
return h @ W2.T + b2 + (h @ A2) @ B2 # ΔW2 = B2A2 旁路
return fwd, [A1, B1, A2, B2], 'LoRA(r=4)'
def method_adapter(bs):
down = nn.Parameter(torch.randn(16, 4, dtype=torch.float64) * 0.05)
up = nn.Parameter(torch.zeros(4, 16, dtype=torch.float64))
W1, b1 = w1b1(bs); W2, b2 = w2b2(bs)
def fwd(x):
h = torch.tanh(x @ W1.T + b1)
a = torch.relu(h @ down) @ up # 瓶颈模块(只训)
return torch.tanh(h + a) @ W2.T + b2 # 残差
return fwd, [down, up], 'Adapter(b=4)'
def method_prefix(bs):
P = nn.Parameter(torch.randn(1, 16, dtype=torch.float64) * 0.05) # 隐藏态前缀(每层 K/V 前缀的 toy 化)
W1, b1 = w1b1(bs); W2, b2 = w2b2(bs)
def fwd(x):
h = torch.tanh(x @ W1.T + b1)
return (h + P) @ W2.T + b2 # 加性条件注入(只学 P)
return fwd, [P], 'Prefix(1 tok)'
def method_prompt(bs):
pvec = nn.Parameter(torch.zeros(8, dtype=torch.float64)) # 输入侧提示向量(只学它)
def fwd(x):
return bs(x + pvec) # 基座冻结,梯度只到 pvec
return fwd, [pvec], 'Prompt(1 tok)'
# ---- 阶段1:冻结基座,只训各方法的 PEFT 参数 300 步 ----
methods = [method_full(base), method_lora(base), method_adapter(base),
method_prefix(base), method_prompt(base)]
hist = {}
print('阶段1 冻结基座,只训 PEFT 参数 300 步:')
for fwd, params, name in methods:
opt = torch.optim.AdamW(params, lr=0.05)
ls = []
for _ in range(300):
opt.zero_grad()
loss = F.binary_cross_entropy_with_logits(fwd(X), Y)
loss.backward(); opt.step()
ls.append(loss.item())
acc = ((fwd(X).sigmoid() > 0.5).double() == Y).float().mean().item()
hist[name] = ls
print(f' {name:14s} 参数={sum(p.numel() for p in params):4d} 最终 loss={ls[-1]:.4f} acc={acc:.2f}')
assert all(hist[n][-1] < 0.25 for n in hist), '有方法未收敛'
assert all(((fwd(X).sigmoid() > 0.5).double() == Y).float().mean().item() >= 0.95
for fwd, _, _ in methods)
print('五种方法全部收敛且 acc>=0.95 -> PASS(PEFT 用少量参数在冻结基座上保持/提升性能)')
阶段0 预训练 200 步:基座 acc = 1.00(PEFT 假设:基座已"会",只加小适配) 阶段1 冻结基座,只训 PEFT 参数 300 步:
全量 参数= 161 最终 loss=0.0000 acc=1.00
LoRA(r=4) 参数= 164 最终 loss=0.0000 acc=1.00
Adapter(b=4) 参数= 128 最终 loss=0.0015 acc=1.00
Prefix(1 tok) 参数= 16 最终 loss=0.0012 acc=1.00
Prompt(1 tok) 参数= 8 最终 loss=0.0012 acc=1.00 五种方法全部收敛且 acc>=0.95 -> PASS(PEFT 用少量参数在冻结基座上保持/提升性能)
收敛曲线对比¶
%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False
fig, ax = plt.subplots(figsize=(9, 4.6))
colors = {'全量': '#C44E52', 'LoRA(r=4)': '#4C72B0', 'Adapter(b=4)': '#55A868',
'Prefix(1 tok)': '#DD8452', 'Prompt(1 tok)': '#8172B3'}
for n, ls in hist.items():
ax.plot(ls, label=n, color=colors[n])
ax.set_xlabel('步数'); ax.set_ylabel('BCE loss')
ax.set_title('PEFT 五法 vs 全量:同样收敛(可训练参数少 10-100 倍)', fontsize=12)
ax.legend(fontsize=9)
plt.tight_layout(); plt.show()
2. LoRA 家族进阶(概念)¶
| 方法 | 关键改动 | 优势 |
|---|---|---|
| QLoRA | 基座 4-bit NF4 量化 + LoRA + 双重量化 + paged optimizer | 65B 微调只需 48GB 显存 |
| DoRA | $\Delta W$ 分解为幅度与方向:$W'=m\cdot\dfrac{W_0+\Delta W}{\|W_0+\Delta W\|}$ | 学得更稳、效果更接近全量 |
| AdaLoRA | 按重要性给不同 $A,B$ 分配秩(SVD 分解,Prune 低重要方向) | 平均秩更省 |
minLLM 的 train_lora.py 用的是 peft 库的 LoraConfig(target_modules / r / lora_alpha),
本讲第 12 讲已手搓其核心 ΔW=BA;QLoRA 只需在"冻结的基座"上再做 4-bit 量化(第 22 讲会手搓 INT4)。
总结¶
- PEFT = 冻结大模型,只训小参数:按注入点分 Prompt(输入)/ Prefix-P-Tuning(中间)/ Adapter(子层)/ LoRA(权重)。
- 实验:同一玩具任务上,5 种方法(参数少 10~100 倍)都与全量同样收敛(PASS)。
- 参数量账:MiniMind 一个 FFN 全量 ~590K,LoRA(r=8) ~24K(4%)、Adapter(b=128) ~197K、Prefix/Prompt 按 token 计。
- 生产:QLoRA 4-bit 基座 + LoRA 让单卡可微调大模型;DoRA/AdaLoRA 进一步提升效果/效率。
