最优化方法Python计算：非二次型共轭梯度算法

设目标函数$f(\mathbf{x})$，$\mathbf{x}\in {\text{R}}^n$，有最小值点${\mathbf{x}}_0$且二阶可微，则在${\mathbf{x}}_0$近旁可以用二次型函数
$$q(\mathbf{x})=\frac{1}{2}{\mathbf{x}}^{\top }\mathbf{H}\mathbf{x}-{\mathbf{x}}^{\top }\mathbf{g}$$
其中$\mathbf{g}=\nabla f(\mathbf{x})$为$f(\mathbf{x})$的梯度，$\mathbf{H}={\nabla }^{2}f(\mathbf{x})$为$f(\mathbf{x})$的Hesse阵，作为$f(\mathbf{x})$的近似。一个自然的想法是对二次型函数$q(\mathbf{x})$运用共轭梯度算法计算$f(\mathbf{x})$的最优值点${\mathbf{x}}_0$的近似值。
对此，需克服两个困难。其一，每次迭代时$f(\mathbf{x})$在上一个迭代点处的Hesse阵$\mathbf{H}$必须重新计算，这将花费很大的运算量。注意到共轭梯度算法中涉及$\mathbf{H}$计算的有两处：搜索步长${\alpha }_k=\frac{-{\mathbf{g}}_k^{\top }{\mathbf{d}}_k}{{\mathbf{d}}_k^{\top }{\mathbf{Hd}}_k}$及共轭方向组合系数${\beta }_k=\frac{{\mathbf{g}}_{k+1}^{\top }{\mathbf{Hd}}_k}{{\mathbf{d}}_k^{\top }{\mathbf{Hd}}_k}$。如果能在这两个计算中消除$\mathbf{H}$，将能大大改善计算效率。
对于${\alpha }_k$，实质上其为一元函数${\varphi }_k(\alpha )=f({\mathbf{x}}_k+\alpha {\mathbf{d}}_k)$最小值点，即
$${\alpha }_k=\arg \underset{\alpha >0}{\min }\varphi (\alpha ),k=1,2,\cdots ,n.$$
为在${\beta }_k$的计算中消除$\mathbf{H}$，按Fletcher-Reeves公式通过代换计算可得
$${\beta }_k=\frac{{\mathbf{g}}_{k+1}^{\top }({\mathbf{g}}_{k+1}-{\mathbf{g}}_k)}{{\mathbf{g}}_k^{\top }{\mathbf{g}}_k},k=1,2,\cdots ,n.$$
将${\alpha }_k$及${\beta }_k$代入共轭向量计算式，得${\mathbf{d}}_{k+1}=-{\mathbf{g}}_k+{\beta }_k{\mathbf{d}}_k$，修改共轭梯度算法——称为FR共轭梯度算法，并实现为如下Python函数

import numpy as np
from scipy.optimize import minimize_scalar,OptimizeResult
def conjFR(f,x1,gtol,**options):
    n=x1.size
    xk=x1
    gk=grad(f,xk)
    dk=-gk
    phi=lambda a: f(xk+a*dk)
    k=1
    while np.linalg.norm(gk)>=gtol:
        ak=(minimize_scalar(phi)).x
        xk=xk+ak*dk
        gk1=grad(f,xk)
        if k%n==0:
            bk=0
        else:
            bk=np.matmul(gk1,gk1)/np.matmul(gk,gk)
        dk=-gk1+bk*dk
        gk=gk1
        k+=1
    bestx=xk
    besty=f(xk)
    return OptimizeResult(fun=besty, x=bestx, nit=k)

程序的第3~23行定义了实现FR共轭梯度算法的conjFR函数，参数f表示目标函数$f(\mathbf{x})$，x1表示初始迭代点${\mathbf{x}}_1$，gtol表示容错误差$\epsilon$，options实现minimize与本函数的信息交换机制。
第4~9行执行初始化操作：第4行将可行解位数赋予n。第5行将迭代点xk初始化为x1。第6行调用计算函数梯度的grad（详见博文《最优化方法Python计算：n元函数梯度与Hesse阵的数值计算》）计算目标函数f在当前迭代点xk处的梯度
$${\mathbf{g}}_1=\nabla f({\mathbf{x}}_1)$$
赋予gk。第7行将表示共轭方向的dk初始化为$-{\mathbf{g}}_1$。第8行定义函数
$$\varphi (\alpha )=f({\mathbf{x}}_k+\alpha {\mathbf{d}}_k)$$
为phi。第9行将迭代次数k初始化为1。
第10~20行的while循环执行迭代操作：第11行调用minimize_scalar（第2行导入）计算
$$\arg \underset{\alpha >0}{\min }\varphi (\alpha )$$
赋予ak。第12行计算迭代点
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k$$
更新xk。第13行计算
$${\mathbf{g}}_{k+1}=\nabla f({\mathbf{x}}_{k+1})$$
赋予gk1。第14~17行的if-else分支根据迭代次数k是否为n的整数倍决定共轭方向${\mathbf{d}}_k$的组合系数${\beta }_k$的计算：若是，则
$${\beta }_k=0$$
否则
$${\beta }_k=\frac{{\mathbf{g}}_{k+1}^{\top }{\mathbf{g}}_{k+1}}{{\mathbf{g}}_k^{\top }{\mathbf{g}}_k}$$
将算得的${\beta }_k$赋予bk。第18行计算
$${\mathbf{d}}_{k+1}=-{\mathbf{g}}_{k+1}+{\beta }_k{\mathbf{d}}_k$$
更新dk。第19行用${\mathbf{g}}_{k+1}$更新gk。第20行将迭代次数k自增1。循环往复，直至条件
$$\Vert {\mathbf{g}}_k\Vert <\epsilon$$
成立。
第21~23行用$f({\mathbf{x}}_k)$，${\mathbf{x}}_k$及$k$构造OptimizeResult（第2行导入）对象，并返回。
例1 给定初始点${\mathbf{x}}_1=\left(\begin{array}{c}2\\ 1\end{array}\right)$，分别以容错误差$\epsilon =10^{-3}$和$\epsilon =10^{-5}$用conjFR方法计算Rosenbrock函数$f(\mathbf{x})=100(x_2-x_1^2{)}^2+(1-x_1{)}^2$的最优解。
解：下列代码完成计算。

import numpy as np                                      #导入numpy
from scipy.optimize import minimize,rosen               #导入minimize,rosen
x=np.array([2,1])                                       #设置初始迭代点
res=minimize(rosen,x,method=conjFR,options={'gtol':1e-3})
print(res)
res=minimize(rosen,x,method=conjFR,options={'gtol':1e-5})
print(res)

程序的第4、6行调用minimize函数，传递rosen和x给参数fun和x0，传递conjFR给参数method，并用options机制向conjFR的gtol参数分别传递$10^{-3}$和$10^{-5}$，计算最优解。运行程序，输出

 fun: 1.7856398066667848e-08
 nit: 10
   x: array([1.00013352, 1.00026759])
 fun: 1.7767405467097918e-18
 nit: 12
   x: array([1., 1.])

可见对FR共轭梯度算法而言，容错误差对解的精度有较大影响，对算法效率（迭代次数）的影响并不明显。可见，共轭梯度算法的效率远比梯度下降算法的高（参见博文《最优化方法Python计算：梯度下降搜索算法》）。
写博不易，敬请支持：
如果阅读本文于您有所获，敬请点赞、评论、收藏，谢谢大家的支持！