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\):
定义标量 \(\rho_k\) 为这两个向量内积的倒数:
在标准 BFGS 算法中,逆 Hessian 矩阵近似 \(\mathbf{B}_{k+1} \approx \mathbf{H}_{k+1}^{-1}\) 的秩-2(Rank-2)递推更新公式为:
其中辅助矩阵 \(\mathbf{V}_k\) 定义为:
维度灾难的根源:向量外积(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\)):
- 展开 2 步(\(m=2\)):
- 展开任意 \(m\) 步的一般形式:
单独看这个式子似乎更复杂了,但别忘了:我们的目标不是算 \(\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}\):
利用矩阵乘法结合律,把括号移到右边:
关键发现 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}\):
其中缩放因子 \(\gamma_k\) 通常采用 Barzilai-Borwein 公式,用最新一步的曲率来近似全局尺度:
这依然只是两个简单的向量点积!
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{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\) 代入,再次使用乘法结合律:
关键发现 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\) 矩阵
- 构造矩阵 \(\mathbf{V}_0 = \mathbf{I} - \rho_0 \mathbf{y}_0 \mathbf{s}_0^T\):
- 构造完整逆 Hessian 矩阵 \(\mathbf{B}_1 = \mathbf{V}_0^T \mathbf{I} \mathbf{V}_0 + \rho_0 \mathbf{s}_0 \mathbf{s}_0^T\):
- 矩阵乘以梯度向量 \(\mathbf{g}_1 = \begin{bmatrix} 4 \\ 2 \end{bmatrix}\):
方法 B:L-BFGS 双循环递归(全程无矩阵)
- 初始化:\(\mathbf{q} = \mathbf{g}_1 = \begin{bmatrix} 4 \\ 2 \end{bmatrix}\)
- 第一重循环(\(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}\)
- 中间层缩放:\(\mathbf{r} = \gamma_1 \mathbf{q} = 1 \times \begin{bmatrix} 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \end{bmatrix}\)
- 第二重循环(\(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\) 进行修正。

浙公网安备 33010602011771号