中国工程建设工程造价管理协会网站,做暧暧视频网站在线,网站建设服务器是什么,常州中环互联网网站建设11.6 Momentum
在 Section 11.4 中#xff0c;我们提到#xff0c;目标函数有关自变量的梯度代表了目标函数在自变量当前位置下降最快的方向。因此#xff0c;梯度下降也叫作最陡下降#xff08;steepest descent#xff09;。在每次迭代中#xff0c;梯度下降根据自变量…11.6 Momentum
在 Section 11.4 中我们提到目标函数有关自变量的梯度代表了目标函数在自变量当前位置下降最快的方向。因此梯度下降也叫作最陡下降steepest descent。在每次迭代中梯度下降根据自变量当前位置沿着当前位置的梯度更新自变量。然而如果自变量的迭代方向仅仅取决于自变量当前位置这可能会带来一些问题。对于noisy gradient,我们需要谨慎的选取学习率和batch size, 来控制梯度方差和收敛的结果。 An ill-conditioned Problem
Condition Number of Hessian Matrix: where is the maximum amd minimum eignvalue of Hessian matrix.
让我们考虑一个输入和输出分别为二维向量和标量的目标函数: Maximum Learning Rate
For , according to convex optimizaiton conclusions, we need step size .To guarantee the convergence, we need to have .
Supp: Preconditioning
在二阶优化中我们使用Hessian matrix的逆矩阵(或者pseudo inverse)来左乘梯度向量 这样的做法称为precondition相当于将 映射为一个单位矩阵拥有分布均匀的Spectrum也即我们去优化的等价标函数的Hessian matrix为良好的identity matrix。
与Section 11.4一节中不同这里将系数从减小到了。下面实现基于这个目标函数的梯度下降并演示使用学习率为时自变量的迭代轨迹。
%matplotlib inline
import sys
sys.path.append(/home/kesci/input)
import d2lzh1981 as d2l
import torcheta 0.4def f_2d(x1, x2):return 0.1 * x1 ** 2 2 * x2 ** 2def 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可以看到同一位置上目标函数在竖直方向轴方向比在水平方向轴方向的斜率的绝对值更大。因此给定学习率梯度下降迭代自变量时会使自变量在竖直方向比在水平方向移动幅度更大。那么我们需要一个较小的学习率从而避免自变量在竖直方向上越过目标函数最优解。然而这会造成自变量在水平方向上朝最优解移动变慢。
下面我们试着将学习率调得稍大一点此时自变量在竖直方向不断越过最优解并逐渐发散。
Solution to ill-condition Preconditioning gradient vector: applied in Adam, RMSProp, AdaGrad, Adelta, KFC, Natural gradient and other secord-order optimization algorithms. Averaging history gradient: like momentum, which allows larger learning rates to accelerate convergence; applied in Adam, RMSProp, SGD momentum.
eta 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))epoch 20, x1 -0.387814, x2 -1673.365109Momentum Algorithm
动量法的提出是为了解决梯度下降的上述问题。设时间步 的自变量为 学习率为 。 在时间步 动量法创建速度变量 并将其元素初始化成 0。在时间步 动量法对每次迭代的步骤做如下修改 Another version: 其中动量超参数 满足 。当 时动量法等价于小批量随机梯度下降。
在解释动量法的数学原理前让我们先从实验中观察梯度下降在使用动量法后的迭代轨迹。
def momentum_2d(x1, x2, v1, v2):v1 beta * v1 eta * 0.2 * x1v2 beta * v2 eta * 4 * x2return x1 - v1, x2 - v2, v1, v2eta, beta 0.4, 0.5
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))epoch 20, x1 -0.062843, x2 0.001202可以看到使用较小的学习率 和动量超参数 时动量法在竖直方向上的移动更加平滑且在水平方向上更快逼近最优解。下面使用较大的学习率 此时自变量也不再发散。
eta 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))epoch 20, x1 0.007188, x2 0.002553Exponential Moving Average
为了从数学上理解动量法让我们先解释一下指数加权移动平均exponential moving average。给定超参数 当前时间步 的变量 是上一时间步 的变量 和当前时间步另一变量 的线性组合 我们可以对 展开 Supp
Approximate Average of Steps
令 那么 。因为 所以当 时如 。如果把 当作一个比较小的数我们可以在近似中忽略所有含 和比 更高阶的系数的项。例如当 时 因此在实际中我们常常将 看作是对最近 个时间步的 值的加权平均。例如当 时 可以被看作对最近20个时间步的 值的加权平均当 时 可以看作是对最近10个时间步的 值的加权平均。而且离当前时间步 越近的 值获得的权重越大越接近1。
由指数加权移动平均理解动量法
现在我们对动量法的速度变量做变形 Another version: 由指数加权移动平均的形式可得速度变量 实际上对序列 做了指数加权移动平均。换句话说相比于小批量随机梯度下降动量法在每个时间步的自变量更新量近似于将前者对应的最近 个时间步的更新量做了指数加权移动平均后再除以 。所以在动量法中自变量在各个方向上的移动幅度不仅取决当前梯度还取决于过去的各个梯度在各个方向上是否一致。在本节之前示例的优化问题中所有梯度在水平方向上为正向右而在竖直方向上时正向上时负向下。这样我们就可以使用较大的学习率从而使自变量向最优解更快移动。
Implement
相对于小批量随机梯度下降动量法需要对每一个自变量维护一个同它一样形状的速度变量且超参数里多了动量超参数。实现中我们将速度变量用更广义的状态变量states表示。
def get_data_ch7(): data np.genfromtxt(/home/kesci/input/airfoil4755/airfoil_self_noise.dat, delimiter\t)data (data - data.mean(axis0)) / data.std(axis0)return torch.tensor(data[:1500, :-1], dtypetorch.float32), \torch.tensor(data[:1500, -1], dtypetorch.float32)features, labels get_data_ch7()def init_momentum_states():v_w torch.zeros((features.shape[1], 1), dtypetorch.float32)v_b torch.zeros(1, dtypetorch.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.datap.data - v.data我们先将动量超参数momentum设0.5
d2l.train_ch7(sgd_momentum, init_momentum_states(),{lr: 0.02, momentum: 0.5}, features, labels)loss: 0.243297, 0.057950 sec per epoch将动量超参数momentum增大到0.9
d2l.train_ch7(sgd_momentum, init_momentum_states(),{lr: 0.02, momentum: 0.9}, features, labels)loss: 0.260418, 0.059441 sec per epoch可见目标函数值在后期迭代过程中的变化不够平滑。直觉上10倍小批量梯度比2倍小批量梯度大了5倍我们可以试着将学习率减小到原来的1/5。此时目标函数值在下降了一段时间后变化更加平滑。
d2l.train_ch7(sgd_momentum, init_momentum_states(),{lr: 0.004, momentum: 0.9}, features, labels)loss: 0.243650, 0.063532 sec per epochPytorch Class
在Pytorch中torch.optim.SGD已实现了Momentum。
d2l.train_pytorch_ch7(torch.optim.SGD, {lr: 0.004, momentum: 0.9},features, labels)loss: 0.243692, 0.048604 sec per epochimg srchttps://cdn.kesci.com/rt_upload/061E57E1FC1240988C134FC43E749BEE/q5qodoy8py.svg
11.7 AdaGrad
在之前介绍过的优化算法中目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。举个例子假设目标函数为自变量为一个二维向量该向量中每一个元素在迭代时都使用相同的学习率。例如在学习率为的梯度下降中元素和都使用相同的学习率来自我迭代 在“动量法”一节里我们看到当和的梯度值有较大差别时需要选择足够小的学习率使得自变量在梯度值较大的维度上不发散。但这样会导致自变量在梯度值较小的维度上迭代过慢。动量法依赖指数加权移动平均使得自变量的更新方向更加一致从而降低发散的可能。本节我们介绍AdaGrad算法它根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率从而避免统一的学习率难以适应所有维度的问题 [1]。
Algorithm
AdaGrad算法会使用一个小批量随机梯度按元素平方的累加变量。在时间步0AdaGrad将中每个元素初始化为0。在时间步首先将小批量随机梯度按元素平方后累加到变量 其中是按元素相乘。接着我们将目标函数自变量中每个元素的学习率通过按元素运算重新调整一下 其中是学习率是为了维持数值稳定性而添加的常数如。这里开方、除法和乘法的运算都是按元素运算的。这些按元素运算使得目标函数自变量中每个元素都分别拥有自己的学习率。
Feature
需要强调的是小批量随机梯度按元素平方的累加变量出现在学习率的分母项中。因此如果目标函数有关自变量中某个元素的偏导数一直都较大那么该元素的学习率将下降较快反之如果目标函数有关自变量中某个元素的偏导数一直都较小那么该元素的学习率将下降较慢。然而由于一直在累加按元素平方的梯度自变量中每个元素的学习率在迭代过程中一直在降低或不变。所以当学习率在迭代早期降得较快且当前解依然不佳时AdaGrad算法在迭代后期由于学习率过小可能较难找到一个有用的解。
下面我们仍然以目标函数为例观察AdaGrad算法对自变量的迭代轨迹。我们实现AdaGrad算法并使用和上一节实验中相同的学习率0.4。可以看到自变量的迭代轨迹较平滑。但由于的累加效果使学习率不断衰减自变量在迭代后期的移动幅度较小。
%matplotlib inline
import math
import torch
import sys
sys.path.append(/home/kesci/input)
import d2lzh1981 as d2ldef adagrad_2d(x1, x2, s1, s2):g1, g2, eps 0.2 * x1, 4 * x2, 1e-6 # 前两项为自变量梯度s1 g1 ** 2s2 g2 ** 2x1 - eta / math.sqrt(s1 eps) * g1x2 - eta / math.sqrt(s2 eps) * g2return x1, x2, s1, s2def f_2d(x1, x2):return 0.1 * x1 ** 2 2 * x2 ** 2eta 0.4
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))epoch 20, x1 -2.382563, x2 -0.158591下面将学习率增大到2。可以看到自变量更为迅速地逼近了最优解。
eta 2
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))epoch 20, x1 -0.002295, x2 -0.000000Implement
同动量法一样AdaGrad算法需要对每个自变量维护同它一样形状的状态变量。我们根据AdaGrad算法中的公式实现该算法。
def get_data_ch7(): data np.genfromtxt(/home/kesci/input/airfoil4755/airfoil_self_noise.dat, delimiter\t)data (data - data.mean(axis0)) / data.std(axis0)return torch.tensor(data[:1500, :-1], dtypetorch.float32), \torch.tensor(data[:1500, -1], dtypetorch.float32)features, labels get_data_ch7()def init_adagrad_states():s_w torch.zeros((features.shape[1], 1), dtypetorch.float32)s_b torch.zeros(1, dtypetorch.float32)return (s_w, s_b)def adagrad(params, states, hyperparams):eps 1e-6for p, s in zip(params, states):s.data (p.grad.data**2)p.data - hyperparams[lr] * p.grad.data / torch.sqrt(s eps)使用更大的学习率来训练模型。
d2l.train_ch7(adagrad, init_adagrad_states(), {lr: 0.1}, features, labels)loss: 0.242258, 0.061548 sec per epochPytorch Class
通过名称为“adagrad”的Trainer实例我们便可使用Pytorch提供的AdaGrad算法来训练模型。
d2l.train_pytorch_ch7(torch.optim.Adagrad, {lr: 0.1}, features, labels)loss: 0.243800, 0.060953 sec per epoch11.8 RMSProp
我们在“AdaGrad算法”一节中提到因为调整学习率时分母上的变量一直在累加按元素平方的小批量随机梯度所以目标函数自变量每个元素的学习率在迭代过程中一直在降低或不变。因此当学习率在迭代早期降得较快且当前解依然不佳时AdaGrad算法在迭代后期由于学习率过小可能较难找到一个有用的解。为了解决这一问题RMSProp算法对AdaGrad算法做了修改。该算法源自Coursera上的一门课程即“机器学习的神经网络”。
Algorithm
我们在“动量法”一节里介绍过指数加权移动平均。不同于AdaGrad算法里状态变量是截至时间步所有小批量随机梯度按元素平方和RMSProp算法将这些梯度按元素平方做指数加权移动平均。具体来说给定超参数计算 和AdaGrad算法一样RMSProp算法将目标函数自变量中每个元素的学习率通过按元素运算重新调整然后更新自变量 其中是学习率是为了维持数值稳定性而添加的常数如。因为RMSProp算法的状态变量是对平方项的指数加权移动平均所以可以看作是最近个时间步的小批量随机梯度平方项的加权平均。如此一来自变量每个元素的学习率在迭代过程中就不再一直降低或不变。
照例让我们先观察RMSProp算法对目标函数中自变量的迭代轨迹。回忆在“AdaGrad算法”一节使用的学习率为0.4的AdaGrad算法自变量在迭代后期的移动幅度较小。但在同样的学习率下RMSProp算法可以更快逼近最优解。
%matplotlib inline
import math
import torch
import sys
sys.path.append(/home/kesci/input)
import d2lzh1981 as d2ldef rmsprop_2d(x1, x2, s1, s2):g1, g2, eps 0.2 * x1, 4 * x2, 1e-6s1 beta * s1 (1 - beta) * g1 ** 2s2 beta * s2 (1 - beta) * g2 ** 2x1 - alpha / math.sqrt(s1 eps) * g1x2 - alpha / math.sqrt(s2 eps) * g2return x1, x2, s1, s2def f_2d(x1, x2):return 0.1 * x1 ** 2 2 * x2 ** 2alpha, beta 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))epoch 20, x1 -0.010599, x2 0.000000Implement
接下来按照RMSProp算法中的公式实现该算法。
def get_data_ch7(): data np.genfromtxt(/home/kesci/input/airfoil4755/airfoil_self_noise.dat, delimiter\t)data (data - data.mean(axis0)) / data.std(axis0)return torch.tensor(data[:1500, :-1], dtypetorch.float32), \torch.tensor(data[:1500, -1], dtypetorch.float32)features, labels get_data_ch7()def init_rmsprop_states():s_w torch.zeros((features.shape[1], 1), dtypetorch.float32)s_b torch.zeros(1, dtypetorch.float32)return (s_w, s_b)def rmsprop(params, states, hyperparams):gamma, eps hyperparams[beta], 1e-6for p, s in zip(params, states):s.data gamma * s.data (1 - gamma) * (p.grad.data)**2p.data - hyperparams[lr] * p.grad.data / torch.sqrt(s eps)我们将初始学习率设为0.01并将超参数设为0.9。此时变量可看作是最近个时间步的平方项的加权平均。
d2l.train_ch7(rmsprop, init_rmsprop_states(), {lr: 0.01, beta: 0.9},features, labels)loss: 0.243334, 0.063004 sec per epochPytorch Class
通过名称为“rmsprop”的Trainer实例我们便可使用Gluon提供的RMSProp算法来训练模型。注意超参数通过gamma1指定。
d2l.train_pytorch_ch7(torch.optim.RMSprop, {lr: 0.01, alpha: 0.9},features, labels)loss: 0.244934, 0.062977 sec per epoch11.9 AdaDelta
除了RMSProp算法以外另一个常用优化算法AdaDelta算法也针对AdaGrad算法在迭代后期可能较难找到有用解的问题做了改进 [1]。有意思的是AdaDelta算法没有学习率这一超参数。
Algorithm
AdaDelta算法也像RMSProp算法一样使用了小批量随机梯度按元素平方的指数加权移动平均变量。在时间步0它的所有元素被初始化为0。给定超参数同RMSProp算法一样计算 与RMSProp算法不同的是AdaDelta算法还维护一个额外的状态变量其元素同样在时间步0时被初始化为0。我们使用来计算自变量的变化量 其中是为了维持数值稳定性而添加的常数如。接着更新自变量 最后我们使用来记录自变量变化量按元素平方的指数加权移动平均 可以看到如不考虑的影响AdaDelta算法与RMSProp算法的不同之处在于使用来替代超参数。
Implement
AdaDelta算法需要对每个自变量维护两个状态变量即和。我们按AdaDelta算法中的公式实现该算法。
def init_adadelta_states():s_w, s_b torch.zeros((features.shape[1], 1), dtypetorch.float32), torch.zeros(1, dtypetorch.float32)delta_w, delta_b torch.zeros((features.shape[1], 1), dtypetorch.float32), torch.zeros(1, dtypetorch.float32)return ((s_w, delta_w), (s_b, delta_b))def adadelta(params, states, hyperparams):rho, eps hyperparams[rho], 1e-5for p, (s, delta) in zip(params, states):s[:] rho * s (1 - rho) * (p.grad.data**2)g p.grad.data * torch.sqrt((delta eps) / (s eps))p.data - gdelta[:] rho * delta (1 - rho) * g * gd2l.train_ch7(adadelta, init_adadelta_states(), {rho: 0.9}, features, labels)loss: 0.243485, 0.084914 sec per epochPytorch Class
通过名称为“adadelta”的Trainer实例我们便可使用pytorch提供的AdaDelta算法。它的超参数可以通过rho来指定。
d2l.train_pytorch_ch7(torch.optim.Adadelta, {rho: 0.9}, features, labels)loss: 0.267756, 0.061329 sec per epoch11.10 Adam
Adam算法在RMSProp算法基础上对小批量随机梯度也做了指数加权移动平均 [1]。下面我们来介绍这个算法。
Algorithm
Adam算法使用了动量变量和RMSProp算法中小批量随机梯度按元素平方的指数加权移动平均变量并在时间步0将它们中每个元素初始化为0。给定超参数算法作者建议设为0.9时间步的动量变量即小批量随机梯度的指数加权移动平均 和RMSProp算法中一样给定超参数算法作者建议设为0.999 将小批量随机梯度按元素平方后的项做指数加权移动平均得到 由于我们将和中的元素都初始化为0 在时间步我们得到。将过去各时间步小批量随机梯度的权值相加得到 。需要注意的是当较小时过去各时间步小批量随机梯度权值之和会较小。例如当时。为了消除这样的影响对于任意时间步我们可以将再除以从而使过去各时间步小批量随机梯度权值之和为1。这也叫作偏差修正。在Adam算法中我们对变量和均作偏差修正 接下来Adam算法使用以上偏差修正后的变量和将模型参数中每个元素的学习率通过按元素运算重新调整 其中是学习率是为了维持数值稳定性而添加的常数如。和AdaGrad算法、RMSProp算法以及AdaDelta算法一样目标函数自变量中每个元素都分别拥有自己的学习率。最后使用迭代自变量 Implement
我们按照Adam算法中的公式实现该算法。其中时间步通过hyperparams参数传入adam函数。
%matplotlib inline
import torch
import sys
sys.path.append(/home/kesci/input)
import d2lzh1981 as d2ldef get_data_ch7(): data np.genfromtxt(/home/kesci/input/airfoil4755/airfoil_self_noise.dat, delimiter\t)data (data - data.mean(axis0)) / data.std(axis0)return torch.tensor(data[:1500, :-1], dtypetorch.float32), \torch.tensor(data[:1500, -1], dtypetorch.float32)features, labels get_data_ch7()def init_adam_states():v_w, v_b torch.zeros((features.shape[1], 1), dtypetorch.float32), torch.zeros(1, dtypetorch.float32)s_w, s_b torch.zeros((features.shape[1], 1), dtypetorch.float32), torch.zeros(1, dtypetorch.float32)return ((v_w, s_w), (v_b, s_b))def adam(params, states, hyperparams):beta1, beta2, eps 0.9, 0.999, 1e-6for p, (v, s) in zip(params, states):v[:] beta1 * v (1 - beta1) * p.grad.datas[:] beta2 * s (1 - beta2) * p.grad.data**2v_bias_corr v / (1 - beta1 ** hyperparams[t])s_bias_corr s / (1 - beta2 ** hyperparams[t])p.data - hyperparams[lr] * v_bias_corr / (torch.sqrt(s_bias_corr) eps)hyperparams[t] 1d2l.train_ch7(adam, init_adam_states(), {lr: 0.01, t: 1}, features, labels)loss: 0.242722, 0.089254 sec per epochPytorch Class
d2l.train_pytorch_ch7(torch.optim.Adam, {lr: 0.01}, features, labels)loss: 0.242389, 0.073228 sec per epoch
