L-BFGS 双循环递归

L-BFGS 双循环递归(Two-Loop Recursion)的核心秘密,是利用矩阵乘法的结合律,将原本“先构造 \(N \times N\) 逆 Hessian 矩阵 \(\mathbf{B}_k\)、再乘以梯度向量 \(\mathbf{g}_k\)”的矩阵运算,彻底改写为一系列“向量点积(标量)与向量线性加减”的运算。

通过这种代数重组,算法在全程计算牛顿方向 \(\mathbf{d}_k = -\mathbf{B}_k \mathbf{g}_k\) 的过程中,连一个 \(N \times N\) 矩阵的元素都不需要生成,从而将空间和时间复杂度从 \(O(N^2)\) 降维打击到了 \(O(mN)\)(其中 \(m\) 通常仅为 \(5 \sim 20\))。

下面我们从标准 BFGS 的递推公式出发,一步步拆解这个优雅的“剥洋葱”数学魔术。


一、 起点:标准 BFGS 公式为什么会产生 \(N \times N\) 矩阵?

在第 \(k\) 步迭代中,我们记录了最近一步的参数位移向量 \(\mathbf{s}_k\) 和梯度变化向量 \(\mathbf{y}_k\):

\[\mathbf{s}_k = \mathbf{x}_{k+1} - \mathbf{x}_k \in \mathbb{R}^N, \qquad \mathbf{y}_k = \mathbf{g}_{k+1} - \mathbf{g}_k \in \mathbb{R}^N \]

定义标量 \(\rho_k\) 为这两个向量内积的倒数:

\[\rho_k = \frac{1}{\mathbf{y}_k^T \mathbf{s}_k} \in \mathbb{R} \]

在标准 BFGS 算法中,逆 Hessian 矩阵近似 \(\mathbf{B}_{k+1} \approx \mathbf{H}_{k+1}^{-1}\) 的秩-2(Rank-2)递推更新公式为:

\[\mathbf{B}_{k+1} = \mathbf{V}_k^T \mathbf{B}_k \mathbf{V}_k + \rho_k \mathbf{s}_k \mathbf{s}_k^T \]

其中辅助矩阵 \(\mathbf{V}_k\) 定义为:

\[\mathbf{V}_k = \mathbf{I} - \rho_k \mathbf{y}_k \mathbf{s}_k^T \in \mathbb{R}^{N \times N} \]

维度灾难的根源:向量外积(Outer Product)

请注意 \(\mathbf{V}_k\) 中的 \(\mathbf{y}_k \mathbf{s}_k^T\) 以及尾项中的 \(\mathbf{s}_k \mathbf{s}_k^T\):

  • 内积(Inner Product) \(\mathbf{y}_k^T \mathbf{s}_k\) 是“行向量 \(\times\) 列向量” \((1 \times N) \times (N \times 1)\),结果是一个标量(\(1 \times 1\))。
  • 外积(Outer Product) \(\mathbf{y}_k \mathbf{s}_k^T\) 是“列向量 \(\times\) 行向量” \((N \times 1) \times (1 \times N)\),结果是一个稠密的 \(N \times N\) 矩阵!

如果你按照从左到右的常规顺序先把 \(\mathbf{B}_{k+1}\) 算出来,就必须计算并存储这些 \(N \times N\) 的外积矩阵,内存瞬间爆炸。


二、 展开最近 \(m\) 步递推:看清“洋葱嵌套结构”

L-BFGS 规定:不从第 \(0\) 步一直累加 \(\mathbf{B}_k\),而是只保留最近 \(m\) 步的历史向量对 \(\{(\mathbf{s}_i, \mathbf{y}_i)\}_{i=k-m}^{k-1}\)。在展开这 \(m\) 步之前,先设定一个极简的初始对角矩阵 \(\mathbf{B}_k^{(0)} = \gamma_k \mathbf{I}\)(一个标量乘以单位阵)。

将递推公式 \(\mathbf{B}_{i+1} = \mathbf{V}_i^T \mathbf{B}_i \mathbf{V}_i + \rho_i \mathbf{s}_i \mathbf{s}_i^T\) 从 \(k-m\) 步展开到 \(k\) 步,我们会得到一个高度对称的“洋葱嵌套结构”:

  • 仅展开 1 步(\(m=1\)):

\[\mathbf{B}_k = \mathbf{V}_{k-1}^T \mathbf{B}_k^{(0)} \mathbf{V}_{k-1} + \rho_{k-1} \mathbf{s}_{k-1} \mathbf{s}_{k-1}^T \]

  • 展开 2 步(\(m=2\)):

\[\mathbf{B}_k = \mathbf{V}_{k-1}^T \left( \mathbf{V}_{k-2}^T \mathbf{B}_k^{(0)} \mathbf{V}_{k-2} + \rho_{k-2} \mathbf{s}_{k-2} \mathbf{s}_{k-2}^T \right) \mathbf{V}_{k-1} + \rho_{k-1} \mathbf{s}_{k-1} \mathbf{s}_{k-1}^T \]

  • 展开任意 \(m\) 步的一般形式:

\[\begin{aligned} \mathbf{B}_k &= \left(\mathbf{V}_{k-1}^T \cdots \mathbf{V}_{k-m}^T\right) \mathbf{B}_k^{(0)} \left(\mathbf{V}_{k-m} \cdots \mathbf{V}_{k-1}\right) \\ &+ \rho_{k-m} \left(\mathbf{V}_{k-1}^T \cdots \mathbf{V}_{k-m+1}^T\right) \mathbf{s}_{k-m} \mathbf{s}_{k-m}^T \left(\mathbf{V}_{k-m+1} \cdots \mathbf{V}_{k-1}\right) \\ &+ \rho_{k-m+1} \left(\mathbf{V}_{k-1}^T \cdots \mathbf{V}_{k-m+2}^T\right) \mathbf{s}_{k-m+1} \mathbf{s}_{k-m+1}^T \left(\mathbf{V}_{k-m+2} \cdots \mathbf{V}_{k-1}\right) \\ &+ \cdots \\ &+ \rho_{k-1} \mathbf{s}_{k-1} \mathbf{s}_{k-1}^T \end{aligned} \]

单独看这个式子似乎更复杂了,但别忘了:我们的目标不是算 \(\mathbf{B}_k\),而是算矩阵与当前梯度向量的乘积 \(\mathbf{r} = \mathbf{B}_k \mathbf{g}_k\)!


三、 核心数学推导:结合律如何把“矩阵外积”变成“标量点积”?

现在,把向量 \(\mathbf{q} = \mathbf{g}_k\) 放到 \(\mathbf{B}_k\) 的最右侧(即计算 \(\mathbf{B}_k \mathbf{q}\))。奇迹发生在 \(\mathbf{V}_i\) 和 \(\mathbf{V}_i^T\) 与列向量相乘的瞬间:

1. 第一阶段(由外向内剥洋葱):右乘算子 \(\mathbf{V}_i \mathbf{q}\)

在展开式的最右侧,向量 \(\mathbf{q}\) 首先遇到的是 \(\mathbf{V}_{k-1}\),接着是 \(\mathbf{V}_{k-2}\),一路向内直到 \(\mathbf{V}_{k-m}\)。
考察任意一步 \(\mathbf{V}_i\) 乘以一个列向量 \(\mathbf{q}\):

\[\mathbf{V}_i \mathbf{q} = \left(\mathbf{I} - \rho_i \mathbf{y}_i \mathbf{s}_i^T\right) \mathbf{q} = \mathbf{q} - \rho_i \left(\mathbf{y}_i \mathbf{s}_i^T\right) \mathbf{q} \]

利用矩阵乘法结合律,把括号移到右边:

\[\mathbf{V}_i \mathbf{q} = \mathbf{q} - \rho_i \mathbf{y}_i \underbrace{\left(\mathbf{s}_i^T \mathbf{q}\right)}_{\text{内积(标量)}} = \mathbf{q} - \underbrace{\left(\rho_i \mathbf{s}_i^T \mathbf{q}\right)}_{\text{记为标量 } \alpha_i} \mathbf{y}_i = \mathbf{q} - \alpha_i \mathbf{y}_i \]

关键发现 1:定义一个标量 \(\alpha_i = \rho_i (\mathbf{s}_i^T \mathbf{q})\)。那么用 \(N \times N\) 矩阵 \(\mathbf{V}_i\) 左乘向量 \(\mathbf{q}\),完全等价于先算一个点积 \(\alpha_i\),再从向量 \(\mathbf{q}\) 中减去 \(\alpha_i \mathbf{y}_i\)!
更妙的是,展开式中间夹着的那些 \(\rho_i \mathbf{s}_i \mathbf{s}_i^T \left(\mathbf{V}_{i+1} \cdots \mathbf{V}_{k-1} \mathbf{g}_k\right)\) 项,由于右边括号里算出来的正是第 \(i\) 步的当前向量 \(\mathbf{q}^{(i)}\),所以:

\[\rho_i \mathbf{s}_i \mathbf{s}_i^T \mathbf{q}^{(i)} = \mathbf{s}_i \underbrace{\left(\rho_i \mathbf{s}_i^T \mathbf{q}^{(i)}\right)}_{\text{恰好就是刚才算出的 } \alpha_i!} = \alpha_i \mathbf{s}_i \]

这意味着我们只需要在第一个循环里把标量 \(\alpha_i\) 顺手存下来(仅占 \(m\) 个浮点数内存),展开式里所有的 \(\rho_i \mathbf{s}_i \mathbf{s}_i^T\) 项就全部化简成了 \(\alpha_i \mathbf{s}_i\)!


2. 中间阶段(洋葱核心):初始对角矩阵缩放 \(\mathbf{B}_k^{(0)} \mathbf{q}\)

当第一个循环从 \(i = k-1\) 倒退到 \(k-m\) 走完后,向量 \(\mathbf{q}\) 已经变成了 \(\mathbf{q}^{(k-m)} = \mathbf{V}_{k-m} \cdots \mathbf{V}_{k-1} \mathbf{g}_k\)。
此时它撞上了最核心的初始矩阵 \(\mathbf{B}_k^{(0)} = \gamma_k \mathbf{I}\):

\[\mathbf{r} = \mathbf{B}_k^{(0)} \mathbf{q} = \gamma_k \mathbf{q} \]

其中缩放因子 \(\gamma_k\) 通常采用 Barzilai-Borwein 公式,用最新一步的曲率来近似全局尺度:

\[\gamma_k = \frac{\mathbf{s}_{k-1}^T \mathbf{y}_{k-1}}{\mathbf{y}_{k-1}^T \mathbf{y}_{k-1}} \]

这依然只是两个简单的向量点积!


3. 第二阶段(由内向外包洋葱):左乘算子 \(\mathbf{V}_i^T \mathbf{r} + \alpha_i \mathbf{s}_i\)

现在,我们拿着核心算出的向量 \(\mathbf{r}\),从最内层 \(i = k-m\) 往最外层 \(i = k-1\) 一层层向外包裹。
每一层洋葱做的操作都是:把上一层的向量 \(\mathbf{r}\) 左乘 \(\mathbf{V}_i^T\),再加上刚才缓存的尾巴项 \(\alpha_i \mathbf{s}_i\):

\[\mathbf{r}_{\text{new}} = \mathbf{V}_i^T \mathbf{r} + \alpha_i \mathbf{s}_i \]

把 \(\mathbf{V}_i^T = \left(\mathbf{I} - \rho_i \mathbf{y}_i \mathbf{s}_i^T\right)^T = \mathbf{I} - \rho_i \mathbf{s}_i \mathbf{y}_i^T\) 代入,再次使用乘法结合律:

\[\begin{aligned} \mathbf{r}_{\text{new}} &= \left(\mathbf{I} - \rho_i \mathbf{s}_i \mathbf{y}_i^T\right) \mathbf{r} + \alpha_i \mathbf{s}_i \\ &= \mathbf{r} - \mathbf{s}_i \underbrace{\left(\rho_i \mathbf{y}_i^T \mathbf{r}\right)}_{\text{记为标量 } \beta_i} + \alpha_i \mathbf{s}_i \\ &= \mathbf{r} + (\alpha_i - \beta_i) \mathbf{s}_i \end{aligned} \]

关键发现 2:定义一个临时标量 \(\beta_i = \rho_i (\mathbf{y}_i^T \mathbf{r})\)。那么向外包裹一层洋葱,仅仅需要算一个点积 \(\beta_i\),然后把向量 \(\mathbf{r}\) 加上 \((\alpha_i - \beta_i)\mathbf{s}_i\)!

当 \(i\) 从 \(k-m\) 走到 \(k-1\) 结束时,最终得到的向量 \(\mathbf{r}\) 就精确等于 \(\mathbf{B}_k \mathbf{g}_k\)。取负号 \(\mathbf{d}_k = -\mathbf{r}\),就是我们要找的 L-BFGS 下降方向!


四、 L-BFGS 双循环递归:标准伪代码与 Python 实现

将上述三个阶段拼在一起,就是著名的 L-BFGS Two-Loop Recursion。你可以看到整个算法由两个长度为 \(m\) 的 for 循环组成,没有任何矩阵运算:

import numpy as np

def lbfgs_two_loop_recursion(grad, s_list, y_list, rho_list):
    """
    计算 L-BFGS 搜索方向 d = - B_k * grad
    
    参数:
        grad: 当前梯度向量 g_k, shape=(N,)
        s_list: 最近 m 步的参数位移向量列表 [s_{k-m}, ..., s_{k-1}], 每个元素 shape=(N,)
        y_list: 最近 m 步的梯度差向量列表 [y_{k-m}, ..., y_{k-1}], 每个元素 shape=(N,)
        rho_list: 预计算的标量列表 [rho_{k-m}, ..., rho_{k-1}], 其中 rho_i = 1.0 / dot(y_i, s_i)
    返回:
        d: 近似牛顿下降方向 -B_k * g_k, shape=(N,)
    """
    m = len(s_list)
    q = grad.copy()          # 复制当前梯度,避免原地修改污染原梯度
    alpha = [0.0] * m        # 只需存储 m 个标量 alpha_i

    # ==========================================================
    # 第一重循环(向后回溯:从最新一步 m-1 到最旧一步 0)
    # 数学作用:计算 q = V_{k-m} ... V_{k-1} * g_k,并缓存标量 alpha_i
    # ==========================================================
    for i in range(m - 1, -1, -1):
        alpha[i] = rho_list[i] * np.dot(s_list[i], q)  # O(N) 点积 -> 标量
        q = q - alpha[i] * y_list[i]                   # O(N) 向量减法

    # ==========================================================
    # 中间层缩放(洋葱核心:初始对角矩阵 B_k^(0) = gamma_k * I)
    # ==========================================================
    if m > 0:
        # 用最新一步 (m-1) 的 s 和 y 估计初始曲率缩放因子 gamma_k
        gamma_k = np.dot(s_list[-1], y_list[-1]) / np.dot(y_list[-1], y_list[-1])
        r = gamma_k * q
    else:
        r = q  # 第一步尚无历史记录时,退化为普通梯度方向

    # ==========================================================
    # 第二重循环(向前递推:从最旧一步 0 到最新一步 m-1)
    # 数学作用:层层左乘 V_i^T 并加上 alpha_i * s_i,还原完整的 B_k * g_k
    # ==========================================================
    for i in range(0, m):
        beta = rho_list[i] * np.dot(y_list[i], r)      # O(N) 点积 -> 标量
        r = r + (alpha[i] - beta) * s_list[i]          # O(N) 向量加法

    # 返回下降方向 d_k = - B_k * g_k
    return -r


五、 眼见为实:用 \(N=2, m=1\) 的极简算例手算验证等价性

为了彻底消除“不算出矩阵怎么可能结果一模一样”的疑惑,我们用一个二维向量(\(N=2\))、保留 \(m=1\) 步历史的例子,对比显式矩阵法与双循环递归法。

假设已知:

  • 历史位移向量 \(\mathbf{s}_0 = \begin{bmatrix} 1 \\ 0 \end{bmatrix}\),历史梯度差 \(\mathbf{y}_0 = \begin{bmatrix} 2 \\ 1 \end{bmatrix}\)
  • 当前梯度 \(\mathbf{g}_1 = \begin{bmatrix} 4 \\ 2 \end{bmatrix}\),为简化演示设初始矩阵 \(\mathbf{B}_1^{(0)} = \mathbf{I}\)(即 \(\gamma_1 = 1\))
  • 预计算标量:\(\rho_0 = \frac{1}{\mathbf{y}_0^T \mathbf{s}_0} = \frac{1}{2\times 1 + 1\times 0} = 0.5\)

方法 A:传统 BFGS 显式构造 \(2 \times 2\) 矩阵

  1. 构造矩阵 \(\mathbf{V}_0 = \mathbf{I} - \rho_0 \mathbf{y}_0 \mathbf{s}_0^T\):

\[\mathbf{V}_0 = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} - 0.5 \begin{bmatrix} 2 \\ 1 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} - \begin{bmatrix} 1 & 0 \\ 0.5 & 0 \end{bmatrix} = \begin{bmatrix} 0 & 0 \\ -0.5 & 1 \end{bmatrix} \]

  1. 构造完整逆 Hessian 矩阵 \(\mathbf{B}_1 = \mathbf{V}_0^T \mathbf{I} \mathbf{V}_0 + \rho_0 \mathbf{s}_0 \mathbf{s}_0^T\):

\[\mathbf{B}_1 = \begin{bmatrix} 0 & -0.5 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} 0 & 0 \\ -0.5 & 1 \end{bmatrix} + 0.5 \begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix} = \begin{bmatrix} 0.25 & -0.5 \\ -0.5 & 1 \end{bmatrix} + \begin{bmatrix} 0.5 & 0 \\ 0 & 0 \end{bmatrix} = \begin{bmatrix} 0.75 & -0.5 \\ -0.5 & 1 \end{bmatrix} \]

  1. 矩阵乘以梯度向量 \(\mathbf{g}_1 = \begin{bmatrix} 4 \\ 2 \end{bmatrix}\):

\[\mathbf{r} = \mathbf{B}_1 \mathbf{g}_1 = \begin{bmatrix} 0.75 & -0.5 \\ -0.5 & 1 \end{bmatrix} \begin{bmatrix} 4 \\ 2 \end{bmatrix} = \begin{bmatrix} 0.75 \times 4 - 0.5 \times 2 \\ -0.5 \times 4 + 1 \times 2 \end{bmatrix} = \begin{bmatrix} 2 \\ 0 \end{bmatrix} \]

方法 B:L-BFGS 双循环递归(全程无矩阵)

  1. 初始化:\(\mathbf{q} = \mathbf{g}_1 = \begin{bmatrix} 4 \\ 2 \end{bmatrix}\)
  2. 第一重循环(\(i=0\)):
  • 算标量点积:\(\alpha_0 = \rho_0 (\mathbf{s}_0^T \mathbf{q}) = 0.5 \times (1\times 4 + 0\times 2) = 2\)
  • 更新向量 \(\mathbf{q}\):\(\mathbf{q} \leftarrow \mathbf{q} - \alpha_0 \mathbf{y}_0 = \begin{bmatrix} 4 \\ 2 \end{bmatrix} - 2 \begin{bmatrix} 2 \\ 1 \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \end{bmatrix}\)
  1. 中间层缩放:\(\mathbf{r} = \gamma_1 \mathbf{q} = 1 \times \begin{bmatrix} 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \end{bmatrix}\)
  2. 第二重循环(\(i=0\)):
  • 算标量点积:\(\beta_0 = \rho_0 (\mathbf{y}_0^T \mathbf{r}) = 0.5 \times (2\times 0 + 1\times 0) = 0\)
  • 更新向量 \(\mathbf{r}\):\(\mathbf{r} \leftarrow \mathbf{r} + (\alpha_0 - \beta_0) \mathbf{s}_0 = \begin{bmatrix} 0 \\ 0 \end{bmatrix} + (2 - 0) \begin{bmatrix} 1 \\ 0 \end{bmatrix} = \begin{bmatrix} 2 \\ 0 \end{bmatrix}\)

结果对比:两边算出来的 \(\mathbf{r}\) 都是分毫不差的 \(\begin{bmatrix} 2 \\ 0 \end{bmatrix}\),但方法 B 从头到尾只做了向量点积和向量加减,完全跳过了 \(\mathbf{B}_1\) 矩阵的构造!


六、 为什么这能拯救高维优化?计算与存储账本对比

假设模型参数量 \(N = 10^7\)(一千万参数),L-BFGS 历史窗口取标准值 \(m = 10\):

指标维度 标准 BFGS(显式存 \(\mathbf{B}_k\)) L-BFGS(双循环递归) 节省倍数
需要存储的对象 \(N \times N\) 稠密矩阵 \(\mathbf{B}_k\) \(m\) 对长度为 \(N\) 的向量 \((\mathbf{s}_i, \mathbf{y}_i)\) —
内存占用公式 \(N^2\) 个浮点数 \(2mN\) 个浮点数 \(\frac{N}{2m}\) 倍
\(N=10^7\) 时的实际显存 \(10^{14} \times 4\text{B} \approx \mathbf{400\text{ TB}}\) \(20 \times 10^7 \times 4\text{B} \approx \mathbf{800\text{ MB}}\) 节省 500,000 倍
单步浮点运算次数(FLOPs) 约 \(2N^2\) 次乘加 \(4mN + N\)(第一重循环 \(2mN\) + 缩放 \(N\) + 第二重循环 \(2mN\)) 快 500,000 倍

七、 交互式单步追踪器:可视化 L-BFGS 双循环递归的数据流

为了让你直观感受“洋葱是如何一层层剥开又包上”的,下方的交互式状态机将 \(m=3\) 步历史记录的 L-BFGS 双循环递归拆解成了清晰的执行步骤。你可以点击 “下一步 (Next Step)”,逐步观察指针如何在历史记录缓冲区 \((\mathbf{s}_i, \mathbf{y}_i)\) 上先向后回溯、再向前递推,以及向量 \(\mathbf{q}\)、标量缓存 \(\alpha_i\)、\(\beta_i\) 和最终方向 \(\mathbf{r}\) 的实时数值演化:

工程实现中的关键细节(曲率条件 \(\mathbf{y}_k^T \mathbf{s}_k \gt 0\)):
细看双循环递归公式会发现,每一步都除以了内积 \(\mathbf{y}_k^T \mathbf{s}_k\)(即 \(\rho_k = \frac{1}{\mathbf{y}_k^T \mathbf{s}_k}\))。为了保证隐式构造出的矩阵 \(\mathbf{B}_k\) 严格正定(确保算出来的 \(\mathbf{d}_k = -\mathbf{B}_k \mathbf{g}_k\) 一定是让损失下降的方向,且分母不为零),必须满足 曲率条件(Curvature Condition):\(\mathbf{y}_k^T \mathbf{s}_k \gt 0\)。
在经典优化中,这是通过 Wolfe 线搜索(Line Search) 调节步长来严格保证的;而在无法做精确线搜索的随机梯度场景中,如果某一步算出 \(\mathbf{y}_k^T \mathbf{s}_k \le 0\),工程上会直接跳过(丢弃)这一步的历史记录,或者使用 Powell 阻尼(Damped BFGS)对 \(\mathbf{y}_k\) 进行修正。

posted @ 2026-10-28 23:45  立体风  阅读(18)  评论(0)    收藏  举报