Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
li工
apachecn-dl-zh
提交
bde7f870
A
apachecn-dl-zh
项目概览
li工
/
apachecn-dl-zh
与 Fork 源项目一致
Fork自
OpenDocCN / apachecn-dl-zh
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
A
apachecn-dl-zh
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
bde7f870
编写于
1月 19, 2021
作者:
W
wizardforcel
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
2021-01-19 14:20:45
上级
ccf1e239
变更
7
隐藏空白更改
内联
并排
Showing
7 changed file
with
23 addition
and
19 deletion
+23
-19
new/pt-tut-17/04.md
new/pt-tut-17/04.md
+8
-6
new/pt-tut-17/21.md
new/pt-tut-17/21.md
+1
-1
new/pt-tut-17/22.md
new/pt-tut-17/22.md
+2
-2
new/pt-tut-17/27.md
new/pt-tut-17/27.md
+1
-1
new/pt-tut-17/34.md
new/pt-tut-17/34.md
+4
-4
new/pt-tut-17/35.md
new/pt-tut-17/35.md
+6
-4
new/pt-tut-17/56.md
new/pt-tut-17/56.md
+1
-1
未找到文件。
new/pt-tut-17/04.md
浏览文件 @
bde7f870
...
...
@@ -73,7 +73,7 @@ b = torch.tensor([6., 4.], requires_grad=True)
我们从
`a`
和
`b`
创建另一个张量
`Q`
。
\[
Q = 3a^3 - b^2
\]
![](
img/tex4-1.gif
)
```
py
Q
=
3
`a`
3
-
b
**
2
...
...
@@ -82,13 +82,15 @@ Q = 3`a`3 - b**2
假设
`a`
和
`b`
是神经网络的参数,
`Q`
是错误。 在 NN 训练中,我们想要相对于参数的误差,即
\[\f
rac{
\p
artial Q}{
\p
artial a} = 9a^2
\]
\[\f
rac{
\p
artial Q}{
\p
artial b} = -2b
\]
![](
img/tex4-2.gif
)
![](
img/tex4-3.gif
)
当我们在
`Q`
上调用
`.backward()`
时,Autograd 将计算这些梯度并将其存储在各个张量的
`.grad`
属性中。
我们需要在
`Q.backward()`
中显式传递
`gradient`
参数,因为它是向量。
`gradient`
是与
`Q`
形状相同的张量,它表示
`Q`
相对于本身的梯度,即
\[\f
rac{dQ}{dQ} = 1
\]
![](
img/tex4-4.gif
)
同样,我们也可以将
`Q`
聚合为一个标量,然后隐式地向后调用,例如
`Q.sum().backward()`
。
...
...
@@ -119,17 +121,17 @@ tensor([True, True])
从数学上讲,如果您具有向量值函数
`y = f(x)`
,则
`y`
相对于
`x`
的雅可比矩阵
`J`
:
\[\b
egin{split}J =
\l
eft(
\b
egin{array}{cc}
\f
rac{
\p
artial
\b
f{y}}{
\p
artial x_{1}} & ... &
\f
rac{
\p
artial
\b
f{y}}{
\p
artial x_{n}}
\e
nd{array}
\r
ight) =
\l
eft(
\b
egin{array}{ccc}
\f
rac{
\p
artial y_{1}}{
\p
artial x_{1}} &
\c
dots &
\f
rac{
\p
artial y_{1}}{
\p
artial x_{n}}
\\
\v
dots &
\d
dots &
\v
dots
\\
\f
rac{
\p
artial y_{m}}{
\p
artial x_{1}} &
\c
dots &
\f
rac{
\p
artial y_{m}}{
\p
artial x_{n}}
\e
nd{array}
\r
ight)
\e
nd{split}
\]
![](
img/tex4-5.gif
)
一般来说,
`torch.autograd`
是用于计算向量雅可比积的引擎。 也就是说,给定任何向量
`v`
,计算乘积
`J^T · v`
如果
`v`
恰好是标量函数的梯度
\[
l = g
\l
eft(
\v
ec{y}
\r
ight) =
\l
eft(
\b
egin{array}{ccc}
\f
rac{
\p
artial l}{
\p
artial y_{1}} &
\c
dots &
\f
rac{
\p
artial l}{
\p
artial y_{m}}
\e
nd{array}
\r
ight)^{T}
\]
![](
img/tex4-6.gif
)
然后根据链式规则,向量-雅可比积将是
`l`
相对于
`x`
的梯度:
\[\b
egin{split}J^{T}
\c
dot
\v
ec{v}=
\l
eft(
\b
egin{array}{ccc}
\f
rac{
\p
artial y_{1}}{
\p
artial x_{1}} &
\c
dots &
\f
rac{
\p
artial y_{m}}{
\p
artial x_{1}}
\\
\v
dots &
\d
dots &
\v
dots
\\
\f
rac{
\p
artial y_{1}}{
\p
artial x_{n}} &
\c
dots &
\f
rac{
\p
artial y_{m}}{
\p
artial x_{n}}
\e
nd{array}
\r
ight)
\l
eft(
\b
egin{array}{c}
\f
rac{
\p
artial l}{
\p
artial y_{1}}
\\
\v
dots
\\
\f
rac{
\p
artial l}{
\p
artial y_{m}}
\e
nd{array}
\r
ight)=
\l
eft(
\b
egin{array}{c}
\f
rac{
\p
artial l}{
\p
artial x_{1}}
\\
\v
dots
\\
\f
rac{
\p
artial l}{
\p
artial x_{n}}
\e
nd{array}
\r
ight)
\e
nd{split}
\]
![](
img/tex4-7.gif
)
上面的示例中使用的是 vector-Jacobian 乘积的这一特征。
`external_grad`
表示
`v`
。
...
...
new/pt-tut-17/21.md
浏览文件 @
bde7f870
...
...
@@ -124,7 +124,7 @@ CUDA Available: True
现在,我们可以通过干扰原始输入来定义创建对抗示例的函数。
`fgsm_attack`
函数接受三个输入,
`image`
是原始的干净图像(
`x`
),
`epsilon`
是像素级扰动量
`ε`
,
`data_grad`
是输入图像损失的梯度(
`ᐁ[x] J(θ, x, y)`
)。 该函数然后创建扰动图像为
\[
perturbed
\_
image = image + epsilon
*sign(data\_grad) = x + \epsilon *
sign(
\n
abla_{x} J(
\m
athbf{
\t
heta},
\m
athbf{x}, y))
\]
![](
img/tex21-1.gif
)
最后,为了维持数据的原始范围,将被扰动的图像裁剪到范围
`[0,1]`
。
...
...
new/pt-tut-17/22.md
浏览文件 @
bde7f870
...
...
@@ -20,7 +20,7 @@ GAN 是用于教授 DL 模型以捕获训练数据分布的框架,因此我们
因此,
`D(G(z))`
是发生器
`G`
的输出是真实图像的概率(标量)。 如
[
Goodfellow 的论文
](
https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf
)
中所述,
`D`
和
`G`
玩一个 minimax 游戏,其中
`D`
试图最大化其正确分类实物和假物
`log D(x)`
,并且
`G`
尝试最小化
`D`
预测其输出为假的概率
`log(1 - D(G(g(x))))`
。 从本文来看,GAN 损失函数为
\[\u
nderset{G}{
\t
ext{min}}
\u
nderset{D}{
\t
ext{max}}V(D,G) =
\m
athbb{E}_{x
\s
im p_{data}(x)}
\b
ig[logD(x)
\b
ig] +
\m
athbb{E}_{z
\s
im p_{z}(z)}
\b
ig[log(1-D(G(z)))
\b
ig]
\]
![](
img/tex22-1.gif
)
从理论上讲,此极小极大游戏的解决方案是
`p_g = p_data`
,判别器会随机猜测输入是真实的还是假的。 但是,GAN 的收敛理论仍在积极研究中,实际上,模型并不总是能达到这一目的。
...
...
@@ -355,7 +355,7 @@ Discriminator(
使用
`D`
和
`G`
设置,我们可以指定它们如何通过损失函数和优化器学习。 我们将使用在 PyTorch 中定义的二进制交叉熵损失(
[
BCELoss
](
https://pytorch.org/docs/stable/nn.html#torch.nn.BCELoss
)
)函数:
\[\e
ll(x, y) = L =
\{
l_1,
\d
ots,l_N
\}
^
\t
op,
\q
uad l_n = -
\l
eft[ y_n
\c
dot
\l
og x_n + (1 - y_n)
\c
dot
\l
og (1 - x_n)
\r
ight]
\]
![](
img/tex22-2.gif
)
请注意,此函数如何提供目标函数中两个对数分量的计算(即
`log D(x)`
和
`log(1 - D(G(z)))`
)。 我们可以指定
`y`
输入使用 BCE 方程的哪一部分。 这是在即将到来的训练循环中完成的,但重要的是要了解我们如何仅通过更改
`y`
(即 GT 标签)即可选择希望计算的分量。
...
...
new/pt-tut-17/27.md
浏览文件 @
bde7f870
...
...
@@ -80,7 +80,7 @@ class PositionalEncoding(nn.Module):
本教程使用
`torchtext`
生成 Wikitext-2 数据集。 vocab 对象是基于训练数据集构建的,用于将标记数字化为张量。 从顺序数据开始,
`batchify()`
函数将数据集排列为列,以修剪掉数据分成大小为
`batch_size`
的批量后剩余的所有令牌。 例如,以字母为序列(总长度为 26)并且批大小为 4,我们将字母分为 4 个长度为 6 的序列:
\[\b
egin{split}
\b
egin{bmatrix}
\t
ext{A} &
\t
ext{B} &
\t
ext{C} &
\l
dots &
\t
ext{X} &
\t
ext{Y} &
\t
ext{Z}
\e
nd{bmatrix}
\R
ightarrow
\b
egin{bmatrix}
\b
egin{bmatrix}
\t
ext{A}
\\
\t
ext{B}
\\
\t
ext{C}
\\
\t
ext{D}
\\
\t
ext{E}
\\
\t
ext{F}
\e
nd{bmatrix} &
\b
egin{bmatrix}
\t
ext{G}
\\
\t
ext{H}
\\
\t
ext{I}
\\
\t
ext{J}
\\
\t
ext{K}
\\
\t
ext{L}
\e
nd{bmatrix} &
\b
egin{bmatrix}
\t
ext{M}
\\
\t
ext{N}
\\
\t
ext{O}
\\
\t
ext{P}
\\
\t
ext{Q}
\\
\t
ext{R}
\e
nd{bmatrix} &
\b
egin{bmatrix}
\t
ext{S}
\\
\t
ext{T}
\\
\t
ext{U}
\\
\t
ext{V}
\\
\t
ext{W}
\\
\t
ext{X}
\e
nd{bmatrix}
\e
nd{bmatrix}
\e
nd{split}
\]
![](
img/tex27-1.gif
)
这些列被模型视为独立的,这意味着无法了解
`G`
和
`F`
的依赖性,但可以进行更有效的批量。
...
...
new/pt-tut-17/34.md
浏览文件 @
bde7f870
...
...
@@ -105,21 +105,21 @@ class ReplayMemory(object):
Q 学习的主要思想是,如果我们有一个函数
`Q*:State x Action => R`
,这可以告诉我们,如果我们取一个 在给定状态下采取行动,那么我们就可以轻松地制定出使我们的回报最大化的策略:
\[\p
i^
*(s) = \arg\!\max_a \ Q^*
(s, a)
\]
![](
img/tex34-1.gif
)
但是,我们对世界一无所知,因此无法访问
`Q*`
。 但是,由于神经网络是通用函数逼近器,因此我们可以简单地创建一个并将其训练为类似于
`Q*`
的函数。
对于我们的训练更新规则,我们将使用一个事实,即某些策略的每个
`Q`
函数都遵循 Bellman 方程:
\[
Q^{
\p
i}(s, a) = r +
\g
amma Q^{
\p
i}(s',
\p
i(s'))
\]
![](
img/tex34-2.gif
)
等式两侧之间的差异称为时间差异误差
`delta`
:
\[\d
elta = Q(s, a) - (r +
\g
amma
\m
ax_a Q(s', a))
\]
![](
img/tex34-3.gif
)
为了最小化此错误,我们将使用
[
Huber 损失
](
https://en.wikipedia.org/wiki/Huber_loss
)
。 当误差较小时,Huber 损耗的作用类似于均方误差,而当误差较大时,则表现为平均绝对误差-当
`Q`
的估计值非常嘈杂时,这使它对异常值的鲁棒性更高。 我们通过从重播内存中采样的一批过渡
`B`
来计算:
\[\m
athcal{L} =
\f
rac{1}{|B|}
\s
um_{(s, a, s', r)
\ \i
n
\
B}
\m
athcal{L}(
\d
elta)
\]
\[\b
egin{split}
\t
ext{where}
\q
uad
\m
athcal{L}(
\d
elta) =
\b
egin{cases}
\f
rac{1}{2}{
\d
elta^2} &
\t
ext{for } |
\d
elta|
\l
e 1,
\\
|
\d
elta| -
\f
rac{1}{2} &
\t
ext{otherwise.}
\e
nd{cases}
\e
nd{split}
\]
![](
img/tex34-4.gif
)
### Q-network
...
...
new/pt-tut-17/35.md
浏览文件 @
bde7f870
...
...
@@ -365,11 +365,13 @@ class MarioNet(nn.Module):
**TD 估计**
-给定状态
`s`
的预测最佳
`Q*`
\[
{TD}_e = Q_{online}^
*
(s,a)
\]
![](
img/tex34-5.gif
)
**TD 目标**
-当前奖励和下一状态
`s'`
中的估计
`Q*`
的汇总
\[
a' = argmax_{a} Q_{online}(s', a)
\]
\[
{TD}_t = r +
\g
amma Q_{target}^
*
(s',a')
\]
![](
img/tex34-6.gif
)
![](
img/tex34-7.gif
)
由于我们不知道下一个动作
`a'`
是什么,因此我们在下一个状态
`s'`
中使用动作
`a'`
最大化
`Q_online`
。
...
...
@@ -402,11 +404,11 @@ class Mario(Mario):
当 Mario 从其重播缓冲区中采样输入时,我们计算
`TD_t`
和
`TD_e`
并反向传播该损耗
`Q_online`
以更新其参数
`θ_online`
(
\
(
\
alpha
\)
是传递给
`optimizer`
的学习率
`lr`
)
\[\t
heta_{online}
\l
eftarrow
\t
heta_{online} +
\a
lpha
\n
abla(TD_e - TD_t)
\]
![](
img/tex34-8.gif
)
`θ_target`
不会通过反向传播进行更新。 相反,我们会定期将
`θ_online`
复制到
`θ_target`
\[\t
heta_{target}
\l
eftarrow
\t
heta_{online}
\]
![](
img/tex34-9.gif
)
```
py
class
Mario
(
Mario
):
...
...
new/pt-tut-17/56.md
浏览文件 @
bde7f870
...
...
@@ -103,7 +103,7 @@ print(torch.__config__.parallel_info())
*
F1 分数的公式为:
\[
F1 = 2
* (\text{precision} *
\t
ext{recall}) / (
\t
ext{precision} +
\t
ext{recall})
\]
![](
img/tex56-1.gif
)
### 1.4 下载数据集
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录