2018-12-28 11:37:04 qq_33414271 阅读数 244

一、发展背景及基本框架

梯度下降是目前神经网络中使用最为广泛的优化算法之一。为了弥补朴素梯度下降的种种缺陷,研究者们发明了一系列变种算法,从最初的 SGD (随机梯度下降) 逐步演进到 NAdam。然而,许多学术界最为前沿的文章中,都并没有一味使用 Adam/NAdam 等公认“好用”的自适应算法,很多甚至还选择了最为初级的 SGD 或者 SGD with Momentum 等。

深度学习优化算法的发展历程:
SGD -> SGDM -> NAG ->AdaGrad -> AdaDelta -> Adam -> Nadam

最基本的框架——梯度下降法(GD)

梯度下降法(GD:gradient descent )或最速下降法(SD:steepest descent )是求解无约束优化问题最常用的方法,实现简单。

梯度下降是指,在给定待优化的模型参数 θRd\theta \in \mathbb{R}^d和目标函数 J(θ)J(\theta) 后,算法通过沿梯度 θJ(θ)\nabla_\theta J(\theta) 的相反方向更新 θ\theta 来最小化J(θ)J(\theta) 。学习率 η\eta 决定了每一时刻的更新步长。对于每一个时刻 tt ,我们可以用下述步骤描述梯度下降的流程:

(1) 计算目标函数关于参数的梯度
gt=θJ(θ)g_t = \nabla_\theta J(\theta)
(2) 根据历史梯度计算一阶和二阶动量
mt=ϕ(g1,g2, ,gt)m_t = \phi(g_1, g_2, \cdots, g_t)
vt=ψ(g1,g2, ,gt)v_t = \psi(g_1, g_2, \cdots, g_t)
(3) 更新模型参数
θt+1=θt1vt+ϵmt\theta_{t+1} = \theta_t - \frac{1}{\sqrt{v_t + \epsilon}} m_t
其中, ϵ\epsilon 为平滑项,防止分母为零,通常取 1e-8。

二、GD算法体系

先上图做直观对比:
在这里插入图片描述
“长谷 (Long Valley)”点——没有基于梯度信息缩放的算法在这里很难打破对称性——SGD在哪里都找不到, Nesterov Accelerated Gradient(NAG) / Momentum 在优化方向上建立速度之前会出现振荡。(此时自适应算法会更好)

在这里插入图片描述
由于大的初始梯度,基于速度的技术(SGD-M ,NAG)被发射出来并在周围反弹。其中 Adagrad、Adadelta、RMSprop 从最开始就找到了正确的方向并快速收敛;SGD 找到了正确方向但收敛速度很慢;SGD-M 和 NAG 最初都偏离了航道,但也能最终纠正到正确方向,SGD-M 偏离的惯性比 NAG 更大。

在这里插入图片描述
鞍点(Saddle Point)附近的行为:
NAG /Momentum探索周围,几乎走了不同的路径。
Adadelta/Adagrad/RMSProp像加速SGD一样运行。

2.1-朴素 SGD (Stochastic Gradient Descent)

最为简单,没有动量的概念
在这里插入图片描述
这时,更新步骤就是最简单的θi+1=θtηgt\theta_{i+1}= \theta_t - \eta g_t

SGD 的缺点在于收敛速度慢,可能在长谷处震荡。并且,如何合理的选择学习率是 SGD 的一大难点。

2.2-SGD with Momentum

为了抑制SGD的震荡,SGDM认为梯度下降过程可以加入惯性。下坡的时候,如果发现是陡坡,那就利用惯性跑的快一些。SGDM全称是SGD with momentum,在SGD基础上引入了一阶动量:
mt=γmt1+ηgtm_t = \gamma m_{t-1} + \eta g_t

SGD-M 在原步长之上,增加了与上一时刻步长相关的 γmt1\gamma m_{t-1}γ\gamma 通常取 0.9 左右。这意味着参数更新方向不仅由当前的梯度决定,也与此前累积的下降方向有关。
这使得参数中那些梯度方向变化不大的维度可以加速更新,并减少梯度方向变化较大的维度上的更新幅度。由此产生了加速收敛和减小震荡的效果。
在这里插入图片描述
从形式上看,动量算法(红色)引入了变量v 充当速度角色——它代表参数在参数空间移动的方向和速率。速度被设为负梯度的指数衰减平均。

2.3-Nesterov Accelerated Gradient

更进一步的,人们希望下降的过程更加智能:算法能够在目标函数有增高趋势之前,减缓更新速率。

NAG 即是为此而设计的,其在 SGD-M 的基础上进一步改进了步骤 1 中的梯度计算公式:
gt=θJ(θγmt1)g_t = \nabla_\theta J(\theta - \gamma m_{t-1})
在这里插入图片描述
SGD-M 的步长计算了当前梯度(短蓝向量)和动量项 (长蓝向量)。然而,既然已经利用了动量项来更新 ,那不妨先计算出下一时刻 θ\theta 的近似位置 (棕向量),并根据该未来位置计算梯度(红向量),然后使用和 SGD-M 中相同的方式计算步长(绿向量)。这种计算梯度的方式可以使算法更好的「预测未来」,提前调整更新速率。

2.4-Adagrad(自适应更新学习率)

Ada为Adaptive,自适应算法。

SGD、SGD-M 和 NAG 均是以相同的学习率去更新 θ\theta 的各个分量。而深度学习模型中往往涉及大量的参数,不同参数的更新频率往往有所区别。

对于更新不频繁的参数(典型例子:更新 word embedding 中的低频词),我们希望单次步长更大,多学习一些知识;对于更新频繁的参数,我们则希望步长较小,使得学习到的参数更稳定,不至于被单个样本影响太多。

Adagrad算法即可达到此效果。其引入了二阶动量:

Adaptive Subgradient Methods for Online Learning and Stochastic Optimization

vt=diag(i=1tgi,12,i=1tgi,22, ,i=1tgi,d2)v_t = \text{diag}(\sum_{i=1}^t g_{i,1}^2, \sum_{i=1}^t g_{i,2}^2, \cdots, \sum_{i=1}^t g_{i,d}^2)

其中, vtRd×dv_t \in \mathbb{R}^{d\times d} 是对角矩阵,其元素 vt,iiv_{t, ii} 为参数第 i 维从初始时刻到时刻 t 的梯度平方和。

此时,可以这样理解:学习率等效为 η/vt+ϵ\eta / \sqrt{v_t + \epsilon} 。对于此前频繁更新过的参数,其二阶动量的对应分量较大,学习率就较小。这一方法在稀疏数据的场景下表现很好。

2.5-RMSprop

在 Adagrad 中, vtv_t是单调递增的,使得学习率逐渐递减至 0,可能导致训练过程提前结束。为了改进这一缺点,可以考虑在计算二阶动量时不累积全部历史梯度,而只关注最近某一时间窗口内的下降梯度。根据此思想有了 RMSprop

gtgtg_t \odot g_tgt2g_t^2 ,有
vt=γvt1+(1γ)diag(gt2)v_t = \gamma v_{t-1} + (1-\gamma) \cdot \text{diag}(g_t^2)

其二阶动量采用指数移动平均公式计算,这样即可避免二阶动量持续累积的问题。和 SGD-M 中的参数类似,\gamma 通常取 0.9 左右。

CSC321 Neural Networks for Machine Learning - Lecture 6a

2.6-Adam

Adam可以认为是 RMSprop 和 Momentum 的结合。和 RMSprop 对二阶动量使用指数移动平均类似,Adam 中对一阶动量也是用指数移动平均计算。

Adam: A Method for Stochastic Optimization

mt=η[β1mt1+(1β1)gt]m_t = \eta[ \beta_1 m_{t-1} + (1 - \beta_1)g_t ]
vt=β2vt1+(1β2)diag(gt2)v_t = \beta_2 v_{t-1} + (1-\beta_2) \cdot \text{diag}(g_t^2)
其中,初值
m0=0m_0 = 0
v0=0v_0 = 0
注意到,在迭代初始阶段,mtm_tvtv_t 有一个向初值的偏移(过多的偏向了 0)。因此,可以对一阶和二阶动量做偏置校正 (bias correction),
m^t=mt1β1t\hat{m}_t = \frac{m_t}{1-\beta_1^t}
v^t=vt1β2t\hat{v}_t = \frac{v_t}{1-\beta_2^t}
再进行更新,
θt+1=θt1v^t+ϵm^t\theta_{t+1} = \theta_t - \frac{1}{\sqrt{\hat{v}_t} + \epsilon } \hat{m}_t
可以保证迭代较为平稳。

三、小结

在这里插入图片描述
虽然这些算法在使用的时候或许只是一句代码,但了解其发展历程和基本特点是很有必要的。

参考:
[1]从 SGD 到 Adam —— 深度学习优化算法概览(一) - 骆梁宸的文章 - 知乎
https://zhuanlan.zhihu.com/p/32626442
[2]一个框架看懂优化算法之异同 SGD/AdaGrad/Adam - Juliuszh的文章 - 知乎
https://zhuanlan.zhihu.com/p/32230623
[3]https://blog.csdn.net/u012223913/article/details/78432412
[4]Visualizing Optimization Algos

2018-08-04 19:00:54 ywx1832990 阅读数 853

在⼀个深度学习问题中,通常我们会预先定义⼀个损失函数。有了损失函数,就可以使⽤优化算法试图使其最小化。在优化中,这样的损失函数通常被称作优化问题的⽬标函数(objectivefunction)。依据惯例,优化算法通常只考虑最小化⽬标函数。因为任何最⼤化问题都可以很容易地转化为最小化问题:只需把⽬标函数前⾯的正号或负号取相反。

在深度学习问题中,由于优化算法的⽬标函数通常是⼀个基于训练数据集的损失函数,优化的⽬标在于降低训练误差。而深度学习的实际⽬标在于降低泛化误差。为了降低泛化误差,除了使⽤优化算法降低训练误差以外,还需要注意应对过拟合。

绝⼤多数深度学习中的⽬标函数都很复杂,因此,优化在深度学习中有很多挑战,其中最主要的两个:局部最小值鞍点

1 局部最小值

对于⽬标函数 f(x),如果 f(x) 在 x 上的值⽐在 x 邻近的其他点的值更小,那么 f(x) 可能是⼀个局部最小值(local minimum)。如果 f(x) 在 x 上的值是⽬标函数在整个定义域上的最小值,那么 f(x) 是全局最小值(global minimum)。例如:f(x) = x · cos(πx)

深度学习模型的⽬标函数可能有若⼲局部最优值。当⼀个优化问题的数值解在局部最优解附近时,由于⽬标函数有关解的梯度接近或变成零,最终迭代求得的数值解可能只令⽬标函数局部最小化而⾮全局最小化。

2 鞍点

梯度接近或变成零可能是由于当前解在局部最优解附近所造成的。事实上,另⼀种可能性是当前解在鞍点(saddle point)附近。例如:f(x) = x **3

深度学习中,虽然找到⽬标函数的全局最优解很难,但这并⾮必要。接下来我们将逐⼀介绍深度学习中常⽤的优化算法。

3 梯度下降和随机梯度下降

3.1 梯度下降

以⼀维梯度下降为例,解释梯度下降算法可以降低⽬标函数值的原因。⼀维梯度是⼀个标量,也称导数。假设函数 f : R → R 的输⼊和输出都是标量。根据泰勒展开公式,可得:

                                                                       f(X + \epsilon )\approx f(X) + f{}'(X)\epsilon

假设 η 是⼀个常数,将 ϵ 替换为 −ηf ′ (x) 后,则有:

                                                                  f(X-\eta f(X)) \approx f(X) - \eta f{}'(X)^{2}

即如果当前导数 f ′ (x) != 0,按照 x := x − ηf ′ (x) 更新 x 可能降低 f(x) 的值。

梯度下降算法中的 η(取正数)叫做学习率或步长。需要注意的是,学习率过⼤可能会造成 x迈过(overshoot)最优解,甚⾄不断发散而⽆法收敛;如果学习率过小,优化算法收敛速度会过慢。如下图所示:

现考虑更⼴义的情况:⽬标函数的输⼊为向量,输出为标量,即多维梯度下降。

假设⽬标函数 f : R d → R 的输⼊是⼀个多维向量 x = [x 1 ,x 2 ,...,x d ] ⊤ 。⽬标函数 f(x) 有关 x 的梯度是⼀个由偏导数组成的向量:

                                              \bigtriangledown _{x}f(X) = [\frac{\partial f(X)}{\partial X_{1}} , \frac{\partial f(X)}{\partial X_{2}} , ......, \frac{\partial f(X)}{\partial X_{d}}]^{T} = \bigtriangledown f(X)

梯度中每个偏导数元素 ∂f(x)/∂x i 代表着 f 在 x有关输⼊ x i 的变化率。为了测量 f 沿着单位向量 u ⽅向上的变化率,在多元微积分中,我们定义f 在 x 上沿着 u ⽅向的⽅向导数为:

                                                               D_{u}f(X) = \underset{h\rightarrow 0}{lim}\frac{f(X+hu)-f(X)}{h}

由链式法则,该⽅向导数可以改写为:

                                                                          D_{u}f(X) = \bigtriangledown f(X)\cdot u

⽅向导数 Du f(x) 给出了 f 在 x 上沿着所有可能⽅向的变化率。为了最小化 f,我们希望找到 f能被降低最快的⽅向。因此,我们可以通过 u 来最小化⽅向导数 Du f(x)。

由于 Du f(x) = ∥∇f(x)∥·∥u∥·cos(θ) = ∥∇f(x)∥·cos(θ),其中 θ 为 ∇f(x) 和 u 之间的夹⻆,当θ = π,cos(θ) 取得最小值-1。因此,当 u 在梯度⽅向 ∇f(x) 的相反⽅向时,⽅向导数 Du f(x) 被最小化。所以,我们可能通过下⾯的 梯度下降算法来不断降低⽬标函数 f 的值:

                                                                        X := X-\eta \bigtriangledown f(X)

3.2 随机梯度下降

当训练数据集很⼤时,梯度下降算法可能会难以使⽤。为了解决这一问题,考虑⽬标函数:

                                                                      f(X) = \frac{1}{n}\sum_{i=1}^{n}f_{i}(X)

其中 fi (x) 是有关索引为 i 的训练数据点的损失函数。需要强调的是,梯度下降每次迭代的计算开销随着 n 线性增长。因此,当 n 很⼤时,每次迭代的计算开销很⾼。

于是随机梯度下降算法便被需要。在每次迭代时,该算法随机均匀采样 i 并计算 ∇fi (x)。事实上,随机梯度 ∇fi (x) 是对梯度 ∇f(x) 的⽆偏估计:

                                                      E_{i}\bigtriangledown f_{i}(X)=\frac{1}{n}\sum_{i=1}^{n}\bigtriangledown f_{i}(X)=\bigtriangledown f(X)

3.3 小批随机梯度下降

⼴义上,每次迭代可以随机均匀采样⼀个由训练数据点索引所组成的小批量 B。类似地,我们可以使⽤:

                                                                 \bigtriangledown f_{\ss }(X)=\frac{1}{|\ss |}\sum_{i\in \ss }\bigtriangledown f_{i}(X)

来更新 x:

                                                                   X := X-\eta \bigtriangledown f_{\ss }(X)

其中 |B| 代表批量中索引数量,η(取正数)称作学习率或步长。同样,小批量随机梯度 ∇fB (x) 也是对梯度 ∇f(x) 的⽆偏估计:

                                                                E_{\ss }\bigtriangledown f_{\ss }(X)=\bigtriangledown f(X)

该算法称小批量随机梯度下降。该算法每次迭代的计算开销为 O(|B|)。因此,当批量较小时,每次迭代的计算开销也较小。

4 动量法

梯度下降的问题:考虑⼀个输⼊为⼆维向量 x = [x 1 ,x 2 ] ⊤ ,输出为标量的⽬标函数 f : R 2 → R。下⾯为该函数的等⾼线⽰意图(每条等⾼线表⽰相同函数值的点:越靠近中间函数值越小)。

上图中,红⾊三⻆形代表参数 x 的初始值。带箭头的线段表⽰每次迭代时参数的更新。由于⽬标函数在竖直⽅向(x 2 轴⽅向)上⽐在⽔平⽅向(x 1 轴⽅向)弯曲得更厉害,梯度下降迭代参数时会使参数在竖直⽅向⽐在⽔平⽅向移动更猛烈。因此,我们需要⼀个较小的学习率从而避免参数在竖直⽅向上 overshoot。这就造成了上图中参数向最优解移动速度的缓慢。

动量法的提出是为了应对梯度下降的上述问题。Momentum的想法很简单,就是多更新一部分上一次迭代的更新量,来平滑这一次迭代的梯度。从物理的角度上解释,就像一个小球滚落的时候会受到自身历史动量的影响,所以才叫动量(Momentum)算法。这样做直接的效果就是使得梯度下降的的时候转弯掉头的幅度不那么大了,能够更加平稳、快速地冲向局部最小点。

⼴义上,以小批量随机梯度下降为例(当批量⼤小等于训练集⼤小时,该算法即为梯度下降;批量⼤小为 1 即为随机梯度下降),对小批量随机梯度算法做如下修改:

                                                                               V:=\gamma V+\eta \bigtriangledown f_{\ss }(X)

                                                                               X:=X-V

其中 v 是当前速度,γ 是动量参数。

当前速度 v 的更新可以理解为对 [η/(1 − γ)]*∇fB (x) 做指数加权移动平均。因此,动量法的每次迭代中,参数在各个⽅向上移动幅度不仅取决当前梯度,还取决过去各个梯度在各个⽅向上是否⼀致。当过去的所有梯度都在同⼀⽅向,例如都是⽔平向右,那么参数在⽔平向右的移动幅度最⼤。如果过去的梯度中在竖直⽅向上时上时下,那么参数在竖直⽅向的移动幅度将变小。这样,我们就可以使⽤较⼤的学习率,从而收敛更快。如下图:

为了更好的理解动量参数 γ,让我们考虑⼀个简单的问题:每次迭代的小批量随机梯度 ∇fB (x) = g。由于所有小批量随机梯度都在同⼀⽅向,动量法在该⽅向使参数移动加速:

                                                                  V_{1}:=\eta\cdot g

                                                                  V_{2}:=\gamma V_{1}+\eta \cdot g=\eta g(\gamma +1)

                                                                  V_{3}:=\gamma V_{2}+\eta \cdot g=\eta g(\gamma ^{2}+\gamma +1)

                                                                  ......

                                                                 V_{n}:=\gamma V_{n-1}+\eta \cdot g=\eta g(\gamma ^{n}+......+\gamma ^{2}+\gamma +1)

                                                                 V_{inf}=\underset{n\rightarrow \infty }{lim}\eta g\frac{1-\gamma ^{n}}{1-\gamma }=\frac{\eta g}{1-\gamma }

当 γ = 0.99, 最终的速度将是学习率乘以相应小批量随机梯度 ηg 的 100 倍⼤。

动量法可以提升随机梯度下降,对于某些问题可以选⽤较⼤学习率从而加快收敛。

5 Adagrad算法

⽆论是梯度下降、随机梯度下降、小批量随机梯度下降还是使⽤动量法,模型参数中的每⼀个元素在相同时刻都使⽤同⼀个学习率来⾃我迭代。当⼀个模型的损失函数为 L,参数为⼀个多维向量 [x1 ,x2 ] ⊤ 时,该向量中每⼀个元素在更新时都使⽤相同的学习率,例如在学习率为 η 的梯度下降中:

                                                                            x_{1}:=x_{1}-\eta \frac{\partial L}{\partial x_{1}}

                                                                            x_{2}:=x_{2}-\eta \frac{\partial L}{\partial x_{2}}

其中元素 x 1 和 x 2 都使⽤相同的学习率 η 来⾃我迭代。如果让 x 1 和 x 2 使⽤不同的学习率⾃我迭代呢?
Adagrad 就是⼀个在迭代过程中不断⾃我调整学习率,并让模型参数中每个元素都使⽤不同学习率的优化算法。

假设x = [4,9] ⊤ ,按元素操作后:

   • 按元素相加:x + 1 = [5,10] ⊤
   • 按元素相乘:x ⊙ x = [16,81] ⊤
   • 按元素相除:72/x = [18,8] ⊤
   • 按元素开⽅: √ x = [2,3] ⊤

Adagrad其实就是对学习率加上了一个正则约束regularizer:

                                                                      \frac{\eta }{\sqrt{s+\epsilon }}=\frac{\eta }{\sqrt{\sum_{r=1}^{t}g_{r}^{2}+\epsilon }}

  • 在前期g_{r}比较小的时候,regularizer较大,能够放大梯度;
  • 在前期g_{r}比较大的时候,regularizer较小,能够约束梯度;
  • 适合处理稀疏梯度;

Adagrad 的算法会使⽤⼀个梯度按元素平⽅的累加变量 s,并将其中每个元素初始化为 0。在每次迭代中,⾸先计算小批量梯度 g,然后将该梯度按元素平⽅后累加到变量 s:

                                                                             s:=s+g\odot g

然后我们将模型参数中每个元素的学习率通过按元素操作重新调整⼀下:

                                                                            g{}':=\frac{\eta }{\sqrt{s+\epsilon }}\odot g

                                                                               X:=X-g{}'

其中 η 是初始学习率,ϵ 是为了维持数值稳定性而添加的常数,例如 10 **(−7) 。请注意其中按元素开⽅、除法和乘法的操作。这些按元素操作使得模型参数中每个元素都分别拥有⾃⼰的学习率。由于梯度按元素平⽅的累加变量 s 出现在分⺟,Adagrad 的核⼼思想是:如果模型损失函数有关⼀个参数元素的偏导数⼀直都较⼤,那么就让它的学习率下降快⼀点;反之,如果模型损失函数有关⼀个参数元素的偏导数⼀直都较小,那么就让它的学习率下降慢⼀点。然而,由于 s ⼀直在累加按元素平⽅的梯度,每个元素的学习率在迭代过程中⼀直在降低或不变。所以在有些问题下,当学习率在迭代早期降得较快时且当前解依然不理想时,Adagrad 在迭代后期可能较难找到⼀个有⽤的解。

 Adagrad 是⼀个在迭代过程中不断⾃我调整学习率,并让模型参数中每个元素都使⽤不同学习率的优化算法。

缺点:

  • 任然还是会依赖初始的人工设置的学习率;
  • \eta设置过大的话,会使regularizer过于敏感,对梯度的调节太大;
  • 中后期,分母上的梯度平方的累加会越来越大,会使得gradient\rightarrow 0,使得训练提前结束;

6 RMSProp算法

在Adagrad⾥,由于学习率分⺟上的变量 s ⼀直在累加按元素平⽅的梯度,每个元素的学习率在迭代过程中⼀直在降低或不变。所以在有些问题下,当学习率在迭代早期降得较快时且当前解依然不理想时,Adagrad 在迭代后期可能较难找到⼀个有⽤的解。为了应对这⼀问题,RMSProp 算法对 Adagrad 做了⼀点小小的修改。

RMSProp 算法会使⽤⼀个梯度按元素平⽅的指数加权移动平均变量 s,并将其中每个元素初始化为 0。在每次迭代中,⾸先计算小批量梯度 g,然后对该梯度按元素平⽅后做指数加权移动平均并计算 s:

                                                                                 s:=\gamma s+(1-\gamma )g\odot g

然后我们将模型参数中每个元素的学习率通过按元素操作重新调整⼀下:

                                                                                      g{}':=\frac{\eta }{\sqrt{s+\epsilon }}\odot g

                                                                                          X:=X-g{}'

其中 η 是初始学习率,ϵ 是为了维持数值稳定性而添加的常数,例如 10 **(−8 )。和 Adagrad ⼀样,模型参数中每个元素都分别拥有⾃⼰的学习率。

需要强调的是:RMSProp 只在 Adagrad 的基础上修改了变量 s 的更新⽅法——将累加改成了指数加权移动平均。因此,每个元素的学习率在迭代过程中既可能降低⼜可能升⾼。

  •  RMSProp 和 Adagrad 的不同在于,RMSProp 使⽤了梯度按元素平⽅的指数加权移动平均变量来调整学习率。
  • 通过调整指数加权移动平均中 γ 参数的值可以控制学习率的变化。
  • 依然依赖全局学习率;
  • RMSProp其实是Adagrad的发展而来,更一般化;
  • 适合处理非平稳目标,对RNN效果很好;

7 Adadelta算法

Adadelta是Adagrad的扩展,最初方案依然是对学习率进行自适应约束,但是进行了计算上的简化。Adagrad会累加之前所有梯度的平方,而Adadelta只是累加大小的项,并且也不直接存储这些项,仅仅只是近似的计算对应的平均值。

在Adagrad⾥,由于学习率分⺟上的变量 s ⼀直在累加按元素平⽅的梯度,每个元素的学习率在迭代过程中⼀直在降低或不变。所以在有些问题下,当学习率在迭代早期降得较快时且当前解依然不理想时,Adagrad 在迭代后期可能较难找到⼀个有⽤的解。在RMSProp中介绍了应对该问题的⼀种⽅法:对梯度按元素平⽅使⽤指数加权移动平均而不是累加。

事实上,Adadelta 也是⼀种应对这个问题的⽅法。并且它没有学习率参数。

Adadelta 算法和 RMSProp ⼀样,使⽤了⼀个梯度按元素平⽅的指数加权移动平均变量 s,并将其中每个元素初始化为 0。在每次迭代中,⾸先计算小批量梯度 g,然后对该梯度按元素平⽅后做指数加权移动平均并计算 s:

                                                                              s:=\rho s+(1-\rho )g\odot g

然后计算当前需要更新的参数的变化量:

                                                                                g{}'=\frac{\sqrt{\bigtriangleup X+\epsilon }}{\sqrt{s+\epsilon }}\odot g

                                                                                      X:=X-g{}'

其中 ϵ 是为了维持数值稳定性而添加的常数,例如 10 **(−5) 。和 Adagrad ⼀样,模型参数中每个元素都分别拥有⾃⼰的学习率。其中 ∆x 初始化为零张量,并做如下 g ′ 按元素平⽅的指数加权移动平均:

                                                                          \bigtriangleup X:=\rho \bigtriangleup X+(1-\rho )g{}'\odot g

  • Adadelta不需要手动调整学习速率
  • 对超参数不敏感
  • 将对每个维度的学习率单独分离出来
  • 最小化梯度下降时的计算量
  • 对大梯度,噪声,不同架构具有很好的健壮性
  • 对本地或分布式环境都可很好的应用
  • 在训练初期,加速效果不错,很快;在训练后期,反复在局部最小值附近抖动

8 Adam算法

本质上是带有动量项的RMSprop,它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。Adam的优点主要在于经过偏置校正后,每一次迭代学习率都有个确定范围,使得参数比较平稳。

Adam 是动量法和RMSProp的组合优化算法。Adam 算法会使⽤⼀个动量变量 v 和⼀个 RMSProp 中梯度按元素平⽅的指数加权移动平均变量s,并将它们中每个元素初始化为 0。在每次迭代中,⾸先计算小批量梯度 g,并递增迭代次数:

                                                                                        t:=t+1

然后对梯度做指数加权移动平均并计算动量变量 v:

                                                                                 V:=\beta _{1}V+(1-\beta_{1} )g

该梯度按元素平⽅后做指数加权移动平均并计算 s:

                                                                                s:=\beta _{2}s+(1-\beta_{2} )g\odot g

在 Adam 算法⾥,为了减轻 v 和 s 被初始化为 0 在迭代初期对计算指数加权移动平均的影响,做如下的偏差修正:

                                                                                      \hat{V}:=\frac{V}{1-\beta _{1}^{t}}

                                                                                       \hat{s}:=\frac{s}{1-\beta _{2}^{t}}

可以看到,当 0 ≤ β1 ,β2 < 1 时(算法作者建议分别设为 0.9 和 0.999),当迭代后期 t 较⼤时,偏差修正⼏乎就不再有影响。使⽤以上偏差修正后的动量变量和 RMSProp 中梯度按元素平⽅的指数加权移动平均变量,将模型参数中每个元素的学习率通过按元素操作重新调整⼀下:

                                                                                     g{}'=\frac{\eta \hat{V}}{\sqrt{\hat{s}+\epsilon }}

                                                                                    X:=X-g{}'

其中 η 是初始学习率,ϵ 是为了维持数值稳定性而添加的常数,例如 10 **(−8) 。和 Adagrad ⼀样,模型参数中每个元素都分别拥有⾃⼰的学习率。

其中 V、s分别是对梯度的一阶矩和二阶矩的估计,可以看做是对期望E|g|和E|g**2|的估计。V^、s^是对V,s的校正,可以近似为对期望的无偏估计。可以看出直接对梯度的矩估计对内存没有额外的要求,而且可以根据梯度进行动态调整,g‘中的η 的系数对学习率η 形成一个动态约束,而且有明确的范围。

特点:

  • 结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点;
  • 对内存需求较小;
  • 为不同的参数计算不同的自适应学习率;
  • 也适用于大多非凸优化;
  • 适用于大数据集和高维空间;

Adam建议的参数设定:

TensorFlow:learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08.

Keras:lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0

Blocks:learning_rate=0.002, beta1=0.9, beta2=0.999, epsilon=1e-08, decay_factor=1

Lasagne:learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08

Caffe:learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08

MxNet:learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8

Torch:learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8

 

2017-04-05 18:05:36 Gavin__Zhou 阅读数 1659

一般来说,深度学习通过仔细的设计Objective function和constraints来确保优化问题是convex的,从而避开一下通用优化算法的难题。
优化(optimization)说的有点大,因为存在一阶优化(first-order)和二阶(second-order)优化算法。我们常用的优化算法,比如Adam,SGD等其实都是一阶优化算法(基于gradient),这篇写的也是一阶优化算法.

现今的一阶优化算法都是基于batch或者是minibatch的,所以从minibatch开始说起吧


batch and minibatch

假设做最大似然估计,需要优化下面的式子:

等价于需要在经验分布上最大化期望:

优化上式自然想到梯度:

求这个期望需要计算每个example的梯度,对于大数据集(比如100W)来说计算成本过高,一个常用的解决方法就是:random sampling

In practice, we can compute these expectations by randomly sampling a small number of examples from the dataset, then taking the average over only those examples.

这样做就是使用近似的梯度估计来代替精确的梯度,毫无疑问计算代价很小,计算的代价是不随training set的增加而增加的.

batch gradient descent

Optimization algorithms that use the entire training set are called batch or deterministic gradient methods, because they process all of the training examples simultaneously in a large batch.

使用所有的训练数据来计算梯度

SGD(stochastic gradient descent)

Optimization algorithms that use only a single example at a time are sometimes called stochastic or sometimes online methods.

minibatch SGD

SGD和batch GD是两个极端,一个每次只使用一个训练数据来计算梯度,一个是使用所有的训练数据;batch GD计算成本太高,SGD太具有随机性,所以需要综合下。

using more than one but less than all of the training examples. These were traditionally called minibatch or minibatch stochastic methods and it is now common to simply call them stochastic methods.

重要的一点是:选择minibatch的数据时一定要随机

It is also crucial that the minibatches be selected randomly. Computing an unbiased estimate of the expected gradient from a set of samples requires that those samples be independent. We also wish for two subsequent gradient estimates to be independent from each other, so two subsequent minibatches of examples should also be independent from each other.

这里只是为了区分batch和minibatch的概念,现在所说的stochastic其实都是minibatch的.

SGD

SGD和它的变种是最常用的一阶优化算法,具体描述:

SGD

momentum

SGD的问题就是它可能会很慢,所以使用momentum来加速学习过程.

The method of momentum (Polyak, 1964) is designed to accelerate learning, especially in the face of high curvature, small but consistent gradients, or noisy gradients.

momentum的原理:

The momentum algorithm accumulates an exponentially decaying moving average of past gradients and continues to move in their direction.

引入一个参数α ∈ [0 ,1),作用是:

determines how quickly the contributions of previous gradients exponentially decay.

更新公式:

其中L是损失函数,v代表速度
使用了momentum之前,step_size = ||g||*lr(梯度乘以学习率),使用了momentum之后的step_size,取决于两个因素:

  • how large a sequence of gradients are.
  • how aligned a sequence of gradients are.

这个对齐(align)怎么理解,可以放到物理上想,当所有的物体的运动方向是一致的时候,这个整体的动量是最大的.

step_size_with_momentum=lr/(1-α)*||g||,通常典型的α值是0.9

CS231n上有比较形象的解释: 地址在这
中文翻译过来就是:

损失值可能理解为山峰的高度, 用随机数字初始化参数等同于在某个位置给质点设定初始速度为0. 这样最优化过程可以看做是模拟参数向量(即质点)在地形上滚动的过程, 质点所受的力就是损失函数的负梯度. 在普通的更新(比如SGD)中,梯度直接影响位置,momentum上是梯度影响速度,速度影响位置.

SGD with momentum

Nesterov momentum

跟momentum非常像,只是计算梯度的位置(x+a*v)不一样,所以可以把nesterov momentum看成是对标准的momentum的一个correction factor.

对于上式更新来说:theta <- theta + v == theta + alpha * v -step_size
此时的theta+alpha*v看做是未来的近似位置,所以算梯度时我们直接在未来的位置(前向位置)处计算就可以了. 所以Nesterov的核心就是在前向位置而不是原始的位置计算梯度.

更新公式:

直观上的理解就是:

Nesterov

Nesterov直接在前向位置(绿色箭头指向的位置)处更新梯度.

SGD with nesterov momentum

AdaGrad

是个学习率自适应的优化算法

individually adapts the learning rates of all model parameters by scaling them inversely proportional to the square root of the sum of all of their historical squared values.

对loss有很大贡献的parameter的学习率会下降的比较快:

The parameters with the largest partial derivative of the loss have a correspondingly rapid decrease in their learning rate, while parameters with small partial derivatives have a relatively small decrease in their learning rate.

经验表明:

the accumulation of squared gradients from the beginning of training can result in a premature and excessive decrease in the effective learning rate.

所以其实AdaGrad使用的也不是很多

RMSprop

RMSProp是从AdaGrad上修改来的,也是个自适应的算法,就是把gradient accumulation换成exponentially weighted moving average.

两者之间的区别:

  1. AdaGrad shrinks the learning rate according to the entire history of the squared gradient and may have made the learning rate too small before arriving at such a convex structure.
  2. RMSProp uses an exponentially decaying average to discard history from the extreme past so that it can converge rapidly after finding a convex bowl.

RMSProp with nesterov momentum

可以将nesterov momentum和RMSProp结合:

Adam

同样的也是个自适应学习率的优化算法,基本和SGD各占半边天.
可以把Adam看成是RMsProp+momentum的变体(存在几个主要的区别)
区别在于:

  1. First, in Adam, momentum is incorporated directly as an estimate of the first order moment (with exponential weighting) of the gradient.
  2. Second, Adam includes bias corrections to the estimates of both the first-order moments (the momentum term) and the (uncentered) second-order moments to account for their initialization at the origin.

算法如下所示:

总结

  1. 优化算法有一阶和二阶算法
  2. 常见优化算法的几乎都是一阶算法比如SGD ,Adam, AdaGrad, RMSProp等
  3. 二阶算法由于计算的代价等问题不常用,比如牛顿法, BFGS, L-BFGS等
  4. 最常用的一阶优化算法是SGD和Adam
2019-05-17 12:07:02 weixin_37142859 阅读数 78

深度学习优化算法

参考资料

1梯度下降算法的三个变种

根据计算一次梯度更新所使用的数据量大小,梯度下降算法共分为三种:

  • Batch gradient descent;(整个数据集)
  • Stochastic gradient descent;(一个数据样本)
  • Mini-batch gradient descent;(几个样本)

Batch gradient descent

Batch gradient descent的梯度更新公式为:
θ=θηθJ(θ)\theta=\theta-\eta \cdot \nabla_{\theta} J(\theta)

(打公式我有一个独特的窍门,嘻嘻)
式中θ\theta要更新的参数,η\eta为学习率,θJ(θ)\nabla_{\theta} J(\theta)是在整个数据集上损失的梯度。
优点:

  • 能保证模型最后收敛于全局最小点(若损失为凸)或局部最小点(损失函数非凸)

缺点:

  • 每更新一次参数需要计算出整个数据集每一个样本的推断结果并计算损失,计算量大,内存占用大
  • 权重更新缓慢
  • 无法在线学习

Stochastic gradient descent(SGD)

Stochastic gradient descent每次计算损失的梯度时,仅使用一个样本,公式如下:
θ=θηθJ(θ;x(i);y(i))\theta=\theta-\eta \cdot \nabla_{\theta} J\left(\theta ; x^{(i)} ; y^{(i)}\right)
优点

  • 考虑一种计算情况,假设数据集中每个样本都一样,Batch gradient decent用所有的数据样本来计算损失,存在严重的计算冗余,其实只要计算一个样本即可。尽管这种极端的情况不会出现,但在同一个数据集中,数据必然存在相似性,SGD相比于Batch gradient decent能减少很多计算冗余。
  • 研究表明,当学习率较小时,SGD和BGD有相同的收敛点
  • 在线学习

缺点

  • SGD由于其频繁的权重更新,会导致损失在下降过程中出现较大的波动。但是波动可能使损失函数跳出局部最小值,进入一个小的收敛点。

Mini-batch gradient descent

Mini-batch gradient descent则是使用数据集中的几个样本计算损失的梯度。计算公式如下:
θ=θηθJ(θ;x(i:i+n);y(i:i+n))\theta=\theta-\eta \cdot \nabla_{\theta} J\left(\theta ; x^{(i : i+n)} ; y^{(i : i+n)}\right)
优点

  • 减小了权重更新的方差,使得损失收敛于一个更稳定的点
  • mini-batch的使用使得我们最大化利用GPU的并行计算能力

2 梯度下降算法的痛点

  • 学习率大小选择困难。太小导致训练缓慢,太大则容易导致难以收敛,在(局部)最小点附近波动
  • 算法中所有的参数都使用相同的学习率进行更新,但实际上对于不同的参数,可能有不同的更新需求
  • 在高维的损失优化中,很难收敛到每一维数据梯度都接近于0的点,相反,很容易收敛于鞍点或局部最小点

3 各种梯度下降算法

Momentum

权重更新公式:
vt=γvt1+ηθJ(θ)θ=θvt\begin{aligned} v_{t} &amp;=\gamma v_{t-1}+\eta \nabla_{\theta} J(\theta) \\ \theta &amp;=\theta-v_{t} \end{aligned}
记进行第tt次权重更新时,梯度大小为gtg_t(为了方便表达),则上式变为:
vt=γvt1+ηgt=ηgt+γ(ηgt1+γvt2)=ηgt+γηgt1+γ2vt2...=ηgt+γηgt1+γ2ηgt2+...+γt1ηg1\begin{aligned}v_t &amp;= \gamma v_{t-1} + \eta g_t \\&amp;=\eta g_t + \gamma(\eta g_{t-1}+\gamma v_{t-2})\\&amp;=\eta g_t + \gamma \eta g_{t-1} + \gamma^2v_{t-2}\\ &amp;...\\&amp;=\eta g_t+\gamma \eta g_{t-1}+\gamma ^2 \eta g_{t-2} + ...+\gamma ^ {t-1}\eta g_1\end{aligned}
从式中可以知道,权重更新不仅和本次计算出来损失函数的梯度有关,还和之前计算出来每一次的梯度大小有点,距离越近,贡献越大,距离越远,贡献越小(γ&lt;1\gamma&lt;1)。当γ=0\gamma=0时则退化成普通的SGD。
那么,把以往的权重更新考虑进去有什么用呢???

  • 若在某个维度多次权重更新方向一致,则会加速该权重的更新
  • 若在某个维度权重更新方向一直发生变化,即梯度出现正负交替,多个梯度求和的结果则会减小该方向权重的变化。

但是,Momentum法存在一个缺陷。当某一维度的梯度经过多次同样的方向的权重更新后,达到了最小值。尽管在最小值处的的梯度gt=0g_t=0,但是!由于累计梯度的原因,vt1v_{t-1}并不为0,因此权重会铁憨憨地继续更新,但却是往损失变大的方向更新。
因此,需要给权重的更新提供一点感知下一位置的能力。请看下一个方法!

Nesterov accelerated gradient

权重更新公式
vt=γvt1+ηθJ(θγvt1)θ=θvt\begin{array}{l}{v_{t}=\gamma v_{t-1}+\eta \nabla_{\theta} J\left(\theta-\gamma v_{t-1}\right)} \\ {\theta=\theta-v_{t}}\end{array}
对比Momentum法,二者在权重更新时,都由两项组成:

  • 累计动量项:γvt1\gamma v_{t-1}
  • 损失梯度项:
    ηθJ(θγvt1)\eta \nabla_{\theta} J\left(\theta-\gamma v_{t-1}\right)(Nesterov);
    ηθJ(θ)\eta \nabla_{\theta} J(\theta)(Momentum)

二者的区别在于损失梯度项。对于Momentum,是当前位置的梯度损失;对于Nesterov是下一近似位置的梯度损失,正是该项,赋予了该优化方法感知下一刻的能力。
考虑以下这个场景:某一维度的权重经过多次的更新后,累计动量项已相对较大,且接近了最小点,权重再次更新后会导致损失反而变大。看看二者的表现:

  • Momentum:计算当前位置损失的梯度(仍与之前的梯度相同),结合累计动量项,更新权重,最终导致损失反而变大
  • Nesterov:计算下一位置的近似梯度(过了最小点之后,此时的梯度与之前相反),结合累计动量项,更新权重。由于损失梯度项变为相反值,一定程度上减少了权重更新的幅度,缓和甚至避免了损失的回升!

考虑一个二维权重的更新,水平方向和垂直方向,假设垂直方向的权重已接近最优值,也即权重再增大会导致损失不减反增。
Momentum的损失梯度项(红色)垂直方向的分量接近0,但累计动量项仍有很大的垂直分量,两个分量合成后(黄色),垂直方向的权重仍进行了很大的权重更新。
Nesterov的损失梯度项是下一位置的近似梯度,由于下一位置梯度和当前相反,因此垂直分量向下。两个分量合成后,垂直方向的分量抵消了一部分,最终垂直方向的权重更新不大。

Adagrad

权重更新公式:
θt+1,i=θt,iηGt,ii+ϵgt,i\theta_{t+1, i}=\theta_{t, i}-\frac{\eta}{\sqrt{G_{t, i i}+\epsilon}} \cdot g_{t, i}
式中:

  • θt+1,i\theta_{t+1,i}t+1t+1时刻ii方向的权重;
  • Gt,iiG_{t,ii}是对角阵GtG_t对角上第ii个元素,该元素大小为θi\theta_i以往每一次梯度的平方和;
  • ϵ=108\epsilon=10^{-8},避免除0

Adagrad方法旨在对不同参数,在不同时刻使用不同的学习率。
对于频繁发生更新(梯度不为0)的权重,其学习率会被调整得较小;而对于更新不频繁的权重,其学习率则会被调整得较大。
但随着训练的进行,梯度的平方和越来越大,导致最终学习率被调整得很小,导致训练收敛困难。

Adadelta

Adadelta旨在处理Adagrad学习速率单调递减的情况。不是使用所有梯度的平方和,而是使用梯度平方的调和均值(与常规均值不一样),定义如下:
E[g2]t=γE[g2]t1+(1γ)gt2E\left[g^{2}\right]_{t}=\gamma E\left[g^{2}\right]_{t-1}+(1-\gamma) g_{t}^{2}
相应地,权重变化值变成
Δθt=ηE[g2]t+ϵgt \Delta \theta_{t}=-\frac{\eta}{\sqrt{E\left[g^{2}\right]_{t}+\epsilon}} g_{t}
将分母用均方根(RME,先平方、取平均、再求平方根)表示(此处并不是严格的平方根,因为所取的平均是经过调和的):
Δθt=ηRMS[g]tgt \Delta \theta_{t}=-\frac{\eta}{R M S[g]_{t}} g_{t}
与以往不同,此处是对参数的平方进行更新:
E[Δθ2]t=γE[Δθ2]t1+(1γ)Δθt2 E\left[\Delta \theta^{2}\right]_{t}=\gamma E\left[\Delta \theta^{2}\right]_{t-1}+(1-\gamma) \Delta \theta_{t}^{2}
同样可以的到参数更新的均方根:
RMS[Δθ]t=E[Δθ2]t+ϵ R M S[\Delta \theta]_{t}=\sqrt{E\left[\Delta \theta^{2}\right]_{t}+\epsilon}
参数更新的均方根反应了以往参数更新的幅度大小,可用来代替学习率,于是,权重更新规则变为:
Δθt=RMS[Δθ]t1RMS[g]tgtθt+1=θt+Δθt \begin{array}{c}{\Delta \theta_{t}=-\frac{R M S[\Delta \theta]_{t-1}}{R M S[g]_{t}} g_{t}} \\ {\theta_{t+1}=\theta_{t}+\Delta \theta_{t}}\end{array}
无需设置学习率

RMSprop

RMSprop同样是为了解决Adagrad学习率单调递减的情况。和Adadelta初始想法一致,采用权重梯度平方和的均值来调整学习率。更新规则如下:
E[g2]t=0.9E[g2]t1+0.1gt2θt+1=θtηE[g2]t+ϵgt \begin{array}{c}{E\left[g^{2}\right]_{t}=0.9 E\left[g^{2}\right]_{t-1}+0.1 g_{t}^{2}} \\ {\theta_{t+1}=\theta_{t}-\frac{\eta}{\sqrt{E\left[g^{2}\right]_{t}+\epsilon}} g_{t}}\end{array}

Adam

Adam同样是一个调整学习率的优化方法。除了记录梯度的历史平方和,还记录了梯度的指数平均值:
mt=β1mt1+(1β1)gtvt=β2vt1+(1β2)gt2 \begin{aligned} m_{t} &amp;=\beta_{1} m_{t-1}+\left(1-\beta_{1}\right) g_{t} \\ v_{t} &amp;=\beta_{2} v_{t-1}+\left(1-\beta_{2}\right) g_{t}^{2} \end{aligned}
将式子展开:
mt=β1mt1+(1β1)gt=(1β1)gt+β1((1β1)gt1+β1mt2)=(1β1)gt+(1β1)β1gt1+β12mt2...=(1β1)(gt+β1gt1+β12gt2+...+β1t1g1) \begin{aligned} m_t &amp;=\beta_1m_{t-1}+(1-\beta_1)g_t\\ &amp;=(1-\beta_1)g_t + \beta_1((1-\beta_1)g_{t-1} + \beta_1m_{t-2})\\ &amp;=(1-\beta_1)g_t+(1-\beta_1) \beta_1 g_{t-1}+\beta_1^2m_{t-2}\\ &amp;...\\ &amp;=(1-\beta_1)(g_t+\beta_1g_{t-1}+\beta_1^2g_{t-2}+...+\beta_1^{t-1}g_1) \end{aligned}
vtv_t同理,都是在指数平均的基础上,再乘以一个缩减的系数。
通过计算偏差校正的一阶矩和二阶矩估计来抵消偏差:
m^t=mt1β1tv^t=vt1β2t \begin{aligned} \hat{m}_{t} &amp;=\frac{m_{t}}{1-\beta_{1}^{t}} \\ \hat{v}_{t} &amp;=\frac{v_{t}}{1-\beta_{2}^{t}} \end{aligned}
于是权重的更新公式为:
θt+1=θtηv^t+ϵm^t \theta_{t+1}=\theta_{t}-\frac{\eta}{\sqrt{\hat{v}_{t}}+\epsilon} \hat{m}_{t}
一般设置β1=0.9β2=0.999ϵ=108\beta_1=0.9、\beta_2=0.999、\epsilon=10^{-8}

4 如何挑选优化器

对于调整学习率的方法,如Adagrad、Adadelta、RMSprop、Adam等,实验表明Adam的效果好于其他方法。有趣的是,不带动量SGD搭配衰减的学习率经常能找到更小值,但会耗费更多的时间,并且也容易陷于鞍点。

2018-09-15 20:27:43 m0_37935211 阅读数 992

本文依旧是吴恩达《深度学习工程师》课程的笔记整理与拓展。

一、优化算法的目的与挑战

    优化算法主要是用来加快神经网络的训练速度,使得目标函数快速收敛。

    优化问题面临的挑战有病态解、鞍点、梯度爆炸与梯度消失……具体可见参考文献【1】241页到249页。

    其中深度学习不太可能陷入局部最优,因为loss函数通常涉及多个维度(w1,w2...)

二、常见的优化算法

1、基本算法

  • 小批量梯度下降即各种变体

  1. 批量梯度下降(Batch gradient descent)

  2. 随机梯度下降(Stochastic gradient descent)

  3. 小批量梯度下降(Mini-batch gradient descent)

     三者关系:

             mini-batch size = m,Batch gradient descent

             mni-batch size = 1,Stochastic gradient descent

    三者各自的特点:

           Batch gradient descent:优化目标函数一次迭代的时间太长

          Stochastic gradient descent:丧失了向量化加速的优势

          Stochastic gradient descent:可以向量化,而且每次迭代不用遍历整个数据集

    如何选择mini-batch size:

          如果是小的训练集(m<=2000),可以直接使用Batch gradient descent;对于大的训练集,常见的size有64,128,256,512.另外注意考虑CPU/GPU memory。

    涉及概念Epoch:

           1 epoch即一代就是遍历整个数据集一次。

  • Momentum梯度下降法(Gradient descent with momentum)

      相对于通常的梯度下降法,该优化算法采用了dw的指数加权平均数替换原来的dw,使得w更快地指向最优解。

       指数加权平均  Exponentially weighted averages

       这里补充一下指数加权平均的概念。课堂上是以伦敦连续很多天的温度为例子,\theta _{t}是指第t天的温度

                                               V_{t} = \beta V _{t-1}+(1-\beta )\theta _{t}

       这里的指数加权平均Vt大约是\frac{1}{1-\beta }  天的平均温度

                                     

2、自适应学习率算法

  • RMSprop

       和Momentum算法一样,可以消除梯度下降中的摆动并使用更大的学习率。

      

  • Adam

      结合了Momentum和RMSprop两种算法,是很常用的优化算法。

三、如何选择合适的优化算法

         一是考虑自己对算法的熟悉程度, 便于调试超参数;二是Adam从总体来说是最好的选择。详见参考文献【2】、【3】

四、优化策略

        许多优化技术并非真正的算法,而是一般化的模板,可以特定地产生算法,或是并入到很多不同的算法中。

  • 正则化输入 Normalizing inputs

        正则化输入可以使得代价函数更圆,从而加快训练速度。

        实现方法分为两步:零均值化,归一化方差。即减去均值除以标准差。

  • 批标准化   Batch Normalization

​​​​​​​       批标准化使得每一层的隐藏单元有着标准的均值和方差(不一定分别为0和1),从而加快训练速度。

           \gamma \varepsilon这两个参数是需要学习的参数。更多内容参看论文。

  • 预训练

               待学习

  • 学习率衰减 Learning rate decay

                                               \alpha =\frac{1}{1+decayrate*epochnum}\alpha _{0}​​​​​​​

      两个超参数:decayrate、\alpha _{0}

 

【1】《深度学习》https://github.com/exacity/deeplearningbook-chinese

【2】《深度学习总结(五)——各优化算法》https://blog.csdn.net/manong_wxd/article/details/78735439

【3】《深度学习常用优化算法》https://blog.csdn.net/pandamax/article/details/72852960

没有更多推荐了,返回首页