L-BFGS优化算法基本原理

L-BFGS优化算法基本原理

L-BFGS优化算法

   一般的机器学习问题往往归结于对一个对数极大似然函数$L(\Lambda )$的优化问题，这里的$\Lambda =({\lambda }_1,\dots ,{\lambda }_n{)}^T$为概率模型中的需要被估计的参数。
  接下来的讨论假设你已经了解牛顿法的基本原理，牛顿法之所以获得了更快的速度，是因为它利用了目标函数的二阶泰勒展开式中的Hessian矩阵。其迭代过程中的更新算法为
$$x_{n+1}=x_n-\alpha {\mathbf{H}}_n^{-1}{\mathbf{g}}_n$$
这里${\mathbf{H}}_n^{-1}$为Hessian矩阵，${\mathbf{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次迭代得到的解，它满足${\mathbf{l}\mathbf{i}\mathbf{m}}_{n\to \infty }{x}_n=x^{\ast }$，$x^{\ast }$为全局最优解。$\Delta x$给出了优化方向，$x_{n+1}=x_n+\Delta x$。为了方便书写，我们引入以下符号
$${\mathbf{g}}_n=\nabla f(x_n)，{\mathbf{H}}_n={\nabla }^{2}f(x_n)，h_{n+1}(x_{n+1})=f(x_{n+1})$$
Secant Condition约束使得上述泰勒展开式对于$x_n$的梯度与$f(x)$对于$x_n$的梯度相等，于是得到如下条件，
$$\begin{gathered} \nabla h_{n+1}(x_{n+1})={\mathbf{g}}_{n+1} \\ \nabla h_n(x_n)={\mathbf{g}}_n \end{gathered}$$
上面两式做差，根据微分中值定理，得到下面的secant condition
$${\mathbf{H}}_{n+1}(x_{n+1}-x_n)={\mathbf{g}}_{n+1}-{\mathbf{g}}_n$$
引入下面的符号，
$$s_{n+1}=x_{n+1}-x_n,y_{n+1}={\mathbf{g}}_{n+1}-{\mathbf{g}}_n$$
于是得到了正割条件的最终形式，避免了对Hessian的求逆操作
$${\mathbf{H}}_{n+1}^{-1}{y}_{n+1}=s_{n+1}$$

对称条件

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

BFGS算法

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

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

L-BFGS算法基本原理

L-BFGS算法即limited BFGS算法（有限内存算法）。我们首先定义一个新的符号，
$${\mathbf{V}}_n=I-{\rho }_n{s}_n{y}_n^T$$
则Hessian的更新表达式可以简化为
$$\begin{array}{rl}{\mathbf{H}}_n^{-1}& ={{\mathbf{V}}_{\mathbf{n}}}^T{\mathbf{H}}_{n-1}^{-1}{\mathbf{V}}_n+{\rho }_n{s}_n{s}_n^T\\ & ={\mathbf{V}}_n^T({\mathbf{V}}_{n-1}^T{\mathbf{H}}_{n-2}^{-1}{\mathbf{V}}_{n-1}+{\rho }_{n-1}{s}_{n-1}{s}_{n-1}^T){\mathbf{V}}_n+{\rho }_n{s}_n{s}_n^T\\ & =\dots \\ & \approx {\mathbf{V}}_n^T\dots {\mathbf{V}}_{n-m+1}^T{\mathbf{H}}_0{\mathbf{V}}_{n-m+1}\dots {\mathbf{V}}_n\\ & +{\rho }_{n-m+1}{\mathbf{V}}_n^T\dots {\mathbf{V}}_{n-m+2}^T{s}_{n-m+2}{s}_{n-m+2}^T{\mathbf{V}}_{n-m+2}\dots {\mathbf{V}}_n\\ & +\cdots +{\rho }_n{s}_n{s}_s^T\end{array}$$
这里初始的Hessian矩阵${\mathbf{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