这篇博客主要是想介绍一下自己对梯度下降的理解，在以往学习过程中我陷入了两个误区。
 
误区1：不求甚解，只是知道梯度下降是用来参数调优的一种方法。
误区2：死钻牛角尖，陷入梯度下降的数学过程中无法自拔。
 
 
前些日自己重新梳理了一下这部分内容，又学习了一下台湾李宏毅老师的视频课程，茅塞顿开，因此在这里做一下整理，和大家一起讨论。
 
 
既然想讲介绍的是梯度下降的来龙去脉，我将从以下角度展开讲解，首先简介梯度是什么，然后讲解为什么机器学习中会用到梯度下降，重点讲解机器学习中梯度下降的使用方法，最后再尽量补充一些梯度下降背后更深层次的数学机理。总而言之也就是是什么，为什么，怎么做。
 
梯度是什么
 
1 .一元函数的导数和微分
 
梯度是一个方向，沿这个方向函数变化最快。对于一元函数来说，函数$f(x)$只能随自变量$x$变化，也就是只能沿$x$轴方向变化，而在某一点$x_0$变化的快慢则可以用这一点的斜率即导数$f'(x_0)$来表示。更近一步用图1来说明一元函数的微分，一元微分$dy$代表的是切线的增量，常常用它来近似函数的变化量，也就是微积分的精髓“以直代曲”。 
 
 
 
 
  
 
 图1 一元函数的导数和微分 
 
 
 

 现在我们已经回顾了一元函数的导数和微分，对于多元函数，后面都用二元函数

$z=f(x,y)$为例来说明多元函数的梯度是什么东东。（因为三元或超多元函数的图像实在是太难画了）。
 
2.多元函数的偏导，方向导数和梯度
 
偏导 
 对于多元函数$f(x,y)$来说，函数的图像通常是一个曲面。而你在曲面上由一个点$(x_0,y_0)$走到另一个点$(x_1,y_1)$也只能是走一条路径（曲线）出来，而从一个点走到另一个点会有无数种不同的走法。 
 
   
   
 
    
   
 
   
 首先我们考虑简单的，即我们只沿坐标轴方向走，如上图所示。如果我们只沿$x$轴方向走，即从$M_0$点走到$M_1$点，很显然路径就是这两点之间的红色部分，这个路径处于$y=y_0$和我们的曲面的交线上。如果我们想知道我们沿着这个路径走多快就能到达，那么就类似于一元函数，只需要在这一点对这条路做切线$T_X$，切线对$x$轴的斜率即为这一点的偏导数$f'_x(x_0,y_0)$.而$f'_y(x_0,y_0)$与之类似。 
 现在我们总结一下偏导数即函数在某一点方向沿坐标轴方向的变化率。事实上过$M_0$点不有无数条曲线，无数条路径，每一条路径都可以表示我们沿某一方向前行。而对这一条路径在$M_0$点做切线即可得到函数沿这一方向的变化率，所以，方向导数的概念就出来了，函数沿某一方向的变化率即方向导数。
方向导数 
 那么方向导数如何求呢？$x$方向和$y$方向的斜率可以由偏导求得，那么我们可以用这两个偏导来表示任何方向的斜率即方向导数（类似于一个平面内的所有向量可以用两个基向量来表示，不知道为什么好像我们的高数很少说这一点，只是告诉我们怎么计算）。现在我们有这个需求，想求出$u$方向的斜率怎么办。同样假设$z=f(x,y)$为一个曲面，$p(x_0，y_0)$为定义域上任意一点，任意单位向量$u=cos\theta i+sin\theta j$其中 $\theta$为向量$u$与$x$轴的夹角，当$\theta$不断变化时向量$u$可以取任意方向，如下图所示。 

 

 

 

梯度 

同时可以证明$D_uf(x,y)=f_x(x,y)cos\theta+f_y(x,y)sin\theta$。此时，设$A=(f_x(x,y),f_y(x,y))$,同样可以证明沿这个方向$D_uf(x,y)$值最大。那么这个方向即为梯度！证明过程我会在下一篇博客详细证明，即为什么梯度方向为变化最快的方向，也会顺便证明$D_uf(x,y)=f_x(x,y)cos\theta+f_y(x,y)sin\theta$这个等式。
  
 
好了啰嗦了这么多，相信大家对于什么是梯度有了一定了解，下面我会讲解为什么机器学习中会用到梯度下降，这里主要是参考李宏毅老师的视频课程来讲解，同样链接会放在文末。
 
为什么采用梯度下降
 
首先我们机器学习，简单来说就是要find一个function，而这个function可以根据我们的input返回一个值，当然这个function里面包含许多参数，这些参数取哪些值是需要我们学习的，而梯度下降正是我们学习参数的一个好方法。 
 这里冒昧的借用李老师的例子。即假如我们手里有 $10$只神奇宝贝的资料，我们知道其中每只神奇宝贝进化前的$cp$值和进化后的$cp$值，想用这些数据来预测其他任意一只神奇宝贝进化后的$cp$值。 
 那么我们假设神奇宝贝进化前和进化后的$cp$值可以用以下函数$f(x)$表示： 
 
 $$y=b+w*x$$  

 其中

$x$是进化前的$cp$值，

$y$是进化后的。其中，$w$和

$b$可以取任何值，那么我们可以用这个函数对我们所有的这十只神奇宝贝的拟合程度来反映这组参数的好坏。即如以下公式： 

 $$L(f)=L(W,B)=\sum_{i=1}^{10}(\hat{y}^n-(b+w*x^n))^2$$  

 

$L$越小，说明函数拟合效果越好，这组参数就越优。因此，我们的目标就是找到一组参数使$L$最小。 即如以下公式： 

 

 $$w^*,b^*=\mathop{\arg\min}_{w,b}{\sum_{i=1}^{10}(\hat{y}^n-(b+w*x^n))^2}$$  

 通常的做法是我们随机选取一个初始的参数

$(w^0,b^0)$,然后我们想不断寻找到函数

$L(w,b)$的最低点，最低点的位置

$（w^*,b^*）$即为我们想要的最优参数。 

 那么我们怎么才能找到这个最低点呢，如下图所示，这就需要用到梯度啦，既然梯度是函数变化最快的方向，那我们让函数沿梯度方向一直走，设置合适的步长，岂不是就可以到达这个最低点啦。 

 

 
 
 
  
 
 
 

 即我们初始选取参数为

$（w^0,b^0）$,然后我们设置合适的步长

$\eta$,下一时刻

$（w^1,b^1）$为： 

 

 $$（w^1,b^1）=(w^0,b^0)-\eta \nabla L$$  

 而

$\nabla L$即为函数在

$（w^0,b^0）$的梯度，如下所示： 

 

 $$\nabla L_{(w^0,b^0)}=[\frac{\delta L}{\delta w}|_{(w^0,b^0)},\frac{\delta L}{\delta b}|_{(w^0,b^0)}]^T$$  

 然后按照上述公式不断迭代，最后我们就可以取得一个较优的

$(w,b)$值，当然在实际操作过程中会有很多技巧，我同样会在下一篇博客中讲解。
 
 
到这，我自认为算是讲清楚了梯度下降的来龙，当然也参考了知乎上的好多回答，希望读者可以和我讨论交流。这里我强烈推荐观看李老师的视频课程，李老师台湾口音，让我有一种看偶像剧的感觉，很奇妙。
 
 
参考文献
 
[1]知乎关于梯度下降讲解的连接：https://www.zhihu.com/question/36301367#answer-22165770 
 [2]李宏毅的机器学习课程：http://speech.ee.ntu.edu.tw/~tlkagk/courses_ML16.html
 
 
初夏很让人焦躁不安，希望我能够尽快写出下一篇，尽量在盛夏，不要拖到秋季。

 
博文目录
 
1. 概述
2. 梯度下降算法
2.1 场景假设
2.2 梯度下降
2.2.1 微分
2.2.2 梯度
      
2.3 数学解释
2.3.1 α
2.3.2 梯度要乘以一个负号
     
     
3. 实例
3.1 单变量函数的梯度下降
3.2 多变量函数的梯度下降
     
4. 代码实现
4. 1 场景分析
4. 2 代码
     
5. 小结
   
  
 

 
1. 概述
 
梯度下降（gradient descent）在机器学习中应用十分的广泛，不论是在线性回归还是Logistic回归中，它的主要目的是通过迭代找到目标函数的最小值，或者收敛到最小值。
 本文将从一个下山的场景开始，先提出梯度下降算法的基本思想，进而从数学上解释梯度下降算法的原理，解释为什么要用梯度，最后实现一个简单的梯度下降算法的实例！
 
2. 梯度下降算法
 
2.1 场景假设
 
梯度下降法的基本思想可以类比为一个下山的过程。
 假设这样一个场景：一个人被困在山上，需要从山上下来(找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低；因此，下山的路径就无法确定，必须利用自己周围的信息一步一步地找到下山的路。这个时候，便可利用梯度下降算法来帮助自己下山。怎么做呢，首先以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着下降方向走一步，然后又继续以当前位置为基准，再找最陡峭的地方，再走直到最后到达最低处；同理上山也是如此，只是这时候就变成梯度上升算法了
 
 
2.2 梯度下降
 
梯度下降的基本过程就和下山的场景很类似。
 
首先，我们有一个可微分的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值，也就是山底。根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数之变化最快的方向(在后面会详细解释)
 所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。那么为什么梯度的方向就是最陡峭的方向呢？接下来，我们从微分开始讲起：
 
2.2.1 微分
 
看待微分的意义，可以有不同的角度，最常用的两种是：
 
函数图像中，某点的切线的斜率
函数的变化率
 几个微分的例子：
 
1.单变量的微分，函数只有一个变量时
 
$\frac{d(x^2)}{dx}=2x$
 
$\frac{d(-2y^5)}{dy}=-10y^4$
 
$\frac{d(5-\theta {)}^2}{d\theta }=-2(5-\theta )$
 
2.多变量的微分，当函数有多个变量的时候，即分别对每个变量进行求微分
 
$\frac{\partial }{\partial x}(x^2{y}^2)=2x{y}^2$
 
$\frac{\partial }{\partial y}(-2y^5+z^2)=-10y^4$
 
$\frac{\partial }{\partial {\theta }_2}(5{\theta }_1+2{\theta }_2-12{\theta }_3)=2$
 
$\frac{\partial }{\partial {\theta }_2}(0.55-(5{\theta }_1+2{\theta }_2-12{\theta }_3))=-2$
 
2.2.2 梯度
 
梯度实际上就是多变量微分的一般化。
 下面这个例子：
 
$J(\Theta )=0.55-(5{\theta }_1+2{\theta }_2-12{\theta }_3)$
 
$▽J(\Theta )=⟨\frac{\partial J}{\partial {\theta }_1},\frac{\partial J}{\partial {\theta }_2},\frac{\partial J}{\partial {\theta }_3}⟩=(-5,-2,12)$
 
我们可以看到，梯度就是分别对每个变量进行微分，然后用逗号分割开，梯度是用<>包括起来，说明梯度其实一个向量。
 
梯度是微积分中一个很重要的概念，之前提到过梯度的意义
 
在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率
在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向
 
这也就说明了为什么我们需要千方百计的求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的方向一直走，就能走到局部的最低点！
 
2.3 数学解释
 
首先给出数学公式：
 
${\Theta }^1={\Theta }^0+\alpha ▽J(\Theta )\to evaluatedat{\Theta }^0$
 
此公式的意义是：J是关于Θ的一个函数，我们当前所处的位置为Θ0点，要从这个点走到J的最小值点，也就是山底。首先我们先确定前进的方向，也就是梯度的反向，然后走一段距离的步长，也就是α，走完这个段步长，就到达了Θ1这个点！
 
 
2.3.1 α
 
α在梯度下降算法中被称作为学习率或者步长，意味着我们可以通过α来控制每一步走的距离，以保证不要步子跨的太大扯着蛋，哈哈，其实就是不要走太快，错过了最低点。同时也要保证不要走的太慢，导致太阳下山了，还没有走到山下。所以α的选择在梯度下降法中往往是很重要的！α不能太大也不能太小，太小的话，可能导致迟迟走不到最低点，太大的话，会导致错过最低点！
 
2.3.2 梯度要乘以一个负号
 
梯度前加一个负号，就意味着朝着梯度相反的方向前进！我们在前文提到，梯度的方向实际就是函数在此点上升最快的方向！而我们需要朝着下降最快的方向走，自然就是负的梯度的方向，所以此处需要加上负号；那么如果时上坡，也就是梯度上升算法，当然就不需要添加负号了。
 
3. 实例
 
我们已经基本了解了梯度下降算法的计算过程，那么我们就来看几个梯度下降算法的小实例，首先从单变量的函数开始，然后介绍多变量的函数。
 
3.1 单变量函数的梯度下降
 
我们假设有一个单变量的函数
 
$J(\theta )={\theta }^2$
 
函数的微分，直接求导就可以得到
 
$J^{\prime }(\theta )=2\theta$
 
初始化，也就是起点，起点可以随意的设置，这里设置为1
 
${\theta }^0=1$
 
学习率也可以随意的设置，这里设置为0.4
 
$\alpha =0.4$
 
根据梯度下降的计算公式
 
${\Theta }^1={\Theta }^0+\alpha ▽J(\Theta )\to evaluatedat{\Theta }^0$
 
我们开始进行梯度下降的迭代计算过程：
 
${\theta }^0=1$
 
${\theta }^1={\theta }^0-\alpha \ast J^{\prime }({\theta }^0)=1-0.4\ast 2=0.2$
 
${\theta }^2={\theta }^1-\alpha \ast J^{\prime }({\theta }^1)=0.2-0.4\ast 0.4=0.04$
 
${\theta }^3=0.008$
 
${\theta }^4=0.0016$
 
如图，经过四次的运算，也就是走了四步，基本就抵达了函数的最低点，也就是山底
 
 
3.2 多变量函数的梯度下降
 
我们假设有一个目标函数
 
$J(\Theta )={\theta }_1^2+{\theta }_2^2$
 
现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0，0)点。但是接下来，我们会从梯度下降算法开始一步步计算到这个最小值！
 我们假设初始的起点为：
 
${\Theta }^0=(1,3)$
 
初始的学习率为：
 
$\alpha =0.1$
 
函数的梯度为：
 
$▽J(\Theta )=⟨2{\theta }_1,2{\theta }_2⟩$
 
进行多次迭代：
 
${\Theta }^0=(1,3)$
 
${\Theta }^1={\Theta }^0-\alpha ▽J(\Theta )=(1,3)-0.1\ast (2,6)=(0.8,2.4)$
 
${\Theta }^2=(0.8,2.4)-0.1\ast (1.6,4.8)=(0.64,1.92)$
 
${\Theta }^3=(0.5124,1.536)$
 
${\Theta }^4=(0.4096,1.228800000000001)$
 $⋮$
 ${\Theta }^{10}=(0.1073741824000003,0.32212254720000005)$
 $⋮$
 ${\Theta }^{50}=(1.141798154164342e^{-05},3.42539442494306e^{-05})$
 $⋮$
 ${\Theta }^{100}=(1.6296287810675902e^{-10},4.8888886343202771e^{-10})$
 
我们发现，已经基本靠近函数的最小值点
 
 
4. 代码实现
 
4. 1 场景分析
 
下面我们将用python实现一个简单的梯度下降算法。场景是一个简单的线性回归的例子：假设现在我们有一系列的点，如下图所示：
 
 我们将用梯度下降法来拟合出这条直线！
 
首先，我们需要定义一个代价函数，在此我们选用均方误差代价函数（也称平方误差代价函数）
 
$J(\Theta )=\frac{1}{2m}{\sum }_{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}{)}^2$
 
此公式中
 
m是数据集中数据点的个数，也就是样本数
½是一个常量，这样是为了在求梯度的时候，二次方乘下来的2就和这里的½抵消了，自然就没有多余的常数系数，方便后续的计算，同时对结果不会有影响
y 是数据集中每个点的真实y坐标的值，也就是类标签
h 是我们的预测函数（假设函数），根据每一个输入x，根据Θ 计算得到预测的y值，即
 
$h_{\Theta }(x^{(i)})={\Theta }_0+{\Theta }_1{x}_1^{(i)}$
 
我们可以根据代价函数看到，代价函数中的变量有两个，所以是一个多变量的梯度下降问题，求解出代价函数的梯度，也就是分别对两个变量进行微分
 
$▽J(\Theta )=⟨\frac{\delta J}{\delta {\Theta }_0},\frac{\delta J}{\delta {\Theta }_1}⟩$
 
$\frac{\delta J}{\delta {\Theta }_0}=\frac{1}{m}{\sum }_{i=1}^m(h_{\Theta }(x^{(i)})-y^{(i)})$
 
$\frac{\delta J}{\delta {\Theta }_1}=\frac{1}{m}{\sum }_{i=1}^m(h_{\Theta }(x^{(i)})-y^{(i)})x_1^{(i)}$
 
明确了代价函数和梯度，以及预测的函数形式。我们就可以开始编写代码了。但在这之前，需要说明一点，就是为了方便代码的编写，我们会将所有的公式都转换为矩阵的形式，python中计算矩阵是非常方便的，同时代码也会变得非常的简洁。
 为了转换为矩阵的计算，我们观察到预测函数的形式
 
$h_{\Theta }(x^{(i)})={\Theta }_0+{\Theta }_1{x}^{(i)}$
 
我们有两个变量，为了对这个公式进行矩阵化，我们可以给每一个点x增加一维，这一维的值固定为1，这一维将会乘到Θ0上。这样就方便我们统一矩阵化的计算
 
$(x_1^{(i)},y^{(i)})\to (x_0^{(i)},x_1^{(i)},y^{(i)})with{x}_0^{(i)}=1{\forall }_i$
 
然后我们将代价函数和梯度转化为矩阵向量相乘的形式
 
$J(\Theta )=\frac{1}{2m}(X\Theta -\vec{y}{)}^T(X\Theta -\vec{y})$
 
$▽J(\Theta )=\frac{1}{m}{X}^T(X\Theta -\vec{y}))$
 
4. 2 代码
 
首先，我们需要定义数据集和学习率
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2019/1/21 21:06
# @Author  : Arrow and Bullet
# @FileName: gradient_descent.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/qq_41800366

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，也就是x0，全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
y = np.array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01
 
接下来我们以矩阵向量的形式定义代价函数和代价函数的梯度
 
# 定义代价函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)


# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)
 
最后就是算法的核心部分，梯度下降迭代计算
 
# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5):
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])
 
当梯度小于1e-5时，说明已经进入了比较平滑的状态，类似于山谷的状态，这时候再继续迭代效果也不大了，所以这个时候可以退出循环！
 运行代码，计算得到的结果如下：
 
print('optimal:', optimal)  # 结果 [[0.51583286][0.96992163]]
print('cost function:', cost_function(optimal, X, Y)[0][0])  # 1.014962406233101
 
通过matplotlib画出图像，
 
# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 这是我改的
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)
 
所拟合出的直线如下
 
 全部代码如下，大家有兴趣的可以复制下来跑一下看一下结果：
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2019/1/21 21:06
# @Author  : Arrow and Bullet
# @FileName: gradient_descent.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/qq_41800366

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，也就是x0，全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
Y = array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01


# 定义代价函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)


# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)


# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5):
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])


# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 这是我改的
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)
 
5. 小结
 
至此，就基本介绍完了梯度下降法的基本思想和算法流程，并且用python实现了一个简单的梯度下降算法拟合直线的案例！
 最后，我们回到文章开头所提出的场景假设:
 这个下山的人实际上就代表了反向传播算法，下山的路径其实就代表着算法中一直在寻找的参数Θ，山上当前点的最陡峭的方向实际上就是代价函数在这一点的梯度方向，场景中观测最陡峭方向所用的工具就是微分 。在下一次观测之前的时间就是有我们算法中的学习率α所定义的。
 可以看到场景假设和梯度下降算法很好的完成了对应！
 
本文部分内容来自一位前辈，非常感谢分享！谢谢！

 

 

 
 
 
 引言
 
 
 
       梯度下降法 (Gradient Descent Algorithm，GD) 是为目标函数J(θ)，如代价函数(cost function), 求解全局最小值（Global Minimum）的一种迭代算法。本文会详细讨论按照准确性和耗费时间（accuracy and time consuming factor）将梯度下降法进行分类。这个算法在机器学习中被广泛用来最小化目标函数，如下图所示。
 
 

  
  
 
 
 
 
 
  
 为什么使用梯度下降法
 
 
 
 

        
  我们使用梯度下降法最小化目标函数J(θ)。在使用梯度下降法时，首先初始化参数值，然后一直改变这些值，直到得到全局最小值。其中，我们计算在每次迭代时计算代价函数的导数，然后使用如下公式同时更新参数值： 
  
 
 
 
 
 

  
  
 
 
 
 
 
  
 α表示学习速率（learning rate）。
 
  
 在本文中，考虑使用线性回归（linear regression）作为算法实例，当然梯度下降法也可以应用到其他算法，如逻辑斯蒂回归（Logistic regression）和 神经网络（Neural networks）。在线性回归中，我们使用如下拟合函数（hypothesis function）:
 
  
 
 
 
  
 其中， 是参数， 是输入特征。为了求解线性回归模型，需要找到合适的参数使拟合函数能够更好地适合模型，然后使用梯度下降最小化代价函数J(θ)。
 
  
 代价函数(普通的最小平方差，ordinary least square error)如下所示：
 
  
 
 
 
  
 代价函数的梯度（Gradient of Cost function）：
 
  
 
 
 
  
 参数与代价函数关系如下图所示：
 
  
 
 
 
  
 梯度下降法的工作原理
 
  

    
   

    下面的伪代码能够解释其详细原理：
   
 
   

    1.
     初始化参数值
   
 
   

    2.
     迭代更新这些参数使目标函数J(θ)不断变小。
   
 
  
 
  
 
 
  
 
 
 
 
 
 
  
 梯度下降法的类型
 
 
 
 
 
  
 基于如何使用数据计算代价函数的导数，梯度下降法可以被定义为不同的形式（various variants）。确切地说，根据使用数据量的大小（the amount of data），时间复杂度（time complexity）和算法的准确率（accuracy of the algorithm），梯度下降法可分为：
 
  
 1.       批量梯度下降法（Batch Gradient Descent, BGD）；
 
  
 2.       随机梯度下降法（Stochastic Gradient Descent, SGD）；
 
  
 3.       小批量梯度下降法（Mini-Batch Gradient Descent, MBGD）。
 
  
 批量梯度下降法原理
 
 
 
 

        
  这是梯度下降法的基本类型，这种方法
  使用整个数据集（
  the complete dataset
  ）去计算代价函数的梯度
  。每次使用全部数据计算梯度去更新参数，
  批量梯度下降法会很慢
  ，并且很难处理不能载入内存（
  don’t fit in memory
  ）的数据集。在随机初始化参数后，按如下方式计算代价函数的梯度： 
  
 
 
 
 
 

  
  
 
 
 
 
 
  
 其中，m是训练样本（training examples）的数量。
 
  
 Note:
 
  
      1. 如果训练集有3亿条数据，你需要从硬盘读取全部数据到内存中；
 
  
      2. 每次一次计算完求和后，就进行参数更新；
 
  
      3.  然后重复上面每一步；
 
  
      4. 这意味着需要较长的时间才能收敛；
 
  
      5. 特别是因为磁盘输入/输出（disk I/O）是系统典型瓶颈，所以这种方法会不可避免地需要大量的读取。
 
  
 
 
 
  
 上图是每次迭代后的等高线图，每个不同颜色的线表示代价函数不同的值。运用梯度下降会快速收敛到圆心，即唯一的一个全局最小值。
 
  
 批量梯度下降法不适合大数据集。下面的Python代码实现了批量梯度下降法：
 
  
 
 
 
  
1.	import numpy as np  
2.	import random  
3.	def gradient_descent(alpha, x, y, ep=0.0001, max_iter=10000):  
4.	    converged = False  
5.	    iter = 0  
6.	    m = x.shape[0] # number of samples  
7.	  
8.	    # initial theta  
9.	    t0 = np.random.random(x.shape[1])  
10.	    t1 = np.random.random(x.shape[1])  
11.	  
12.	    # total error, J(theta)  
13.	    J = sum([(t0 + t1*x[i] - y[i])**2 for i in range(m)])  
14.	  
15.	    # Iterate Loop  
16.	    while not converged:  
17.	        # for each training sample, compute the gradient (d/d_theta j(theta))  
18.	        grad0 = 1.0/m * sum([(t0 + t1*x[i] - y[i]) for i in range(m)])   
19.	        grad1 = 1.0/m * sum([(t0 + t1*x[i] - y[i])*x[i] for i in range(m)])  
20.	        # update the theta_temp  
21.	        temp0 = t0 - alpha * grad0  
22.	        temp1 = t1 - alpha * grad1  
23.	      
24.	        # update theta  
25.	        t0 = temp0  
26.	        t1 = temp1  
27.	  
28.	        # mean squared error  
29.	        e = sum( [ (t0 + t1*x[i] - y[i])**2 for i in range(m)] )   
30.	  
31.	        if abs(J-e) <= ep:  
32.	            print 'Converged, iterations: ', iter, '!!!'  
33.	            converged = True  
34.	      
35.	        J = e   # update error   
36.	        iter += 1  # update iter  
37.	      
38.	        if iter == max_iter:  
39.	            print 'Max interactions exceeded!'  
40.	            converged = True  
41.	  
42.	    return t0,t1 
 
  
 
 
  
 随机梯度下降法原理
 
  

      
   批量梯度下降法被证明是一个较慢的算法，所以，我们可以选择随机梯度下降法达到更快的计算。随机梯度下降法的第一步是随机化整个数据集。在每次迭代仅选择一个训练样本去计算代价函数的梯度，然后更新参数。即使是大规模数据集，随机梯度下降法也会很快收敛。随机梯度下降法得到结果的准确性可能不会是最好的，但是计算结果的速度很快。在随机化初始参数之后，使用如下方法计算代价函数的梯度：
   
 
  
 
  

   
 
  
 
  
 
   
 这里m表示训练样本的数量。
 
   
 如下为随机梯度下降法的伪码：
 
   
        1. 进入内循环（inner loop）;
 
   
        2. 第一步：挑选第一个训练样本并更新参数，然后使用第二个实例；
 
   
        3. 第二步：选第二个训练样本，继续更新参数；
 
   
        4. 然后进行第三步…直到第n步；
 
   
        5. 直到达到全局最小值
 
   如下图所示，随机梯度下降法不像批量梯度下降法那样收敛，而是游走到接近全局最小值的区域终止。 
   
 
 
  
 
  

   
   
 
  
 
  
 
   
 小批量梯度下降法原理
 
  
 
  
 
   
  小批量梯度下降法是最广泛使用的一种算法，该算法每次使用m个训练样本（称之为一批）进行训练，能够更快得出准确的答案。小批量梯度下降法不是使用完整数据集，在每次迭代中仅使用m个训练样本去计算代价函数的梯度。一般小批量梯度下降法所选取的样本数量在50到256个之间，视具体应用而定。
 
   
 1.这种方法减少了参数更新时的变化，能够更加稳定地收敛。
 
   
 2.同时，也能利用高度优化的矩阵，进行高效的梯度计算。
 
   随机初始化参数后，按如下伪码计算代价函数的梯度：
   
 
  
 
  

   
  
 
  

   这里b表示一批训练样本的个数，m是训练样本的总数。
 
  
 
  

   
 
  
 
  
 
   
 Notes:
 
   
 1. 实现该算法时，同时更新参数。
 
   
 
 
 
   
 2. 学习速率α（也称之为步长）。如果α过大，算法可能不会收敛；如果α比较小，就会很容易收敛。
 
   
 
 
 
   
 3. 检查梯度下降法的工作过程。画出迭代次数与每次迭代后代价函数值的关系图，这能够帮助你了解梯度下降法是否取得了好的效果。每次迭代后J(θ)应该降低，多次迭代后应该趋于收敛。
 
   
 
 
 
   
 
 
 
   
 4. 不同的学习速率在梯度下降法中的效果
 
   
 
 
 
   
 总结
 
   
 
    
 本文详细介绍了不同类型的梯度下降法。这些算法已经被广泛应用于神经网络。下面的图详细展示了3种梯度下降法的比较。
 
    
 
 
 
    

     
 
    
 
    

     
 
    
 
    

     另一篇文章介绍的内容：
    
 
    
 
     
 　在求解机器学习算法的模型参数，即无约束优化问题时，梯度下降（Gradient Descent）是最常采用的方法之一，另一种常用的方法是最小二乘法。这里就对梯度下降法做一个完整的总结。
 
     
 1. 梯度
 
     
 　　　　在微积分里面，对多元函数的参数求∂偏导数，把求得的各个参数的偏导数以向量的形式写出来，就是梯度。比如函数f(x,y), 分别对x,y求偏导数，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,简称grad f(x,y)或者▽f(x,y)。对于在点(x0,y0)的具体梯度向量就是(∂f/∂x0, ∂f/∂y0)T.或者▽f(x0,y0)，如果是3个参数的向量梯度，就是(∂f/∂x, ∂f/∂y，∂f/∂z)T,以此类推。
 
     
 　　　　那么这个梯度向量求出来有什么意义呢？他的意义从几何意义上讲，就是函数变化增加最快的地方。具体来说，对于函数f(x,y),在点(x0,y0)，沿着梯度向量的方向就是(∂f/∂x0, ∂f/∂y0)T的方向是f(x,y)增加最快的地方。或者说，沿着梯度向量的方向，更加容易找到函数的最大值。反过来说，沿着梯度向量相反的方向，也就是 -(∂f/∂x0, ∂f/∂y0)T的方向，梯度减少最快，也就是更加容易找到函数的最小值。
 
     
  　　　　
 
     
 2. 梯度下降与梯度上升
 
     
 　　　　在机器学习算法中，在最小化损失函数时，可以通过梯度下降法来一步步的迭代求解，得到最小化的损失函数，和模型参数值。反过来，如果我们需要求解损失函数的最大值，这时就需要用梯度上升法来迭代了。
 
     
 　　　　梯度下降法和梯度上升法是可以互相转化的。比如我们需要求解损失函数f(θ)的最小值，这时我们需要用梯度下降法来迭代求解。但是实际上，我们可以反过来求解损失函数 -f(θ)的最大值，这时梯度上升法就派上用场了。
 
     
 　　　　下面来详细总结下梯度下降法。        
 
     
 3. 梯度下降法算法详解
 
     
 3.1 梯度下降的直观解释
 
     
 　　　　首先来看看梯度下降的一个直观的解释。比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去，一直走到觉得我们已经到了山脚。当然这样走下去，有可能我们不能走到山脚，而是到了某一个局部的山峰低处。
 
     
 　　　　从上面的解释可以看出，梯度下降不一定能够找到全局的最优解，有可能是一个局部最优解。当然，如果损失函数是凸函数，梯度下降法得到的解就一定是全局最优解。
 
     
 
 
     
 3.2 梯度下降的相关概念
 
     
 　　　　在详细了解梯度下降的算法之前，我们先看看相关的一些概念。
 
     
 　　　　1. 步长（Learning rate）：步长决定了在梯度下降迭代的过程中，每一步沿梯度负方向前进的长度。用上面下山的例子，步长就是在当前这一步所在位置沿着最陡峭最易下山的位置走的那一步的长度。
 
     
 　　　　2.特征（feature）：指的是样本中输入部分，比如样本（x0,y0）,（x1,y1）,则样本特征为x，样本输出为y。
 
     
 　　　　3. 假设函数（hypothesis function）：在监督学习中，为了拟合输入样本，而使用的假设函数，记为hθ(x)。比如对于样本（xi,yi）(i=1,2,...n),可以采用拟合函数如下： hθ(x) = θ0+θ1x。
 
     
 　　　　4. 损失函数（loss function）：为了评估模型拟合的好坏，通常用损失函数来度量拟合的程度。损失函数极小化，意味着拟合程度最好，对应的模型参数即为最优参数。在线性回归中，损失函数通常为样本输出和假设函数的差取平方。比如对于样本（xi,yi）(i=1,2,...n),采用线性回归，损失函数为：
 
     
              
       
        
       J(θ0,θ1)=∑i=1m(hθ(xi)−yi)2
 
     
  　　　　其中
       
        
       xi表示样本特征x的第i个元素，
       
        
       yi表示样本输出y的第i个元素，
       
        
       hθ(xi)为假设函数。   
 
     
 3.3 梯度下降的详细算法
 
     
 　　　　梯度下降法的算法可以有代数法和矩阵法（也称向量法）两种表示，如果对矩阵分析不熟悉，则代数法更加容易理解。不过矩阵法更加的简洁，且由于使用了矩阵，实现逻辑更加的一目了然。这里先介绍代数法，后介绍矩阵法。
 
     
  
 
     
 3.3.1 梯度下降法的代数方式描述
 
     
 　　　　1. 先决条件： 确认优化模型的假设函数和损失函数。
 
     
 　　　　比如对于线性回归，假设函数表示为 
       
        
       hθ(x1,x2,...xn)=θ0+θ1x1+...+θnxn, 其中
       
        
       θi (i = 0,1,2... n)为模型参数，
       
        
       xi (i = 0,1,2... n)为每个样本的n个特征值。这个表示可以简化，我们增加一个特征
       
        
       x0=1 ，这样
       
        
       hθ(x0,x1,...xn)=∑i=0nθixi。
 
     
 　　　　同样是线性回归，对应于上面的假设函数，损失函数为：
 
     
            
       
        
       J(θ0,θ1...,θn)=12m∑i=0m(hθ(x0,x1,...xn)−yi)2
 
     
  
 
     
 　　　　2. 算法相关参数初始化：主要是初始化
       
        
       θ0,θ1...,θn,算法终止距离
       
        
       ε以及步长
       
        
       α。在没有任何先验知识的时候，我喜欢将所有的
       
        
       θ初始化为0， 将步长初始化为1。在调优的时候再 优化。
 
     
 　　　　3. 算法过程：
 
     
 　　　　　　1）确定当前位置的损失函数的梯度，对于
       
        
       θi,其梯度表达式如下：
 
     
 　　　　　　　　
       
        
       ∂∂θiJ(θ0,θ1...,θn)
 
     
 　　　　　　2）用步长乘以损失函数的梯度，得到当前位置下降的距离，即
       
        
       α∂∂θiJ(θ0,θ1...,θn)对应于前面登山例子中的某一步。
 
     
 　　　　　　3）确定是否所有的
       
        
       θi,梯度下降的距离都小于
       
        
       ε，如果小于
       
        
       ε则算法终止，当前所有的
       
        
       θi(i=0,1,...n)即为最终结果。否则进入步骤4.
 
     
 　　　　　　4）更新所有的
       
        
       θ，对于
       
        
       θi，其更新表达式如下。更新完毕后继续转入步骤1.
 
     
 　　　　　　　　
       
        
       θi=θi−α∂∂θiJ(θ0,θ1...,θn)
 
     
 　　　　下面用线性回归的例子来具体描述梯度下降。假设我们的样本是
       
        
       (x1(0),x2(0),...xn(0),y0),(x1(1),x2(1),...xn(1),y1),...(x1(m),x2(m),...xn(m),yn),损失函数如前面先决条件所述：
 
     
 　　　　
       
        
       J(θ0,θ1...,θn)=12m∑i=0m(hθ(x0,x1,...xn)−yi)2。
 
     
 　　　　则在算法过程步骤1中对于
       
        
       θi 的偏导数计算如下： 　　
 
     
  　　　　
       
        
       ∂∂θiJ(θ0,θ1...,θn)=1m∑j=0m(hθ(x0j,x1j,...xnj)−yj)xij
 
     
 　　　　由于样本中没有
       
        
       x0上式中令所有的
       
        
       x0j为1.
 
     
 　　　　步骤4中
       
        
       θi的更新表达式如下：
 
     
            
       
        
       θi=θi−α1m∑j=0m(hθ(x0j,x1j,...xnj)−yj)xij
 
     
 　　　　从这个例子可以看出当前点的梯度方向是由所有的样本决定的，加
       
        
       1m 是为了好理解。由于步长也为常数，他们的乘机也为常数，所以这里
       
        
       α1m可以用一个常数表示。
 
     
 　　　　在下面第4节会详细讲到的梯度下降法的变种，他们主要的区别就是对样本的采用方法不同。这里我们采用的是用所有样本。
 
     
 3.3.2 梯度下降法的矩阵方式描述
 
     
 　　　　这一部分主要讲解梯度下降法的矩阵方式表述，相对于3.3.1的代数法，要求有一定的矩阵分析的基础知识，尤其是矩阵求导的知识。
 
     
 　　　　1. 先决条件： 和3.3.1类似， 需要确认优化模型的假设函数和损失函数。对于线性回归，假设函数
       
        
       hθ(x1,x2,...xn)=θ0+θ1x1+...+θnxn的矩阵表达方式为：
 
     
 　　　　　
       
        
       hθ(x)=Xθ ，其中， 假设函数
       
        
       hθ(X)为mx1的向量,
       
        
       θ为nx1的向量，里面有n个代数法的模型参数。
       
        
       X为mxn维的矩阵。m代表样本的个数，n代表样本的特征数。
 
     
              损失函数的表达式为：
       
        
       J(θ)=12(Xθ−Y)T(Xθ−Y), 其中
       
        
       Y是样本的输出向量，维度为mx1.
 
     
 　　　　2. 算法相关参数初始化: 
       
        
       θ向量可以初始化为默认值，或者调优后的值。算法终止距离
       
        
       ε，步长
       
        
       α和3.3.1比没有变化。
 
     
 　　　　3. 算法过程：
 
     
 　　　　　　1）确定当前位置的损失函数的梯度，对于
       
        
       θ向量,其梯度表达式如下：
 
     
 　　　　　　　　
       
        
       ∂∂θJ(θ)
 
     
 　　　　　　2）用步长乘以损失函数的梯度，得到当前位置下降的距离，即
       
        
       α∂∂θJ(θ)对应于前面登山例子中的某一步。
 
     
 　　　　　　3）确定
       
        
       θ向量里面的每个值,梯度下降的距离都小于
       
        
       ε，如果小于
       
        
       ε则算法终止，当前
       
        
       θ向量即为最终结果。否则进入步骤4.
 
     
 　　　　　　4）更新
       
        
       θ向量，其更新表达式如下。更新完毕后继续转入步骤1.
 
     
 　　　　　　　　
       
        
       θ=θ−α∂∂θJ(θ)
 
     
 　　　
 
     
 　　　　还是用线性回归的例子来描述具体的算法过程。
 
     
 　　　　损失函数对于
       
        
       θ向量的偏导数计算如下：