DoRA 深度解析：权重分解低秩适应的理论与实践

1. 引言：LoRA 的隐含假设#

1.1 LoRA 的成功与局限#

LoRA 已经成为 LLM 微调的事实标准，但它有一个隐含假设：

1
LoRA 的核心假设：
2

3
  W_new = W₀ + BA
4

5
  隐含假设：W₀ 和 BA 可以直接相加
6
  → 即 W₀ 和 ΔW = BA 在同一个量纲空间
7

8
  实际问题：
9
  → 方向更新和幅度更新被耦合
10
  → 无法独立控制两者的学习率
11
  → 可能导致次优收敛

1.2 DoRA 的核心洞察#

DoRA（Weight-Decomposed Low-Rank Adaptation，Liu et al., 2024）的核心发现：

1
┌─────────────────────────────────────────────────────────────┐
2
│               DoRA 的核心洞察                                 │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  任何矩阵 W 都可以唯一分解为：                                │
6
│                                                              │
7
│    W = m · (W / ||W||_F)                                    │
8
│                                                              │
9
│  其中：                                                      │
10
│    • m = ||W||_F    （幅度，标量）                          │
11
│    • W / ||W||_F    （方向，矩阵）                          │
12
│                                                              │
13
│  DoRA 将这个分解应用于权重更新：                             │
14
│                                                              │
15
│    W_new = W₀ + ΔW                                          │
16
│           = W₀ + m_DoRA · (BA / ||BA||_F)                   │
17
│                                                              │
18
│  幅度和方向可以独立学习！                                     │
19
│                                                              │
20
└─────────────────────────────────────────────────────────────┘

1.3 本系列文章关联#

文章	关联
PEFT/LoRA 深度解析	LoRA 基础原理与变体
QLoRA 深度解析	量化感知 LoRA
后训练深度解析	对齐训练的完整流水线

2. 权重分解的数学原理#

2.1 矩阵的幅度-方向分解#

1
class WeightDecomposition:
2
    """
3
    矩阵的幅度-方向分解
4

5
    对于任意非零矩阵 W ∈ R^(d×k)：
6

7
    W = ||W||_F · (W / ||W||_F)
8

9
    其中：
10
    - ||W||_F = sqrt(Σᵢ Σⱼ Wᵢⱼ²)  是 Frobenius 范数（幅度）
11
    - W / ||W||_F  是归一化矩阵（方向）
12
    """
13

14
    def decompose(self, W):
15
        """
16
        分解矩阵
17

18
        返回：(magnitude, direction)
19
        """
20
        # 计算 Frobenius 范数
21
        magnitude = torch.norm(W, p="fro")  # ||W||_F
22

23
        # 归一化得到方向
24
        direction = W / (magnitude + 1e-8)
25

26
        return magnitude, direction
27

28
    def reconstruct(self, magnitude, direction):
29
        """
30
        重构矩阵
31
        """
32
        return magnitude * direction
33

34
    def properties(self):
35
        """
36
        分解的性质
37
        """
38
        return {
39
            "uniqueness": "分解是唯一的（当 W ≠ 0）",
40
            "orthogonal": "方向矩阵的 Frobenius 范数为 1",
41
            "independent": "幅度和方向可以独立变化",
42
            "geometric": "类似向量的幅度-方向表示",
43
        }

2.2 为什么这种分解有用？#

1
幅度-方向分解的直观理解：
2

3
  类比 1D 向量：
4

5
    v = |v| · (v / |v|)
6

7
    • |v|  控制向量的"长度"
8
    • v/|v| 控制向量的"指向"
9

10
  DoRA 的类比：
11

12
    W = ||W||_F · (W / ||W||_F)
13

14
    • ||W||_F  控制权重的"强度"
15
    • W/||W||_F 控制权重的"模式"
16

17
  优势：
18
  → 幅度和方向可以独立调优
19
  → 更细粒度的控制
20
  → 更好的收敛性

2.3 DoRA 的数学形式化#

1
class DoRAMath:
2
    """
3
    DoRA 的数学形式化
4
    """
5

6
    def lora_update(self):
7
        """
8
        LoRA 更新
9

10
        W_new^LoRA = W₀ + BA
11

12
        问题：
13
        - BA 的幅度和方向被联合优化
14
        - 无法独立控制学习率
15
        """
16
        return "W_new^LoRA = W₀ + BA"
17

18
    def dora_update(self):
19
        """
20
        DoRA 更新
21

22
        W_new^DoRA = W₀ + m · (BA / ||BA||_F)
23

24
        其中：
25
        - m ∈ R^(d×k)  是幅度矩阵（可学习）
26
        - BA / ||BA||_F  是方向矩阵（归一化）
27

28
        优势：
29
        - m 控制每个元素的幅度变化
30
        - 方向被归一化，独立于幅度
31
        """
32
        return "W_new^DoRA = W₀ + m · (BA / ||BA||_F)"
33

34
    def gradient_analysis(self):
35
        """
36
        梯度分析
37

38
        DoRA 的梯度：
39

40
        ∂L/∂A = (m / ||BA||_F) · ∂L/∂(W_new) · B^T
41
        ∂L/∂B = (m / ||BA||_F) · W₀^T · ∂L/∂(W_new)
42
        ∂L/∂m = (BA / ||BA||_F) · ∂L/∂(W_new)
43

44
        关键观察：
45
        - A, B 的梯度被 ||BA||_F 归一化
46
        - m 的梯度直接作用于方向
47
        - 幅度和方向的更新解耦
48
        """
49
        return {
50
            "grad_A": "∂L/∂A = (m / ||BA||_F) · ∂L/∂W_new · B^T",
51
            "grad_B": "∂L/∂B = (m / ||BA||_F) · W₀^T · ∂L/∂W_new",
52
            "grad_m": "∂L/∂m = (BA / ||BA||_F) · ∂L/∂W_new",
53
        }

3. DoRA vs LoRA：深度对比#

3.1 结构对比#

1
class LoRAvsDoRA:
2
    """
3
    LoRA vs DoRA 结构对比
4
    """
5

6
    def compare_structure(self):
7
        """
8
        结构对比
9
        """
10
        return {
11
            "loRA": {
12
                "formula": "W_new = W₀ + BA",
13
                "parameters": ["A (r×k)", "B (d×r)"],
14
                "parameter_count": "r × (d + k)",
15
                "update_type": "joint",
16
            },
17
            "doRA": {
18
                "formula": "W_new = W₀ + m · (BA / ||BA||_F)",
19
                "parameters": ["A (r×k)", "B (d×r)", "m (d×k)"],
20
                "parameter_count": "r × (d + k) + d×k",
21
                "update_type": "decoupled (magnitude + direction)",
22
            },
23
        }
24

25
    def parameter_overhead(self):
26
        """
27
        参数量开销
28

29
        DoRA 相比 LoRA 额外增加了 d×k 个幅度参数
30
        """
31
        return {
32
            "lora_7b": "~8M params",
33
            "dora_7b": "~125M params (额外幅度)",
34
            "overhead": "~16x 参数",
35
            "justification": "幅度参数是低秩的，不是全量 d×k",
36
        }

3.2 收敛性对比#

1
收敛性对比：
2

3
  LoRA：
4
  → BA 的幅度随训练变化
5
  → 可能导致更新不稳定
6
  → 需要小心控制学习率
7

8
  DoRA：
9
  → 方向被归一化，稳定
10
  → 幅度独立学习，可控
11
  → 收敛更平滑
12

13
  实验观察（论文 Figure 3）：
14
  → DoRA 在相同训练步数下达到更低 loss
15
  → DoRA 的 loss 曲线更平滑
16
  → DoRA 对学习率不那么敏感

3.3 性能对比#

1
class PerformanceComparison:
2
    """
3
    性能对比（来自 DoRA 论文）
4
    """
5

6
    RESULTS = {
7
        "instruction_following": {
8
            "dataset": "AlpacaEval",
9
            "lora_r8": 68.2,
10
            "dora_r8": 70.1,
11
            "improvement": "+1.9",
12
        },
13
        "commonsense_reasoning": {
14
            "datasets": ["BoolQ", "PIQA", "SIQA", "HellaSwag", "WinoGrande"],
15
            "lora_avg": 75.3,
16
            "dora_avg": 77.8,
17
            "improvement": "+2.5",
18
        },
19
        "math_reasoning": {
20
            "dataset": "GSM8K",
21
            "lora_r16": 52.1,
22
            "dora_r16": 54.8,
23
            "improvement": "+2.7",
24
        },
25
        "chat": {
26
            "dataset": "MT-Bench",
27
            "lora_r8": 6.2,
28
            "dora_r8": 6.5,
29
            "improvement": "+0.3",
30
        },
31
    }

4. DoRA 的实现#

4.1 DoRA 核心实现#

1
import torch
2
import torch.nn as nn
3
import torch.nn.functional as F
4

5
class DoRALinear(nn.Module):
6
    """
7
    DoRA 线性层
8

9
    W_new = W₀ + m · (BA / ||BA||_F)
10

11
    其中：
12
    - W₀: 原始权重（冻结）
13
    - A, B: LoRA 方向参数
14
    - m: 可学习的幅度缩放
15
    """
16

17
    def __init__(
18
        self,
19
        in_features,
20
        out_features,
21
        rank=4,
22
        alpha=16,
23
    ):
24
        super().__init__()
25

26
        self.in_features = in_features
27
        self.out_features = out_features
28
        self.rank = rank
29
        self.alpha = alpha
30
        self.scaling = alpha / rank
31

32
        # 原始权重（冻结）
33
        self.weight = nn.Parameter(
34
            torch.randn(out_features, in_features),
35
            requires_grad=False
36
        )
37
        self.bias = nn.Parameter(
38
            torch.zeros(out_features),
39
            requires_grad=False
40
        )
41

42
        # 方向参数（LoRA 风格）
43
        self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
44
        self.lora_B = nn.Parameter(torch.zeros(out_features, rank))
45

46
        # 幅度参数（DoRA 新增）
47
        # 初始化为全 1，表示初始不改变幅度
48
        self.m = nn.Parameter(torch.ones(out_features, in_features))
49

50
        # 冻结原始权重
51
        self.weight.requires_grad = False
52

53
    def compute_delta(self):
54
        """
55
        计算权重更新 ΔW = BA
56
        """
57
        return self.lora_B @ self.lora_A
58

59
    def compute_magnitude(self, delta):
60
        """
61
        计算当前幅度 ||BA||_F
62
        """
63
        return torch.norm(delta, p="fro")
64

65
    def forward(self, x):
66
        """
67
        DoRA 前向传播
68
        """
69
        # Step 1: 计算 ΔW
70
        delta = self.compute_delta()  # (d, k)
71

72
        # Step 2: 计算方向
73
        delta_magnitude = self.compute_magnitude(delta)  # scalar
74
        delta_direction = delta / (delta_magnitude + 1e-8)  # (d, k)
75

76
        # Step 3: 应用幅度
77
        delta_weight = self.m * delta_direction  # (d, k)
78

79
        # Step 4: 缩放
80
        scaled_delta = delta_weight * self.scaling  # (d, k)
81

82
        # Step 5: 合并到原始权重
83
        effective_weight = self.weight + scaled_delta
84

85
        # Step 6: 前向传播
86
        return F.linear(x, effective_weight, self.bias)

4.2 DoRA 的初始化策略#

1
class DoRAInitialization:
2
    """
3
    DoRA 初始化策略
4
    """
5

6
    def __init__(self):
7
        pass
8

9
    def recommended_init(self):
10
        """
11
        推荐初始化
12
        """
13
        return {
14
            "lora_A": "N(0, 0.01) - 小随机值",
15
            "lora_B": "全零 - 确保初始 ΔW = 0",
16
            "m": "全 1 - 确保初始不改变幅度",
17
            "rationale": "从原始模型开始，逐步学习方向和幅度",
18
        }
19

20
    def verify_init(self, layer):
21
        """
22
        验证初始化正确性
23
        """
24
        # 验证初始状态
25
        delta = layer.compute_delta()
26
        initial_magnitude = layer.compute_magnitude(delta)
27

28
        print(f"Initial ΔW magnitude: {initial_magnitude:.6f}")
29
        print(f"Expected: ~0 (B is zeros)")
30

31
        # 验证幅度参数
32
        print(f"Initial m mean: {layer.m.mean():.6f}")
33
        print(f"Expected: 1.0")
34

35
        # 验证初始权重更新为零
36
        effective_weight = layer.weight + layer.scaling * layer.m * (delta / (initial_magnitude + 1e-8))
37
        is_zero_update = torch.allclose(effective_weight, layer.weight, atol=1e-6)
38
        print(f"Zero initial update: {is_zero_update}")

4.3 DoRA 的梯度实现#

1
class DoRAGradient:
2
    """
3
    DoRA 梯度计算详解
4
    """
5

6
    def compute_gradients(self, model, loss):
7
        """
8
        梯度计算流程
9

10
        假设：∂L/∂W_new 已通过反向传播计算
11
        """
12
        model.zero_grad()
13
        loss.backward()
14

15
        for name, param in model.named_parameters():
16
            if param.grad is not None:
17
                print(f"{name}: grad norm = {param.grad.norm():.6f}")
18

19
    def gradient_analysis(self, layer, grad_output):
20
        """
21
        梯度分析
22

23
        手动验证梯度计算
24
        """
25
        # 设置 requires_grad
26
        layer.lora_A.requires_grad_(True)
27
        layer.lora_B.requires_grad_(True)
28
        layer.m.requires_grad_(True)
29

30
        # 前向
31
        output = layer.forward(self.sample_input)
32

33
        # 反向
34
        output.sum().backward()
35

36
        # 观察梯度
37
        print(f"lora_A grad norm: {layer.lora_A.grad.norm():.6f}")
38
        print(f"lora_B grad norm: {layer.lora_B.grad.norm():.6f}")
39
        print(f"m grad norm: {layer.m.grad.norm():.6f}")
40

41
        # 关键观察：
42
        # - lora_A, lora_B 梯度被 ||BA||_F 归一化
43
        # - m 梯度直接作用于方向

5. DoRA 的变体#

5.1 DoRA 与 LoRA+ 结合#

1
class DoRALoRAPlus:
2
    """
3
    DoRA + LoRA+ 组合
4

5
    LoRA+ 的核心思想：
6
    - A 和 B 使用不同的学习率
7
    - lr_A = lr / r, lr_B = lr
8

9
    DoRA 保持这个特性，同时分解幅度和方向
10
    """
11

12
    def __init__(self, in_features, out_features, rank=4):
13
        # ... 标准 DoRA 初始化 ...
14

15
        # LoRA+ 特有的学习率配置
16
        self.lr_ratio = rank  # lr_A / lr_B = r
17

18
    def configure_optimizer(self, base_lr=1e-4):
19
        """
20
        配置优化器（LoRA+ 风格）
21
        """
22
        return [
23
            {"params": self.lora_A, "lr": base_lr / self.rank},
24
            {"params": self.lora_B, "lr": base_lr},
25
            {"params": self.m, "lr": base_lr},
26
        ]

5.2 DoRA 与 QLoRA 结合#

1
class DoRAQLoRA:
2
    """
3
    DoRA + QLoRA 组合
4
    """
5

6
    def __init__(self, model, rank=64):
7
        self.model = model
8
        self.rank = rank
9

10
        # 量化基础模型
11
        self.quantized_model = self.quantize_base_model()
12

13
        # 添加 DoRA 适配器
14
        self.dora_adapters = self.add_dora_adapters()
15

16
    def quantize_base_model(self):
17
        """
18
        量化基础模型
19
        """
20
        from transformers import BitsAndBytesConfig
21

22
        bnb_config = BitsAndBytesConfig(
23
            load_in_4bit=True,
24
            bnb_4bit_compute_dtype=torch.bfloat16,
25
            bnb_4bit_quant_type="nf4",
26
            bnb_4bit_use_double_quant=True,
27
        )
28

29
        # 量化加载
30
        model = AutoModelForCausalLM.from_pretrained(
31
            self.model_path,
32
            quantization_config=bnb_config,
33
        )
34

35
        return model
36

37
    def add_dora_adapters(self):
38
        """
39
        为量化模型添加 DoRA 适配器
40
        """
41
        # 遍历所有线性层
42
        for name, module in self.quantized_model.named_modules():
43
            if isinstance(module, nn.Linear):
44
                # 替换为 DoRA 层
45
                dora_layer = DoRALinear(
46
                    in_features=module.in_features,
47
                    out_features=module.out_features,
48
                    rank=self.rank,
49
                )
50

51
                # 复制原始权重
52
                dora_layer.weight.data = module.weight.data.clone()
53
                if module.bias is not None:
54
                    dora_layer.bias.data = module.bias.data.clone()
55

56
                # 替换
57
                self.replace_module(name, dora_layer)
58

59
        return self.quantized_model

5.3 DoRA-MLP 变体#

1
class DoRAMLP:
2
    """
3
    DoRA 应用于 MLP 层
4

5
    标准 DoRA 只应用于注意力层
6
    DoRA-MLP 扩展到 FFN 层
7
    """
8

9
    def __init__(self, hidden_size, intermediate_size, rank=4):
10
        self.hidden_size = hidden_size
11
        self.intermediate_size = intermediate_size
12
        self.rank = rank
13

14
        # DoRA 适配器
15
        self.up_proj = DoRALinear(hidden_size, intermediate_size, rank)
16
        self.gate_proj = DoRALinear(hidden_size, intermediate_size, rank)
17
        self.down_proj = DoRALinear(intermediate_size, hidden_size, rank)
18

19
    def forward(self, x):
20
        """
21
        FFN 前向
22
        """
23
        # GELU 激活
24
        return self.down_proj(
25
            F.gelu(self.up_proj(x)) * self.gate_proj(x)
26
        )

6. DoRA 的实验分析#

6.1 幅度 vs 方向学习#

1
class MagnitudeVsDirection:
2
    """
3
    幅度和方向的学习分析
4
    """
5

6
    def analyze_training(self, log_path):
7
        """
8
        分析训练过程中的幅度和方向变化
9
        """
10
        import pandas as pd
11

12
        data = pd.read_csv(log_path)
13

14
        # 跟踪幅度变化
15
        data["magnitude_change"] = data["magnitude"].pct_change()
16
        data["direction_change"] = data["direction_norm"].pct_change()
17

18
        return {
19
            "avg_magnitude_change": data["magnitude_change"].mean(),
20
            "avg_direction_change": data["direction_change"].mean(),
21
            "magnitude_final": data["magnitude"].iloc[-1],
22
            "direction_final": data["direction_norm"].iloc[-1],
23
        }
24

25
    def visualize(self):
26
        """
27
        可视化幅度和方向的学习曲线
28
        """
29
        return """
30
        预期观察：
31

32
        1. 方向先于幅度收敛
33
           → 方向快速适应任务
34
           → 幅度逐步精细调整
35

36
        2. 幅度变化范围较小
37
           → 大多数幅度值在 [0.8, 1.2] 范围
38
           → 极端值较少
39

40
        3. 不同层学习不同的幅度模式
41
           → 某些层需要增强，某些需要减弱
42
        """

6.2 秩敏感性分析#

1
class RankSensitivity:
2
    """
3
    秩敏感性分析
4
    """
5

6
    EXPERIMENTS = {
7
        "rank_4": {
8
            "params": "低",
9
            "lora_performance": 72.5,
10
            "dora_performance": 74.2,
11
            "improvement": "+1.7",
12
        },
13
        "rank_8": {
14
            "params": "中",
15
            "lora_performance": 74.1,
16
            "dora_performance": 76.8,
17
            "improvement": "+2.7",
18
        },
19
        "rank_16": {
20
            "params": "中高",
21
            "lora_performance": 75.8,
22
            "dora_performance": 78.3,
23
            "improvement": "+2.5",
24
        },
25
        "rank_32": {
26
            "params": "高",
27
            "lora_performance": 77.2,
28
            "dora_performance": 79.1,
29
            "improvement": "+1.9",
30
        },
31
    }
32

33
    def conclusion(self):
34
        """
35
        结论
36
        """
37
        return {
38
            "finding": "DoRA 在所有秩设置下都优于 LoRA",
39
            "best_rank": "r=8 是 DoRA 的最佳选择",
40
            "reason": "r=8 提供了足够的表达能力，同时保持参数效率",
41
        }

6.3 层类型敏感性#

1
class LayerSensitivity:
2
    """
3
    不同层的 DoRA 敏感性
4
    """
5

6
    EXPERIMENTS = {
7
        "attention_only": {
8
            "layers": ["q_proj", "v_proj", "k_proj", "o_proj"],
9
            "performance": 76.8,
10
        },
11
        "attention_mlp": {
12
            "layers": ["q_proj", "v_proj", "k_proj", "o_proj",
13
                       "gate_proj", "up_proj", "down_proj"],
14
            "performance": 78.3,
15
        },
16
        "all_linear": {
17
            "layers": "all",
18
            "performance": 79.1,
19
        },
20
    }
21

22
    def recommendation(self):
23
        """
24
        建议
25
        """
26
        return {
27
            "low_resource": "仅注意力层",
28
            "medium_resource": "注意力层 + MLP up/down proj",
29
            "high_resource": "所有线性层",
30
        }

7. 实战指南#

7.1 使用 PEFT 库#

1
from peft import LoraConfig, get_peft_model, PeftType
2

3
def create_dora_model(model, rank=8):
4
    """
5
    使用 PEFT 库创建 DoRA 模型
6
    """
7
    # PEFT 支持 DoRA
8
    lora_config = LoraConfig(
9
        r=rank,
10
        lora_alpha=2 * rank,
11
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
12
        lora_dropout=0.05,
13
        bias="none",
14
        task_type="CAUSAL_LM",
15

16
        # DoRA 配置
17
        use_dora=True,  # 启用 DoRA
18
    )
19

20
    model = get_peft_model(model, lora_config)
21

22
    model.print_trainable_parameters()
23
    # 输出包含 DoRA 幅度参数
24

25
    return model

7.2 手动实现（更灵活）#

1
class DoRAFramework:
2
    """
3
    DoRA 框架实现
4
    """
5

6
    def __init__(self, model, rank=8, alpha=16):
7
        self.model = model
8
        self.rank = rank
9
        self.alpha = alpha
10

11
        # 替换所有目标层
12
        self.replace_layers()
13

14
    def replace_layers(self):
15
        """
16
        替换模型中的目标层
17
        """
18
        target_modules = ["q_proj", "v_proj"]
19

20
        for name, module in self.model.named_modules():
21
            if any(target in name for target in target_modules):
22
                if isinstance(module, nn.Linear):
23
                    # 创建 DoRA 层
24
                    dora_layer = DoRALinear(
25
                        in_features=module.in_features,
26
                        out_features=module.out_features,
27
                        rank=self.rank,
28
                        alpha=self.alpha,
29
                    )
30

31
                    # 复制权重
32
                    dora_layer.weight.data = module.weight.data.clone()
33
                    if module.bias is not None:
34
                        dora_layer.bias.data = module.bias.data.clone()
35

36
                    # 替换
37
                    parent_name, child_name = self.get_parent_and_child(name)
38
                    setattr(parent_name, child_name, dora_layer)
39

40
    def train(self, train_loader, num_epochs=3):
41
        """
42
        训练循环
43
        """
44
        optimizer = torch.optim.AdamW(
45
            self.get_trainable_parameters(),
46
            lr=1e-4,
47
        )
48

49
        for epoch in range(num_epochs):
50
            for batch in train_loader:
51
                optimizer.zero_grad()
52

53
                outputs = self.model(batch["input_ids"])
54
                loss = outputs.loss
55

56
                loss.backward()
57
                optimizer.step()
58

59
                # 梯度裁剪
60
                torch.nn.utils.clip_grad_norm_(
61
                    self.get_trainable_parameters(),
62
                    max_norm=1.0
63
                )
64

65
    def get_trainable_parameters(self):
66
        """
67
        获取可训练参数
68
        """
69
        return [
70
            p for p in self.model.parameters()
71
            if p.requires_grad
72
        ]

7.3 DoRA 配置推荐#

1
class DoRAConfig:
2
    """
3
    DoRA 配置推荐
4
    """
5

6
    CONFIGS = {
7
        "7b": {
8
            "rank": 8,
9
            "alpha": 16,
10
            "target_modules": ["q_proj", "v_proj", "k_proj", "o_proj"],
11
            "dropout": 0.05,
12
            "learning_rate": 1e-4,
13
        },
14
        "13b": {
15
            "rank": 8,
16
            "alpha": 16,
17
            "target_modules": ["q_proj", "v_proj", "k_proj", "o_proj"],
18
            "dropout": 0.05,
19
            "learning_rate": 8e-5,
20
        },
21
        "70b": {
22
            "rank": 8,
23
            "alpha": 16,
24
            "target_modules": ["q_proj", "v_proj"],  # 减少目标以节省显存
25
            "dropout": 0.05,
26
            "learning_rate": 5e-5,
27
        },
28
    }
29

30
    @classmethod
31
    def get_config(cls, model_size="7b"):
32
        """
33
        获取配置
34
        """
35
        return cls.CONFIGS.get(model_size, cls.CONFIGS["7b"])

8. DoRA 的局限性#

8.1 参数量增加#

1
class DoRALimitations:
2
    """
3
    DoRA 的局限性
4
    """
5

6
    def parameter_overhead(self):
7
        """
8
        参数量开销
9
        """
10
        return {
11
            "loRA_r8": "~8M params (for 7B)",
12
            "doRA_r8": "~125M params (for 7B)",
13
            "overhead": "~16x",
14
            "note": "实际可训练参数仍然很少（<1%），但比 LoRA 多",
15
        }
16

17
    def when_to_use(self):
18
        """
19
        使用建议
20
        """
21
        return {
22
            "use_dora": [
23
                "对性能有极致追求",
24
                "有足够的显存（比 LoRA 多 ~5%）",
25
                "需要更好的收敛性",
26
            ],
27
            "prefer_lora": [
28
                "显存极度受限",
29
                "需要快速实验",
30
                "模型很大（>70B）",
31
            ],
32
        }

8.2 收敛速度#

1
收敛速度对比：
2

3
  DoRA：
4
  → 初期收敛稍慢
5
  → 后期收敛更稳
6

7
  LoRA：
8
  → 初期收敛快
9
  → 后期可能震荡
10

11
  建议：
12
  → 复杂任务使用 DoRA（长期收益）
13
  → 简单任务使用 LoRA（快速实验）

9. 核心公式汇总#

9.1 幅度-方向分解#

\mathbf{W} = \|\mathbf{W}\|_F \cdot \frac{\mathbf{W}}{\|\mathbf{W}\|_F}

其中 $\|\mathbf{W}\|_F = \sqrt{\sum_i \sum_j W_{ij}^2}$ 是 Frobenius 范数。

9.2 DoRA 更新#

\mathbf{W}_{\text{new}}^{\text{DoRA}} = \mathbf{W}_0 + \mathbf{m} \odot \frac{\mathbf{B}\mathbf{A}}{\|\mathbf{B}\mathbf{A}\|_F}

其中 $\mathbf{m}$ 是幅度矩阵， $\frac{\mathbf{B}\mathbf{A}}{\|\mathbf{B}\mathbf{A}\|_F}$ 是归一化方向。

9.3 DoRA 梯度#

\frac{\partial \mathcal{L}}{\partial \mathbf{A}} = \frac{\alpha}{r} \cdot \frac{\mathbf{m}}{\|\mathbf{B}\mathbf{A}\|_F} \cdot \frac{\partial \mathcal{L}}{\partial \mathbf{W}_{\text{new}}} \cdot \mathbf{B}^\top

10. 总结#

10.1 DoRA 的核心优势#

1
┌─────────────────────────────────────────────────────────────┐
2
│                    DoRA 核心优势                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  1. 更细粒度的控制                                          │
6
│     → 幅度和方向独立学习                                     │
7
│     → 更精细的权重更新                                       │
8
│                                                              │
9
│  2. 更好的收敛性                                            │
10
│     → 方向被归一化，更稳定                                   │
11
│     → 对学习率不那么敏感                                     │
12
│                                                              │
13
│  3. 性能提升                                                │
14
│     → 在所有任务上优于 LoRA                                  │
15
│     → 平均提升 2-3%                                          │
16
│                                                              │
17
│  4. 实现简单                                                │
18
│     → 只需在 LoRA 基础上增加幅度参数                          │
19
│     → 与 QLoRA、LoRA+ 等兼容                                 │
20
│                                                              │
21
└─────────────────────────────────────────────────────────────┘

10.2 选择指南#

1
DoRA vs LoRA 选择：
2

3
  选择 DoRA：
4
    ✓ 复杂推理任务
5
    ✓ 对性能有极致追求
6
    ✓ 有足够显存
7
    ✓ 愿意多花一点训练时间
8

9
  选择 LoRA：
10
    ✓ 简单分类任务
11
    ✓ 需要快速实验
12
    ✓ 显存受限
13
    ✓ 模型很大
14

15
  关键结论：
16
  DoRA 是 LoRA 的增强版
17
  在资源和时间允许的情况下，优先使用 DoRA

参考资料#

Liu, S., et al. (2024). “DoRA: Weight-Decomposed Low-Rank Adaptation.” arXiv<2402>.09353.
Hu, E. J., et al. (2021). “LoRA: Low-Rank Adaptation of Large Language Models.” ICLR.
Dettmers, T., et al. (2023). “QLoRA: Efficient Finetuning of Quantized LLMs.” NeurIPS.
Hayou, S., et al. (2024). “LoRA+: Efficient Low Rank Adaptation of LLMs.” arXiv.
Jia, M., et al. (2024). “DoRA-MLP: Enhancing Fine-tuning with Dynamic Weight Decomposition.” arXiv.