梯度下降法（Gradient descent）

在了解梯度下降法之前我们首先来了解一下梯度的概念

梯度

设函数$z=f(x,y)$在平面区域$D$内具有一阶连续偏导数，则对于每一点$P(x,y)\in D$,都可以定出一个向量$\frac{\partial f}{\partial x}\vec{i}+\frac{\partial f}{\partial y}\vec{j}（其中\overrightarrow{i,},\vec{j}）为单位向量$，这向量称为函数$z=f(x,y)$在点$P(x,y)$的梯度，记为$$\nabla z=\overrightarrow{grad}f(x,y)=\frac{\partial f}{\partial x}\vec{i}+\frac{\partial f}{\partial y}\vec{j}$$
函数在某点的梯度是这样一个向量：它的方向与取得最大方向导数的方向一致，它的模为方向导数的最大值。
举例：
$$\begin{array}{rl}f(x,y,z)& =4x+3y+10z\\ \partial f& =⟨\frac{df}{dx},\frac{df}{dy},\frac{df}{dz}⟩\\ & =⟨4,3,10⟩\end{array}$$
需要了解几个梯度的性质

• 梯度是一个向量
• 梯度的方向是使函数在这一点值上升最快方向（可以由方向导数推得）
• 在单变量的函数中，梯度其实就是函数的微分，（例：$\frac{d\left(x^2\right)}{dx}=2x$）代表着函数在某个给定点的切线的斜率
• 在多变量函数中，梯度是一个向量，向梯度的方向就指出了函数在给定点的上升最快的方向

梯度下降

运用梯度下降法是为了求解无约束最优化问题，即假设$f(x)$是在$R^n$上具有一阶连续偏导数的函数，要求解的无约束最优化问题是$$\underset{x\in {\mathbf{R}}^n}{\min }f(x)$$
举例说明：
如图，有一个函数$L$,我们任选一个点开始，要求得使函数值$L$最小的点；类似于一个人站在一座山中，要到达山谷中最低的位置(寻找最小点)，那么我们应该从出发点开始（任选一点$x^0$），每次都选择往最陡峭的方向走（寻找$x^{k+1}$），每走一段距离（这里就相当于$\eta$）判断一次下一个最陡峭的地方(相当于当前点的梯度方向)，这样就能到达一个相对最低的点（极小点），并求得该点的位置（参数值）。

梯度下降法是一种迭代算法.选取适当的初值$x^0$,不断迭代，更新$x$的值,进行目标函数的极小化，直到收敛.由于负梯度方向是使函数值下降最快的方向，在迭代的每一步，以负梯度方向更新$x$的值，从而达到减少函数值的目的。

我们通常运用梯度下降法来求解使得损失函数$f$的值最小的点，
运用梯度下降解决一元函数的问题,
例如:假设$L$图像如图所示，求$$w^{\ast }=\arg \underset{w}{\min }L(w)$$，

1. 从图像上选取适当一点$w^0$作为起始点；
2. 求取$L在w^0$点的微分${\frac{dL}{dw}|}_{w=w^0}$；
3. 然后变化根据$L在w^0$点的微分值选择下一步要走的方向：我们要找最小的点，则当微分值大于0时，即图中2那一点的情况，此时应该往左走，即$w^1(下一步要到达的位置)等于w^0$减去一个值,当微分值小于0，即图中1那一点的情况，此时应该往右走，则$w^1$等于$w^0$加上一个值，综上$w^1可写成$：
   $$\begin{gathered} w^1\leftarrow w^0-\eta {\frac{dL}{dw}|}_{w=w^0} \\ 其中\eta 表示步长（即下一次移动的距离（又称学习率），-{\frac{dL}{dw}|}_{w=w^0}微分决定前进方向） \end{gathered}$$
4. 然后不断重复2，3步骤，即$w^{k+1}\leftarrow w^k-\eta {\frac{dL}{dw}|}_{w=w^k}$，直到终止条件（微分值为零或找不到更小的值等），就有可能找到最小值点或者极小值点。需要注意的是我们还需要调整$\eta$的大小，当离极小值点越来越近（$L$的变化越来越小时），需要减小$\eta$的值，即减小步长。

类似的，我们可以得到二元及多元的情况：
假设函数$L(w,b)$,求$$w^{\ast },b^{\ast }=\arg \underset{w,b}{\min }L(w,b)$$

1. 随机选取初始点$w^0,b^0$;
2. 因为$L(w,b)$包含两个自变量$w,b$，因此需要求偏微分:$${\frac{\partial L}{\partial w}|}_{w=w^0,b=b^0},{\frac{\partial L}{\partial b}|}_{w=w^0,b=b^0};$$
   3.类似一元的情况： $$w^1\leftarrow w^0-\eta {\frac{\partial L}{\partial w}|}_{w=w^0,b=b^0}{b}^1\leftarrow b^0-\eta {\frac{\partial L}{\partial b}|}_{w=w^0,b=b^0}$$
   即：根据第k步决定k+1步，$$w^{k+1}\leftarrow w^k-\eta {\frac{\partial L}{\partial w}|}_{w=w^k,b=b^k}{b}^{k+1}\leftarrow b^k-\eta {\frac{\partial L}{\partial b}|}_{w=w^k,b=b^k}$$
   因为多元的情况可以将梯度写成如下形式：
   $$\nabla L={\left[\begin{array}{l}\frac{\partial L}{\partial w}\\ \frac{\partial L}{\partial b}\end{array}\right]}_{gradient}$$
   所以有：
   $$\left[\begin{array}{c}{w}^{k+1}\\ b^{k+1}\end{array}\right]=\left[\begin{array}{l}{w}^k\\ b^k\end{array}\right]-\eta \nabla L（w,b）=\left[\begin{array}{l}{w}^k\\ b^k\end{array}\right]-\eta \left[\begin{array}{l}\frac{\partial L}{\partial w}{|}_{w=w^k,b=b^k}\\ \frac{\partial L}{\partial b}{|}_{w=w^k,b=b^k}\end{array}\right],类似地，-\eta \nabla L（w,b）决定方向$$
   步长（学习率）的大小可能对结果产生不同的影响。如图所示
   不同大小的$\eta$可能会造成下面图中的情况
   
   有关调整步长的方法可以参考文章步长（学习率learning rate）

全局最小和局部最小

如图所示，是在运用梯度下降的过程中，从某一点出发可能会陷入局部最小（即在某一邻域内，它是最小值）找不到最优解。


可以使用一些方法来跳出局部最小：

• 以多组不同参数值初始化多个神经网络,按标准方法训练后，取其中误差最小的解作为最终参数.这相当于从多个不同的初始点开始搜索,这样就可能陷入不同的局部极小，从中进行选择有可能获得更接近全局最小的结果.
• 使用“模拟退火”(simulated annealing) 技术模拟退火在每-步都以一定的概率接受比当前解更差的结果，从而有助于“跳出”局部极小.在每步迭代过程中，接受“次优解”的概率要随着时间的推移而逐渐降低，从而保证算法稳定,
• 使用随机梯度下降.与标准梯度下降法精确计算梯度不同,随机梯度下降法在计算梯度时加入了随机因素.于是,即便陷入局部极小点,它计算出的梯度仍可能不为零,这样就有机会跳出局部极小继续搜索.

梯度下降法可用于求函数的最小值，即通过样本值运用梯度下降法求使得误差最小的参数值，
前面我们介绍的线性模型利用最小二乘法估测误差，求$w^{\ast },b^{\ast }$,即求：$$（w^{\ast },b^{\ast }）=arg\underset{(w,b)}{\min }(E(w,b))=arg\underset{(w,b)}{\min }\sum _{i=1}^n(w{x}_i+b-y_i{)}^2$$就可以用梯度下降法来解：这里误差函数$E(w,b)={\sum }_{i=1}^n(w{x}_i+b-y_i{)}^2$j就是损失函数$L$,分别对$w,b$求偏导：
$$\frac{\partial L}{\partial w}=\sum _{i=1}^{n}2\left(b+w\cdot x_i-y_i\right)\left(x_i\right)$$
$$\frac{\partial L}{\partial b}=\sum _{i=1}^{n}2(b+w\cdot x_i-y_i)\ast (1)$$
这里$（x_i,$是已知值（样本点），$w,b$是未知，运用梯度下降法求最佳的$w,b$使得损失函数$L(w,b)$最小。

Momentum(动量)

在物理学上我们知道，一个球从山坡上滚下来，到达最低点时不一定会停下来，带有动量会继续往前走。如图，这个球可能会冲出局部最低点。那么我们应该怎样将这点知识运用到梯度下降法中，帮助我们调参时逃出局部最小点，从而找到最优解呢？

如图，当球在最右边时，如果动能再向右，而通过梯度计算告诉我们应该往左走，等动能足够大时就可以跳出局部最小。

梯度下降加入Momentum：

• 每次移动时计算梯度的方向，
• 这里的动量以前一次所移动的方向当做动量。

1. 起始点$w^0$，Momentum: $v^0=0$;
2. 计算$w^0$处的梯度$g^0=\nabla L\left(w^0\right)$,动量${\mathrm{v}}^1=\lambda {\mathrm{v}}^0-\eta \nabla L\left(w^0\right)$；
3. $w^1=w^0+v^1$,计算$g^1$,$v^2=\lambda v^1-\eta \nabla L\left(w^1\right)$;
   4.重复上述过程，$w^{k+1}=w^k+vk+1$,$v^{k+2}=\lambda v^{k+1}-\eta \nabla L\left(w^{k+1}\right)$

$v^k$其实是之前所有梯度的和，即${\sum }_{i=1}^{k-1}\nabla L\left(w^i\right)$;
因为：
$$\begin{gathered} \begin{array}{rl}{\mathrm{v}}^0& =0\\ {\mathrm{v}}^1& =-\eta \nabla L\left(w^0\right)\\ {\mathrm{v}}^2& =-\lambda \eta \nabla L\left(w^0\right)-\eta \nabla L\left(w^1\right)\end{array} \\ ... \end{gathered}$$
（上述做法可以在Adam中找到原型。）

比较几种梯度下降的优缺点

1，批量梯度下降法（Batch Gradient Descent） ：在更新参数时每次都使用所有的样本组成一个矩阵来对参数进行更新。

优点：全局最优解，能保证每一次更新权值，都能降低损失函数；易于并行实现。

缺点：当样本数目很多时，训练过程会很慢。

2，随机梯度下降法（Stochastic Gradient Descent）：在更新参数时每次只使用一个样本来进行更新。每一次跟新参数都用一个样本，更新很多次。如果样本量很大的情况（例如几十万），那么可能只用其中几万条或者几千条的样本，就已经将参数迭代到最优解了，对比上面的批量梯度下降，迭代一次需要用到十几万训练样本，一次迭代不可能最优，如果迭代10次的话就需要遍历训练样本10次，这种方式计算复杂度太高。

优点：训练速度快；

缺点：准确度下降，并不是全局最优；不易于并行实现。从迭代的次数上来看，随机梯度下降法迭代的次数较多，在解空间的搜索过程看起来很盲目。噪音很多，使得它并不是每次迭代都向着整体最优化方向。

3，小批量梯度下降法（Mini-batch Gradient Descen）：在更新每一参数时都使用一部分样本来进行更新。例如，有样本30w,batch_size=100，需迭代3000次，而随机梯度下降需迭代30w次，克服上面两种方法的缺点，又同时兼顾两种方法的优点。运用了GPU并行计算的优点。
　　

4，三种方法使用的情况：如果样本量比较小，采用批量梯度下降算法。如果样本太大，或者在线算法，使用随机梯度下降算法。在实际的一般情况下，采用小批量梯度下降算法。

数学知识（仅做了解）

学过泰勒公式的同学可以知道，假设一个函数$h(x)在x=x_0的邻域内n阶可导$，则：
$$\begin{array}{rl}h(x)& =\sum _{k=0}^{\infty }\frac{h^{(k)}\left(x_0\right)}{k!}{\left(x-x_0\right)}^k\\ & =h\left(x_0\right)+h^{\prime }\left(x_0\right)\left(x-x_0\right)+\frac{h^{\prime \prime }\left(x_0\right)}{2!}{\left(x-x_0\right)}^2+\dots \end{array}$$
$$当x->x_0时，h(x)\approx h\left(x_0\right)+h^{\prime }\left(x_0\right)\left(x-x_0\right)$$
多元函数的情况：
$$h(x,y)=h\left(x_0,y_0\right)+\frac{\partial h\left(x_0,y_0\right)}{\partial x}\left(x-x_0\right)+\frac{\partial h\left(x_0,y_0\right)}{\partial y}\left(y-y_0\right)+...$$
$$当(x,y)->(x_0,y_0)时，h(x,y)\approx h\left(x_0,y_0\right)+\frac{\partial h\left(x_0,y_0\right)}{\partial x}\left(x-x_0\right)+\frac{\partial h\left(x_0,y_0\right)}{\partial y}\left(y-y_0\right)$$
有二元函数$L(x,y),n$阶可偏导，在（$a,b$）这一点展开，则
$$\mathrm{L}(x，y)\approx \mathrm{L}(a,b)+\frac{\partial \mathrm{L}(a,b)}{\partial x}\left(x-a\right)+\frac{\partial \mathrm{L}(a,b)}{\partial y}\left(y-b\right)$$
令：$s=L(a,b),u=\frac{\partial \mathrm{L}(a,b)}{\partial x},v=\frac{\partial \mathrm{L}(a,b)}{\partial y};$
则$$L(a,b)\approx s+u（x-a）+v(y-b)$$
在邻域${\left(x-a\right)}^2+{\left(y-b\right)}^2\le d^2$内找到使$L(x,y)$最小的点，即与梯度相反的方向，

即：$$\left[\begin{array}{l}x-a\\ y-b\end{array}\right]=\left[\begin{array}{c}\Delta x\\ \Delta y\end{array}\right]=-\eta \left[\begin{array}{l}u\\ v\end{array}\right]$$
可得：
$$\left[\begin{array}{l}x\\ y\end{array}\right]=\left[\begin{array}{l}a\\ b\end{array}\right]-\eta \left[\begin{array}{l}u\\ v\end{array}\right]=\left[\begin{array}{l}a\\ b\end{array}\right]-\eta \left[\begin{array}{c}\frac{\partial \mathrm{L}(a,b)}{\partial x}\\ \frac{\partial \mathrm{L}(a,b)}{\partial y}\end{array}\right]，\eta 要足够小$$
由此推出梯度下降原理。

def gradient(X,Y,options):
    m,n=X.shape
    theta=np.zeros((n,1))#参数
    cost=J(theta,X,Y)#代价函数
    costs=[cost]
    thetas=[theta]#保存参数
    
    alpha=options.get('alpha',0.01)#学习率
    epsilon=options.get('epsilon',0.00001)#迭代阙值
    maxloop=options.get('maxloop',1000)#最大迭代次数
    theLambda=float(options.get('theLambda',0))#正则化系数
    method=options.get('method','bgd')
    #随机梯度下降
    def _sgd(theta):
        count=0
        converged=False
        while count<maxloop:
            if converged:
                break
                
            for i in range(m):
                h=sigmoid(np.dot(X[i].reshape((1,n)),theta))#逻辑回归
                #np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等
                theta=theta-alpha*((1.0/m)*X[i].reshape((n,1))*(h-Y[i])+(theLambda/m)*np.r_[[[0]],theta[1:]])
                thetas.append(theta)
                cost=J(theta,X,Y,theLambda)
                costs.append(cost)
                if abs(costs[-1]-costs[-2])<epsilon:
                    converged=True
                    break
            count+=1
        return thetas,costs,count
    #批量梯度下降
    def _bgd(theta):
        count=0
        converged=False
        while count<maxloop:
            if converged:
                break
            h=sigmoid(np.dot(X,theta))
            theta=theta-alpha*((1.0/m)*np.dot(X.T,(h-Y))+(theLambda/m)*np.r_[[[0]],theta[1:]])
            thetas.append(theta)
            cost=J(theta,X,Y,theLambda)
            costs.append(cost)
            if abs(costs[-1]-costs[-2])<epsilon:
                converged=True
                break
            count+=1
        return thetas,costs,count
    methods={'sgd':_sgd,'bgd':_bgd}
    return methods[method](theta)