最优化方法Python计算：梯度下降搜索算法

设$n$元实值函数$f(\mathbf{x})$连续可微，且在区域$\Omega$内有唯一局部最小值点${\mathbf{x}}_0$，根据极值点的必要条件知$f^{\prime }({\mathbf{x}}_0)=0$。给定初始点${\mathbf{x}}_1$及容错误差$\epsilon$，利用迭代式
$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k,k=1,2,\cdots .$$
其中，${\mathbf{d}}_k\in {\text{R}}^n$为方向向量，正数${\alpha }_k>0$为搜索步长。每次迭代寻求合适的方向${\mathbf{d}}_k$和步长${\alpha }_k$，使得
$$f({\mathbf{x}}_{k+1})=f({\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k)<f({\mathbf{x}}_k),$$
且$\{{\mathbf{x}}_k\}$收敛于$f(\mathbf{x})$的局部最优点${\mathbf{x}}_0$。
可以证明，${\mathbf{d}}_k=-\nabla f({\mathbf{x}}_{\mathbf{k}})$是使得$f(\mathbf{x})$在${\mathbf{x}}_k$处下降最快的方向向量。定义一元函数
$${\varphi }_k(\alpha )=f({\mathbf{x}}_k+\alpha {\mathbf{d}}_k),\alpha \in {\text{R}}^{+},$$
为使$f({\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k)=\varphi ({\alpha }_k)$在${\mathbf{x}}_k$处沿方向${\mathbf{d}}_k$下降值最大，理想的是计算
$${\alpha }_k=\arg \underset{\alpha >0}{\min }{\varphi }_k(\alpha ).$$
用如此选取的方向向量${\mathbf{d}}_k$和步长${\alpha }_k$，从$k=1$开始，每次迭代使由迭代式${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k$算得序列$\{{\mathbf{x}}_k\}$的函数值满足$f({\mathbf{x}}_{k+1})<f({\mathbf{x}}_k)$。一旦得到$|f^{\prime }({\mathbf{x}}_k)|<\epsilon$，则认为${\mathbf{x}}_k$十分接近$f(\mathbf{x})$的驻点。由于可微函数$f(\mathbf{x})$有局部唯一最小值点，因此可以作为最优解$\mathbf{x}$满足容错误差的近似值。这一算法因所选下降方向为${\mathbf{d}}_k=-\nabla f({\mathbf{x}}_{\mathbf{k}})$，故称为梯度下降法。下列代码实现梯度下降搜索算法。

from scipy.optimize import minimize_scalar,OptimizeResult
def gradientDescent(fun,x1,gtol,**options):
    xk=x1
    dk=-fprime1(fun,xk)                	#计算搜索方向
    phi=lambda a:fun(xk+a*dk)
    k=1
    while np.linalg.norm(dk)>=gtol:
        ak=(minimize_scalar(phi)).x 	#计算搜索步长
        xk+=ak*dk                   	#生成新迭代点
        dk=-fprime1(fun,xk)            	#新的搜索方向
        k=k+1
    bestx=xk
    besty=fun(bestx)
    return OptimizeResult(fun=besty, x=bestx, nit=k)

程序的第2~14行定义函数gradientDescent，实现梯度下降算法。参数fun表示目标函数$f(\mathbf{x})$，x1表示初始迭代点${\mathbf{x}}_1$，gtol（自定义自由参数）表示容错误差$\epsilon$。
第3~6行进行初始化操作：第3行将表示迭代点${\mathbf{x}}_k$的变量xk初始化为x1。第4行计算搜索方向${\mathbf{d}}_k=-\nabla f({\mathbf{x}}_k)$赋予dk。其中，调用计算多元函数梯度的函数grad（详见博文《最优化方法Python计算：n元函数梯度与Hesse阵的数值计算》）计算$f(\mathbf{x})$在当前迭代点${\mathbf{x}}_k$处的梯度$\nabla f({\mathbf{x}}_k)$。第5行定义函数
$$\varphi (\alpha )=f({\mathbf{x}}_k+\alpha {\mathbf{d}}_k)$$
赋予phi。第6行将迭代次数k初始化为1。
第7~11行的while循环执行迭代操作：第8行调用minimize_scalar函数（第1行导入），传递phi，用缺省的brent方法计算搜索步长${\alpha }_k=\arg \underset{\alpha >0}{\min }\varphi (\alpha )$赋予ak。第9行计算迭代${\mathbf{x}}_{k+1}={\mathbf{x}}_k+{\alpha }_k{\mathbf{d}}_k$更新xk。第10行调用grad计算${\mathbf{d}}_{k+1}=-\nabla f({\mathbf{x}}_{k+1})$更新dk。第11行将迭代次数k自增1。循环往复，直至条件$\Vert \nabla f({\mathbf{x}}_k)\Vert <\epsilon$满足为止。第12~14行用f(xk)，xk和k构造OptimizeResult对象（第1行导入）返回。
例1：考虑Rosenbrock函数$f(\mathbf{x})=100(x_2-x_1^2{)}^2+(1-x_1{)}^2$，$\mathbf{x}=\left(\begin{array}{c}{x}_1\\ x_2\end{array}\right)\in {\text{R}}^2$。给定初始点${\mathbf{x}}_1=\left(\begin{array}{c}2\\ 1\end{array}\right)$。下列代码用gradientDescent分别以容错误差为$\epsilon =10^{-3}$和$\epsilon =10^{-5}$，计算${\mathbf{x}}_0$的近似值。

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

程序的第3行设置初始点${\mathbf{x}}_1=\left(\begin{array}{c}2\\ 1\end{array}\right)$为x1。第4、6行调用minimize函数传递gradientDescent给参数method，并将表示容错误差的gtol参数分别设置为$10^{-3}$和$10^{-5}$，计算表示Rosenbrock函数的rosen（第2行导入）最优解。运行程序，输出

 fun: 1.179532940214763e-06
 nit: 1024
   x: array([1.00108499, 1.00217598])
 fun: 1.1791444533318637e-10
 nit: 2068
   x: array([1.00001085, 1.00002174])

即gradientDescent函数从${\mathbf{x}}_1=\left(\begin{array}{c}2\\ 1\end{array}\right)$开始，以$\epsilon =10^{-3}$为容错误差，迭代1024次，算得Rosenbrock函数的最优解${\mathbf{x}}_0$的近似值$\left(\begin{array}{c}1.00108499\\ 1.00217598\end{array}\right)$。而以$\epsilon =10^{-5}$为容错误差，需迭代2068次，计算结果为$\left(\begin{array}{c}1.00001085\\ 1.00002174\end{array}\right)$。由此可见，不同的容错误差，对算法迭代次数的影响是比较大的，且算法的运行效率不是很高。