Skip to content
项目
群组
代码片段
帮助
当前项目
正在载入...
登录 / 注册
切换导航面板
M
mtbookv2
概览
Overview
Details
Activity
Cycle Analytics
版本库
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
问题
0
Issues
0
列表
Board
标记
里程碑
合并请求
0
Merge Requests
0
CI / CD
CI / CD
流水线
作业
日程表
图表
维基
Wiki
代码片段
Snippets
成员
Collapse sidebar
Close sidebar
活动
图像
聊天
创建新问题
作业
提交
Issue Boards
Open sidebar
NiuTrans
mtbookv2
Commits
29db5a6d
Commit
29db5a6d
authored
Dec 19, 2020
by
zengxin
Browse files
Options
Browse Files
Download
Plain Diff
合并分支 'zengxin' 到 'caorunzhe'
Zengxin 查看合并请求
!642
parents
bbb125bb
621f1eeb
显示空白字符变更
内嵌
并排
正在显示
3 个修改的文件
包含
43 行增加
和
43 行删除
+43
-43
Chapter10/chapter10.tex
+29
-29
Chapter11/chapter11.tex
+9
-9
Chapter12/chapter12.tex
+5
-5
没有找到文件。
Chapter10/chapter10.tex
查看文件 @
29db5a6d
...
...
@@ -441,13 +441,13 @@ NMT & 21.7 & 18.7 & -13.7 \\
\parinterval
从数学模型上看,神经机器翻译模型与统计机器翻译的目标是一样的:在给定源语言句子
$
\seq
{
x
}$
的情况下,找出翻译概率最大的目标语言译文
$
\hat
{
\seq
{
y
}}$
,其计算如公式
\eqref
{
eq:10-1
}
所示:
\begin{eqnarray}
\hat
{
\seq
{{
y
}}}
=
\argmax
_{
\seq
{{
y
}}}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
\hat
{
\seq
{{
y
}}}
&
=
&
\argmax
_{
\seq
{{
y
}}}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
\label
{
eq:10-1
}
\end{eqnarray}
\noindent
这里,用
$
\seq
{{
x
}}
=
\{
x
_
1
,x
_
2
,..., x
_
m
\}
$
表示输入的源语言单词序列,
$
\seq
{{
y
}}
=
\{
y
_
1
,y
_
2
,..., y
_
n
\}
$
表示生成的目标语言单词序列。由于神经机器翻译在生成译文时采用的是自左向右逐词生成的方式,并在翻译每个单词时考虑已经生成的翻译结果,因此对
$
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
$
的求解可以转换为公式
\eqref
{
eq:10-2
}
所示过程:
\begin{eqnarray}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
=
\prod
_{
j=1
}^{
n
}
\funp
{
P
}
( y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
&
=
&
\prod
_{
j=1
}^{
n
}
\funp
{
P
}
( y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
\label
{
eq:10-2
}
\end{eqnarray}
...
...
@@ -465,12 +465,12 @@ NMT & 21.7 & 18.7 & -13.7 \\
\vspace
{
0.5em
}
\item
如何得到每个目标语言单词的概率,即译文单词的
{
\small\sffamily\bfseries
{
生成
}}
\index
{
生成
}
(Generation)
\index
{
Generation
}
。与神经语言模型一样,可以用一个Softmax输出层来获取当前时刻所有单词的分布,即利用Softmax 函数计算目标语言词表中每个单词的概率。令目标语言序列
$
j
$
时刻的循环神经网络的输出向量(或状态)为
$
\mathbi
{
s
}_
j
$
。根据循环神经网络的性质,
$
y
_
j
$
的生成只依赖前一个状态
$
\mathbi
{
s
}_{
j
-
1
}$
和当前时刻的输入(即词嵌入
$
\textrm
{
e
}_
y
(
y
_{
j
-
1
}
)
$
)。同时考虑源语言信息
$
\mathbi
{
C
}$
,
$
\funp
{
P
}
(
y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
$
可以被重新定义为公式
\eqref
{
eq:10-3
}
:
\begin{eqnarray}
\funp
{
P
}
(y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
=
\funp
{
P
}
(
{
y
_
j |
\mathbi
{
s
}_{
j-1
}
,y
_{
j-1
}
,
\mathbi
{
C
}}
)
\funp
{
P
}
(y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
&
=
&
\funp
{
P
}
(
{
y
_
j |
\mathbi
{
s
}_{
j-1
}
,y
_{
j-1
}
,
\mathbi
{
C
}}
)
\label
{
eq:10-3
}
\end{eqnarray}
$
\funp
{
P
}
(
{
y
_
j |
\mathbi
{
s
}_{
j
-
1
}
,y
_{
j
-
1
}
,
\mathbi
{
C
}}
)
$
由Softmax实现,Softmax的输入是循环神经网络
$
j
$
时刻的输出。在具体实现时,
$
\mathbi
{
C
}$
可以被简单地作为第一个时刻循环单元的输入,即,当
$
j
=
1
$
时,解码器的循环神经网络会读入编码器最后一个隐层状态
$
\mathbi
{
h
}_
m
$
(也就是
$
\mathbi
{
C
}$
),而其他时刻的隐层状态不直接与
$
\mathbi
{
C
}$
相关。最终,
$
\funp
{
P
}
(
y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
$
被表示为公式
\eqref
{
eq:10-4
}
:
\begin{eqnarray}
\funp
{
P
}
(y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
=
\funp
{
P
}
(y
_
j |
\seq
{{
y
}}_{
<j
}
,
\seq
{{
x
}}
)
&
=
&
\left
\{
\begin{array}
{
ll
}
\funp
{
P
}
(y
_
j |
\mathbi
{
C
}
,y
_{
j-1
}
)
&
j=1
\\
\funp
{
P
}
(y
_
j|
\mathbi
{
s
}_{
j-1
}
,y
_{
j-1
}
)
\quad
&
j>1
...
...
@@ -492,7 +492,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
\parinterval
输入层(词嵌入)和输出层(Softmax)的内容已在
{
\chapternine
}
进行了介绍,因此这里的核心内容是设计循环神经网络结构,即设计循环单元的结构。至今,研究人员已经提出了很多优秀的循环单元结构。其中循环神经网络(RNN)
是最原始的循环单元结构。在RNN中,对于序列
$
\seq
{{
x
}}
=
\{
\mathbi
{
x
}_
1
,
\mathbi
{
x
}_
2
,...,
\mathbi
{
x
}_
m
\}
$
,每个时刻
$
t
$
都对应一个循环单元,它的输出是一个向量
$
\mathbi
{
h
}_
t
$
,可以被描述为公式
\eqref
{
eq:10-5
}
:
\begin{eqnarray}
\mathbi
{
h
}_
t
=
f(
\mathbi
{
x
}_
t
\mathbi
{
U
}
+
\mathbi
{
h
}_{
t-1
}
\mathbi
{
W
}
+
\mathbi
{
b
}
)
\mathbi
{
h
}_
t
&
=
&
f(
\mathbi
{
x
}_
t
\mathbi
{
U
}
+
\mathbi
{
h
}_{
t-1
}
\mathbi
{
W
}
+
\mathbi
{
b
}
)
\label
{
eq:10-5
}
\end{eqnarray}
...
...
@@ -529,7 +529,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
\vspace
{
0.5em
}
\item
{
\small\sffamily\bfseries
{
遗忘
}}
\index
{
遗忘
}
。顾名思义,遗忘的目的是忘记一些历史,在LSTM中通过遗忘门实现,其结构如图
\ref
{
fig:10-11
}
(a)所示。
$
\mathbi
{
x
}_{
t
}$
表示时刻
$
t
$
的输入向量,
$
\mathbi
{
h
}_{
t
-
1
}$
是时刻
$
t
-
1
$
的循环单元的输出,
$
\mathbi
{
x
}_{
t
}$
和
$
\mathbi
{
h
}_{
t
-
1
}$
都作为
$
t
$
时刻循环单元的输入。
$
\sigma
$
将对
$
\mathbi
{
x
}_{
t
}$
和
$
\mathbi
{
h
}_{
t
-
1
}$
进行筛选,以决定遗忘的信息,其计算如公式
\eqref
{
eq:10-6
}
所示:
\begin{eqnarray}
\mathbi
{
f
}_
t
=
\sigma
(
\mathbi
{
W
}_
f [
\mathbi
{
h
}_{
t-1
}
,
\mathbi
{
x
}_{
t
}
] +
\mathbi
{
b
}_
f )
\mathbi
{
f
}_
t
&
=
&
\sigma
(
\mathbi
{
W
}_
f [
\mathbi
{
h
}_{
t-1
}
,
\mathbi
{
x
}_{
t
}
] +
\mathbi
{
b
}_
f )
\label
{
eq:10-6
}
\end{eqnarray}
...
...
@@ -543,7 +543,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
之后,用
$
\mathbi
{
i
}_
t
$
点乘
$
\hat
{
\mathbi
{
c
}}_
t
$
,得到当前需要记忆的信息,记为
$
\mathbi
{
i
}_
t
\cdot
\hat
{
\mathbi
{
c
}}_
t
$
。接下来需要更新旧的信息
$
\mathbi
{
c
}_{
t
-
1
}$
,得到新的记忆信息
$
\mathbi
{
c
}_
t
$
,更新的操作如图
\ref
{
fig:10-11
}
(c)红色线部分所示,“
$
\bigoplus
$
”表示相加。具体规则是通过遗忘门选择忘记一部分上文信息
$
\mathbi
{
f
}_
t
$
,通过输入门计算新增的信息
$
\mathbi
{
i
}_
t
\cdot
\hat
{
\mathbi
{
c
}}_
t
$
,然后根据“
$
\bigotimes
$
”门与“
$
\bigoplus
$
”门进行相应的乘法和加法计算,如公式
\eqref
{
eq:10-9
}
:
\begin{eqnarray}
\mathbi
{
c
}_
t
=
\mathbi
{
f
}_
t
\cdot
\mathbi
{
c
}_{
t-1
}
+
\mathbi
{
i
}_
t
\cdot
\hat
{
\mathbi
{
c
}_
t
}
\mathbi
{
c
}_
t
&
=
&
\mathbi
{
f
}_
t
\cdot
\mathbi
{
c
}_{
t-1
}
+
\mathbi
{
i
}_
t
\cdot
\hat
{
\mathbi
{
c
}_
t
}
\label
{
eq:10-9
}
\end{eqnarray}
\vspace
{
-1.0em
}
...
...
@@ -594,13 +594,13 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
\parinterval
当完成了重置门和更新门计算后,就需要更新当前隐藏状态,如图
\ref
{
fig:10-13
}
(c)所示。在计算得到了重置门的权重
$
\mathbi
{
r
}_
t
$
后,使用其对前一时刻的状态
$
\mathbi
{
h
}_{
t
-
1
}$
进行重置(
$
\mathbi
{
r
}_
t
\cdot
\mathbi
{
h
}_{
t
-
1
}$
),将重置后的结果与
$
\mathbi
{
x
}_
t
$
拼接,通过Tanh激活函数将数据变换到[-1,1]范围内,具体计算如公式
\eqref
{
eq:10-14
}
:
\begin{eqnarray}
\hat
{
\mathbi
{
h
}}_
t
=
\textrm
{
Tanh
}
(
\mathbi
{
W
}_
h [
\mathbi
{
r
}_
t
\cdot
\mathbi
{
h
}_{
t-1
}
,
\mathbi
{
x
}_{
t
}
])
\hat
{
\mathbi
{
h
}}_
t
&
=
&
\textrm
{
Tanh
}
(
\mathbi
{
W
}_
h [
\mathbi
{
r
}_
t
\cdot
\mathbi
{
h
}_{
t-1
}
,
\mathbi
{
x
}_{
t
}
])
\label
{
eq:10-14
}
\end{eqnarray}
\parinterval
$
\hat
{
\mathbi
{
h
}}_
t
$
在包含了输入信息
$
\mathbi
{
x
}_
t
$
的同时,引入了
$
\mathbi
{
h
}_{
t
-
1
}$
的信息,可以理解为,记忆了当前时刻的状态。下一步是计算更新后的隐藏状态也就是更新记忆,如公式
\eqref
{
eq:10-15
}
所示:
\begin{eqnarray}
\mathbi
{
h
}_
t
=
(1-
\mathbi
{
u
}_
t)
\cdot
\mathbi
{
h
}_{
t-1
}
+
\mathbi
{
u
}_
t
\cdot
\hat
{
\mathbi
{
h
}}_
t
\mathbi
{
h
}_
t
&
=
&
(1-
\mathbi
{
u
}_
t)
\cdot
\mathbi
{
h
}_{
t-1
}
+
\mathbi
{
u
}_
t
\cdot
\hat
{
\mathbi
{
h
}}_
t
\label
{
eq:10-15
}
\end{eqnarray}
...
...
@@ -721,7 +721,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
\parinterval
根据这种思想,上下文向量
$
\mathbi
{
C
}_
j
$
被定义为对不同时间步编码器输出的状态序列
$
\{
\mathbi
{
h
}_
1
,
\mathbi
{
h
}_
2
,...,
\mathbi
{
h
}_
m
\}
$
进行加权求和,如公式
\eqref
{
eq:10-16
}
所示:
\begin{eqnarray}
\mathbi
{
C
}_
j
=
\sum
_{
i
}
\alpha
_{
i,j
}
\mathbi
{
h
}_
i
\mathbi
{
C
}_
j
&
=
&
\sum
_{
i
}
\alpha
_{
i,j
}
\mathbi
{
h
}_
i
\label
{
eq:10-16
}
\end{eqnarray}
...
...
@@ -742,13 +742,13 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现,Softm
\vspace
{
0.5em
}
\item
使用目标语言上一时刻循环单元的输出
$
\mathbi
{
s
}_{
j
-
1
}$
与源语言第
$
i
$
个位置的表示
$
\mathbi
{
h
}_
i
$
之间的相关性,其用来表示目标语言位置
$
j
$
对源语言位置
$
i
$
的关注程度,记为
$
\beta
_{
i,j
}$
,由函数
$
a
(
\cdot
)
$
实现,其具体计算如公式
\eqref
{
eq:10-17
}
所示:
\begin{eqnarray}
\beta
_{
i,j
}
=
a(
\mathbi
{
s
}_{
j-1
}
,
\mathbi
{
h
}_
i)
\beta
_{
i,j
}
&
=
&
a(
\mathbi
{
s
}_{
j-1
}
,
\mathbi
{
h
}_
i)
\label
{
eq:10-17
}
\end{eqnarray}
$
a
(
\cdot
)
$
可以被看作是目标语言表示和源语言表示的一种“统一化”,即把源语言和目标语言表示映射在同一个语义空间,进而语义相近的内容有更大的相似性。该函数有多种计算方式,比如,向量乘、向量夹角和单层神经网络等,具体数学表达如公式
\eqref
{
eq:10-18
}
:
\begin{eqnarray}
a (
\mathbi
{
s
}
,
\mathbi
{
h
}
)
=
\left\{
\begin{array}
{
ll
}
a (
\mathbi
{
s
}
,
\mathbi
{
h
}
)
&
=
&
\left\{
\begin{array}
{
ll
}
\mathbi
{
s
}
\mathbi
{
h
}^{
\textrm
{
T
}}
&
\textrm
{
向量乘
}
\\
\textrm
{
cos
}
(
\mathbi
{
s
}
,
\mathbi
{
h
}
)
&
\textrm
{
向量夹角
}
\\
\mathbi
{
s
}
\mathbi
{
W
}
\mathbi
{
h
}^{
\textrm
{
T
}}
&
\textrm
{
线性模型
}
\\
...
...
@@ -763,7 +763,7 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\item
进一步,利用Softmax函数,将相关性系数
$
\beta
_{
i,j
}$
进行指数归一化处理,得到注意力权重
$
\alpha
_{
i,j
}$
,具体计算如公式
\eqref
{
eq:10-19
}
:
\vspace
{
0.5em
}
\begin{eqnarray}
\alpha
_{
i,j
}
=
\frac
{
\textrm
{
exp
}
(
\beta
_{
i,j
}
)
}
{
\sum
_{
i'
}
\textrm
{
exp
}
(
\beta
_{
i',j
}
)
}
\alpha
_{
i,j
}
&
=
&
\frac
{
\textrm
{
exp
}
(
\beta
_{
i,j
}
)
}
{
\sum
_{
i'
}
\textrm
{
exp
}
(
\beta
_{
i',j
}
)
}
\label
{
eq:10-19
}
\end{eqnarray}
\vspace
{
0.5em
}
...
...
@@ -795,7 +795,7 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\parinterval
在
\ref
{
sec:10.3.1
}
节中,公式
\eqref
{
eq:10-4
}
描述了目标语言单词生成概率
$
\funp
{
P
}
(
y
_
j |
\mathbi
{
y
}_{
<j
}
,
\mathbi
{
x
}
)
$
。在引入注意力机制后,不同时刻的上下文向量
$
\mathbi
{
C
}_
j
$
替换了传统模型中固定的句子表示
$
\mathbi
{
C
}$
。描述如公式
\eqref
{
eq:10-20
}
:
\begin{eqnarray}
\funp
{
P
}
(y
_
j |
\mathbi
{
y
}_{
<j
}
,
\mathbi
{
x
}
)
\equiv
\funp
{
P
}
(y
_
j |
\mathbi
{
s
}_{
j-1
}
,y
_{
j-1
}
,
\mathbi
{
C
}_
j )
\funp
{
P
}
(y
_
j |
\mathbi
{
y
}_{
<j
}
,
\mathbi
{
x
}
)
&
=
&
\funp
{
P
}
(y
_
j |
\mathbi
{
s
}_{
j-1
}
,y
_{
j-1
}
,
\mathbi
{
C
}_
j )
\label
{
eq:10-20
}
\end{eqnarray}
...
...
@@ -839,7 +839,7 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\parinterval
也可以用这个系统描述翻译中的注意力问题,其中,
$
\mathrm
{
query
}$
即目标语言位置
$
j
$
的某种表示,
$
\mathrm
{
key
}$
和
$
\mathrm
{
value
}$
即源语言每个位置
$
i
$
上的
${
\mathbi
{
h
}_
i
}$
(这里
$
\mathrm
{
key
}$
和
$
\mathrm
{
value
}$
是相同的)。但是,这样的系统在机器翻译问题上并不好用,因为目标语言的表示和源语言的表示都在多维实数空间上,所以无法要求两个实数向量像字符串一样进行严格匹配,或者说这种严格匹配的模型可能会导致
$
\mathrm
{
query
}$
几乎不会命中任何的
$
\mathrm
{
key
}$
。既然无法严格精确匹配,注意力机制就采用了一个“模糊”匹配的方法。这里定义每个
$
\mathrm
{
key
}_
i
$
和
$
\mathrm
{
query
}$
都有一个0~1之间的匹配度,这个匹配度描述了
$
\mathrm
{
key
}_
i
$
和
$
\mathrm
{
query
}$
之间的相关程度,记为
$
\alpha
_
i
$
。而查询的结果(记为
$
\overline
{
\mathrm
{
value
}}$
)也不再是某一个单元的
$
\mathrm
{
value
}$
,而是所有单元
$
\mathrm
{
value
}$
用
$
\alpha
_
i
$
的加权和,具体计算如公式
\eqref
{
eq:10-21
}
:
\begin{eqnarray}
\overline
{
\mathrm
{
value
}}
=
\sum
_
i
\alpha
_
i
\cdot
{
\mathrm
{
value
}}_
i
\overline
{
\mathrm
{
value
}}
&
=
&
\sum
_
i
\alpha
_
i
\cdot
{
\mathrm
{
value
}}_
i
\label
{
eq:10-21
}
\end{eqnarray}
...
...
@@ -858,15 +858,15 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\parinterval
最后,从统计学的角度,如果把
$
\alpha
_
i
$
作为每个
$
\mathrm
{
value
}_
i
$
出现的概率的某种估计,即:
$
\funp
{
P
}
(
\mathrm
{
value
}_
i
$
)
$
=
\alpha
_
i
$
,于是可以把公式
\eqref
{
eq:10-21
}
重写为公式
\eqref
{
eq:10-22
}
:
\begin{eqnarray}
\overline
{
\mathrm
{
value
}}
=
\sum
_
i
\funp
{
P
}
(
{
\mathrm
{
value
}}_
i)
\cdot
{
\mathrm
{
value
}}_
i
\overline
{
\mathrm
{
value
}}
&
=
&
\sum
_
i
\funp
{
P
}
(
{
\mathrm
{
value
}}_
i)
\cdot
{
\mathrm
{
value
}}_
i
\label
{
eq:10-22
}
\end{eqnarray}
\noindent
显然,
$
\overline
{
\mathrm
{
value
}}$
就是
$
\mathrm
{
value
}_
i
$
在分布
$
\funp
{
P
}
(
\mathrm
{
value
}_
i
$
)下的期望,即公式
\eqref
{
eq:10-23
}
:
\begin{eq
uation
}
\mathbb
{
E
}_{
\sim
\
\
\funp
{
P
}
(
{
\mathrm
{
\mathrm
{
value
}}}_
i )
}
(
{
\mathrm
{
value
}}_
i) =
\sum
_
i
\funp
{
P
}
(
{
\mathrm
{
value
}}_
i)
\cdot
{
\mathrm
{
value
}}_
i
\begin{eq
narray
}
\mathbb
{
E
}_{
\sim
\
funp
{
P
}
(
{
\mathrm
{
\mathrm
{
value
}}}_
i )
}
(
{
\mathrm
{
value
}}_
i)
&
=
&
\sum
_
i
\funp
{
P
}
(
{
\mathrm
{
value
}}_
i)
\cdot
{
\mathrm
{
value
}}_
i
\label
{
eq:10-23
}
\end{eq
uation
}
\end{eq
narray
}
从这个观点看,注意力机制实际上是得到了变量
$
\mathrm
{
value
}$
的期望。当然,严格意义上说,
$
\alpha
_
i
$
并不是从概率角度定义的,在实际应用中也并不必须追求严格的统计学意义。
...
...
@@ -925,7 +925,7 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\parinterval
在基于梯度的方法中,模型参数可以通过损失函数
$
L
$
对参数的梯度进行不断更新。对于第
$
\textrm
{
step
}$
步参数更新,首先进行神经网络的前向计算,之后进行反向计算,并得到所有参数的梯度信息,再使用公式
\eqref
{
eq:10-24
}
的规则进行参数更新:
\begin{eqnarray}
\mathbi
{
w
}_{
\textrm
{
step
}
+1
}
=
\mathbi
{
w
}_{
\textrm
{
step
}}
-
\alpha
\cdot
\frac
{
\partial
L(
\mathbi
{
w
}_{
\textrm
{
step
}}
)
}
{
\partial
\mathbi
{
w
}_{
\textrm
{
step
}}
}
\mathbi
{
w
}_{
\textrm
{
step
}
+1
}
&
=
&
\mathbi
{
w
}_{
\textrm
{
step
}}
-
\alpha
\cdot
\frac
{
\partial
L(
\mathbi
{
w
}_{
\textrm
{
step
}}
)
}
{
\partial
\mathbi
{
w
}_{
\textrm
{
step
}}
}
\label
{
eq:10-24
}
\end{eqnarray}
...
...
@@ -941,13 +941,13 @@ a (\mathbi{s},\mathbi{h}) = \left\{ \begin{array}{ll}
\parinterval
神经机器翻译在目标端的每个位置都会输出一个概率分布,表示这个位置上不同单词出现的可能性。设计损失函数时,需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题,常用的是交叉熵损失函数。令
$
\mathbi
{
y
}$
表示机器翻译模型输出的分布,
$
\hat
{
\mathbi
{
y
}}$
表示标准答案,则交叉熵损失可以被定义为公式
\eqref
{
eq:10-25
}
:
\begin{eqnarray}
L
_{
\textrm
{
ce
}}
(
\mathbi
{
y
}
,
\hat
{
\mathbi
{
y
}}
)
=
-
\sum
_{
k=1
}^{
|V|
}
\mathbi
{
y
}
[k]
\textrm
{
log
}
(
\hat
{
\mathbi
{
y
}}
[k])
L
_{
\textrm
{
ce
}}
(
\mathbi
{
y
}
,
\hat
{
\mathbi
{
y
}}
)
&
=
&
-
\sum
_{
k=1
}^{
|V|
}
\mathbi
{
y
}
[k]
\textrm
{
log
}
(
\hat
{
\mathbi
{
y
}}
[k])
\label
{
eq:10-25
}
\end{eqnarray}
\noindent
其中
$
\mathbi
{
y
}
[
k
]
$
和
$
\hat
{
\mathbi
{
y
}}
[
k
]
$
分别表示向量
$
\mathbi
{
y
}$
和
$
\hat
{
\mathbi
{
y
}}$
的第
$
k
$
维,
$
|V|
$
表示输出向量的维度(等于词表大小)。假设有
$
n
$
个训练样本,模型输出的概率分布为
$
\mathbi
{
Y
}
=
\{
\mathbi
{
y
}_
1
,
\mathbi
{
y
}_
2
,...,
\mathbi
{
y
}_
n
\}
$
,标准答案的分布
$
\widehat
{
\mathbi
{
Y
}}
=
\{
\hat
{
\mathbi
{
y
}}_
1
,
\hat
{
\mathbi
{
y
}}_
2
,...,
\hat
{
\mathbi
{
y
}}_
n
\}
$
。这个训练样本集合上的损失函数可以被定义为公式
\eqref
{
eq:10-26
}
:
\begin{eqnarray}
L(
\mathbi
{
Y
}
,
\widehat
{
\mathbi
{
Y
}}
)
=
\sum
_{
j=1
}^
n L
_{
\textrm
{
ce
}}
(
\mathbi
{
y
}_
j,
\hat
{
\mathbi
{
y
}}_
j)
L(
\mathbi
{
Y
}
,
\widehat
{
\mathbi
{
Y
}}
)
&
=
&
\sum
_{
j=1
}^
n L
_{
\textrm
{
ce
}}
(
\mathbi
{
y
}_
j,
\hat
{
\mathbi
{
y
}}_
j)
\label
{
eq:10-26
}
\end{eqnarray}
...
...
@@ -1002,7 +1002,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) = \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\
\parinterval
需要注意的是,训练循环神经网络时,反向传播使得网络层之间的梯度相乘。在网络层数过深时,如果连乘因子小于1可能造成梯度指数级的减少,甚至趋近于0,导致网络无法优化,也就是梯度消失问题。当连乘因子大于1时,可能会导致梯度的乘积变得异常大,造成梯度爆炸的问题。在这种情况下需要使用“梯度裁剪”来防止梯度超过阈值。梯度裁剪在
{
\chapternine
}
已经介绍过,这里简单回顾一下。梯度裁剪的具体公式如公式
\eqref
{
eq:10-28
}
所示:
\vspace
{
-0.5em
}
\begin{eqnarray}
\mathbi
{
w
}
'
=
\mathbi
{
w
}
\cdot
\frac
{
\gamma
}
{
\textrm
{
max
}
(
\gamma
,
\|
\mathbi
{
w
}
\|
_
2)
}
\mathbi
{
w
}
'
&
=
&
\mathbi
{
w
}
\cdot
\frac
{
\gamma
}
{
\textrm
{
max
}
(
\gamma
,
\|
\mathbi
{
w
}
\|
_
2)
}
\label
{
eq:10-28
}
\end{eqnarray}
%\vspace{0.5em}
...
...
@@ -1034,7 +1034,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) = \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\
\parinterval
图
\ref
{
fig:10-26
}
展示了一种常用的学习率调整策略。它分为两个阶段:预热阶段和衰减阶段。模型训练初期梯度通常很大,如果直接使用较大的学习率很容易让模型陷入局部最优。学习率的预热阶段便是通过在训练初期使学习率从小到大逐渐增加来减缓在初始阶段模型“跑偏”的现象。一般来说,初始学习率太高会使得模型进入一种损失函数曲面非常不平滑的区域,进而使得模型进入一种混乱状态,后续的优化过程很难取得很好的效果。一个常用的学习率预热方法是
{
\small\bfnew
{
逐渐预热
}}
\index
{
逐渐预热
}
(Gradual Warmup)
\index
{
Gradual Warmup
}
。假设预热的更新次数为
$
N
$
,初始学习率为
$
\alpha
_
0
$
,则预热阶段第
$
\textrm
{
step
}$
次更新的学习率计算如公式
\eqref
{
eq:10-29
}
所示:
%\vspace{0.5em}
\begin{eqnarray}
\alpha
_
t
=
\frac
{
\textrm
{
step
}}{
N
}
\alpha
_
0
\quad
,
\quad
1
\leq
t
\leq
T'
\alpha
_
t
&
=
&
\frac
{
\textrm
{
step
}}{
N
}
\alpha
_
0
\quad
,
\quad
1
\leq
t
\leq
T'
\label
{
eq:10-29
}
\end{eqnarray}
%-------
...
...
@@ -1133,13 +1133,13 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) = \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\
\parinterval
在具体实现时,由于当前目标语言单词的生成需要依赖前面单词的生成,因此无法同时生成所有的目标语言单词。理论上,可以枚举所有的
$
\seq
{{
y
}}$
,之后利用
$
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
$
的定义对每个
$
\seq
{{
y
}}$
进行评价,然后找出最好的
$
\seq
{{
y
}}$
。这也被称作
{
\small\bfnew
{
全搜索
}}
\index
{
全搜索
}
(Full Search)
\index
{
Full Search
}
。但是,枚举所有的译文单词序列显然是不现实的。因此,在具体实现时,并不会访问所有可能的译文单词序列,而是用某种策略进行有效的搜索。常用的做法是自左向右逐词生成。比如,对于每一个目标语言位置
$
j
$
,可以执行公式
\eqref
{
eq:10-31
}
的过程:
\begin{eqnarray}
\hat
{
y
}_
j
=
\argmax
_{
y
_
j
}
\funp
{
P
}
(y
_
j |
\hat
{
\seq
{{
y
}}}_{
<j
}
,
\seq
{{
x
}}
)
\hat
{
y
}_
j
&
=
&
\argmax
_{
y
_
j
}
\funp
{
P
}
(y
_
j |
\hat
{
\seq
{{
y
}}}_{
<j
}
,
\seq
{{
x
}}
)
\label
{
eq:10-31
}
\end{eqnarray}
\noindent
其中,
$
\hat
{
y
}_
j
$
表示位置
$
j
$
概率最高的单词,
$
\hat
{
\seq
{{
y
}}}_{
<j
}
=
\{
\hat
{
y
}_
1
,...,
\hat
{
y
}_{
j
-
1
}
\}
$
表示已经生成的最优译文单词序列。也就是,把最优的译文看作是所有位置上最优单词的组合。显然,这是一种贪婪搜索,因为无法保证
$
\{
\hat
{
y
}_
1
,...,
\hat
{
y
}_{
n
}
\}
$
是全局最优解。一种缓解这个问题的方法是,在每步中引入更多的候选。这里定义
$
\hat
{
y
}_{
jk
}
$
表示在目标语言第
$
j
$
个位置排名在第
$
k
$
位的单词。在每一个位置
$
j
$
,可以生成
$
k
$
个最可能的单词,而不是1个,这个过程可以被描述为公式
\eqref
{
eq:10-32
}
:
\begin{eqnarray}
\{
\hat
{
y
}_{
j1
}
,...,
\hat
{
y
}_{
jk
}
\}
=
\argmax
_{
\{
\hat
{
y
}_{
j1
}
,...,
\hat
{
y
}_{
jk
}
\}
}
\{
\hat
{
y
}_{
j1
}
,...,
\hat
{
y
}_{
jk
}
\}
&
=
&
\argmax
_{
\{
\hat
{
y
}_{
j1
}
,...,
\hat
{
y
}_{
jk
}
\}
}
\funp
{
P
}
(y
_
j |
\{
\hat
{
\seq
{{
y
}}}_{
<
{
j
\ast
}}
\}
,
\seq
{{
x
}}
)
\label
{
eq:10-32
}
\end{eqnarray}
...
...
@@ -1218,13 +1218,13 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) = \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\
\parinterval
为了解决上面提到的问题,可以使用其他特征与
$
\textrm
{
log
}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
$
一起组成新的模型得分
$
\textrm
{
score
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
$
。针对模型倾向于生成短句子的问题,常用的做法是引入惩罚机制。比如,可以定义一个惩罚因子,具体如公式
\eqref
{
eq:10-33
}
:
\begin{eqnarray}
\textrm
{
lp
}
(
\seq
{{
y
}}
)
=
\frac
{
(5+ |
\seq
{{
y
}}
|)
^{
\alpha
}}
{
(5+1)
^{
\alpha
}}
\textrm
{
lp
}
(
\seq
{{
y
}}
)
&
=
&
\frac
{
(5+ |
\seq
{{
y
}}
|)
^{
\alpha
}}
{
(5+1)
^{
\alpha
}}
\label
{
eq:10-33
}
\end{eqnarray}
\noindent
其中,
$
|
\seq
{{
y
}}
|
$
代表已经得到的译文长度,
$
\alpha
$
是一个固定的常数,用于控制惩罚的强度。同时在计算句子得分时,额外引入表示覆盖度的因子,如公式
\eqref
{
eq:10-34
}
所示:
\begin{eqnarray}
\textrm
{
cp
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
=
\beta
\cdot
\sum
_{
i=1
}^{
|
\seq
{{
x
}}
|
}
\textrm
{
log
}
\big
(
\textrm
{
min
}
(
\sum
_
j
^{
|
\seq
{{
y
}}
|
}
\alpha
_{
ij
}
,1 )
\big
)
\textrm
{
cp
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
&
=
&
\beta
\cdot
\sum
_{
i=1
}^{
|
\seq
{{
x
}}
|
}
\textrm
{
log
}
\big
(
\textrm
{
min
}
(
\sum
_
j
^{
|
\seq
{{
y
}}
|
}
\alpha
_{
ij
}
,1 )
\big
)
\label
{
eq:10-34
}
\end{eqnarray}
...
...
@@ -1232,7 +1232,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) = \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\
\parinterval
最终,模型得分定义如公式
\eqref
{
eq:10-35
}
所示:
\begin{eqnarray}
\textrm
{
score
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
=
\frac
{
\textrm
{
log
}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
}
{
\textrm
{
lp
}
(
\seq
{{
y
}}
)
}
+
\textrm
{
cp
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
\textrm
{
score
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
&
=
&
\frac
{
\textrm
{
log
}
\funp
{
P
}
(
\seq
{{
y
}}
|
\seq
{{
x
}}
)
}
{
\textrm
{
lp
}
(
\seq
{{
y
}}
)
}
+
\textrm
{
cp
}
(
\seq
{{
y
}}
,
\seq
{{
x
}}
)
\label
{
eq:10-35
}
\end{eqnarray}
...
...
Chapter11/chapter11.tex
查看文件 @
29db5a6d
...
...
@@ -87,7 +87,7 @@
\parinterval
在卷积计算中,不同深度下卷积核不同但是执行操作相同,这里以二维卷积核为例展示具体卷积计算。若设输入矩阵为
$
\mathbi
{
x
}$
,输出矩阵为
$
\mathbi
{
y
}$
,卷积滑动步幅为
$
\textrm
{
stride
}$
,卷积核为
$
\mathbi
{
w
}$
,且
$
\mathbi
{
w
}
\in
\mathbb
{
R
}^{
Q
\times
U
}
$
,那么卷积计算过程如公式
\eqref
{
eq:11-1
}
所示:
\begin{eqnarray}
\mathbi
{
y
}_{
i,j
}
=
\sum
\sum
(
\mathbi
{
x
}_{
[j
\times
\textrm
{
stride
}
:j
\times
\textrm
{
stride
}
+U-1,i
\times
\textrm
{
stride
}
:i
\times
\textrm
{
stride
}
+Q-1]
}
\odot
\mathbi
{
w
}
)
\mathbi
{
y
}_{
i,j
}
&
=
&
\sum
\sum
(
\mathbi
{
x
}_{
[j
\times
\textrm
{
stride
}
:j
\times
\textrm
{
stride
}
+U-1,i
\times
\textrm
{
stride
}
:i
\times
\textrm
{
stride
}
+Q-1]
}
\odot
\mathbi
{
w
}
)
\label
{
eq:11-1
}
\end{eqnarray}
...
...
@@ -340,7 +340,7 @@
\parinterval
残差连接是一种训练深层网络的技术,其内容在
{
\chapternine
}
已经进行了介绍,即在多层神经网络之间通过增加直接连接的方式,从而将底层信息直接传递给上层。通过增加这样的直接连接,可以让不同层之间的信息传递更加高效,有利于深层神经网络的训练,其计算如公式
\eqref
{
eq:11-6
}
所示:
\begin{eqnarray}
\mathbi
{
h
}^{
l+1
}
=
F (
\mathbi
{
h
}^
l) +
\mathbi
{
h
}^
l
\mathbi
{
h
}^{
l+1
}
&
=
&
F (
\mathbi
{
h
}^
l) +
\mathbi
{
h
}^
l
\label
{
eq:11-6
}
\end{eqnarray}
...
...
@@ -349,7 +349,7 @@
\parinterval
在ConvS2S中残差连接主要应用于门控卷积神经网络和多跳自注意力机制中,比如在编码器的多层门控卷积神经网络中,在每一层的输入和输出之间增加残差连接,具体的数学描述如公式
\eqref
{
eq:11-7
}
所示:
\begin{eqnarray}
%\mathbi{h}_i^l = \funp{v} (\mathbi{W}^l [\mathbi{h}_{i-\frac{k}{2}}^{l-1},...,\mathbi{h}_{i+\frac{k}{2}}^{l-1}] + b_{\mathbi{W}}^l ) + \mathbi{h}_i^{l-1}
\mathbi
{
h
}^{
l+1
}
=
\mathbi
{
A
}^{
l
}
\otimes
\sigma
(
\mathbi
{
B
}^{
l
}
) +
\mathbi
{
h
}^{
l
}
\mathbi
{
h
}^{
l+1
}
&
=
&
\mathbi
{
A
}^{
l
}
\otimes
\sigma
(
\mathbi
{
B
}^{
l
}
) +
\mathbi
{
h
}^{
l
}
\label
{
eq:11-7
}
\end{eqnarray}
...
...
@@ -383,7 +383,7 @@
\parinterval
在ConvS2S模型中,解码器同样采用堆叠的多层门控卷积网络来对目标语言进行序列建模。区别于编码器,解码器在每一层卷积网络之后引入了注意力机制,用来参考源语言信息。ConvS2S选用了点乘注意力,并且通过类似残差连接的方式将注意力操作的输入与输出同时作用于下一层计算,称为多跳注意力。其具体计算方式如公式
\eqref
{
eq:11-10
}
所示:
\begin{eqnarray}
\alpha
_{
ij
}^
l
=
\frac
{
\textrm
{
exp
}
(
\mathbi
{
d
}_{
j
}^
l
\mathbi
{
h
}_
i)
}{
\sum
_{
i
^{
'
}
=1
}^
m
\textrm
{
exp
}
(
\mathbi
{
d
}_{
j
}^
l
\mathbi
{
h
}_{
i
^{
'
}}
)
}
\alpha
_{
ij
}^
l
&
=
&
\frac
{
\textrm
{
exp
}
(
\mathbi
{
d
}_{
j
}^
l
\mathbi
{
h
}_
i)
}{
\sum
_{
i
^{
'
}
=1
}^
m
\textrm
{
exp
}
(
\mathbi
{
d
}_{
j
}^
l
\mathbi
{
h
}_{
i
^{
'
}}
)
}
\label
{
eq:11-10
}
\end{eqnarray}
...
...
@@ -395,13 +395,13 @@
\noindent
其中,
$
\mathbi
{
z
}_
j
^
l
$
表示第
$
l
$
层卷积网络输出中第
$
j
$
个位置的表示,
$
\mathbi
{
W
}_{
d
}^{
l
}$
和
$
\mathbi
{
b
}_{
d
}^{
l
}$
是模型可学习的参数,
$
\textrm
{
Conv
}
(
\cdot
)
$
表示卷积操作。在获得第
$
l
$
层的注意力权重之后,就可以得到对应的一个上下文表示
$
\mathbi
{
C
}_
j
^
l
$
,具体计算如公式
\eqref
{
eq:11-13
}
所示:
\begin{eqnarray}
\mathbi
{
C
}_
j
^
l
=
\sum
_
i
\alpha
_{
ij
}^
l (
\mathbi
{
h
}_
i +
\mathbi
{
e
}_
i)
\mathbi
{
C
}_
j
^
l
&
=
&
\sum
_
i
\alpha
_{
ij
}^
l (
\mathbi
{
h
}_
i +
\mathbi
{
e
}_
i)
\label
{
eq:11-13
}
\end{eqnarray}
\noindent
模型使用了更全面的源语言信息,同时考虑了源语言端编码表示
$
\mathbi
{
h
}_
i
$
以及词嵌入表示
$
\mathbi
{
e
}_
i
$
。在获得第
$
l
$
层的上下文向量
$
\mathbi
{
C
}_
j
^
l
$
后,模型将其与
$
\mathbi
{
z
}_
j
^
l
$
相加后送入下一层网络,这个过程可以被描述为公式
\eqref
{
eq:11-14
}
:
\begin{eqnarray}
\mathbi
{
s
}_
j
^{
l+1
}
=
\mathbi
{
C
}_
j
^
l +
\mathbi
{
z
}_
j
^
l
\mathbi
{
s
}_
j
^{
l+1
}
&
=
&
\mathbi
{
C
}_
j
^
l +
\mathbi
{
z
}_
j
^
l
\label
{
eq:11-14
}
\end{eqnarray}
...
...
@@ -478,7 +478,7 @@
\parinterval
给定输入序列表示
$
\seq
{
x
}
=
\{
\mathbi
{
x
}_
1
,
\mathbi
{
x
}_
2
,...,
\mathbi
{
x
}_
m
\}
$
,其中
$
m
$
为序列长度,
$
\mathbi
{
x
}_
i
\in
\mathbb
{
R
}^{
O
}
$
,
$
O
$
即输入序列的通道数。为了获得与输入序列长度相同的卷积输出结果,首先需要进行填充。为了方便描述,这里在输入序列尾部填充
$
K
-
1
$
个元素(
$
K
$
为卷积核窗口的长度),其对应的卷积结果为
$
\seq
{
z
}
=
\{
\mathbi
{
z
}_
1
,
\mathbi
{
z
}_
2
,...,
\mathbi
{
z
}_
m
\}
$
。
在标准卷积中,若使用N表示卷积核的个数,也就是标准卷积输出序列的通道数,那么对于第
$
i
$
个位置的第
$
n
$
个通道
$
\mathbi
{
z
}_{
i,n
}^
\textrm
{
\,
std
}$
,其标准卷积具体计算如公式
\eqref
{
eq:11-18
}
所示:
\begin{eqnarray}
\mathbi
{
z
}_{
i,n
}^
\textrm
{
\,
std
}
=
\sum
_{
o=1
}^{
O
}
\sum
_{
k=0
}^{
K-1
}
\mathbi
{
W
}_{
k,o,n
}^
\textrm
{
\,
std
}
\mathbi
{
x
}_{
i+k,o
}
\mathbi
{
z
}_{
i,n
}^
\textrm
{
\,
std
}
&
=
&
\sum
_{
o=1
}^{
O
}
\sum
_{
k=0
}^{
K-1
}
\mathbi
{
W
}_{
k,o,n
}^
\textrm
{
\,
std
}
\mathbi
{
x
}_{
i+k,o
}
\label
{
eq:11-18
}
\end{eqnarray}
...
...
@@ -488,7 +488,7 @@
\parinterval
相应的,深度卷积只考虑不同词之间的依赖性,而不考虑不同通道之间的关系,相当于使用
$
O
$
个卷积核逐个通道对不同的词进行卷积操作。因此深度卷积不改变输出的表示维度,输出序列表示的通道数与输入序列一致,其计算如公式
\eqref
{
eq:11-19
}
所示:
\begin{eqnarray}
\mathbi
{
z
}_{
i,o
}^
\textrm
{
\,
dw
}
=
\sum
_{
k=0
}^{
K-1
}
\mathbi
{
W
}_{
k,o
}^
\textrm
{
\,
dw
}
\mathbi
{
x
}_{
i+k,o
}
\mathbi
{
z
}_{
i,o
}^
\textrm
{
\,
dw
}
&
=
&
\sum
_{
k=0
}^{
K-1
}
\mathbi
{
W
}_{
k,o
}^
\textrm
{
\,
dw
}
\mathbi
{
x
}_{
i+k,o
}
\label
{
eq:11-19
}
\end{eqnarray}
...
...
@@ -564,7 +564,7 @@
\parinterval
在轻量卷积中,模型使用的卷积参数是静态的,与序列位置无关, 维度大小为
$
K
\times
a
$
;而在动态卷积中,为了增强模型的表示能力,卷积参数来自于当前位置输入的变换,具体如公式
\eqref
{
eq:11-22
}
:
\begin{eqnarray}
\funp
{
f
}
(
\mathbi
{
x
}_{
i
}
)
=
\sum
_{
c=1
}^
d
\mathbi
{
W
}_{
:,:,c
}
\odot
\mathbi
{
x
}_{
i,c
}
\funp
{
f
}
(
\mathbi
{
x
}_{
i
}
)
&
=
&
\sum
_{
c=1
}^
d
\mathbi
{
W
}_{
:,:,c
}
\odot
\mathbi
{
x
}_{
i,c
}
\label
{
eq:11-22
}
\end{eqnarray}
...
...
Chapter12/chapter12.tex
查看文件 @
29db5a6d
...
...
@@ -281,7 +281,7 @@
\parinterval
在得到
$
\mathbi
{
Q
}$
,
$
\mathbi
{
K
}$
和
$
\mathbi
{
V
}$
后,便可以进行注意力机制的运算,这个过程可以被形式化为公式
\eqref
{
eq:12-9
}
:
\begin{eqnarray}
\textrm
{
Attention
}
(
\mathbi
{
Q
}
,
\mathbi
{
K
}
,
\mathbi
{
V
}
)
=
\textrm
{
Softmax
}
\textrm
{
Attention
}
(
\mathbi
{
Q
}
,
\mathbi
{
K
}
,
\mathbi
{
V
}
)
&
=
&
\textrm
{
Softmax
}
(
\frac
{
\mathbi
{
Q
}
\mathbi
{
K
}^{
\textrm
{
T
}}}
{
\sqrt
{
d
_
k
}}
+
\mathbi
{
Mask
}
)
\mathbi
{
V
}
\label
{
eq:12-9
}
\end{eqnarray}
...
...
@@ -417,13 +417,13 @@
\parinterval
在Transformer的训练过程中,由于引入了残差操作,将前面所有层的输出加到一起,如公式
\eqref
{
eq:12-12
}
所示:
\begin{eqnarray}
%x_{l+1} = x_l + F (x_l)
\mathbi
{
x
}^{
l+1
}
=
F (
\mathbi
{
x
}^
l) +
\mathbi
{
x
}^
l
\mathbi
{
x
}^{
l+1
}
&
=
&
F (
\mathbi
{
x
}^
l) +
\mathbi
{
x
}^
l
\label
{
eq:12-12
}
\end{eqnarray}
\noindent
其中
$
\mathbi
{
x
}^
l
$
表示第
$
l
$
层网络的输入向量,
$
F
(
\mathbi
{
x
}^
l
)
$
是子层运算,这样会导致不同层(或子层)的结果之间的差异性很大,造成训练过程不稳定、训练时间较长。为了避免这种情况,在每层中加入了层标准化操作
\upcite
{
Ba2016LayerN
}
。图
\ref
{
fig:12-14
}
中的红色方框展示了Transformer中残差和层标准化的位置。层标准化的计算如公式
\eqref
{
eq:12-13
}
所示:
\begin{eqnarray}
\textrm
{
LN
}
(
\mathbi
{
x
}
)
=
g
\cdot
\frac
{
\mathbi
{
x
}
-
\mu
}
{
\sigma
}
+ b
\textrm
{
LN
}
(
\mathbi
{
x
}
)
&
=
&
g
\cdot
\frac
{
\mathbi
{
x
}
-
\mu
}
{
\sigma
}
+ b
\label
{
eq:12-13
}
\end{eqnarray}
...
...
@@ -459,7 +459,7 @@
\parinterval
Transformer使用了全连接网络。全连接网络的作用主要体现在将经过注意力操作之后的表示映射到新的空间中,新的空间会有利于接下来的非线性变换等操作。实验证明,去掉全连接网络会对模型的性能造成很大影响。Transformer的全连接前馈神经网络包含两次线性变换和一次非线性变换(ReLU激活函数:ReLU
$
(
\mathbi
{
x
}
)=
\textrm
{
max
}
(
0
,
\mathbi
{
x
}
)
$
),每层的前馈神经网络参数不共享,具体计算如公式
\eqref
{
eq:12-14
}
:
\begin{eqnarray}
\textrm
{
FFN
}
(
\mathbi
{
x
}
)
=
\textrm
{
max
}
(0,
\mathbi
{
x
}
\mathbi
{
W
}_
1 +
\mathbi
{
b
}_
1)
\mathbi
{
W
}_
2 +
\mathbi
{
b
}_
2
\textrm
{
FFN
}
(
\mathbi
{
x
}
)
&
=
&
\textrm
{
max
}
(0,
\mathbi
{
x
}
\mathbi
{
W
}_
1 +
\mathbi
{
b
}_
1)
\mathbi
{
W
}_
2 +
\mathbi
{
b
}_
2
\label
{
eq:12-14
}
\end{eqnarray}
...
...
@@ -489,7 +489,7 @@
\item
Transformer使用Adam优化器优化参数,并设置
$
\beta
_
1
=
0
.
9
$
,
$
\beta
_
2
=
0
.
98
$
,
$
\epsilon
=
10
^{
-
9
}$
。
\item
Transformer在学习率中同样应用了学习率
{
\small\bfnew
{
预热
}}
\index
{
预热
}
(Warmup)
\index
{
Warmup
}
策略,其计算如公式
\eqref
{
eq:12-15
}
所示:
\begin{eqnarray}
lrate
=
d
_{
\textrm
{
model
}}^{
-0.5
}
\cdot
\textrm
{
min
}
(
\textrm
{
step
}^{
-0.5
}
,
\textrm
{
step
}
\cdot
\textrm
{
warmup
\_
steps
}^{
-1.5
}
)
lrate
&
=
&
d
_{
\textrm
{
model
}}^{
-0.5
}
\cdot
\textrm
{
min
}
(
\textrm
{
step
}^{
-0.5
}
,
\textrm
{
step
}
\cdot
\textrm
{
warmup
\_
steps
}^{
-1.5
}
)
\label
{
eq:12-15
}
\end{eqnarray}
...
...
编写
预览
Markdown
格式
0%
重试
或
添加新文件
添加附件
取消
您添加了
0
人
到此讨论。请谨慎行事。
请先完成此评论的编辑!
取消
请
注册
或者
登录
后发表评论