精华内容
下载资源
问答
  • 共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的...

    共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的方法之一,也是解大型非线性最优化最有效的算法之一。 在各种优化算法中,共轭梯度法是非常重要的一种。其优点是所需存储量小,具有步收敛性,稳定性高,而且不需要任何外来参数。

    算法步骤:

    import random

    import numpy as np

    import matplotlib.pyplot as plt

    def goldsteinsearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d,t试探系数>1,

    '''

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def Wolfesearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d

    σ∈(ρ,1)=0.75

    '''

    sigma=0.75

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    # if abs(np.dot(df(x + alpha * d),d))<=-sigma*dphi0:

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def frcg(fun,gfun,x0):

    # x0是初始点,fun和gfun分别是目标函数和梯度

    # x,val分别是近似最优点和最优值,k是迭代次数

    # dk是搜索方向,gk是梯度方向

    # epsilon是预设精度,np.linalg.norm(gk)求取向量的二范数

    maxk = 5000

    rho = 0.6

    sigma = 0.4

    k = 0

    epsilon = 1e-5

    n = np.shape(x0)[0]

    itern = 0

    W = np.zeros((2, 20000))

    f = open("共轭.txt", 'w')

    while k < maxk:

    W[:, k] = x0

    gk = gfun(x0)

    itern += 1

    itern %= n

    if itern == 1:

    dk = -gk

    else:

    beta = 1.0 * np.dot(gk, gk) / np.dot(g0, g0)

    dk = -gk + beta * d0

    gd = np.dot(gk, dk)

    if gd >= 0.0:

    dk = -gk

    if np.linalg.norm(gk) < epsilon:

    break

    alpha=goldsteinsearch(fun,gfun,dk,x0,1,0.1,2)

    # alpha=Wolfesearch(fun,gfun,dk,x0,1,0.1,2)

    x0+=alpha*dk

    f.write(str(k)+' '+str(np.linalg.norm(gk))+"\n")

    print(k,alpha)

    g0 = gk

    d0 = dk

    k += 1

    W = W[:, 0:k+1] # 记录迭代点

    return [x0, fun(x0), k,W]

    def fun(x):

    return 100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0]) ** 2

    def gfun(x):

    return np.array([-400 * x[0] * (x[1] - x[0] ** 2) - 2 * (1 - x[0]), 200 * (x[1] - x[0] ** 2)])

    if __name__=="__main__":

    X1 = np.arange(-1.5, 1.5 + 0.05, 0.05)

    X2 = np.arange(-3.5, 4 + 0.05, 0.05)

    [x1, x2] = np.meshgrid(X1, X2)

    f = 100 * (x2 - x1 ** 2) ** 2 + (1 - x1) ** 2 # 给定的函数

    plt.contour(x1, x2, f, 20) # 画出函数的20条轮廓线

    x0 = np.array([-1.2, 1])

    x=frcg(fun,gfun,x0)

    print(x[0],x[2])

    # [1.00318532 1.00639618]

    W=x[3]

    # print(W[:, :])

    plt.plot(W[0, :], W[1, :], 'g*-') # 画出迭代点收敛的轨迹

    plt.show()

    代码中求最优步长用得是goldsteinsearch方法,另外的Wolfesearch是试验的部分,在本段程序中不起作用。

    迭代轨迹:

    三种最优化方法的迭代次数对比:

    最优化方法

    最速下降法

    共轭梯度法

    牛顿法

    迭代次数

    1702

    240

    5

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

    本文标题: python实现共轭梯度法

    本文地址: http://www.cppcns.com/jiaoben/python/264414.html

    展开全文
  • 共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的...

    共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的方法之一,也是解大型非线性最优化最有效的算法之一。 在各种优化算法中,共轭梯度法是非常重要的一种。其优点是所需存储量小,具有步收敛性,稳定性高,而且不需要任何外来参数。

    算法步骤:

    import random

    import numpy as np

    import matplotlib.pyplot as plt

    def goldsteinsearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d,t试探系数>1,

    '''

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def Wolfesearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d

    σ∈(ρ,1)=0.75

    '''

    sigma=0.75

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    # if abs(np.dot(df(x + alpha * d),d))<=-sigma*dphi0:

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def frcg(fun,gfun,x0):

    # x0是初始点,fun和gfun分别是目标函数和梯度

    # x,val分别是近似最优点和最优值,k是迭代次数

    # dk是搜索方向,gk是梯度方向

    # epsilon是预设精度,np.linalg.norm(gk)求取向量的二范数

    maxk = 5000

    rho = 0.6

    sigma = 0.4

    k = 0

    epsilon = 1e-5

    n = np.shape(x0)[0]

    itern = 0

    W = np.zeros((2, 20000))

    f = open("共轭.txt", 'w')

    while k < maxk:

    W[:, k] = x0

    gk = gfun(x0)

    itern += 1

    itern %= n

    if itern == 1:

    dk = -gk

    else:

    beta = 1.0 * np.dot(gk, gk) / np.dot(g0, g0)

    dk = -gk + beta * d0

    gd = np.dot(gk, dk)

    if gd >= 0.0:

    dk = -gk

    if np.linalg.norm(gk) < epsilon:

    break

    alpha=goldsteinsearch(fun,gfun,dk,x0,1,0.1,2)

    # alpha=Wolfesearch(fun,gfun,dk,x0,1,0.1,2)

    x0+=alpha*dk

    f.write(str(k)+' '+str(np.linalg.norm(gk))+"\n")

    print(k,alpha)

    g0 = gk

    d0 = dk

    k += 1

    W = W[:, 0:k+1] # 记录迭代点

    return [x0, fun(x0), k,W]

    def fun(x):

    return 100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0]) ** 2

    def gfun(x):

    return np.array([-400 * x[0] * (x[1] - x[0] ** 2) - 2 * (1 - x[0]), 200 * (x[1] - x[0] ** 2)])

    if __name__=="__main__":

    X1 = np.arange(-1.5, 1.5 + 0.05, 0.05)

    X2 = np.arange(-3.5, 4 + 0.05, 0.05)

    [x1, x2] = np.meshgrid(X1, X2)

    f = 100 * (x2 - x1 ** 2) ** 2 + (1 - x1) ** 2 # 给定的函数

    plt.contour(x1, x2, f, 20) # 画出函数的20条轮廓线

    x0 = np.array([-1.2, 1])

    x=frcg(fun,gfun,x0)

    print(x[0],x[2])

    # [1.00318532 1.00639618]

    W=x[3]

    # print(W[:, :])

    plt.plot(W[0, :], W[1, :], 'g*-') # 画出迭代点收敛的轨迹

    plt.show()

    代码中求最优步长用得是goldsteinsearch方法,另外的Wolfesearch是试验的部分,在本段程序中不起作用。

    迭代轨迹:

    三种最优化方法的迭代次数对比:

    最优化方法

    最速下降法

    共轭梯度法

    牛顿法

    迭代次数

    1702

    240

    5

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • python实现共轭梯度法

    2021-01-20 06:05:02
    共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的...
  • 上篇文章介绍了线性共轭梯度法。简单回顾一下,线性共轭梯度法是一种不需要矩阵求逆或矩阵分解,以迭代的方式求解线性方程的方法,而且可以保证在N次迭代内收敛,其中N是变量的维度。对于维度较大的问题,辅以良好的...

    上篇文章介绍了线性共轭梯度法。简单回顾一下,线性共轭梯度法是一种不需要矩阵求逆或矩阵分解,以迭代的方式求解线性方程的方法,而且可以保证在N次迭代内收敛,其中N是变量的维度。对于维度较大的问题,辅以良好的预处理步骤,算法可以在很少的步数内收敛,得到一个比较好的近似解。

    在线性共轭梯度法提出约10年后,Fletcher和Reeves将其推广到非线性优化问题中,称为非线性共轭梯度法。这种新方法可以替代之前讲过的线搜索和信赖域方法,并且仍然在高维度问题中展现出非凡的性能。

    Fletcher-Reeves CG

    我们把Fletcher和Reeves最早提出的非线性共轭梯度法称为Fletcher-Reeves CG(FR-CG)算法。按照惯例,我们应该先介绍该方法提出的动机,并一步步推导其计算公式。但据我所知,FR-CG似乎不是从某个目标推导出来的,而是直接在CG(线性共轭梯度法)上改进而来的。直接替换CG算法中某些值的计算方法,如下所示

    与共轭梯度法(一):线性共轭梯度中的式(5.23)相比,只修改了两处。一是计算

    的方式,用线搜索(一):步长的选取中介绍的线搜索算法来搜索
    方向上可接受的步长。之所以这样做,是因为在非线性问题中,我们已经无从构造一组共轭向量了,而且也不可能保证N次迭代内收敛。FR-CG更像是一种线搜索方法,通过所谓共轭梯度的方式计算优化方向,然后用步长搜索算法计算一个可接受的步长。二是用梯度
    替代残差
    ,因为在CG中,残差恰好就是梯度,这里只不过将其推广而已。换句话说,式(5.40)不过是CG推广到普通非线性函数后的结果,CG则是其在二次函数下的特例。

    不过,强行推广到普通非线性函数就能奏效吗?那可未必。首先,我们要确认式(5.40)的每次迭代都能生成使得目标函数下降的方向。其次,我们还要探究该方法是否能保证全局收敛。

    第一个问题等价于证明

    ,我们代入式(5.40)的第4行,得到

    如果第

    次迭代求得了确切解,即
    方向上的最优步长,那么下一次迭代的梯度方向一定与上次迭代方向垂直,即
    ,于是
    成立。但是,确切解是不可能的,我们无法对普通的非线性函数求某个方向的极值,时间上也不允许,只能用前面提到的线搜索算法来搜索一个可接受的步长。所以式(5.41)中的
    很可能大于
    ,从而无法保证
    。不过,虽然线搜索无法找到确切最优解,我们仍可以把搜索的结果限制在可接受的范围内。在线搜索那篇文章中,我们讲解了Goldstein conditions和Wolfe conditions,它们用来限制搜索的区域。如果我们把后者的约束变得再严格一些,可以得到下面的strong Wolfe conditions

    它要求函数值有充分的下降,并要求导数的绝对值不要过大。可以证明,当常数因子满足

    时,
    一定成立。证明方式是数学归纳法,先验证
    成立。然后假设
    成立,再借助式(5.42)的第二行,可以推导出
    也成立。(证明过程略。)好在线搜索算法一般都在strong Wolfe conditions下进行,所以这个要求很容易满足。

    第二个问题,关于收敛性,则有更多值得讨论的地方。

    收敛性分析

    先从直观上感受FR-CG方法的收敛性能。想象非线性目标函数

    ,如果在非常接近极小值点的区域,
    恰好是一个严格的凸二次函数。那么我们就可以期待,在该区域内,算法能够像线性共轭梯度法一样在N次迭代内收敛。

    但是,注意到CG有效的一个前提是,初始方向必须是最速下降方向,这在FR-CG的迭代过程中是无法保证的。这时,我们需要一种称为重新启动(restart)的策略,让FR-CG每N次迭代后都从最速下降方向重新开始,具体操作是直接令

    。这样一来,一旦进入凸二次函数的区域,迟早会有一次重新启动,接下来收敛速度就非常快了。

    不过,由于FR-CG是用线搜索的方式计算步长

    ,因此即使进入凸二次函数区域,也不一定搜索出最优步长,这就违反了CG方法的要求。回顾线搜索那篇文章的最后一节,我们提到了用插值的方式加速线搜索。现在,我们会发现这一策略用在FR-CG上简直完美,一旦进入凸二次函数区域,二次插值的结果就会完全吻合原目标函数,直接就能求出最优步长。

    事实上,添加了重新启动策略的FR-CG方法,具有n-step意义上的二次收敛性质,即

    可以理解为,如果把每N次迭代合并为一次,得到的序列就是二次收敛的。

    此时,另一个问题出现了。每N次迭代进行一次重新启动并不一定是最优方案,当N特别大时,我们其实期望整个算法在远小于N次迭代时就收敛,所以重新启动可能永远不会执行。这种情况下,可以采用更灵活的重新启动策略,比如,当

    时,意味着连续两次迭代的梯度方向不垂直。但我们知道,线性共轭梯度法中,任意两次迭代的梯度都应该是垂直的,此时方可获得最快的收敛速度。因此,如果它们不垂直,就说明收敛速度慢下来了,需要重新启动。

    现在回归主题,既然是收敛性分析,就需要研究FR-CG是否具有全局收敛性。

    在线搜索的收敛性分析中提到过,当目标函数

    满足Lipschitz continuous性质,且线搜索步长满足Wolfe conditions时,下式成立

    我们知道,全局收敛的条件是

    ,要想满足该条件,需要
    。一个典型的例子是最速下降法中
    恒成立,因此最速下降法全局收敛。而在FR-CG中,每次重新启动也是满足
    的,所以所有重新启动对应的
    组成的序列满足
    。这意味着梯度的某个子序列是全局收敛的,即

    这里极限运算符中的

    表示取整个序列中极限值最小的那个子序列。这是一种打了折的全局收敛性,虽然不是严格意义上的全局收敛,但也不错。

    不过,如果没有重新启动呢,纯粹的FR-CG是否具有全局收敛性?答案是有的,可以通过反证法证明。假设

    ,利用strong Wolfe conditions,式(5.42)的第二行,可以推导出与假设相反的矛盾,详细过程本文就不讲了,需要的同学可以参考原书。

    缺陷与改进

    如果实际中使用FR-CG,会发现它收敛得很慢,而且有时会在很小的区域内停滞不前。这是因为其固有的一个缺陷,当某次迭代计算出的方向

    较差时,比如与梯度方向相差90°,线搜索的结果是一个极小的步长,这是显然的,因为
    恰好是函数
    的等高线方向。我们接下来看看此时会发生什么。

    在本文第一段的最后,我们简要提到了可以用数学归纳法证明

    。事实上,这部分证明的结果不只如此,完整的结论是

    其中

    。借助这个结果,我们继续证明刚才的问题。对上式左右同时乘上
    ,并带入
    的定义,得到

    其中,

    。回到最初的假设,一旦当前的
    相差90°,即
    ,就会导致式(5.52)的左右两端的值都是0,这意味着
    。另外,由于
    很小,迭代前后变量值基本不变,即
    ,于是迭代前后的梯度值也基本不变,即
    。由式(5.40)第三行可知,
    ,再由式(5.40)第四行可得,

    这一结果说明,从第

    次开始的每次迭代,都会前进一个相同且非常小的步长,相当于在做无用功。这也是导致FR-CG方法收敛慢的罪魁祸首。不过,既然找到了原因,自然可以想到改进方案。当出现这种情况的时候,让算法做一次重新启动,强行让迭代方向与梯度方向垂直,就可以避开这种无畏的消耗了。这一思想有个更直接的名称,PR-CG。

    Polak-Ribière CG

    PR-CG是FR-CG的一种改进,由Polak和Ribière提出,与FR-CG的唯一区别在于如何选取

    。选取方法为

    在凸二次函数情况下,

    是一样的,因为
    。但对于普通非线性函数,当出现上一节介绍的停滞不前的状况时,可以发现
    ,这恰好就相当于一次重新启动。所以PR-CG用改进
    计算公式的方式解决了FR-CG收敛慢的问题。

    但PR-CG也不是没有缺点,

    的定义会导致其不满足全局收敛性。更具体地,会使得某些迭代产生小于
    ,进而使得新的
    不再是下降方向。好在解决方法也很简单,用

    替代

    。这样做的意义是,当出现无法使得目标函数下降的方向时,执行重新启动策略。这种方法称为PR+-CG。

    总结

    本文介绍了非线性共轭梯度法中的FR-CG、PR-CG和PR+-CG三种方法。它们都源自于线性共轭梯度法,只不过修改了残差的计算方式和步长的确定方式,以适应任意的非线性目标函数。为了确保全局收敛性,选择在合适的时机使用重新启动策略非常重要,也是PR-CG和PR+-CG设计的初衷。

    至此,数值最优化系列文章已经推出了八篇,从宏观的层面上介绍了线搜索、信赖域和共轭梯度的整体思想和算法流程。从下篇文章开始,我们会进一步深入细节,探究各种方法的具体实现细节以及针对实际情况的改进。

    上一篇:共轭梯度法(一):线性共轭梯度
    下一篇:牛顿法进阶
    展开全文
  • 共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的...

    共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的方法之一,也是解大型非线性最优化最有效的算法之一。 在各种优化算法中,共轭梯度法是非常重要的一种。其优点是所需存储量小,具有步收敛性,稳定性高,而且不需要任何外来参数。

    算法步骤:

    import random

    import numpy as np

    import matplotlib.pyplot as plt

    def goldsteinsearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d,t试探系数>1,

    '''

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def Wolfesearch(f,df,d,x,alpham,rho,t):

    '''

    线性搜索子函数

    数f,导数df,当前迭代点x和当前搜索方向d

    σ∈(ρ,1)=0.75

    '''

    sigma=0.75

    flag = 0

    a = 0

    b = alpham

    fk = f(x)

    gk = df(x)

    phi0 = fk

    dphi0 = np.dot(gk, d)

    alpha=b*random.uniform(0,1)

    while(flag==0):

    newfk = f(x + alpha * d)

    phi = newfk

    # print(phi,phi0,rho,alpha ,dphi0)

    if (phi - phi0 )<= (rho * alpha * dphi0):

    # if abs(np.dot(df(x + alpha * d),d))<=-sigma*dphi0:

    if (phi - phi0) >= ((1 - rho) * alpha * dphi0):

    flag = 1

    else:

    a = alpha

    b = b

    if (b < alpham):

    alpha = (a + b) / 2

    else:

    alpha = t * alpha

    else:

    a = a

    b = alpha

    alpha = (a + b) / 2

    return alpha

    def frcg(fun,gfun,x0):

    # x0是初始点,fun和gfun分别是目标函数和梯度

    # x,val分别是近似最优点和最优值,k是迭代次数

    # dk是搜索方向,gk是梯度方向

    # epsilon是预设精度,np.linalg.norm(gk)求取向量的二范数

    maxk = 5000

    rho = 0.6

    sigma = 0.4

    k = 0

    epsilon = 1e-5

    n = np.shape(x0)[0]

    itern = 0

    W = np.zeros((2, 20000))

    f = open("共轭.txt", 'w')

    while k < maxk:

    W[:, k] = x0

    gk = gfun(x0)

    itern += 1

    itern %= n

    if itern == 1:

    dk = -gk

    else:

    beta = 1.0 * np.dot(gk, gk) / np.dot(g0, g0)

    dk = -gk + beta * d0

    gd = np.dot(gk, dk)

    if gd >= 0.0:

    dk = -gk

    if np.linalg.norm(gk) < epsilon:

    break

    alpha=goldsteinsearch(fun,gfun,dk,x0,1,0.1,2)

    # alpha=Wolfesearch(fun,gfun,dk,x0,1,0.1,2)

    x0+=alpha*dk

    f.write(str(k)+' '+str(np.linalg.norm(gk))+"\n")

    print(k,alpha)

    g0 = gk

    d0 = dk

    k += 1

    W = W[:, 0:k+1] # 记录迭代点

    return [x0, fun(x0), k,W]

    def fun(x):

    return 100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0]) ** 2

    def gfun(x):

    return np.array([-400 * x[0] * (x[1] - x[0] ** 2) - 2 * (1 - x[0]), 200 * (x[1] - x[0] ** 2)])

    if __name__=="__main__":

    X1 = np.arange(-1.5, 1.5 + 0.05, 0.05)

    X2 = np.arange(-3.5, 4 + 0.05, 0.05)

    [x1, x2] = np.meshgrid(X1, X2)

    f = 100 * (x2 - x1 ** 2) ** 2 + (1 - x1) ** 2 # 给定的函数

    plt.contour(x1, x2, f, 20) # 画出函数的20条轮廓线

    x0 = np.array([-1.2, 1])

    x=frcg(fun,gfun,x0)

    print(x[0],x[2])

    # [1.00318532 1.00639618]

    W=x[3]

    # print(W[:, :])

    plt.plot(W[0, :], W[1, :], 'g*-') # 画出迭代点收敛的轨迹

    plt.show()

    代码中求最优步长用得是goldsteinsearch方法,另外的Wolfesearch是试验的部分,在本段程序中不起作用。

    迭代轨迹:

    三种最优化方法的迭代次数对比:

    最优化方法

    最速下降法

    共轭梯度法

    牛顿法

    迭代次数

    1702

    240

    5

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • MATLAB - 共轭梯度法

    千次阅读 2019-10-07 10:25:29
    一、问题描述 求解系数矩阵A是对称正定矩阵的线性方程组或求解二次函数的极... 共轭梯度法步骤如下: 1 任意给定初始点及精度 2 3 对于,作 1) 2) 3),或 4) 若或,则输出,,取作为的解,否则 ...
  • 学会不同搜索法(最速下降法,共轭梯度法,牛顿法,拟牛顿法)的计算步骤; 比较不同搜索法(最速下降法,共轭梯度法,牛顿法,拟牛顿法)的优缺点
  • 最优化方法——最速下降法,阻尼牛顿法,共轭梯度法 目录 最优化方法——最速下降法,阻尼牛顿法,共轭梯度法 1、不精确一维搜素 1.1 Wolfe-Powell 准则 2、不精确一维搜索算法计算步骤 3、最速下降法 3.1 ...
  • 第十三课 稳定双共轭梯度法(BiCGSTAB)解方程 非对称方程 前面的方法只使用于方程是对称排列的情况,对于非对称排列的情况,只需要在之前的基础上做一些改进。尽管最终方法的编程相对简单,但完整的数学推理也很复杂...
  • 参考资料《精通MATLAB最优化计算(第二版)》编程工具Matlab 2019a目录石中居士:最优化计算与Matlab实现——目录​zhuanlan.zhihu....算法用共轭梯度法求无约束多维极值问题 的算法步骤如下:【1】给定初始点 ,及...
  • 在这里,共轭梯度法用于解决基于模型的改进的最优控制问题,其中反复使用所用模型的最优解,然后在每个迭代步骤中更新调整后的参数。 当达到收敛时,尽管模型与现实之间存在差异,但迭代解决方案仍将逼近原始最优...
  • 算法步骤 初始化,x(k)表示第k次迭代的解向量。p(k)表示第k次迭代的方向向量。r(k)表示第k次迭代的残差向量。 进入迭代,计算残差向量 计算方向向量 计算步长 更新解向量 Matlab代码: A=[4 1 4 6 7;1 3 2 5 8...
  • Mahout 系列之----共轭梯度

    千次阅读 2013-11-08 17:58:41
    要求解线性方程组 ,稳定双共轭梯度法从初始解 开始按以下步骤迭代: 任意选择向量 使得 ,例如, 对 若 足够精确则退出 预处理共轭梯度 预处理通常被用来加速迭代方法...
  •   此次实验要求采用共轭梯度下降来解决二次优化问题,在解决此问题前,首先分析下什么是共轭梯度法共轭梯度法能解决什么问题。   我们来看一个线性方程组Ax=b,求解此方程组的过程可以看成是形如公式(1)的优化...
  • 八、最优化解决非线性无约束问题—最速下降、牛顿、FR共轭梯度 1.最优化理论 未完待续 2.最速下降 求解步骤 最速下降程序图 3.牛顿迭代 为加快收敛速度,我们考虑利用目标函数f(x)在迭代点x(k) 处的...
  • 这里记录一下共轭梯度法,一直想了解这个算法 但是网上搜了很多东西写的都没法看 看来以后想学什么还是直接去看英文原版比较好 这个共轭梯度最初的提出是用来解线性方程组的,这里先介绍解方程组的步骤 求解...
  • An overview of gradient descent optimization algorithms​ruder.io共轭梯度法通俗讲义 | 断鸿声里,立尽斜阳​flat2010.github.ioCG 和 PCG 算法实现和分析​blog.genkun.me以下内容转载自:批量梯度下降(BGD)、...
  • 1 无约束优化算法思路 2 无约束优化的几种方法 2.1 最速下降法(梯度法) ...注意:共轭方向法仅仅是一种思想,其思想描述如下,由此衍生的共轭梯度法 看了好多人的讲解,可脑袋里还是没...
  • 机器学习之多项式拟合

    千次阅读 2018-10-03 23:47:39
    机器学习之多项式拟合实验内容目标要求实验步骤生成随机数据高阶多项式拟合无正则项的解析解有正则项的解析解梯度下降法共轭梯度法 实验内容 目标 掌握最小二乘法求解(无惩罚项的损失函数)、掌握加惩罚项(2范数)...
  • 最优化方法小结

    2020-02-26 22:00:44
    文章目录一维搜索算法Fibonacci法与黄金分割法黄金分割法步骤进退法平分法不精确的一维搜索无约束最优化方法最速下降法Newton法共轭方向法和共轭梯度法拟Newton法约束最优化方法等式约束的最优性条件不等式约束的最...
  • Matlab求解无约束最优化问题及其 一教学目标 了解悟约束规划的基本算法最速下降法共轭梯度法的基本步骤1.求解五约束的一元规划问题多元规划问题以及掌握用Matlab2. Matlab求解过程中参数的设置 Matlab求解3. 针对...
  • 针对BP网络现有学习算法的不足,在研究多种改进算法的基础上,在非线性规划理论的指导下,在共轭梯度法中巧妙地运行间插步骤和不精确的一维搜索技术,因而形成一种自适应的、...
  • 最优化方法——BGFS变尺度算法

    千次阅读 2019-04-18 22:07:29
    目录 ...最优化方法——最速下降法,阻尼牛顿法,共轭梯度法 1、不精确一维搜素 1.1 Wolfe-Powell 准则 2、不精确一维搜索算法计算步骤 1、BGFS基本思想 2、BGFS变尺度算法的计算公式 ...
  • 中文网站:http://download.csdn.net/detail/tiandijun/7098285 ... 一 数据预处理 1.常用批量梯度下降来求解神经网络代价函数,但是L-BFGS和共轭梯度算法通常比梯度下降快很多。 求取代价函数的关键步骤是计算
  • 对于每个子图,采用共轭梯度法对节点进行局部定位;之后,对相邻子图重叠区域内节点的局部位置进行融合平均.这两个步骤持续进行,直至满足迭代终止条件.仿真实验表明,与现有分布式算法相比,所提出算法的定位误差降低了一...
  • 本书系统地论述了有限元方程形成和求解的各个步骤的并行计算、大型稀疏有限元方程组直接解法的并行处理、大型稀疏线性方程组预处理共轭梯度法的并行处理、矩阵向量积的并行计算,还概括了近年来有关研究的主要成果,...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

共轭梯度法步骤