低秩训练新进展

低秩训练新进展：超越LoRA

1. LoRA回顾与理论基础

1.1 低秩假设

LoRA（Hu et al., 2021）的核心假设是预训练模型的权重更新具有低秩结构：

$$W^{\prime }=W_0+\Delta W=W_0+BA,B\in {\mathbb{R}}^{d\times r},A\in {\mathbb{R}}^{r\times k}$$

其中 $r\ll \min (d,k)$。

1.2 可训练参数分析

组件	原始参数量	LoRA参数量	压缩比
$W_0\in {\mathbb{R}}^{d\times k}$	$dk$	0	-
$A\in {\mathbb{R}}^{r\times k}$	-	$rk$	-
$B\in d\times r$	-	$dr$	-
总计	$dk$	$r(d+k)$	$\frac{r}{d}+\frac{r}{k}$

1.3 表达能力的根本限制

LoRA的低秩假设存在表达能力上限：

• 如果真实最优更新 $\Delta W^{\ast }$ 的秩 $r^{\ast }>r$，LoRA会引入近似误差
• 在某些任务上（如需要大幅修改预训练知识），低秩约束可能导致欠拟合

---

2. 稀疏+低秩统一框架：HASSLE-free

2.1 问题形式化

HASSLE-free（CPAL 2025）提出统一稀疏剪枝和低秩近似的框架：

$$\underset{\Theta ,S,L}{\min }\mathcal{L}(\Theta \odot S+L)+{\lambda }_1\Vert S{\Vert }_0+{\lambda }_2\text{rank}(L)$$

其中：

• $\Theta$：原始权重矩阵
• $S\in \{0,1{\}}^d$：稀疏掩码
• $L$：低秩矩阵

2.2 优化策略

两阶段交替优化：

def hassLE_free(theta, lambda_sparse, lambda_rank, iters):
    S = torch.ones_like(theta)  # 初始掩码
    L = torch.zeros_like(theta)  # 初始低秩
    
    for _ in range(iters):
        # Step 1: 固定L，优化S（稀疏性）
        S = hard_threshold(theta - L, lambda_sparse)
        
        # Step 2: 固定S，优化L（低秩性）
        residual = theta - theta * S
        L = truncated_svd(residual, lambda_rank)
    
    return theta * S + L

2.3 理论保证

压缩-重构误差界：

$$\Vert W-(W\odot S+L){\Vert }_F\le \underset{\text{低秩误差}}{\underbrace{\Vert W-W_k{\Vert }_F}}+\underset{\text{稀疏误差}}{\underbrace{\Vert W_k\odot \bar{S}{\Vert }_F}}$$

其中 $W_k$ 是 $W$ 的最优 $k$-秩近似。

---

3. 动态秩训练

3.1 动机

固定秩无法适应不同层的不同表达能力需求：

• 浅层：低秩可能足够（捕获通用特征）
• 深层：高秩可能必要（捕获任务特定知识）

3.2 动态秩分配策略

自适应秩调度：

class DynamicRankLayer(nn.Module):
    def __init__(self, d, k, max_rank, warmup_steps):
        super().__init__()
        self.max_rank = max_rank
        self.warmup = warmup_steps
        # 初始低秩
        self.A = nn.Parameter(torch.randn(max_rank, k))
        self.B = nn.Parameter(torch.randn(d, max_rank))
        
    def get_effective_rank(self, step):
        # 预热后线性增加秩
        if step < self.warmup:
            return 1
        progress = (step - self.warmup) / (10000 - self.warmup)
        return min(int(1 + progress * (self.max_rank - 1)), self.max_rank)
    
    def forward(self, x, step):
        r = self.get_effective_rank(step)
        # 使用前r个秩
        return x @ self.A[:r] @ self.B[:, :r].T

3.3 逃逸低秩陷阱

渐进式秩增长允许模型在训练初期利用低秩快速收敛，随后扩展秩以捕获复杂模式：

$$r(t)=r_{\min }+(r_{\max }-r_{\min })\cdot \sigma \left(\frac{t-t_0}{\tau }\right)$$

其中 $\sigma$ 是Sigmoid函数，$t_0$ 是开始增长的时刻，$\tau$ 是增长率。

---

4. RandLoRA：随机投影全量微调

4.1 核心思想

RandLoRA（2025）通过随机投影突破低秩瓶颈：

$$W^{\prime }=W_0+R^{\top }HR,R\in {\mathbb{R}}^{m\times d},H\in {\mathbb{R}}^{m\times m}$$

其中 $m\gg r$（但 $m\ll d$），$R$ 是随机正交矩阵。

4.2 随机投影理论基础

Johnson-Lindenstrauss引理保证：

$$(1-ϵ)\Vert x{\Vert }_2^2\le \Vert Rx{\Vert }_2^2\le (1+ϵ)\Vert x{\Vert }_2^2$$

这意味着在投影空间中可以保持权重更新的几何结构。

4.3 优势

特性	LoRA	RandLoRA
表达能力	受限于秩 $r$	理论上全秩可达
可训练参数	$r(d+k)$	$m^2$
适用场景	简单任务	复杂知识修改
推理开销	需要合并	需要合并

4.4 PyTorch实现

class RandLoRALayer(nn.Module):
    def __init__(self, d, k, m, random_dim="left"):
        super().__init__()
        self.random_dim = random_dim
        
        # 随机投影矩阵
        self.R = nn.Parameter(self._init_random(d, m))
        
        # 中间层
        self.H = nn.Parameter(torch.randn(m, m))
        
    def _init_random(self, d, m):
        # 随机正交初始化
        Q, _ = torch.linalg.qr(torch.randn(d, m))
        return Q
    
    def forward(self, x, W0):
        if self.random_dim == "left":
            proj = x @ self.R.T
        else:
            proj = x @ self.R
        hidden = proj @ self.H @ self.R
        return x + hidden  # 等效于 W0 + ΔW

---

5. 正交知情低秩（OIALR）

5.1 动机

标准LoRA的 $A$ 和 $B$ 可能产生病态基，导致训练不稳定。

5.2 正交SVD基

OIALR强制低秩矩阵在正交基下分解：

$$L=U\Sigma V^{\top },U^{\top }U=I,V^{\top }V=I$$

其中 $U,V$ 是从 $W_0$ 的SVD分解中继承。

5.3 稳定性保证

正交基确保：

• 奇异值 $\Sigma$ 直接控制缩放
• 避免梯度消失/爆炸
• 更好的条件数

---

6. 方法对比与选择指南

6.1 方法特性对比

方法	可训练参数	表达能力	稳定性	适用场景
LoRA	$r(d+k)$	低	高	简单任务、持续学习
HASSLE-free	动态	中-高	中	内存受限场景
动态秩	$r(t)(d+k)$	中-高	高	渐进式适应
RandLoRA	$m^2$	高	中	复杂知识修改
OIALR	$r(d+k)$	中	很高	对稳定性要求高

6.2 实践建议

1. 简单任务（如指令微调）：使用LoRA，$r\in \{4,8,16\}$
2. 复杂任务（如领域适应）：考虑动态秩或RandLoRA
3. 内存受限场景：使用HASSLE-free的稀疏-低秩联合
4. 稳定性优先场景：使用OIALR

---

7. 代码示例：综合实践

class HybridLowRankLayer(nn.Module):
    """
    组合LoRA + 稀疏剪枝的混合方法
    """
    def __init__(self, d, k, r=8, sparsity=0.3):
        super().__init__()
        self.W0 = nn.Parameter(torch.randn(d, k))
        self.A = nn.Parameter(torch.randn(r, k) * 0.01)
        self.B = nn.Parameter(torch.randn(d, r))
        
    def forward(self, x):
        # LoRA部分
        delta = self.B @ self.A
        
        # 随机稀疏性（训练时用于正则化）
        if self.training:
            mask = torch.rand_like(self.W0) > 0.3
            delta = delta * mask.float()
        
        return x @ (self.W0 + delta)

---

8. 参考文献