文章目录
edited by nrzheng,2021.11.25
transformer
1. 概述
1.1. 网络整体结构
transformer网络结构如下图所示:
- 注意!!!!!!!!!!
- transformer的输入是有两个的,一个在Encoder, 一个在Decoder(机器翻译是这样)
1.2. 网络结构大致解析
从全局角度先看看,transformer在做一个什么事:
TRM一开始是在机器翻译中被提出的,整个过程可以概括为下图:
不用管里面怎么做,总之经过TRM这个黑盒的操作,“我爱你”就变成了“I LOVE YOU”。
然后我们细化TRM的操作,一步一步细化。
- 输入没有发生变化,输出也没有发生变化,把TRM分成两个部分,Encoders和Decoders:
- 也就是说“我爱你”作为输入,经过Encoders,然后Encoders输出再作为Decoders的输入,流出来,就变成“I LOVE YOU”
- Encoders和Decoders就是由n个Encoder和n个Decoder组成的:
- 也就是流经多个Encoder和多个Decoder,就可以把“我爱你”变成“I LOVE YOU”
- 上图二者的个数都是6,这个数字可以自己定
- 需要注意的是,6个Encoder的结构是完全相同的,6个Decoder的结构也是完全相同的
- 但是,只是结构相同,参数是不一样的,都在训练
- Encoder和Decoder是不一样的
- 这个其实就是1.1中的那个网络结构图了,里面不是有*n嘛。(可以上去翻看看)
- (这里的每一小个Encoder就是1.1网络结构图的左半部分,每个Decoder就是右半部分)
- 需要注意的是:
- Encoder和Decoder架构是不一样的
- 多了一层交互层
- Decoder中的多了一个“Masked”
2. Encoder
2.1. Encoder概况
Encoder可以划分为三部分,如下图所示:
2.2. 输入部分
输入部分分为两个,一个是Embedding,一个是位置嵌入
2.2.1. Embedding
Embedding是NLP里面简单的入门知识
比如我们的输入句子是“我爱你…”,一共12个字,我们按字切分,每个字定义为一个512维度的字向量。这个字向量可以使用随机初始化或者word2vector
- 可以理解成图像中,用(255, 0, 0)代表红色,然后再用0代表(255, 0, 0),然后再onehot,用000001之类的代表0
- 就是把一个字,用计算机能理解的语言代替
2.2.2. 位置嵌入 / 位置编码
- 为什么需要位置编码?这里从RNN引出举例
- U:RNN的输入参数,W:隐层参数,V:输出参数。对于RNN的所有time step都共享同一套参数。就是说,有100个词,都是用这么一套参数
- 按照时间线展开(上图右),可以看到其中的U,W,V都是一样的,没有上下标,就是一套参数
- (插)RNN的梯度消失是怎么来的?
- 和普通网络的梯度消失含义不一样,它的梯度是总的梯度和
- 它的梯度消失不是变为0,而是说总梯度被近距离梯度阻挡,被远距离梯度忽略不计
所以说RNN这种结构对于处理天然的时序关系的东西很符合。就是说先处理一个东西,再处理另一个东西。
但是对于transformer来说,它是有多头注意力的,也就是说,是一下子读了好多词进去。不是像RNN,输入一个“我”,等处理完,再处理“爱”。它是一起处理的
这样做增快了速度,但是忽略了单词之间的先后关系,所以说transformer想比于RNN就缺少了某种东西,告诉模型,某些单词是在前面还是后面
所以需要位置编码
- 位置编码
位置编码的公式如下所示:
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
)
(1)
PE_{(pos,2i)}=sin(pos/10000^{2i/d_{model}}) \\PE_{(pos,2i+1)}=cos(pos/10000^{2i/d_{model}}) \tag{1}
PE(pos,2i)=sin(pos/100002i/dmodel)PE(pos,2i+1)=cos(pos/100002i/dmodel)(1)
- pos指的是position
- 2i就是偶数位,2i+1就是奇数位
- 在位置2i处,使用sin;在位置2i+1处,使用cos
- 得到位置编码之后,把位置编码和Embedding相加,得到一个512维的向量,作为整个transformer中Encoder的输入
- 为什么位置编码会有用?
借助上述公式,我们可以得到一个特定位置的
d
m
o
d
e
l
d_{model}
dmodel维的位置向量,并且借助三角函数的性质:
{
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
β
(2)
\begin{cases} sin(\alpha+\beta)=sin\alpha cos\beta+cos\alpha sin\beta\\ cos(\alpha+\beta)=cos\alpha cos\beta+sin\alpha sin\beta \end{cases} \tag{2}
{sin(α+β)=sinαcosβ+cosαsinβcos(α+β)=cosαcosβ+sinαsinβ(2)
我们可以得到:
{
P
E
(
p
o
s
+
k
,
2
i
)
=
P
E
(
p
o
s
,
2
i
)
×
P
E
(
k
,
2
i
+
1
)
+
P
E
(
p
o
s
,
2
i
+
1
)
×
P
E
(
k
,
2
i
)
P
E
(
p
o
s
+
k
,
2
i
+
1
)
=
P
E
(
p
o
s
,
2
i
+
1
)
×
P
E
(
k
,
2
i
+
1
)
−
P
E
(
p
o
s
,
2
i
)
×
P
E
(
k
,
2
i
)
(3)
\begin{cases} PE(pos+k,2i)=PE(pos,2i) \times PE(k,2i+1)+PE(pos,2i+1) \times PE(k,2i) \\ PE(pos+k,2i+1)=PE(pos,2i+1) \times PE(k,2i+1)-PE(pos,2i) \times PE(k,2i) \end{cases} \tag{3}
{PE(pos+k,2i)=PE(pos,2i)×PE(k,2i+1)+PE(pos,2i+1)×PE(k,2i)PE(pos+k,2i+1)=PE(pos,2i+1)×PE(k,2i+1)−PE(pos,2i)×PE(k,2i)(3)
可以看出,对于
p
o
s
+
k
pos+k
pos+k位置的位置向量某一维
2
i
2i
2i或
2
i
+
1
2i+1
2i+1而言,可以表示为,
p
o
s
pos
pos位置与
k
k
k位置的位置向量的
2
i
2i
2i与
2
i
+
1
2i+1
2i+1维的线性组合,这样的线性组合意味着位置向量(绝对位置)中蕴含了相对位置信息。但是这种相对位置信息会在注意力机制那里消失。
(正弦和余弦函数具有周期性,对于固定长度偏差k(类似于周期),post+k位置的PE可以表示成关于pos位置PE的一个线性变化(存在线性关系),这样可以方便模型学习词与词之间的一个相对位置关系)
2.3. 注意力机制
A t t e n t i o n ( Q , K , V ) = s o f t m a x ( Q K T k ) V (4) \large Attention(Q,K,V)=softmax(\frac {QK^T}{\sqrt k})V \tag{4} Attention(Q,K,V)=softmax(kQKT)V(4)
2.3.1 注意力
(用一个婴儿在看一张报纸的图片举例,图片就不放了)
- 左上、左下、右上、右下、V1、V2、V3、V4、婴儿。都是拿来举例的,就是QKV,向量
- 婴儿分别个左上、左下、右上、右下,做点乘。得到的数值越大,说明距离越近,越相似,越关注,就是越相关呗。
- 然后再和V相乘,就相当于是加权。
(详见下图解析)
- 把Q和K1、K2、K3、K4做F函数变换。也就是“爱”和“我”,“不”,“爱”,“你”做F函数变换
- F函数变换可以有几种操作,一般用点乘
- 得到S1、S2、S3、S4结果,再做SoftMax得到a1、a2、a3、a4。这四个相加是等于一的(假设是[0.1, 0.1, 0.7, 0.1])
- 然后和Value值相乘,再相加,就是加权。
- 除以 d k \sqrt{d_k} dk是因为QK相乘的值很大,这样SoftMax之后,梯度就会很小(为什么很小,看看SoftMax函数就知道了)。除以 d k \sqrt{d_k} dk而不是别的数,是为了控制方差为1
- 在实际操作用,使用矩阵,方便并行。
2.3.2 多头的操作
假设现在有一些句子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] [batch size,sequence length]。
在2.2之后,我们有了transformer的输入,也就是Embedding和位置编码的和。可以得到
X
e
m
b
e
d
d
i
n
g
∈
[
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
]
X_{embedding}\in[batch\ size,\ sequence\ length,\ embedding\ dimension]
Xembedding∈[batch size, sequence length, embedding dimension]。为了学到多重含义的表达,对
X
e
m
b
e
d
d
i
n
g
X_{embedding}
Xembedding做线性映射,也就是分配三个权重:
W
Q
,
W
K
,
W
V
∈
ℜ
e
m
b
e
d
.
d
i
m
.
×
e
m
b
e
d
.
d
i
m
.
(5)
W_Q,W_K,W_V\in\Re^{embed.dim.\times embed.dim.} \tag{5}
WQ,WK,WV∈ℜembed.dim.×embed.dim.(5)
线性映射之后形成三个矩阵,为Q,K,V,和线性变化之前的维度一致,线性变换的公式:
Q
=
L
i
n
e
a
r
(
X
e
m
b
e
d
d
i
n
g
)
=
X
e
m
b
e
d
d
i
n
g
W
Q
K
=
L
i
n
e
a
r
(
X
e
m
b
e
d
d
i
n
g
)
=
X
e
m
b
e
d
d
i
n
g
W
K
V
=
L
i
n
e
a
r
(
X
e
m
b
e
d
d
i
n
g
)
=
X
e
m
b
e
d
d
i
n
g
W
V
(6)
Q=Linear(X_{embedding})=X_{embedding}W_Q\\ K=Linear(X_{embedding})=X_{embedding}W_K\\ V=Linear(X_{embedding})=X_{embedding}W_V \tag{6}
Q=Linear(Xembedding)=XembeddingWQK=Linear(Xembedding)=XembeddingWKV=Linear(Xembedding)=XembeddingWV(6)
接下来就是多头注意力机制,(这几步的)流程图如下:
进行MHSA,我们要定义一个超参数h,也就是head的数量,注意,embedding dimension必须整除于h,因为要把它分成h份。
分割后:
Q
,
K
,
V
∈
[
b
a
t
c
h
s
i
z
e
,
s
e
q
u
e
n
c
e
l
e
n
g
t
h
,
h
,
e
m
b
e
d
d
i
n
g
d
i
m
e
n
s
i
o
n
/
h
]
Q,K,V\in [batch\ size,\ sequence\ length,\ h,\ embedding\ dimension/h]
Q,K,V∈[batch size, sequence length, h, embedding dimension/h]
为了方便计算,进行转置,转置后:
Q
,
K
,
V
∈
[
b
a
t
c
h
s
i
z
e
,
h
,
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
/
h
]
Q,K,V\in [batch\ size,\ h,\ sequence\ length,\ embedding\ dimension/h]
Q,K,V∈[batch size, h, sequence length, embedding dimension/h]
我们拿出一组来解释(QKV的计算):
- 如上图所示,先计算Q与K的转置的点积。(点积的几何意义上面解释了)
- 点击的结果就是生成注意力矩阵。注意力矩阵的第一行就是第一个字c1与这六个字分别的相关程度。
- 然后用SoftMax进行归一化,这样每个字跟其他所有字的注意力权重的和为1
- 接着用注意力矩阵给V加权,见下图
上图中我们从注意力矩阵中取出一行(和为1)然后依次点乘V的列,矩阵V的每一行代表着每个字向量的数学表达。上图的操作正是用注意力权重进行这些数学表达的加权线性组合,从而使每个字向量都含有当前句子内所有字向量的信息。
注意进行点积运算之后,V的维度没有变化哦。还是 [ b a t c h s i z e , h , 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 / h ] [batch\ size,\ h,\ sequence\ length,\ embedding\ dimension/h] [batch size, h, sequence length, embedding dimension/h]
在上面的self attention的计算过程中,我们通常采用mini batch来计算,也就是一次计算多句话,也就是 X ∈ [ b a t c h s i z e , s e q u e n c e l e n g t h ] X\in [batch\ size, sequence\ length] X∈[batch size,sequence length],sequence length 是句长。而一个mini batch是有多个不等长的句子组成的,我们就需要按照这个mini batch中最大的句长对剩余的句子进行补齐长度,一般使用0来填充,也就是padding。
但是在这时进行SoftMax就会产生问题。SoftMax函数如下:
σ
(
z
)
=
e
z
i
∑
j
=
1
k
e
z
j
(7)
\LARGE \sigma(z)=\frac{e^{z_i}}{\sum_{j=1}^k e^{z_j}} \tag{7}
σ(z)=∑j=1kezjezi(7)
e的0次方是1,是有值的,这样的话softmax中被padding的部分就参与了运算,就等于是让无效的部分参与了运算,会产生很大的隐患,这时就需要做一个mask让这些无效区域不参与运算,我们一般给无效区域加一个很大的负数的偏置,也就是:
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
(8)
z_{illegal}=z_{illegal}+bias_{illegal}\\ bias_{illegal}\rightarrow -\infty\\ e^{z_illegal}\rightarrow0 \tag{8}
zillegal=zillegal+biasillegalbiasillegal→−∞ezillegal→0(8)
经过上式的masking我们使无效区域经过softmax计算之后还几乎为0,这样就避免了无效区域参与计算。
2.4. 残差和LayerNorm
2.4.1. 残差
略了。可以去看ResNet的那篇笔记
上图就是把x拿过去跟z相加,再放进去LayerNorm
2.4.2. LayerNorm
为什么使用Layer Normalization,而不是使用常用的Batch Normalization?
- 因为BN效果差,所以不用
为什么BN效果差呢?
- BN是针对整个Batch中的样本,在同一维度的特征做处理
- LN则不一样,具体见下图
- 这边用班级同学的例子来解释
- 每一列代表不同的样本,也就是同学(小明、小红、…)
- 每一行代表一个特征,也就是(体重、身高、成绩、…)
- BN是针对所有样本的每一个特征做BN,比如:体重做BN、身高做BN、成绩做BN(也就是上图绿色框框)
- (LN是对一个样本的所有特征做归一化,就是上图的一列。下面会具体解释为什么这样好)
- BN的优点:
- 解决内部协变量偏移(什么隐藏层啥的,不懂,不用深究)
- 缓解梯度饱和问题(如果使用sigmoid激活函数的话),加快收敛
- BN的缺点:
- batch size较小的时候,效果差
- 很容易理解,因为BN就是用batch的均值和方差来模拟所有样本的均值和方差。batch size小了误差就大了
- 如小明一个人的均值和方差,就不能代表全班的
- BN在RNN中效果比较差,这一点和第一点原因很类似
- batch size较小的时候,效果差
- 可以看到,在这个例子中,BN很合理,因为对所有人的身高、体重等做BN,很合理
- 但是,用在NLP中,就会有很大的问题
为什么使用LayerNorm?为什么LayerNorm单独对一个样本的所有单词做缩放可以起到效果。
- 接下来用NLP来举例
- 上图每一列当作一个句子。比如:第一列是我爱中国共产党;第二列是今天天气真不错
- 可见,如果用BN的话,就是“我”和“今”做均值方差,“爱”和“天”做均值方差,…。它代表的意思就是“我”和“今”代表同样的语义信息…
- LN针对的就是“我爱中国共产党”来做均值和方差。它默认的意思就是“我爱中国共产党”在同一个语义信息里面
- (这是视频作者自己的理解)
2.5. 前馈神经网络
(就是两层的全连接)没啥好说的
- 用了两层全连接层,激活函数都是ReLU,可以看成是两层1*1的1维卷积
- 尺度变化为512—2048—512
- 公式如下:
F F N ( x ) = m a x ( 0 , x W 1 + b 1 ) W 2 + b 2 \large FFN(x)=max(0,xW_1+b_1)W_2+b_2 FFN(x)=max(0,xW1+b1)W2+b2
3. Decoder
3.1. Decoder概况
Decoder可以划分为两部分,如下所示:
3.2. Decoder中的多头注意力机制
注意,Decoder中的多头注意力机制多了一个Masked,为什么要masked呢?
- Masked操作就是把当前词及其之后的全部都不看!!!
- 假设在输入“LOVE”的时候,Decoder没有masked,和Encoder的多头注意力机制一样结构的话
- 那么,“S”、“I”、“LOVE”、“YOU”、“NOW”就都会为“YOU”的预测输出提供信息
- 但是,这样训练出来的模型,在训练阶段会出现问题
- 因为预测的时候。是没有真值的,也就是说,后面的句子是看不到的。那么预测就会有问题。
- 所以说,在训练的时候,Decoder中的多头需要Masked掉
- 训练跟预测保持了一致性
- (记住,transformer的输入是有两个的,一个在Encoder,一个在Decoder,中间还有一个交互)
3.3. Dncoder和Decoder的交互层
Encoder生成KV矩阵,Decoder生成Q矩阵,然后进行普通的多头注意力机制
4. 代码
4.1. 三类应用
- Encoder和Decoder共同使用:机器翻译类应用
- 只使用Encoder:文本分类BERT和图片分类VIT
- 只使用Decoder:生成类模型
4.2. 代码详解
sentences = ['ich mochte ein bier P', 'S i want a beer', 'i want a beer E']
-
里面有三个句子,但是我们要明白,这算是一组句子。也就是说属于一个样本,batch size等于1的
- 如果batch size要等于4,那就是有4组句子,如果都是上面那个的话,那就是4组句子,每组句子里面有三个句子
-
有两个问题:
- 这三个句子分别代表什么,怎么被模型处理掉
- 三个句子中的特殊符号,P、S、E,分别代表什么
-
第一个问题:
-
看一眼transformer网络结构图,我们要明白,它是有两个输入的,一个是编码端的输入,一个是解码端的输入
-
抽离出来,放到机器翻译中来看:
-
-
“我爱你”是编码端的输入,“S I LOUE YOU”是解码端的输入
-
“I LOVE YOU E”不是解码端的输出,这是解码端的真实标签
-
解码端输出会跟真实标签做损失
-
用这个代码来当作示例,就是:
# "我爱你" "ich mochte ein bier P"
# "S I LOVE YOU" "S i want a beer"
# "I LOVE YOU E" "i want a beer E"
- 第二个问题:
- S代表start
- E代表end
- P代表的是一个pad字符(因为一个batch中句子长度可能不一样,所以就要规定一个最大长度max length,大于的就截断,小于的就使用特殊字符来填充,也就是P,如下图:)
不想写了,看视频或者自己调试一下代码就知道了
4.3. 代码
"""
orginal from :
https://github.com/graykode/nlp-tutorial/blob/master/5-1.Transformer/Transformer.ipynb
"""
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
import math
def make_batch(sentences):
input_batch = [[src_vocab[n] for n in sentences[0].split()]]
output_batch = [[tgt_vocab[n] for n in sentences[1].split()]]
target_batch = [[tgt_vocab[n] for n in sentences[2].split()]]
return torch.LongTensor(input_batch), torch.LongTensor(output_batch), torch.LongTensor(target_batch)
## 10
def get_attn_subsequent_mask(seq):
"""
seq: [batch_size, tgt_len]
"""
attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
# attn_shape: [batch_size, tgt_len, tgt_len]
subsequence_mask = np.triu(np.ones(attn_shape), k=1) # 生成一个上三角矩阵
subsequence_mask = torch.from_numpy(subsequence_mask).byte()
return subsequence_mask # [batch_size, tgt_len, tgt_len]
## 7. ScaledDotProductAttention
class ScaledDotProductAttention(nn.Module):
def __init__(self):
super(ScaledDotProductAttention, self).__init__()
def forward(self, Q, K, V, attn_mask):
## 输入进来的维度分别是 [batch_size x n_heads x len_q x d_k] K: [batch_size x n_heads x len_k x d_k] V: [batch_size x n_heads x len_k x d_v]
##首先经过matmul函数得到的scores形状是 : [batch_size x n_heads x len_q x len_k]
scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)
## 然后关键词地方来了,下面这个就是用到了我们之前重点讲的attn_mask,把被mask的地方置为无限小,softmax之后基本就是0,对q的单词不起作用
scores.masked_fill_(attn_mask, -1e9) # Fills elements of self tensor with value where mask is one.
attn = nn.Softmax(dim=-1)(scores)
context = torch.matmul(attn, V)
return context, attn
## 6. MultiHeadAttention
class MultiHeadAttention(nn.Module):
def __init__(self):
super(MultiHeadAttention, self).__init__()
## 输入进来的QKV是相等的,我们会使用映射linear做一个映射得到参数矩阵Wq, Wk,Wv
self.W_Q = nn.Linear(d_model, d_k * n_heads)
self.W_K = nn.Linear(d_model, d_k * n_heads)
self.W_V = nn.Linear(d_model, d_v * n_heads)
self.linear = nn.Linear(n_heads * d_v, d_model)
self.layer_norm = nn.LayerNorm(d_model)
def forward(self, Q, K, V, attn_mask):
## 这个多头分为这几个步骤,首先映射分头,然后计算atten_scores,然后计算atten_value;
##输入进来的数据形状: Q: [batch_size x len_q x d_model], K: [batch_size x len_k x d_model], V: [batch_size x len_k x d_model]
residual, batch_size = Q, Q.size(0)
# (B, S, D) -proj-> (B, S, D) -split-> (B, S, H, W) -trans-> (B, H, S, W)
##下面这个就是先映射,后分头;一定要注意的是q和k分头之后维度是一致额,所以一看这里都是dk
q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1,2) # q_s: [batch_size x n_heads x len_q x d_k]
k_s = self.W_K(K).view(batch_size, -1, n_heads, d_k).transpose(1,2) # k_s: [batch_size x n_heads x len_k x d_k]
v_s = self.W_V(V).view(batch_size, -1, n_heads, d_v).transpose(1,2) # v_s: [batch_size x n_heads x len_k x d_v]
## 输入进行的attn_mask形状是 batch_size x len_q x len_k,然后经过下面这个代码得到 新的attn_mask : [batch_size x n_heads x len_q x len_k],就是把pad信息重复了n个头上
attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
##然后我们计算 ScaledDotProductAttention 这个函数,去7.看一下
## 得到的结果有两个:context: [batch_size x n_heads x len_q x d_v], attn: [batch_size x n_heads x len_q x len_k]
context, attn = ScaledDotProductAttention()(q_s, k_s, v_s, attn_mask)
context = context.transpose(1, 2).contiguous().view(batch_size, -1, n_heads * d_v) # context: [batch_size x len_q x n_heads * d_v]
output = self.linear(context)
return self.layer_norm(output + residual), attn # output: [batch_size x len_q x d_model]
## 8. PoswiseFeedForwardNet
class PoswiseFeedForwardNet(nn.Module):
def __init__(self):
super(PoswiseFeedForwardNet, self).__init__()
self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1)
self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1)
self.layer_norm = nn.LayerNorm(d_model)
def forward(self, inputs):
residual = inputs # inputs : [batch_size, len_q, d_model]
output = nn.ReLU()(self.conv1(inputs.transpose(1, 2)))
output = self.conv2(output).transpose(1, 2)
return self.layer_norm(output + residual)
## 4. get_attn_pad_mask
## 比如说,我现在的句子长度是5,在后面注意力机制的部分,我们在计算出来QK转置除以根号之后,softmax之前,我们得到的形状
## len_input * len*input 代表每个单词对其余包含自己的单词的影响力
## 所以这里我需要有一个同等大小形状的矩阵,告诉我哪个位置是PAD部分,之后在计算计算softmax之前会把这里置为无穷大;
## 一定需要注意的是这里得到的矩阵形状是batch_size x len_q x len_k,我们是对k中的pad符号进行标识,并没有对k中的做标识,因为没必要
## seq_q 和 seq_k 不一定一致,在交互注意力,q来自解码端,k来自编码端,所以告诉模型编码这边pad符号信息就可以,解码端的pad信息在交互注意力层是没有用到的;
def get_attn_pad_mask(seq_q, seq_k):
batch_size, len_q = seq_q.size()
batch_size, len_k = seq_k.size()
# eq(zero) is PAD token
pad_attn_mask = seq_k.data.eq(0).unsqueeze(1) # batch_size x 1 x len_k, one is masking
return pad_attn_mask.expand(batch_size, len_q, len_k) # batch_size x len_q x len_k
## 3. PositionalEncoding 代码实现
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
## 位置编码的实现其实很简单,直接对照着公式去敲代码就可以,下面这个代码只是其中一种实现方式;
## 从理解来讲,需要注意的就是偶数和奇数在公式上有一个共同部分,我们使用log函数把次方拿下来,方便计算;
## pos代表的是单词在句子中的索引,这点需要注意;比如max_len是128个,那么索引就是从0,1,2,...,127
##假设我的demodel是512,2i那个符号中i从0取到了255,那么2i对应取值就是0,2,4...510
self.dropout = nn.Dropout(p=dropout)
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)## 这里需要注意的是pe[:, 0::2]这个用法,就是从0开始到最后面,补长为2,其实代表的就是偶数位置
pe[:, 1::2] = torch.cos(position * div_term)##这里需要注意的是pe[:, 1::2]这个用法,就是从1开始到最后面,补长为2,其实代表的就是奇数位置
## 上面代码获取之后得到的pe:[max_len*d_model]
## 下面这个代码之后,我们得到的pe形状是:[max_len*1*d_model]
pe = pe.unsqueeze(0).transpose(0, 1)
self.register_buffer('pe', pe) ## 定一个缓冲区,其实简单理解为这个参数不更新就可以
def forward(self, x):
"""
x: [seq_len, batch_size, d_model]
"""
x = x + self.pe[:x.size(0), :]
return self.dropout(x)
## 5. EncoderLayer :包含两个部分,多头注意力机制和前馈神经网络
class EncoderLayer(nn.Module):
def __init__(self):
super(EncoderLayer, self).__init__()
self.enc_self_attn = MultiHeadAttention()
self.pos_ffn = PoswiseFeedForwardNet()
def forward(self, enc_inputs, enc_self_attn_mask):
## 下面这个就是做自注意力层,输入是enc_inputs,形状是[batch_size x seq_len_q x d_model] 需要注意的是最初始的QKV矩阵是等同于这个输入的,去看一下enc_self_attn函数 6.
enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V
enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size x len_q x d_model]
return enc_outputs, attn
## 2. Encoder 部分包含三个部分:词向量embedding,位置编码部分,注意力层及后续的前馈神经网络
class Encoder(nn.Module):
def __init__(self):
super(Encoder, self).__init__()
self.src_emb = nn.Embedding(src_vocab_size, d_model) ## 这个其实就是去定义生成一个矩阵,大小是 src_vocab_size * d_model
self.pos_emb = PositionalEncoding(d_model) ## 位置编码情况,这里是固定的正余弦函数,也可以使用类似词向量的nn.Embedding获得一个可以更新学习的位置编码
self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)]) ## 使用ModuleList对多个encoder进行堆叠,因为后续的encoder并没有使用词向量和位置编码,所以抽离出来;
def forward(self, enc_inputs):
## 这里我们的 enc_inputs 形状是: [batch_size x source_len]
## 下面这个代码通过src_emb,进行索引定位,enc_outputs输出形状是[batch_size, src_len, d_model]
enc_outputs = self.src_emb(enc_inputs)
## 这里就是位置编码,把两者相加放入到了这个函数里面,从这里可以去看一下位置编码函数的实现;3.
enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1)
##get_attn_pad_mask是为了得到句子中pad的位置信息,给到模型后面,在计算自注意力和交互注意力的时候去掉pad符号的影响,去看一下这个函数 4.
enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs)
enc_self_attns = []
for layer in self.layers:
## 去看EncoderLayer 层函数 5.
enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)
enc_self_attns.append(enc_self_attn)
return enc_outputs, enc_self_attns
## 10.
class DecoderLayer(nn.Module):
def __init__(self):
super(DecoderLayer, self).__init__()
self.dec_self_attn = MultiHeadAttention()
self.dec_enc_attn = MultiHeadAttention()
self.pos_ffn = PoswiseFeedForwardNet()
def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs, dec_self_attn_mask)
dec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs, dec_enc_attn_mask)
dec_outputs = self.pos_ffn(dec_outputs)
return dec_outputs, dec_self_attn, dec_enc_attn
## 9. Decoder
class Decoder(nn.Module):
def __init__(self):
super(Decoder, self).__init__()
self.tgt_emb = nn.Embedding(tgt_vocab_size, d_model)
self.pos_emb = PositionalEncoding(d_model)
self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])
def forward(self, dec_inputs, enc_inputs, enc_outputs): # dec_inputs : [batch_size x target_len]
dec_outputs = self.tgt_emb(dec_inputs) # [batch_size, tgt_len, d_model]
dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1) # [batch_size, tgt_len, d_model]
## get_attn_pad_mask 自注意力层的时候的pad 部分
dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs)
## get_attn_subsequent_mask 这个做的是自注意层的mask部分,就是当前单词之后看不到,使用一个上三角为1的矩阵
dec_self_attn_subsequent_mask = get_attn_subsequent_mask(dec_inputs)
## 两个矩阵相加,大于0的为1,不大于0的为0,为1的在之后就会被fill到无限小
dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequent_mask), 0)
## 这个做的是交互注意力机制中的mask矩阵,enc的输入是k,我去看这个k里面哪些是pad符号,给到后面的模型;注意哦,我q肯定也是有pad符号,但是这里我不在意的,之前说了好多次了哈
dec_enc_attn_mask = get_attn_pad_mask(dec_inputs, enc_inputs)
dec_self_attns, dec_enc_attns = [], []
for layer in self.layers:
dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask)
dec_self_attns.append(dec_self_attn)
dec_enc_attns.append(dec_enc_attn)
return dec_outputs, dec_self_attns, dec_enc_attns
## 1. 从整体网路结构来看,分为三个部分:编码层,解码层,输出层
class Transformer(nn.Module):
def __init__(self):
super(Transformer, self).__init__()
self.encoder = Encoder() ## 编码层
self.decoder = Decoder() ## 解码层
self.projection = nn.Linear(d_model, tgt_vocab_size, bias=False) ## 输出层 d_model 是我们解码层每个token输出的维度大小,之后会做一个 tgt_vocab_size 大小的softmax
def forward(self, enc_inputs, dec_inputs):
## 这里有两个数据进行输入,一个是enc_inputs 形状为[batch_size, src_len],主要是作为编码段的输入,一个dec_inputs,形状为[batch_size, tgt_len],主要是作为解码端的输入
## enc_inputs作为输入 形状为[batch_size, src_len],输出由自己的函数内部指定,想要什么指定输出什么,可以是全部tokens的输出,可以是特定每一层的输出;也可以是中间某些参数的输出;
## enc_outputs就是主要的输出,enc_self_attns这里没记错的是QK转置相乘之后softmax之后的矩阵值,代表的是每个单词和其他单词相关性;
enc_outputs, enc_self_attns = self.encoder(enc_inputs)
## dec_outputs 是decoder主要输出,用于后续的linear映射; dec_self_attns类比于enc_self_attns 是查看每个单词对decoder中输入的其余单词的相关性;dec_enc_attns是decoder中每个单词对encoder中每个单词的相关性;
dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)
## dec_outputs做映射到词表大小
dec_logits = self.projection(dec_outputs) # dec_logits : [batch_size x src_vocab_size x tgt_vocab_size]
return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns
if __name__ == '__main__':
## 句子的输入部分,
sentences = ['ich mochte ein bier P', 'S i want a beer', 'i want a beer E']
# Transformer Parameters
# Padding Should be Zero
## 构建词表
src_vocab = {'P': 0, 'ich': 1, 'mochte': 2, 'ein': 3, 'bier': 4}
src_vocab_size = len(src_vocab)
tgt_vocab = {'P': 0, 'i': 1, 'want': 2, 'a': 3, 'beer': 4, 'S': 5, 'E': 6}
tgt_vocab_size = len(tgt_vocab)
src_len = 5 # length of source
tgt_len = 5 # length of target
## 模型参数
d_model = 512 # Embedding Size
d_ff = 2048 # FeedForward dimension
d_k = d_v = 64 # dimension of K(=Q), V
n_layers = 6 # number of Encoder of Decoder Layer
n_heads = 8 # number of heads in Multi-Head Attention
model = Transformer()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
enc_inputs, dec_inputs, target_batch = make_batch(sentences)
for epoch in range(20):
optimizer.zero_grad()
outputs, enc_self_attns, dec_self_attns, dec_enc_attns = model(enc_inputs, dec_inputs)
loss = criterion(outputs, target_batch.contiguous().view(-1))
print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
loss.backward()
optimizer.step()