一、BFGS算法

在“优化算法——拟牛顿法之BFGS算法”中，我们得到了BFGS算法的校正公式：

$B_{k+1}=B_k-\frac{B_ks_ks_k^TB_k}{s_k^TB_ks_k}+\frac{y_ky_k^T}{y_k^Ts_k}$

利用Sherman-Morrison公式可对上式进行变换，得到

$B_{k+1}^{-1}=\left ( I-\frac{s_ky_k^T}{y_k^Ts_k} \right )^TB_k^{-1}\left ( I-\frac{y_ks_k^T}{y_k^Ts_k} \right )+\frac{s_ks_k^T}{y_k^Ts_k}$

令 $H_{k+1}=B_{k+1}^{-1}$ ，则得到：

$H_{k+1}=\left ( I-\frac{s_ky_k^T}{y_k^Ts_k} \right )^TH_k\left ( I-\frac{y_ks_k^T}{y_k^Ts_k} \right )+\frac{s_ks_k^T}{y_k^Ts_k}$

二、BGFS算法存在的问题

在BFGS算法中，每次都要存储近似Hesse矩阵 $B_k^{-1}$ ，在高维数据时，存储 $B_k^{-1}$ 浪费很多的存储空间，而在实际的运算过程中，我们需要的是搜索方向，因此出现了L-BFGS算法，是对BFGS算法的一种改进算法。在L-BFGS算法中，只保存最近的 $m$ 次迭代信息，以降低数据的存储空间。

三、L-BFGS算法思路

令 $\rho _k=\frac{1}{y_k^Ts_k}$ ， $V_k=I-\frac{y_ks_k^T}{y_k^Ts_k}$ ，则BFGS算法中的 $H_{k+1}$ 可以表示为：

$H_{k+1}=V_k^TH_kV_k+\rho _ks_ks_k^T$

若在初始时，假定初始的矩阵 $H_0=I$ ，则我们可以得到：

$H_{1}=V_0^TH_0V_0+\rho _0s_0s_0^T$

$\begin{align*} H_2 &= V_1^TH_1V_1+\rho _1s_1s_1^T\\ &= V_1^T\left ( V_0^TH_0V_0+\rho _0s_0s_0^T \right )V_1+\rho _1s_1s_1^T\\ &= V_1^TV_0^TH_0V_0V_1+V_1^T\rho _0s_0s_0^TV_1+\rho _1s_1s_1^T \end{align*}$

$\cdots$

$\begin{align*} H_{k+1} &= \left ( V_k^TV_{k-1}^T\cdots V_1^TV_0^T \right )H_0\left ( V_0V_1\cdots V_{k-1}V_k \right )\\ &+ \left ( V_k^TV_{k-1}^T\cdots V_1^T \right )\rho _1s_1s_1^T\left ( V_1\cdots V_{k-1}V_k \right )\\ &+ \cdots \\ &+ V_k^T\rho _{k-1}s_{k-1}s_{k-1}^TV_k\\ &+ \rho _ks_ks_k^T \end{align*}$

若此时，只保留最近的 $m$ 步：

$\begin{align*} H_{k+1} &= \left ( V_k^TV_{k-1}^T\cdots V_{k-m}^T \right )H_0\left ( V_{k-m}\cdots V_{k-1}V_k \right )\\ &+ \left ( V_k^TV_{k-1}^T\cdots V_{k-m}^T \right )\rho _1s_1s_1^T\left ( V_{k-m}\cdots V_{k-1}V_k \right )\\ &+ \cdots \\ &+ V_k^T\rho _{k-1}s_{k-1}s_{k-1}^TV_k\\ &+ \rho _ks_ks_k^T \end{align*}$

这样在L-BFGS算法中，不再保存完整的 $H_k$ ，而是存储向量序列 $\left \{ s_k \right \}$ 和 $\left \{ y_k \right \}$ ，需要矩阵 $H_k$ 时，使用向量序列 $\left \{ s_k \right \}$ 和 $\left \{ y_k \right \}$ 计算就可以得到，而向量序列 $\left \{ s_k \right \}$ 和 $\left \{ y_k \right \}$ 也不是所有都要保存，只要保存最新的 $m$ 步向量即可。

四、L-BFGS算法中的方向的计算方法

五、实验仿真

lbfgs.py

#coding:UTF-8from numpy import *
from function import *def lbfgs(fun, gfun, x0):result = []#保留最终的结果maxk = 500#最大的迭代次数rho = 0.55sigma = 0.4H0 = eye(shape(x0)[0])#s和y用于保存最近m个，这里m取6s = []y = []m = 6k = 1gk = mat(gfun(x0))#计算梯度dk = -H0 * gkwhile (k < maxk):             n = 0mk = 0gk = mat(gfun(x0))#计算梯度while (n < 20):newf = fun(x0 + rho ** n * dk)oldf = fun(x0)if (newf < oldf + sigma * (rho ** n) * (gk.T * dk)[0, 0]):mk = nbreakn = n + 1#LBFGS校正x = x0 + rho ** mk * dk#print x#保留m个if k > m:s.pop(0)y.pop(0)#计算最新的sk = x - x0yk = gfun(x) - gks.append(sk)y.append(yk)#two-loop的过程t = len(s)qk = gfun(x)a = []for i in xrange(t):alpha = (s[t - i - 1].T * qk) / (y[t - i - 1].T * s[t - i - 1])qk = qk - alpha[0, 0] * y[t - i - 1]a.append(alpha[0, 0])r = H0 * qkfor i in xrange(t):beta = (y[i].T * r) / (y[i].T * s[i])r = r + s[i] * (a[t - i - 1] - beta[0, 0])if (yk.T * sk > 0):dk = -r            k = k + 1x0 = xresult.append(fun(x0))return result

function.py

#coding:UTF-8
'''
Created on 2015年5月19日@author: zhaozhiyong
'''from numpy import *#fun
def fun(x):return 100 * (x[0,0] ** 2 - x[1,0]) ** 2 + (x[0,0] - 1) ** 2#gfun
def gfun(x):result = zeros((2, 1))result[0, 0] = 400 * x[0,0] * (x[0,0] ** 2 - x[1,0]) + 2 * (x[0,0] - 1)result[1, 0] = -200 * (x[0,0] ** 2 - x[1,0])return result

testLBFGS.py

#coding:UTF-8
'''
Created on 2015年6月6日@author: zhaozhiyong
'''from lbfgs import *import matplotlib.pyplot as plt  x0 = mat([[-1.2], [1]])
result = lbfgs(fun, gfun, x0)
print resultn = len(result)
ax = plt.figure().add_subplot(111)
x = arange(0, n, 1)
y = result
ax.plot(x,y)plt.show()

实验结果

参考文献

libLBFGS: a library of Limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS)

优化算法——拟牛顿法之L-BFGS算法相关推荐

l bfgs算法java代码_优化算法——拟牛顿法之L-BFGS算法
一.BFGS算法 BFGS算法的校正公式: 利用Sherman-Morrison公式可对上式进行变换,得到令 ,则得到: 二.BGFS算法存在的问题在BFGS算法中.每次都要存储近似Hesse矩阵 ...
拟牛顿法/Quasi-Newton，DFP算法/Davidon-Fletcher-Powell，及BFGS算法/Broyden-Fletcher-Goldfarb-Shanno...
拟牛顿法/Quasi-Newton,DFP算法/Davidon-Fletcher-Powell,及BFGS算法/Broyden-Fletcher-Goldfarb-Shanno 转载须注明出处:htt ...
l bfgs算法java代码_数值优化：理解L-BFGS算法
译自<Numerical Optimization: Understanding L-BFGS>,本来只想作为学习CRF的补充材料,读完后发现收获很多,把许多以前零散的知识点都串起来了.对 ...
l bfgs算法java代码_L-BFGS算法介绍
本文由作者林洋港授权网易云社区发布. 一. L-BFGS是什么 L-BFGS是解无约束非线性规划问题最常用的方法,具有收敛速度快.内存开销少等优点,在机器学习各类算法中常有它的身影.简单的说,L-BF ...
l bfgs算法java代码_理解L-BFGS算法
理解L-BFGS算法 Mar 30, 2015 #数值优化 #无约束最优化 L-BFGS(Limited-Memory BFGS)是BFGS算法在受限内存时的一种近似算法,而BFGS是数学优化中 ...
L-BFGS算法/Broyden族/BFGS算法/阻尼牛顿法的Python实现代码
下面定义了三个Python语言编写的函数:函数表达式fun,梯度向量gfun,和海森矩阵hess.这三个表达式在后面各个算法的实现中会用到. # 函数表达式fun fun = lambda x:100 ...
bfgs算法 matlab,BFGS算法的最优化问题及在MATLAB中的实现
BFGS算法的最优化问题及在MATLAB中的实现对拟牛顿方法中的BFGS算法进行阐述,基于matlab软件对非线性无约束优化问题进行了仿真研究,结果表明利用matlab软件解答非线性无约束优化问题获 ...
BFGS算法及其matlab实现
目录一.前沿二.基本思想三.秩2校正公式四.算法步骤五.matlab程序实现一.前沿上一篇文章介绍了基于秩1的拟牛顿算法,紧接上文,这次我们介绍关于秩2的拟牛顿算法,即BFGS算法.为啥 ...
优化算法——拟牛顿法之BFGS算法
一.BFGS算法简介 BFGS算法是使用较多的一种拟牛顿方法,是由Broyden,Fletcher,Goldfarb,Shanno四个人分别提出的,故称为BFGS校正. 同DFP校正的推导公式一样,D ...

优化算法——拟牛顿法之L-BFGS算法