精华内容
下载资源
问答
  • 动量随机梯度下降
    千次阅读 多人点赞
    2018-05-23 15:18:33

    1. SGD图示

    随机梯度下降


    红色表示SGD的收敛路径,棕色表示梯度下降的收敛路径。普通的GD算法就是计算出每一时刻最陡的下降趋势(梯度),SGD在随机挑选某一分量的梯度方向进行收敛,详细解释可继续往下看。


    2. SGD公式理解


    注:这一部分引用自知乎用户Qi Qi,原回答链接

    随机梯度下降主要用来求解类似于如下求和形式的优化问题:

    f(x)=i=1nfi(w,xi,yi) f ( x ) = ∑ i = 1 n f i ( w , x i , y i )

    普通梯度下降算法:

    wt+1=wtηt+1f(wt)=wtηt+1i=1nfi(wt,xi,yi) w t + 1 = w t − η t + 1 ∇ f ( w t ) = w t − η t + 1 ∑ i = 1 n ∇ f i ( w t , x i , y i )

    n n 很大时,每次迭代计算所有的会非常耗时。fi随机梯度下降的想法就是: 每次在 fi ∇ f i 随机选取一个计算代替如上的 f ∇ f ,以这个随机选取的方向作为下降的方向。

    wt+1=wtηt+1fik(wt,xik,yik) w t + 1 = w t − η t + 1 ∇ f i k ( w t , x i k , y i k )

          由于 E[fik(wt,xik,yik)] E [ ∇ f i k ( w t , x i k , y i k ) ] = f(wt) ∇ f ( w t ) , 当选取学习率 ηt=O(1/t) η t = O ( 1 / t ) 时,算法在期望的意义下收敛。
          注意到在 wt w t 靠近极小值点 w w ∗ 时, f(w) ∇ f ( w ∗ ) ≠ 0,这导致随机梯度下降法精度低。由于方差的存在,要使得算法收敛,就需要 ηt η t 随t逐渐减小。因此导致函数即使在强凸且光滑的条件下,收敛速度也只有 O(1/T) O ( 1 / T ) . 后来提出的变种SAGSVRGSDCA都是在降方差,为了保证在 wt w t w w ∗ 时,方差趋于0。以上提到的几种变种都能达到线性收敛速度。


    3. momentum 动量

    “动量”这个概念源自于物理学,解释力在一段时间内作用所产生的物理量。我们没必要往复杂想,其实我们可以将动量约等于惯性。我们对惯性的基本理解就是: 当你跑起来,由于惯性的存在你跑起来会比刚起步加速的时候更轻松,当你跑过头,想调头往回跑,惯性会让你拖着你。
    在普通的梯度下降法 w=w+v w = w + v 中,每次 x x 的更新量v

    v=ηdw v = − η d w
    当使用动量时,则把每次 x x 的更新量v考虑为本次的梯度下降量 ηdw − η d w 与上次 w w 的更新量v乘上一个介于[0, 1]的因子momentum的和,即 v v
    vt=ηdw+vt1momentum

    如果这一时刻更新度 vt v t 与上一时刻更新度 vt1 v t − 1 的方向相同,则会加速。反之,则会减速。加动量的优势有两点:
    1. 加速收敛
    2. 提高精度(减少收敛过程中的振荡)

    更多相关内容
  • 面向深度神经网络训练的数据差分隐私保护随机梯度下降算法.pdf
  • 动量随机梯度下降算法中参数更新公式 设动量为 ,其动量更新公式: (是本次更新之前的动量,参考上面的指数加权平均) 动量v其实是负梯度(梯度方向表示上升最快的方向,反方向则表示下降最快的方向)的指数加权...

    1.指数加权平均

    类比n个数求平均:average=\frac{1+2+3+....+n}{n}

    如果 v_{t-1} 表示前 t-1 个数的平均,n_{t} 表示第 t 个数,那么 t 个数的指数加权平均定义为:

                                           v_{t}=\alpha v_{t-1}+\beta n_{t}       

    其展开为:

                                           v_{t-1}=\alpha v_{t-2}+\beta n_{t-1}

                                           v_{t-2}=\alpha v_{t-3}+\beta n_{t-2}

                                             ....

                                           v_{3}=\alpha v_{2}+\beta n_{3}

                                           v_{2}=\alpha v_{1}+\beta n_{2}

                                           v_{1}=\beta n_{1}

                              则有    v_{t}=\alpha (\alpha v_{t-2}+\beta n_{t-1})+\beta n_{t}=\alpha ^{2}v_{t-2}+\alpha \beta n_{t-1}+\beta n_{t}=.......

             全部展开有          v_{t}=\alpha ^{t-1}\beta n_{1}+\alpha ^{t-2}\beta n_{2}+\alpha ^{t-3}\beta n_{3}+.......+\alpha \beta n_{t-1}+\beta n_{t}

        将\beta提取出来得        v_{t}=\beta (\alpha ^{t-1} n_{1}+\alpha ^{t-2} n_{2}+\alpha ^{t-3} n_{3}+.......+\alpha n_{t-1}+ n_{t})

    可以看出来,括号中\alpha即为加权平均系数完整系数应该是\alpha\beta的乘积,为了便于理解此处忽略\beta),又因为\alpha为指数形式,所以称之为指数加权平均。                                

    2.动量

    众所周知,使用梯度下降算法更新参数的公式为:

                                             \Theta=\Theta -\epsilon \Delta\Delta为梯度,\epsilon是学习率)

    在具体的迭代过程中,上式只利用本次迭代计算的梯度更新参数,而加入动量机制则是考虑了之前每次迭代计算的梯度。

     

    3.带动量的随机梯度下降算法中参数更新公式

    设动量为  v  ,其动量更新公式:

                                           v=\alpha {v}'-\epsilon \Delta   ({v}'是本次更新之前的动量,参考上面的指数加权平均)

                                           \Theta =\Theta +v        

     动量v其实是负梯度(梯度方向表示上升最快的方向,反方向则表示下降最快的方向)的指数加权平均,所以v是负数,所以上面的参数更新公式中是加上v,算法如下:

    4.Nesterov动量

    相比于标准动量(上面描述的动量),Nesterov动量在计算梯度\Delta之前,首先用{v}'更新了参数:{\Theta }'=\Theta +\alpha {v}',然后再求梯度。

    其步骤除了求梯度之前更新了参数之外,其他步骤和标准动量的步骤一致,具体算法如下。

     

     

     

    展开全文
  • 原文链接:动手学深度学习pytorch版:优化算法7.1-7.4 ... 最好去看一下原书和GitHub,讲解更加详细。...我们先以简单的一维梯度下降为例, 解释梯度下降算法可能降低目标函数值的原因。假设连续可导的函数 f:R→

    原文链接:动手学深度学习pytorch版:优化算法7.1-7.4
    github:https://github.com/ShusenTang/Dive-into-DL-PyTorch

    最好去看一下原书和GitHub,讲解更加详细。

    虽然梯度下降在深度学习中很少被直接使用,但理解梯度的意义以及沿着梯度反方向更新自变量可能降低目标函数值的原因是学习后续优化算法的基础。

    1. 梯度下降

    1.1 一维梯度下降

    我们先以简单的一维梯度下降为例, 解释梯度下降算法可能降低目标函数值的原因。假设连续可导的函数 f : R → R f: \mathbb{R} \rightarrow \mathbb{R} f:RR 的输入和输出都是标量。给 定绝对值足够小的数 ϵ \epsilon ϵ, 根据泰勒展开公式,我们得到以下的近似:
    f ( x + ϵ ) ≈ f ( x ) + ϵ f ′ ( x ) f(x+\epsilon) \approx f(x)+\epsilon f^{\prime}(x) f(x+ϵ)f(x)+ϵf(x)

    这里 f ′ ( x ) f^{\prime}(x) f(x) 是函数 f f f x x x 处的梯度。一维函数的梯度是一个标量,也称导数。

    这意味着,如果通过
    x ← x − η f ′ ( x ) x \leftarrow x-\eta f^{\prime}(x) xxηf(x)

    来迭代 x x x, 函数 f ( x ) f(x) f(x) 的值可能会降低。因此在梯度下降中, 我们先选取一个初始值 x x x 和常数 η > 0 \eta>0 η>0, 然后不断通过上式来迭代 x x x, 直到达到停止条 件, 例如 f ′ ( x ) 2 f^{\prime}(x)^{2} f(x)2 的值已足够小或迭代次数已达到某个值。

    下面我们以目标函数 f ( x ) = x 2 f(x)=x^{2} f(x)=x2 为例来看一看梯度下降是如何工作的。虽然我们知道最小化 f ( x ) f(x) f(x) 的解为 x = 0 x=0 x=0, 这里依然使用这个简单函数来观 察 x x x 是如何被迭代的。首先,导入本节实验所需的包或模块。

    %matplotlib inline
    import numpy as np
    import torch
    import math
    import sys
    sys.path.append("..") 
    import d2lzh_pytorch as d2l
    import os
    os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    

    接下来使用 x = 10 x=10 x=10 作为初始值,并设 η = 0.2 η=0.2 η=0.2。 使用梯度下降对 x x x 迭代10次,可见最终 x x x 的值较接近最优解。

    def gd(eta):
        x = 10
        results = [x]
        for i in range(10):
            x -= eta * 2 * x  # f(x) = x * x的导数为f'(x) = 2 * x
            results.append(x)
        print('epoch 10, x:', x)
        return results
    
    res = gd(0.2)
    

    输出:

    epoch 10, x: 0.06046617599999997

    绘制出自变量 x x x 的迭代轨迹

    def show_trace(res):
        n = max(abs(min(res)), abs(max(res)), 10)
        f_line = np.arange(-n, n, 0.1)
        d2l.set_figsize()
        d2l.plt.plot(f_line, [x * x for x in f_line])
        d2l.plt.plot(res, [x * x for x in res], '-o')
        d2l.plt.xlabel('x')
        d2l.plt.ylabel('f(x)')
    
    show_trace(res)
    

    请添加图片描述

    1.2 学习率

    上述梯度下降算法中的正数 η η η 通常叫作学习率。这是一个超参数,需要人工设定。如果使用过小的学习率,会导致 x x x 更新缓慢从而需要更多的迭代才能得到较好的解。

    下面展示使用学习率 η = 0.05 \eta=0.05 η=0.05 时自变量 x x x 的迭代轨迹。可见,同样迭代10次后,当学习率过小时,最终 x x x 的值依然与最优解存在较大偏差。

    show_trace(gd(0.05))
    

    输出:

    epoch 10, x: 3.4867844009999995

    请添加图片描述
    如果设置过大的学习率,可能会导致最优解 x = 0 x = 0 x=0 并逐渐发散。

    show_trace(gd(1.1))
    

    输出:

    epoch 10, x: 61.917364224000096

    请添加图片描述

    1.3 多维梯度下降

    在了解了一维梯度下降之后, 我们再考虑一种更广义的情况: 目标函数的输入为向量, 输出为标量。假设目标函数 f : R d → R f: \mathbb{R}^{d} \rightarrow \mathbb{R} f:RdR 的输入是一个 d d d 维 向量 x = [ x 1 , x 2 , … , x d ] ⊤ \boldsymbol{x}=\left[x_{1}, x_{2}, \ldots, x_{d}\right]^{\top} x=[x1,x2,,xd] 。目标函数 f ( x ) f(\boldsymbol{x}) f(x) 有关 x \boldsymbol{x} x 的梯度是一个由 d d d 个偏导数组成的向量:

    ∇ x f ( x ) = [ ∂ f ( x ) ∂ x 1 , ∂ f ( x ) ∂ x 2 , . . . , ∂ f ( x ) ∂ x d ] T {{\nabla }_{x}}f(x)={{[\frac{\partial f(x)}{\partial {{x}_{1}}},\frac{\partial f(x)}{\partial x2},...,\frac{\partial f(x)}{\partial {{x}_{d}}}]}^{T}} xf(x)=[x1f(x),x2f(x),...,xdf(x)]T

    因此,我们可能通过梯度下降算法来不断降低目标函数 f f f 的值:

    x ← x − η ∇ f ( x ) x\leftarrow x-\eta \nabla f(x) xxηf(x)

    下面我们构造一个输入为二维向量 x = [ x 1 , x 2 ] T x=[x_1, x_2]^T x=[x1,x2]T 和输出为标量的目标函数 f ( x ) = x 1 2 + 2 x 2 2 f(x)=x^2_1+2x^2_2 f(x)=x12+2x22。那么梯度 ∇ f ( x ) = [ 2 x 1 , 4 x 2 ] ∇f(x)=[2x_1,4x_2] f(x)=[2x1,4x2]

    def train_2d(trainer):  # 本函数将保存在d2lzh_pytorch包中方便以后使用
        x1, x2, s1, s2 = -5, -2, 0, 0  # s1和s2是自变量状态,本章后续几节会使用
        results = [(x1, x2)]
        for i in range(20):
            x1, x2, s1, s2 = trainer(x1, x2, s1, s2)
            results.append((x1, x2))
        print('epoch %d, x1 %f, x2 %f' % (i + 1, x1, x2))
        return results
    
    def show_trace_2d(f, results):  # 本函数将保存在d2lzh_pytorch包中方便以后使用
        d2l.plt.plot(*zip(*results), '-o', color='#ff7f0e')
        x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))
        d2l.plt.contour(x1, x2, f(x1, x2), colors='#1f77b4')
        d2l.plt.xlabel('x1')
        d2l.plt.ylabel('x2')
    

    然后,观察学习率为0.1时自变量的迭代轨迹。使用梯度下降对自变量 x x x 迭代20次后,可见最终 x x x 的值较接近最优解 [ 0 , 0 ] [0, 0] [0,0]

    eta = 0.1
    
    def f_2d(x1, x2):  # 目标函数
        return x1 ** 2 + 2 * x2 ** 2
    
    def gd_2d(x1, x2, s1, s2):
        return (x1 - eta * 2 * x1, x2 - eta * 4 * x2, 0, 0)
    
    show_trace_2d(f_2d, train_2d(gd_2d))
    

    输出:

    epoch 20, x1 -0.057646, x2 -0.000073

    请添加图片描述

    2. 随机梯度下降

    在深度学习里,目标函数通常是训练数据集中有关各个样本的损失函数的平均。朴素的梯度下降根据目标函数 f ( x ) f(x) f(x) 对所有样本梯度取平均,一轮结束之后再更新迭代 x x x
    ∇ f ( x ) = 1 n ∑ i = 1 n ∇ f i ( x ) \nabla f(x)=\frac{1}{n}\sum\limits_{i=1}^{n}{\nabla {{f}_{i}}(x)} f(x)=n1i=1nfi(x)
    x ← x − η ∇ f ( x ) x\leftarrow x-\eta \nabla f(x) xxηf(x)

    而随机梯度下降的每次迭代随机均匀取出一个样本索引 i ∈ 1 , . . . , n i \in {1,...,n} i1,...,n,并计算梯度 ∇ f i ( x ) \nabla f_i(x) fi(x) 来迭代 x x x
    x ← x − η ∇ f i ( x ) x\leftarrow x-\eta \nabla f_i(x) xxηfi(x)

    下面我们通过在梯度中添加均值为0的随机噪声来模拟随机梯度下降,以此来比较它与梯度下降的区别。

    def sgd_2d(x1, x2, s1, s2):
        return (x1 - eta * (2 * x1 + np.random.normal(0.1)),
                x2 - eta * (4 * x2 + np.random.normal(0.1)), 0, 0)
    
    show_trace_2d(f_2d, train_2d(sgd_2d))
    

    输出:

    epoch 20, x1 -0.047150, x2 -0.075628

    请添加图片描述
    可以看到,随机梯度下降中自变量的迭代轨迹相对于梯度下降中的来说更为曲折。这是由于实验所添加的噪声使模拟的随机梯度的准确度下降。在实际中,这些噪声通常指训练数据集中的无意义的干扰。

    3. 小批量随机梯度下降

    在每一次迭代中,梯度下降使用整个训练数据集来计算梯度,因此它有时也被称为批量梯度下降(batch gradient descent)。而随机梯度下降在每次迭代中只随机采样一个样本来计算梯度。正如我们在前几章中所看到的,我们还可以在每轮迭代中随机均匀采样多个样本来组成一个小批量,然后使用这个小批量来计算梯度。

    g t ← ∇ f B t ( x t − 1 ) = 1 ∣ B ∣ ∑ i ∈ B t ∇ f i ( x t − 1 ) {{g}_{t}}\leftarrow \nabla {{f}_{{{B}_{t}}}}({{x}_{t-1}})=\frac{1}{|B|}\sum\limits_{i\in {{B}_{t}}}^{{}}{\nabla {{f}_{i}}({{x}_{t-1}})} gtfBt(xt1)=B1iBtfi(xt1)
    x t ← x t − 1 − η t g t {{x}_{t}}\leftarrow {{x}_{t-1}}-{{\eta }_{t}}{{g}_{t}} xtxt1ηtgt

    小批量随机梯度下降中每次迭代的计算开销为 O ( ∣ B ∣ ) O(|B|) O(B) 。当批量大小为1时,该算法即为随机梯度下降;当批量大小等于训练数据样本数时,该算法即为梯度下降。

    pytorch 简洁实现

    # 本函数与原书不同的是这里第一个参数优化器函数而不是优化器的名字# 例如: optimizer_fn=torch.optim.SGD, optimizer_hyperparams={"lr": 0.05}def train_pytorch_ch7(optimizer_fn, optimizer_hyperparams, features, labels,
                        batch_size=10, num_epochs=2):
        # 初始化模型
        net = nn.Sequential(
            nn.Linear(features.shape[-1], 1)
        )
        loss = nn.MSELoss()
        optimizer = optimizer_fn(net.parameters(), **optimizer_hyperparams)
    
        def eval_loss():
            return loss(net(features).view(-1), labels).item() / 2
    
        ls = [eval_loss()]
        data_iter = torch.utils.data.DataLoader(
            torch.utils.data.TensorDataset(features, labels), batch_size, shuffle=True)
    
        for _ in range(num_epochs):
            start = time.time()
            for batch_i, (X, y) in enumerate(data_iter):
                # 除以2是为了和train_ch7保持一致, 因为squared_loss中除了2
                l = loss(net(X).view(-1), y) / 2 
    
                optimizer.zero_grad()
                l.backward()
                optimizer.step()
                if (batch_i + 1) * batch_size % 100 == 0:
                    ls.append(eval_loss())
        # 打印结果和作图
        print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
        d2l.set_figsize()
        d2l.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
        d2l.plt.xlabel('epoch')
        d2l.plt.ylabel('loss')
     
    train_pytorch_ch7(optim.SGD, {"lr": 0.05}, features, labels, 10)
    

    输出:

    loss: 0.245491, 0.044150 sec per epoch

    请添加图片描述

    4. 动量法

    梯度下降和随机梯度下降中我们提到,目标函数有关自变量的梯度代表了目标函数在自变量当前位置下降最快的方向。因此,梯度下降也叫作最陡下降(steepest descent)。在每次迭代中,梯度下降根据自变量当前位置,沿着当前位置的梯度更新自变量。然而,如果自变量的迭代方向仅仅取决于自变量当前位置,这可能会带来一些问题。

    4.1 梯度下降的问题

    让我们考虑一个输入和输出分别为二维向量 x = [ x 1 , x 2 ] T x=[x_1, x_2]^T x=[x1,x2]T 和标量的目标函数 f ( x ) = 0.1 x 1 2 + 2 x 2 2 f(x)=0.1x^2_1 + 2x^2_2 f(x)=0.1x12+2x22。下面实现基于这个目标函数的梯度下降,并演示使用学习率为 0.4 时自变量的迭代轨迹。

    %matplotlib inline
    import sys
    sys.path.append("..") 
    import d2lzh_pytorch as d2l
    import torch
    
    eta = 0.4 # 学习率
    
    def f_2d(x1, x2):
        return 0.1 * x1 ** 2 + 2 * x2 ** 2
    
    def gd_2d(x1, x2, s1, s2):
        return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)
    
    d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))
    

    输出:

    epoch 20, x1 -0.943467, x2 -0.000073

    请添加图片描述
    下面我们试着将学习率调得稍大一点,调成 0.6 ,此时自变量在竖直方向不断越过最优解并逐渐发散

    eta = 0.6
    d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))
    

    输出:

    epoch 20, x1 -0.387814, x2 -1673.365109

    请添加图片描述

    4.2 动量法

    动量法的提出是为了解决梯度下降的上述问题。设时间步ttt的自变量为 x t x_t xt,学习率为 η t η_t ηt。在时间步0,动量法创建速度变量 v 0 v_0 v0,并将其元素初始化成0。在时间步 t > 0 t>0 t>0,动量法对每次迭代的步骤做如下修改:
    v t ← γ v t − 1 + η t g t {{v}_{t}}\leftarrow \gamma {{v}_{t-1}}+{{\eta }_{t}}{{g}_{t}} vtγvt1+ηtgt
    x t ← x t − 1 − v t {{\text{x}}_{t}}\leftarrow {{x}_{t-1}}-{{v}_{t}} xtxt1vt

    其中,动量超参数 γ \gamma γ 满足 0 ≤ γ < 1 0≤γ<1 0γ<1 。当 γ = 0 γ=0 γ=0 时,动量法等价于小批量随机梯度下降。

    我们对动量法的速度变量做变形:
    v t ← γ v t − 1 + ( 1 − γ ) ( η t 1 − γ g t ) {{v}_{t}}\leftarrow \gamma {{v}_{t-1}}+(1-\gamma )(\frac{\eta \text{t}}{1-\gamma }{{\text{g}}_{t}}) vtγvt1+(1γ)(1γηtgt)
    由质数加权移动平均的形式可得,速度变量 v t v_t vt 实际上对序列 { η t − i g t − i 1 − γ : i = 0 , . . . , 1 ( 1 − γ ) − 1 } \{\frac{{{\eta }_{t-i}}{{g}_{t-i}}}{1-\gamma }:i=0,...,\frac{1}{(1-\gamma )}-1\} {1γηtigti:i=0,...,(1γ)11} 做了指数加权移动平均。换句话说,相比于小批量随机梯度下降,动量法在每个时间步的自变量更新量近似于将最近 1 1 − γ \frac{1}{1-\gamma} 1γ1个时间步的普通更新量(即学习率乘以梯度)做了质数加权移动平均后再除以 1 − γ 1-\gamma 1γ

    所以,在动量法中,自变量在各个方向上的移动幅度不仅取决当前梯度,还取决于过去的各个梯度在各个方向上是否一致。

    4.3 从零开始实现

    %matplotlib inline
    import sys
    sys.path.append("..") 
    import d2lzh_pytorch as d2l
    import torch
    
    features, labels = d2l.get_data_ch7()
    
    def init_momentum_states():
        v_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
        v_b = torch.zeros(1, dtype=torch.float32)
        return (v_w, v_b)
    
    def sgd_momentum(params, states, hyperparams):
        for p, v in zip(params, states):
            v.data = hyperparams['momentum'] * v.data + hyperparams['lr'] * p.grad.data
            p.data -= v.data
    
    d2l.train_ch7(sgd_momentum, init_momentum_states(),
                  {'lr': 0.02, 'momentum': 0.5}, features, labels)
    

    输出:

    loss: 0.245518, 0.042304 sec per epoch

    请添加图片描述

    4.4 简洁实现

    在 PyTorch 中,只需要通过参数 momentum 来指定动量超参数即可使用动量法。

    %matplotlib inline
    import sys
    sys.path.append("..") 
    import d2lzh_pytorch as d2l
    import torch
    
    d2l.train_pytorch_ch7(torch.optim.SGD, {'lr': 0.004, 'momentum': 0.9}, features, labels)
    

    输出:

    loss: 0.253280, 0.060247 sec per epoch

    请添加图片描述

    展开全文
  • 随机梯度下降、牛顿法、动量法、Nesterov、AdaGrad、RMSprop、Adam”随机梯度下降法牛顿法动量法Nesterov学习率应该慢慢减小的。AdaGradRMSpropAdamNadam 随机梯度下降法 怎么减小每次计算的参数量? 梯度下降法性...

    “随机梯度下降、牛顿法、动量法、Nesterov、AdaGrad、RMSprop、Adam”

    随机梯度下降法

    怎么减小每次计算的参数量?
    梯度下降法性价比低。
    mini-batch等价于随机梯度下降法。

    在这里插入图片描述
    步长越大和理想下降路径偏离越大。

    牛顿法

    在这里插入图片描述
    在这里插入图片描述
    实用性较差

    动量法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    指数加权移动平均法
    在这里插入图片描述
    动量法:把历史的数据也考虑进来,对参数的修改进行一些修正。

    Nesterov

    动量法:梯度和冲量共同决定下降方向。
    在这里插入图片描述
    怎么做到超前?
    Nesterov:不止利用历史数据,还要向前超前一步,然后再修正下降方向。

    学习率应该慢慢减小的。

    最简单的方法,每迭代一步,学习率减少一个固定的数值。
    当然这种方法并不好用。

    AdaGrad

    在这里插入图片描述
    在学习率下面除以一个数值,这个数值是历史上所有的梯度数据的平方再开方。
    在这里插入图片描述
    适用于稀疏数据,更容易出现震荡,adagrad能够很好的解决这种情况。

    RMSprop

    在adagrad的基础上,采用指数加权移动平均法,强调了近的历史数据的影响,忽略了远的历史数据的影响,这样下降时该快的时候就快,该慢的时候就慢。
    在这里插入图片描述

    Adam

    RMSprop和动量法的结合
    在这里插入图片描述

    Nadam

    AdaGrad 和Nesterov结合

    展开全文
  • 梯度下降法不熟悉的可以参考梯度下降法,理解梯度下降法是理解动量梯度下降法的前提,除此之外要搞懂动量梯度下降法需要知道原始方法在实际应用中的不足之处,动量梯度下降法怎样改善了原来方法的不足以及其具体的...
  • 从零开始的Nesterov动量梯度下降

    千次阅读 2021-03-19 17:16:14
    【翻译自 : Gradient Descent With ... 梯度下降是一种优化算法,遵循目标函数的负梯度以定位函数的最小值。 梯度下降的一个限制是,如果目标函数返回嘈杂的梯度,则它可能会卡在平坦的区域中或反弹。动量是...
  • 随机梯度下降动量法 Momentum

    千次阅读 2019-05-21 18:45:10
    转自:https://blog.csdn.net/BVL10101111/article/details/72615621 (下面选中的这句话很直观)
  • 简述动量Momentum梯度下降

    万次阅读 多人点赞 2017-09-12 13:53:17
    在普通的随机梯度下降和批梯度下降当中,参数的更新是按照如下公式进行的:W = W - αdW b = b - αdb其中α是学习率,dW、db是cost function对w和b的偏导数。 随机梯度下降和批梯度下降的区别只是输入的数据分别...
  • 动量梯度下降(Gradient descent with momentum)详解 关于动量梯度下降,其作用普通的梯度下降是差不多的。但是在普通的梯度下降中,如果遇到了比较复杂的情况,就会出现:如果学习率过大,摆动过大,误差较大;如果...
  • 主要介绍了Python语言描述随机梯度下降法,具有一定借鉴价值,需要的朋友可以参考下
  • 文章目录1 SGD实现2 小批量SGD3 动量Momentum 1 SGD实现   以以下式子为例: f(x)=ax+b(y−f(x))2=(y−(ax+b))2dyda=−2x(y−(ax+b))dydb=−2(y−(ax+b)) \begin{aligned} f(x) &= a x+b \\ (y-f(x))^{2} &...
  • 梯度下降、随机梯度下降、小批量梯度下降、动量梯度下降、Nesterov加速梯度下降法前言梯度下降法(Gradient Descent / GD)单变量线性回归模型(Univariate Linear Regression)批梯度下降法(Batch Gradient ...
  • 应该用梯度下降,随机梯度下降,还是Adam方法?这篇文章介绍了不同优化算法之间的主要区别,以及如何选择最佳的优化方法。优化算法的功能,是通过改善训练方式,来最小化(或最大化)损失函数E(x)。模型内部有些参数,...
  • 梯度下降和随机梯度下降的区别是,梯度下降在每次更新时,使用所有样本来计算,这样的实现在大型数据集上运行会非常慢,会被认为是浪费资源。SGD是训练深度神经网络时最重要的算法。mini-batch随机梯度下降是采样小...
  • 梯度下降算法是通过沿着目标函数J(θ)参数θ∈R的梯度(一阶导数)相反方向−∇θJ(θ)来不断更新模型参数来到达目标函数的极小值点(收敛),更新步长为η。有三种梯度下降算法框架,它们不同之处在于每次学习(更新模型...
  • 梯度下降算法代码及详细解释(非常易懂)Matlab代码,有详细图文解释,适合小白,全面介绍算法原理和公式推导
  • [机器学习] 梯度下降优化算法前言常见的梯度下降优化算法Gradient DescentStochastic Gradient Descent (SGD)SGD with momentumAdaptive Gradient (AdaGrad)RMSpropAdam什么是机器学习中最佳优化算法 前言 为什么...
  • matlab随机梯度下降

    2021-04-22 09:33:26
    %是否使用梯度下降法进行局部搜索的控制参数 IfLocalSearch=0; %...经过 10000 次训练后,traningdm 网络...Traningdm 是动量梯度下降算法,和 traningd......权系数调整 u(k) e(k) e(k 1) O1(3) u (k ) O2(3) e(k ) u...
  • 动量梯度下降法(gradient descent with momentum)

    万次阅读 多人点赞 2018-10-28 10:57:35
    梯度下降法不熟悉的可以参考梯度下降法,理解梯度下降法是理解动量梯度下降法的前提,除此之外要搞懂动量梯度下降法需要知道原始方法在实际应用中的不足之处,动量梯度下降法怎样改善了原来方法的不足以及其具体的...
  • 首先来看看梯度下降的一个直观的解释。比如我们在一座大山上的某处位置,由于我们不知道怎么下山,于是决定走一步算一步,也就是在每走到一个位置的时候,求解当前位置的梯度,沿着梯度的负方向,也就是当前最陡峭的...
  • 理解梯度下降算法中的动量 在深度学习优化算法中,常用...在理解动量之前,我们有必要先了解梯度下降算法随机梯度下降算法。我们先假设,优化的目标函数为: f(x⃗):ℜd→ℜwhere,x⃗=[x1,x2,...,xd]T \begin{matrix} f
  • 但对随机梯度下降法来说, 可怕的不是局部最优点, 而是山谷和鞍点两类地形。 山谷顾名思义就是狭长的山间小道, 左右两边是峭壁; 鞍点的形状像是一个马鞍, 一个方向上两头翘, 另一个方向上两头垂, 而中...
  • 随机梯度下降法,支持动量参数,支持学习衰减率,支持Nesterov动量 参数: lr:大或等于0的浮点数,学习率 momentum:大或等于0的浮点数,动量参数 decay:大或等于0的浮点数,每次更新后的学习率衰减值
  • 动量梯度下降(momentum)

    千次阅读 2020-08-15 12:01:56
    梯度下降法不熟悉的可以参考梯度下降法,理解梯度下降法是理解动量梯度下降法的前提,除此之外要搞懂动量梯度下降法需要知道原始方法在实际应用中的不足之处,动量梯度下降法怎样改善了原来方法的不足以及其具体的...
  • 随机梯度下降与梯度下降的区别?

    千次阅读 2019-08-18 17:54:19
    随机梯度下降与梯度下降之间有什么区别? 假设你已经懂了梯度下降的原理与公式。接下来我会举个例子来讲随机梯度下降与梯度下降的区别。 假如损失(误差)函数对参数w的导数是x(wx−label)x(wx - label)x(wx−label)...
  • 动量梯度下降法 Momentum

    千次阅读 2019-09-14 21:33:11
    动量梯度下降法是对梯度下降法的一种优化算法,该方法学习率可以选择更大的值,函数的收敛速度也更快。 梯度下降法就像下面这张图,通过不断的更新 w与b,从而让函数移动到红点,但是要到达最优解,需要我们不断的...
  • 采用分数阶动量的卷积神经网络随机梯度下降法.pdf
  • 凌云时刻 · 技术导读:这篇笔记主要介绍梯度下降法,梯度下降不是机器学习专属的算法,它是一种基于搜索的最优化方法,也就是通过不断的搜索然后找到损失函数的最小值。像上篇笔记中使用正规方程解...
  • 这三种算法都用于反向传播的优化损失函数算法。在每轮迭代中更新一次权重w,...1. 梯度下降算法: 主要优点:梯度更新准确 (1) 如果数据集比较小,完全可以采用全数据集(Full Batch Learning)的形式,采用全数据有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,347
精华内容 4,138
关键字:

动量随机梯度下降

友情链接: Picture.rar