DoRA：权重分解低秩适应技术解析与实验验证

通俗理解，这个公式就是把权重矩阵分解成'强弱程度'和'作用方向'这两个独立的部分。LoRA 精度有时不如 FT，因为它在'精细调整'上能力不足，比如想大幅调整方向的时候，没法同时灵活调整大小。

方法设计

既然知道了问题，我们就提出了 DoRA 这个方法：先把预训练权重拆成'大小'和'方向'两部分；对'方向'部分再用 LoRA 来微调（因为方向部分参数多，LoRA 能保证高效）；同时让'大小'部分也能微调。

简单来说，就是让 LoRA 专心搞'方向调整'，把'大小调整'的灵活性也加上，这样就能让 LoRA 的学习模式更接近 FT，精度也能提升。

DoRA 的公式如下：

W' = m · (V + ΔV) / ||V + ΔV||_F = m · (W_0 + BΔA) / ||W_0 + BΔA||_F

DoRA 解决了模型初始化的问题。它先把预训练的权重 W_0 初始化为两个低秩矩阵 B 和 A 的乘积，并将 m = ||W_0|| 作为可训练的标量参数，通过类似 LoRA 的方式更新方向。

梯度分析与训练开销

梯度分析

由上面的公式可推导出损失函数 L 对幅值 m 和方向更新后向量 V' 的梯度。权重梯度 ∇_{W'}L 会经过两个处理：一是被 m / ||V'||_c 缩放，二是被投影到远离当前权重矩阵的方向。这两个作用共同使梯度的协方差矩阵更接近单位矩阵，对优化过程是有利的。

创新点在于：通过权重分解，将幅值和方向调整解耦，让 LoRA 专注方向的低秩微调，同时放开幅值的可调性，从而提升微调的精细度和效率。

训练开销的降低

1. 核心问题：在标准 LoRA 公式中，更新后权重 W 与权重增量的梯度具有一致性；而 DoRA 将低秩适应定向于方向分量，导致低秩更新的梯度与 W' 的梯度产生差异，该差异在反向传播过程中引发额外内存开销。
2. 优化策略：在 DoRA 的训练开销优化中，需将 ||V + ΔV||_c 视为常数以降低内存消耗。视为常数，使其从梯度计算图中分离（即反向传播时不接收梯度）。
3. 效果验证：通过对 LLaMA-7B 和 VL-BART 模型的消融实验表明，该优化可使 LLaMA 微调时训练内存降低约 24.4%，VL-BART 降低约 12.4%；且精度损失极小。

实验结果

常识推理任务

常识推理任务包含 8 个子任务。为确保对比的公平性，研究人员最初按照 LoRA 的配置对 DoRA 模型进行微调：保持秩（rank）参数一致，仅调整学习率。

实验表格展示了不同大语言模型（LLaMA 7B/13B、LLaMA2 7B、LLaMA3 8B）在采用各种参数高效微调（PEFT）方法后，在八个常识推理数据集上的准确率对比。

• 模型与 PEFT 方法的性能差异：不同 PEFT 方法对同一模型的性能提升效果不同。例如，LLaMA-7B 采用 DoRA 时，在多个数据集上的表现优于 LoRA、Prefix 等方法，平均准确率达到 78.4。
• DoRA 方法的优势：无论是 DoRA 还是其调整版本 DoRA^i（秩减半），在多个模型上的表现都较为突出，平均准确率往往高于 LoRA 等其他 PEFT 方法。
• 参数量占比与性能的权衡：PEFT 方法的参数量占比 # Params (%) 较低（如 DoRA^i 普遍在 0.35-0.43% 左右），但能带来显著的性能提升。

图像/视频 - 文本理解

在以 VL-BART 为骨干的多模态（图像 - 文本、视频 - 文本）任务中，DoRA 在参数量占比远低于全微调的前提下，性能表现优于 LoRA，且接近或达到全微调的水平。

• Table 2（图像 - 文本多任务评估）：DoRA 的平均准确率（85.4）超过 LoRA 的 83.5，且在 TVQA、How2QA 等表现均优于 LoRA。
• Table 3（视频 - 文本多任务评估）：DoRA 在平均准确率（Avg.）上达到 77.4，超过 LoRA 的 76.5，且接近全微调的 77.3。

视觉指令微调

从表中可以观察到，LoRA 的平均准确率已经超过了全微调（FT），这可能意味着全微调存在过拟合问题。尽管如此，DoRA 仍然表现仍优于 LoRA 和全微调（FT）：相较于 LoRA，平均性能提升 0.7%；相较于 FT，平均性能提升 1.1%。

兼容性与鲁棒性

• 与其他 LoRA 变体的兼容性：DVoRA 融合了 DoRA 的优势特质，得分与 LoRA 相当甚至更高，但参数数量明显更少。无论训练样本如何，DoRA 相较于 LoRA 和 VeRA 都能持续提升性能。
• 不同秩设置下的鲁棒性：研究表明，在所有秩配置下，DoRA 的性能始终超过 LoRA。值得注意的是，当秩低于 8 时，性能差距会扩大，此时对于 r=8，LoRA 的平均准确率降至 40.74%；而对于 r=8，DoRA 保持着 77.96% 的显著准确率。

更广泛的影响

QDoRA：对 QLoRA 的增强

为了进一步降低微调的内存需求，QDoRA 建议将预训练模型量化为 4 位，并在冻结的低位骨干网络之上对 LoRA 进行微调。QDoRA 能够有效地将 QLoRA 的参数效率与全微调更精细的优化相结合，具有很大潜力给开源社区带来极大益处。

文本到图像生成

DoRA 相对于 LoRA 的优势能够延伸至图像生成任务中。

结论

研究人员首先进行了一种新颖的权重分解分析，以揭示 LoRA 和 FT 之间不同的学习模式。基于这些见解，我们提出了 DoRA——一种与 LoRA 及其变体兼容的微调方法，其学习行为与 FT 更为相似。在各种微调任务和模型架构上，DoRA 的性能始终优于 LoRA。此外，DoRA 可以被视为 LoRA 的一种无成本替代方案，因为其分解后的幅度和方向分量在训练后可以合并回预训练权重中，确保没有额外的推理开销。

代码实现分析

以下是 DoRA 的核心 Python 实现逻辑，主要基于 PyTorch 的 nn.Linear 层进行修改。

class Linear(nn.Linear, LoraLayer):
    """Lora implemented in a dense layer with DoRA support."""
    def __init__(self,
                 in_features: int,
                 out_features: int,
                 r: int = 0,
                 lora_alpha: int = 1,
                 lora_dropout: float = 0.0,
                 fan_in_fan_out: bool = False,
                 merge_weights: bool = True,
                 Wdecompose: bool = False,
                 dora_simple: bool = True,
                 **kwargs):
        nn.Linear.__init__(self, in_features, out_features, **kwargs)
        LoraLayer.__init__(self, r=r, lora_alpha=lora_alpha,
                           lora_dropout=lora_dropout, merge_weights=merge_weights)
        
        # 定义可学习的幅度向量 m，形状为 (out_features, 1)
        self.weight_m_wdecomp = nn.Linear(1, out_features, bias=False)
        self.fan_in_fan_out = fan_in_fan_out
        self.Wdecompose = Wdecompose
        self.dora_simple = dora_simple

        if self.Wdecompose == False:
            # Wdecompose=False 时创建 LoRA 矩阵用于方向更新
            if r > 0:
                self.lora_A = nn.Linear(in_features, r, bias=False)
                self.lora_B = nn.Linear(r, out_features, bias=False)
            self.scaling = self.lora_alpha / self.r
            # Freezing the pre-trained weight matrix
            self.weight.requires_grad = False
            self.reset_parameters()
            if fan_in_fan_out:
                self.weight.data = self.weight.data.T

    def reset_parameters(self):
        nn.Linear.reset_parameters(self)
        if hasattr(self, "lora_A"):
            # initialize A the same way as the default for nn.Linear and B to zero
            nn.init.kaiming_uniform_(self.lora_A.weight, a=math.sqrt(5))
            nn.init.zeros_(self.lora_B.weight)

    def train(self, mode: bool = True):
        nn.Linear.train(self, mode)
        if self.Wdecompose == False:
            self.lora_A.train(mode)
            self.lora_B.train(mode)
            self.weight_m_wdecomp.train(mode)

    def forward(self, x: torch.Tensor):
        previous_dtype = self.weight.dtype
        if self.disable_adapters:
            raise NotImplementedError
        elif self.Wdecompose and not self.merged:
            # 仅幅度模式
            norm_scale = self.weight_m_wdecomp.weight.view(-1) / (torch.linalg.norm(self.weight, dim=1))
            org_result = F.linear(x, transpose(self.weight, self.fan_in_fan_out))
            result = org_result + (norm_scale - 1) * (F.linear(self.lora_dropout(x), transpose(self.weight, self.fan_in_fan_out)))
            if not self.bias is None:
                result += self.bias.view(1, -1).expand_as(result)
        elif self.r > 0 and not self.merged:
            # 完整 DoRA 模式
            new_weight_v = self.weight + (self.lora_B.weight @ self.lora_A.weight) * self.scaling
            if self.dora_simple:
                norm_scale = self.weight_m_wdecomp.weight.view(-1) / (torch.linalg.norm(new_weight_v, dim=1)).detach()
            else:
                norm_scale = self.weight_m_wdecomp.weight.view(-1) / (torch.linalg.norm(new_weight_v, dim=1))
            
            org_result = F.linear(x, transpose(self.weight, self.fan_in_fan_out))
            dropout_x = self.lora_dropout(x)
            # 幅度调整项
            result = org_result + (norm_scale - 1) * (F.linear(dropout_x, transpose(self.weight, self.fan_in_fan_out)))
            if not self.bias is None:
                result += self.bias.view(1, -1).expand_as(result)
            # 方向更新项
            result += (norm_scale * (self.lora_B(self.lora_A(dropout_x.to(self.lora_A.weight.dtype)))) * self.scaling)
        else:
            result = F.linear(x, transpose(self.weight, self.fan_in_fan_out), bias=self.bias)

        if result.dtype != previous_dtype:
            result = result.to(previous_dtype)
        return result

代码关键点说明：

1. 权重分解：W = m × V，其中 m 为可学习幅度，V 为方向向量。
2. 方向更新：通过 LoRA 更新 V = W + ΔW，其中 ΔW = (B @ A) × scaling。
3. 幅度学习：通过 weight_m_wdecomp 学习幅度参数 m。
4. 最终公式：W_final = (m / ||W + ΔW||) × (W + ΔW)。
5. 内存优化：对范数使用了 .detach() 减少显存占用。
6. 增量计算：通过 org_result + (norm_scale-1) × ... 实现增量更新，而非直接计算完整权重。