devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Transformer（Pytorch）部分讲解_number of encoder and decoder layers

作者：不正经 | 2024-04-04 16:22:59

赞

踩

number of encoder and decoder layers

前言

之前在看transformer的时候写了一篇文章，文章整体几乎是对着论文翻译过来的，最近也算是有时间看了看transformer的代码，也看了看别人文章的介绍，此处记录下来，方便自己以后查看。

前一篇介绍transformer的文章链接：

(4条消息) Transformer_Mr___WQ的博客-CSDN博客icon-default.png?t=M85Bhttps://blog.csdn.net/Mr___WQ/article/details/126629883?spm=1001.2014.3001.5502接下来对transformer的代码做简单介绍。

Transformer

1 模型参数

  1. # Transformer Parameters
  2. d_model = 512  # Embedding Size（词嵌入维度，此处设为512）
  3. # FeedForward dimension (两次线性层中的隐藏层 512->2048->512，
  4. #线性层是用来做特征提取的），当然最后会再接一个projection层
  5. d_ff = 2048   #  Feed Forward 层隐藏神经元个数
  6. d_k = d_v = 64  # dimension of K(=Q), V（Q和K的维度需要相同，这里为了方便让K=V）
  7. n_layers = 6  # number of Encoder of Decoder Layer（Block的个数）
  8. n_heads = 8  # number of heads in Multi-Head Attention（有几个头）

2 Embedding层

Embedding层的作用是将某种格式的输入数据，例如文本，转变为模型可以处理的向量表示，来描述原始数据所包含的信息。

Embedding层输出的可以理解为当前时间步的特征，如果是文本任务，这里就可以是Word Embedding，如果是其他任务，就可以是任何合理方法所提取的特征。

构建Embedding层的代码很简单，核心是借助torch提供的nn.Embedding，如下：

  1. class Embeddings(nn.Module):
  2.     def __init__(self, d_model, vocab):
  3.         """
  4.         类的初始化函数
  5.         d_model：指词嵌入的维度
  6.         vocab:指词表的大小
  7.         """
  8.         super(Embeddings, self).__init__()
  9.         #之后就是调用nn中的预定义层Embedding，获得一个词嵌入对象self.lut
  10.         self.lut = nn.Embedding(vocab, d_model)
  11.         #最后就是将d_model传入类中
  12.         self.d_model =d_model
  13.     def forward(self, x):
  14.         """
  15.         Embedding层的前向传播逻辑
  16.         参数x：这里代表输入给模型的单词文本通过词表映射后的one-hot向量
  17.         将x传给self.lut并与根号下self.d_model相乘作为结果返回
  18.         """
  19.         embedds = self.lut(x)
  20.         return embedds * math.sqrt(self.d_model)

 此处为了简单测试，我们手动编码并加载数据，代码如下：

  1. entences = [
  2.     # 中文和英语的单词个数不要求相同
  3.     # enc_input                dec_input           dec_output
  4.     ['我 有 一 个 好 朋 友 P', 'S I have a good friend .', 'I have a good friend . E'],
  5.     ['我 有 零 个 女 朋 友 P', 'S I have zero girl friend .', 'I have zero girl friend . E'],
  6.     ['我 有 一 个 男 朋 友 P', 'S I have a boy friend .', 'I have a boy friend . E']
  7. ]
  8.  
  9. # 测试集（希望transformer能达到的效果）
  10. # 输入："我 有 一 个 女 朋 友"
  11. # 输出："i have a girlfriend"
  12.  
  13. # 中文和英语的单词要分开建立词库
  14. # Padding Should be Zero
  15. src_vocab = {'P': 0, '我': 1, '有': 2, '一': 3,
  16.              '个': 4, '好': 5, '朋': 6, '友': 7, '零': 8, '女': 9, '男': 10}
  17. src_idx2word = {i: w for i, w in enumerate(src_vocab)}
  18. src_vocab_size = len(src_vocab)
  19.  
  20. tgt_vocab = {'P': 0, 'I': 1, 'have': 2, 'a': 3, 'good': 4,
  21.              'friend': 5, 'zero': 6, 'girl': 7,  'boy': 8, 'S': 9, 'E': 10, '.': 11}
  22. idx2word = {i: w for i, w in enumerate(tgt_vocab)}
  23. tgt_vocab_size = len(tgt_vocab)
  24. src_len = 8  # （源句子的长度）enc_input max sequence length
  25. tgt_len = 7  # dec_input(=dec_output) max sequence length
  26.  
  27.  
  28. def make_data(sentences):
  29.     """把单词序列转换为数字序列"""
  30.     enc_inputs, dec_inputs, dec_outputs = [], [], []
  31.     for i in range(len(sentences)):
  32.  
  33.         enc_input = [[src_vocab[n] for n in sentences[i][0].split()]]
  34.         dec_input = [[tgt_vocab[n] for n in sentences[i][1].split()]]
  35.         dec_output = [[tgt_vocab[n] for n in sentences[i][2].split()]]
  36.  
  37.         #[[1, 2, 3, 4, 5, 6, 7, 0], [1, 2, 8, 4, 9, 6, 7, 0], [1, 2, 3, 4, 10, 6, 7, 0]]
  38.         enc_inputs.extend(enc_input)
  39.         #[[9, 1, 2, 3, 4, 5, 11], [9, 1, 2, 6, 7, 5, 11], [9, 1, 2, 3, 8, 5, 11]]
  40.         dec_inputs.extend(dec_input)
  41.         #[[1, 2, 3, 4, 5, 11, 10], [1, 2, 6, 7, 5, 11, 10], [1, 2, 3, 8, 5, 11, 10]]
  42.         dec_outputs.extend(dec_output)
  43.  
  44.     return torch.LongTensor(enc_inputs), torch.LongTensor(dec_inputs), torch.LongTensor(dec_outputs)
  45.  
  46.  
  47. class MyDataSet(Data.Dataset):
  48.     """自定义DataLoader"""
  49.  
  50.     def __init__(self, enc_inputs, dec_inputs, dec_outputs):
  51.         super(MyDataSet, self).__init__()
  52.         self.enc_inputs = enc_inputs
  53.         self.dec_inputs = dec_inputs
  54.         self.dec_outputs = dec_outputs
  55.  
  56.     def __len__(self):
  57.         return self.enc_inputs.shape[0]
  58.  
  59.     def __getitem__(self, idx):
  60.         return self.enc_inputs[idx], self.dec_inputs[idx], self.dec_outputs[idx]
  61.  
  62.  
  63. loader = Data.DataLoader(
  64.     MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)

3 位置编码 Positional Encoding

Positional Encoding 的计算公式如下：

至于为何要用上面的计算公式，详见Transformer中的Positional Encoding - mathor (wmathor.com)icon-default.png?t=M85Bhttps://wmathor.com/index.php/archives/1453/公式中的sin和cos 对应着 embedding_dimension 维度的一组奇数和偶数的序号的维度。例如 0,1 一组，2,3 一组，分别用上面的sin和cos函数做处理从而产生不同的周期性变化，而位置嵌入在
embedding_dimension维度上随着维度序号增大，周期变化会越来越慢。

代码如下：

  1.  
  2. import numpy as np
  3. import seaborn as sns
  4. import math
  5.  
  6. def get_positional_encoding(max_seq_len, embed_dim):
  7.     # 初始化一个positional encoding
  8.     # embed_dim: 字嵌入的维度
  9.     # max_seq_len: 最大的序列长度
  10.     positional_encoding = np.array([
  11.         [pos / np.power(10000, 2 * i / embed_dim) for i in range(embed_dim)]
  12.         if pos != 0 else np.zeros(embed_dim) for pos in range(max_seq_len)])
  13.     
  14.     positional_encoding[1:, 0::2] = np.sin(positional_encoding[1:, 0::2])  # dim 2i 偶数
  15.     positional_encoding[1:, 1::2] = np.cos(positional_encoding[1:, 1::2])  # dim 2i+1 奇数
  16.     return positional_encoding
  17.

4 Mask

Transformer中有两个部分用到了mask，第一个由于在网络的训练过程中同一个batch会包含有多个文本序列，而不同的序列长度并不一致。因此在数据集的生成过程中，就需要将同一个batch中的序列Padding到相同的长度。但是，这样就会导致在注意力的计算过程中会考虑到Padding位置上的信息。扩充的部分不应该被注意到，因此需要Mask操作l，称为Padding Mask；第二个则是在训练过程中对于每一个样本来说都需要这样一个对称矩阵来掩盖掉当前时刻之后所有位置的信息，称为Attention Mask。

代码如下：

  1. def get_attn_pad_mask(seq_q, seq_k):
  2.     # pad mask的作用：在对value向量加权平均的时候，可以让pad对应的alpha_ij=0，这样注意力就不会考虑到pad向量
  3.     """这里的q,k表示的是两个序列（跟注意力机制的q,k没有关系），例如encoder_inputs (x1,x2,..xm)和encoder_inputs (x1,x2..xm)
  4.     encoder和decoder都可能调用这个函数，所以seq_len视情况而定
  5.     seq_q: [batch_size, seq_len]
  6.     seq_k: [batch_size, seq_len]
  7.     seq_len could be src_len or it could be tgt_len
  8.     seq_len in seq_q and seq_len in seq_k maybe not equal
  9.     """
  10.     batch_size, len_q = seq_q.size()  # 这个seq_q只是用来expand维度的
  11.     batch_size, len_k = seq_k.size()
  12.     # eq(zero) is PAD token
  13.     # 例如:seq_k = [[1,2,3,4,0], [1,2,3,5,0]]
  14.     # [batch_size, 1, len_k], True is masked
  15.     pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)
  16.     # [batch_size, len_q, len_k] 构成一个立方体(batch_size个这样的矩阵)
  17.     return pad_attn_mask.expand(batch_size, len_q, len_k)
  18.  
  19. """这个函数最核心的一句代码是 seq_k.data.eq(0)，
  20. 这句的作用是返回一个大小和 seq_k 一样的 tensor，
  21. 只不过里面的值只有 True 和 False。
  22. 如果 seq_k 某个位置的值等于 0，
  23. 那么对应位置就是 True，否则即为 False。
  24. 举个例子，输入为 seq_data = [1, 2, 3, 4, 0]，
  25. seq_data.data.eq(0) 就会返回 
  26. [False, False, False, False, True]
  27. """
  28.  
  29.  
  30. def get_attn_subsequence_mask(seq):
  31.     """建议打印出来看看是什么的输出（一目了然）
  32.     seq: [batch_size, tgt_len]
  33.     """
  34.     attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
  35.     # attn_shape: [batch_size, tgt_len, tgt_len]
  36.     subsequence_mask = np.triu(np.ones(attn_shape), k=1)  # 生成一个上三角矩阵
  37.     subsequence_mask = torch.from_numpy(subsequence_mask).byte()
  38.     return subsequence_mask  # [batch_size, tgt_len, tgt_len]
  39.     
  40. """
  41. get_attn_subsequence_mask 只有 Decoder 会用到，
  42. 主要作用是屏蔽未来时刻单词的信息。
  43. 首先通过 np.ones() 生成一个全 1 的方阵，
  44. 然后通过 np.triu() 生成一个上三角矩阵
  45. """

 5 ScaledDotProductAttention

 

这里要做的是，通过 Q 和 K 计算出 scores，然后将 scores 和 V 相乘，得到每个单词的 context vector。

第一步是将 Q 和 K 的转置相乘没什么好说的，相乘之后得到的 scores 还不能立刻进行 softmax，需要和 attn_mask 相加，把一些需要屏蔽的信息屏蔽掉，attn_mask 是一个仅由 True 和 False 组成的 tensor，并且一定会保证 attn_mask 和 scores 的维度四个值相同（不然无法做对应位置相加）mask 完了之后，就可以对 scores 进行 softmax 了。然后再与 V 相乘，得到 context。

计算图解如下：

这个分数表的含义如下：

        当模型处理数据集中的第 1 个数据（第 1 行），其中只包含着一个单词 （robot），它将 100% 的注意力集中在这个单词上。
        当模型处理数据集中的第 2 个数据（第 2 行），其中包含着单词（robot must）。当模型处理单词 must，它将 42% 的注意力集中在 robot，将 57% 的注意力集中在 must。
        诸如此类，继续处理后面的单词。

补充说明：

 

代码如下：

  1. class ScaledDotProductAttention(nn.Module):
  2.     def __init__(self):
  3.         super(ScaledDotProductAttention, self).__init__()
  4.  
  5.     def forward(self, Q, K, V, attn_mask):
  6.         """
  7.         Q: [batch_size, n_heads, len_q, d_k]
  8.         K: [batch_size, n_heads, len_k, d_k]
  9.         V: [batch_size, n_heads, len_v(=len_k), d_v]
  10.         attn_mask: [batch_size, n_heads, seq_len, seq_len]
  11.         说明：在encoder-decoder的Attention层中len_q(q1,..qt)和len_k(k1,...km)可能不同
  12.         """
  13.         scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)  # scores : [batch_size, n_heads, len_q, len_k]
  14.         # mask矩阵填充scores（用-1e9填充scores中与attn_mask中值为1位置相对应的元素）
  15.         scores.masked_fill_(attn_mask, -1e9)  # Fills elements of self tensor with value where mask is True.
  16.  
  17.         attn = nn.Softmax(dim=-1)(scores)  # 对最后一个维度(v)做softmax
  18.         # scores : [batch_size, n_heads, len_q, len_k] * V: [batch_size, n_heads, len_v(=len_k), d_v]
  19.         context = torch.matmul(attn, V)  # context: [batch_size, n_heads, len_q, d_v]
  20.         # context：[[z1,z2,...],[...]]向量, attn注意力稀疏矩阵（用于可视化的）
  21.         return context, attn
  22.

6 Feed Forward和Add&Norm

  1. # Pytorch中的Linear只会对最后一维操作，所以正好是我们希望的每个位置用同一个全连接网络
  2. class PoswiseFeedForwardNet(nn.Module):
  3.     def __init__(self):
  4.         super(PoswiseFeedForwardNet, self).__init__()
  5.         self.fc = nn.Sequential(
  6.             nn.Linear(d_model, d_ff, bias=False),
  7.             nn.ReLU(),
  8.             nn.Linear(d_ff, d_model, bias=False)
  9.         )
  10.  
  11.     def forward(self, inputs):
  12.         """
  13.         inputs: [batch_size, seq_len, d_model]
  14.         """
  15.         residual = inputs
  16.         output = self.fc(inputs)
  17.         return nn.LayerNorm(d_model).to(device)(output + residual)  # [batch_size, seq_len, d_model]
  18.

 7 MultiHeadAttention

多个self-attention的组合：

  1. class MultiHeadAttention(nn.Module):
  2.     """这个Attention类可以实现:
  3.     Encoder的Self-Attention
  4.     Decoder的Masked Self-Attention
  5.     Encoder-Decoder的Attention
  6.     输入：seq_len x d_model
  7.     输出：seq_len x d_model
  8.     """
  9.  
  10.     def __init__(self):
  11.         super(MultiHeadAttention, self).__init__()
  12.         self.W_Q = nn.Linear(d_model, d_k * n_heads,
  13.                              bias=False)  # q,k必须维度相同，不然无法做点积
  14.         self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)
  15.         self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)
  16.         # 这个全连接层可以保证多头attention的输出仍然是seq_len x d_model
  17.         self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)
  18.  
  19.     def forward(self, input_Q, input_K, input_V, attn_mask):
  20.         """
  21.         input_Q: [batch_size, len_q, d_model]
  22.         input_K: [batch_size, len_k, d_model]
  23.         input_V: [batch_size, len_v(=len_k), d_model]
  24.         attn_mask: [batch_size, seq_len, seq_len]
  25.         """
  26.         residual, batch_size = input_Q, input_Q.size(0)
  27.         # 下面的多头的参数矩阵是放在一起做线性变换的，然后再拆成多个头，这是工程实现的技巧
  28.         # B: batch_size, S:seq_len, D: dim
  29.         # (B, S, D) -proj-> (B, S, D_new) -split-> (B, S, Head, W) -trans-> (B, Head, S, W)
  30.         #           线性变换               拆成多头
  31.  
  32.         # Q: [batch_size, n_heads, len_q, d_k]
  33.         Q = self.W_Q(input_Q).view(batch_size, -1,
  34.                                    n_heads, d_k).transpose(1, 2)
  35.         # K: [batch_size, n_heads, len_k, d_k] # K和V的长度一定相同，维度可以不同
  36.         K = self.W_K(input_K).view(batch_size, -1,
  37.                                    n_heads, d_k).transpose(1, 2)
  38.         # V: [batch_size, n_heads, len_v(=len_k), d_v]
  39.         V = self.W_V(input_V).view(batch_size, -1,
  40.                                    n_heads, d_v).transpose(1, 2)
  41.  
  42.         # 因为是多头，所以mask矩阵要扩充成4维的
  43.         # attn_mask: [batch_size, seq_len, seq_len] -> [batch_size, n_heads, seq_len, seq_len]
  44.         attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
  45.  
  46.         # context: [batch_size, n_heads, len_q, d_v], attn: [batch_size, n_heads, len_q, len_k]
  47.         context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)
  48.         # 下面将不同头的输出向量拼接在一起
  49.         # context: [batch_size, n_heads, len_q, d_v] -> [batch_size, len_q, n_heads * d_v]
  50.         context = context.transpose(1, 2).reshape(
  51.             batch_size, -1, n_heads * d_v)
  52.  
  53.         # 这个全连接层可以保证多头attention的输出仍然是seq_len x d_model
  54.         output = self.fc(context)  # [batch_size, len_q, d_model]
  55.         return nn.LayerNorm(d_model).to(device)(output + residual), attn

完整代码中一定会有三处地方调用 MultiHeadAttention()，Encoder Layer 调用一次，传入的 input_Q、input_K、input_V 全部都是 enc_inputs；Decoder Layer 中两次调用，第一次传入的全是 dec_inputs，第二次传入的分别是 dec_outputs，enc_outputs，enc_outputs。

8 Encoder Layer

  1. class EncoderLayer(nn.Module):
  2.     def __init__(self):
  3.         super(EncoderLayer, self).__init__()
  4.         self.enc_self_attn = MultiHeadAttention()
  5.         self.pos_ffn = PoswiseFeedForwardNet()
  6.  
  7.     def forward(self, enc_inputs, enc_self_attn_mask):
  8.         """E
  9.         enc_inputs: [batch_size, src_len, d_model]
  10.         enc_self_attn_mask: [batch_size, src_len, src_len]  mask矩阵(pad mask or sequence mask)
  11.         """
  12.         # enc_outputs: [batch_size, src_len, d_model], attn: [batch_size, n_heads, src_len, src_len]
  13.         # 第一个enc_inputs * W_Q = Q
  14.         # 第二个enc_inputs * W_K = K
  15.         # 第三个enc_inputs * W_V = V
  16.         enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs,
  17.                                                enc_self_attn_mask)  # enc_inputs to same Q,K,V（未线性变换前）
  18.         enc_outputs = self.pos_ffn(enc_outputs)
  19.         # enc_outputs: [batch_size, src_len, d_model]
  20.         return enc_outputs, attn

 9 Encoder

  1. class Encoder(nn.Module):
  2.     def __init__(self):
  3.         super(Encoder, self).__init__()
  4.         self.src_emb = nn.Embedding(src_vocab_size, d_model)  # token Embedding
  5.         self.pos_emb = PositionalEncoding(
  6.             d_model)  # Transformer中位置编码时固定的，不需要学习
  7.         self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
  8.  
  9.     def forward(self, enc_inputs):
  10.         """
  11.         enc_inputs: [batch_size, src_len]
  12.         """
  13.         enc_outputs = self.src_emb(
  14.             enc_inputs)  # [batch_size, src_len, d_model]
  15.         enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(
  16.             0, 1)  # [batch_size, src_len, d_model]
  17.         # Encoder输入序列的pad mask矩阵
  18.         enc_self_attn_mask = get_attn_pad_mask(
  19.             enc_inputs, enc_inputs)  # [batch_size, src_len, src_len]
  20.         enc_self_attns = []  # 在计算中不需要用到，它主要用来保存你接下来返回的attention的值（这个主要是为了你画热力图等，用来看各个词之间的关系
  21.         for layer in self.layers:  # for循环访问nn.ModuleList对象
  22.             # 上一个block的输出enc_outputs作为当前block的输入
  23.             # enc_outputs: [batch_size, src_len, d_model], enc_self_attn: [batch_size, n_heads, src_len, src_len]
  24.             enc_outputs, enc_self_attn = layer(enc_outputs,
  25.                                                enc_self_attn_mask)  # 传入的enc_outputs其实是input，传入mask矩阵是因为你要做self attention
  26.             enc_self_attns.append(enc_self_attn)  # 这个只是为了可视化
  27.         return enc_outputs, enc_self_attns

10 Decoder Layer

  1. class DecoderLayer(nn.Module):
  2.     def __init__(self):
  3.         super(DecoderLayer, self).__init__()
  4.         self.dec_self_attn = MultiHeadAttention()
  5.         self.dec_enc_attn = MultiHeadAttention()
  6.         self.pos_ffn = PoswiseFeedForwardNet()
  7.  
  8.     def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
  9.         """
  10.         dec_inputs: [batch_size, tgt_len, d_model]
  11.         enc_outputs: [batch_size, src_len, d_model]
  12.         dec_self_attn_mask: [batch_size, tgt_len, tgt_len]
  13.         dec_enc_attn_mask: [batch_size, tgt_len, src_len]
  14.         """
  15.         # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len]
  16.         dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs,
  17.                                                         dec_self_attn_mask)  # 这里的Q,K,V全是Decoder自己的输入
  18.         # dec_outputs: [batch_size, tgt_len, d_model], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]
  19.         dec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs,
  20.                                                       dec_enc_attn_mask)  # Attention层的Q(来自decoder) 和 K,V(来自encoder)
  21.         # [batch_size, tgt_len, d_model]
  22.         dec_outputs = self.pos_ffn(dec_outputs)
  23.         # dec_self_attn, dec_enc_attn这两个是为了可视化的
  24.         return dec_outputs, dec_self_attn, dec_enc_attn

 11 Decoder

  1. class Decoder(nn.Module):
  2.     def __init__(self):
  3.         super(Decoder, self).__init__()
  4.         self.tgt_emb = nn.Embedding(
  5.             tgt_vocab_size, d_model)  # Decoder输入的embed词表
  6.         self.pos_emb = PositionalEncoding(d_model)
  7.         self.layers = nn.ModuleList([DecoderLayer()
  8.                                     for _ in range(n_layers)])  # Decoder的blocks
  9.  
  10.     def forward(self, dec_inputs, enc_inputs, enc_outputs):
  11.         """
  12.         dec_inputs: [batch_size, tgt_len]
  13.         enc_inputs: [batch_size, src_len]
  14.         enc_outputs: [batch_size, src_len, d_model]   # 用在Encoder-Decoder Attention层
  15.         """
  16.         dec_outputs = self.tgt_emb(
  17.             dec_inputs)  # [batch_size, tgt_len, d_model]
  18.         dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1).to(
  19.             device)  # [batch_size, tgt_len, d_model]
  20.         # Decoder输入序列的pad mask矩阵（这个例子中decoder是没有加pad的，实际应用中都是有pad填充的）
  21.         dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs).to(
  22.             device)  # [batch_size, tgt_len, tgt_len]
  23.         # Masked Self_Attention：当前时刻是看不到未来的信息的
  24.         dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs).to(
  25.             device)  # [batch_size, tgt_len, tgt_len]
  26.  
  27.         # Decoder中把两种mask矩阵相加（既屏蔽了pad的信息，也屏蔽了未来时刻的信息）
  28.         dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequence_mask),
  29.                                       0).to(device)  # [batch_size, tgt_len, tgt_len]; torch.gt比较两个矩阵的元素，大于则返回1，否则返回0
  30.  
  31.         # 这个mask主要用于encoder-decoder attention层
  32.         # get_attn_pad_mask主要是enc_inputs的pad mask矩阵(因为enc是处理K,V的，求Attention时是用v1,v2,..vm去加权的，要把pad对应的v_i的相关系数设为0，这样注意力就不会关注pad向量)
  33.         #                       dec_inputs只是提供expand的size的
  34.         dec_enc_attn_mask = get_attn_pad_mask(
  35.             dec_inputs, enc_inputs)  # [batc_size, tgt_len, src_len]
  36.  
  37.         dec_self_attns, dec_enc_attns = [], []
  38.         for layer in self.layers:
  39.             # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]
  40.             # Decoder的Block是上一个Block的输出dec_outputs（变化）和Encoder网络的输出enc_outputs（固定）
  41.             dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs, dec_self_attn_mask,
  42.                                                              dec_enc_attn_mask)
  43.             dec_self_attns.append(dec_self_attn)
  44.             dec_enc_attns.append(dec_enc_attn)
  45.         # dec_outputs: [batch_size, tgt_len, d_model]
  46.         return dec_outputs, dec_self_attns, dec_enc_attns

 12 Transformer

  1. class Transformer(nn.Module):
  2.     def __init__(self):
  3.         super(Transformer, self).__init__()
  4.         self.encoder = Encoder().to(device)
  5.         self.decoder = Decoder().to(device)
  6.         self.projection = nn.Linear(
  7.             d_model, tgt_vocab_size, bias=False).to(device)
  8.  
  9.     def forward(self, enc_inputs, dec_inputs):
  10.         """Transformers的输入：两个序列
  11.         enc_inputs: [batch_size, src_len]
  12.         dec_inputs: [batch_size, tgt_len]
  13.         """
  14.         # tensor to store decoder outputs
  15.         # outputs = torch.zeros(batch_size, tgt_len, tgt_vocab_size).to(self.device)
  16.  
  17.         # enc_outputs: [batch_size, src_len, d_model], enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len]
  18.         # 经过Encoder网络后，得到的输出还是[batch_size, src_len, d_model]
  19.         enc_outputs, enc_self_attns = self.encoder(enc_inputs)
  20.         # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attns: [n_layers, batch_size, n_heads, tgt_len, tgt_len], dec_enc_attn: [n_layers, batch_size, tgt_len, src_len]
  21.         dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(
  22.             dec_inputs, enc_inputs, enc_outputs)
  23.         # dec_outputs: [batch_size, tgt_len, d_model] -> dec_logits: [batch_size, tgt_len, tgt_vocab_size]
  24.         dec_logits = self.projection(dec_outputs)
  25.         return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns

train 

  1. model = Transformer().to(device)
  2. # 这里的损失函数里面设置了一个参数 ignore_index=0，因为 "pad" 这个单词的索引为 0，这样设置以后，就不会计算 "pad" 的损失（因为本来 "pad" 也没有意义，不需要计算）
  3. criterion = nn.CrossEntropyLoss(ignore_index=0)
  4. optimizer = optim.SGD(model.parameters(), lr=1e-3,
  5.                       momentum=0.99)  # 用adam的话效果不好
  6.  
  7.  
  8. for epoch in range(epochs):
  9.     for enc_inputs, dec_inputs, dec_outputs in loader:
  10.         """
  11.         enc_inputs: [batch_size, src_len]
  12.         dec_inputs: [batch_size, tgt_len]
  13.         dec_outputs: [batch_size, tgt_len]
  14.         """
  15.         enc_inputs, dec_inputs, dec_outputs = enc_inputs.to(
  16.             device), dec_inputs.to(device), dec_outputs.to(device)
  17.         # outputs: [batch_size * tgt_len, tgt_vocab_size]
  18.         outputs, enc_self_attns, dec_self_attns, dec_enc_attns = model(
  19.             enc_inputs, dec_inputs)
  20.         # dec_outputs.view(-1):[batch_size * tgt_len * tgt_vocab_size]
  21.         loss = criterion(outputs, dec_outputs.view(-1))
  22.         print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))
  23.  
  24.         optimizer.zero_grad()
  25.         loss.backward()
  26.         optimizer.step()

输出：

  1.  
  2. def greedy_decoder(model, enc_input, start_symbol):
  3.     """贪心编码
  4.     For simplicity, a Greedy Decoder is Beam search when K=1. This is necessary for inference as we don't know the
  5.     target sequence input. Therefore we try to generate the target input word by word, then feed it into the transformer.
  6.     Starting Reference: http://nlp.seas.harvard.edu/2018/04/03/attention.html#greedy-decoding
  7.     :param model: Transformer Model
  8.     :param enc_input: The encoder input
  9.     :param start_symbol: The start symbol. In this example it is 'S' which corresponds to index 4
  10.     :return: The target input
  11.     """
  12.     enc_outputs, enc_self_attns = model.encoder(enc_input)
  13.     # 初始化一个空的tensor: tensor([], size=(1, 0), dtype=torch.int64)
  14.     dec_input = torch.zeros(1, 0).type_as(enc_input.data)
  15.     terminal = False
  16.     next_symbol = start_symbol
  17.     while not terminal:
  18.         # 预测阶段：dec_input序列会一点点变长（每次添加一个新预测出来的单词）
  19.         dec_input = torch.cat([dec_input.to(device), torch.tensor([[next_symbol]], dtype=enc_input.dtype).to(device)],
  20.                               -1)
  21.         dec_outputs, _, _ = model.decoder(dec_input, enc_input, enc_outputs)
  22.         projected = model.projection(dec_outputs)
  23.         prob = projected.squeeze(0).max(dim=-1, keepdim=False)[1]
  24.         # 增量更新（我们希望重复单词预测结果是一样的）
  25.         # 我们在预测是会选择性忽略重复的预测的词，只摘取最新预测的单词拼接到输入序列中
  26.         # 拿出当前预测的单词(数字)。我们用x'_t对应的输出z_t去预测下一个单词的概率，不用z_1,z_2..z_{t-1}
  27.         next_word = prob.data[-1]
  28.         next_symbol = next_word
  29.         if next_symbol == tgt_vocab["E"]:
  30.             terminal = True
  31.         # print(next_word)
  32.  
  33.     # greedy_dec_predict = torch.cat(
  34.     #     [dec_input.to(device), torch.tensor([[next_symbol]], dtype=enc_input.dtype).to(device)],
  35.     #     -1)
  36.     greedy_dec_predict = dec_input[:, 1:]
  37.     return greedy_dec_predict
  38.  
  39.  
  40. # ==========================================================================================
  41. # 预测阶段
  42. # 测试集
  43. sentences = [
  44.     # enc_input                dec_input           dec_output
  45.     ['我 有 零 个 女 朋 友 P', '', '']
  46. ]
  47.  
  48. enc_inputs, dec_inputs, dec_outputs = make_data(sentences)
  49. test_loader = Data.DataLoader(
  50.     MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)
  51. enc_inputs, _, _ = next(iter(test_loader))
  52.  
  53. print()
  54. print("="*30)
  55. print("利用训练好的Transformer模型将中文句子'我 有 零 个 女 朋 友' 翻译成英文句子: ")
  56. for i in range(len(enc_inputs)):
  57.     greedy_dec_predict = greedy_decoder(model, enc_inputs[i].view(
  58.         1, -1).to(device), start_symbol=tgt_vocab["S"])
  59.     print(enc_inputs[i], '->', greedy_dec_predict.squeeze())
  60.     print([src_idx2word[t.item()] for t in enc_inputs[i]], '->',
  61.           [idx2word[n.item()] for n in greedy_dec_predict.squeeze()])

完整代码

源码参考：

nlp-tutorial/Transformer_Torch.py at master · wmathor/nlp-tutorial (github.com)icon-default.png?t=M85Bhttps://github.com/wmathor/nlp-tutorial/blob/master/5-1.Transformer/Transformer_Torch.py参考：

Transformer 代码详解(Pytorch版)_@左左@右右的博客-CSDN博客_transformer代码icon-default.png?t=M85Bhttps://blog.csdn.net/BXD1314/article/details/126187598

  1. # ======================================
  2. # === Pytorch手写Transformer完整代码
  3. # ======================================
  4. """
  5. code by Tae Hwan Jung(Jeff Jung) @graykode, Derek Miller @dmmiller612, modify by shwei
  6. Reference: https://github.com/jadore801120/attention-is-all-you-need-pytorch
  7.            https://github.com/JayParks/transformer
  8. """
  9. # ====================================================================================================
  10. # 数据构建
  11. import math
  12. import torch
  13. import numpy as np
  14. import torch.nn as nn
  15. import torch.optim as optim
  16. import torch.utils.data as Data
  17.  
  18. device = 'cpu'
  19. #device = 'cuda'
  20.  
  21. # transformer epochs
  22. epochs = 100
  23. # epochs = 1000
  24.  
  25. # 这里我没有用什么大型的数据集，而是手动输入了两对中文→英语的句子
  26. # 还有每个字的索引也是我手动硬编码上去的，主要是为了降低代码阅读难度
  27. # S: Symbol that shows starting of decoding input
  28. # E: Symbol that shows starting of decoding output
  29. # P: Symbol that will fill in blank sequence if current batch data size is short than time steps
  30.  
  31. # 训练集
  32. sentences = [
  33.     # 中文和英语的单词个数不要求相同
  34.     # enc_input                dec_input           dec_output
  35.     ['我 有 一 个 好 朋 友 P', 'S I have a good friend .', 'I have a good friend . E'],
  36.     ['我 有 零 个 女 朋 友 P', 'S I have zero girl friend .', 'I have zero girl friend . E'],
  37.     ['我 有 一 个 男 朋 友 P', 'S I have a boy friend .', 'I have a boy friend . E']
  38. ]
  39.  
  40. # 测试集（希望transformer能达到的效果）
  41. # 输入："我 有 一 个 女 朋 友"
  42. # 输出："i have a girlfriend"
  43.  
  44. # 中文和英语的单词要分开建立词库
  45. # Padding Should be Zero
  46. src_vocab = {'P': 0, '我': 1, '有': 2, '一': 3,
  47.              '个': 4, '好': 5, '朋': 6, '友': 7, '零': 8, '女': 9, '男': 10}
  48. src_idx2word = {i: w for i, w in enumerate(src_vocab)}
  49. src_vocab_size = len(src_vocab)
  50.  
  51. tgt_vocab = {'P': 0, 'I': 1, 'have': 2, 'a': 3, 'good': 4,
  52.              'friend': 5, 'zero': 6, 'girl': 7,  'boy': 8, 'S': 9, 'E': 10, '.': 11}
  53. idx2word = {i: w for i, w in enumerate(tgt_vocab)}
  54. tgt_vocab_size = len(tgt_vocab)
  55.  
  56. src_len = 8  # （源句子的长度）enc_input max sequence length
  57. tgt_len = 7  # dec_input(=dec_output) max sequence length
  58.  
  59. # Transformer Parameters
  60. d_model = 512  # Embedding Size（token embedding和position编码的维度）
  61. # FeedForward dimension (两次线性层中的隐藏层 512->2048->512，线性层是用来做特征提取的），当然最后会再接一个projection层
  62. d_ff = 2048
  63. d_k = d_v = 64  # dimension of K(=Q), V（Q和K的维度需要相同，这里为了方便让K=V）
  64. n_layers = 6  # number of Encoder of Decoder Layer（Block的个数）
  65. n_heads = 8  # number of heads in Multi-Head Attention（有几套头）
  66.  
  67.  
  68. # ==============================================================================================
  69. # 数据构建
  70.  
  71.  
  72. def make_data(sentences):
  73.     """把单词序列转换为数字序列"""
  74.     enc_inputs, dec_inputs, dec_outputs = [], [], []
  75.     for i in range(len(sentences)):
  76.  
  77.         enc_input = [[src_vocab[n] for n in sentences[i][0].split()]]
  78.         dec_input = [[tgt_vocab[n] for n in sentences[i][1].split()]]
  79.         dec_output = [[tgt_vocab[n] for n in sentences[i][2].split()]]
  80.  
  81.         #[[1, 2, 3, 4, 5, 6, 7, 0], [1, 2, 8, 4, 9, 6, 7, 0], [1, 2, 3, 4, 10, 6, 7, 0]]
  82.         enc_inputs.extend(enc_input)
  83.         #[[9, 1, 2, 3, 4, 5, 11], [9, 1, 2, 6, 7, 5, 11], [9, 1, 2, 3, 8, 5, 11]]
  84.         dec_inputs.extend(dec_input)
  85.         #[[1, 2, 3, 4, 5, 11, 10], [1, 2, 6, 7, 5, 11, 10], [1, 2, 3, 8, 5, 11, 10]]
  86.         dec_outputs.extend(dec_output)
  87.  
  88.     return torch.LongTensor(enc_inputs), torch.LongTensor(dec_inputs), torch.LongTensor(dec_outputs)
  89.  
  90.  
  91. enc_inputs, dec_inputs, dec_outputs = make_data(sentences)
  92.  
  93.  
  94. class MyDataSet(Data.Dataset):
  95.     """自定义DataLoader"""
  96.  
  97.     def __init__(self, enc_inputs, dec_inputs, dec_outputs):
  98.         super(MyDataSet, self).__init__()
  99.         self.enc_inputs = enc_inputs
  100.         self.dec_inputs = dec_inputs
  101.         self.dec_outputs = dec_outputs
  102.  
  103.     def __len__(self):
  104.         return self.enc_inputs.shape[0]
  105.  
  106.     def __getitem__(self, idx):
  107.         return self.enc_inputs[idx], self.dec_inputs[idx], self.dec_outputs[idx]
  108.  
  109.  
  110. loader = Data.DataLoader(
  111.     MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)
  112.  
  113.  
  114. # ====================================================================================================
  115. # Transformer模型
  116.  
  117. class PositionalEncoding(nn.Module):
  118.     def __init__(self, d_model, dropout=0.1, max_len=5000):
  119.         super(PositionalEncoding, self).__init__()
  120.         self.dropout = nn.Dropout(p=dropout)
  121.  
  122.         pe = torch.zeros(max_len, d_model)
  123.         position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
  124.         div_term = torch.exp(torch.arange(
  125.             0, d_model, 2).float() * (-math.log(10000.0) / d_model))
  126.         pe[:, 0::2] = torch.sin(position * div_term)
  127.         pe[:, 1::2] = torch.cos(position * div_term)
  128.         pe = pe.unsqueeze(0).transpose(0, 1)
  129.         self.register_buffer('pe', pe)
  130.  
  131.     def forward(self, x):
  132.         """
  133.         x: [seq_len, batch_size, d_model]
  134.         """
  135.         x = x + self.pe[:x.size(0), :]
  136.         return self.dropout(x)
  137.  
  138.  
  139. def get_attn_pad_mask(seq_q, seq_k):
  140.     # pad mask的作用：在对value向量加权平均的时候，可以让pad对应的alpha_ij=0，这样注意力就不会考虑到pad向量
  141.     """这里的q,k表示的是两个序列（跟注意力机制的q,k没有关系），例如encoder_inputs (x1,x2,..xm)和encoder_inputs (x1,x2..xm)
  142.     encoder和decoder都可能调用这个函数，所以seq_len视情况而定
  143.     seq_q: [batch_size, seq_len]
  144.     seq_k: [batch_size, seq_len]
  145.     seq_len could be src_len or it could be tgt_len
  146.     seq_len in seq_q and seq_len in seq_k maybe not equal
  147.     """
  148.     batch_size, len_q = seq_q.size()  # 这个seq_q只是用来expand维度的
  149.     batch_size, len_k = seq_k.size()
  150.     # eq(zero) is PAD token
  151.     # 例如:seq_k = [[1,2,3,4,0], [1,2,3,5,0]]
  152.     # [batch_size, 1, len_k], True is masked
  153.     pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)
  154.     # [batch_size, len_q, len_k] 构成一个立方体(batch_size个这样的矩阵)
  155.     return pad_attn_mask.expand(batch_size, len_q, len_k)
  156.  
  157.  
  158. def get_attn_subsequence_mask(seq):
  159.     """建议打印出来看看是什么的输出（一目了然）
  160.     seq: [batch_size, tgt_len]
  161.     """
  162.     attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
  163.     # attn_shape: [batch_size, tgt_len, tgt_len]
  164.     subsequence_mask = np.triu(np.ones(attn_shape), k=1)  # 生成一个上三角矩阵
  165.     subsequence_mask = torch.from_numpy(subsequence_mask).byte()
  166.     return subsequence_mask  # [batch_size, tgt_len, tgt_len]
  167.  
  168.  
  169. # ==========================================================================================
  170. class ScaledDotProductAttention(nn.Module):
  171.     def __init__(self):
  172.         super(ScaledDotProductAttention, self).__init__()
  173.  
  174.     def forward(self, Q, K, V, attn_mask):
  175.         """
  176.         Q: [batch_size, n_heads, len_q, d_k]
  177.         K: [batch_size, n_heads, len_k, d_k]
  178.         V: [batch_size, n_heads, len_v(=len_k), d_v]
  179.         attn_mask: [batch_size, n_heads, seq_len, seq_len]
  180.         说明：在encoder-decoder的Attention层中len_q(q1,..qt)和len_k(k1,...km)可能不同
  181.         """
  182.         scores = torch.matmul(Q, K.transpose(-1, -2)) / \
  183.             np.sqrt(d_k)  # scores : [batch_size, n_heads, len_q, len_k]
  184.         # mask矩阵填充scores（用-1e9填充scores中与attn_mask中值为1位置相对应的元素）
  185.         # Fills elements of self tensor with value where mask is True.
  186.         scores.masked_fill_(attn_mask, -1e9)
  187.  
  188.         attn = nn.Softmax(dim=-1)(scores)  # 对最后一个维度(v)做softmax
  189.         # scores : [batch_size, n_heads, len_q, len_k] * V: [batch_size, n_heads, len_v(=len_k), d_v]
  190.         # context: [batch_size, n_heads, len_q, d_v]
  191.         context = torch.matmul(attn, V)
  192.         # context：[[z1,z2,...],[...]]向量, attn注意力稀疏矩阵（用于可视化的）
  193.         return context, attn
  194.  
  195.  
  196. class MultiHeadAttention(nn.Module):
  197.     """这个Attention类可以实现:
  198.     Encoder的Self-Attention
  199.     Decoder的Masked Self-Attention
  200.     Encoder-Decoder的Attention
  201.     输入：seq_len x d_model
  202.     输出：seq_len x d_model
  203.     """
  204.  
  205.     def __init__(self):
  206.         super(MultiHeadAttention, self).__init__()
  207.         self.W_Q = nn.Linear(d_model, d_k * n_heads,
  208.                              bias=False)  # q,k必须维度相同，不然无法做点积
  209.         self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)
  210.         self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)
  211.         # 这个全连接层可以保证多头attention的输出仍然是seq_len x d_model
  212.         self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)
  213.  
  214.     def forward(self, input_Q, input_K, input_V, attn_mask):
  215.         """
  216.         input_Q: [batch_size, len_q, d_model]
  217.         input_K: [batch_size, len_k, d_model]
  218.         input_V: [batch_size, len_v(=len_k), d_model]
  219.         attn_mask: [batch_size, seq_len, seq_len]
  220.         """
  221.         residual, batch_size = input_Q, input_Q.size(0)
  222.         # 下面的多头的参数矩阵是放在一起做线性变换的，然后再拆成多个头，这是工程实现的技巧
  223.         # B: batch_size, S:seq_len, D: dim
  224.         # (B, S, D) -proj-> (B, S, D_new) -split-> (B, S, Head, W) -trans-> (B, Head, S, W)
  225.         #           线性变换               拆成多头
  226.  
  227.         # Q: [batch_size, n_heads, len_q, d_k]
  228.         Q = self.W_Q(input_Q).view(batch_size, -1,
  229.                                    n_heads, d_k).transpose(1, 2)
  230.         # K: [batch_size, n_heads, len_k, d_k] # K和V的长度一定相同，维度可以不同
  231.         K = self.W_K(input_K).view(batch_size, -1,
  232.                                    n_heads, d_k).transpose(1, 2)
  233.         # V: [batch_size, n_heads, len_v(=len_k), d_v]
  234.         V = self.W_V(input_V).view(batch_size, -1,
  235.                                    n_heads, d_v).transpose(1, 2)
  236.  
  237.         # 因为是多头，所以mask矩阵要扩充成4维的
  238.         # attn_mask: [batch_size, seq_len, seq_len] -> [batch_size, n_heads, seq_len, seq_len]
  239.         attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
  240.  
  241.         # context: [batch_size, n_heads, len_q, d_v], attn: [batch_size, n_heads, len_q, len_k]
  242.         context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)
  243.         # 下面将不同头的输出向量拼接在一起
  244.         # context: [batch_size, n_heads, len_q, d_v] -> [batch_size, len_q, n_heads * d_v]
  245.         context = context.transpose(1, 2).reshape(
  246.             batch_size, -1, n_heads * d_v)
  247.  
  248.         # 这个全连接层可以保证多头attention的输出仍然是seq_len x d_model
  249.         output = self.fc(context)  # [batch_size, len_q, d_model]
  250.         return nn.LayerNorm(d_model).to(device)(output + residual), attn
  251.  
  252.  
  253. # Pytorch中的Linear只会对最后一维操作，所以正好是我们希望的每个位置用同一个全连接网络
  254. class PoswiseFeedForwardNet(nn.Module):
  255.     def __init__(self):
  256.         super(PoswiseFeedForwardNet, self).__init__()
  257.         self.fc = nn.Sequential(
  258.             nn.Linear(d_model, d_ff, bias=False),
  259.             nn.ReLU(),
  260.             nn.Linear(d_ff, d_model, bias=False)
  261.         )
  262.  
  263.     def forward(self, inputs):
  264.         """
  265.         inputs: [batch_size, seq_len, d_model]
  266.         """
  267.         residual = inputs
  268.         output = self.fc(inputs)
  269.         # [batch_size, seq_len, d_model]
  270.         return nn.LayerNorm(d_model).to(device)(output + residual)
  271.  
  272.  
  273. class EncoderLayer(nn.Module):
  274.     def __init__(self):
  275.         super(EncoderLayer, self).__init__()
  276.         self.enc_self_attn = MultiHeadAttention()
  277.         self.pos_ffn = PoswiseFeedForwardNet()
  278.  
  279.     def forward(self, enc_inputs, enc_self_attn_mask):
  280.         """E
  281.         enc_inputs: [batch_size, src_len, d_model]
  282.         enc_self_attn_mask: [batch_size, src_len, src_len]  mask矩阵(pad mask or sequence mask)
  283.         """
  284.         # enc_outputs: [batch_size, src_len, d_model], attn: [batch_size, n_heads, src_len, src_len]
  285.         # 第一个enc_inputs * W_Q = Q
  286.         # 第二个enc_inputs * W_K = K
  287.         # 第三个enc_inputs * W_V = V
  288.         enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs,
  289.                                                enc_self_attn_mask)  # enc_inputs to same Q,K,V（未线性变换前）
  290.         enc_outputs = self.pos_ffn(enc_outputs)
  291.         # enc_outputs: [batch_size, src_len, d_model]
  292.         return enc_outputs, attn
  293.  
  294.  
  295. class DecoderLayer(nn.Module):
  296.     def __init__(self):
  297.         super(DecoderLayer, self).__init__()
  298.         self.dec_self_attn = MultiHeadAttention()
  299.         self.dec_enc_attn = MultiHeadAttention()
  300.         self.pos_ffn = PoswiseFeedForwardNet()
  301.  
  302.     def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
  303.         """
  304.         dec_inputs: [batch_size, tgt_len, d_model]
  305.         enc_outputs: [batch_size, src_len, d_model]
  306.         dec_self_attn_mask: [batch_size, tgt_len, tgt_len]
  307.         dec_enc_attn_mask: [batch_size, tgt_len, src_len]
  308.         """
  309.         # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len]
  310.         dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs,
  311.                                                         dec_self_attn_mask)  # 这里的Q,K,V全是Decoder自己的输入
  312.         # dec_outputs: [batch_size, tgt_len, d_model], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]
  313.         dec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs,
  314.                                                       dec_enc_attn_mask)  # Attention层的Q(来自decoder) 和 K,V(来自encoder)
  315.         # [batch_size, tgt_len, d_model]
  316.         dec_outputs = self.pos_ffn(dec_outputs)
  317.         # dec_self_attn, dec_enc_attn这两个是为了可视化的
  318.         return dec_outputs, dec_self_attn, dec_enc_attn
  319.  
  320.  
  321. class Encoder(nn.Module):
  322.     def __init__(self):
  323.         super(Encoder, self).__init__()
  324.         self.src_emb = nn.Embedding(src_vocab_size, d_model)  # token Embedding
  325.         self.pos_emb = PositionalEncoding(
  326.             d_model)  # Transformer中位置编码时固定的，不需要学习
  327.         self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
  328.  
  329.     def forward(self, enc_inputs):
  330.         """
  331.         enc_inputs: [batch_size, src_len]
  332.         """
  333.         enc_outputs = self.src_emb(
  334.             enc_inputs)  # [batch_size, src_len, d_model]
  335.         enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(
  336.             0, 1)  # [batch_size, src_len, d_model]
  337.         # Encoder输入序列的pad mask矩阵
  338.         enc_self_attn_mask = get_attn_pad_mask(
  339.             enc_inputs, enc_inputs)  # [batch_size, src_len, src_len]
  340.         enc_self_attns = []  # 在计算中不需要用到，它主要用来保存你接下来返回的attention的值（这个主要是为了你画热力图等，用来看各个词之间的关系
  341.         for layer in self.layers:  # for循环访问nn.ModuleList对象
  342.             # 上一个block的输出enc_outputs作为当前block的输入
  343.             # enc_outputs: [batch_size, src_len, d_model], enc_self_attn: [batch_size, n_heads, src_len, src_len]
  344.             enc_outputs, enc_self_attn = layer(enc_outputs,
  345.                                                enc_self_attn_mask)  # 传入的enc_outputs其实是input，传入mask矩阵是因为你要做self attention
  346.             enc_self_attns.append(enc_self_attn)  # 这个只是为了可视化
  347.         return enc_outputs, enc_self_attns
  348.  
  349.  
  350. class Decoder(nn.Module):
  351.     def __init__(self):
  352.         super(Decoder, self).__init__()
  353.         self.tgt_emb = nn.Embedding(
  354.             tgt_vocab_size, d_model)  # Decoder输入的embed词表
  355.         self.pos_emb = PositionalEncoding(d_model)
  356.         self.layers = nn.ModuleList([DecoderLayer()
  357.                                     for _ in range(n_layers)])  # Decoder的blocks
  358.  
  359.     def forward(self, dec_inputs, enc_inputs, enc_outputs):
  360.         """
  361.         dec_inputs: [batch_size, tgt_len]
  362.         enc_inputs: [batch_size, src_len]
  363.         enc_outputs: [batch_size, src_len, d_model]   # 用在Encoder-Decoder Attention层
  364.         """
  365.         dec_outputs = self.tgt_emb(
  366.             dec_inputs)  # [batch_size, tgt_len, d_model]
  367.         dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1).to(
  368.             device)  # [batch_size, tgt_len, d_model]
  369.         # Decoder输入序列的pad mask矩阵（这个例子中decoder是没有加pad的，实际应用中都是有pad填充的）
  370.         dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs).to(
  371.             device)  # [batch_size, tgt_len, tgt_len]
  372.         # Masked Self_Attention：当前时刻是看不到未来的信息的
  373.         dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs).to(
  374.             device)  # [batch_size, tgt_len, tgt_len]
  375.  
  376.         # Decoder中把两种mask矩阵相加（既屏蔽了pad的信息，也屏蔽了未来时刻的信息）
  377.         dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequence_mask),
  378.                                       0).to(device)  # [batch_size, tgt_len, tgt_len]; torch.gt比较两个矩阵的元素，大于则返回1，否则返回0
  379.  
  380.         # 这个mask主要用于encoder-decoder attention层
  381.         # get_attn_pad_mask主要是enc_inputs的pad mask矩阵(因为enc是处理K,V的，求Attention时是用v1,v2,..vm去加权的，要把pad对应的v_i的相关系数设为0，这样注意力就不会关注pad向量)
  382.         #                       dec_inputs只是提供expand的size的
  383.         dec_enc_attn_mask = get_attn_pad_mask(
  384.             dec_inputs, enc_inputs)  # [batc_size, tgt_len, src_len]
  385.  
  386.         dec_self_attns, dec_enc_attns = [], []
  387.         for layer in self.layers:
  388.             # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]
  389.             # Decoder的Block是上一个Block的输出dec_outputs（变化）和Encoder网络的输出enc_outputs（固定）
  390.             dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs, dec_self_attn_mask,
  391.                                                              dec_enc_attn_mask)
  392.             dec_self_attns.append(dec_self_attn)
  393.             dec_enc_attns.append(dec_enc_attn)
  394.         # dec_outputs: [batch_size, tgt_len, d_model]
  395.         return dec_outputs, dec_self_attns, dec_enc_attns
  396.  
  397.  
  398. class Transformer(nn.Module):
  399.     def __init__(self):
  400.         super(Transformer, self).__init__()
  401.         self.encoder = Encoder().to(device)
  402.         self.decoder = Decoder().to(device)
  403.         self.projection = nn.Linear(
  404.             d_model, tgt_vocab_size, bias=False).to(device)
  405.  
  406.     def forward(self, enc_inputs, dec_inputs):
  407.         """Transformers的输入：两个序列
  408.         enc_inputs: [batch_size, src_len]
  409.         dec_inputs: [batch_size, tgt_len]
  410.         """
  411.         # tensor to store decoder outputs
  412.         # outputs = torch.zeros(batch_size, tgt_len, tgt_vocab_size).to(self.device)
  413.  
  414.         # enc_outputs: [batch_size, src_len, d_model], enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len]
  415.         # 经过Encoder网络后，得到的输出还是[batch_size, src_len, d_model]
  416.         enc_outputs, enc_self_attns = self.encoder(enc_inputs)
  417.         # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attns: [n_layers, batch_size, n_heads, tgt_len, tgt_len], dec_enc_attn: [n_layers, batch_size, tgt_len, src_len]
  418.         dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(
  419.             dec_inputs, enc_inputs, enc_outputs)
  420.         # dec_outputs: [batch_size, tgt_len, d_model] -> dec_logits: [batch_size, tgt_len, tgt_vocab_size]
  421.         dec_logits = self.projection(dec_outputs)
  422.         return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns
  423.  
  424.  
  425. model = Transformer().to(device)
  426. # 这里的损失函数里面设置了一个参数 ignore_index=0，因为 "pad" 这个单词的索引为 0，这样设置以后，就不会计算 "pad" 的损失（因为本来 "pad" 也没有意义，不需要计算）
  427. criterion = nn.CrossEntropyLoss(ignore_index=0)
  428. optimizer = optim.SGD(model.parameters(), lr=1e-3,
  429.                       momentum=0.99)  # 用adam的话效果不好
  430.  
  431. # ====================================================================================================
  432. for epoch in range(epochs):
  433.     for enc_inputs, dec_inputs, dec_outputs in loader:
  434.         """
  435.         enc_inputs: [batch_size, src_len]
  436.         dec_inputs: [batch_size, tgt_len]
  437.         dec_outputs: [batch_size, tgt_len]
  438.         """
  439.         enc_inputs, dec_inputs, dec_outputs = enc_inputs.to(
  440.             device), dec_inputs.to(device), dec_outputs.to(device)
  441.         # outputs: [batch_size * tgt_len, tgt_vocab_size]
  442.         outputs, enc_self_attns, dec_self_attns, dec_enc_attns = model(
  443.             enc_inputs, dec_inputs)
  444.         # dec_outputs.view(-1):[batch_size * tgt_len * tgt_vocab_size]
  445.         loss = criterion(outputs, dec_outputs.view(-1))
  446.         print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))
  447.  
  448.         optimizer.zero_grad()
  449.         loss.backward()
  450.         optimizer.step()
  451.  
  452.  
  453. def greedy_decoder(model, enc_input, start_symbol):
  454.     """贪心编码
  455.     For simplicity, a Greedy Decoder is Beam search when K=1. This is necessary for inference as we don't know the
  456.     target sequence input. Therefore we try to generate the target input word by word, then feed it into the transformer.
  457.     Starting Reference: http://nlp.seas.harvard.edu/2018/04/03/attention.html#greedy-decoding
  458.     :param model: Transformer Model
  459.     :param enc_input: The encoder input
  460.     :param start_symbol: The start symbol. In this example it is 'S' which corresponds to index 4
  461.     :return: The target input
  462.     """
  463.     enc_outputs, enc_self_attns = model.encoder(enc_input)
  464.     # 初始化一个空的tensor: tensor([], size=(1, 0), dtype=torch.int64)
  465.     dec_input = torch.zeros(1, 0).type_as(enc_input.data)
  466.     terminal = False
  467.     next_symbol = start_symbol
  468.     while not terminal:
  469.         # 预测阶段：dec_input序列会一点点变长（每次添加一个新预测出来的单词）
  470.         dec_input = torch.cat([dec_input.to(device), torch.tensor([[next_symbol]], dtype=enc_input.dtype).to(device)],
  471.                               -1)
  472.         dec_outputs, _, _ = model.decoder(dec_input, enc_input, enc_outputs)
  473.         projected = model.projection(dec_outputs)
  474.         prob = projected.squeeze(0).max(dim=-1, keepdim=False)[1]
  475.         # 增量更新（我们希望重复单词预测结果是一样的）
  476.         # 我们在预测是会选择性忽略重复的预测的词，只摘取最新预测的单词拼接到输入序列中
  477.         # 拿出当前预测的单词(数字)。我们用x'_t对应的输出z_t去预测下一个单词的概率，不用z_1,z_2..z_{t-1}
  478.         next_word = prob.data[-1]
  479.         next_symbol = next_word
  480.         if next_symbol == tgt_vocab["E"]:
  481.             terminal = True
  482.         # print(next_word)
  483.  
  484.     # greedy_dec_predict = torch.cat(
  485.     #     [dec_input.to(device), torch.tensor([[next_symbol]], dtype=enc_input.dtype).to(device)],
  486.     #     -1)
  487.     greedy_dec_predict = dec_input[:, 1:]
  488.     return greedy_dec_predict
  489.  
  490.  
  491. # ==========================================================================================
  492. # 预测阶段
  493. # 测试集
  494. sentences = [
  495.     # enc_input                dec_input           dec_output
  496.     ['我 有 零 个 女 朋 友 P', '', '']
  497. ]
  498.  
  499. enc_inputs, dec_inputs, dec_outputs = make_data(sentences)
  500. test_loader = Data.DataLoader(
  501.     MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)
  502. enc_inputs, _, _ = next(iter(test_loader))
  503.  
  504. print()
  505. print("="*30)
  506. print("利用训练好的Transformer模型将中文句子'我 有 零 个 女 朋 友' 翻译成英文句子: ")
  507. for i in range(len(enc_inputs)):
  508.     greedy_dec_predict = greedy_decoder(model, enc_inputs[i].view(
  509.         1, -1).to(device), start_symbol=tgt_vocab["S"])
  510.     print(enc_inputs[i], '->', greedy_dec_predict.squeeze())
  511.     print([src_idx2word[t.item()] for t in enc_inputs[i]], '->',
  512.           [idx2word[n.item()] for n in greedy_dec_predict.squeeze()])
  513.  
  514.  
  515.

结果：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/359807
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号