在第一篇论文中，我们讨论了 intrinsic dimension：模型虽然位于一个很大的参数空间中，但完成特定任务可能只需要很少的 degrees of freedom。random subspace training 使用一个固定的随机投影，把低维可训练参数映射回完整参数空间，从而测量任务真正需要的训练维度。
第二篇论文继续讨论了如何使用 Sparse projection 和 Fastfood 降低随机投影的计算与存储成本，以及如何把 intrinsic dimension 用到预训练模型上。实验进一步表明：模型规模虽然很大，下游适配所需要的有效训练空间却可能很小。
这自然带来一个新的问题：如果下游任务只需要少量有效的更新方向，那么这些方向能否直接反映在权重更新 matrix 的结构中？
random subspace training 只能说明完整参数更新可能位于一个低维 subspace，并没有说明更新本身具有怎样的结构。LoRA 在此基础上提出了一个更具体、也更强的假设：对于某个权重矩阵 W 0 ‾ ‾ \underline{\underline{W_0}} W 0 Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W
如果这个假设成立，就可以让输入先经过一个 r r r Δ W ‾ ‾ = B ‾ ‾ A ‾ ‾ \underline{\underline{\Delta W}}=\underline{\underline{B}}\underline{\underline{A}} Δ W = B A rank ( Δ W ‾ ‾ ) ≤ r \operatorname{rank}(\underline{\underline{\Delta W}})\leq r rank ( Δ W ) ≤ r Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W
这篇文章讨论论文 LoRA: Low-Rank Adaptation of Large Language Models ↗
本文先简要介绍论文解决的问题和主要贡献，然后重点讨论 LoRA 的具体实现：rank 是怎样被约束的，训练时 A ‾ ‾ \underline{\underline{A}} A B ‾ ‾ \underline{\underline{B}} B
记号说明： 本文用单下划线表示 vector，用双下划线表示 matrix；scalar 不加下划线。
Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen. "LoRA: Low-Rank Adaptation of Large Language Models." ICLR, 2022. arXiv:2106.09685
论文贡献与内容#
对每一个下游任务做全量微调，需要训练并保存一套与原模型同样大的参数。Adapter 虽然只增加少量参数，但会在原网络中加入需要顺序执行的新模块；prefix tuning 则会占用一部分序列长度。
LoRA 希望同时满足下面几个目标：
冻结预训练参数，只训练少量新增参数；
不在网络中加入额外的串行层；
不占用输入 token；
每个任务只保存很小的 adapter；
合并 adapter 后不增加推理延迟。
围绕这个目标，论文给出了 low-rank update 的具体参数化方法，并在 RoBERTa、DeBERTa、GPT-2 和 GPT-3 上与全量微调、Adapter 和 prefix-based 方法进行了比较。实验中，LoRA 使用更少的可训练参数，模型质量仍然可以达到或超过全量微调。论文还进一步分析了 LoRA 应该放在哪些权重矩阵、不同 rank 的效果，以及不同训练得到的主要更新方向是否重合。
论文受到 intrinsic dimension 研究的启发：一个预训练模型虽然有大量参数，下游任务可能只需要少量有效的更新方向。但 LoRA 没有继续使用覆盖整个模型的 random subspace，而是提出一个新的经验假设：
下游适配产生的权重更新，可能具有较低的 intrinsic rank。
这里需要先保留一个逻辑边界：low intrinsic dimension 并不能直接推出 low-rank weight update。LoRA 从前者获得启发，再通过实验验证后者是一种有效的参数化方法；它不是一个由 intrinsic dimension 推导出来的定理。
LoRA 的核心实现#
考虑一个预训练线性层，其权重矩阵为 W 0 ‾ ‾ ∈ R d × k \underline{\underline{W_0}}\in\mathbb{R}^{d\times k} W 0 ∈ R d × k x ‾ ∈ R k \underline{x}\in\mathbb{R}^k x ∈ R k h ‾ = W 0 ‾ ‾ x ‾ \underline{h}=\underline{\underline{W_0}}\underline{x} h = W 0 x
全量微调会直接学习一个完整更新 Δ W ‾ ‾ ∈ R d × k \underline{\underline{\Delta W}}\in\mathbb{R}^{d\times k} Δ W ∈ R d × k W ‾ ‾ = W 0 ‾ ‾ + Δ W ‾ ‾ \underline{\underline{W}}=\underline{\underline{W_0}}+\underline{\underline{\Delta W}} W = W 0 + Δ W
LoRA 不直接训练 Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W Δ W ‾ ‾ = B ‾ ‾ A ‾ ‾ \underline{\underline{\Delta W}}=\underline{\underline{B}}\underline{\underline{A}} Δ W = B A A ‾ ‾ ∈ R r × k \underline{\underline{A}}\in\mathbb{R}^{r\times k} A ∈ R r × k B ‾ ‾ ∈ R d × r \underline{\underline{B}}\in\mathbb{R}^{d\times r} B ∈ R d × r r ≪ min ( d , k ) r\ll\min(d,k) r ≪ min ( d , k )
于是前向计算变为 h ‾ = W 0 ‾ ‾ x ‾ + α r B ‾ ‾ A ‾ ‾ x ‾ \underline{h}=\underline{\underline{W_0}}\underline{x}+\frac{\alpha}{r}\underline{\underline{B}}\underline{\underline{A}}\underline{x} h = W 0 x + r α B A x
训练过程中：
W 0 ‾ ‾ \underline{\underline{W_0}} W 0 A ‾ ‾ \underline{\underline{A}} A B ‾ ‾ \underline{\underline{B}} B A ‾ ‾ \underline{\underline{A}} A B ‾ ‾ \underline{\underline{B}} B 因此训练开始时 B ‾ ‾ A ‾ ‾ = 0 \underline{\underline{B}}\underline{\underline{A}}=0 B A = 0
Rank 是怎样被约束的#
LoRA 不需要在训练过程中反复计算 rank ( Δ W ‾ ‾ ) \operatorname{rank}(\underline{\underline{\Delta W}}) rank ( Δ W ) r r r
根据矩阵乘法的性质，rank ( B ‾ ‾ A ‾ ‾ ) ≤ min ( rank ( B ‾ ‾ ) , rank ( A ‾ ‾ ) ) ≤ r \operatorname{rank}(\underline{\underline{B}}\underline{\underline{A}})\leq\min(\operatorname{rank}(\underline{\underline{B}}),\operatorname{rank}(\underline{\underline{A}}))\leq r rank ( B A ) ≤ min ( rank ( B ) , rank ( A )) ≤ r
从计算路径看，x ‾ ∈ R k \underline{x}\in\mathbb{R}^k x ∈ R k A ‾ ‾ \underline{\underline{A}} A r r r B ‾ ‾ \underline{\underline{B}} B R d \mathbb{R}^d R d r r r r r r
还可以把乘积写成 B ‾ ‾ A ‾ ‾ = ∑ i = 1 r b i ‾ a i ‾ T \underline{\underline{B}}\underline{\underline{A}}=\sum_{i=1}^r\underline{b_i}\underline{a_i}^T B A = ∑ i = 1 r b i a i T b i ‾ a i ‾ T \underline{b_i}\underline{a_i}^T b i a i T 1 1 1 r r r
所以 r r r r = 8 r=8 r = 8
完整更新需要训练 d k dk d k r ( d + k ) r(d+k) r ( d + k ) d = k = 4096 d=k=4096 d = k = 4096 r = 8 r=8 r = 8 16,777,216 16{,}777{,}216 16 , 777 , 216 65,536 65{,}536 65 , 536
这里数的是矩阵中可训练标量参数 的数量。设原始权重矩阵及其完整更新为
W 0 ‾ ‾ , Δ W ‾ ‾ ∈ R d out × d in . \underline{\underline{W_0}},\underline{\underline{\Delta W}}
\in\mathbb{R}^{d_{\text{out}}\times d_{\text{in}}}. W 0 , Δ W ∈ R d out × d in . 矩阵有 d out d_{\text{out}} d out d in d_{\text{in}} d in Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W
d out d in d_{\text{out}}d_{\text{in}} d out d in 个标量参数。
LoRA 不直接训练完整的 Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W
Δ W ‾ ‾ = B ‾ ‾ A ‾ ‾ , B ‾ ‾ ∈ R d out × r , A ‾ ‾ ∈ R r × d in . \underline{\underline{\Delta W}}
=\underline{\underline{B}}\underline{\underline{A}},
\qquad
\underline{\underline{B}}\in\mathbb{R}^{d_{\text{out}}\times r},
\qquad
\underline{\underline{A}}\in\mathbb{R}^{r\times d_{\text{in}}}. Δ W = B A , B ∈ R d out × r , A ∈ R r × d in . 矩阵乘法会消去中间的 r r r
( d out × r ) ⏟ B ‾ ‾ ( r × d in ) ⏟ A ‾ ‾ = ( d out × d in ) ⏟ Δ W ‾ ‾ . \underbrace{(d_{\text{out}}\times r)}_{\underline{\underline{B}}}
\underbrace{(r\times d_{\text{in}})}_{\underline{\underline{A}}}
=
\underbrace{(d_{\text{out}}\times d_{\text{in}})}_{\underline{\underline{\Delta W}}}. B ( d out × r ) A ( r × d in ) = Δ W ( d out × d in ) . 例如：
[ 2 1 3 4 0 2 ] ⏟ B ‾ ‾ ∈ R 2 × 3 [ 5 2 1 4 3 7 ] ⏟ A ‾ ‾ ∈ R 3 × 2 = [ 20 29 26 22 ] ⏟ B ‾ ‾ A ‾ ‾ ∈ R 2 × 2 . \underbrace{
\begin{bmatrix}
2 & 1 & 3\\
4 & 0 & 2
\end{bmatrix}
}_{\underline{\underline{B}}\in\mathbb{R}^{2\times 3}}
\underbrace{
\begin{bmatrix}
5 & 2\\
1 & 4\\
3 & 7
\end{bmatrix}
}_{\underline{\underline{A}}\in\mathbb{R}^{3\times 2}}
=
\underbrace{
\begin{bmatrix}
20 & 29\\
26 & 22
\end{bmatrix}
}_{\underline{\underline{B}}\underline{\underline{A}}\in\mathbb{R}^{2\times 2}}. B ∈ R 2 × 3 [ 2 4 1 0 3 2 ] A ∈ R 3 × 2 5 1 3 2 4 7 = B A ∈ R 2 × 2 [ 20 26 29 22 ] . 其中左上角元素为
( B ‾ ‾ A ‾ ‾ ) 11 = ( 2 ⋅ 5 ) + ( 1 ⋅ 1 ) + ( 3 ⋅ 3 ) = 20. (\underline{\underline{B}}\underline{\underline{A}})_{11}
=(2\cdot5)+(1\cdot1)+(3\cdot3)=20. ( B A ) 11 = ( 2 ⋅ 5 ) + ( 1 ⋅ 1 ) + ( 3 ⋅ 3 ) = 20. 分别计数两个 LoRA 矩阵：
B ‾ ‾ \underline{\underline{B}} B d out r d_{\text{out}}r d out r A ‾ ‾ \underline{\underline{A}} A r d in rd_{\text{in}} r d in 加起来就是
d out r + r d in = r ( d out + d in ) . d_{\text{out}}r+rd_{\text{in}}
=r(d_{\text{out}}+d_{\text{in}}). d out r + r d in = r ( d out + d in ) . 当 r ≪ min ( d out , d in ) r\ll\min(d_{\text{out}},d_{\text{in}}) r ≪ min ( d out , d in ) d out d in d_{\text{out}}d_{\text{in}} d out d in W 0 ‾ ‾ \underline{\underline{W_0}} W 0
初始化以后，谁先开始学习#
训练开始时 B ‾ ‾ = 0 \underline{\underline{B}}=0 B = 0 α / r \alpha/r α / r Δ W ‾ ‾ \underline{\underline{\Delta W}} Δ W G ‾ ‾ \underline{\underline{G}} G ∂ L ∂ B ‾ ‾ = G ‾ ‾ A ‾ ‾ T \frac{\partial L}{\partial\underline{\underline{B}}}=\underline{\underline{G}}\underline{\underline{A}}^T ∂ B ∂ L = G A T ∂ L ∂ A ‾ ‾ = B ‾ ‾ T G ‾ ‾ = 0 \frac{\partial L}{\partial\underline{\underline{A}}}=\underline{\underline{B}}^T\underline{\underline{G}}=0 ∂ A ∂ L = B T G = 0
因此第一步主要是 B ‾ ‾ \underline{\underline{B}} B B ‾ ‾ \underline{\underline{B}} B A ‾ ‾ \underline{\underline{A}} A
可以把计算顺序直观地理解为：
A ‾ ‾ \underline{\underline{A}} A r r r B ‾ ‾ \underline{\underline{B}} B r r r
这是一种有用的计算直觉，但 B ‾ ‾ A ‾ ‾ \underline{\underline{B}}\underline{\underline{A}} B A A ‾ ‾ \underline{\underline{A}} A B ‾ ‾ \underline{\underline{B}} B
训练伪代码#
class LoRALinear ( nn . Module ): def __init__ (self, base_linear, rank, alpha): super (). __init__ () self .base = base_linear for parameter in self .base.parameters(): parameter.requires_grad = False d_out, d_in = self .base.weight.shape self .A = nn.Parameter(torch.randn(rank, d_in)) self .B = nn.Parameter(torch.zeros(d_out, rank)) self .scale = alpha / rank def forward (self, x): original = self .base(x) update = (x @ self .A.T) @ self .B.T return original + self .scale * update python
展开 收起 训练模型时，optimizer 只接收 LoRA 参数：
model = load_pretrained_model() freeze(model) insert_lora(model, target_modules = [ "q_proj" , "v_proj" ]) optimizer = Adam(lora_parameters(model)) for batch in dataset: logits = model(batch.input) loss = cross_entropy(logits, batch.label) loss.backward() optimizer.step() optimizer.zero_grad() python
展开 收起 原论文在大多数实验中把 LoRA 加到 self-attention 的 Query 和 Value projection 上，并冻结 MLP。LoRA 的参数化方法本身并不局限于这两个 matrix，也可以用于其他 dense layer。
推理时如何使用 LoRA#
动态加载 adapter#
如果希望同一个基础模型快速切换不同任务，可以保留 LoRA 分支：
original = W0(x) update = B(A(x)) output = original + alpha / rank * update python
这样只需切换很小的 A ‾ ‾ \underline{\underline{A}} A B ‾ ‾ \underline{\underline{B}} B
合并到原始权重#
因为原分支和 LoRA 分支都是线性的，所以可以提前计算 W m e r g e d ‾ ‾ = W 0 ‾ ‾ + α r B ‾ ‾ A ‾ ‾ \underline{\underline{W_{\mathrm{merged}}}}=\underline{\underline{W_0}}+\frac{\alpha}{r}\underline{\underline{B}}\underline{\underline{A}} W merged = W 0 + r α B A
with torch.no_grad(): W0.weight += alpha / rank * (B @ A) python
合并后，推理仍然只执行普通 linear layer。LoRA 的优势是相对全量微调不会增加推理延迟，但 matrix 的形状没有变，因此它通常不会让基础模型的推理本身更快。
合并也有代价：如果同一个 batch 中的样本需要使用不同的 adapter，就很难在一次普通 matrix multiplication 中同时完成。保留未合并的 LoRA 分支可以动态选择 adapter，但会重新引入额外计算和延迟。
论文的局限性#
low-rank update 是由实验支持的经验假设，不是从 intrinsic dimension 严格推导出的结论；合适的 rank 会随模型、任务和目标 matrix 改变。
原论文主要研究 Transformer 的 attention 权重，MLP、LayerNorm 和 bias 的系统性比较被留作后续工作。
合并 LoRA 可以消除额外推理延迟，却不适合在同一个 batch 中为不同样本动态选择不同 adapter；不合并则需要接受额外计算。
论文证明了 LoRA 是一种有效的 parameter-efficient training 方法，但没有证明所有下游任务的最优更新都一定是 low rank。
LoRA 的实现可以压缩成一句话：冻结 W 0 ‾ ‾ \underline{\underline{W_0}} W 0 rank ( Δ W ‾ ‾ ) ≤ r \operatorname{rank}(\underline{\underline{\Delta W}})\leq r rank ( Δ W ) ≤ r Δ W ‾ ‾ = B ‾ ‾ A ‾ ‾ \underline{\underline{\Delta W}}=\underline{\underline{B}}\underline{\underline{A}} Δ W = B A
它与 intrinsic dimension 的联系主要是一种研究动机：两者都在追问下游训练究竟需要多少有效的 degrees of freedom。LoRA 的关键推进，是把这个问题落实成对每个权重更新 matrix 的 low-rank 结构约束，并给出了可以直接训练、保存和部署的实现。