transformer的学习记录【完整代码+详细注释】（系列二）

第一节：transformer的架构介绍 + 输入部分的实现
链接：https://editor.csdn.net/md/?articleId=124648718

---

第二节 编码器部分实现（一）
链接：https://editor.csdn.net/md/?articleId=124648718

---

第三节 编码器部分实现（二）
链接：https://editor.csdn.net/md/?articleId=124724264

---

第四节 编码器部分实现（三）
链接：https://editor.csdn.net/md/?articleId=124746022

---

第五节 解码器部分实现
链接：https://editor.csdn.net/md/?articleId=124750632

---

第六节 输出部分实现
链接：https://editor.csdn.net/md/?articleId=124757450

---

1 编码器部分实现

1.1 掩码张量

目标：

• 了解什么是掩码张量以及它的作用
• 掌握生成掩码张量的实现过程

代码分析：

• 生成遮掩后的掩码张量，参数 size 是最后两个维度大小，它的最后两维形成一个方阵。

1.1.1 用 np.triu 生产上三角矩阵

• 1, 5, 9，代表是主对角线，k=-1代表主对角线下平移

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 0,  8,  9],
       [ 0,  0, 12]])

• 代码展示：

import numpy as np
np.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], k=-1)
Out[3]: 
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 0,  8,  9],
       [ 0,  0, 12]])
np.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], k=0)
Out[4]: 
array([[1, 2, 3],
       [0, 5, 6],
       [0, 0, 9],
       [0, 0, 0]])
np.triu([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], k=1)
Out[5]: 
array([[0, 2, 3],
       [0, 0, 6],
       [0, 0, 0],
       [0, 0, 0]])


np.triu(np.ones((1, 5, 5)), k=1)
Out[6]: 
array([[[0., 1., 1., 1., 1.],
        [0., 0., 1., 1., 1.],
        [0., 0., 0., 1., 1.],
        [0., 0., 0., 0., 1.],
        [0., 0., 0., 0., 0.]]])

1.1.2 生成掩码张量的代码

• 注意，这里的上三角矩阵是不包含主对角线的。

import torch
import numpy as np

def subsequent_mask(size):
    # size: 代表掩码张量 最后两个维度，形成一个方阵
    attn_shape = (1, size, size)

    # 使用np.ones()先构建一个全1 的张量，然后用np.triu形成上三角矩阵
    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')

    # 反转
    return torch.from_numpy(1-subsequent_mask)

size = 5
sm = subsequent_mask(size)
print(sm)

• 输出结果：

tensor([[[1, 0, 0, 0, 0],
         [1, 1, 0, 0, 0],
         [1, 1, 1, 0, 0],
         [1, 1, 1, 1, 0],
         [1, 1, 1, 1, 1]]], dtype=torch.uint8)

1.1.3 掩码张量可视化展示

plt.figure(figsize=(5, 5))
plt.imshow(subsequent_mask(20)[0])
plt.show()

输出效果分析：
（1）黄色是1的部分，代表被遮掩
（2）横坐标——目标词汇的位置，纵坐标——可以查看的位置 【这样就达到了，在某个目标词汇的位置，只能向前看，不能向后看的作用了】
（3）例如在横坐标0的位置，所有的纵坐标都是黄色的，说明第一个词还没有产生。

1.1.4 掩码张量学习总结

1. 尺寸不定，里面一般只有1和0
2. 作用：由于在transformer中，是并行的输入，未来的信息和过去的信息都是可以直接在attention中看到的，为了防止未来信息被提前利用、影响模型效果，所以生成一个“只能向后观察的掩码张量”

1.2 注意力机制

• 什么是注意力：
  我们在快速判断一种事物时，我们的大脑会把注意力快速放在最具有辨识度的部分，从而做出判断。

• 注意力计算规则：
  Q（query）、K（key）、V（value）然后通过公式得到注意力的计算结果，这里使用的是其中的一种：
  

• Q、K、V 的比喻解释：

给出一段文本，使用一些关键词对它进行描述。
① 给出的本文信息，就相当于是query
② 给出的一些关键词提示，就相当于是key
③ 当大脑看到这段文本之后，脑子里浮现出来的答案信息，就相当于是value

刚开始的时候，key和value是相似的，但是随着对于问题的深入理解，value是会发生变化的。

1.2.1 注意力机制 vs 自注意力机制

• 注意力机制：采用注意力计算规则；还要包括一些必要的全连接层以及相关张量处理。
• 自注意力机制：采用自注意力计算规则；【Q = K = V】

---

1.2.2 注意力机制代码解读

注意力机制在网络中实现的图形表示：

流程手写：

1.2.3 masked_fill 函数介绍

masked_fill 方法有两个参数，mask和value，mask是一个pytorch张量（Tensor），元素是布尔值，value是要填充的值，填充规则是mask中取值为True位置对应于self的相应位置用value填充。

• 煮个例子：

>>> t = torch.randn(3,2)
>>> t
tensor([[-0.9180, -0.4654],
        [ 0.9866, -1.3063],
        [ 1.8359,  1.1607]])
>>> m = torch.randint(0,2,(3,2))
>>> m
tensor([[0, 1],
        [1, 1],
        [1, 0]])
>>> m == 0
tensor([[ True, False],
        [False, False],
        [False,  True]])
>>> t.masked_fill(m == 0, -1e9)
tensor([[-1.0000e+09, -4.6544e-01],
        [ 9.8660e-01, -1.3063e+00],
        [ 1.8359e+00, -1.0000e+09]])

1.2.3 注意力机制的实现代码

• 注意，这里的pe_result 是上一节内容，位置编码层的输出。

import math
from torch.autograd import Variable
from torch import nn
import torch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn.functional as F

def attention(query, key, value, mask=None, dropout=None):
    # query, key, value : 代表注意力的三个输入张量
    # mask : 掩码张量
    # dropout : 传入Dropout实例化对象
    # 首先，将query的最后一个维度提取出来，代表的是词嵌入的维度
    d_k = query.size(-1)

    # 按照注意力计算公式，将query和key 的转置进行矩阵乘法，然后除以缩放系数
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)

    # 判断是否使用掩码张量
    if mask is not None:
        # 利用masked_fill 方法，将掩码张量和0进行位置的意义比较，如果等于0，就替换成 -1e9
        scores = scores.masked_fill(mask == 0, -1e9)

    # scores的最后一个维度上进行 softmax
    p_attn = F.softmax(scores, dim=-1)

    # 判断是否使用dropout
    if dropout is not None:
        p_attn = dropout(p_attn)

    # 最后一步完成p_attm 和 value 的乘法，并返回query的注意力表示
    return torch.matmul(p_attn, value), p_attn


query = key = value = pe_result
mask = Variable(torch.zeros(2, 4, 4))
attn, p_attn = attention(query, key, value, mask=mask)
print('attn', attn)
print('attn.shape', attn.shape)
print("p_attn", p_attn)
print(p_attn.shape)

• 输出情况：

attn tensor([[[ -2.4812,  -1.7259,   8.9559,  ...,   6.2060, -15.6329,   2.5891],
         [ -2.4812,  -1.7259,   8.9559,  ...,   6.2060, -15.6329,   2.5891],
         [ -2.4812,  -1.7259,   8.9559,  ...,   6.2060, -15.6329,   2.5891],
         [ -2.4812,  -1.7259,   8.9559,  ...,   6.2060, -15.6329,   2.5891]],

        [[-25.7351,   3.2554,  -3.4601,  ...,  -0.2282,  -9.3463, -20.8138],
         [-25.7351,   3.2554,  -3.4601,  ...,  -0.2282,  -9.3463, -20.8138],
         [-25.7351,   3.2554,  -3.4601,  ...,  -0.2282,  -9.3463, -20.8138],
         [-25.7351,   3.2554,  -3.4601,  ...,  -0.2282,  -9.3463, -20.8138]]],
       grad_fn=<UnsafeViewBackward0>)
attn.shape torch.Size([2, 4, 512])
p_attn tensor([[[0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500]],

        [[0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500],
         [0.2500, 0.2500, 0.2500, 0.2500]]], grad_fn=<SoftmaxBackward0>)
torch.Size([2, 4, 4])

1.3 多头注意力机制

目标：
（1）了解多头注意力机制的原理
（2）学会实现多头注意力机制

这种结构设计，能够让每个注意力机制去优化每个词汇不同特征部分，从而均衡同一种注意力机制可能产生的偏差。

• 注意点：
  （1）只有一组线性变换层，即三个变换张量对Q， K， V进行线性变换。每个变换矩阵都是方阵，保证不会改变原有张量的尺寸。
  （2）“多头”：指的是，分割最后一维的词嵌入向量
  （3）将每个头形成的注意力机制的输出送到注意力机制中，最后形成的是多头注意力机制。

1.3.1 copy工具包——深度拷贝

copy.deepcopy()

1.3.2 tensor.view()

1.3.3 torch.transpose()

import torch
x = torch.randn(2, 3)
x
Out[11]: 
tensor([[ 1.9657,  1.6477,  0.1552],
        [-2.3723, -0.5028, -0.3238]])
torch.transpose(x, 0, 1)
Out[13]: 
tensor([[ 1.9657, -2.3723],
        [ 1.6477, -0.5028],
        [ 0.1552, -0.3238]])

1.3.4 多头注意力机制的实现

• 注意，这里的实现还是基于上一层的输出。

实现克隆函数，因为在多头注意力机制下，要用到多个结果相同的线性层
需要使用clone 函数u，将他们统一 初始化到一个网络层列表对象中

def clones(module, N):
    # module : 代表要克隆的目标网络层
    # N : 将module几个
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

• 完整代码：

import math
from torch.autograd import Variable
from torch import nn
import torch
from embedding_layer import Embedding
import copy

# 构建位置编码器的类
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout, max_len=5000):
        # d_model : 代表词嵌入的维度
        # dropout : 代表Dropout层的置零比率
        # max_len : 代表每个句子的最大长度
        super(PositionalEncoding, self).__init__()

        # 实例化 Dropout层
        self.dropout = nn.Dropout(p=dropout)

        # 初始化一个位置编码矩阵，大小是 max_len * d_model
        pe = torch.zeros(max_len, d_model)

        # 初始化一个绝对位置矩阵, max_len * 1
        position = torch.arange(0, max_len).unsqueeze(1)
        # print(position)

        # 定义一个变化矩阵，div_term, 跳跃式的初始化
        div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
        # print("ndiv_term", div_term)

        # 将前面定义的变化矩阵 进行技术，偶数分别赋值
        pe[:, 0::2] = torch.sin(position * div_term)  # 用正弦波给偶数部分赋值
        pe[:, 1::2] = torch.cos(position * div_term)  # 用余弦波给奇数部分赋值

        # 将二维张量，扩充为三维张量
        pe = pe.unsqueeze(0)  # 1 * max_len * d_model

        # 将位置编码矩阵，注册成模型的buffer，这个buffer不是模型中的参数，不跟随优化器同步更新
        # 注册成buffer后，就可以在模型保存后 重新加载的时候，将这个位置编码器和模型参数
        self.register_buffer('pe', pe)

    def forward(self, x):
        # x : 代表文本序列的词嵌入表示
        # 首先明确pe的编码太长了，将第二个维度，就是max_len对应的维度，缩小成x的句子的同等的长度
        x = x + Variable(self.pe[:, : x.size(1)], requires_grad=False)  # 表示位置编码是不参与更新的
        return self.dropout(x)


d_model = 512
dropout = 0.1
max_len = 60
vocab = 1000

x = Variable(torch.LongTensor([[100, 2, 421, 508], [491, 998, 1, 221]]))

emb = Embedding(vocab, d_model)
embr = emb(x)
x = embr  # shape: [2, 4, 512]
pe = PositionalEncoding(d_model, dropout, max_len)
pe_result = pe(x)
# print(pe_result)

import math
from torch.autograd import Variable
from torch import nn
import torch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn.functional as F

def attention(query, key, value, mask=None, dropout=None):
    # query, key, value : 代表注意力的三个输入张量
    # mask : 掩码张量
    # dropout : 传入Dropout实例化对象
    # 首先，将query的最后一个维度提取出来，代表的是词嵌入的维度
    d_k = query.size(-1)

    # 按照注意力计算公式，将query和key 的转置进行矩阵乘法，然后除以缩放系数
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)

    print("..", scores.shape)
    # 判断是否使用掩码张量
    if mask is not None:
        # 利用masked_fill 方法，将掩码张量和0进行位置的意义比较，如果等于0，就替换成 -1e9
        scores = scores.masked_fill(mask == 0, -1e9)

    # scores的最后一个维度上进行 softmax
    p_attn = F.softmax(scores, dim=-1)

    # 判断是否使用dropout
    if dropout is not None:
        p_attn = dropout(p_attn)

    # 最后一步完成p_attm 和 value 的乘法，并返回query的注意力表示
    return torch.matmul(p_attn, value), p_attn


query = key = value = pe_result
mask = Variable(torch.zeros(2, 4, 4))
attn, p_attn = attention(query, key, value, mask=mask)
# print('attn', attn)
# print('attn.shape', attn.shape)
# print("p_attn", p_attn)
# print(p_attn.shape)







# 实现克隆函数，因为在多头注意力机制下，要用到多个结果相同的线性层
# 需要使用clone 函数u，将他们统一 初始化到一个网络层列表对象中
def clones(module, N):
    # module : 代表要克隆的目标网络层
    # N : 将module几个
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])


# 实现多头注意力机制的类
class MultiHeadAttention(nn.Module):
    def __init__(self, head, embedding_dim, dropout=0.1):
        # head : 代表几个头的函数
        # embedding_dim ： 代表词嵌入的维度
        # dropout
        super(MultiHeadAttention, self).__init__()

        # 强调：多头的数量head 需要整除 词嵌入的维度 embedding_dim
        assert embedding_dim % head == 0

        # 得到每个头，所获得 的词向量的维度
        self.d_k = embedding_dim // head
        self.head = head
        self.embedding_dim = embedding_dim

        # 获得线性层，需要获得4个，分别是Q K V 以及最终输出的线性层
        self.linears = clones(nn.Linear(embedding_dim, embedding_dim), 4)

        # 初始化注意力张量
        self.attn = None

        # 初始化dropout对象
        self.drop = nn.Dropout(p=dropout)

    def forward(self, query, key, value, mask=None):
        # query,key,value 是注意力机制的三个输入张量，mask代表掩码张量
        # 首先判断是否使用掩码张量
        if mask is not None:
            # 使用squeeze将掩码张量进行围堵扩充，代表多头的第n个头
            mask = mask.unsqueeze(1)

        # 得到batch_size
        batch_size = query.size(0)

        # 首先使用 zip 将网络能和输入数据连接在一起，模型的输出 利用 view 和 transpose 进行维度和形状的
        query, key, value = \
            [model(x).view(batch_size, -1, self.head, self.d_k).transpose(1, 2)
             for model, x in zip(self.linears, (query, key, value))]

        # 将每个头的输出 传入到注意力层
        x, self.attn = attention(query, key, value, mask=mask, dropout=self.drop)

        # 得到每个头的计算结果，每个output都是4维的张量，需要进行维度转换
        # 前面已经将transpose（1， 2）
        # 注意，先transpose 然后 contiguous，否则无法使用view
        x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.head*self.d_k)

        # 最后将x输入到线性层的最后一个线性层中进行处理，得到最终的多头注意力结构输出
        return self.linears[-1](x)

# 实例化若干个参数
head = 8
embedding_dim = 512
dropout = 0.2

# 若干输入参数的初始化
query = key = value = pe_result

mask = Variable(torch.zeros(2, 4, 4))

mha = MultiHeadAttention(head, embedding_dim, dropout)
mha_result = mha(query, key, value, mask)

print(mha_result)
print(mha_result.shape)

• 输出情况：

.. torch.Size([2, 4, 4])
.. torch.Size([2, 8, 4, 4])
tensor([[[ 1.9910, -2.0143, -1.0101,  ...,  4.7109, -0.1073, -2.2446],
         [-3.8935, -7.8693, -1.8197,  ...,  5.6679, -1.0325, -2.8742],
         [-5.3308, -9.2092, -2.7024,  ...,  4.3109, -1.0082, -2.2811],
         [-1.1616,  0.4375, -3.8045,  ...,  4.6051,  2.1552,  0.0618]],

        [[ 6.0951, -3.1225, -0.6519,  ..., -6.7592, -5.9331,  1.6942],
         [ 8.5730, -1.0621,  6.5263,  ..., -2.6061, -2.4478, -3.8353],
         [ 5.9896, -1.9288,  4.7686,  ..., -5.4466, -1.1590, -1.9577],
         [ 3.7722, -0.9137,  2.7080,  ..., -5.8659, -5.7925, -0.8831]]],
       grad_fn=<AddBackward0>)
torch.Size([2, 4, 512])