Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
OpenDocCN
d2l-zh
提交
6345c65a
D
d2l-zh
项目概览
OpenDocCN
/
d2l-zh
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
D
d2l-zh
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
6345c65a
编写于
8月 21, 2018
作者:
A
Aston Zhang
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
revise momentum and adagrad
上级
7d1a13a6
变更
3
显示空白变更内容
内联
并排
Showing
3 changed file
with
38 addition
and
184 deletion
+38
-184
chapter_deep-learning-basics/softmax-regression.md
chapter_deep-learning-basics/softmax-regression.md
+2
-4
chapter_optimization/adagrad.md
chapter_optimization/adagrad.md
+16
-56
chapter_optimization/momentum.md
chapter_optimization/momentum.md
+20
-124
未找到文件。
chapter_deep-learning-basics/softmax-regression.md
浏览文件 @
6345c65a
...
...
@@ -39,11 +39,9 @@ $$\hat{y}_1, \hat{y}_2, \hat{y}_3 = \text{softmax}(o_1, o_2, o_3),$$
其中
$$
\b
egin{aligned}
\h
at{y}_1 =
\f
rac{
\e
xp(o_1)}{
\s
um_{i=1}^3
\e
xp(o_i)},
\\
\h
at{y}_2 =
\f
rac{
\e
xp(o_2)}{
\s
um_{i=1}^3
\e
xp(o_i)},
\\
\h
at{y}_1 =
\f
rac{
\e
xp(o_1)}{
\s
um_{i=1}^3
\e
xp(o_i)},
\q
uad
\h
at{y}_2 =
\f
rac{
\e
xp(o_2)}{
\s
um_{i=1}^3
\e
xp(o_i)},
\q
uad
\h
at{y}_3 =
\f
rac{
\e
xp(o_3)}{
\s
um_{i=1}^3
\e
xp(o_i)}.
\e
nd{aligned}
$$
容易看出$
\h
at{y}_1 +
\h
at{y}_2 +
\h
at{y}_3 = 1$且$
\h
at{y}_1 > 0,
\h
at{y}_2 > 0,
\h
at{y}_3 > 0$,因此$
\h
at{y}_1,
\h
at{y}_2,
\h
at{y}_3$是一个合法的概率分布。这时候,如果$
\h
at y_2=0.8$,不管其他两个值多少,我们都知道有80%概率图片里是猫。此外,可以注意到
...
...
chapter_optimization/adagrad.md
浏览文件 @
6345c65a
...
...
@@ -8,30 +8,31 @@ x_1 \leftarrow x_1 - \eta \frac{\partial{f}}{\partial{x_1}}, \quad
x_2
\l
eftarrow x_2 -
\e
ta
\f
rac{
\p
artial{f}}{
\p
artial{x_2}}.
$$
在
[
“动量法”
](
./momentum.md
)
一节里我们看到当$x_1$和$x_2$的梯度值有较大差别时
(我们使用的例子是20倍不同),我们需要选择足够小的学习率使得梯度较大的维度不发散,但这样会导致梯度较小的维度收敛缓慢。动量依赖指数加权移动平均来使得自变量的更新方向更加一致来降低发散可能。这一节我们介绍Adagrad算法,它根据每个维度的数值大小来自动调整
学习率,从而避免统一的学习率难以适应所有维度的问题。
在
[
“动量法”
](
./momentum.md
)
一节里我们看到当$x_1$和$x_2$的梯度值有较大差别时
,我们需要选择足够小的学习率使得自变量在梯度值较大的维度上不发散。但这样会导致自变量在梯度值较小的维度上迭代过慢。动量法依赖指数加权移动平均使得自变量的更新方向更加一致,从而降低发散的可能。这一节我们介绍Adagrad算法,它根据自变量在每个维度的梯度值的大小来调整各个维度上的
学习率,从而避免统一的学习率难以适应所有维度的问题。
## Adagrad算法
Adagrad的算法
对每个维度维护其所有时间步里梯度的平法累加。在算法开始前我们定义累加变量$
\b
oldsymbol{s}$,其元素个数等于自变量的个数,并将其中每个元素初始化为0。在每次迭代中,假设小批量随机梯度为$
\b
oldsymbol{g}$,我们将该梯度按元素平方后累加到变量$
\b
oldsymbol{s}$里
:
Adagrad的算法
会使用一个小批量随机梯度按元素平方的累加变量$
\b
oldsymbol{s}$,其形状与自变量形状相同。开始时将变量$
\b
oldsymbol{s}$中每个元素初始化为0。在每次迭代中,首先计算小批量随机梯度$
\b
oldsymbol{g}$,然后将该梯度按元素平方后累加到变量$
\b
oldsymbol{s}$
:
$$
\b
oldsymbol{s}
\l
eftarrow
\b
oldsymbol{s} +
\b
oldsymbol{g}
\o
dot
\b
oldsymbol{g},
$$
$$
\b
oldsymbol{s}
\l
eftarrow
\b
oldsymbol{s} +
\b
oldsymbol{g}
\o
dot
\b
oldsymbol{g},$$
这里$
\o
dot$是按元素相乘(请参见
[
“数学基础”
](
../chapter_appendix/math.md
)
一节)。
其中$
\o
dot$是按元素相乘(请参见
[
“数学基础”
](
../chapter_appendix/math.md
)
一节)。接着,我们将目标函数自变量中每个元素的学习率通过按元素运算重新调整一下:
在自变量更新前,我们将梯度中的每个元素除以累加变量中对应元素的平方根,这样使得每个元素数值在同样的尺度下,然后再乘以学习率后更新:
$$
\b
oldsymbol{g}'
\l
eftarrow
\f
rac{
\e
ta}{
\s
qrt{
\b
oldsymbol{s} +
\e
psilon}}
\o
dot
\b
oldsymbol{g},$$
$$
\b
oldsymbol{x}
\l
eftarrow
\b
oldsymbol{x} -
\f
rac{
\e
ta}{
\s
qrt{
\b
oldsymbol{s} +
\e
psilon}}
\o
dot
\b
oldsymbol{g},$$
其中$
\e
ta$是初始学习率且$
\e
ta > 0$,$
\e
psilon$是为了维持数值稳定性而添加的常数,例如$10^{-7}$。我们需要注意,其中开方、除法和乘法的运算都是按元素进行的。这些按元素运算使得目标函数自变量中每个元素都分别拥有自己的学习率。
这里开方、除法和乘法的运算都是按元素进行的,$
\e
psilon$是为了使得除数不为0来而添加的正常数,例如$10^{-7}$。
最后,自变量的迭代步骤与小批量随机梯度下降类似。只是这里梯度前的学习率已经被调整过了:
## Adagrad特性
$$
\b
oldsymbol{x}
\l
eftarrow
\b
oldsymbol{x} -
\b
oldsymbol{g}'.$$
为了更好的理解累加变量是如何将每个自变量的更新变化到同样尺度,我们来看时间步1时的更新,这时候$
\b
oldsymbol{s} =
\b
oldsymbol{g}
\o
dot
\b
oldsymbol{g}$,忽略掉$
\e
psilon$的话,这时候的更新是$
\b
oldsymbol{x}
\l
eftarrow
\b
oldsymbol{x} -
\e
ta
\c
dot
\t
extrm{sign}(
\b
oldsymbol{g})$,这里$
\t
extrm{sign}$是按元素的取符号。就是说,不管梯度具体值是多少,此时的每个自变量的更新量只是$
\e
ta$,$-
\e
ta$或0。
从另一个角度来看,如果自变量中某个元素取值总是另外一个元素的数倍,例如$x_2=20x_1$,那么其梯度也是20被的关系,那么在Adagrad里这两个元素的更新量总是一样,而不是20倍的关系。
此外,由于累加变量里我们总是累加,所以其会变得越来越大,等效于我们一直减低学习率。例如如果每个时间步的梯度都是常数$c$,那么时间步$t$的学习率就是$
\f
rac{
\e
ta}{c
\s
qrt{t}}$,其以平方根的速度依次递减。
## Adagrad的特点
需要强调的是,小批量随机梯度按元素平方的累加变量$
\b
oldsymbol{s}$出现在含调整后学习率的梯度$
\b
oldsymbol{g}'$的分母项。因此,如果目标函数有关自变量中某个元素的偏导数一直都较大,那么就让该元素的学习率下降快一点;反之,如果目标函数有关自变量中某个元素的偏导数一直都较小,那么就让该元素的学习率下降慢一点。然而,由于$
\b
oldsymbol{s}$一直在累加按元素平方的梯度,自变量中每个元素的学习率在迭代过程中一直在降低(或不变)。所以,当学习率在迭代早期降得较快且当前解依然不佳时,Adagrad在迭代后期由于学习率过小,可能较难找到一个有用的解。
...
...
@@ -50,49 +51,7 @@ import numpy as np
import math
```
我们先实现一个简单的针对二维目标函数$f(
\b
oldsymbol{x})=0.1x_1^2+2x_2$的Adagrad来查看其自变量更新轨迹。
```
{.python .input}
f = lambda x1, x2: 0.1*x1**2 + 2*x2**2
f_grad = lambda x1, x2: (0.2*x1, 2*x2)
def adagrad(eta):
x1, x2 = -5, -2
sx1, sx2 = 0, 0
eps = 1e-7
res = [(x1, x2)]
for i in range(15):
gx1, gx2 = f_grad(x1, x2)
sx1 += gx1 ** 2
sx2 += gx2 ** 2
x1 -= eta / math.sqrt(sx1 + eps) * gx1
x2 -= eta / math.sqrt(sx2 + eps) * gx2
res.append((x1, x2))
return res
def show(res):
x1, x2 = zip(*res)
gb.set_figsize((3.5, 2.5))
gb.plt.plot(x1, x2, '-o')
x1 = np.arange(-5.0, 1.0, .1)
x2 = np.arange(min(-3.0, min(x2)-1), max(3.0, max(x2)+1), .1)
x1, x2 = np.meshgrid(x1, x2)
gb.plt.contour(x1, x2, f(x1, x2), colors='g')
gb.plt.xlabel('x1')
gb.plt.ylabel('x2')
show(adagrad(.9))
```
可以看到使用$
\e
ta=0.9$,Adagrad的更新轨迹非常平滑。但由于其自有的降低学习率特性,我们看到在后期收敛比较缓慢。这个特性同样也使得我们可以在Adagrad中使用更大的学习率。
```
{.python .input}
show(adagrad(2))
```
接下来我们以之前介绍过的线性回归为例。设数据集的样本数为1000,我们使用权重
`w`
为[2, -3.4],偏差
`b`
为4.2的线性回归模型来生成数据集。该模型的平方损失函数即所需优化的目标函数,模型参数即目标函数自变量。
实验中,我们以之前介绍过的线性回归为例。设数据集的样本数为1000,我们使用权重
`w`
为[2, -3.4],偏差
`b`
为4.2的线性回归模型来生成数据集。该模型的平方损失函数即所需优化的目标函数,模型参数即目标函数自变量。
我们把梯度按元素平方的累加变量初始化为和模型参数形状相同的零张量。
...
...
@@ -119,7 +78,7 @@ def init_params():
return params, sqrs
```
接下来基于NDArray
来实现Adagrad
。
接下来基于NDArray
实现Adagrad算法
。
```
{.python .input n=1}
def adagrad(params, sqrs, lr, batch_size):
...
...
@@ -148,7 +107,8 @@ def optimize(batch_size, lr, num_epochs, log_interval):
adagrad([w, b], sqrs, lr, batch_size)
if batch_i * batch_size % log_interval == 0:
ls.append(loss(net(features, w, b), labels).mean().asnumpy())
print('w:', w, '\nb:', b, '\n')
print('w[0]=%.2f, w[1]=%.2f, b=%.2f'
% (w[0].asscalar(), w[1].asscalar(), b.asscalar()))
es = np.linspace(0, num_epochs, len(ls), endpoint=True)
gb.semilogy(es, ls, 'epoch', 'loss')
```
...
...
chapter_optimization/momentum.md
浏览文件 @
6345c65a
因为 它太大了无法显示 source diff 。你可以改为
查看blob
。
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录