最优化方法Python计算：信赖域算法

作为求解目标函数$f(\mathbf{x})$无约束优化问题的策略之一的信赖域方法，与前讨论的线性搜索策略略有不同。线性搜索策略是在当前点${\mathbf{x}}_k$处先确定搜索方向${\mathbf{d}}_k$，再确定在该方向上的搜索步长${\alpha }_k$。以此计算下一步搜索点
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k.$$
信赖域方法的基本思想是以当前点${\mathbf{x}}_k$为心，以${\Delta }_k$为半径的称为信任域的闭球内，求解与$f(\mathbf{x})$相似的二次型函数称为信赖域子问题的最优点来确定搜索方向${\mathbf{d}}_k$：
$${\mathbf{d}}_k=\arg \underset{\Vert \mathbf{d}\Vert \le {\Delta }_k}{\min }\left(\frac{1}{2}{\mathbf{d}}^{\top }{\mathbf{H}}_k\mathbf{d}+{\mathbf{g}}_k^{\top }\mathbf{d}\right)$$
其中，${\mathbf{g}}_k=\nabla f({\mathbf{x}}_k)$，${\mathbf{H}}_k$是$f(\mathbf{x})$在${\mathbf{x}}_k$处的Hesse阵。若求得的${\mathbf{d}}_k$能使$f(\mathbf{x})$明显下降，则以此确定下一步搜索点
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\mathbf{d}}_k.$$
否则，调整（缩放）信赖域半径${\Delta }_k$，重新求解信赖域子问题。循环往复，直至${\mathbf{d}}_k$能使$f(\mathbf{x})$充分下降。

1、信赖域子问题的解

对二阶连续可微的目标函数$f(\mathbf{x})$，所谓信赖域子问题是指的求解
$$\begin{array}{c}\text{minimize}{q}_k(\mathbf{d})=\frac{1}{2}{\mathbf{d}}^{\top }{\mathbf{H}}_k\mathbf{d}+{\mathbf{g}}_k^{\top }\mathbf{d}\\ \text{s.t.}\Vert \mathbf{d}\Vert \le {\Delta }_k.\end{array}(1)$$
其中，${\mathbf{g}}_k=\nabla f({\mathbf{x}}_k)$，${\mathbf{H}}_k={\nabla }^{2}f({\mathbf{x}}_k)$。
这是一个二次型函数$q_k(\mathbf{d})$的优化问题，我们试图运用上一章讨论过的共轭梯度法（详见博文《最优化方法Python计算：正定二次型共轭梯度算法》）来解决信赖域子问题。首先，注意到目标函数$q_k(\mathbf{d})$的自变量为$\mathbf{d}$，初始${\mathbf{d}}_1=\mathbf{o}$。为避免发生符号混淆，记${\mathbf{r}}_i=\nabla q_k({\mathbf{d}}_i)={\mathbf{H}}_k{\mathbf{d}}_i+{\mathbf{g}}_k$为$q_k(\mathbf{d})$在第$i$次迭代时的梯度，初始${\mathbf{r}}_1={\mathbf{g}}_k=\nabla f({\mathbf{x}}_k)$。${\mathbf{p}}_i$为第$i$次迭代时的搜索方向，初始${\mathbf{p}}_1=-{\mathbf{r}}_1$。${\alpha }_i=\frac{-{\mathbf{r}}_i^{\top }{\mathbf{p}}_i}{{\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i}$为第$i$次迭代时的搜索步长。${\beta }_i=\frac{{\mathbf{r}}_{i+1}^{\top }{\mathbf{r}}_{i+1}}{{\mathbf{r}}_i^{\top }{\mathbf{r}}_i}$为方向向量${\mathbf{p}}_{i+1}=-{\mathbf{r}}_{i+1}+{\beta }_i{\mathbf{p}}_i$的线性组合系数。由此而得
$${\mathbf{d}}_{i+1}={\mathbf{d}}_i+{\alpha }_i{\mathbf{p}}_i$$
是$q_k(\mathbf{d})$的无约束优化问题的第$i+1$个迭代点，但加上约束条件$\Vert \mathbf{d}\Vert \le {\Delta }_k$后，可能需要作下列的“截断操作”：
(1)若${\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i\le 0$，即${\mathbf{H}}_k$不是正定阵，停止迭代。保持${\mathbf{p}}_i$的方向，将其推至信赖域边界，即寻求$\rho >0$，使得$\Vert {\mathbf{d}}_i+\rho {\mathbf{p}}_i\Vert ={\Delta }_k$， 返回${\mathbf{d}}_i+\rho {\mathbf{p}}_i={\Delta }_k$。
(2)${\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i>0$，但$\Vert {\mathbf{d}}_i+{\alpha }_i{\mathbf{p}}_i\Vert >{\Delta }_k$，即${\mathbf{d}}_{i+1}$突破了约束条件$\Vert \mathbf{d}\Vert \le {\Delta }_k$，停止迭代。寻求$\rho \in (0,1)$，使得$\Vert {\mathbf{d}}_i+\rho {\mathbf{p}}_i\Vert ={\Delta }_k$，返回${\mathbf{d}}_i+\rho {\mathbf{p}}_i={\Delta }_k$。
(3)${\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i>0$，$\Vert {\mathbf{d}}_i+{\alpha }_i{\mathbf{p}}_i\Vert \le {\Delta }_k$，且$\Vert {\mathbf{r}}_{i+1}\Vert >\epsilon$，令${\mathbf{d}}_{i+1}={\mathbf{d}}_i+{\alpha }_i{\mathbf{p}}_i$，继续迭代。其中，$\epsilon$为给定的容错误差。
用上述为满足约束条件而进行迭代截断的思想改造共轭梯度算法（详见博文《最优化方法Python计算：正定二次型共轭梯度算法》）。由于这一方法是在对共轭梯度算法的迭代过程进行了有条件的“截断”，故称为截断共轭梯度算法。
下列代码实现截断共轭梯度算法。

import numpy as np
def tcg(H,g,D,eps=1e-6):
    n=g.size
    di=np.zeros(n)
    ri=g
    pi=-ri
    i=1
    while np.linalg.norm(ri)>eps:
        if np.matmul(np.matmul(pi,H),pi)<=0:
            rho=1
            while np.linalg.norm(di+rho*pi)<D:
                rho*=1.05
            while np.linalg.norm(di+rho*pi)>D:
                rho*=0.95
            return di+rho*pi
        ai=(-np.matmul(ri,pi)/np.matmul(np.matmul(pi,H),pi))
        if np.linalg.norm(di+ai*pi)>D:
            rho=ai*0.95
            while np.linalg.norm(di+rho*pi)>D:
                rho*=0.95
            return di+rho*pi
        di=di+ai*pi
        ri=ri+ai*np.matmul(H,pi)
        bi=np.matmul(np.matmul(ri,H),pi)/np.matmul(np.matmul(pi,H),pi)
        pi=-ri+bi*pi
        i+=1
    return di

程序的第2~27行定义的函数tcg实现计算信赖域子问题的截断共轭梯度算法。参数H表示子问题目标函数中的矩阵${\mathbf{H}}_k$，g表示向量${\mathbf{g}}_k$，D表示信赖域半径${\Delta }_k$，eps表示容错误差$\epsilon$，缺省值设置为$10^{-6}$。\par
第3~7行做初始化操作。其中第3行读取g的维数赋予n，第4行调用numpy的zeros函数将最优解向量di初始化为n维零向量，第5行将表示目标函数的梯度${\mathbf{r}}_i$的ri初始化为表示${\mathbf{g}}_k$的g。第6行将表示搜索方向${\mathbf{p}}_i$的pi初始化为$-{\mathbf{r}}_i$。第7行将迭代次数i初始化为1。
第8~ 26行的while循环进行迭代操作。其中，第9~15行根据检测条件
$$\Vert {\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i\Vert \le 0$$
真假决定是否调截断迭代：若该条件为真，则第10~14行的两个并列while循环计算满足
$$\Vert {\mathbf{d}}_i+\rho {\mathbf{p}}_i\Vert ={\Delta }_k$$
的实数$\rho$，并在第15行返回最优解的近似值（截断）
$${\mathbf{d}}_i+\rho {\mathbf{p}}_i.$$
否则，第16行计算
$${\alpha }_i=-\frac{{\mathbf{r}}_i^{\top }{\mathbf{p}}_i}{{\mathbf{p}}_i^{\top }{\mathbf{H}}_k{\mathbf{p}}_i}$$
赋予ai。第17~21行根据检测条件
$$\Vert {\mathbf{d}}_i+\rho {\mathbf{p}}_i\Vert >{\Delta }_k$$
的真假决定是否截断迭代：若条件为真，第19~20行的while循环计算满足
$$\Vert {\mathbf{d}}_i+\rho {\mathbf{p}}_i\Vert ={\Delta }_k$$
的实数$\rho$，并在第21行返回最优解的近似值（截断）
$${\mathbf{d}}_i+\rho {\mathbf{p}}_i.$$
否则完成本次迭代：第22行计算
$${\mathbf{d}}_{i+1}={\mathbf{d}}_i+{\alpha }_i{\mathbf{p}}_i$$
更新最优解迭代点di，第23行计算
$${\mathbf{r}}_{i+1}={\mathbf{r}}_i+{\alpha }_i{\mathbf{H}}_k{\mathbf{p}}_i$$
更新ri。第24行计算系数
$${\beta }_i=\frac{{\mathbf{r}}_{i+1}^{\top }{\mathbf{H}}_k{\mathbf{p}}_i}{{\mathbf{p}}_i\top {\mathbf{H}}_k{\mathbf{p}}_i}$$
赋予bi。第25行计算
$${\mathbf{p}}_{i+1}={\mathbf{r}}_{i+1}+{\beta }_i{\mathbf{p}}_i$$
更新pi。第26行迭代次数i自增1。循环往复，直至被截断或检测到
$$\Vert {\mathbf{r}}_i\Vert \ge \epsilon .$$
第27行返回最优解近似值di。

2、信赖域算法

在信赖域算法中，设第$k$次迭代算得子问题最优解${\mathbf{d}}_k=\arg \underset{\Vert \mathbf{d}\Vert \le {\Delta }_k}{\min }{q}_k(\mathbf{d})\ne \mathbf{o}$，记$\Delta f_k=f({\mathbf{x}}_k)-f({\mathbf{x}}_k+{\mathbf{d}}_k)$，
$$\begin{gathered} \Delta q_k=q_k(\mathbf{o})-q_k({\mathbf{d}}_k) \\ =-q_k({\mathbf{d}}_k)=-\frac{1}{2}{\mathbf{d}}_k^{\top }{\mathbf{H}}_k{\mathbf{d}}_k-{\mathbf{g}}_k^{\top }{\mathbf{d}}_k \end{gathered}$$
由二次型函数在一区域内最小值点的唯一性知$\Delta q_k>0$。考虑比值
$$r_k=\frac{\Delta f_k}{\Delta q_k}$$
反映了$q_k(\mathbf{d})$从$q_k(\mathbf{o})$变化到$q_k({\mathbf{d}}_k)$与$f(\mathbf{x})$从$f({\mathbf{x}}_k)$变化到$f({\mathbf{x}}_k+{\mathbf{d}}_k)$的变化率。根据$r_k$的值，作如下判断和思考：
(1)若$r_k<0$，则意味着${\mathbf{d}}_k$不是$f(\mathbf{x})$在${\mathbf{x}}_k$处的下降方向。或$r_k$虽然大于零但其值很小，意味着$f(\mathbf{x})$从${\mathbf{x}}_k$，沿${\mathbf{d}}_k$到${\mathbf{x}}_k+{\mathbf{d}}_k$的下降幅度微不足道。因此，需缩小信赖半径${\Delta }_k$并重新计算${\mathbf{d}}_k$。
(2)若$r_k$显著大于零，则意味着$q_k(\mathbf{d})$在${\mathbf{x}}_k$近旁比较接近$f(\mathbf{x})$，${\mathbf{d}}_k$作为$f(\mathbf{x})$在${\mathbf{x}}_k$的下降方向是可信赖的，即
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\mathbf{d}}_k(2)$$
可作为下一个搜索点。
(3)$r_k>0$前提下，接近1，且$\Vert {\mathbf{d}}_k\Vert ={\Delta }_k$，则意味着还可以适当放大下一步迭代时的信赖半径${\Delta }_{k+1}$，以期提高搜索效率。
对于情形(2)和(3)，进入下一轮迭代前，均需将$f(\mathbf{x})$的梯度及Hesse矩阵分别更新为${\mathbf{g}}_{k+1}$及${\mathbf{H}}_{k+1}$。为界定$r_k$的“大小”，设置阀值$0<{\mu }_1<{\mu }_2\le 1$。当$r_k<{\mu }_1$时，认为$r_k$太小。当$r_k\ge {\mu }_2$时，认为$r_k$接近于1。还可以设置信赖域半径${\Delta }_k$的缩放比例$0<{\tau }_1<1<{\tau }_2$，用${\tau }_1{\Delta }_k$缩小半径，${\tau }_2{\Delta }_k$扩大半径。实践中，${\mu }_1=0.05$，${\mu }_2=0.75$，${\tau }_1=0.5$，${\tau }_2=2$，是这组参数的推荐值。信赖域半径初始值可取$\overline{\Delta }=1$。
下列代码实现信赖域算法。

import numpy as np
from scipy.optimize import OptimizeResult
def trust(f, x1, gtol=1e-6, D=1, **options):
    mu1,mu2=0.05,0.75
    t1,t2=0.25,2
    xk=x1
    fk,gk,Hk=f(xk),grad(f,xk),hess(f,xk)
    Dk=D
    k=1
    while np.linalg.norm(gk)>gtol:
        dk=tcg(Hk,gk,Dk)
        df=fk-f(xk+dk)
        dq=-(np.matmul(gk,dk)+np.matmul(np.matmul(dk,Hk),dk)/2)
        rk=df/dq
        if rk<mu1:
            Dk=t1*Dk
        else:
            if rk>mu2 and abs(np.linalg.norm(dk)-Dk)<1e-6:
                Dk=min(t2*Dk,D)
            xk=xk+dk
            fk,gk,Hk=f(xk),grad(f,xk),hess(f,xk)
            k+=1
    bestx=xk
    besty=f(bestx)
    return OptimizeResult(fun=besty, x=bestx, nit=k)

程序的第3~25行定义的函数trust实现信赖域算法，参数f表示目标函数$f(\mathbf{x})$，x1表示初始点${\mathbf{x}}_1$，命名参数eps表示容错误差$\epsilon$，缺省值为$10^{-6}$，D表示信赖域半径$\overline{\Delta }$，缺省值为1。
第4~9行完成初始化操作：第4行设置阀值${\mu }_1=0.05$赋予mu1，${\mu }_2=0.75$赋予mu2。第5行设置信赖半径缩放系数${\tau }_1=0.25$赋予t1，${\tau }_2=2$赋予t2。第6行将表示迭代点${\mathbf{x}}_k$的xk初始化为x1。第7行调用grad函数和hess函数（见博文《最优化方法Python计算：n元函数梯度与Hesse阵的数值计算》）用$f({\mathbf{x}}_1)$初始化fk，$\nabla f({\mathbf{x}}_1)$初始化gk，${\nabla }^{2}f({\mathbf{x}}_1)$初始化Hk。第8行用$\overline{\Delta }$初始化Dk。\par
第10~22行的while循环根据条件$\Vert {\mathbf{g}}_k\Vert >\epsilon$执行迭代：第11行调用解子问题的tcg函数计算子问题最优解
$${\mathbf{d}}_k=\arg \underset{\Vert \mathbf{d}\Vert \le {\Delta }_k}{\min }{q}_k(\mathbf{d})=\arg \underset{\Vert \mathbf{d}\Vert \le {\Delta }_k}{\min }(\frac{1}{2}{\mathbf{d}}^{\top }{\mathbf{H}}_k\mathbf{d}+{\mathbf{g}}_k^{\top }\mathbf{d})$$
赋予dk。第12行计算
$$\Delta f_k=f({\mathbf{x}}_k)-f({\mathbf{x}}_k+{\mathbf{d}}_k)$$
赋予df。第13行计算
$$\Delta q_k=q_k(\mathbf{o})-q_k({\mathbf{d}}_k)$$
赋予dq。第14行计算
$$r_k=\frac{\Delta f_k}{\Delta q_k}$$
赋予rk。第15~22行的if-else分支根据条件$r_k<{\mu }_1$决定是否重做本次迭代：若条件为真，第16行执行
$${\Delta }_k={\tau }_1{\Delta }_k$$
以缩小信赖域半径${\Delta }_k$。否则，第18~ 22行完成本次迭代：先用第18~19行的if语句根据条件
$$r_k>{\mu }_2\text{且}\Vert {\mathbf{d}}_k\Vert ={\Delta }_k$$
决定是否执行
$${\Delta }_k={\tau }_2{\Delta }_k$$
以放大${\Delta }_k$。然后第20行继续进行迭代，用
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\mathbf{d}}_k$$
更新xk。第21行用新的xk（即${\mathbf{x}}_{k+1}$）更新fk，gk，Hk为$f_{k+1}$，${\mathbf{g}}_{k+1}$和${\mathbf{H}}_{k+1}$。\par
第23~25行用xk，f(xk)及k构造返回值返回。
例1 用trust函数计算Rosenbrock函数的最优解，给定信赖域半径$\overline{\Delta }=3$，容错误差$\epsilon =10^{-6}$，初始点${\mathbf{x}}_1=\left(\begin{array}{c}100\\ 100\end{array}\right)$。
解：下列代码完成本例计算。

import numpy as np                                              #导入numpy
from scipy.optimize import minimize,rosen                       #导入minimize，rosen
x1=np.array([100,100])                                          #设置初始点
res=minimize(rosen,x1,method=trust,options={'eps':1e-6,'D':3})  #计算最优解
print(res)

程序的第3行设置初始点${\mathbf{x}}_1=\left(\begin{array}{c}100\\ 100\end{array}\right)$。第4行调用minimize函数（第2行导入），传递rosen（第2行导入）给表示目标函数的参数，x1给表示初始点的参数，传递trust给表示算法的参数method，并设置表示容错误差$\epsilon$的eps为$10^{-6}$，表示信赖域半径$\overline{\Delta }$的D为3，计算Rosenbrock函数的最优解。运行程序，输出

 fun: 8.970641906878568e-16
 nit: 125
   x: array([1.00000003, 1.00000005])

意味着trust从${\mathbf{x}}_1=\left(\begin{array}{c}100\\ 100\end{array}\right)$开始，迭代125次，算得Rosenbrock函数的最优解${\mathbf{x}}_0=\left(\begin{array}{c}1\\ 1\end{array}\right)$的近似值。
应当指出，scipy.optimize为用户提供了包括trust-ncg、trust-krylov、trust-exact等若干个信赖域方法。使用这些方法时，需向minimize的参数jac传递目标函数的梯度，向参数hess传递目标函数的Hess阵。
例2 以$\epsilon =10^{-6}$为容错误差，以${\mathbf{x}}_1=\left(\begin{array}{c}100\\ 100\end{array}\right)$为初始点，用trust-ncg方法计算Rosenbrock函数的最优解。\par
解：下列代码完成本例计算。

import numpy as np                                              #导入numpy
from scipy.optimize import minimize,rosen,rosen_der, rosen_hess #导入minimize等
x1=np.array([100,100])                                          #设置初始点
res=minimize(rosen, x1, method='trust-ncg',                     #计算最优解
             jac=rosen_der, hess=rosen_hess,options={'gtol': 1e-6})
print(res)

程序中的第4~5行调用minimize函数（第2行导入）计算Rosenbrock函数的最优解。传递给目标函数为rosen（第2行导入），传递给初始点向量为x1（第3行定义），传递给表示算法的参数method为’trust-ngc’，传递给表示目标函数梯度的参数jac为rosen_{}der（第2行导入），传递给表示目标函数Hess矩阵的参数hess为rosen_{}hess（第2行导入）传递给表示容错误差的参数gtol为$10^{-6}$。运行程序，输出

     fun: 2.25873063877735e-28
    hess: array([[ 802., -400.],
       [-400.,  200.]])
     jac: array([ 1.44328993e-14, -2.22044605e-14])
 message: 'Optimization terminated successfully.'
    nfev: 126
    nhev: 108
     nit: 125
    njev: 109
  status: 0
 success: True
       x: array([1., 1.])

比较例1和例2可见，系统提供的trust-ngc方法与我们编制的trust方法在计算效率上不分仲伯（相同的容错误差下均迭代125次）。然而用我们的trust时无需向minimize提供目标函数的梯度和和Hesse阵作为参数（trust内部调用der和hess函数计算），使得调用形式更加简洁。