seq2seq 是一个 Encoder–Decoder 结构的网络，它的输入是一个序列，输出也是一个序列， Encoder 中将一个可变长度的信号序列变为固定长度的向量表达，Decoder 将这个固定长度的向量变成可变长度的目标的信号序列。这个结构最重要的地方在于输入序列和输出序列的长度是可变的 ，可以用于翻译，聊天机器人，句法分析，文本摘要等。把Encoder的最后一个隐状态赋值给c ，还可以对最后的隐状态做一个变换得到c ，也可以对所有的隐状态做变换 。
h
0
h_0
h 0
编码器的作⽤是把⼀个不定⻓的输⼊序列变换成⼀个定⻓的背景变量c, 常⽤的编码器是循环神经⽹络。考虑批量⼤⼩为1的时序数据样本。假设输⼊序列是
x
1
,
x
2
,
.
.
.
,
x
T
x_1, x_2,...,x_T
x 1 , x 2 , . . . , x T
x
i
x_i
x i
i
i
i
t
t
t
x
t
x_t
x t
h
t
−
1
h_{t-1}
h t − 1
h
t
h_t
h t
h
t
=
f
(
x
t
,
h
t
−
1
)
h_t=f(x_t, h_{t-1})
h t = f ( x t , h t − 1 )
q
q
q
c
=
q
(
h
1
,
h
2
,
.
.
.
,
h
T
)
c=q(h_1, h_2, ..., h_T)
c = q ( h 1 , h 2 , . . . , h T )
q
(
h
1
,
h
2
,
.
.
.
,
h
T
)
=
h
T
q(h_1, h_2, ..., h_T)=h_T
q ( h 1 , h 2 , . . . , h T ) = h T
h
T
h_T
h T
给定训练样本中的输出序列
y
1
,
y
2
,
.
.
.
,
y
T
y_1, y_2, ..., y_T
y 1 , y 2 , . . . , y T
t
t
t
y
t
y_t
y t
y
1
,
y
2
,
.
.
.
,
y
t
−
1
y_1, y_2, ..., y_{t-1}
y 1 , y 2 , . . . , y t − 1
c
c
c
P
(
y
t
∣
y
1
,
y
2
,
.
.
.
,
y
t
−
1
,
c
)
P(y_t|y_1, y_2, ..., y_{t-1}, c)
P ( y t ∣ y 1 , y 2 , . . . , y t − 1 , c )
为此，我们可以使⽤另⼀个循环神经⽹络作为解码器，在输出序列的时间步
t
t
t
y
t
−
1
y_{t-1}
y t − 1
c
c
c
s
t
−
1
s_{t-1}
s t − 1
s
t
s_t
s t
s
t
=
g
(
y
t
−
1
,
c
,
s
t
−
1
)
s_t = g(y_{t-1}, c, s_{t-1})
s t = g ( y t − 1 , c , s t − 1 )
根据最⼤似然估计，我们可以最⼤化输出序列基于输⼊序列的条件概率
P
(
y
1
,
…
,
y
T
′
∣
x
1
,
…
,
x
T
)
=
∏
t
′
=
1
T
′
P
(
y
t
′
∣
y
1
,
…
,
y
t
′
−
1
,
x
1
,
…
,
x
T
)
=
∏
t
′
=
1
T
′
P
(
y
t
′
∣
y
1
,
…
,
y
t
′
−
1
,
c
)
\begin{aligned} P\left(y_{1}, \ldots, y_{T^{\prime}} | x_{1}, \ldots, x_{T}\right) &=\prod_{t^{\prime}=1}^{T^{\prime}} P\left(y_{t^{\prime}} | y_{1}, \ldots, y_{t^{\prime}-1}, x_{1}, \ldots, x_{T}\right) \\ &=\prod_{t^{\prime}=1}^{T^{\prime}} P\left(y_{t^{\prime}} | y_{1}, \ldots, y_{t^{\prime}-1}, \boldsymbol{c}\right) \end{aligned}
P ( y 1 , … , y T ′ ∣ x 1 , … , x T ) = t ′ = 1 ∏ T ′ P ( y t ′ ∣ y 1 , … , y t ′ − 1 , x 1 , … , x T ) = t ′ = 1 ∏ T ′ P ( y t ′ ∣ y 1 , … , y t ′ − 1 , c )
−
log
P
(
y
1
,
…
,
y
T
′
∣
x
1
,
…
,
x
T
)
=
−
∑
t
′
=
1
T
′
log
P
(
y
t
′
∣
y
1
,
…
,
y
t
′
−
1
,
c
)
-\log P\left(y_{1}, \ldots, y_{T^{\prime}} | x_{1}, \ldots, x_{T}\right)=-\sum_{t^{\prime}=1}^{T^{\prime}} \log P\left(y_{t^{\prime}} | y_{1}, \ldots, y_{t^{\prime}-1}, \boldsymbol{c}\right)
− log P ( y 1 , … , y T ′ ∣ x 1 , … , x T ) = − t ′ = 1 ∑ T ′ log P ( y t ′ ∣ y 1 , … , y t ′ − 1 , c ) 强制教学 （teacher forcing）。而在测试的时候因为不知道标签，因此将上一时刻的输出作为当前时刻的输入。
假设解码器的输出是⼀段⽂本序列。设输出⽂本词典
V
V
V
∣
V
∣
|V|
∣ V ∣
O
(
∣
V
∣
T
)
O(|V|^T)
O ( ∣ V ∣ T )
P
(
y
1
,
…
,
y
T
′
∣
x
1
,
…
,
x
T
)
=
∏
t
′
=
1
T
′
P
(
y
t
′
∣
y
1
,
…
,
y
t
′
−
1
,
c
)
P\left(y_{1}, \ldots, y_{T^{\prime}} | x_{1}, \ldots, x_{T}\right)=\prod_{t^{\prime}=1}^{T^{\prime}} P\left(y_{t^{\prime}} | y_{1}, \ldots, y_{t^{\prime}-1}, \boldsymbol{c}\right)
P ( y 1 , … , y T ′ ∣ x 1 , … , x T ) = ∏ t ′ = 1 T ′ P ( y t ′ ∣ y 1 , … , y t ′ − 1 , c )
y
1
,
y
2
,
.
.
.
,
y
T
y_1, y_2, ...,y_T
y 1 , y 2 , . . . , y T
对每一次的输出，都使得
P
(
y
t
∣
y
1
,
y
2
,
.
.
.
,
y
t
−
1
,
c
)
P(y_t|y_1, y_2, ..., y_{t-1}, c)
P ( y t ∣ y 1 , y 2 , . . . , y t − 1 , c )
P
(
y
1
,
…
,
y
T
′
∣
x
1
,
…
,
x
T
)
P\left(y_{1}, \ldots, y_{T^{\prime}} | x_{1}, \ldots, x_{T}\right)
P ( y 1 , … , y T ′ ∣ x 1 , … , x T )
穷举所有可能的输出序列，输出条件概率最⼤的序列；穷举搜索可以得到最优输出序列，但它的计算开销
O
(
∣
V
∣
T
)
O(|V|^T)
O ( ∣ V ∣ T )
O
(
T
∣
V
∣
)
O(T|V|)
O ( T ∣ V ∣ )
束搜索（beam search）是对贪婪搜索的⼀个改进算法。它有⼀个束宽（beam size）超参数。我们将它设为
k
k
k
k
k
k
k
k
k
k
k
k
k
∣
V
∣
k|V|
k ∣ V ∣
k
k
k
V
=
{
A
,
B
,
C
,
D
,
E
}
V=\{A, B, C, D, E\}
V = { A , B , C , D , E }
P
(
y
1
∣
c
)
P(y_1|c)
P ( y 1 ∣ c )
A
A
A
C
C
C
y
2
∈
V
y_2 \in V
y 2 ∈ V
P
(
y
2
∣
A
,
c
)
P(y_2|A, c)
P ( y 2 ∣ A , c )
P
(
y
2
∣
C
,
c
)
P(y_2|C, c)
P ( y 2 ∣ C , c )
P
(
B
∣
A
,
c
)
P(B|A, c)
P ( B ∣ A , c )
P
(
E
∣
C
,
c
)
P(E|C,c)
P ( E ∣ C , c )
y
3
∈
V
y_3 \in V
y 3 ∈ V
P
(
y
3
∣
A
,
B
,
c
)
P(y_3|A, B, c)
P ( y 3 ∣ A , B , c )
P
(
y
3
∣
C
,
E
,
c
)
P(y_3|C, E, c)
P ( y 3 ∣ C , E , c )
P
(
D
∣
A
,
B
,
c
)
P(D|A, B, c)
P ( D ∣ A , B , c )
P
(
D
∣
C
,
E
,
c
)
P(D|C, E, c)
P ( D ∣ C , E , c )
在最终候选输出序列的集合中，我们取以下分数最⾼的序列作为输出序列：
1
L
α
log
P
(
y
1
,
…
,
y
L
)
=
1
L
α
∑
t
′
=
1
L
log
P
(
y
t
′
∣
y
1
,
…
,
y
t
′
−
1
,
c
)
\frac{1}{L^{\alpha}} \log P\left(y_{1}, \ldots, y_{L}\right)=\frac{1}{L^{\alpha}} \sum_{t^{\prime}=1}^{L} \log P\left(y_{t^{\prime}} | y_{1}, \ldots, y_{t^{\prime}-1}, \boldsymbol{c}\right)
L α 1 log P ( y 1 , … , y L ) = L α 1 t ′ = 1 ∑ L log P ( y t ′ ∣ y 1 , … , y t ′ − 1 , c )
L
L
L
α
\alpha
α
L
α
L^\alpha
L α
O
(
k
∣
V
∣
T
)
O(k|V|T)
O ( k ∣ V ∣ T )
k
k
k
上文中，解码器在各个时间步依赖相同的背景变量来获取输⼊序列信息。当编码器为循环神经⽹络时，背景变量来⾃它最终时间步的隐藏状态或者各个时间步隐藏状态的变换（即背景向量是一个固定的向量）。很明显这样做有两个缺点
为了解决上面两个问题，于是引入了 Ａttention 模型。Attention机制通过在每个时间输入不同的c 来解决这个问题；仍然以循环神经⽹络为例，注意⼒机制通过对编码器所有时间步的隐藏状态做加权平均 来得到背景变量。解码器在每⼀时间步调整这些权重，即注意⼒权重，从⽽能够在不同时间步分别关注输⼊序列中的不同部分并编码进相应时间步的背景变量。从上文分析中可知，解码器在时间步
t
t
t
s
t
=
g
(
y
t
−
1
,
s
t
−
1
,
c
)
s_t = g(y_{t-1}, s_{t-1}, c)
s t = g ( y t − 1 , s t − 1 , c )
c
c
c
t
t
t
s
t
=
g
(
y
t
−
1
,
s
t
−
1
,
c
t
)
s_t = g(y_{t-1}, s_{t-1}, c_t)
s t = g ( y t − 1 , s t − 1 , c t )
c
t
c_t
c t
s
t
s_t
s t
下图绘制了注意⼒机制如何为解码器在时间步2 计算背景变量。⾸先，函数
a
a
a 解码器在时间步1的隐藏状态 和编码器在各个时间步的隐藏状态 计算softmax运算的输⼊。softmax运算输出概率分布并对编码器各个时间步的隐藏状态做加权平均，从⽽得到背景变量。
t
t
t
h
t
h_t
h t
T
T
T
i
i
i
c
i
=
∑
t
=
1
T
α
i
t
h
t
\boldsymbol{c}_i=\sum_{t=1}^{T} \alpha_{i t} \boldsymbol{h}_{t}
c i = t = 1 ∑ T α i t h t
i
i
i
α
i
t
\alpha_{it}
α i t
α
i
t
=
exp
(
e
i
t
)
∑
k
=
1
T
exp
(
e
i
k
)
,
t
=
1
,
…
,
T
\alpha_{i t}=\frac{\exp \left(e_{i t}\right)}{\sum_{k=1}^{T} \exp \left(e_{i k}\right)}, \quad t=1, \ldots, T
α i t = ∑ k = 1 T exp ( e i k ) exp ( e i t ) , t = 1 , … , T
e
i
t
e_{i t}
e i t
e
i
t
e_{i t}
e i t
i
i
i
t
t
t
i
−
1
i-1
i − 1
s
i
−
1
s_{i-1}
s i − 1
t
t
t
h
t
h_t
h t
a
a
a
e
i
t
e_{i t}
e i t
e
i
t
=
a
(
s
i
−
1
,
h
t
)
e_{it}=a\left(\boldsymbol{s}_{i-1}, \boldsymbol{h}_{t}\right)
e i t = a ( s i − 1 , h t )
a
a
a
a
(
s
,
h
)
=
s
T
h
a(s, h)=s^Th
a ( s , h ) = s T h 单隐藏层的多层感知机变换
a
(
s
,
h
)
=
v
⊤
tanh
(
W
s
s
+
W
h
h
)
a(\boldsymbol{s}, \boldsymbol{h})=\boldsymbol{v}^{\top} \tanh \left(\boldsymbol{W}_{s} \boldsymbol{s}+\boldsymbol{W}_{h} \boldsymbol{h}\right)
a ( s , h ) = v ⊤ tanh ( W s s + W h h )
v
v
v
W
s
W_s
W s
W
h
W_h
W h
⼴义上，注意⼒机制的输⼊包括查询项 以及⼀⼀对应的键项 和值项 ，其中值项是需要加权平均的⼀组项 。在加权平均中，值项的权重来⾃查询项以及与该值项对应的键项的计算。
在上⾯的例⼦中，查询项为解码器的隐藏状态，键项和值项均为编码器的隐藏状态，让我们考虑⼀个常⻅的简单情形，即编码器和解码器的隐藏单元个数均为
h
h
h
a
(
s
,
h
)
=
s
T
h
a(s, h)=s^Th
a ( s , h ) = s T h
s
i
−
1
∈
R
h
\boldsymbol{s}_{i-1} \in \mathbb{R}^{h}
s i − 1 ∈ R h
h
t
∈
R
h
,
t
=
1
,
2
,
.
.
.
,
T
h_t \in \mathbb R^{h},t=1, 2,...,T
h t ∈ R h , t = 1 , 2 , . . . , T
c
i
∈
R
h
c_i \in \mathbb R^h
c i ∈ R h
Q
∈
R
1
×
h
Q \in \mathbb R^{1 \times h}
Q ∈ R 1 × h
s
i
−
1
s_{i-1}
s i − 1
K
∈
R
T
×
h
\boldsymbol K \in \mathbb R^{T \times h}
K ∈ R T × h
V
∈
R
T
×
h
\boldsymbol V \in \mathbb R^{T \times h}
V ∈ R T × h
t
t
t
h
t
⊤
h_t^{\top}
h t ⊤
softmax
(
Q
K
⊤
)
V
\operatorname{softmax}\left(\boldsymbol{Q} \boldsymbol{K}^{\top}\right) \boldsymbol{V}
s o f t m a x ( Q K ⊤ ) V
c
i
⊤
c_i^{\top}
c i ⊤
Q
Q
Q
n
n
n
n
n
n
以⻔控循环单元为例，在解码器中我们可以对RNN总结 中⻔控循环单元的设计稍作修改，从⽽变换上⼀时间步
i
−
1
i-1
i − 1
y
i
−
1
y_{i-1}
y i − 1
s
i
−
1
s_{i-1}
s i − 1
i
i
i
c
i
c_{i}
c i
i
i
i
s
i
=
z
i
⊙
s
i
−
1
+
(
1
−
z
i
)
⊙
s
~
i
\boldsymbol{s}_{i}=\boldsymbol{z}_{i} \odot \boldsymbol{s}_{i-1}+\left(1-\boldsymbol{z}_{i}\right) \odot \tilde{\boldsymbol{s}}_{i}
s i = z i ⊙ s i − 1 + ( 1 − z i ) ⊙ s ~ i
r
i
=
σ
(
W
y
r
y
i
−
1
+
W
s
r
s
i
−
1
+
W
c
r
c
i
+
b
r
)
z
i
=
σ
(
W
y
z
y
i
−
1
+
W
s
z
s
i
−
1
+
W
c
z
c
i
+
b
z
)
s
~
i
=
tanh
(
W
y
s
y
i
−
1
+
W
s
s
(
s
i
−
1
⊙
r
i
)
+
W
c
s
c
i
+
b
s
)
\begin{aligned} \boldsymbol{r}_{i} &=\sigma\left(\boldsymbol{W}_{y r} \boldsymbol{y}_{i-1}+\boldsymbol{W}_{s r} \boldsymbol{s}_{i-1}+\boldsymbol{W}_{c r} \boldsymbol{c}_{i}+\boldsymbol{b}_{r}\right) \\ \boldsymbol{z}_{i} &=\sigma\left(\boldsymbol{W}_{y z} \boldsymbol{y}_{i-1}+\boldsymbol{W}_{s z} \boldsymbol{s}_{i-1}+\boldsymbol{W}_{c z} \boldsymbol{c}_{i}+\boldsymbol{b}_{z}\right) \\ \tilde{\boldsymbol{s}}_{i} &=\tanh \left(\boldsymbol{W}_{y s} \boldsymbol{y}_{i-1}+\boldsymbol{W}_{s s}\left(\boldsymbol{s}_{i-1} \odot \boldsymbol{r}_{i}\right)+\boldsymbol{W}_{c s} \boldsymbol{c}_{i}+\boldsymbol{b}_{s}\right) \end{aligned}
r i z i s ~ i = σ ( W y r y i − 1 + W s r s i − 1 + W c r c i + b r ) = σ ( W y z y i − 1 + W s z s i − 1 + W c z c i + b z ) = tanh ( W y s y i − 1 + W s s ( s i − 1 ⊙ r i ) + W c s c i + b s )
动手学深度学习
