梯度下降_梯度下降算法 - CSDN
梯度下降 订阅
梯度下降是迭代法的一种,可以用于求解最小二乘问题(线性和非线性都可以)。在求解机器学习算法的模型参数,即无约束优化问题时,梯度下降(Gradient Descent)是最常采用的方法之一,另一种常用的方法是最小二乘法。在求解损失函数的最小值时,可以通过梯度下降法来一步步的迭代求解,得到最小化的损失函数和模型参数值。反过来,如果我们需要求解损失函数的最大值,这时就需要用梯度上升法来迭代了。在机器学习中,基于基本的梯度下降法发展了两种梯度下降方法,分别为随机梯度下降法和批量梯度下降法。 展开全文
梯度下降是迭代法的一种,可以用于求解最小二乘问题(线性和非线性都可以)。在求解机器学习算法的模型参数,即无约束优化问题时,梯度下降(Gradient Descent)是最常采用的方法之一,另一种常用的方法是最小二乘法。在求解损失函数的最小值时,可以通过梯度下降法来一步步的迭代求解,得到最小化的损失函数和模型参数值。反过来,如果我们需要求解损失函数的最大值,这时就需要用梯度上升法来迭代了。在机器学习中,基于基本的梯度下降法发展了两种梯度下降方法,分别为随机梯度下降法和批量梯度下降法。
信息
用    于
求解非线性方程组
类    型
最优化算法
中文名
梯度下降
外文名
steepest descent (gradient descent)
梯度下降简介
梯度:对于可微的数量场 ,以 为分量的向量场称为f的梯度或斜量。 [1]  梯度下降法(gradient descent)是一个最优化算法,常用于机器学习和人工智能当中用来递归性地逼近最小偏差模型。
收起全文
精华内容
参与话题
  • 梯度下降算法原理讲解——机器学习

    万次阅读 多人点赞 2020-10-09 09:07:47
    本文将从一个下山的场景开始,先提出梯度下降算法的基本思想,进而从数学上解释梯度下降算法的原理,解释为什么要用梯度,最后实现一个简单的梯度下降算法的实例! 2. 梯度下降算法 2.1 场景假设 梯度下降法的基本.....

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

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

    展开全文
  • 要使用梯度下降法找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索。如果相反地向梯度正方向迭代进行搜索,则会接近函数的局部极大值点;

    http://blog.csdn.net/pipisorry/article/details/23692455

    梯度下降法(Gradient Descent)

    梯度下降法是一个一阶最优化算法,通常也称为最速下降法。 要使用梯度下降法找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索。如果相反地向梯度正方向迭代进行搜索,则会接近函数的局部极大值点;这个过程则被称为梯度上升法。

    梯度下降法的优化思想是用当前位置负梯度方向作为搜索方向,因为该方向为当前位置的最快下降方向,所以也被称为是”最速下降法“。最速下降法越接近目标值,步长越小(cost函数是凸函数,比如x^2梯度就是越来越小),前进越慢。

    梯度下降方法基于以下的观察:如果实值函数F({\mathbf  {x}})在点\mathbf {a}处可微且有定义,那么函数F({\mathbf  {x}})\mathbf {a}点沿着梯度相反的方向 -\nabla F({\mathbf  {a}}) 下降最快。

    因而,如果 {\mathbf  {b}}={\mathbf  {a}}-\gamma \nabla F({\mathbf  {a}}) 对于\gamma >0为一个够小数值时成立,那么F({\mathbf  {a}})\geq F({\mathbf  {b}})

    考虑到这一点,我们可以从函数F的局部极小值的初始估计{\mathbf  {x}}_{0}出发,并考虑如下序列 {\mathbf  {x}}_{0},{\mathbf  {x}}_{1},{\mathbf  {x}}_{2},\dots使得

    \mathbf{x}_{n+1}=\mathbf{x}_n-\gamma_n \nabla F(\mathbf{x}_n),\ n \ge 0

    因此可得到

    F({\mathbf  {x}}_{0})\geq F({\mathbf  {x}}_{1})\geq F({\mathbf  {x}}_{2})\geq \cdots ,

    如果顺利的话序列({\mathbf  {x}}_{n})收敛到期望的极值。注意每次迭代步长\gamma可以改变。

    [wikipedia 梯度下降法]

    梯度下降法的搜索迭代示意图如下左图所示:图片示例了这一过程,这里假设F定义在平面上,并且函数图像是一个碗形。蓝色的曲线是等高线(水平集),即函数F为常数的集合构成的曲线。红色的箭头指向该点梯度的反方向。(一点处的梯度方向与通过该点的等高线垂直)。沿着梯度下降方向,将最终到达碗底,即函数F值最小的点。

     

    梯度下降法处理一些复杂的非线性函数会出现问题,例如Rosenbrock函数f(x, y) =(1-x)^2 + 100(y-x^2)^2 .\quad其最小值在(x,y)=(1,1)处,数值为f(x,y)=0。但是此函数具有狭窄弯曲的山谷,最小值(x,y)=(1,1)就在这些山谷之中,并且谷底很平。优化过程是之字形的向极小值点靠近,速度非常缓慢。利用梯度下降法求解需要很多次的迭代。

    Banana-SteepDesc.gif


    Gradient Descent直观解释:J(θ)是一个关于θ的多元函数,高等数学的知识说,J(θ)在点P(θ0,θ1,⋯,θn)延梯度方向上升最快。现在要最小化 J(θ),为了让J(θ)尽快收敛,就在更新θ时减去其在P点的梯度。

    梯度下降法的评价

    梯度下降法的缺点包括(lz应该主要相比牛顿法)

    • 靠近极小值时速度减慢。
    • 直线搜索可能会产生一些问题。
    • 可能会“之字型”地下降。

    1>梯度下降收敛速度慢的原因:

    1 梯度下降中,x = φ(x) = x - f'(x),φ'(x) = 1 - f''(x) != 0极值领域一般应该不会满足为0。则根据[最优化方法:非线性方程的求极值方法]高阶收敛定理2.6可以梯度下降在根*x附近一般一阶收敛。

    2 梯度下降方法中,负梯度方向从局来看是二次函数的最快下降方向,但是从整体来看却并非最好。

    2> 梯度下降最优解

    梯度下降法实现简单,当目标函数是凸函数时,梯度下降法的解是全局解。一般情况下,其解不保证是全局最优解,梯度下降法的速度也未必是最快的。

    梯度下降用来求最优解,哪些问题可以求得全局最优?哪些问题可能局部最优解?

    对于上面的linear regression问题,最优化问题对theta的分布是unimodal,即从图形上面看只有一个peak,所以梯度下降最终求得的是全局最优解。然而对于multimodal的问题,因为存在多个peak值,很有可能梯度下降的最终结果是局部最优。

    3> lz Z字型应该可以通过对feature进行归一化处理解决。

    梯度gradient

    标量场中某一点上的梯度指向标量场增长最快的方向,梯度的长度是这个最大的变化率。更严格的说,从欧氏空间Rn到R的函数的梯度是在Rn某一点最佳的线性近似。在这个意义上,梯度是雅戈比矩阵的一个特殊情况。在单变量的实值函数的情况,梯度只是导数,或者,对于一个线性函数,也就是线的斜率。[gradient]

    梯度下降解决最优化问题

    在机器学习中,基于基本的梯度下降法发展了两种梯度下降方法,分别为随机梯度下降法和批量梯度下降法。

      比如对一个线性回归(Linear Logistics)模型[ 训练数据的格式如下:x1,x2,x3,⋯,xn,y。 所有的这些数据称为训练集,其中x称为feature,y称为target。现在又有一些数据:x1,x2,x3,⋯,xn, 需要做的是根据这些x的值,推测出y的值 ],假设下面的h(x)是要拟合的函数,J(θ)为损失函数,θ是参数,要迭代求解的值,θ求解出来了那最终要拟合的函数h(θ)就出来了。其中m是训练集的样本个数,n是特征的个数。

    皮皮blog


    批量梯度下降法(Batch Gradient Descent,BGD)

    批量梯度下降是一种对参数的update进行累积,然后批量更新的一种方式。用于在已知整个训练集时的一种训练方式,但对于大规模数据并不合适。

    一般说的梯度下降都是指批梯度下降。batch指的是,每次更新θ的时候都需要所有的数据集。

    梯度下降算法

    for i in range(nb_epochs):
      params_grad = evaluate_gradient(loss_function, data, params)
      params = params - learning_rate * params_grad

    算法每次改变θ一点点

    如果θ到达一个值使cost func到达极值,这时cost func的梯度为0,所以θ就不会更新了。

      (1)将J(θ)对θ求偏导,得到每个θ对应的的梯度:

      (2)由于是要最小化风险函数,所以按每个参数θ的梯度负方向,来更新每个θ:

      (3)从上面公式可以注意到,它得到的是一个全局最优解。

    梯度下降的迭代步长选择

    [机器学习模型选择:调参参数选择 ]

    批梯度下降算法评价

    对于批量梯度下降法,样本个数m,x为n维向量,一次迭代需要把m个样本全部带入计算,迭代一次计算量为m*n2。

    这个算法有两个缺陷:
        数据集很大时,训练过程计算量太大;
        需要得到所有的数据才能开始训练;

    批梯度下降每迭代一步,都要用到训练集所有的数据,如果m很大,那么可想而知这种方法的迭代速度会相当的慢。所以,这就引入了另外一种方法——随机梯度下降。

    皮皮blog



    随机梯度下降(Stochastic Gradient Descent,SGD)

    随机梯度下降,也叫增量梯度下降,是一种对参数随着样本训练,一个一个的及时update的方式。当有新的数据时,直接通过上式更新θ,这就是所谓的online learning。又因为每次更新都只用到一个数据,所以可以显著减少计算量。常用于大规模训练集,但往往容易收敛到局部最优解。
    说明:因为最小二乘问题是一个求凸函数极值的问题,它只有一个最优解,没有所谓的局部最优,所以在这个问题上完全可以大用梯度下降来解。

      (1)上面的风险函数可以写成如下这种形式,损失函数对应的是训练集中每个样本的粒度,而上面批量梯度下降对应的是所有的训练样本:


      (2)每个样本的损失函数,对θ求偏导得到对应梯度,来更新θ:


    随机梯度下降能及时更新模型,比如一个场景下,我们训练了一个lr模型,应用于线上环境,当这个模型跑在线上的时候我们会收集更多的数据。
    –根据某个单独样例的误差增量计算权值更新,得到近似的梯度下降搜索(随机取一个样例)
    –可以看作为每个单独的训练样例定义不同的误差函数
    –在迭代所有训练样例时,这些权值更新的序列给出了对于原来误差函数的梯度下降的一个合理近似
    –通过使下降速率的值足够小,可以使随机梯度下降以任意程度接近于真实梯度下降

    [sebastianruder.com/content/images/2016/09/sgd_fluctuation.png]

    SGD performs frequent updates with a high variance that cause the objective function to fluctuate heavily as in Image 1.随机梯度可能使cost函数抖动,但是总体方向是下降的。

    for i in range(nb_epochs):
      np.random.shuffle(data)
      for example in data:
        params_grad = evaluate_gradient(loss_function, example, params)
        params = params - learning_rate * params_grad

    随机梯度下降的收敛性及有效性分析

    为什么随机梯度下降可以收敛到最优解?

    能收敛的一个直观解释


    图中七条曲线,六条较细的都是些简单的极小值为0的一维凸函数,中间那个红色加粗的曲线是所有这些函数的和函数(为了更好看把和函数向下平移到了使其极小值为0的位置,函数性质不变)

    假设初始点是-4,目标就是找个迭代算法找到使和函数(红色加粗曲线)达到极小值的那个点(0.8附近),这里只考虑基于梯度的一阶方法。

    1.  如果使用随机梯度下降法,每次迭代会随机选择六个函数中的一个算其梯度确定该函数的下降方向,然后选择步长开始迭代。相比于全梯度,随机梯度下降确定的移动方向(并不一定是和函数的下降方向)每次只需要1/6的计算量,所以便宜。

    2. 从初始点-4开始,随机选择六个函数中的任何一个,所产生的梯度方向都是向右的,都是指向和函数的极小点的。持续迭代,如果当前迭代点离极小点很远,就会以大概率得到指向和函数极小点的方向。如果步长选择‘得当’,就‘可以’‘收敛’。

    也就是随机梯度下降虽然不是每次一个样本都是最优下降方向,但是很多样本加起来,大致方向就和批梯度类似了。

    [为什么随机梯度下降方法能够收敛?]

    为什么随机梯度下降通过少量迭代能达到批梯度下降的效果?

    lz认为:批梯度下降计算梯度时,同时计算了所有数据,其中包含了相似的(一定程度上可以认为是冗余的)数据(比如说一个地点附近两个点,另一个地点附近一个点,但是真实分布可能是另一个地点附近也是两个点,这样的话,前一个地点的那两个点可以认为是冗余的),所以实际上,在批梯度下降中即使我们使用少量的随机数据得到的结果和计算所有数据的结果差不多。而随机梯度就是只使用了随机选择的数据,如果这些数据刚好不是冗余的(或者是近似这样)就可以不完全遍历完数据就到达最优解附近(一般会损失一定精度不是最优的而是附近)。Batch gradient descent performs redundant computations for large datasets, as it recomputes gradients for similar examples before each parameter update. SGD does away with this redundancy by performing one update at a time. It is therefore usually much faster and can also be used to learn online.

    皮皮blog



    批梯度下降和随机梯度下降的对比的区别

    随机梯度下降是通过每个样本来迭代更新一次,如果样本量很大的情况(例如几十万),那么可能只用其中几万条或者几千条的样本,就已经将θ迭代到最优解了。对比上面的批量梯度下降,迭代一次需要用到十几万训练样本,一次迭代不可能最优,如果迭代10次的话就需要遍历训练样本10次。

    随机梯度下降每次迭代只使用一个样本,迭代一次计算量为n2,当样本个数m很大的时候,随机梯度下降迭代一次的速度要远高于批量梯度下降方法。

    两者的关系可以这样理解:随机梯度下降方法以损失很小的一部分精确度和增加一定数量的迭代次数为代价,换取了总体的优化效率的提升。增加的迭代次数远远小于样本的数量。

    SGD伴随的一个问题是噪音较BGD要多,使得SGD并不是每次迭代都向着整体最优化方向。

    批量梯度下降---最小化所有训练样本的损失函数,使得最终求解的是全局的最优解,即求解的参数是使得风险函数最小,但是对于大规模样本问题效率低下。

    随机梯度下降---最小化每条样本的损失函数,虽然不是每次迭代得到的损失函数都向着全局最优方向, 但是大的整体的方向是向全局最优解的,最终的结果往往是在全局最优解附近,适用于大规模训练样本情况。

    标准梯度下降和随机梯度下降之间的关键区别

    –标准梯度下降是在权值更新前对所有样例汇总误差,而随机梯度下降的权值是通过考查某个训练样例来更新的
    –在标准梯度下降中,权值更新的每一步对多个样例求和,需要更多的计算
    –标准梯度下降,由于使用真正的梯度,标准梯度下降对于每一次权值更新经常使用比随机梯度下降大的步长
    –如果标准误差曲面有多个局部极小值,随机梯度下降有时可能避免陷入这些局部极小值中

    皮皮blog



    梯度下降的改进和加速

    Mini-batch gradient

    它还是采用了batch的思路,也就是所有样本一起更新。和batch不同的是mini,在求解方向的时候选择了一部分样本一起更新,这样就减少了计算量,同时它又不像SGD那样极端只使用一个样本,所以保证了方向的精确性。

    mini-batch评价

    一句话总结就是,mini-batch是一个位于BGD和SGD之间的算法,精度比BGD低,比SGD高,速度比BGD快,比SGD慢(这个结论只是单从公式上分析,没有实证)。

    a) reduces the variance of the parameter updates, which can lead to more stable convergence; lz随机选取数据组合成batch,应用了类似bagging算法一样,减小了方差。

    b) can make use of highly optimized matrix optimizations common to state-of-the-art deep learning libraries that make computing the gradient w.r.t. a mini-batch very efficient.

    batch大小选择

    Common mini-batch sizes range between 50 and 256, but can vary for different applications.

    mini-batch应用

    Mini-batch gradient descent is typically the algorithm of choice when training a neural network

    mini-batch算法

    θ=θηθJ(θ;x(i:i+n);y(i:i+n)).

    for i in range(nb_epochs):
      np.random.shuffle(data)
      for batch in get_batches(data, batch_size=50):
        params_grad = evaluate_gradient(loss_function, batch, params)
        params = params - learning_rate * params_grad

    Averaged SGD

    这是standardSGD的一个变化,到这里可以看到,再次在方向和步长上做文章,这里面有比较多的数学证明和推导,抽时间看了一会zhangtong老师的论文,没有完全理解,有时间再认真看一下。

    其它技巧

    为避免bias,做shuffle。但有时在某种背景下,也可刻意地事先order training examples。

    Batch normalization。

    Early stopping。若指标趋近平稳,及时终止。

    Gradient noise。引入一个符合高斯分布的noise项,使得在poor initialization时具有更好的鲁棒性。形式如下:

    gt,i=gt,i+N(0,σ2t).

    同时对方差退火,因为随着训练进行越来越稳定,noise也随之减弱,退火项如下:
    σ2t=η(1+t)γ.

    Parallelizing and distributing SGD

    [An overview of gradient descent optimization algorithms]

    1)样本可靠度,特征完备性的验证
          例如可能存在一些outlier,这种outlier可能是测量误差,也有可能是未考虑样本特征,例如有一件衣服色彩评分1分,料子1分,确可以卖到10000万元,原来是上面有一个姚明的签名,这个特征没有考虑,所以出现了训练的误差,识别样本中outlier产生的原因。
    2)批量梯度下降方法的改进
          并行执行批量梯度下降
    3)随机梯度下降方法的改进
          找到一个合适的训练路径(学习顺序),去最大可能的找到全局最优解
    4)假设合理性的检验
         H(X)是否合理的检验
    5)维度放大
        维度放大和过拟合问题,维度过大对训练集拟合会改善,对测试集的适用性会变差,如果找到合理的方法?

    某小皮



    启发式优化方法

      启发式方法指人在解决问题时所采取的一种根据经验规则进行发现的方法。其特点是在解决问题时,利用过去的经验,选择已经行之有效的方法,而不是系统地、以确定的步骤去寻求答案。启发式优化方法种类繁多,包括经典的模拟退火方法、遗传算法、蚁群算法以及粒子群算法等等。

      还有一种特殊的优化算法被称之多目标优化算法,它主要针对同时优化多个目标(两个及两个以上)的优化问题,这方面比较经典的算法有NSGAII算法、MOEA/D算法以及人工免疫算法等。

      《[Evolutionary Algorithm] 进化算法简介

    from:http://blog.csdn.net/pipisorry/article/details/23692455
    ref: [An overview of gradient descent optimization algorithms] [论文arxiv.org] [梯度下降最优算法综述]

    [http://www.stanford.edu/class/cs229/notes/cs229-notes1.pdf ]

    [stanford机器学习 实验1]

    [Deep learning系列(十)随机梯度下降 ]


    展开全文
  • 浅谈对梯度下降法的理解

    万次阅读 多人点赞 2018-01-03 09:30:45
    浅谈梯度下降法   如果读者对方向导数和梯度的定义不太了解,请先阅读上篇文章《方向导数与梯度》。   前些时间接触了机器学习,发现梯度下降法是机器学习里比较基础又比较重要的一个求最小值的算法。梯度下降算法...

    浅谈梯度下降法

     

    如果读者对方向导数和梯度的定义不太了解,请先阅读上篇文章《方向导数与梯度》

     

    前些时间接触了机器学习,发现梯度下降法是机器学习里比较基础又比较重要的一个求最小值的算法。梯度下降算法过程如下:

    1)随机初始值

    2)迭代,直至收敛。表示在处的负梯度方向,表示学习率。

     

    在这里,简单谈一下自己对梯度下降法的理解。

    首先,要明确梯度是一个向量,是一个n元函数f关于n个变量的偏导数,比如三元函数f的梯度为(fx,fy,fz),二元函数f的梯度为(fx,fy),一元函数f的梯度为fx然后要明白梯度的方向是函数f增长最快的方向,梯度的反方向是f降低最快的方向

    我们以一元函数为例,介绍一下梯度下降法。

    f(x) = (x-1)2+1/2

     

     

    上图给出了函数f的图像和初始值x0我们希望求得函数f的最小值,因为沿负梯度方向移动一小步后,f值降低,故只需x0沿着负梯度方向移动一小步即可。

     

    而f在点x0的导数大于0,从而f在点x0的梯度方向为正,即梯度方向为f’(x0),故由梯度下降法可知,下一个迭代值,也就是说x0向左移动一小步到了x1,同理在x1点的导数同样大于零,下一次迭代x1向左移动一小步到达x2,一直进行下去,只要每次移动的步数不是很大,我们就可以得到收敛1的解x

    上述证实了我们对分析(蓝色倾斜字体)的验证。

     

    同样,如果处置选在了最小值的左边,即如图所示:

     

    由于f’(x0)<0,所以梯度方向为负,负梯度方向为正,故需将x0沿负梯度方向移动一小步,即向右移动一小步,这样使得f值更小一些。或用梯度下降法迭代公式,依次我们可以得到如图所示的x1,x2,...,xk,...,直到收敛至最小值。

     

    对于二元函数,我们也可以通过实例验证梯度下降法的合理性:

     

     

    在每次得到一个点(xk,yk)时,我们需要计算(fx(xk),fy(yk)),这个方向表示梯度f增长最快的方向,-(fx(xk),fy(yk))表示梯度下降最快的方向,故只需将(xk,yk)沿着-(fx(xk),fy(yk))这个方向移动一小步,就可以减少f的值,直至收敛到最小值,如上图所示。

     

    谈几点梯度下降法需要注意的地方,也是自己对梯度下降法的理解:

    1)梯度下降不一定可以收敛到最小值。

    梯度下降法是收敛到局部最小值,不一定可以收敛到全局最小值。

    比如:

     

    我们初始值选择了如图的x0,由于f在点x0的导数大于0,梯度方向向右,负梯度方向向左,从而x0向左移动,逐渐收敛到了局部最小值,而不能收敛到全局最小值。

    2)学习率的大小要适中。

    学习率太小,每次移动步长太小,收敛太慢,这个比较容易理解。

    学习率太大,每次移动步长大,可能导致不收敛,这里用一个图来表示一下:

     

    由于距离最小值点越远,导数越大,从而导致步长越来越大,不会收敛。

    3)不一定选择负梯度方向,只要是值下降的方向即可。

    在每一次迭代选择方向时,我们只要选择与梯度方向夹角小于90度的向量的反方向就可,不一定要选择负梯度方向。但由于,满足这样条件的向量不太容易求出,我们就选择了与梯度方向0度的向量的反方向(负梯度方向),而且这个方向函数值减少的更快,更快的收敛,故是个不错的选择。

    4)求最大值的梯度上升法。

    f的梯度方向是f的值增长最快的方向。我们每次沿负梯度方向移动一小步可以逐步收敛到局部最大值,因此我们每次沿梯度方向也可以得到函数f的局部最大值。迭代公式为:

    这里表示在处的梯度方向,与梯度下降法的含义不同。

     

     

    本文由作者结合自己对梯度的理解写出,希望对大家有所帮助,敬请阅读、指正。

     

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

    万次阅读 多人点赞 2017-12-16 09:09:35
    梯度下降算法(Gradient Descent Optimization)是神经网络模型训练最常用的优化算法。对于深度学习模型,基本都是采用梯度下降算法来进行优化训练的。梯度下降算法背后的原理:目标函数关于参数的梯度将是目标函数...


    作者:叶    虎

    编辑:祝鑫泉


    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




    展开全文
  • 什么是梯度下降 梯度下降法(gradient descent)是一种常见的一阶(first-order)优化方法,是求解无约束优化问题最简单、最经典的方法之一。所谓的一阶方法就是仅使用目标函数的一阶导数,不利用其高阶导数。 那...
  • 梯度下降 随机梯度下降 算法

    千次阅读 2018-09-25 17:03:21
    一、一维梯度下降 算法思想: 我们要找到一个函数的谷底,可以通过不断求导,不断逼近,找到一个函数求导后为0,我们就引入了一个概念 学习率(也可以叫作步长),因为是不断逼近某个x,所以学习率过大会导致超过...
  • 随机梯度下降法概述与实例

    万次阅读 2018-12-15 15:45:26
    机器学习算法中回归算法有很多,例如神经网络回归算法、蚁群回归算法,支持向量机回归算法等,其中也包括本篇文章要讲述的梯度下降算法,本篇文章将主要讲解其基本原理以及基于Spark MLlib进行实例示范,不足之处请...
  • 最近实验集体学习机器学习,其中涉及到梯度下降及其变体,不是很清楚,看了好多资料和博客。在这里整理总结一下。如果哪里写得不对,请大家指正。 一、梯度下降(GD) &amp;amp;amp;amp;amp;amp;nbsp; &...
  • 原文出处:...这篇文章回顾了基于梯度的随机优化算法在这几年的重要发展 -- SAG、SVRG。 很多常见的机器学习模型的目标(比如最小二乘做线性回归、逻辑回归)都可以概括成以下这种一般形式:
  • 机器学习 SGD BGD 批量梯度下降 随机梯度下降
  • 梯度下降

    千次阅读 2019-03-03 23:15:13
    梯度下降法的基本思想可以类比为一个下山的过程。假设这样一个场景:一个人被困在山上,需要从山上下来(i.e. 找到山的最低点,也就是山谷)。但此时山上的浓雾很大,导致可视度很低。因此,下山的路径就无法确定,他...
  • 梯度下降与随机梯度下降概念及推导过程

    万次阅读 多人点赞 2019-07-09 13:43:13
    同这一章的梯度下降部分加起来,才是我们要讲的如何求解多元线性回归.如果写在一章中,内容过长,担心有的同学会看不完,所以拆分成两章.[坏笑] 上一章中有提到利用解析解求解多元线性回归,虽然看起来很方便,但是在...
  • 本文结合实例简单介绍梯度下降算法。 梯度下降用处广泛,既可以用于回归也可以用于分类,在神经网络中更是作为主流方法完成网络参数估计任务。 方便起见,用二维点表示我们的训练数据集。    (a) ...
  • 随机梯度下降(SGD)与经典的梯度下降法的区别

    万次阅读 多人点赞 2019-01-04 14:50:49
    随机梯度下降(SGD)与经典的梯度下降法的区别 经典的优化方法,例如梯度下降法,在每次迭代过程中需要使用所有的训练数据,这就给求解大规模数据优化问题带来挑战。 知识点:随机梯度下降法(SGD)、小批量梯度下降法。...
  • 关于梯度上升和梯度下降的理解

    万次阅读 2017-08-13 22:23:14
    在求极值的问题中,有梯度上升和梯度下降两个最优化方法。梯度上升用于求最大值,梯度下降用于求最小值。
  • 梯度下降法的推导(非常详细、易懂的推导)

    万次阅读 多人点赞 2018-07-05 20:01:40
    梯度下降算法的公式非常简单,”沿着梯度的反方向(坡度最陡)“是我们日常经验得到的,其本质的原因到底是什么呢?为什么局部下降最快的方向就是梯度的负方向呢?也许很多朋友还不太清楚。没关系,接下来我将以通俗...
  • 梯度下降算法的正确步骤是什么?

    万次阅读 2018-08-27 09:09:42
    梯度下降算法的正确步骤是什么?   a.用随机值初始化权重和偏差 b.把输入传入网络,得到输出值 c.计算预测值和真实值之间的误差 d.对每一个产生误差的神经元,调整相应的(权重)值以减小误差 e.重复迭代...
  • 梯度下降法和最速下降法区别

    万次阅读 多人点赞 2018-08-04 11:34:18
    一直以来,我都认为,梯度下降法就是最速下降法,反之亦然,老师是这么叫的,百度百科上是这么写的,wiki百科也是这么说的,这么说,必然会导致大家认为,梯度的反方向就是下降最快的方向,然而最近在读Stephen Boyd...
  • 简述动量Momentum梯度下降

    万次阅读 多人点赞 2017-09-15 15:50:04
    梯度下降是机器学习中用来使模型逼近真实分布的最小偏差的优化方法。 在普通的随机梯度下降和批梯度下降当中,参数的更新是按照如下公式进行的:W = W - αdW b = b - αdb其中α是学习率,dW、db是cost function...
  • 梯度下降法的步长到底怎么确定?

    千次阅读 2017-12-12 14:48:37
    https://www.zhihu.com/question/37911687
1 2 3 4 5 ... 20
收藏数 111,193
精华内容 44,477
关键字:

梯度下降