目前主流的处理序列问题(如机器翻译、文档摘要,对话系统,QA等)大部分都是基于Encoder-Decoder框架(如seq2seq)。即:Encoder:from word sequence to sentence representation;Decoder: from sentence representation to word sequence distribution.传统的Encoder-Decoder一般使用RNN,大部分的神经机器翻译模型都选择使用RNN,但是正如我们所知道的,RNN难以处理长序列的句子,无法实现并行化(由于RNN处理序列的模式),并且面临对齐的问题。
每个子层又引入了 residual connection,具体的做法为:每个子层的输出为这个子层的输入和输出相加:
x
+
S
u
b
l
a
y
e
r
(
x
)
x+Sublayer(x)
x+Sublayer(x),这就要求每个子层的输入与输出的维度是完全相等的,然后再使用layer normalization,作为最终的输出:
L
a
y
e
r
N
o
r
m
(
x
+
S
u
b
l
a
y
e
r
(
x
)
)
Layer Norm(x+Sublayer(x))
LayerNorm(x+Sublayer(x)) 论文中限定了Embedding层的输出和两个子层的输入输出的维度都是
d
m
o
d
e
l
=
512
d_{model}=512
dmodel=512,即上图中的
e
m
b
e
d
d
i
n
g
d
i
m
e
n
s
i
o
n
embedding\ dimension
embeddingdimension.
经过Attention之后的输出维度和输入的嵌入表示维度,即
X
e
m
b
e
d
d
i
n
g
X_{embedding}
Xembedding,相同,也就是
[
b
a
t
c
h
s
i
z
e
,
s
e
q
u
e
n
c
e
l
e
n
g
t
h
,
e
m
b
e
d
d
i
n
g
d
i
m
e
n
s
i
o
n
]
[batch\ size,\ sequence\ length,\ embedding\ dimension]
[batchsize,sequencelength,embeddingdimension],然后把它们加起来,做残差连接,直接进行元素相加,因为它们的维度是一致的。即,
X
+
S
u
b
L
a
y
e
r
(
X
)
=
X
e
m
b
e
d
d
i
n
g
+
A
t
t
e
n
t
i
o
n
(
Q
,
K
,
V
)
(
此
处
的
A
t
t
e
n
t
i
o
n
为
后
面
将
要
提
到
的
M
u
l
t
i
−
H
e
a
d
A
t
t
e
n
t
i
o
n
)
X+SubLayer(X)=\\ X_{embedding}+Attention(Q,\ K,\ V)\\(此处的Attention为后面将要提到的Multi-Head Attention)
X+SubLayer(X)=Xembedding+Attention(Q,K,V)(此处的Attention为后面将要提到的Multi−HeadAttention) 在之后的运算里,每经过一个模块的运算,都要把运算之前的值和运算之后的值相加(在此,运算即为Attention),从而得到残差连接,训练的时候可以使梯度直接走捷径反传到最初始层(这就是为啥要residual connection,也可以理解为residual connection的作用)residual connection。
Layer Norm
L
a
y
e
r
N
o
r
m
a
l
i
z
a
t
i
o
n
Layer Normalization
LayerNormalization的作用就是把神经网络中隐藏层归一为标准正太分布,也就是独立同分布,以起到加快训练速度,加速收敛的作用,同时也可以避免梯度消失和梯度爆炸的问题,相比Batch Normalization, Layer Normalization更适用于序列化模型比如RNN等,而Batch Normalization则更适用于CNN处理图像。
μ
i
=
1
m
∑
i
=
1
m
x
i
j
\mu_{i}=\frac{1}{m} \sum^{m}_ {i=1}x_{ij}
μi=m1i=1∑mxij 上式中以矩阵的行
(
r
o
w
)
(row)
(row)为单位求均值;
σ
j
2
=
1
m
∑
i
=
1
m
(
x
i
j
−
μ
j
)
2
\sigma^{2}_ {j} = \frac{1}{m} \sum^{m}_ {i=1}(x_{ij}-\mu_{j})^{2}
σj2=m1i=1∑m(xij−μj)2 上式中以矩阵的行
(
r
o
w
)
(row)
(row)为单位求方差;
L
a
y
e
r
N
o
r
m
(
x
)
=
α
⊙
x
i
j
−
μ
i
σ
i
2
+
ϵ
+
β
LayerNorm(x) = \alpha \odot \frac{x_{ij}-\mu_{i}}{\sqrt{\sigma^{2}_ {i}+\epsilon}} + \beta
LayerNorm(x)=α⊙σi2+ϵxij−μi+β 然后用每一行的每一个元素减去这行的均值, 再除以这行的标准差, 从而得到归一化后的数值,
ϵ
\epsilon
ϵ 是为了防止除
0
0
0; 之后引入两个可训练参数
α
,
β
\alpha,\beta
α,β 来弥补归一化的过程中损失掉的信息, 注意
⊙
\odot
⊙ 表示元素相乘而不是点积, 我们一般初始化
α
\alpha
α 为全
1
1
1, 而
β
\beta
β 为全
0
0
0.
其实,只要把Encoder每个子层都理解清楚了,Decoder的各个层就会很好理解。
Decoder
Decoder也是由N=6个独立的层堆叠而成的,除了与Encoder层中的两个完全相同的子层外,在两层之间又加入了一个multi-head attention,这里是对Encoder的输出作attention处理。 与Encoder相同,每个子层之间也引入了residual connection,并且相加之后使用layer normalization得到每个子层的最后输出。 此外为了防止序列中元素的位置主导输出结果,对Decoder层的multi-head-attention层增加了mask操作,并且结合对output embedding结果进行右移一位的操作,保证了每个位置i的输出,只会依赖于i位之前(不包括i位,因为右移一位和mask)(加入了mask机制, masking 的作用就是防止在训练的时候 使用未来的输出的单词。 比如训练时,第一个单词是不能参考第二个单词的生成结果的。 Masking就会把这个信息变成0, 用来保证预测位置 i 的信息只能基于比 i 小的输出)。
我们假设query和key这两个用来比较的向量,长度都为
d
k
d_{k}
dk;value向量的长度为
d
v
d_{v}
dv。对query和所有的key进行点积得到值,再对这个点积结果除以
d
k
\sqrt{d_{k}}
dk,完成scale,最后应用一个softmax function获得每个value对应的权重(也就说这也是一种soft attention),加权求和求得最后的输出向量。 这是对于一个query的情况,实际中是直接对一个血猎对应的所有querys直接进行计算,将所有querys拼成一个大的Q矩阵,对应的keys和values也拼接成K和V矩阵,则Scaled Dot-Product Attention对应的计算公式为:
A
t
t
e
n
t
i
o
n
(
Q
,
K
,
V
)
=
s
o
f
t
m
a
x
(
Q
K
T
d
k
)
V
Attention(Q,K,V)=softmax(\frac{QK^{T}}{\sqrt{d_{k}}})V
Attention(Q,K,V)=softmax(dkQKT)V 需要注意的是:
d
k
d_{k}
dk较大的时候,向量之间的点积结果可能就会非常大,这会造成softmax函数陷入到梯度很小的区域,不利于反向传播的进行,。为了适应这种情况,适应了缩放因子
d
k
\sqrt{d_{k}}
dk,对点积结果进行尺度化,将点积结果尽量缩小到梯度敏感的区域内。
为什么当
d
k
\sqrt{d_{k}}
dk比较大的时候,会导致点积的结果比较大,原论文中是这样解释的:
Multi-Head Attention
之前的方法都是对
d
m
o
d
e
l
d_{model}
dmodel维度的query,keys和value直接只用一个Attention函数。在Multi-Head Attention方法中,进行如此操作:
对querys,keys和values都分别进行h次线性映射(类似于SVM中的线性核),得到h组维度分别为
d
k
,
d
k
,
d
v
d_{k},d_{k},d_{v}
dk,dk,dv的向量。需要注意的是,这h次映射都是不同的映射,每次线性映射使用的参数是不相同的,而且这个映射是可学习的,相当于得到了h个不同空间(虽然这些空间的维数是相等的)中的表征。
然后并行的对这h组维度分别为
d
k
,
d
k
,
d
v
d_{k},d_{k},d_{v}
dk,dk,dv的query,keys,和values向量执行Attention函数,每组产生一个,
d
v
d_{v}
dv维的输出结果。
最后将这h个维度为
d
k
d_{k}
dk的向量拼接起来
通过线性转换还原成
d
m
o
d
e
l
d_{model}
dmodel维度向量 公式表示为
W
i
Q
,
W
i
K
,
W
i
V
,
W
i
O
W_{i}^{Q}, W_{i}^{K}, W_{i}^{V}, W_{i}^{O}
WiQ,WiK,WiV,WiO都是可学习的线性映射参数。在论文中超参数的选择为h=8,由由于
d
m
o
d
e
l
=
512
d_{model}=512
dmodel=512,因此
d
k
=
d
v
=
d
m
o
d
e
l
h
=
64.
d_{k}=d_{v}=\frac{d_{model}}{h}=64.
dk=dv=hdmodel=64.因为对每一个head的将维,总体计算的消耗与直接使用Attention函数的消耗相近。
Decoder中第一个子层 Multi-Head Attention,query=key=value=decoder的输入。因此对于某个位置的元素,会获取序列中所有序列信息,但是为了防止leftward information flow(左侧信息泄露),即防止出现自回归属性,我们对这种Scaled Dot-Product Attention通过mask进行了限制。解释如下:在self-attention的计算过程中,我们通常使用
m
i
n
i
b
a
t
c
h
mini\ batch
minibatch来计算,也就是一次计算多个序列,即输入
X
X
X的维度是
[
b
a
t
c
h
s
i
z
e
,
s
e
q
u
e
n
c
e
l
e
n
g
t
h
]
[batch\ size, sequence\ length]
[batchsize,sequencelength], sequence length是句长,而一个 mini batch是由多个不等长的句子组成的,我们就需要按照这个mini batch中最大的句长对剩余的句子进行补齐长度,我们一般就是用0来进行填充,这其实就是
P
a
d
d
i
n
g
Padding
Padding的过程。但是这时再进行
s
o
f
t
m
a
x
softmax
softmax的时候就会产生问题,回顾
s
o
f
t
m
a
x
softmax
softmax函数,
s
o
f
t
m
a
x
(
z
i
)
=
e
z
i
∑
j
=
1
K
e
z
j
softmax(z_{i})=\frac{e^{z_{i}}}{\sum_{j=1}^{K}e^{z_{j}}}
softmax(zi)=∑j=1Kezjezi 而
e
0
=
1
≠
0
e^{0}=1\not=0
e0=1=0,也就是是有值的,这样的话就说明
s
o
f
t
m
a
x
softmax
softmax中被
p
a
d
d
i
n
g
padding
padding的部分就参与了运算,就等于是让无效的部分参与了运算,会产生很大的隐患,这就需要做一个
m
a
s
k
mask
mask,让这些无效区域不参与运算,我们给无效区域加一个很大的负数的偏置,即设置为
−
∞
- \infty
−∞。
z
i
l
l
e
g
a
l
=
z
i
l
l
e
g
a
l
+
b
i
a
s
i
l
l
e
g
a
l
b
i
a
s
i
l
l
e
g
a
l
→
−
∞
e
z
i
l
l
e
g
a
l
→
0
z_{illegal} = z_{illegal} + bias_{illegal}\\ bias_{illegal} \rightarrow -\infty\\ e^{z_{illegal}}\rightarrow 0
zillegal=zillegal+biasillegalbiasillegal→−∞ezillegal→0 经过上式的
m
a
s
k
i
n
g
masking
masking我们使无效区域经过
s
o
f
t
m
a
x
softmax
softmax计算之后还几乎为
0
0
0,这样就避免了无效区域参与运算。
至此,Attention部分已经完全讲完了,下面给出一个直观的解释,帮助理解。
整个Transformer的Encoder整体结构
至此, 我们已经基本了解到
t
r
a
n
s
f
o
r
m
e
r
transformer
transformer编码器的主要构成部分, 我们下面用公式把一个
t
r
a
n
s
f
o
r
m
e
r
b
l
o
c
k
transformer\ \ block
transformerblock的计算过程整理一下: 1). 字向量与位置编码:
X
=
E
m
b
e
d
d
i
n
g
L
o
o
k
u
p
(
X
)
+
P
o
s
i
t
i
o
n
a
l
E
n
c
o
d
i
n
g
X
i
n
R
b
a
t
c
h
s
i
z
e
∗
s
e
q
l
e
n
∗
e
m
b
e
d
d
i
m
.
X = EmbeddingLookup(X) + Positional\ Encoding\\ X\ in\ \mathbb{R}^{ batch\ size* seq\ len* embed\ dim.}
X=EmbeddingLookup(X)+PositionalEncodingXinRbatchsize∗seqlen∗embeddim.
2). 自注意力机制: 其实在Encoder中,
Q
=
K
=
V
=
X
Q=K=V=X
Q=K=V=X那么对
Q
,
K
,
V
Q,K,V
Q,K,V进行线性映射后的
Q
,
K
,
V
Q,K,V
Q,K,V可以写成如下:
Q
=
L
i
n
e
a
r
(
X
)
=
X
W
Q
K
=
L
i
n
e
a
r
(
X
)
=
X
W
K
V
=
L
i
n
e
a
r
(
X
)
=
X
W
V
Q = Linear(X) = XW^{Q}\\ K = Linear(X) = XW^{K}\\ V = Linear(X) = XW^{V}
Q=Linear(X)=XWQK=Linear(X)=XWKV=Linear(X)=XWV 然后对线性映射后的
Q
,
K
,
V
Q,K,V
Q,K,V进行Attention:
X
a
t
t
e
n
t
i
o
n
=
M
u
l
t
i
.
H
e
a
d
A
t
t
e
n
t
i
o
n
(
Q
,
K
,
V
)
X_{attention} = Multi.Head\ Attention(Q, K, V)
Xattention=Multi.HeadAttention(Q,K,V)
3). 残差连接与
L
a
y
e
r
N
o
r
m
a
l
i
z
a
t
i
o
n
Layer\ Normalization
LayerNormalization
X
a
t
t
e
n
t
i
o
n
=
X
+
X
a
t
t
e
n
t
i
o
n
X
a
t
t
e
n
t
i
o
n
=
L
a
y
e
r
N
o
r
m
(
X
a
t
t
e
n
t
i
o
n
)
X_{attention} = X + X_{attention}\\ X_{attention} = LayerNorm(X_{attention})
Xattention=X+XattentionXattention=LayerNorm(Xattention)
4). 下面进行
F
e
e
d
F
o
r
w
a
r
d
Feed\ Forward
FeedForward, 其实就是两层线性映射并用激活函数激活, 比如说
R
e
L
U
ReLU
ReLU:
X
h
i
d
d
e
n
=
A
c
t
i
v
a
t
e
(
L
i
n
e
a
r
(
L
i
n
e
a
r
(
X
a
t
t
e
n
t
i
o
n
)
)
)
即
:
F
F
N
(
x
)
=
m
a
x
(
0
,
x
W
1
+
b
1
)
W
2
+
b
2
X_{hidden} = Activate(Linear(Linear(X_{attention}))) \\ 即:FFN(x)=max(0,xW_{1}+b_{1})W_{2}+b_{2}
Xhidden=Activate(Linear(Linear(Xattention)))即:FFN(x)=max(0,xW1+b1)W2+b2
5). 重复 3)残差连接与
L
a
y
e
r
N
o
r
m
a
l
i
z
a
t
i
o
n
Layer Normalization
LayerNormalization: 令:
X
h
i
d
d
e
n
=
X
a
t
t
e
n
t
i
o
n
+
X
h
i
d
d
e
n
X
h
i
d
d
e
n
=
L
a
y
e
r
N
o
r
m
(
X
h
i
d
d
e
n
)
X
h
i
d
d
e
n
i
n
R
b
a
t
c
h
.
s
i
z
e
∗
s
e
q
.
l
e
n
∗
.
e
m
b
e
d
.
d
i
m
.
X_{hidden} = X_{attention} + X_{hidden}\\ X_{hidden} = LayerNorm(X_{hidden})\\ X_{hidden}\ \ in\ \mathbb{R} ^ { batch.size* seq. len*. embed. dim.}
Xhidden=Xattention+XhiddenXhidden=LayerNorm(Xhidden)XhiddeninRbatch.size∗seq.len∗.embed.dim.
在完整的Encoder中,上述步骤的2)~5)要堆叠式的重复6次。
Position-wise Feed-Forward Networks
Encoder 和Decoder都包含了一个fully connected feed-forward network,特殊的是,这个网络分别对每个位置的attention层的输出向量单独地进行作用,整个过程包括了两次线性变换以及一次ReLU激活。
F
F
N
(
x
)
=
m
a
x
(
0
,
x
W
1
+
b
1
)
W
2
+
b
2
FFN(x)=max(0,xW_{1}+b_{1})W_{2}+b_{2}
FFN(x)=max(0,xW1+b1)W2+b2 对于不同位置的线性变换是完全一样的,即使使用相同的参数。这一层的输入输出都是
d
m
o
d
e
l
=
512
d_{model}=512
dmodel=512,中间隐层的维度为
d
f
f
=
2048
d_{ff}=2048
dff=2048。 用了两层Dense层,第二层的activation用的是Relu。可以看成是两层的1*1的1d-convolution。hidden_size变化为:
512
−
>
2048
−
>
512
512->2048->512
512−>2048−>512。 Position-wise feed forward network,其实就是一个MLP 网络,子层的输出中每个
d
m
o
d
e
l
d_{model}
dmodel 维向量 x 在此先由
x
W
1
+
b
1
xW_1+b_1
xW1+b1 变为
d
f
f
d_{ff}
dff维的
x
′
x'
x′,再经过
m
a
x
(
0
,
x
′
)
W
2
+
b
2
max(0,x')W_2+b_2
max(0,x′)W2+b2 回归
d
m
o
d
e
l
d_{model}
dmodel 维。之后再是一个residual connection。输出 size 仍是
[
s
e
q
u
e
n
c
e
l
e
n
g
t
h
,
d
m
o
d
e
l
]
[sequence\ length, d_{model}]
[sequencelength,dmodel]
Embeddings and Softmax
使用已经训练好的embeddings将input token和output token转换成
d
m
o
d
e
l
d_{model}
dmodel维度的向量。在最后Decoder的输出时,将Decoder的输出通过一个线性变换层和一个softmax层,转换成预测下一个token的概率向量,这两个层中参数也是提前训练好的。 在transformer模型中,两个embedding layers以及最后的softmax之前的线性变换,这三者共享使用相同的矩阵权值。对于embedding层,里面的权值需要乘以
d
m
o
d
e
l
\sqrt{d_{model}}
dmodel之后再使用。
Positional Encoding
因为模型完全没有使用RNN和CNN,而又想使用序列中的顺序信息,就必须加入一些关于token的相对位置和绝对位置的信息。因此我们加入了Positional Encoding,作为Encoder和Decoder的输入。需要注意的是Positional Encoding产生的每个向量维度为
d
m
o
d
e
l
d_{model}
dmodel,与原本的embedding向量维度相同,从而两者可以被相加使用。
实际上,Position Encoding的大小为
[
m
a
x
s
e
q
u
e
n
c
e
l
e
n
g
t
h
,
e
m
b
e
d
d
i
n
g
d
i
m
e
n
s
i
o
n
]
[max\ sequence\ length, embedding\ dimension]
[maxsequencelength,embeddingdimension],嵌入的维度同词向量的维度,即等于
d
m
o
d
e
l
=
512
d_{model}=512
dmodel=512,
m
a
x
s
e
q
u
e
n
c
e
l
e
n
g
t
h
max\ sequence\ length
maxsequencelength属于超参数,指的是限定的最大单个句长。
对位置进行embedding的方法有很多,有训练方法和指定方法。在本文中,采用频率不同的sin函数和cos函数。
P
E
(
p
o
s
,
2
i
)
=
s
i
n
(
p
o
s
/
1000
0
2
i
d
m
o
d
e
l
)
P
E
(
p
o
s
,
2
i
+
1
)
=
c
o
s
(
p
o
s
/
1000
0
2
i
d
m
o
d
e
l
)
PE_{(pos,2i)}=sin(pos/10000^{\frac{2i}{d_{model}}})\\ PE_{(pos,2i+1)}=cos(pos/10000^{\frac{2i}{d_{model}}})
PE(pos,2i)=sin(pos/10000dmodel2i)PE(pos,2i+1)=cos(pos/10000dmodel2i)
上述表达式中,pos指的是句中字(或词)的位置,取值范围是
[
0
,
m
a
x
s
e
q
u
e
n
c
e
l
e
n
g
t
h
)
[0, max\ sequence\ length)
[0,maxsequencelength)(注意左闭右开),i指的是维度向量的第i维,取值范围是
[
0
,
e
m
b
e
d
d
i
n
g
d
i
m
e
n
s
t
i
o
n
)
[0, embedding\ dimenstion)
[0,embeddingdimenstion),上面有
s
i
n
sin
sin和
c
o
s
cos
cos一组公式,对应着embedding dimension上的一组奇数和偶数的序号的维度。例如,当i=0的时候
2
i
=
0
,
2
i
+
1
=
1
2i=0,2i+1=1
2i=0,2i+1=1,那么久对应着
(
0
,
1
)
(0,1)
(0,1)这组维度,对于偶数维用
s
i
n
sin
sin函数,奇数维用
c
o
s
cos
cos函数,也就是说,第0维用
s
i
n
sin
sin函数,第1维用
c
o
s
cos
cos函数,从而产生不同的周期性变化。那么可知
i
<
=
d
m
o
d
e
l
/
2
i<=d_{model}/2
i<=dmodel/2。如下图所示:
位置嵌入在 embedding dimension维度上随着维度序号的增大,周期会越来越大(从
2
π
2 \pi
2π到
2
π
∗
10000
2\pi*10000
2π∗10000),从而产生一种包含位置信息的纹理。而每一个位置在embedding dimension维度上都会得到不同周期的
s
i
n
sin
sin和
c
o
s
cos
cos函数的取值组合,从而产生独一的纹理位置信息,模型从而学到位置之间的依赖关系(函数图像是连续的)和自然语言的时序特性(周期内不同时刻对应于函数图像上不同的位置)。
Position Embedding本身是一个绝对位置信息,由于sin函数和cos函数的特性:
S
i
n
(
α
+
β
)
=
s
i
n
α
c
o
s
β
+
c
o
s
α
s
i
n
β
C
o
s
(
α
+
β
)
=
c
o
s
α
c
o
s
β
−
s
i
n
α
s
i
n
β
Sin(\alpha+\beta)=sin\alpha cos\beta +cos\alpha sin\beta\\ Cos(\alpha+\beta)=cos\alpha cos\beta -sin\alpha sin\beta
Sin(α+β)=sinαcosβ+cosαsinβCos(α+β)=cosαcosβ−sinαsinβ 这表明
P
E
p
o
s
+
k
PE_{pos+k}
PEpos+k可以表示为
P
E
p
o
s
PE_{pos}
PEpos的线性函数。
Transformer使用Adam optimizer with
β
1
=
0.9
,
β
2
=
0.98
,
ϵ
=
1
0
−
9
\beta_{1}=0.9,\ \beta_{2}=0.98,\ \epsilon=10^{-9}
β1=0.9,β2=0.98,ϵ=10−9,学习率根据下面的计算公式进行变动,现有一个预热,学习率会呈线性增长,然后呈幂函数递减,类似于下图所示。。
l
r
a
t
e
=
d
m
o
d
e
l
−
0.5
∗
m
i
n
(
s
t
e
p
_
n
u
m
−
0.5
,
s
t
e
p
_
n
u
m
∗
w
a
r
m
u
p
s
t
e
p
s
−
1.5
)
lrate=d_{model}^{-0.5}*min(step\_num^{-0.5},step\_num\ *warmup_steps^{-1.5})
lrate=dmodel−0.5∗min(step_num−0.5,step_num∗warmupsteps−1.5)
Label Smothing Regularization(LSR)是2015年发表在CoRR的paper:Rethinking the inception architecture for computer vision中的一个idea,这个idea简单又实用。假设数据样本x的针对label条件概率的真实分布为:
q
(
k
∣
x
)
=
δ
k
,
y
=
{
1
,
k
=
y
0
,
k
≠
y
q(k|x)=\delta_{k,y}=\left\{ \begin{aligned} 1, k = y\\ 0, k \neq y \end{aligned} \right.
q(k∣x)=δk,y={1,k=y0,k=y 这使得模型对自己给出的预测太过自信,容易导致过拟合并且自适应能力差(easy cause overfit and hard to adapt)。解决方案是:给label分布加入平滑分布
u
(
k
)
u(k)
u(k),一般取平均分布
u
(
k
)
=
1
k
u(k)=\frac{1}{k}
u(k)=k1就可以,于是得到:
q
′
(
k
∣
x
)
=
(
1
−
ϵ
)
δ
k
,
y
+
ϵ
u
(
k
)
q'(k|x)=(1-\epsilon)\delta_{k,y}+\epsilon u(k)
q′(k∣x)=(1−ϵ)δk,y+ϵu(k) 映射到损失函数 cross entropy有:
H
(
q
′
,
p
)
=
−
∑
k
=
1
K
log
p
(
k
)
q
′
(
k
)
=
(
1
−
ϵ
)
H
(
q
,
p
)
+
ϵ
H
(
u
,
p
)
\begin{aligned} H(q',p)&=-\sum_{k=1}^{K}\log^{p(k)}q'(k)\\ &=(1-\epsilon)H(q,p)+\epsilon H(u,p) \end{aligned}
H(q′,p)=−k=1∑Klogp(k)q′(k)=(1−ϵ)H(q,p)+ϵH(u,p) 由上式可以知道,LSR使得不仅要最小化原来的交叉熵
H
(
q
,
p
)
H(q,p)
H(q,p),还要考虑预测分布p与
u
(
k
)
u(k)
u(k)之间差异最小化,使得模型预测泛化能力更好。transformer的论文指定
ϵ
l
s
=
0.1
\epsilon_{ls}=0.1
ϵls=0.1。 下表是使用LSR和未使用LSR在tensorflow datasets的ted_hrlr_translate/pt_to_en dataset上bleu score对比