Lora原理及实现浅析

Lora

什么是Lora

Lora的原始论文为《LoRA: Low-Rank Adaptation of Large Language Models》，翻译为中文为“大语言模型的低秩自适应”。最初是为了解决大型语言模在进行任务特定微调时消耗大量资源的问题；随后也用在了Diffusion等领域，用于对模型进行微调。总而言之，Lora是一种微调技术。

Lora是怎么实现的

原理

Lora的思想很简单，在原有权重的旁边加一个的分支。训练时冻结原有权重，只训练这个分支。然后将分支输出的结果与原有权重的输出结果相加即可。这么做的理论依据是：预训练模型拥有极小的内在维度(instrisic dimension)，即存在一个极低维度的参数，微调它和在全参数空间中微调能起到相同的效果。

伪代码实现

假设我们有一个简单的模型，仅包含一个线性层：

import torch
import torch.nn as nn

# 原始 SimpleModel 定义
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(100, 50)  # 原始权重形状: (50, 100)

    def forward(self, x):
        return self.linear(x)

那么我们用最原始的手段添加Lora：

import torch
import torch.nn as nn

class SimpleModelWithLoRA(nn.Module):
    def __init__(self, rank=4):
        super().__init__()
        # 原始预训练层（冻结）
        self.linear = nn.Linear(100, 50)
        
        # 冻结原始参数
        for param in self.linear.parameters():
            param.requires_grad = False
        
        # LoRA 参数
        self.lora_A = nn.Parameter(torch.randn(50, rank))   # (out_dim, rank)
        self.lora_B = nn.Parameter(torch.randn(rank, 100))  # (rank, in_dim)

    def forward(self, x):
        # 原始输出
        original_output = self.linear(x)
        
        # LoRA 分支输出
        lora_output = x @ self.lora_B.t() @ self.lora_A.t()  # [batch, 100] -> [batch, 50]
        
        # 输出为两者的和
        return original_output + lora_output

可以看到，Lora的代码跟原始代码的主要区别仅在于：

在权重层面：

1. 冻结原始参数
2. 添加了两个线性层，分别用于将输出映射到rank维的中间结果，和将中间结果映射到输出

在推理层面：

1. 计算Lora的输出结果
2. 将两个计算结果相加

这就是Lora的实际计算过程了，就是在原有模型旁边加了个轻量化的分支而已。此外，由于矩阵运算的性质，我们还可以直接把训练好的权重加到原始权重上以提高计算效率：

import torch
import torch.nn as nn

# 应用了 LoRA 的 SimpleModel 定义
class SimpleModelWithLoRA(nn.Module):
    def __init__(self, rank=4):
        super().__init__()
        # 初始化原始线性层
        self.linear = nn.Linear(100, 50)  # 原始权重形状: (50, 100)
        
        # 冻结原始线性层的参数
        for param in self.linear.parameters():
            param.requires_grad = False
        
        # 添加 LoRA 矩阵 A 和 B
        self.A = nn.Parameter(torch.randn(50, rank))  # 形状: (50, rank)
        self.B = nn.Parameter(torch.randn(rank, 100)) # 形状: (rank, 100)

    def forward(self, x):
        # 计算 LoRA 修正项
        lora_term = self.A @ self.B  # 形状: (50, 100)
        
        # 将 LoRA 修正项加到原始权重上
        adapted_weight = self.linear.weight.data + lora_term
        
        # 使用适应后的权重进行计算
        output = nn.functional.linear(x, adapted_weight, self.linear.bias)
        return output

值得注意的是，是否将Lora权重与原始权重融合取决于是否需要更新lora权重。因为融合后的权重虽然能够提高计算效率，但是无法单独更新Lora了。

其他细节说明

其他微调方法

除了Lora，还有其他微调手段，下面简单列出，不再做进一步说明：

rank选择与初始化

rank 越大：模型表达能力越强，但消耗资源越多。

rank 越小：更轻量，但可能无法捕捉复杂的任务特征。

通常尝试 r=8, r=16, r=64 等值，根据验证集效果选择最优配置。

在原始的 LoRA 论文中A和两个矩阵通常是随机初始化。但为了确保刚开始微调的时候不对模型输出产生影响，一些方法会其中一个矩阵初始化为零。

Q&A

Q: LoRA 是否会影响模型推理速度？

A: 不会显著影响，融合权重后模型层面没有增加任何多余的计算量

Q: LoRA 是否只能用于语言模型？

A: 不是，也可以用于图像模型（如 Diffusion）、语音模型等。

Q: 我可以用多个 LoRA 吗？

A: 可以，有些框架支持加载多个 LoRA，并按需组合使用。