BFGS算法分析与实现
bfgs算法公式
bfgs算法公式BFGS算法公式引言：BFGS算法是一种用于非线性优化问题的迭代算法，它通过估计目标函数的海森矩阵的逆来逼近最优解。
本文将介绍BFGS算法的公式及其原理，并通过实例说明算法的应用。
一、BFGS算法公式：BFGS算法的迭代公式如下：x(k+1) = x(k) - H(k)∇f(x(k))其中，x(k)表示第k次迭代的变量值，∇f(x(k))表示目标函数f(x)在x(k)处的梯度，H(k)表示近似的海森矩阵的逆。
二、BFGS算法原理：BFGS算法的核心思想是通过逐步逼近目标函数的海森矩阵的逆来求解最优解。
具体步骤如下：1. 初始化：设定初始点x(0)，近似的海森矩阵的逆H(0)。
2. 计算梯度：计算目标函数f(x)在当前点x(k)处的梯度∇f(x(k))。
3. 更新变量：根据BFGS公式，更新变量x(k+1) = x(k) - H(k)∇f(x(k))。
4. 更新海森矩阵逆：根据BFGS公式，更新近似的海森矩阵的逆H(k+1)。
5. 终止条件：判断是否满足终止条件，如目标函数值的变化小于某个阈值或梯度的范数小于某个阈值。
6. 若满足终止条件，则停止迭代，得到近似的最优解；若不满足终止条件，则返回第2步。
三、BFGS算法应用实例：下面通过一个实例来说明BFGS算法的应用。
假设我们要求解目标函数f(x) = x^4 - 3x^3 + 2，在初始点x(0) = 1处开始迭代。
1. 初始化：设定初始点x(0) = 1，近似的海森矩阵的逆H(0) = I（单位矩阵）。
2. 计算梯度：计算目标函数f(x)在当前点x(k)处的梯度∇f(x(k)) = 4x^3 - 9x^2。
3. 更新变量：根据BFGS公式，更新变量x(k+1) = x(k) - H(k)∇f(x(k))，代入上面的梯度，得到x(1) = 1 - I(4*1^3 - 9*1^2) = -4。
4. 更新海森矩阵逆：根据BFGS公式，更新近似的海森矩阵的逆H(k+1)。
L-BFGS算法
一、BFGS算法算法思想如下：Step1 取初始点，初始正定矩阵，允许误差，令；Step2 计算；Step3 计算，使得；Step4 令；Step5 如果，则取为近似最优解；否则转下一步；Step6 计算，，令，转Step2.优点：1、不用直接计算Hessian矩阵；2、通过迭代的方式用一个近似矩阵代替Hessian矩阵的逆矩阵。
缺点：1、矩阵存储量为，因此维度很大时内存不可接受；2、矩阵非稀疏会导致训练速度慢。
二、L-BFGS算法针对BFGS的缺点，主要在于如何合理的估计出一个Hessian矩阵的逆矩阵，L-BFGS的基本思想是只保存最近的m次迭代信息，从而大大降低数据存储空间。
对照BFGS，我重新整理一下用到的公式：于是估计的Hessian矩阵逆矩阵如下：把带入上式，得：假设当前迭代为k，只保存最近的m次迭代信息，（即：从k-m~k-1），依次带入，得到：公式1：算法第二步表明了上面推导的最终目的：找到第k次迭代的可行方向，满足：为了求可行方向p，有下面的:two-loop recursion算法该算法的正确性推导：1、令: ，递归带入q：相应的：2、令：于是:这个two-loop recursion算法的结果和公式1*初始梯度的形式完全一样，这么做的好处是：1、只需要存储、（i=1~m）；2、计算可行方向的时间复杂度从O(n*n)降低到了O(n*m)，当m远小于n时为线性复杂度。
总结L-BFGS算法的步骤如下：Step1: 选初始点，允许误差，存储最近迭代次数m（一般取6）；Step2: ；Step3: 如果则返回最优解，否则转Step4；Step4: 计算本次迭代的可行方向：；Step5: 计算步长，对下面式子进行一维搜索：；Step6: 更新权重x：；Step7: if k > m只保留最近m次的向量对，需要删除()；Step8: 计算并保存：；Step9: 用two-loop recursion算法求得：；k=k+1，转Step3。
BFGS算法分析与实现
BFGS算法分析与实现BFGS（Broyden-Fletcher-Goldfarb-Shanno）算法是用于无约束优化问题的一种逐步逼近最优点的优化算法。
它基于拟牛顿法的思想，在每一步迭代中，通过逼近目标函数的Hessian矩阵来确定方向和步长。
本文将对BFGS算法的原理进行分析，并给出一个简单的实现示例。
BFGS算法的基本思想是通过近似Hessian矩阵来指导方向和步长，从而逐渐逼近最优点。
具体来说，BFGS算法通过不断更新Broyden-Fletcher-Goldfarb-Shanno（BFGS）公式来近似目标函数的Hessian矩阵。
BFGS公式的更新规则是：B_{k+1} = B_k + \frac{s_k s_k^T}{s_k^T y_k} - \frac{B_k y_ky_k^T B_k}{y_k^T B_k y_k}其中，B_{k+1} 是第k+1步的近似Hessian矩阵，B_k 是第k步的近似Hessian矩阵，s_k 是第k步的步向量（即目标函数的负梯度），y_k是第k步步向量的变化量。
1. 初始化目标函数的近似Hessian矩阵 B_02.设定初始点x_03. 计算步向量 s_k = -B_k^{-1} \nabla f(x_k)4.利用线方法确定步长t_k5.计算的下一点x_{k+1}=x_k+t_ks_k6. 计算步向量的变化量 y_k = \nabla f(x_{k+1}) - \nabla f(x_k)7. 更新近似Hessian矩阵 B_{k+1} = B_k + \frac{s_ks_k^T}{s_k^T y_k} - \frac{B_k y_k y_k^T B_k}{y_k^T B_k y_k}8.判断终止条件，如果满足停止条件，则返回近似最优点，否则返回第3步继续迭代。
下面是一个简单的BFGS算法的Python实现示例：```pythonimport numpy as npdef bfgs(f, df, x0, max_iter=1000, tol=1e-6):n = len(x0)B = np.eye(n) # 初始化近似 Hessian 矩阵为单位矩阵x = x0.copyfor k in range(max_iter):g = df(x) # 计算当前点的梯度s = -np.linalg.solve(B, g) # 计算步向量t=1.0#初始化步长while f(x + t * s) > f(x) + 0.5 * t * np.dot(g, s):t*=0.5#采用二分法步长x_new = x + t * s # 计算的下一点y = df(x_new) - g # 计算步向量的变化量if np.linalg.norm(y) < tol: # 判断终止条件return x_newBs = np.dot(B, s)B += np.outer(y, y) / np.dot(y, s) - np.outer(Bs, Bs) / np.dot(Bs, s) # 更新近似Hessian矩阵x = x_newreturn x# 示例：求解无约束最小化问题 min f(x) = x_1^2 + 2*x_2^2f = lambda x: x[0]**2 + 2 * x[1]**2df = lambda x: np.array([2 * x[0], 4 * x[1]])x_opt = bfgs(f, df, np.array([1, 2]))print('Optimal point:', x_opt)print('Optimal value:', f(x_opt))```在这个示例中，我们求解了一个简单的无约束最小化问题。
pytorch 拟牛顿法lbfgs算法
pytorch 拟牛顿法lbfgs算法拟牛顿法是一种优化算法，用于寻找函数的局部最小值。
L-BFGS （Limited-memory Broyden-Fletcher-Goldfarb-Shanno）算法是一种拟牛顿法的变种，特别适用于大规模优化问题，因为它使用有限的内存来近似Hessian矩阵的逆。
在PyTorch中，您可以使用torch.optim.LBFGS优化器来应用L-BFGS算法进行优化。
下面是使用PyTorch的L-BFGS算法的一般步骤：定义要优化的目标函数（损失函数）。
创建一个初始参数向量（或张量）。
创建LBFGS优化器，将目标函数和初始参数向量传递给它。
使用step方法来执行优化步骤，不断迭代直到达到收敛条件。
以下是一个简单的示例：import torchfrom torch.optim import LBFGS# 1. 定义目标函数（这里是一个简单的二次函数）def objective(x):return (x - 2) ** 2# 2. 创建初始参数向量x = torch.tensor([5.0], requires_grad=True)# 3. 创建LBFGS优化器，将目标函数和参数向量传递给它optimizer = LBFGS([x])# 4. 执行优化步骤，直到达到收敛条件def closure():optimizer.zero_grad()loss = objective(x)loss.backward()return lossfor _ in range(100):optimizer.step(closure)print("Optimal x:", x.data)print("Optimal objective value:", objective(x).item()) 在上面的示例中，closure函数用于计算损失并执行反向传播。
无约束最优化问题的BFGS松弛异步并行算法
无约束最优化问题的BFGS松弛异步并行算法李文敬;刘之家;蓝贞雄【摘要】In order to solve the sequential solution speed slow problem of the large-scale non-linearity optimization problems, for solving unconstrained optimization problems, chaotic relaxation asynchronous iterative parallel algorithm is proposed. BFGS sequential algorithm of unconstrained optimization problems are parallelized in the PC cluster environment. It utilizes CHOLESKY method to decompose coefficient to make the linear equation group of matrix for the symmetry. To solve the solution vector and non-linear search step of Wolfe-Powell by chaotic relaxation asynchronous parallel method, it parallels to the revised formula BFGS. The BFGS relaxation asynchronous parallel algorithm is build. Time complexity and speedup of the algorithm are analyzed. The experimental results of PC cluster show that this algorithm better solves the system load unbalanced problem, improves the speed of problem solving, the algorithm has the linear speedup ratio.%为解决大规模非线性最优化问题的串行求解速度慢的问题,提出应用松弛异步并行算法求解无约束最优化问题.根据无约束最优化问题的BFGS串行算法,在PC机群环境下将其并行化.利用CHOLESKY方法分解系数为对称正定矩阵的线性方程组,运用无序松弛异步并行方法求解解向量和Wolfe-Powell非线性搜索步长,并行求解BFGS修正公式,构建BFGS松弛异步并行算法,并对算法的时间复杂性、加速比进行分析.在PC机群的实验结果表明,该算法提高了无约束最优化问题的求解速度且负载均衡,算法具有线性加速比.【期刊名称】《计算机工程与应用》【年(卷),期】2012(048)017【总页数】4页(P44-47)【关键词】最优化问题;BFGS公式;松弛异步;并行算法;加速比【作者】李文敬;刘之家;蓝贞雄【作者单位】广西师范学院计算机与信息工程学院,南宁530023;广西师范学院计算机与信息工程学院,南宁530023;广西师范学院计算机与信息工程学院,南宁530023【正文语种】中文【中图分类】TP393在工农业生产、工程技术、交通运输、生产管理、经济计划、国防、金融等很多实际问题都可以抽象转化成最优化问题。
bfgs 拟牛顿法
bfgs 拟牛顿法BFGS拟牛顿法是一种优化算法，用于求解无约束优化问题。
它是一种拟牛顿法，即它使用拟牛顿矩阵来近似目标函数的海森矩阵。
BFGS算法是由Broyden、Fletcher、Goldfarb和Shanno四位数学家在1970年代初提出的。
BFGS算法的基本思想是通过不断更新拟牛顿矩阵来逼近目标函数的海森矩阵。
具体来说，BFGS算法通过计算两个连续迭代点的梯度差和函数值差来更新拟牛顿矩阵。
这个更新过程可以看作是在拟牛顿矩阵上进行一次修正，使得它更加接近目标函数的海森矩阵。
BFGS算法的优点是收敛速度快，而且不需要计算目标函数的二阶导数。
BFGS算法的具体步骤如下：1. 初始化拟牛顿矩阵B0为单位矩阵，选择初始点x0和容许误差ε。
2. 计算梯度g0=∇f(x0)，如果g0=0，则停止迭代，输出x0为最优解。
3. 计算搜索方向pk=-Bk∇f(xk)，其中Bk为拟牛顿矩阵。
4. 选择步长αk，使得f(xk+αkpk)<f(xk)。
5. 计算xk+1=xk+αkpk。
6. 计算梯度gk+1=∇f(xk+1)。
7. 如果||gk+1||<ε，则停止迭代，输出xk+1为最优解。
8. 计算sk=xk+1-xk，yk=gk+1-gk，计算拟牛顿矩阵Bk+1=Bk+(skBkyskT)/(skTysk)-(BkyskskTBk)/(skTBkysk)。
9. 令k=k+1，返回步骤3。
BFGS算法的收敛性和全局最优性都得到了证明。
但是，BFGS算法的计算复杂度较高，需要存储和更新拟牛顿矩阵，因此在处理大规模问题时可能会遇到困难。
此外，BFGS算法对初始点的选择比较敏感，不同的初始点可能会导致不同的结果。
BFGS算法是一种高效的优化算法，可以用于求解无约束优化问题。
它的收敛速度快，收敛性和全局最优性都得到了证明。
但是，它的计算复杂度较高，需要存储和更新拟牛顿矩阵，因此在处理大规模问题时可能会遇到困难。
l-bfgs算法 python例程
l-bfgs算法 python例程L-BFGS（Limited-Memory Broyden–Fletcher–Goldfarb–Shanno）算法是一种广泛应用于优化问题的迭代算法，尤其在机器学习和数据分析领域。
本篇文章将介绍如何使用Python实现L-BFGS算法。
一、L-BFGS算法原理L-BFGS算法是一种基于坐标下降法的优化算法，通过逐步迭代来逼近函数的最低点。
该算法具有内存限制，因此被称为“有限记忆”算法。
该算法在每次迭代中，通过使用历史信息来更新搜索方向，从而减少搜索次数，提高优化效率。
二、Python实现下面是一个简单的Python实现L-BFGS算法的例程：```pythonimport numpy as npclass LBFGS:def __init__(self, max_iter, alpha, tol):self.max_iter = max_iterself.alpha = alphaself.tol = tolself.x = Noneself.history = []def _update_history(self, grad):self.history.append((grad, self.x))if len(self.history) > self.max_iter:del self.history[0]def _line_search(self, f, grad, x, z, alpha):return -np.dot(grad, z) / np.dot(z, z) - alpha *np.dot(grad, grad) / (np.dot(grad, z) ** 2 + self.alpha *np.linalg.norm(grad) ** 2) * graddef fit(self, f, x, grad):self.x = xself._update_history(grad)for i in range(self.max_iter):old_grad = grad.copy()z = x + np.linalg.inv(np.dot(grad, grad) + self.alpha * np.eye(x.shape[0])).dot(grad)new_grad = np.dot(z, grad) - np.dot(grad, z)if np.linalg.norm(new_grad - old_grad) < self.tol:breakf_new = f(x + new_grad)if f_new - f_old < self.tol:break# 更多实现细节...）））））））））））））））））））））））））））））```。
bfgs算法例题
bfgs算法例题标题：BFBG算法例题在数学和统计学中，BFGS（BFGS算法）是一种广泛应用于优化问题的迭代算法。
这种方法尤其在求解非线性最小二乘问题时非常有效。
下面，我们将通过一个具体的例题来详细介绍BFGS算法的原理和应用。
例题：求解非线性最小二乘问题假设我们有一个非线性最小二乘问题，其目标函数是f(x)=x^TQx+u(x)，其中x是我们要优化的参数向量，Q是x的协方差矩阵，u(x)是我们希望最小化的函数。
我们的任务是找到一组最优参数x，使得f(x)的值最小。
BFGS算法的基本步骤包括以下四个步骤：1.初始化：选择一个初始猜测值x_0。
2.迭代更新：对于每个迭代步骤k，计算一个新的x_k，通过以下公式得到：x_k=x_{k-1}-alpha_k*d_k，其中alpha_k是步长，d_k是最近的梯度估计。
3.梯度估计：在每个迭代步骤k，我们使用BFGS公式来估计梯度d_k=-Q^-1*g，其中g是目标函数的梯度。
4.判断终止条件：如果目标函数的值已经足够接近最优值，或者达到预设的最大迭代次数，就停止迭代并输出当前的参数值x_k。
应用实例考虑一个简单的例题，假设我们要找到一组参数（质量m和距离d），使得一维实验数据能够最好地拟合一条直线。
我们的数据集包含了大量的实验点，并且我们希望找到一条直线，使得这些点与这条直线的距离的平方和最小。
我们使用BFGS算法来解决这个问题。
首先，我们选择一个初始猜测值（例如（m,d）=（1,0）），然后开始迭代更新我们的参数。
在每次迭代中，我们都会使用BFGS公式来估计梯度，并根据这个梯度来更新我们的参数。
当目标函数的值足够接近最优值或者达到预设的最大迭代次数时，我们就停止迭代并输出当前的参数值。
代码实现下面是一个使用Python实现的简单BFGS算法示例代码：```pythonimportnumpyasnp#目标函数和梯度函数deff(x):m,d=xreturnm*d**2+np.exp(-d)#假设数据符合指数分布的直线模型defdf(x):m,d=xreturn2*m*d+np.exp(-d)/np.exp(-d)#假设数据的权重符合指数分布的线性模型defbfgs(data,initial_guess=(1,0)):m,d=initial_guessQ=np.eye(len(data))-np.sum(data,axis=0)/len(data)/data[:,np.newaxis]/data#协方差矩阵近似估计forkinrange(100):#最大迭代次数g=df(m,d)#最近的梯度估计alpha=np.linalg.norm(data-m*d-np.exp(-d)*np.arange(len(data)))/len(data)#步长计算m_new=(df(m+alpha*g)-g)/alpha#BFGS公式计算更新后的质量m' d_new=-Q.T@(Q@g+(m*df(m,d)-g))/alpha#BFGS公式计算更新后的距离d'ifabs(d_new)<1e-6:#判断是否接近最优值或达到最大迭代次数break#停止迭代并输出参数值else:#更新参数值并继续迭代m,d=m_new,d_new#m和d更新为新的参数值returnm,d#返回最优参数值（质量和距离）```这个代码示例展示了如何使用BFGS算法来解决非线性最小二乘问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《最优化方法》课程设计题目：BFGS算法分析与实现院系：数学与计算科学学院专业：统计学姓名学号：左想 **********指导教师：***日期： 2014 年 01 月 22 日摘要在求解无约束最优化问题的众多算法中,拟牛顿法是颇受欢迎的一类算法。
尤其是用于求解中小规模问题时该类算法具有较好的数值效果。
BFGS 算法被认为是数值效果最好的拟牛顿法，其收敛理论的研究也取得了很好的成果. 在一定的条件下，BFGS 算法具有全局收敛性和超线性收敛速度。
然而，对于大规模最优化问题来求解，包括 BFGS 算法在内拟牛顿法具有明显的缺陷。
有许多的例子表明，一旦处理问题很大时，一些对小规模问题非常成功的算法变得毫无吸引力。
究其原因，主要是由于在中小型问题一些不太重要的因素在求解大规模问题时，变得代价很高。
随着速度更快及更复杂的计算机的出现，增强了我们的计算处理能力。
同时也为我们设计算法带来了新的课题。
并行计算机的发展为求解大规模最优化问题提供了一条新途径。
关键词：BFGS 拟牛顿法；无约束最优化问题；大规模问题AbstractQuasi-Newton methods are welcome numerical methods for solving optimization problems. They are particularly effective when applied to solve small or middle size problems. BFGS method is regarded as the most effective quasi-Newton method due toits good numerical perfor mance. It also possesses very good global and superlinear con vergen ceproperties. On the other hand, however, when applied to solve larg escaleproblems, quasi-Newton methods including BFGS method don ot perform well. Themajor drawback for a quasi-Newton method, when used to solve large scaleoptimization problem, is that the matrix gener ated by the method does not retain thesparsity of the Hessian matrix of the objective function. There are examples showing that many success methods for solving small-sized optimization become unattractive once the problem to be tackled is large. An important reason for thisfeature is that some process that is important for small problems may become veryexpensive for large scale problems.The fast development of computer has enhanced our ability to solve large scaleproblems. In particular, the parallel computer provides us a new way to solve largescale problems efficiently. In recent years, there has been growing interest in the studyin parallel methods. It has been found that many good methods that are efficient forsolving small and middle size problems can be parallized.Key Words: BFGS quasi-Newton method; unconstrained optimization problem, large scale problem目录1、引言 ........................................................................................ 错误!未定义书签。
2、BFGS算法及其修正形式 (3)2.1 拟牛顿法 (3)2.2 BFGS算法 (4)2.3 修正形式的BFGS算法 (5)3、BFGS算法对大规模问题研究 (5)4、数值分析 (7)4.1代码实现 (7)4.3 算法测试 (8)4.4结果分析 (8)5、总结 (9)5.1 总结概括 (9)5.2 个人感言 (9)6、参考文献： (10)1 .引言最优化问题在经济计划，生产管理，交通，运输，物理和通信等居多领域有广泛而又深入的应用。
本文主要考察无约束最优化问题。
无约束最优化问题(UC)的数学模型如下:min (),n f x x R ∈ (1.1) 其中:n f R R →是一个连续可微函数.我们用∇ f (x )和 ∇2f (x)分别表示f 在x 处的梯度和 Hessian 阵。
在求解上述无约束最优化问题时，通常采用算法是迭代算法，其迭代格式如下:1k k k k x x d α+=+， (1.2) 其中d k 为搜索方向，一般满足 ∇f (x k )T d k <0，因而d k 是 f (x)在x k 处的一个下降方向。
αk >0称为步长，由线性搜索得到，为简便起见，在整篇文章中，我们分别把∇f (x k )记为g k ， f (x k )记为f k ， f (x ∗)记为f ∗。
上面的迭代法称为下降算法，自上世纪 70 年代以来，下降算法的研究得到了飞速发展。
迄今为止，已提出了许多的下降算法，这些算法具有各自的优缺点。
常用的算法有：最速下降法. 即取d k =−g k 。
该算法的优点是计算简便且存储量小，可用于大规模最优化问题求解。
但该算法仅有线性收敛速度，收敛速度太慢。
牛顿法.即取d k =−∇2f (x k )−1g k 。
其中∇2f (x k )表示f 在x k 处的Hessian 阵。
该算法的优点是收敛速度快，可达到二阶收敛速度，但每次迭代需计算目标函数Hessian 矩阵，计算量大。
拟牛顿法. 即取d k =−H k g k 。
其中H k 是∇2(x k )−1的近似。
拟牛顿法的优点是超线性收敛速度，而且，大多数拟牛顿法可产生下降方向，但拟牛顿法需贮存一个矩阵。
共轭梯度法.即取d k ={−g k ，k =1−g k +βk ∗d k−1，k ≥2(1.3)其中参数βk 的选取依赖于不同的共轭梯度法。
优点在于克服了最速下降法收敛慢的缺点，又避免了存贮和计算牛顿法所需的二阶导数信息。
所以对大规模问题来说，也是一种很不错的算法。
超记忆梯度法. 即取d k ={−g k ，k =1−∑βk−i+1∗g k−i+1m i=1，k ≥2(1.4) 其中当k ≥m 时，βk−i+1=ρm−1∙||g k ||2||g k ||2+|g k T g k−i+1|,(i =1,2,3…m );βk =1−∑βk−i+1m i=2Miele 和 Cantrell 研究了这种记忆梯度法(memory gradient method)。
同时 Cantrell 发现，当用于二次函数极小值问题求解时,记忆梯度法与 Fletcher- -Reeves 算法是一致的.Cragg 和 Levy 进一步地研究了一种超记忆梯度法(super-memory gradient method),实际上是记忆梯度法的一般化.其他有关超记忆梯度法可参考文献[3,4]等。
无论是记忆梯度法还是超记忆梯度法,都比共轭梯度法更为有效,因为它使用了更多的先前迭代信息,并且增加了参数的自由度,但在形式上与共轭梯度法很相似,并且避免了计算与Hessian 阵有关的矩阵,尽管收敛速度不如拟牛顿法,但也适合于大规模稀疏问题的求解。
在选取步长αk 时，通常有如下几种方式：精确搜索: 即αk 满足αk =arg min α>0f (x k +αd k ) (1.5) 此种搜索由于计算量大，所以在实际中很少采用。
非精确搜索:(i) Armijo 搜索:给定 σ∈ (0,1),步长αk 满足下列不等式f (x k +αd k )≤f (x k )+σ∇ f (x k )T d k, (1.6)确定步长αk的一种方式是令其为集合{1,ρ,ρ2,ρ3,… }满足条件(1.6)的最大者。
(ii) Wolfe-Powell 搜索: 即步长同时满足下面的两个不等式:{f(x k+αk d k)≤f(x k)+σ1∇ f(x k)T d k；∇f(x k+αk d k)T d k≥σ2∇ f(x k)T d k，(1.7)其中σ1,σ2为常数,满足0≤σ1≤12,σ1≤σ2≤12. BFGS 算法及其修正形式自上世纪七十年代以来，关于拟 Newton 法的收敛性研究取得了重大进展。
假设目标函数 f(x)是凸的，采用精确线性搜索时，Powell 等证明了 Broyden 族算法具有全局收敛性和超线性收敛速率。
当采用非精确线性搜索时，即Wolfe-Powell准则确定步长，Byrd等在1987年证明了Broyden 族算法(除DFP 算法外)具有全局收敛性。
若假设目标函数是一致凸的，其二阶导数矩阵在极小点附近满足 Lipschitz 条件，且在正定的条件下，还证明了其收敛速度是 Q-超线性的. Bryd 和 Nocedal 证明了采用Armijo 线性搜索时，BFGS 方法的全局收敛性等在文献得出：当目标函数是伪凸函数时，Broyden 算法依然具有全局收敛性.Li 证明了：当目标函数是凸二次函数，DFP 算法仍然具有全局收敛性。
在 2001 年，Li 和 Fukushima 在文献提出了一种求解非凸函数极小值问题的修正拟牛顿法，并证明了修正的拟牛顿法的全局收敛性，并在适当的假设条件下，证明了超线性收敛速率。