rmsprop算法

❶ inception v3用的是什么算法

v3在raw的v2上做了如下变化：RMSProp替代SGD，在类别全连接层后加入 LSR层，将7x7卷积核由三个3x3卷积核替代。简单来说，就是卷积的替代，层的更换和更新方式的差别。

❷ 深度机器学习中的batch的大小对学习效果有何影响

深度机器学习中的batch的大小对学习效果有何影响？
如题，在深度学习中，刚入门的小弟一直听闻一个batch中同时训练多个数据可以得到较好的效果，于是小弟在caffe上跑deepID的网络时对如何选取batchsize颇具困惑。恳求万能的知友给予指点~~

14 个回答

谈谈深度学习中的 Batch_Size Batch_Size（批尺寸）是机器学习中一个重要参数，涉及诸多矛盾，下面逐一展开。 首先，为什么需要有 Batch_Size 这个参数？ Batch 的选择，首先决定的是下降的方向。如果数据集比较小，完全可以采用全数据集 （ Full Batch Lea… 显示全部
谈谈深度学习中的 Batch_Size
Batch_Size（批尺寸）是机器学习中一个重要参数，涉及诸多矛盾，下面逐一展开。

首先，为什么需要有 Batch_Size 这个参数？
Batch 的选择，首先决定的是下降的方向。如果数据集比较小，完全可以采用全数据集 （ Full Batch Learning）的形式，这样做至少有 2 个好处：其一，由全数据集确定的方向能够更好地代表样本总体，从而更准确地朝向极值所在的方向。其二，由于不同权重的梯度值差别巨大，因此选取一个全局的学习率很困难。 Full Batch Learning 可以使用Rprop 只基于梯度符号并且针对性单独更新各权值。

对于更大的数据集，以上 2 个好处又变成了 2 个坏处：其一，随着数据集的海量增长和内存限制，一次性载入所有的数据进来变得越来越不可行。其二，以 Rprop 的方式迭代，会由于各个 Batch 之间的采样差异性，各次梯度修正值相互抵消，无法修正。这才有了后来 RMSProp 的妥协方案。

既然 Full Batch Learning 并不适用大数据集，那么走向另一个极端怎么样？
所谓另一个极端，就是每次只训练一个样本，即 Batch_Size = 1。这就是在线学习（Online Learning）。线性神经元在均方误差代价函数的错误面是一个抛物面，横截面是椭圆。对于多层神经元、非线性网络，在局部依然近似是抛物面。使用在线学习，每次修正方向以各自样本的梯度方向修正，横冲直撞各自为政，难以达到收敛。
可不可以选择一个适中的 Batch_Size 值呢？
当然可以，这就是批梯度下降法（Mini-batches Learning）。因为如果数据集足够充分，那么用一半（甚至少得多）的数据训练算出来的梯度与用全部数据训练出来的梯度是几乎一样的。

在合理范围内，增大 Batch_Size 有何好处？

内存利用率提高了，大矩阵乘法的并行化效率提高。
跑完一次 epoch（全数据集）所需的迭代次数减少，对于相同数据量的处理速度进一步加快。
在一定范围内，一般来说 Batch_Size 越大，其确定的下降方向越准，引起训练震荡越小。

盲目增大 Batch_Size 有何坏处？

内存利用率提高了，但是内存容量可能撑不住了。
跑完一次 epoch（全数据集）所需的迭代次数减少，要想达到相同的精度，其所花费的时间大大增加了，从而对参数的修正也就显得更加缓慢。
Batch_Size 增大到一定程度，其确定的下降方向已经基本不再变化。

调节 Batch_Size 对训练效果影响到底如何？
这里跑一个 LeNet 在 MNIST 数据集上的效果。MNIST 是一个手写体标准库，我使用的是 Theano 框架。这是一个 Python 的深度学习库。安装方便（几行命令而已），调试简单（自带 Profile），GPU / CPU 通吃，官方教程相当完备，支持模块十分丰富（除了 CNNs，更是支持 RBM / DBN / LSTM / RBM-RNN / SdA / MLPs）。在其上层有Keras 封装，支持 GRU / JZS1, JZS2, JZS3 等较新结构，支持 Adagrad / Adadelta / RMSprop / Adam 等优化算法。
运行结果如上图所示，其中绝对时间做了标幺化处理。运行结果与上文分析相印证：

Batch_Size 太小，算法在 200 epoches 内不收敛。

随着 Batch_Size 增大，处理相同数据量的速度越快。
随着 Batch_Size 增大，达到相同精度所需要的 epoch 数量越来越多。

由于上述两种因素的矛盾， Batch_Size 增大到某个时候，达到时间上的最优。
由于最终收敛精度会陷入不同的局部极值，因此 Batch_Size 增大到某些时候，达到最终收敛精度上的最优。

欢迎一起讨论。

知乎用户 理论物理跳深度学习...60%概率失业
20 人赞同
批训练的引入最大好处是针对非凸损失函数来做的， 毕竟非凸的情况下， 全样本就算工程上算的动， 也会卡在局部优上， 批表示了全样本的部分抽样实现， 相当于人为引入修正梯度上的采样噪声，使“一路不通找别路”更有可能搜索最优值。 楼上很多说到随机梯度… 显示全部
批训练的引入最大好处是针对非凸损失函数来做的， 毕竟非凸的情况下， 全样本就算工程上算的动， 也会卡在局部优上， 批表示了全样本的部分抽样实现， 相当于人为引入修正梯度上的采样噪声，使“一路不通找别路”更有可能搜索最优值。

楼上很多说到随机梯度收敛问题，物理上是这样的理解，

增加噪音扩大了你的行动范围，不会受限于局部。
然而过大的行动范围使得你的选择过多而”迷茫“。
这是一个损失函数局部优有“多坑人”和局部优“数目太多好难选”之间的竞争，竞争平衡点才是你最终的训练值。故此，最终的训练值是一个分布，大伙们一般取平均来证明自己的模型多牛逼。
物理上，就是能量（坑好深）和熵（选择多）的竞争结果，而且复杂系统中，能量和熵一辈子都在竞争，讨论自由能最小值在非凸问题上的意义，比直接讨论损失函数的最小值更有意义。
然而，这种牛逼，不仅依赖模型，而且依赖数据本身。调参需要预先建立竞争平衡的理论模型，单纯用软件刷指标只能用在某个数据集上，不具有转移性。纯浪费电！
这些观点在大部分复杂物理系统的采样，自旋玻璃的研究，蛋白质折叠构象搜索上，都有广泛的认识。但是工业界被凸优化影响过多了，除了特征选择和防止过拟合外可以通过直觉建立，遇到非凸优化问题，基本不可能拍脑袋调出一个通用的（如果数学上可以，物理上应该最先发现，然而并没有）。于是，即便在物理上遇到这种问题，目前很low，而且节省成本的方法就是烧钱增加计算蛮力点。矛盾到我笑尿了。

关于深度学习中的非凸优化，可以参考LeCun今年来对深度学习和自旋玻璃之间的联系，以及随机微分方程同增强采样之间的研究。

Yinghong li 重新出发干实事

caffe小菜鸟也来答一下，感觉就是大batch size在显存能允许的情况下收敛速度是比较快的但有时的确会有陷入局部最小的情况，小batch size引入的随机性会更大些，有时候能有更好的效果，但是就是收敛速度慢一些…… 还有就是除了batch size这个参数外，如果在… 显示全部
caffe小菜鸟也来答一下，感觉就是大batch size在显存能允许的情况下收敛速度是比较快的但有时的确会有陷入局部最小的情况，小batch size引入的随机性会更大些，有时候能有更好的效果，但是就是收敛速度慢一些……
还有就是除了batch size这个参数外，如果在solver setting中有momentum这个参数的话也要注意batch size的选取，具体参考一下caffe的tutorial

关于训练参数怎么选取可以参考以下一些文章:
Bengio的 Practical recommendations for gradient-based learning

Lecun 和 Bottou的 Efficient Backprop

还有一个代码上的细节，就是caffe的代码实现上选取一个batch的时候似乎是按着数据库的图片顺序选取输入图片的，所以在生成数据库的时候切记要shuffle一下图片顺序~

供题主参考，求大神指正~

匿名用户
4 人赞同
搞机器学习大忌就是不做实验想当然，话说这种问题题主跑几组不同的batch不就知道了...调参调参不调哪来的参～ 另外，运用在不同的领域，不同的网络结构，不同的训练方法，batch的取法，用法和影响也不一样。不知道题主问的是哪种batch？ 显示全部
搞机器学习大忌就是不做实验想当然，话说这种问题题主跑几组不同的batch不就知道了...调参调参不调哪来的参～

另外，运用在不同的领域，不同的网络结构，不同的训练方法，batch的取法，用法和影响也不一样。不知道题主问的是哪种batch？

知乎用户 我是认真的
我也看到过说理论上batchsize=1是最好的，不过实际上调的时候，可能因为我调参的能力比较有限，确实batchsize太小会出现网络收敛不稳定，最后结果比较差的情况，这个在ImageNet和其他数据库上都遇到过，而batchsize太大确实也会影响随机性的引入。目前一般… 显示全部
我也看到过说理论上batchsize=1是最好的，不过实际上调的时候，可能因为我调参的能力比较有限，确实batchsize太小会出现网络收敛不稳定，最后结果比较差的情况，这个在ImageNet和其他数据库上都遇到过，而batchsize太大确实也会影响随机性的引入。目前一般调ImageNet的时候，大家都喜欢把显存占满，不过小一些的库，个人感觉还是应该大大小小都尝试一下。不知道各路大神有没有什么好办法指点一下。。

匿名用户
23 人赞同
看你GPU显存，显存大就把batch size设大点，反之亦然。一般情况下对学习效果没影响。 补充点细节： 事实上从优化的角度来说最快的是纯stochastic，即batch size为1。 关于这一点参见Leon Bottou的分析：http://leon.bottou.org/publications/pdf/compstat-2010.pdf。当然，文中的分析适用于large … 显示全部
看你GPU显存，显存大就把batch size设大点，反之亦然。一般情况下对学习效果没影响。

补充点细节：

事实上从优化的角度来说最快的是纯stochastic，即batch size为1。
关于这一点参见Leon Bottou的分析：http://leon.bottou.org/publications/pdf/compstat-2010.pdf。当然，文中的分析适用于large scale的情况下，但deep neural net适用的条件之一就是有大量数据。另外http://cilvr.nyu.e/lib/exe/fetch.php?media=deeplearning:dl-optimization.pdf 的第11页也有比较stochastic和batch的优劣。

拿Yann Lecun在上述第二个链接第10页中举的toy example来说，如果事实上只有100个数据点，但有人各复制了10遍拿给你，你不知道。这时候你如果做batch gradient descent，更只用了100个点效果一样；而做stochastic gradient descent则相当于做了10个epoch。相近的计算量后者效果显然更好。至于mini batch，要你取的每个mini batch都很diverse的情况才会效果好。

当然你会说，现实中哪会有100个数据各重复10遍就直接拿来用的？没错，是不会，但现实中的数据，尤其是large scale的数据中，必然有大量的rendancy，不然你也很难学出有较好泛化性的model。因此stochastic在large scale总是优于batch。

那为什么还要用mini batch呢？这是由于GPU并行运算的性质，同时把多组数据传过去一起运算比一条一条运算来的快，因而mini batch只是为了充分利用GPU memory而做出的妥协。既然如此，batch size也调到刚好能塞进显存就差不多了。

司徒功源 非典型程序猿
2 人赞同
简而言之，步子太大容易扯着蛋... 显示全部
简而言之，步子太大容易扯着蛋...

发布于 2016-01-14 1 条评论 感谢

匿名用户
9 人赞同
其实是有影响的。batch数太小，而类别又比较多的时候，真的可能会导致loss函数震荡而不收敛，尤其是在你的网络比较复杂的时候。这个做过几个实验，但是没有详细的做，主要是针对googlenet，alexnet以及vgg几个模型（实验结果就是batch为32的时候，alex开始… 显示全部
其实是有影响的。batch数太小，而类别又比较多的时候，真的可能会导致loss函数震荡而不收敛，尤其是在你的网络比较复杂的时候。这个做过几个实验，但是没有详细的做，主要是针对googlenet，alexnet以及vgg几个模型（实验结果就是batch为32的时候，alex开始收敛，但是googlenet不收敛；提高batch size，googlenet开始收敛）。
就像lecun[note]里说的一样，随机梯度下降不能像full batch那样明显的保证收敛。一般而言，根据你的GPU显存，设置为最大，而且一般要求是8的倍数（比如32，128），这样，GPU内部的并行运算效率最高。
那么怎么选择batch number呢？就像刚才说的，8的倍数，然后是稍微大一点（一般而言）。另外一个方法，就是选择一部分数据，跑几个batch看看你的loss是不是在变小,选择一个合适的就可以了。

❸ 如何在Python中用LSTM网络进行时间序列预测

时间序列模型

时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题，和回归分析模型的预测不同，时间序列模型是依赖于事件发生的先后顺序的，同样大小的值改变顺序后输入模型产生的结果是不同的。
举个栗子：根据过去两年某股票的每天的股价数据推测之后一周的股价变化；根据过去2年某店铺每周想消费人数预测下周来店消费的人数等等

RNN 和 LSTM 模型

时间序列模型最常用最强大的的工具就是递归神经网络（recurrent neural network, RNN）。相比与普通神经网络的各计算结果之间相互独立的特点，RNN的每一次隐含层的计算结果都与当前输入以及上一次的隐含层结果相关。通过这种方法，RNN的计算结果便具备了记忆之前几次结果的特点。

典型的RNN网路结构如下：

4. 模型训练和结果预测
将上述数据集按4:1的比例随机拆分为训练集和验证集，这是为了防止过度拟合。训练模型。然后将数据的X列作为参数导入模型便可得到预测值，与实际的Y值相比便可得到该模型的优劣。

实现代码

这里的输入数据来源是csv文件，如果输入数据是来自数据库的话可以参考这里

这里写的只涉及LSTM网络的结构搭建，至于如何把数据处理规范化成网络所需的结构以及把模型预测结果与实际值比较统计的可视化，就需要根据实际情况做调整了。

❹ 神经网络中自适应的梯度下降优化算法（二）

Adagrad算法可以针对不同的参数自适应的采用不同的更新频率，对低频出现的特征采用低的更新率，对高频出现的特征采用高的更新率，因此，对于稀疏的数据它表现的很好，很好的提升了SGD的鲁棒性，在Google的通过Youtube视频识别猫的神经网络训练中有很好的表现。

梯度更新规则:

g(t,i)表示在t时刻目标函数对θ(i)的偏导数。SGD的每个参数的更新过程如下：

Adagrad的每个参数更新过程如下:

G(t)是一个对角矩阵，对角线上的每个元素是t时刻前所有θ(i)的梯度的平方和。ε通常取值在1e-8量级，它的存在是为了避免除数为0。一个有趣的现象是，如果没有平方根操作，算法的表现就非常糟糕。

Adagrad的主要缺点是，它的分母是平方梯度的累积，它的值会一直增加，最终导致学习率衰减到非常小，从而使得学习算法无法进行下去。

TensorFlow实现:

tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1, use_locking=False, name='Adagrad')

Adadelta算法主要解决Adagrad的缺陷，它不再累加过去所有的梯度，而是仅累积过去固定个数的梯度。

Adadelta不是采用平方梯度的简单累加，而是采用 历史 平方梯度的衰减的平均。

γ通常等于0.9

分母相当于梯度的均方根(root mean squared, RMS)，即将所有值平方求和，求其均值，再开平方，就得到均方根值。

梯度更新规则:

将学习率η设置为

，我们就不需要提前设定学习率。

RMSprop是Geoff Hinton提出的一种自适应学习率的方法，它与Adadelta方法都是为了解决Adagrad学习率急剧下降问题的。它与Adadelta方法是一致的。

梯度更新规则

超参数设定值:

Hinton建议设定γ=0.9, 学习率η=0.001。

TensorFlow实现:

tf.train.RMSPropOptimizer.__init__(learning_rate, decay, momentum=0.0, epsilon=1e-10, use_locking=False, name='RMSProp')

Adam也是对不同的参数自适应设置不同的学习率。它对 历史 梯度和 历史 平方梯度同时采用指数梯度衰减(exponentially decaying average)。

梯度更新规则

Adam作者观察到，如果m(t)和v(t)初始化为零向量，并且衰减率很小时(比如β1和β2都非常接近于1时)，在开始的迭代中，m(t)和v(t)总是向零偏移，所以需要做偏移校正。

然后用校正后的值进行梯度更新:

Adam作者建议β1=0.9,β2=0.999,ε=10^{-8}

，在实践中，Adam比其它算法的效果要好。

TensorFlow实现：

tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam')

Adam更新规则中的梯度缩放与 历史 梯度的L2范数成反比。

我们可以把这个规则泛化到Lp范数。

当p值增大的时候，Lp的值往往会变得不稳定，所以在实践中L1和L2使用的比较普遍。但是Adamax作者发现L∞可以收敛到一个稳定值。

然后我们可以采用u(t)代替

来更新Adam中的梯度。

同时u(t)不需要做零偏校正。默认取值建议：

❺ 100维度用什么优化算法

神经网络中常用的优化算法。
优化算法的目的：
1. 跳出局部极值点或鞍点，寻找全局最小值；
2.使训练过程更加稳定，更加容易收敛。
优化算法：深度学习优化学习方法（一阶、二阶）
一阶方法：随机梯度下降（SGD）、动量（Momentum）、牛顿动量法（Nesterov动量）、AdaGrad（自适应梯度）、RMSProp（均方差传播）、Adam、Nadam。
二阶方法：牛顿法、拟牛顿法、共轭梯度法（CG）、BFGS、L-BFGS。
自适应优化算法有哪些？（Adagrad（累积梯度平方）、RMSProp（累积梯度平方的滑动平均）、Adam（带动量的RMSProp，即同时使用梯度的一、二阶矩））。
梯度下降陷入局部最优有什么解决办法？可以用BGD、SGD、MBGD、momentum，RMSprop，Adam等方法来避免陷入局部最优。

❻ 根号6+根号2×多少等于1

梯度下降是非常常用的优化算法。作为机器学习的基础知识，这是一个必须要掌握的算法。借助本文，让我们来一起详细了解一下这个算法。

前言

本文的代码可以到我的Github上获取：

https://github.com/paulQuei/gradient_descent

本文的算法示例通过Python语言实现，在实现中使用到了numpy和matplotlib。如果你不熟悉这两个工具，请自行在网上搜索教程。

关于优化

大多数学习算法都涉及某种形式的优化。优化指的是改变x以最小化或者最大化某个函数的任务。

我们通常以最小化指代大多数最优化问题。最大化可经由最小化来实现。

我们把要最小化或最大化的函数成为目标函数（objective function）或准则（criterion）。

我们通常使用一个上标*表示最小化或最大化函数的x值，记做这样：

[x^* = arg; min; f(x)]

优化本身是一个非常大的话题。如果有兴趣，可以通过《数值优化》和《运筹学》的书籍进行学习。

模型与假设函数

所有的模型都是错误的，但其中有些是有用的。– George Edward Pelham Box

模型是我们对要分析的数据的一种假设，它是为解决某个具体问题从数据中学习到的，因此它是机器学习最核心的概念。

针对一个问题，通常有大量的模型可以选择。

本文不会深入讨论这方面的内容，关于各种模型请参阅机器学习的相关书籍。本文仅以最简单的线性模型为基础来讨论梯度下降算法。

这里我们先介绍一下在监督学习（supervised learning）中常见的三个符号：

• m，描述训练样本的数量

• x，描述输入变量或特征

• y，描述输出变量或者叫目标值

• 请注意，一个样本可能有很多的特征，因此x和y通常是一个向量。不过在刚开始学习的时候，为了便于理解，你可以暂时理解为这就是一个具体的数值。

训练集会包含很多的样本，我们用 表示其中第i个样本。

x是数据样本的特征，y是其目标值。例如，在预测房价的模型中，x是房子的各种信息，例如：面积，楼层，位置等等，y是房子的价格。在图像识别的任务中，x是图形的所有像素点数据，y是图像中包含的目标对象。

我们是希望寻找一个函数，将x映射到y，这个函数要足够的好，以至于能够预测对应的y。由于历史原因，这个函数叫做假设函数（hypothesis function）。

学习的过程如下图所示。即：首先根据已有的数据（称之为训练集）训练我们的算法模型，然后根据模型的假设函数来进行新数据的预测。

线性模型（linear model）正如其名称那样：是希望通过一个直线的形式来描述模式。线性模型的假设函数如下所示：

[h_{ heta}(x) = heta_{0} + heta_{1} * x]

这个公式对于大家来说应该都是非常简单的。如果把它绘制出来，其实就是一条直线。

下图是一个具体的例子，即： 的图形：

在实际的机器学习工程中，你会拥有大量的数据。这些数据会来自于某个数据源。它们存储在csv文件中，或者以其他的形式打包。

但是本文作为演示使用，我们通过一些简单的代码自动生成了需要的数据。为了便于计算，演示的数据量也很小。

import numpy as np

max_x = 10
data_size = 10
theta_0 = 5
theta_1 = 2

def get_data:
x = np.linspace(1, max_x, data_size)
noise = np.random.normal(0, 0.2, len(x))
y = theta_0 + theta_1 * x + noise
return x, y


这段代码很简单，我们生成了x范围是 [1, 10] 整数的10条数据。对应的y是以线性模型的形式计算得到，其函数是：。现实中的数据常常受到各种因素的干扰，所以对于y我们故意加上了一些高斯噪声。因此最终的y值为比原先会有轻微的偏离。

最后我们的数据如下所示：

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [6.66, 9.11, 11.08, 12.67, 15.12, 16.76, 18.75, 21.35, 22.77, 24.56]


我们可以把这10条数据绘制出来这样就有一个直观的了解了，如下图所示：

虽然演示用的数据是我们通过公式计算得到的。但在实际的工程中，模型的参数是需要我们通过数据学习到的。所以下文我们假设我们不知道这里线性模式的两个参数是什么，而是通过算法的形式求得。

最后再跟已知的参数进行对比以验证我们的算法是否正确。

有了上面的数据，我们可以尝试画一条直线来描述我们的模型。

例如，像下面这样画一条水平的直线：

很显然，这条水平线离数据太远了，非常的不匹配。

那我们可以再画一条斜线。

我们初次画的斜线可能也不贴切，它可能像下面这样：

最后我们通过不断尝试，找到了最终最合适的那条，如下所示：

梯度下降算法的计算过程，就和这种本能式的试探是类似的，它就是不停的迭代，一步步的接近最终的结果。


代价函数

上面我们尝试了几次通过一条直线来拟合（fitting）已有的数据。

二维平面上的一条直线可以通过两个参数唯一的确定，两个参数的确定也即模型的确定。那如何描述模型与数据的拟合程度呢？答案就是代价函数。

代价函数（cost function）描述了学习到的模型与实际结果的偏差程度。以上面的三幅图为例，最后一幅图中的红线相比第一条水平的绿线，其偏离程度（代价）应该是更小的。

很显然，我们希望我们的假设函数与数据尽可能的贴近，也就是说：希望代价函数的结果尽可能的小。这就涉及到结果的优化，而梯度下降就是寻找最小值的方法之一。

• 代价函数也叫损失函数。

对于每一个样本，假设函数会依据计算出一个估算值，我们常常用来表示。即 。

很自然的，我们会想到，通过下面这个公式来描述我们的模型与实际值的偏差程度：

[(h_ heta(x^i) - y^i)^2 = (widehat{y}^{i} - y^i)^2 = ( heta_{0} + heta_{1} * x^{i} - y^{i})^2]

请注意， 是实际数据的值， 是我们的模型的估算值。前者对应了上图中的离散点的y坐标，后者对应了离散点在直线上投影点的y坐标。

每一条数据都会存在一个偏差值，而代价函数就是对所有样本的偏差求平均值，其计算公式如下所示：

[L( heta) = frac {1}{m} sum_{i=1}^{m}(h_ heta(x^i) - y^i)^2 = frac {1}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i})^2]

当损失函数的结果越小，则意味着通过我们的假设函数估算出的结果与真实值越接近。这也就是为什么我们要最小化损失函数的原因。

• 不同的模型可能会用不同的损失函数。例如，logistic回归的假设函数是这样的：。其代价函数是这样的：

借助上面这个公式，我们可以写一个函数来实现代价函数：

def cost_function(x, y, t0, t1):
cost_sum = 0
for i in range(len(x)):
cost_item = np.power(t0 + t1 * x[i] - y[i], 2)
cost_sum += cost_item
return cost_sum / len(x)


这个函数的代码应该不用多做解释，它就是根据上面的完成计算。

我们可以尝试选取不同的 和 组合来计算代价函数的值，然后将结果绘制出来：

import numpy as np
import matplotlib.pyplot as plt

from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

theta_0 = 5
theta_1 = 2

def draw_cost(x, y):
fig = plt.figure(figsize=(10, 8))
ax = fig.gca(projection='3d')
scatter_count = 100
radius = 1
t0_range = np.linspace(theta_0 - radius, theta_0 + radius, scatter_count)
t1_range = np.linspace(theta_1 - radius, theta_1 + radius, scatter_count)
cost = np.zeros((len(t0_range), len(t1_range)))
for a in range(len(t0_range)):
for b in range(len(t1_range)):
cost[a][b] = cost_function(x, y, t0_range[a], t1_range[b])
t0, t1 = np.meshgrid(t0_range, t1_range)

ax.set_xlabel('theta_0')
ax.set_ylabel('theta_1')
ax.plot_surface(t0, t1, cost, cmap=cm.hsv)


在这段代码中，我们对 和 各自指定了一个范围进行100次的采样，然后以不同的 组合对来计算代价函数的值。

如果我们将所有点的代价函数值绘制出来，其结果如下图所示：

从这个图形中我们可以看出，当 越接近 [5, 2]时其结果（偏差）越小。相反，离得越远，结果越大。


直观解释

从上面这幅图中我们可以看出，代价函数在不同的位置结果大小不同。

从三维的角度来看，这就和地面的高低起伏一样。最高的地方就好像是山顶。

而我们的目标就是：从任意一点作为起点，能够快速寻找到一条路径并以此到达图形最低点（代价值最小）的位置。

而梯度下降的算法过程就和我们从山顶想要快速下山的做法是一样的。

在生活中，我们很自然会想到沿着最陡峭的路往下行是下山速度最快的。如下面这幅图所示：

针对这幅图，细心的读者可能很快就会有很多的疑问，例如：

• 对于一个函数，怎么确定下行的方向？

• 每一步该往前走多远？

• 有没有可能停留在半山腰的平台上？

这些问题也就是本文接下来要讨论的内容。


算法描述

梯度下降算法最开始的一点就是需要确定下降的方向，即：梯度。

我们常常用 来表示梯度。

对于一个二维空间的曲线来说，梯度就是其切线的方向。如下图所示：

而对于更高维空间的函数来说，梯度由所有变量的偏导数决定。

其表达式如下所示：

[ abla f({ heta}) = ( frac{partial f({ heta})}{partial heta_1} , frac{partial f({ heta})}{partial heta_2} , ... , frac{partial f({ heta})}{partial heta_n} )]

在机器学习中，我们主要是用梯度下降算法来最小化代价函数，记做：

[ heta ^* = arg min L( heta)]

其中，L是代价函数，是参数。

梯度下降算法的主体逻辑很简单，就是沿着梯度的方向一直下降，直到参数收敛为止。

记做：

[ heta ^{k + 1}_i = heta^{k}_i - lambda abla f( heta^{k})]

• 这里的下标i表示第i个参数。 上标k指的是第k步的计算结果，而非k次方。在能够理解的基础上，下文的公式中将省略上标k。

这里有几点需要说明：

• 收敛是指函数的变化率很小。具体选择多少合适需要根据具体的项目来确定。在演示项目中我们可以选择0.01或者0.001这样的值。不同的值将影响算法的迭代次数，因为在梯度下降的最后，我们会越来越接近平坦的地方，这个时候函数的变化率也越来越小。如果选择一个很小的值，将可能导致算法迭代次数暴增。

• 公式中的 称作步长，也称作学习率（learning rate）。它决定了每一步往前走多远，关于这个值我们会在下文中详细讲解。你可以暂时人为它是一个类似0.01或0.001的固定值。

• 在具体的项目，我们不会让算法无休止的运行下去，所以通常会设置一个迭代次数的最大上限。


线性回归的梯度下降

有了上面的知识，我们可以回到线性模型代价函数的梯度下降算法实现了。

首先，根据代价函数我们可以得到梯度向量如下：

[ abla f({ heta}) = (frac{partial L( heta)}{ partial heta_{0}}, frac{ partial L( heta)}{ partial heta_{1}}) = (frac {2}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) , frac {2}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) x^{i})]

接着，将每个偏导数带入迭代的公式中，得到：

[ heta_{0} := heta_{0} - lambda frac{partial L( heta_{0})}{ partial heta_{0}} = heta_{0} - frac {2 lambda }{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) heta_{1} := heta_{1} - lambda frac{partial L( heta_{1})}{ partial heta_{1}} = heta_{1} - frac {2 lambda }{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) x^{i}]

由此就可以通过代码实现我们的梯度下降算法了，算法逻辑并不复杂：

learning_rate = 0.01

def gradient_descent(x, y):
t0 = 10
t1 = 10
delta = 0.001
for times in range(1000):
sum1 = 0
sum2 = 0
for i in range(len(x)):
sum1 += (t0 + t1 * x[i] - y[i])
sum2 += (t0 + t1 * x[i] - y[i]) * x[i]
t0_ = t0 - 2 * learning_rate * sum1 / len(x)
t1_ = t1 - 2 * learning_rate * sum2 / len(x)
print('Times: {}, gradient: [{}, {}]'.format(times, t0_, t1_))
if (abs(t0 - t0_) < delta and abs(t1 - t1_) < delta):
print('Gradient descent finish')
return t0_, t1_
t0 = t0_
t1 = t1_
print('Gradient descent too many times')
return t0, t1


这段代码说明如下：

• 我们随机选择了 都为10作为起点

• 设置最多迭代1000次

• 收敛的范围设为0.001

• 学习步长设为0.01

如果我们将算法迭代过程中求得的线性模式绘制出来，可以得到下面这幅动态图：

最后算法得到的结果如下：


Times: 657, gradient: [5.196562662718697, 1.952931052920264]
Times: 658, gradient: [5.195558390180733, 1.9530753071808193]
Times: 659, gradient: [5.194558335124868, 1.9532189556399233]
Times: 660, gradient: [5.193562479839619, 1.9533620008416623]
Gradient descent finish


从输出中可以看出，算法迭代了660次就收敛了。这时的结果[5.193562479839619, 1.9533620008416623]，这已经比较接近目标值 [5, 2]了。如果需要更高的精度，可以将delta的值调的更小，当然，此时会需要更多的迭代次数。


高维扩展

虽然我们举的例子是二维的，但是对于更高维的情况也是类似的。同样是根据迭代的公式进行运算即可：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - frac{2lambda}{m} sum_{i=1}^{m}(h_ heta(x^{k})-y^k)x_i^k]

这里的下标i表示第i个参数，上标k表示第k个数据。


梯度下降家族BGD

在上面的内容中我们看到，算法的每一次迭代都需要把所有样本进行遍历处理。这种做法称为之Batch Gradient Descent，简称BGD。作为演示示例只有10条数据，这是没有问题的。

但在实际的项目中，数据集的数量可能是几百万几千万条，这时候每一步迭代的计算量就会非常的大了。

于是就有了下面两个变种。


SGD

Stochastic Gradient Descent，简称SGD，这种算法是每次从样本集中仅仅选择一个样本来进行计算。很显然，这样做算法在每一步的计算量一下就少了很多。

其算法公式如下：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - lambda(h_ heta(x^k)-y^k)x_i^k]

当然，减少算法计算量也是有代价的，那就是：算法结果会强依赖于随机取到的数据情况，这可能会导致算法的最终结果不太令人满意。


MBGD

以上两种做法其实是两个极端，一个是每次用到了所有数据，另一个是每次只用一个数据。

我们自然就会想到两者取其中的方法：每次选择一小部分数据进行迭代。这样既避免了数据集过大导致每次迭代计算量过大的问题，也避免了单个数据对算法的影响。

这种算法称之为Mini-batch Gradient Descent，简称MBGD。

其算法公式如下：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - frac{2lambda}{m} sum_{i=a}^{a + b}(h_ heta(x^k)-y^k)x_i^k]

当然，我们可以认为SGD是Mini-batch为1的特例。

针对上面提到的算法变种，该如何选择呢？

下面是Andrew Ng给出的建议：

• 如果样本数量较小（例如小于等于2000），选择BGD即可。

• 如果样本数量很大，选择 来进行MBGD，例如：64，128，256，512。

下表是 Optimization for Deep Learning 中对三种算法的对比

方法准确性更新速度内存占用在线学习BGD好慢高否SGD好（with annealing）快低是MBGD好中等中等是
算法优化

式7是算法的基本形式，在这个基础上有很多人进行了更多的研究。接下来我们介绍几种梯度下降算法的优化方法。


Momentum

Momentum是动量的意思。这个算法的思想就是借助了动力学的模型：每次算法的迭代会使用到上一次的速度作为依据。

算法的公式如下：

[v^t = gamma v^{t - 1} + lambda abla f( heta) heta = heta - v_t]

对比式7可以看出，这个算法的主要区别就是引入了，并且，每个时刻的受前一个时刻的影响。

从形式上看，动量算法引入了变量 v 充当速度角色——它代表参数在参数空间移动的方向和速率。速度被设为负梯度的指数衰减平均。名称动量来自物理类比，根据牛顿运动定律，负梯度是移动参数空间中粒子的力。动量在物理学上定义为质量乘以速度。在动量学习算法中，我们假设是单位质量，因此速度向量 v 也可以看作是粒子的动量。

对于可以取值0，而是一个常量，设为0.9是一个比较好的选择。

下图是momentum算法的效果对比：

对原来的算法稍加修改就可以增加动量效果：

def gradient_descent_with_momentum(x, y):
t0 = 10
t1 = 10
delta = 0.001
v0 = 0
v1 = 0
gamma = 0.9
for times in range(1000):
sum1 = 0
sum2 = 0
for i in range(len(x)):
sum1 += (t0 + t1 * x[i] - y[i])
sum2 += (t0 + t1 * x[i] - y[i]) * x[i]
v0 = gamma * v0 + 2 * learning_rate * sum1 / len(x)
v1 = gamma * v1 + 2 * learning_rate * sum2 / len(x)
t0_ = t0 - v0
t1_ = t1 - v1
print('Times: {}, gradient: [{}, {}]'.format(times, t0_, t1_))
if (abs(t0 - t0_) < delta and abs(t1 - t1_) < delta):
print('Gradient descent finish')
return t0_, t1_
t0 = t0_
t1 = t1_
print('Gradient descent too many times')
return t0, t1


以下是该算法的输出：


Times: 125, gradient: [4.955453758569991, 2.000005017897775]
Times: 126, gradient: [4.955309381126545, 1.9956928964532015]
Times: 127, gradient: [4.9542964317327005, 1.9855674828684156]
Times: 128, gradient: [4.9536358220657, 1.9781180992510465]
Times: 129, gradient: [4.95412496254411, 1.9788858350530971]
Gradient descent finish


从结果可以看出，改进的算法只用了129次迭代就收敛了。速度比原来660次快了很多。

同样的，我们可以把算法计算的过程做成动态图：

对比原始的算法过程可以看出，改进算法最大的区别是：在寻找目标值时会在最终结果上下跳动，但是越往后跳动的幅度越小，这也就是动量所产生的效果。


Learning Rate 优化

至此，你可能还是好奇该如何设定学习率的值。

事实上，这个值的选取需要一定的经验或者反复尝试才能确定。

• 《深度学习》一书中是这样描述的：“与其说是科学，这更像是一门艺术，我们应该谨慎地参考关于这个问题的大部分指导。”。

关键在于，这个值的选取不能过大也不能过小。

如果这个值过小，会导致每一次迭代的步长很小，其结果就是算法需要迭代非常多的次数。

那么，如果这个值过大会怎么样呢？其结果就是：算法可能在结果的周围来回震荡，却落不到目标的点上。下面这幅图描述了这个现象：

事实上，学习率的取值未必一定要是一个常数，关于这个值的设定有很多的研究。

下面是比较常见的一些改进算法。


AdaGrad

AdaGrad是Adaptive Gradient的简写，该算法会为每个参数设定不同的学习率。它使用历史梯度的平方和作为基础来进行计算。

其算法公式如下：

[ heta_i = heta_i - frac{lambda}{sqrt{G_t + epsilon}} abla f( heta)]

对比式7，这里的改动就在于分号下面的根号。

根号中有两个符号，第二个符号比较好理解，它就是为了避免除0而人为引入的一个很小的常数，例如可以设为：0.001。

第一个符号的表达式展开如下：

[G_t = sum_{i = 1}^{t} abla f( heta){i} abla f( heta){i}^{T}]

这个值其实是历史中每次梯度的平方的累加和。

AdaGrad算法能够在训练中自动的对learning rate进行调整，对于出现频率较低参数采用较大的学习率；相反，对于出现频率较高的参数采用较小的学习率。因此，Adagrad非常适合处理稀疏数据。

但该算法的缺点是它可能导致学习率非常小以至于算法收敛非常的慢。

关于这个算法的直观解释可以看李宏毅教授的视频课程：ML Lecture 3-1: Gradient Descent。


RMSProp

RMS是Root Mean Square的简写。RMSProp是AI教父Geoff Hinton提出的一种自适应学习率方法。AdaGrad会累加之前所有的梯度平方，而RMSProp仅仅是计算对应的平均值，因此可缓解Adagrad算法学习率下降较快的问题。

该算法的公式如下：

[E[ abla f( heta_{i})^2]^{t} = gamma E[ abla f( heta_{i})^2]^{t - 1} + (1-gamma)( abla f( heta_{i})^{t})^{2} heta_i = heta_i - frac{lambda}{sqrt{E[g^2]^{t+1} + epsilon}} abla f( heta_{i})]

类似的，是为了避免除0而引入。 是衰退参数，通常设为0.9。

这里的 是t时刻梯度平方的平均值。


Adam

Adam是Adaptive Moment Estimation的简写。它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。

Adam的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定范围，使得参数比较平稳。

该算法公式如下：

[m^{t} = eta_{1} m^{t-1} + (1-eta_{1}) abla f( heta) v^{t} = eta_{2} v^{t-1} + (1-eta_{2}) abla f( heta)^2 widehat{m}^{t} = frac{m^{t}}{1 - eta^{t}_1} widehat{v}^{t} = frac{v^{t}}{1 - eta^{t}_2} heta = heta - frac{lambda}{sqrt{widehat{v}^{t}} + epsilon}widehat{m}^{t}]

，分别是对梯度的一阶矩估计和二阶矩估计。， 是对，的校正，这样可以近似为对期望的无偏估计。

Adam算法的提出者建议 默认值为0.9，默认值为0.999，默认值为 。

在实际应用中 ，Adam较为常用，它可以比较快地得到一个预估结果。


优化小结

这里我们列举了几种优化算法。它们很难说哪种最好，不同的算法适合于不同的场景。在实际的工程中，可能需要逐个尝试一下才能确定选择哪一个，这个过程也是目前现阶段AI项目要经历的工序之一。

实际上，该方面的研究远不止于此，如果有兴趣，可以继续阅读 《Sebastian Ruder: An overview of gradient descent optimization algorithms》 这篇论文或者 Optimization for Deep Learning 这个Slides进行更多的研究。

由于篇幅所限，这里不再继续展开了。


算法限制

梯度下降算法存在一定的限制。首先，它要求函数必须是可微分的，对于不可微的函数，无法使用这种方法。

除此之外，在某些情况下，使用梯度下降算法在接近极值点的时候可能收敛速度很慢，或者产生Z字形的震荡。这一点需要通过调整学习率来回避。

另外，梯度下降还会遇到下面两类问题。


局部最小值

局部最小值（Local Minima）指的是，我们找到的最小值仅仅是一个区域内的最小值，而并非全局的。由于算法的起点是随意取的，以下面这个图形为例，我们很容易落到局部最小值的点里面。

这就是好像你从上顶往下走，你第一次走到的平台未必是山脚，它有可能只是半山腰的一个平台的而已。

算法的起点决定了算法收敛的速度以及是否会落到局部最小值上。

坏消息是，目前似乎没有特别好的方法来确定选取那个点作为起点是比较好的，这就有一点看运气的成分了。多次尝试不同的随机点或许是一个比较好的方法，这也就是为什么做算法的优化这项工作是特别消耗时间的了。

但好消息是：

• 对于凸函数或者凹函数来说，不存在局部极值的问题。其局部极值一定是全局极值。

• 最近的一些研究表明，某些局部极值并没有想象中的那么糟糕，它们已经非常的接近全局极值所带来的结果了。


鞍点

除了Local Minima，在梯度下降的过程中，还有可能遇到另外一种情况，即：鞍点（Saddle Point）。鞍点指的是我们找到点某个点确实是梯度为0，但它却不是函数的极值，它的周围既有比它小的值，也有比它大的值。这就好像马鞍一样。

如下图所示：

多类随机函数表现出以下性质：在低维空间中，局部极值很普遍。但在高维空间中，局部极值比较少见，而鞍点则很常见。

不过对于鞍点，可以通过数学方法Hessian矩阵来确定。关于这点，这里就不再展开了，有兴趣的读者可以以这里提供的几个链接继续探索。


参考资料与推荐读物

• Wikipeida: Gradient descent

• Sebastian Ruder: An overview of gradient descent optimization algorithms

• 吴恩达：机器学习

• 吴恩达：深度学习

• Peter Flach：机器学习

• 李宏毅 - ML Lecture 3-1: Gradient Descent

• PDF: 李宏毅 - Gradient Descent

• Intro to optimization in deep learning: Gradient Descent

• Intro to optimization in deep learning: Momentum, RMSProp and Adam

• Stochastic Gradient Descent – Mini-batch and more

• 刘建平Pinard - 梯度下降（Gradient Descent）小结

• 多元函数的偏导数、方向导数、梯度以及微分之间的关系思考

• [Machine Learning] 梯度下降法的三种形式BGD、SGD以及MBGD

• 作者：阿Paul https://paul.pub/gradient-descent

❼ 深度学习算法标签怎么输入

深度学习算法标签输入：买同款读写器当然可以改数据，一般数据是加密的，甚至是非对称的公钥加密体系。所以只用读写工具读数据是无意义的。毕竟要解密还需要算法和密钥。

随机梯度下降法(Stochastic Gradient Descent)——SGD，小批量梯度下降——mini-batch GD动量梯度下降——Momentum，均方根算法(root mean square prop) ——RMSprop，自适应矩估计(Adaptive Moment Estimation)——Adam。

区别于传统的浅层学习，深度学习的不同在于：

(1)强调了模型结构的深度，通常有5层、6层，甚至10多层的隐层节点。

(2)明确了特征学习的重要性。也就是说，通过逐层特征变换，将样本在原空间的特征表示变换到一个新特征空间，从而使分类或预测更容易。与人工规则构造特征的方法相比，利用大数据来学习特征，更能够刻画数据丰富的内在信息。

通过设计建立适量的神经元计算节点和多层运算层次结构，选择合适的输人层和输出层，通过网络的学习和调优，建立起从输入到输出的函数关系。

❽ e的x减一次方的导数

e的x减一次方的导数是e^(x-1)。

具体解法如下：

e的x减一次方，即为e^(x-1)

e的x减一次方的导数，即为e^(x-1)的导数

e^(x-1)'=e^(x-1)*(1)=e^(x-1)

所以e的x减一次方的导数是e^(x-1)。

(8)rmsprop算法扩展阅读

导数的求解注意点：

1、理解并牢记导数定义。导数定义中一定要出现这一点的函数值，如果已知告诉等于零，那极限表达式中就可以不出现，否就不能推出在这一点可导。

2、导数定义相关计算。这里有几种题型：1)已知某点处导数存在，计算极限，这需要掌握导数的广义化形式，还要注意是在这一点处导数存在的前提下，否则是不一定成立的。

3、导数、可微与连续的关系。函数在一点处可导与可微是等价的，可以推出在这一点处是连续的，反过来则是不成立的。

4、导数的计算。导数的计算可以说在每一年的考研数学中都会涉及到，而且形式不一，考查的方法也不同。

5、高阶导数计算。需要同学们记住几个常见的高阶导数公式，将其他函数都转化成我们这几种常见的函数，代入公式就可以了，也有通过求一阶导数，二阶，三阶的方法来找出他们之间关系的。

❾ 10的三次方怎么稀释梯度

这个复杂，需要了解方法。可以用到两三种方法。
十倍梯度稀释法(倍比稀释和梯度稀释)：
梯度下降是寻找函数极小值的优化方法，在深度学习模型中常用于在反向传播过程中更新神经网络的权重。

梯度下降优化算法功能是什么？

梯度下降，优化算法发挥了以下三个主要方面的作用：
1、学习率成分、或

2、修正坡度成分L/W
3或2者
让我们看看下面的公式1。
方程1 :随机梯度下降中的各种量
学习率调度器vs梯度下降优化的主要区别在于，梯度下降优化是将学习率乘以梯度的函数即因子来调整学习率成分，而学习率调度器是将学习率乘以一定的常数或关于时间步的函数的因子来更新学习率。
第一种方法主要是通过将学习率(learning rate )乘以0到1之间的因子来降低学习率)例如RMSprop。 第二种方法通常使用坡度(Gradient )的滑动平均(也称为动量)而不是纯坡度来确定下降方向。 第三种方法是将Adam和AMSGrad这样的两者结合起来。

Fig.2 )各类梯度下降优化算法、其发表年和使用的核心思路。
Fig.3自上而下，展示了这些优化算法是如何从最简单的简单梯度下降(SGD )进化到Adam的各种变种的。 SGD最初分别向两个方向发展，一个是AdaGrad，主要调整学习率(learning rate )。 另一个是Momentum，主要调整梯度的构成要素。 随着进化的发展，Momentum和RMSprop一体化，“QS dch”(Adam )诞生了。 你可能会对我这样的组织方式提出异议，但我一直以来都是这样理解的。

Fig.3 )各种最优化算法的进化图(gist ) ) ) ) ) )。

符号表示
t -迭代步数

w -需要更新的权重和参数
-学习率
L/w - L (损失函数)相对于w的梯度
因为我统一了论文中出现的希腊文字和符号表示，所以可以用统一的“进化”的观点来看这些优化算法

1. 随机梯度下降（Stochastic Gradient Descend）
最原始的随机梯度下降算法主要是将当前梯度l/w乘以一个系数学习率来更新模型的权重w。
2. 动量算法（Momentum）

动量算法使用具有动量的坡度(坡度的指数滑动平均、Polyak、1964 )而不是当前坡度来更新w。 在后续的文章中，我们会发现采用指数滑动平均作为动量更新方法几乎已经成为行业标准。
另外，v初始化值为0。 通常设定为0.9。

值得注意的是，许多文章在引用Momemtum算法时都使用年轻花瓣Qian，1999的文章。 但是，该算法的原始来源是Sutskever et al。 另一方面，经典动量算法是1964年由Polyak提出的，因此上述也引用了Polyak的文章。 (谢谢James指出这一点)
3.Nesterov加速梯度下降法（NAG）

是在Polyak提出动量法后(双关： Polyak势)
头正盛），一个使用Nesterov加速梯度下降法(Sutskever et al., 2013)的类似更新方法也被实现了。此更新方法使用V，即我称之为投影梯度的指数移动平均值。

其中

且V 初始化为0。
第二个等式中的最后一项就是一个投影梯度。这个值可以通过使用先前的速度“前进一步”获得（等式4）。这意味着对于这个时间步骤t，我们必须在最终执行反向传播之前执行另一个前向传播。这是步骤：
1.使用先前的速度将当前权重w更新为投影权重w*
（等式4）
2. 使用投影权重计算前向传播
3.获得投影梯度∂L/∂w*
4.计算相应的V和w
常见的默认值：
β = 0.9
请注意，原始的Nesterov 加速梯度下降法论文（ Nesterov, 1983 ）并不是关于随机梯度下降，也没有明确使用梯度下降方程。因此，更合适的参考是上面提到的Sutskever等人的出版物。在2013年，它描述了NAG在随机梯度下降中的应用。（再一次，我要感谢James对HackerNews的评论中指出这一点。）