L-BFGS优化算法基本原理

L-BFGS优化算法

   一般的机器学习问题往往归结于对一个对数极大似然函数 $L(\Lambda)$的优化问题，这里的 $\Lambda = (\lambda_{1}, \dots, \lambda_{n} )^{T}$为概率模型中的需要被估计的参数。
  接下来的讨论假设你已经了解牛顿法的基本原理，牛顿法之所以获得了更快的速度，是因为它利用了目标函数的二阶泰勒展开式中的Hessian矩阵。其迭代过程中的更新算法为
$x_{n+1}=x_{n}-\alpha \bold{H}_{n}^{-1}\bold{g}_{n}$
这里 $\bold{H}_{n}^{-1}$为Hessian矩阵， $\bold{g}_{n}$为梯度向量， $\alpha$为步长。

牛顿法至少存在两个问题，

1. 对于存在梯度的函数来说未必存在Hessian矩阵，或者Hessian矩阵的计算过于复杂。
2. 在机器学习问题中，需要优化的向量 $\Lambda$维度往往达到50000以上，如此存储Hessian矩阵至少需要 $N(N+1)/2$=12亿，且对Hessian求逆矩阵的工作量过于庞大。

  为了解决问题一，数学家们提出了拟牛顿法，基本思路是利用优化过程中的变量自身和它的梯度信息估计Hessian矩阵。首先来看在估计过程中Hessian矩阵必须满足的两个条件。

正割条件(Secant Condition)

  给定凸的目标函数 $f(x)$，其在 $x_{n}$处二阶泰勒近似展开式为
$f(x_{n}+\Delta x) \approx f(x_{n})+\Delta x^T\nabla f(x_{n})+\frac{1}{2}\Delta x^T \nabla ^{2}f(x_{n})\Delta x$
这里的 $x_{n}$表示优化算法第n次迭代得到的解，它满足 $\bold{lim}_{n\rightarrow \infty}x_{n}=x^*$， $x^*$为全局最优解。 $\Delta x$给出了优化方向， $x_{n+1}=x_{n}+\Delta x$。为了方便书写，我们引入以下符号
$\bold{g}_{n}=\nabla f(x_{n})，\bold{H}_{n}=\nabla ^2f(x_{n})，h_{n+1}(x_{n+1})=f(x_{n+1})$
Secant Condition约束使得上述泰勒展开式对于 $x_{n}$的梯度与 $f(x)$对于 $x_{n}$的梯度相等，于是得到如下条件，
$\nabla h_{n+1}(x_{n+1})=\bold{g}_{n+1} \\ \nabla h_{n}(x_{n})=\bold{g}_{n}$
上面两式做差，根据微分中值定理，得到下面的secant condition
$\bold{H}_{n+1}(x_{n+1}-x_{n})=\bold{g}_{n+1}-\bold{g}_{n}$
引入下面的符号，
$s_{n+1}=x_{n+1}-x_{n},y_{n+1}=\bold{g}_{n+1}-\bold{g}_{n}$
于是得到了正割条件的最终形式，避免了对Hessian的求逆操作
$\bold{H}^{-1}_{n+1}y_{n+1}=s_{n+1}$

对称条件

  由二阶偏导数的性质，Hessian矩阵显然要满足对称性，即 $\bold{H}_{n}^{-T}=\bold{H}_{n}$

BFGS算法

  有了上面两个约束条件，我们减少了Hessian矩阵的一些自由度，secant condition提供了N个约束，而确定一个Hessian矩阵需要 $N(N+1)/2$个约束条件，因而我们仍然需要一些条件，于是便有了BFGS算法，B,F,G,S分别为四个数学家名字的首字母，该算法将Hessian矩阵的估计问题转化为约束优化问题，他们假设在迭代过程中，Hessian尽可能的连续变换，即前后两次迭代的Frobenius范数变化不大，数学化的描述如下，
$\min_{\bold{H}^{-1}}||\bold{H}^{-1}-\bold{H}_{n-1}||_{2} \\ \bold{s.t.}\quad \quad \quad \quad \quad \quad \quad \\ \bold{H}^{-1}y_{n}=s_{n}\\ \bold{H}^{-T}=\bold{H}^{-1}$
经过一系列繁琐的求解（以Lagrange乘子法为出发点），得到如下的解，这里不给出证明，有兴趣的读者可以查询相关论文，直接给出求解结果如下
$\bold{H}_{n}^{-1}=\left( I-\rho _{n} y_{n}s_{n}^T \right)\bold{H}_{n-1}^{-1}(I-\rho _{n}s_{n}y_{n}^T)+\rho_{n}s_{n}s_{n}^T$
其中， $\rho_{n}=(s_{n}^Ty_{n})^{-1}$。

  至此，我们解决了Hessian逆矩阵的估计问题，但我们仍然未解决Hessian庞大的内存占用问题，L-BFGS算法在BFGS的基础上解决了BFGS算法的内存占用问题。

L-BFGS算法基本原理

L-BFGS算法即limited BFGS算法（有限内存算法）。我们首先定义一个新的符号，
$\bold{V}_{n}=I-\rho_{n}s_{n}y_{n}^T$
则Hessian的更新表达式可以简化为
$\begin{aligned} \bold{H}_{n}^{-1}&=\bold{V_{n}}^T\bold{H}_{n-1}^{-1}\bold{V}_{n}+\rho_{n}s_{n}s_{n}^T \\ &=\bold{V}_{n}^{T}(\bold{V}_{n-1}^T\bold{H}_{n-2}^{-1}\bold{V}_{n-1}+\rho_{n-1}s_{n-1}s_{n-1}^T)\bold{V}_{n}+\rho_{n}s_{n}s_{n}^T \\ &= \dots \\ &\approx \bold{V}_{n}^T\dots \bold{V}_{n-m+1}^T\bold{H}_{0}\bold{V}_{n-m+1}\dots\bold{V}_{n} \\ &\quad + \rho_{n-m+1}\bold{V}_{n}^T\dots \bold{V}_{n-m+2}^Ts_{n-m+2}s_{n-m+2}^T\bold{V}_{n-m+2}\dots\bold{V}_{n} \\ &\quad + \dots +\rho_{n}s_{n}s_{s}^T \end{aligned}$
这里初始的Hessian矩阵 $\bold{H}_{0}$一般用单位矩阵代替，因此，L-BFGS算法在迭代过程中只需要保存前m次的 $s_{n}$和 $y_{n}$即可，空间复杂度为 $O(mN)$，远小于BFGS算法的 $O(N^2)$。

[参考文档]
[1]: https://www.hankcs.com/ml/l-bfgs.html
[2]: https://www.cnblogs.com/zyfd/p/10120036.html