梯度 订阅
梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。 展开全文
梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。
信息
外文名
gradient
适用范围
数理科学
相关概念
方向导数
中文名
梯度
学    科
微积分学
性    质
向量
梯度定义
设二元函数 在平面区域D上具有一阶连续偏导数,则对于每一个点P(x,y)都可定出一个向量 ,该函数就称为函数 在点P(x,y)的梯度,记作gradf(x,y)或 ,即有:gradf(x,y)= = 其中 称为(二维的)向量微分算子或Nabla算子, 。设 是方向l上的单位向量,则 由于当方向l与梯度方向一致时,有 所以当l与梯度方向一致时,方向导数 有最大值,且最大值为梯度的模,即 因此说,函数在一点沿梯度方向的变化率最大,最大值为该梯度的模。 [1] 
收起全文
精华内容
下载资源
问答
  • 梯度下降算法原理讲解——机器学习

    万次阅读 多人点赞 2019-01-21 20:27:48
    详细来讲讲梯度下降算法的原理,感受数学和程序的魅力吧!!

    1. 概述

    梯度下降(gradient descent)在机器学习中应用十分的广泛,不论是在线性回归还是Logistic回归中,它的主要目的是通过迭代找到目标函数的最小值,或者收敛到最小值。
    本文将从一个下山的场景开始,先提出梯度下降算法的基本思想,进而从数学上解释梯度下降算法的原理,解释为什么要用梯度,最后实现一个简单的梯度下降算法的实例!

    2. 梯度下降算法

    2.1 场景假设

    梯度下降法的基本思想可以类比为一个下山的过程。
    假设这样一个场景:一个人被困在山上,需要从山上下来(找到山的最低点,也就是山谷)。但此时山上的浓雾很大,导致可视度很低;因此,下山的路径就无法确定,必须利用自己周围的信息一步一步地找到下山的路。这个时候,便可利用梯度下降算法来帮助自己下山。怎么做呢,首先以他当前的所处的位置为基准,寻找这个位置最陡峭的地方,然后朝着下降方向走一步,然后又继续以当前位置为基准,再找最陡峭的地方,再走直到最后到达最低处;同理上山也是如此,只是这时候就变成梯度上升算法了
    在这里插入图片描述

    2.2 梯度下降

    梯度下降的基本过程就和下山的场景很类似。

    首先,我们有一个可微分的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值,也就是山底。根据之前的场景假设,最快的下山的方式就是找到当前位置最陡峭的方向,然后沿着此方向向下走,对应到函数中,就是找到给定点的梯度 ,然后朝着梯度相反的方向,就能让函数值下降的最快!因为梯度的方向就是函数之变化最快的方向(在后面会详细解释)
    所以,我们重复利用这个方法,反复求取梯度,最后就能到达局部的最小值,这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向,也就是场景中测量方向的手段。那么为什么梯度的方向就是最陡峭的方向呢?接下来,我们从微分开始讲起:

    2.2.1 微分

    看待微分的意义,可以有不同的角度,最常用的两种是:

    • 函数图像中,某点的切线的斜率
    • 函数的变化率
      几个微分的例子:

    1.单变量的微分,函数只有一个变量时

    d(x2)dx=2x\frac{d(x^2)}{dx}=2x

    d(2y5)dy=10y4\frac{d(-2y^5)}{dy}=-10y^4

    d(5θ)2dθ=2(5θ)\frac{d(5-\theta )^2}{d\theta}=-2(5-\theta)

    2.多变量的微分,当函数有多个变量的时候,即分别对每个变量进行求微分

    x(x2y2)=2xy2\frac{\partial}{\partial x}(x^2y^2) = 2xy^2

    y(2y5+z2)=10y4\frac{\partial}{\partial y}(-2y^5+z^2) = -10y^4

    θ2(5θ1+2θ212θ3)=2\frac{\partial}{\partial \theta_{2}}(5\theta_{1} + 2\theta_{2} - 12\theta_{3}) = 2

    θ2(0.55(5θ1+2θ212θ3))=2\frac{\partial}{\partial \theta_{2}}(0.55 - (5\theta_{1} + 2\theta_{2} - 12\theta_{3})) = -2

    2.2.2 梯度

    梯度实际上就是多变量微分的一般化。
    下面这个例子:

    J(Θ)=0.55(5θ1+2θ212θ3)J(\Theta ) = 0.55 - (5\theta_{1} + 2\theta_{2} - 12\theta_{3})

    J(Θ)=<Jθ1,Jθ2,Jθ3>=(5,2,12)\triangledown J(\Theta ) = \left < \frac{\partial J}{\partial \theta_{1}}, \frac{\partial J}{\partial \theta_{2}},\frac{\partial J}{\partial \theta_{3}} \right > =(-5,-2,12)

    我们可以看到,梯度就是分别对每个变量进行微分,然后用逗号分割开,梯度是用<>包括起来,说明梯度其实一个向量。

    梯度是微积分中一个很重要的概念,之前提到过梯度的意义

    • 在单变量的函数中,梯度其实就是函数的微分,代表着函数在某个给定点的切线的斜率
    • 在多变量函数中,梯度是一个向量,向量有方向,梯度的方向就指出了函数在给定点的上升最快的方向

    这也就说明了为什么我们需要千方百计的求取梯度!我们需要到达山底,就需要在每一步观测到此时最陡峭的地方,梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向,那么梯度的反方向就是函数在给定点下降最快的方向,这正是我们所需要的。所以我们只要沿着梯度的方向一直走,就能走到局部的最低点!

    2.3 数学解释

    首先给出数学公式:

    Θ1=Θ0+αJ(Θ)evaluatedatΘ0{\color{Red} \Theta^1} = {\color{Blue} \Theta^0} + {\color{Green} \alpha} {\color{Purple} \triangledown J(\Theta)}\rightarrow evaluated at \Theta^0

    此公式的意义是:J是关于Θ的一个函数,我们当前所处的位置为Θ0点,要从这个点走到J的最小值点,也就是山底。首先我们先确定前进的方向,也就是梯度的反向,然后走一段距离的步长,也就是α,走完这个段步长,就到达了Θ1这个点!
    在这里插入图片描述

    2.3.1 α

    α在梯度下降算法中被称作为学习率或者步长,意味着我们可以通过α来控制每一步走的距离,以保证不要步子跨的太大扯着蛋,哈哈,其实就是不要走太快,错过了最低点。同时也要保证不要走的太慢,导致太阳下山了,还没有走到山下。所以α的选择在梯度下降法中往往是很重要的!α不能太大也不能太小,太小的话,可能导致迟迟走不到最低点,太大的话,会导致错过最低点!

    2.3.2 梯度要乘以一个负号

    梯度前加一个负号,就意味着朝着梯度相反的方向前进!我们在前文提到,梯度的方向实际就是函数在此点上升最快的方向!而我们需要朝着下降最快的方向走,自然就是负的梯度的方向,所以此处需要加上负号;那么如果时上坡,也就是梯度上升算法,当然就不需要添加负号了。

    3. 实例

    我们已经基本了解了梯度下降算法的计算过程,那么我们就来看几个梯度下降算法的小实例,首先从单变量的函数开始,然后介绍多变量的函数。

    3.1 单变量函数的梯度下降

    我们假设有一个单变量的函数

    J(θ)=θ2J(\theta) = \theta^2

    函数的微分,直接求导就可以得到

    J(θ)=2θJ'(\theta) = 2\theta

    初始化,也就是起点,起点可以随意的设置,这里设置为1

    θ0=1\theta^0 = 1

    学习率也可以随意的设置,这里设置为0.4

    α=0.4\alpha = 0.4

    根据梯度下降的计算公式

    Θ1=Θ0+αJ(Θ)evaluatedatΘ0{\color{Red} \Theta^1} = {\color{Blue} \Theta^0} + {\color{Green} \alpha} {\color{Purple} \triangledown J(\Theta)}\rightarrow evaluated at \Theta^0

    我们开始进行梯度下降的迭代计算过程:

    θ0=1\theta^0 = 1

    θ1=θ0αJ(θ0)=10.42=0.2\theta^1 = \theta^0 - \alpha*J'(\theta^0)=1 - 0.4*2 = 0.2

    θ2=θ1αJ(θ1)=0.20.40.4=0.04\theta^2 = \theta^1 - \alpha*J'(\theta^1)= 0.2 - 0.4*0.4=0.04

    θ3=0.008\theta^3 = 0.008

    θ4=0.0016\theta^4 = 0.0016

    如图,经过四次的运算,也就是走了四步,基本就抵达了函数的最低点,也就是山底
    在这里插入图片描述

    3.2 多变量函数的梯度下降

    我们假设有一个目标函数

    J(Θ)=θ12+θ22J(\Theta) = \theta_{1}^2 + \theta_{2}^2

    现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0,0)点。但是接下来,我们会从梯度下降算法开始一步步计算到这个最小值!
    我们假设初始的起点为:

    Θ0=(1,3)\Theta^0 = (1, 3)

    初始的学习率为:

    α=0.1\alpha = 0.1

    函数的梯度为:

    J(Θ)=<2θ1,2θ2>\triangledown J(\Theta ) = \left < 2\theta_{1},2\theta_{2} \right >

    进行多次迭代:

    Θ0=(1,3)\Theta^0 = (1, 3)

    Θ1=Θ0αJ(Θ)=(1,3)0.1(2,6)=(0.8,2.4)\Theta^1 = \Theta^0 - \alpha\triangledown J(\Theta ) = (1,3) - 0.1*(2, 6)=(0.8, 2.4)

    Θ2=(0.8,2.4)0.1(1.6,4.8)=(0.64,1.92)\Theta^2 = (0.8, 2.4) - 0.1*(1.6, 4.8)=(0.64, 1.92)

    Θ3=(0.5124,1.536)\Theta^3 =(0.5124, 1.536)

    Θ4=(0.4096,1.228800000000001)\Theta^4 =(0.4096, 1.228800000000001)
    \vdots
    Θ10=(0.1073741824000003,0.32212254720000005)\Theta^{10} =(0.1073741824000003, 0.32212254720000005)
    \vdots
    Θ50=(1.141798154164342e05,3.42539442494306e05)\Theta^{50} =(1.141798154164342e^{-05}, 3.42539442494306e^{-05})
    \vdots
    Θ100=(1.6296287810675902e10,4.8888886343202771e10)\Theta^{100} =(1.6296287810675902e^{-10}, 4.8888886343202771e^{-10})

    我们发现,已经基本靠近函数的最小值点
    在这里插入图片描述

    4. 代码实现

    4. 1 场景分析

    下面我们将用python实现一个简单的梯度下降算法。场景是一个简单的线性回归的例子:假设现在我们有一系列的点,如下图所示:
    在这里插入图片描述
    我们将用梯度下降法来拟合出这条直线!

    首先,我们需要定义一个代价函数,在此我们选用均方误差代价函数(也称平方误差代价函数)

    J(Θ)=12mi=1m(hθ(x(i))y(i))2J(\Theta) = \frac{1}{2m}\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2

    此公式中

    • m是数据集中数据点的个数,也就是样本数
    • ½是一个常量,这样是为了在求梯度的时候,二次方乘下来的2就和这里的½抵消了,自然就没有多余的常数系数,方便后续的计算,同时对结果不会有影响
    • y 是数据集中每个点的真实y坐标的值,也就是类标签
    • h 是我们的预测函数(假设函数),根据每一个输入x,根据Θ 计算得到预测的y值,即

    hΘ(x(i))=Θ0+Θ1x1(i)h_{\Theta}(x^{(i)}) = \Theta_{0} + \Theta_{1}x_{1}^{(i)}

    我们可以根据代价函数看到,代价函数中的变量有两个,所以是一个多变量的梯度下降问题,求解出代价函数的梯度,也就是分别对两个变量进行微分

    J(Θ)=<δJδΘ0,δJδΘ1>\triangledown J(\Theta ) = \left < \frac{\delta J}{\delta \Theta_{0}}, \frac{\delta J}{\delta \Theta_{1}} \right >

    δJδΘ0=1mi=1m(hΘ(x(i))y(i))\frac{\delta J}{\delta \Theta_{0}} = \frac{1}{m}\sum_{i=1}^{m}(h_{\Theta}(x^{(i)})-y^{(i)})

    δJδΘ1=1mi=1m(hΘ(x(i))y(i))x1(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Θ(x(i))=Θ0+Θ1x(i)h_{\Theta}(x^{(i)}) = \Theta_{0} + \Theta_{1}x^{(i)}

    我们有两个变量,为了对这个公式进行矩阵化,我们可以给每一个点x增加一维,这一维的值固定为1,这一维将会乘到Θ0上。这样就方便我们统一矩阵化的计算

    (x1(i),y(i))(x0(i),x1(i),y(i))withx0(i)=1i(x_{1}^{(i)},y^{(i)})\rightarrow (x_{0}^{(i)},x_{1}^{(i)},y^{(i)}) with x_{0}^{(i)} = 1 \forall _{i}

    然后我们将代价函数和梯度转化为矩阵向量相乘的形式

    J(Θ)=12m(XΘy)T(XΘy)J(\Theta) = \frac{1}{2m}(X\Theta - \vec{y})^{T}(X\Theta - \vec{y})

    J(Θ)=1mXT(XΘy))\triangledown 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实现了一个简单的梯度下降算法拟合直线的案例!
    最后,我们回到文章开头所提出的场景假设:
    这个下山的人实际上就代表了反向传播算法,下山的路径其实就代表着算法中一直在寻找的参数Θ,山上当前点的最陡峭的方向实际上就是代价函数在这一点的梯度方向,场景中观测最陡峭方向所用的工具就是微分 。在下一次观测之前的时间就是有我们算法中的学习率α所定义的。
    可以看到场景假设和梯度下降算法很好的完成了对应!

    本文部分内容来自一位前辈,非常感谢分享!谢谢!

    展开全文
  • 梯度

    千次阅读 多人点赞 2019-09-19 14:30:11
    梯度(转) 1. 基本概念 方向导数:是一个数;反映的是f(x,y)在P0点沿方向v的变化率。 偏导数:是多个数(每元有一个);是指多元函数沿坐标轴方向的方向导数,因此二元函数就有两个偏导数。 偏导...

    梯度(转)

    1. 基本概念

        方向导数:是一个数;反映的是f(x,y)在P0点沿方向v的变化率。

        偏导数:是多个数(每元有一个);是指多元函数沿坐标轴方向的方向导数,因此二元函数就有两个偏导数。

        偏导函数:是一个函数;是一个关于点的偏导数的函数。

        梯度:是一个向量;每个元素为函数对一元变量的偏导数;它既有大小(其大小为最大方向导数),也有方向。

    2. 方向导数

        反映的是f(x,y)在P0点沿方向v的变化率。

        例子如下:

        

        

    2.0 方向导数计算公式

          

    2.1 偏导数

         

    2.2 二元函数偏导数的几何意义

         

         

     

    2.3 偏导函数

         偏导数与偏导函数的关系:

        偏导数是偏导函数在指定点的函数值,因此在求偏导数时,也可先求出偏导函数,然后再将点代入偏导函数,从而求出函数在此点的偏导数。

         

    3. 全微分

       

        

    4. 梯度

          梯度是一个向量;既有大小,也有方向。

        

          

    4.1 几何意义

        函数z=f(x,y)在点P0处的梯度方向是函数变化率(即方向导数)最大的方向。

        梯度的方向就是函数f(x,y)在这点增长最快的方向,梯度的模为方向导数的最大值。

        

     

    转自:http://blog.csdn.net/myarrow/article/details/51332421

     

    刚接触梯度下降这个概念的时候,是在学习机器学习算法的时候,很多训练算法用的就是梯度下降,然后资料和老师们也说朝着梯度的反方向变动,函数值下降最快,但是究其原因的时候,很多人都表达不清楚。所以我整理出自己的理解,从方向导数这个角度把这个结论证明出来,让我们知其然也知其所以然~

    下面我一开始不提梯度的概念,完全根据自己的理解进行下文的梳理,一步一步推出梯度的来历:

    • 导数

    导数的几何意义可能很多人都比较熟悉: 当函数定义域和取值都在实数域中的时候,导数可以表示函数曲线上的切线斜率。 除了切线的斜率,导数还表示函数在该点的变化率

    将上面的公式转化为下面图像为:

    (来自维基百科)

    直白的来说,导数代表了在自变量变化趋于无穷小的时候,函数值的变化与自变量变化的比值代表了导数,几何意义有该点的切线。物理意义有该时刻的(瞬时)变化率...

    注意在一元函数中,只有一个自变量变动,也就是说只存在一个方向的变化率,这也就是为什么一元函数没有偏导数的原因。

    • 偏导数

    既然谈到偏导数,那就至少涉及到两个自变量,以两个自变量为例,z=f(x,y) . 从导数到偏导数,也就是从曲线来到了曲面. 曲线上的一点,其切线只有一条。但是曲面的一点,切线有无数条。

    而我们所说的偏导数就是指的是多元函数沿坐标轴的变化率.

    f_{x} (x,y)指的是函数在y方向不变,函数值沿着x轴方向的变化率

    f_{y} (x,y)指的是函数在x方向不变,函数值沿着y轴方向的变化率

    对应的图像形象表达如下:

    那么偏导数对应的几何意义是是什么呢?

    • 偏导数f_{x} (x_{0},y_{0} )就是曲面被平面y=y_{0}所截得的曲面在点M_{0}处的切线M_{0}T_{x}对x轴的斜率
    • 偏导数f_{y} (x_{0},y_{0} )就是曲面被平面x=x_{0}所截得的曲面在点M_{0}处的切线M_{0}T_{y}对y轴的斜率

    可能到这里,读者就已经发现偏导数的局限性了,原来我们学到的偏导数指的是多元函数沿坐标轴的变化率,但是我们往往很多时候要考虑多元函数沿任意方向的变化率,那么就引出了方向导数.

     

    • 方向导数

    终于引出我们的重头戏了,方向导数,下面我们慢慢来走进它

    假设你站在山坡上,相知道山坡的坡度(倾斜度)

    山坡图如下:

    假设山坡表示为z=f(x,y),你应该已经会做主要俩个方向的斜率.

    y方向的斜率可以对y偏微分得到.

    同样的,x方向的斜率也可以对x偏微分得到

    那么我们可以使用这俩个偏微分来求出任何方向的斜率(类似于一个平面的所有向量可以用俩个基向量来表示一样)

    现在我们有这个需求,想求出u方向的斜率怎么办.假设z=f(x,y)为一个曲面,p(x_{0} ,y_{0} )f定义域中一个点,单位向量u =cos\theta i+sin\theta j的斜率,其中\theta是此向量与x轴正向夹角.单位向量u可以表示对任何方向导数的方向.如下图:

    那么我们来考虑如何求出u方向的斜率,可以类比于前面导数定义,得出如下:

    f(x,y)为一个二元函数,u =cos\theta i+sin\theta j为一个单位向量,如果下列的极限值存在

    \lim_{t \rightarrow 0}{\frac{f(x_{0}+tcos\theta ,y_{0}+tsin\theta )-f(x_{0},y_{0})}{t} }此方向导数记为D_{u}f

    则称这个极限值是f沿着u方向的方向导数,那么随着\theta的不同,我们可以求出任意方向的方向导数.这也表明了方向导数的用处,是为了给我们考虑函数对任意方向的变化率.

    在求方向导数的时候,除了用上面的定义法求之外,我们还可以用偏微分来简化我们的计算.

    表达式是D_{u}f(x,y)=f_{x}(x,y)cos\theta   +f_{y}(x,y)sin\theta(至于为什么成立,很多资料有,不是这里讨论的重点)

    那么一个平面上无数个方向,函数沿哪个方向变化率最大呢?

    目前我不管梯度的事,我先把表达式写出来:

    D_{u}f(x,y)=f_{x}(x,y)cos\theta   +f_{y}(x,y)sin\theta

    A=(f_{x}(x,y) ,f_{y}(x,y)),I=(cos\theta ,sin\theta )

    那么我们可以得到:

    D_{u}f(x,y)=A\bullet I=\left| A \right| *\left| I \right| cos\alpha(\alpha为向量A与向量I之间的夹角)

    那么此时如果D_{u}f(x,y)要取得最大值,也就是当\alpha为0度的时候,也就是向量I(这个方向是一直在变,在寻找一个函数变化最快的方向)与向量A(这个方向当点固定下来的时候,它就是固定的)平行的时候,方向导数最大.方向导数最大,也就是单位步伐,函数值朝这个反向变化最快.

    好了,现在我们已经找到函数值下降最快的方向了,这个方向就是和A向量相同的方向.那么此时我把A向量命名为梯度(当一个点确定后,梯度方向是确定的),也就是说明了为什么梯度方向是函数变化率最大的方向了!!!(因为本来就是把这个函数变化最大的方向命名为梯度)

    我的理解是,本来梯度就不是横空出世的,当我们有了这个需求(要求一个方向,此方向函数值变化最大),得到了一个方向,然后这个方向有了意义,我们给了它一个名称,叫做梯度(纯个人理解~希望对大家理解有帮助)欢迎知友提出问题交流~

    转自:https://zhuanlan.zhihu.com/p/24913912

    转载于:https://my.oschina.net/u/2285247/blog/3068095

    展开全文
  • 本文分为三部分,第一部分主要直观的介绍深度学习中为什么使用梯度更新,第二部分主要介绍深度学习中梯度消失及爆炸的原因,第三部分对提出梯度消失及爆炸的解决方案。有基础的同鞋可以跳着阅读。 其中,梯度消失...

    前言

    本文主要深入介绍深度学习中的梯度消失和梯度爆炸的问题以及解决方案。本文分为三部分,第一部分主要直观的介绍深度学习中为什么使用梯度更新,第二部分主要介绍深度学习中梯度消失及爆炸的原因,第三部分对提出梯度消失及爆炸的解决方案。有基础的同鞋可以跳着阅读。
    其中,梯度消失爆炸的解决方案主要包括以下几个部分。

    - 预训练加微调
    - 梯度剪切、权重正则(针对梯度爆炸)
    - 使用不同的激活函数
    - 使用batchnorm
    - 使用残差结构
    - 使用LSTM网络
    

    第一部分:为什么要使用梯度更新规则


    在介绍梯度消失以及爆炸之前,先简单说一说梯度消失的根源—–深度神经网络和反向传播。目前深度学习方法中,深度神经网络的发展造就了我们可以构建更深层的网络完成更复杂的任务,深层网络比如深度卷积网络,LSTM等等,而且最终结果表明,在处理复杂任务上,深度网络比浅层的网络具有更好的效果。但是,目前优化神经网络的方法都是基于反向传播的思想,即根据损失函数计算的误差通过梯度反向传播的方式,指导深度网络权值的更新优化。这样做是有一定原因的,首先,深层网络由许多非线性层堆叠而来,每一层非线性层都可以视为是一个非线性函数 f(x)f(x)f(x)(非线性来自于非线性激活函数),因此整个深度网络可以视为是一个复合的非线性多元函数
    F(x)=fn(...f3(f2(f1(x)∗θ1+b)∗θ2+b)...)F(x) = {f_n}(...{f_3}({f_2}({f_1}(x)*{\theta _1} + b)*{\theta _2} + b)...)F(x)=fn(...f3(f2(f1(x)θ1+b)θ2+b)...) 我们最终的目的是希望这个多元函数可以很好的完成输入到输出之间的映射,假设不同的输入,输出的最优解是g(x)g(x)g(x) ,那么,优化深度网络就是为了寻找到合适的权值,满足Loss=L(g(x),F(x))Loss = L(g(x),F(x))Loss=L(g(x),F(x))取得极小值点,比如最简单的损失函数
    Loss=∣∣g(x)−f(x)∣∣22Loss = ||g(x)-f(x)||^2_2Loss=g(x)f(x)22,假设损失函数的数据空间是下图这样的,我们最优的权值就是为了寻找下图中的最小值点,对于这种数学寻找最小值问题,采用梯度下降的方法再适合不过了。
    这里写图片描述

    第二部分:梯度消失、爆炸

    梯度消失与梯度爆炸其实是一种情况,看接下来的文章就知道了。两种情况下梯度消失经常出现,一是在深层网络中,二是采用了不合适的损失函数,比如sigmoid。梯度爆炸一般出现在深层网络和权值初始化值太大的情况下,下面分别从这两个角度分析梯度消失和爆炸的原因。

    1.深层网络角度

    比较简单的深层网络如下:
    这里写图片描述
    图中是一个四层的全连接网络,假设每一层网络激活后的输出为fi(x)f_i(x)fi(x),其中iii为第iii层, xxx代表第iii层的输入,也就是第i−1i-1i1层的输出,fff是激活函数,那么,得出fi+1=f(fi∗wi+1+bi+1)f_{i+1}=f(f_i*w_{i+1}+b_{i+1})fi+1=f(fiwi+1+bi+1),简单记为fi+1=f(fi∗wi+1)f_{i+1}=f(f_i*w_{i+1})fi+1=f(fiwi+1)
    BP算法基于梯度下降策略,以目标的负梯度方向对参数进行调整,参数的更新为w←w+Δww \leftarrow w+\Delta www+Δw,给定学习率α\alphaα,得出Δw=−α∂Loss∂w\Delta w=-\alpha \frac{\partial Loss}{\partial w}Δw=αwLoss。如果要更新第二隐藏层的权值信息,根据链式求导法则,更新梯度信息:
    Δw2=∂Loss∂w2=∂Loss∂f4∂f4∂f3∂f3∂f2∂f2∂w2\Delta w_2=\frac{\partial Loss}{\partial w_2}=\frac{\partial Loss}{\partial f_4}\frac{\partial f_4}{\partial f_3}\frac{\partial f_3}{\partial f_2}\frac{\partial f_2}{\partial w_2}Δw2=w2Loss=f4Lossf3f4f2f3w2f2,很容易看出来∂f2∂w2=∂f∂(f1∗w2)f1\frac{\partial f_2}{\partial w_2}=\frac{\partial f}{\partial (f_1*w_2)}f_1w2f2=(f1w2)ff1,即第二隐藏层的输入。
    所以说,∂f4∂f3×w4\frac{\partial f_4}{\partial f_3} \times w4f3f4×w4就是对激活函数进行求导,如果此部分大于1,那么层数增多的时候,最终的求出的梯度更新将以指数形式增加,即发生梯度爆炸,如果此部分小于1,那么随着层数增多,求出的梯度更新信息将会以指数形式衰减,即发生了梯度消失。如果说从数学上看不够直观的话,下面几个图可以很直观的说明深层网络的梯度问题1^11(图片内容来自参考文献1):

    注:下图中的隐层标号和第一张全连接图隐层标号刚好相反。
    图中的曲线表示权值更新的速度,对于下图两个隐层的网络来说,已经可以发现隐藏层2的权值更新速度要比隐藏层1更新的速度慢

    这里写图片描述

    	那么对于四个隐层的网络来说,就更明显了,第四隐藏层比第一隐藏层的更新速度慢了两个数量级:
    

    这里写图片描述

    总结:从深层网络角度来讲,不同的层学习的速度差异很大,表现为网络中靠近输出的层学习的情况很好,靠近输入的层学习的很慢,有时甚至训练了很久,前几层的权值和刚开始随机初始化的值差不多。因此,梯度消失、爆炸,其根本原因在于反向传播训练法则,属于先天不足,另外多说一句,Hinton提出capsule的原因就是为了彻底抛弃反向传播,如果真能大范围普及,那真是一个革命。

    2.激活函数角度

    其实也注意到了,上文中提到计算权值更新信息的时候需要计算前层偏导信息,因此如果激活函数选择不合适,比如使用sigmoid,梯度消失就会很明显了,原因看下图,左图是sigmoid的损失函数图,右边是其导数的图像,如果使用sigmoid作为损失函数,其梯度是不可能超过0.25的,这样经过链式求导之后,很容易发生梯度消失,sigmoid函数数学表达式为:sigmoid(x)=11+e−xsigmoid(x)=\frac{1}{1+e^{-x}}sigmoid(x)=1+ex1
    sigmoid函数sigmoid函数导数

    同理,tanh作为激活函数,它的导数图如下,可以看出,tanh比sigmoid要好一些,但是它的导数仍然是小于1的。tanh数学表达为:
    

    tanh(x)=ex−e−xex+e−xtanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}tanh(x)=ex+exexex

    这里写图片描述

    第三部分:梯度消失、爆炸的解决方案


    2.1 方案1-预训练加微调

    此方法来自Hinton在2006年发表的一篇论文,Hinton为了解决梯度的问题,提出采取无监督逐层训练方法,其基本思想是每次训练一层隐节点,训练时将上一层隐节点的输出作为输入,而本层隐节点的输出作为下一层隐节点的输入,此过程就是逐层“预训练”(pre-training);在预训练完成后,再对整个网络进行“微调”(fine-tunning)。Hinton在训练深度信念网络(Deep Belief Networks中,使用了这个方法,在各层预训练完成后,再利用BP算法对整个网络进行训练。此思想相当于是先寻找局部最优,然后整合起来寻找全局最优,此方法有一定的好处,但是目前应用的不是很多了。

    2.2 方案2-梯度剪切、正则

    梯度剪切这个方案主要是针对梯度爆炸提出的,其思想是设置一个梯度剪切阈值,然后更新梯度的时候,如果梯度超过这个阈值,那么就将其强制限制在这个范围之内。这可以防止梯度爆炸。

    注:在WGAN中也有梯度剪切限制操作,但是和这个是不一样的,WGAN限制梯度更新信息是为了保证lipchitz条件。
    

    另外一种解决梯度爆炸的手段是采用权重正则化(weithts regularization)比较常见的是l1l1l1正则,和l2l2l2正则,在各个深度框架中都有相应的API可以使用正则化,比如在tensorflowtensorflowtensorflow中,若搭建网络的时候已经设置了正则化参数,则调用以下代码可以直接计算出正则损失:

    regularization_loss = tf.add_n(tf.losses.get_regularization_losses(scope='my_resnet_50'))
    

    如果没有设置初始化参数,也可以使用以下代码计算l2l2l2正则损失:

        l2_loss = tf.add_n([tf.nn.l2_loss(var) for var in tf.trainable_variables() if 'weights' in var.name])
    
    

    正则化是通过对网络权重做正则限制过拟合,仔细看正则项在损失函数的形式:
    Loss=(y−WTx)2+α∣∣W∣∣2Loss=(y-W^Tx)^2+ \alpha ||W||^2Loss=(yWTx)2+αW2
    其中,α\alphaα是指正则项系数,因此,如果发生梯度爆炸,权值的范数就会变的非常大,通过正则化项,可以部分限制梯度爆炸的发生。

    注:事实上,在深度神经网络中,往往是梯度消失出现的更多一些。
    

    2.3 方案3-relu、leakrelu、elu等激活函数

    **Relu:**思想也很简单,如果激活函数的导数为1,那么就不存在梯度消失爆炸的问题了,每层的网络都可以得到相同的更新速度,relu就这样应运而生。先看一下relu的数学表达式:

    这里写图片描述

    其函数图像:

    这里写图片描述
    从上图中,我们可以很容易看出,relu函数的导数在正数部分是恒等于1的,因此在深层网络中使用relu激活函数就不会导致梯度消失和爆炸的问题。

    relu的主要贡献在于:

     -- 解决了梯度消失、爆炸的问题
     -- 计算方便,计算速度快
     -- 加速了网络的训练
    

    同时也存在一些缺点

    -- 由于负数部分恒为0,会导致一些神经元无法激活(可通过设置小学习率部分解决)
     -- 输出不是以0为中心的
    

    尽管relu也有缺点,但是仍然是目前使用最多的激活函数

    leakrelu
    leakrelu就是为了解决relu的0区间带来的影响,其数学表达为:leakrelu=max(k∗x,x)leakrelu=max(k*x,x)leakrelu=max(kx,x)其中k是leak系数,一般选择0.01或者0.02,或者通过学习而来

    这里写图片描述

    leakrelu解决了0区间带来的影响,而且包含了relu的所有优点
    elu
    elu激活函数也是为了解决relu的0区间带来的影响,其数学表达为:这里写图片描述
    其函数及其导数数学形式为:

    这里写图片描述

    但是elu相对于leakrelu来说,计算要更耗时间一些

    2.4 解决方案4-batchnorm

    Batchnorm是深度学习发展以来提出的最重要的成果之一了,目前已经被广泛的应用到了各大网络中,具有加速网络收敛速度,提升训练稳定性的效果,Batchnorm本质上是解决反向传播过程中的梯度问题。batchnorm全名是batch normalization,简称BN,即批规范化,通过规范化操作将输出信号x规范化保证网络的稳定性。
    具体的batchnorm原理非常复杂,在这里不做详细展开,此部分大概讲一下batchnorm解决梯度的问题上。具体来说就是反向传播中,经过每一层的梯度会乘以该层的权重,举个简单例子:
    正向传播中f2=f1(wT∗x+b)f_2=f_1(w^T*x+b)f2=f1(wTx+b),那么反向传播中,∂f2∂w=∂f2∂f1x\frac {\partial f_2}{\partial w}=\frac{\partial f_2}{\partial f_1}xwf2=f1f2x,反向传播式子中有xxx的存在,所以xxx的大小影响了梯度的消失和爆炸,batchnorm就是通过对每一层的输出规范为均值和方差一致的方法,消除了xxx带来的放大缩小的影响,进而解决梯度消失和爆炸的问题,或者可以理解为BN将输出从饱和区拉倒了非饱和区。
    有关batch norm详细的内容可以参考我的另一篇博客:
    http://blog.csdn.net/qq_25737169/article/details/79048516

    2.5 解决方案5-残差结构

    残差结构说起残差的话,不得不提这篇论文了:Deep Residual Learning for Image Recognition,关于这篇论文的解读,可以参考知乎链接:https://zhuanlan.zhihu.com/p/31852747这里只简单介绍残差如何解决梯度的问题。
    事实上,就是残差网络的出现导致了image net比赛的终结,自从残差提出后,几乎所有的深度网络都离不开残差的身影,相比较之前的几层,几十层的深度网络,在残差网络面前都不值一提,残差可以很轻松的构建几百层,一千多层的网络而不用担心梯度消失过快的问题,原因就在于残差的捷径(shortcut)部分,其中残差单元如下图所示:
    这里写图片描述
    相比较于以前网络的直来直去结构,残差中有很多这样的跨层连接结构,这样的结构在反向传播中具有很大的好处,见下式:
    这里写图片描述
    式子的第一个因子 ∂loss∂xL\frac{\partial loss}{\partial {{x}_{L}}}xLloss 表示的损失函数到达 L 的梯度,小括号中的1表明短路机制可以无损地传播梯度,而另外一项残差梯度则需要经过带有weights的层,梯度不是直接传递过来的。残差梯度不会那么巧全为-1,而且就算其比较小,有1的存在也不会导致梯度消失。所以残差学习会更容易。

    注:上面的推导并不是严格的证明。
    

    2.6 解决方案6-LSTM

    LSTM全称是长短期记忆网络(long-short term memory networks),是不那么容易发生梯度消失的,主要原因在于LSTM内部复杂的“门”(gates),如下图,LSTM通过它内部的“门”可以接下来更新的时候“记住”前几次训练的”残留记忆“,因此,经常用于生成文本中。目前也有基于CNN的LSTM,感兴趣的可以尝试一下。

    这里写图片描述

    参考资料:

    1.《Neural networks and deep learning》
    2.《机器学习》周志华
    3. https://www.cnblogs.com/willnote/p/6912798.html
    4. https://www.zhihu.com/question/38102762
    5. http://www.jianshu.com/p/9dc9f41f0b29


    如果感兴趣,请关注微信公众号,还有更多精彩:
    这里写图片描述

    展开全文
  • 一文看懂常用的梯度下降算法

    万次阅读 多人点赞 2017-11-29 00:00:00
    作者:叶 虎 编辑:祝鑫泉 ...梯度下降算法背后的原理:目标函数关于参数的梯度将是目标函数上升最快的方向。对于最小化优化问题,只需要将参数沿着梯度相反的方向前进一个步长,就可以实现目标函数的


    作者:叶    虎

    编辑:祝鑫泉


    640?wx_fmt=png&wxfrom=5&wx_lazy=1

    概述

    梯度下降算法(Gradient Descent Optimization)是神经网络模型训练最常用的优化算法。对于深度学习模型,基本都是采用梯度下降算法来进行优化训练的。梯度下降算法背后的原理:目标函数640?wx_fmt=png&wxfrom=5&wx_lazy=1关于参数640?wx_fmt=png&wxfrom=5&wx_lazy=1的梯度将是目标函数上升最快的方向。对于最小化优化问题,只需要将参数沿着梯度相反的方向前进一个步长,就可以实现目标函数的下降。这个步长又称为学习速率640?wx_fmt=png&wxfrom=5&wx_lazy=1。参数更新公式如下:

    640?wx_fmt=png&wxfrom=5&wx_lazy=1

    其中640?wx_fmt=png&wxfrom=5&wx_lazy=1是参数的梯度,根据计算目标函数640?wx_fmt=png&wxfrom=5&wx_lazy=1采用数据量的不同,梯度下降算法又可以分为批量梯度下降算法(Batch Gradient Descent),随机梯度下降算法(Stochastic GradientDescent)和小批量梯度下降算法(Mini-batch Gradient Descent)。对于批量梯度下降算法,640?wx_fmt=png&wxfrom=5&wx_lazy=1是在整个训练集上计算的,如果数据集比较大,可能会面临内存不足问题,而且其收敛速度一般比较慢。随机梯度下降算法是另外一个极端,640?wx_fmt=png&wxfrom=5&wx_lazy=1是针对训练集中的一个训练样本计算的,又称为在线学习,即得到了一个样本,就可以执行一次参数更新。所以其收敛速度会快一些,但是有可能出现目标函数值震荡现象,因为高频率的参数更新导致了高方差。小批量梯度下降算法是折中方案,选取训练集中一个小批量样本计算640?wx_fmt=png&wxfrom=5&wx_lazy=1这样可以保证训练过程更稳定,而且采用批量训练方法也可以利用矩阵计算的优势。这是目前最常用的梯度下降算法。

    对于神经网络模型,借助于BP算法可以高效地计算梯度,从而实施梯度下降算法。但梯度下降算法一个老大难的问题是:不能保证全局收敛。如果这个问题解决了,深度学习的世界会和谐很多。梯度下降算法针对凸优化问题原则上是可以收敛到全局最优的,因为此时只有唯一的局部最优点。而实际上深度学习模型是一个复杂的非线性结构,一般属于非凸问题,这意味着存在很多局部最优点(鞍点),采用梯度下降算法可能会陷入局部最优,这应该是最头疼的问题。这点和进化算法如遗传算法很类似,都无法保证收敛到全局最优。因此,我们注定在这个问题上成为高级调参师。可以看到,梯度下降算法中一个重要的参数是学习速率,适当的学习速率很重要:学习速率过小时收敛速度慢,而过大时导致训练震荡,而且可能会发散。理想的梯度下降算法要满足两点:收敛速度要快;能全局收敛。为了这个理想,出现了很多经典梯度下降算法的变种,下面将分别介绍它们。


    01

    Momentum optimization

    冲量梯度下降算法是BorisPolyak1964年提出的,其基于这样一个物理事实:将一个小球从山顶滚下,其初始速率很慢,但在加速度作用下速率很快增加,并最终由于阻力的存在达到一个稳定速率。对于冲量梯度下降算法,其更新方程如下:

    0?wx_fmt=png

    可以看到,参数更新时不仅考虑当前梯度值,而且加上了一个积累项(冲量),但多了一个超参0?wx_fmt=png,一般取接近1的值如0.9。相比原始梯度下降算法,冲量梯度下降算法有助于加速收敛。当梯度与冲量方向一致时,冲量项会增加,而相反时,冲量项减少,因此冲量梯度下降算法可以减少训练的震荡过程。TensorFlow中提供了这一优化器:tf.train.MomentumOptimizer(learning_rate=learning_rate,momentum=0.9)。


    02 

    NAG

    NAG算法全称Nesterov Accelerated Gradient,是YuriiNesterov1983年提出的对冲量梯度下降算法的改进版本,其速度更快。其变化之处在于计算超前梯度更新冲量项,具体公式如下:

    0?wx_fmt=png

    既然参数要沿着0?wx_fmt=png更新,不妨计算未来位置0?wx_fmt=png的梯度,然后合并两项作为最终的更新项,其具体效果如图1所示,可以看到一定的加速效果。在TensorFlow中,NAG优化器为:tf.train.MomentumOptimizer(learning_rate=learning_rate,momentum=0.9, use_nesterov=True)


    0?wx_fmt=png

    1 NAG效果图


    03

    AdaGrad

    AdaGradDuchi2011年提出的一种学习速率自适应的梯度下降算法。在训练迭代过程,其学习速率是逐渐衰减的,经常更新的参数其学习速率衰减更快,这是一种自适应算法。其更新过程如下:

    0?wx_fmt=png

    其中是梯度平方的积累量,在进行参数更新时,学习速率要除以这个积累量的平方根,其中加上一个很小值是为了防止除0的出现。由于是该项逐渐增加的,那么学习速率是衰减的。考虑如图2所示的情况,目标函数在两个方向的坡度不一样,如果是原始的梯度下降算法,在接近坡底时收敛速度比较慢。而当采用AdaGrad,这种情况可以被改观。由于比较陡的方向梯度比较大,其学习速率将衰减得更快,这有利于参数沿着更接近坡底的方向移动,从而加速收敛。


    0?wx_fmt=png

    2 AdaGrad效果图


    前面说到AdaGrad其学习速率实际上是不断衰减的,这会导致一个很大的问题,就是训练后期学习速率很小,导致训练过早停止,因此在实际中AdaGrad一般不会被采用,下面的算法将改进这一致命缺陷。不过TensorFlow也提供了这一优化器:tf.train.AdagradOptimizer



    04

    RMSprop

    RMSpropHinton在他的课程上讲到的,其算是对Adagrad算法的改进,主要是解决学习速率过快衰减的问题。其实思路很简单,类似Momentum思想,引入一个超参数,在积累梯度平方项进行衰减:

    0?wx_fmt=png

    可以认为仅仅对距离时间较近的梯度进行积累,其中一般取值0.9,其实这样就是一个指数衰减的均值项,减少了出现的爆炸情况,因此有助于避免学习速率很快下降的问题。同时Hinton也建议学习速率设置为0.001RMSprop是属于一种比较好的优化算法了,在TensorFlow中当然有其身影:tf.train.RMSPropOptimizer(learning_rate=learning_rate,momentum=0.9, decay=0.9, epsilon=1e-10)

    不得不说点题外话,同时期还有一个Adadelta算法,其也是Adagrad算法的改进,而且改进思路和RMSprop很像,但是其背后是基于一次梯度近似代替二次梯度的思想,感兴趣的可以看看相应的论文,这里不再赘述。


    05

    Adam

    Adam全称Adaptive moment estimation,Kingma等在2015年提出的一种新的优化算法,其结合了MomentumRMSprop算法的思想。相比Momentum算法,其学习速率是自适应的,而相比RMSprop,其增加了冲量项。所以,Adam是两者的结合体:

    0?wx_fmt=png

    可以看到前两项和MomentumRMSprop是非常一致的,由于的初始值一般设置为0,在训练初期其可能较小,第三和第四项主要是为了放大它们。最后一项是参数更新。其中超参数的建议值是0?wx_fmt=pngAdm是性能非常好的算法,在TensorFlow其实现如下: tf.train.AdamOptimizer(learning_rate=0.001,beta1=0.9, beta2=0.999, epsilon=1e-08)





    学习速率

    前面也说过学习速率的问题,对于梯度下降算法,这应该是一个最重要的超参数。如果学习速率设置得非常大,那么训练可能不会收敛,就直接发散了;如果设置的比较小,虽然可以收敛,但是训练时间可能无法接受;如果设置的稍微高一些,训练速度会很快,但是当接近最优点会发生震荡,甚至无法稳定。不同学习速率的选择影响可能非常大,如图3所示。

    0?wx_fmt=png

    3 不同学习速率的训练效果




    理想的学习速率是:刚开始设置较大,有很快的收敛速度,然后慢慢衰减,保证稳定到达最优点。所以,前面的很多算法都是学习速率自适应的。除此之外,还可以手动实现这样一个自适应过程,如实现学习速率指数式衰减:

    0?wx_fmt=png

    TensorFlow中,你可以这样实现:

    initial_learning_rate = 0.1
    decay_steps = 10000
    decay_rate = 1/10
    global_step = tf.Variable(0, trainable=False)
    learning_rate = tf.train.exponential_decay(initial_learning_rate,                          
                               global_step, decay_steps, decay_rate)
    # decayed_learning_rate = learning_rate *
    #                decay_rate ^ (global_step / decay_steps)
    optimizer = tf.train.MomentumOptimizer(learning_rate, momentum=0.9)
    training_op = optimizer.minimize(loss, global_step=global_step)







    总结

    本文简单介绍了梯度下降算法的分类以及常用的改进算法,总结来看,优先选择学习速率自适应的算法如RMSpropAdam算法,大部分情况下其效果是较好的。还有一定要特别注意学习速率的问题。其实还有很多方面会影响梯度下降算法,如梯度的消失与爆炸,这也是要额外注意的。最后不得不说,梯度下降算法目前无法保证全局收敛还将是一个持续性的数学难题。







    参考文献

    1. Anoverview of gradient descent optimization algorithms: http://sebastianruder.com/optimizing-gradient-descent/.

    2. Hands-OnMachine Learning with Scikit-Learn and TensorFlow, Aurélien Géron, 2017.

    3. NAG:http://proceedings.mlr.press/v28/sutskever13.pdf.

    4. Adagrad:http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf.

    5. RMSprop:http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf.

    6. Adadelta:https://arxiv.org/pdf/1212.5701v1.pdf.

    7. Adam:https://arxiv.org/pdf/1412.6980.pdf.

    8. 不同的算法的效果可视化:https://imgur.com/a/Hqolp.






    欢迎大家加群在群中探讨

    欢迎留言或赞赏。









    阅 

    1. 客官,来嘛,谷歌小菜请你尝尝!

    2. 趣谈深度学习核心----激活函数

    3. 朴素贝叶斯实战篇之新浪新闻分类

    4. Object Detection R-CNN

    5. 史上最详细的XGBoost实战(上)




    扫描个人微信号,

    拉你进机器学习大牛群。

    福利满满,名额已不多…

    640.jpeg?



    80%的AI从业者已关注我们微信公众号

    0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif

    0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif 0?wx_fmt=gif




    展开全文
  • PCL 3D-SIFT关键点检测(Z方向梯度约束)

    万次阅读 2021-04-22 20:02:46
    SIFT是图像上检测关键点的重要算法之一,用于处理点云数据时,有三种改进方式。此为SIFT的第一种改进算法:基于Z方向梯度约束的3D-SIFT关键点检测。
  • 梯度下降与随机梯度下降概念及推导过程

    万次阅读 多人点赞 2018-11-03 14:43:52
    同这一章的梯度下降部分加起来,才是我们要讲的如何求解多元线性回归.如果写在一章中,内容过长,担心有的同学会看不完,所以拆分成两章.[坏笑] 上一章中有提到利用解析解求解多元线性回归,虽然看起来很方便,但是在...
  • 梯度算法之梯度上升和梯度下降

    千次阅读 2017-12-13 22:48:02
    第一次看见随机梯度上升算法是看《机器学习实战》这本书,当时也是一知半解,只是大概知道和高等数学中的函数求导有一定的关系。下边我们就好好研究下随机梯度上升(下降)和梯度上升(下降)。
  • 要使用梯度下降法找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索。如果相反地向梯度正方向迭代进行搜索,则会接近函数的局部极大值点;
  • 梯度消失与梯度爆炸,梯度弥散

    千次阅读 2018-07-16 09:35:25
    详解机器学习中的梯度消失、爆炸原因及其解决方法机器学习总结(九):梯度消失(vanishing gradient)与梯度爆炸(exploding gradient)问题
  • 图像梯度

    千次阅读 2020-10-23 08:19:06
    图像梯度原理:简单来说就是求导 OpenCV提供了三种不同的梯度滤波器,或者说高通滤波器:Sobel,Scharr和Laplacian。Sobel和Scharr是求一阶或二阶导数。Scharr是对Sobel(使用小的卷积核求解梯度角度时)的优化,...
  • 梯度消失 & 梯度爆炸

    千次阅读 2019-07-01 23:46:51
    神经网络(DNN)其实就是人工神经网络(ANN)的多层实现,一个ANN有2个或者2个以上的隐藏层,则被称为深度神经网络(DNN),下面的内容我们会针对神经网络反向微分过程中产生的梯度爆炸和梯度消失,以及当前有效的缓和方法做...
  • 梯度弥散和梯度爆炸

    千次阅读 2019-03-25 17:51:38
    1. 什么是梯度弥散和梯度爆炸(发生原因) 梯度弥散:由于导数的链式法则,连续多层小于1的梯度相乘会使梯度越来越小,最终导致某层梯度为0。 梯度爆炸:由于导数的链式法则,连续多层大于1的梯度相乘会使梯度...
  • 原本没觉得它们有多难区分,但真要向一个人解释清类似“为何要有梯度提升”这类问题,似乎还是很吃力,从而发现自己其实并没有完全理解其中的含义。 也许根本就不存在什么“梯度上升”,只有“梯度提升”罢,但我...
  • 梯度下降与梯度消失

    2019-09-03 20:10:42
    梯度消失和梯度爆炸是深度学习常见的问题 产生的原因 神经网络反向传播固有的问题; 其实梯度爆炸和梯度消失是同一个问题,只是发生在训练的不同时期: 梯度爆炸:发生在训练的初期,靠近输出层的权重变化迅速,随着...
  • 梯度上升和梯度下降

    千次阅读 2018-07-28 16:00:45
    关于梯度上升法和梯度下降法的原理,大多数都是纯理论的解释和公式的推导,没有一种直观的表达方式。 在这我分别举出两个简单而又直观的例子,大家就明白了,为什么梯度下降法一定是减梯度,而梯度上升法一定是加...
  • 在机器学习领域,体梯度下降算法分为三种 - 批量梯度下降算法(BGD,Batch gradient descent algorithm) - 随机梯度下降算法(SGD,Stochastic gradient descent algorithm) - 小批量梯度下降算法(MBGD,Mini-...
  • 梯度消失和梯度爆炸

    2020-08-22 16:54:21
    1)梯度消失 如下图,当梯度消失出现时,靠近输出层的hidden layer3权值更新相对正常,但是靠近输入层的hidden layer1权值更新变得很慢,导致靠近输入层的隐藏层权值几乎不变,仍接近于初始化的权值。这就导致hidden...
  • 梯度下降、随机梯度下降、小批量梯度下降、动量梯度下降、Nesterov加速梯度下降法前言梯度下降法(Gradient Descent / GD)单变量线性回归模型(Univariate Linear Regression)批梯度下降法(Batch Gradient ...
  • 一文通透优化算法:从随机梯度、随机梯度下降法到牛顿法、共轭梯度       1 什么是梯度下降法 经常在机器学习中的优化问题中看到一个算法,即梯度下降法,那到底什么是梯度下降法呢? 维基百科给出的定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,067
精华内容 24,826
关键字:

梯度