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

Transformer代码逐步解读（pytorch版本）Encoder部分_class encoderlayer(nn.module): def __init__(self,

作者：凡人多烦事01 | 2024-05-03 09:28:09

赞

踩

class encoderlayer(nn.module): def __init__(self, attention, d_model, d_ff=n

目录

Model部分的源码如下:

data部分的源码如下 

对于data部分的代码分析 

 1.Encoder部分的代码分析

 （1）在Encoder中首先进入的是Embedding层。

（2）在Encoder中第二次进入的是Positional层。

（3）在Encoder中第三次进入的是get_attn_pad_mask，

（4）最后一步进入的是layer层，也就是Encoderlayer层，最主要的计算都在这里。

 多头注意力的部分，

 代码来自b站up：数学家是我理想

代码总体分为三个部分，data部分是测试用的数据，为手动输入为了方便理解代码的流程比较简单。model部分是整个模型的代码流程。 

Model部分的源码如下:

  1. import math
  2. import torch
  3. import numpy as np
  4. import torch.nn as nn
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11. # Transformer Parameters
  12. from transformer_data import src_vocab_size, target_vocab_size
  13.  
  14. d_model = 512  # Embedding Size
  15. d_ff = 2048 # FeedForward dimension
  16. d_k = d_v = 64  # dimension of K(=Q), V
  17. n_layers = 6  # number of Encoder of Decoder Layer
  18. n_heads = 8  # number of heads in Multi-Head Attention
  19.  
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  
  26. class PositionalEncoding(nn.Module):
  27.     def __init__(self, d_model, dropout=0.1, max_len=5000):
  28.         super(PositionalEncoding, self).__init__()
  29.         self.dropout = nn.Dropout(p=dropout)
  30.  
  31.         #pe的维度是（5000，512）
  32.         pe = torch.zeros(max_len, d_model)
  33.  
  34.         #position是一个5000行1列的tensor
  35.         position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
  36.  
  37.         #div_term是一个256长度的一维tensor
  38.         div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
  39.  
  40.         pe[:, 0::2] = torch.sin(position * div_term)
  41.         pe[:, 1::2] = torch.cos(position * div_term)
  42.  
  43.         pe = pe.unsqueeze(0).transpose(0, 1)
  44.         #最终的pe是一个torch.Size([5000, 1, 512])的维度
  45.         self.register_buffer('pe', pe)
  46.  
  47.     def forward(self, x):
  48.         '''
  49.         x: [seq_len, batch_size, d_model]
  50.         '''
  51.         x = x + self.pe[:x.size(0), :]
  52.        
  53.         return self.dropout(x)
  54.  
  55. def get_attn_pad_mask(seq_q, seq_k):
  56.     '''
  57.     seq_q: [batch_size, seq_len]
  58.     seq_k: [batch_size, seq_len]
  59.     seq_len could be src_len or it could be tgt_len
  60.     seq_len in seq_q and seq_len in seq_k maybe not equal
  61.     '''
  62.     batch_size, len_q = seq_q.size()
  63.     batch_size, len_k = seq_k.size()
  64.     # eq(zero) is PAD token
  65.     pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)  # [batch_size, 1, len_k], True is masked
  66.     return pad_attn_mask.expand(batch_size, len_q, len_k)  # [batch_size, len_q, len_k]
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73. def get_attn_subsequence_mask(seq):
  74.     '''
  75.     seq: [batch_size, tgt_len]
  76.     '''
  77.     attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
  78.     subsequence_mask = np.triu(np.ones(attn_shape), k=1) # Upper triangular matrix
  79.     subsequence_mask = torch.from_numpy(subsequence_mask).byte()
  80.     return subsequence_mask # [batch_size, tgt_len, tgt_len]
  81.  
  82.  
  83. class ScaledDotProductAttention(nn.Module):
  84.     def __init__(self):
  85.         super(ScaledDotProductAttention, self).__init__()
  86.  
  87.     def forward(self, Q, K, V, attn_mask):
  88.         '''
  89.         Q: [batch_size, n_heads, len_q, d_k]
  90.         K: [batch_size, n_heads, len_k, d_k]
  91.         V: [batch_size, n_heads, len_v(=len_k), d_v]
  92.         attn_mask: [batch_size, n_heads, seq_len, seq_len]
  93.         '''
  94.         scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)  # scores : [batch_size, n_heads, len_q, len_k]
  95.  
  96.         scores.masked_fill_(attn_mask, -1e9)  # Fills elements of self tensor with value where mask is True.
  97.  
  98.         attn = nn.Softmax(dim=-1)(scores)
  99.  
  100.  
  101.         context = torch.matmul(attn, V)  # [batch_size, n_heads, len_q, d_v]
  102.         # print(attn.shape)
  103.         # print(V.shape)
  104.         # torch.Size([2, 8, 5, 5])
  105.         # torch.Size([2, 8, 5, 64])
  106.         return context, attn
  107.  
  108. class MultiHeadAttention(nn.Module):
  109.     def __init__(self):
  110.         super(MultiHeadAttention, self).__init__()
  111.         self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)
  112.         #d_k * n_heads     64 * 8
  113.         self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)
  114.         self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)
  115.         self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)
  116.  
  117.     #input_Q  （2，5，512）    attn_mask （2，5，5）
  118.     def forward(self, input_Q, input_K, input_V, attn_mask):
  119.             # '''
  120.             # input_Q: [batch_size, len_q, d_model] （2，5，512）
  121.             # input_K: [batch_size, len_k, d_model]
  122.             # input_V: [batch_size, len_v(=len_k), d_model]
  123.             # attn_mask: [batch_size, seq_len, seq_len]
  124.             # '''
  125.         #print("input_Q的维度", input_Q.shape)
  126.         residual, batch_size = input_Q, input_Q.size(0)
  127.             # (B, S, D) -proj-> (B, S, D_new) -split-> (B, S, H, W) -trans-> (B, H, S, W)
  128.             # D_new这个新的维度就是原本的维度 × n个头，也就是
  129.         Q = self.W_Q(input_Q).view(batch_size, -1, n_heads, d_k).transpose(1,2)
  130.             # Q: [batch_size, n_heads, len_q, d_k]
  131.             #（2，5，512）-> (2,5,8,64) ->
  132.         K = self.W_K(input_K).view(batch_size, -1, n_heads, d_k).transpose(1,2)
  133.             # K: [batch_size, n_heads, len_k, d_k]
  134.  
  135.         V = self.W_V(input_V).view(batch_size, -1, n_heads, d_v).transpose(1,2)
  136.             # V: [batch_size, n_heads, len_v(=len_k), d_v]
  137.  
  138.            # torch.Size([2, 5, 5]) -》([2, 8, 5, 5]) 也就是复制了几份
  139.  
  140.         attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
  141.         # attn_mask : [batch_size, n_heads, seq_len, seq_len]
  142.  
  143.         # context: [batch_size, n_heads, len_q, d_v], attn: [batch_size, n_heads, len_q, len_k]
  144.         context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)
  145.         # (2,8,5,64)
  146.         # (2,8,5,5)
  147.  
  148.  
  149.         context = context.transpose(1, 2).reshape(batch_size, -1,n_heads * d_v)
  150.         # context: [batch_size, len_q, n_heads * d_v]
  151.         #2 8 5 64 -> 2 5 8 64 -> 2 5 512
  152.  
  153.         #self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)
  154.         #8 * 64 -> 512
  155.         output = self.fc(context)  # [batch_size, len_q, d_model]
  156.         print("attn.shapeattn.shapeattn.shapeattn.shapeattn.shapeattn.shapeattn.shapeattn.shapeattn.shape")
  157.         print(attn.shape)
  158.         return nn.LayerNorm(d_model).cuda()(output + residual), attn
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165. class PoswiseFeedForwardNet(nn.Module):
  166.     def __init__(self):
  167.         super(PoswiseFeedForwardNet, self).__init__()
  168.         self.fc = nn.Sequential(
  169.             nn.Linear(d_model, d_ff, bias=False),
  170.             nn.ReLU(),
  171.             nn.Linear(d_ff, d_model, bias=False)
  172.         )
  173.     def forward(self, inputs):
  174.         '''
  175.         inputs: [batch_size, seq_len, d_model]
  176.         '''
  177.         residual = inputs
  178.         output = self.fc(inputs)
  179.         return nn.LayerNorm(d_model).cuda()(output + residual) # [batch_size, seq_len, d_model]
  180.  
  181.  
  182. # enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)
  183. class EncoderLayer(nn.Module):
  184.     def __init__(self):
  185.         super(EncoderLayer, self).__init__()
  186.         self.enc_self_attn = MultiHeadAttention()
  187.         self.pos_ffn = PoswiseFeedForwardNet()
  188.  
  189.     def forward(self, enc_inputs, enc_self_attn_mask):
  190.         '''
  191.         enc_inputs: [batch_size, src_len, d_model]
  192.         enc_self_attn_mask: [batch_size, src_len, src_len]
  193.         '''
  194.         # enc_outputs: [batch_size, src_len, d_model], attn: [batch_size, n_heads, src_len, src_len]
  195.         enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V
  196.         enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size, src_len, d_model]
  197.         return enc_outputs, attn
  198.  
  199. class Encoder(nn.Module):
  200.     def __init__(self):
  201.         super(Encoder, self).__init__()
  202.         self.src_emb = nn.Embedding(src_vocab_size, d_model)
  203.         #词向量，src_vocab_size 有多少个词库，d_model是要转换的维度。
  204.  
  205.  
  206.         self.pos_emb = PositionalEncoding(d_model)
  207.         #返回的是一个二维的矩阵
  208.  
  209.         self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
  210.  
  211.     def forward(self, enc_inputs):
  212.         '''
  213.         enc_inputs: [batch_size, src_len]
  214.         '''
  215.         enc_outputs = self.src_emb(enc_inputs) # [batch_size, src_len, d_model]
  216.         enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1) # [batch_size, src_len, d_model]
  217.         enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs) # [batch_size, src_len, src_len]
  218.         enc_self_attns = []
  219.         for layer in self.layers:
  220.             # enc_outputs: [batch_size, src_len, d_model], enc_self_attn: [batch_size, n_heads, src_len, src_len]
  221.             enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)
  222.             enc_self_attns.append(enc_self_attn)
  223.         return enc_outputs, enc_self_attns
  224.  
  225. class DecoderLayer(nn.Module):
  226.     def __init__(self):
  227.         super(DecoderLayer, self).__init__()
  228.         self.dec_self_attn = MultiHeadAttention()
  229.         self.dec_enc_attn = MultiHeadAttention()
  230.         self.pos_ffn = PoswiseFeedForwardNet()
  231.  
  232.     def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
  233.         '''
  234.         dec_inputs: [batch_size, tgt_len, d_model]
  235.         enc_outputs: [batch_size, src_len, d_model]
  236.         dec_self_attn_mask: [batch_size, tgt_len, tgt_len]
  237.         dec_enc_attn_mask: [batch_size, tgt_len, src_len]
  238.         '''
  239.         # dec_outputs: [batch_size, tgt_len, d_model], dec_self_attn: [batch_size, n_heads, tgt_len, tgt_len]
  240.         dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs, dec_self_attn_mask)
  241.         # dec_outputs: [batch_size, tgt_len, d_model], dec_enc_attn: [batch_size, h_heads, tgt_len, src_len]
  242.         dec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs, enc_outputs, dec_enc_attn_mask)
  243.         dec_outputs = self.pos_ffn(dec_outputs) # [batch_size, tgt_len, d_model]
  244.         return dec_outputs, dec_self_attn, dec_enc_attn
  245.  
  246. class Decoder(nn.Module):
  247.     def __init__(self):
  248.         super(Decoder, self).__init__()
  249.         self.tgt_emb = nn.Embedding(target_vocab_size, d_model)
  250.         self.pos_emb = PositionalEncoding(d_model)
  251.         self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])
  252.  
  253.     def forward(self, dec_inputs, enc_inputs, enc_outputs):
  254.         '''
  255.         dec_inputs: [batch_size, tgt_len]
  256.         enc_intpus: [batch_size, src_len]
  257.         enc_outputs: [batch_size, src_len, d_model]
  258.         '''
  259.         dec_outputs = self.tgt_emb(dec_inputs) # [batch_size, tgt_len, d_model]
  260.         dec_outputs = self.pos_emb(dec_outputs.transpose(0, 1)).transpose(0, 1).cuda() # [batch_size, tgt_len, d_model]
  261.         dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs).cuda() # [batch_size, tgt_len, tgt_len]
  262.         dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs).cuda() # [batch_size, tgt_len, tgt_len]
  263.         dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask + dec_self_attn_subsequence_mask), 0).cuda() # [batch_size, tgt_len, tgt_len]
  264.  
  265.         dec_enc_attn_mask = get_attn_pad_mask(dec_inputs, enc_inputs) # [batc_size, tgt_len, src_len]
  266.  
  267.         dec_self_attns, dec_enc_attns = [], []
  268.         for layer in self.layers:
  269.             # 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]
  270.             dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask)
  271.             dec_self_attns.append(dec_self_attn)
  272.             dec_enc_attns.append(dec_enc_attn)
  273.         return dec_outputs, dec_self_attns, dec_enc_attns
  274.  
  275.  
  276. class Transformer(nn.Module):
  277.     def __init__(self):
  278.         super(Transformer, self).__init__()
  279.         self.encoder = Encoder().cuda()
  280.         self.decoder = Decoder().cuda()
  281.         #这里的意思是，在encoder和decoder后都变成了512维的，然后再转换成target_vocab_size的维度的
  282.         # tgt_vocab = {'P': 0, 'i': 1, 'want': 2, 'a': 3, 'beer': 4, 'coke': 5, 'S': 6, 'E': 7, '.': 8}
  283.         # idx2word = {i: w for i, w in enumerate(tgt_vocab)}
  284.         # idx2word = {0: 'P', 1: 'i', 2: 'want', 3: 'a', 4: 'beer', 5: 'coke', 6: 'S', 7: 'E', 8: '.'}
  285.         # target_vocab_size = len(tgt_vocab)
  286.         #为什么要转换成 target_vocab_size这个维度呢，因为你有这么多单词，要判断概率最大的是哪一个。
  287.         self.projection = nn.Linear(d_model, target_vocab_size, bias=False).cuda()
  288.  
  289.     def forward(self, enc_inputs, dec_inputs):
  290.         '''
  291.         enc_inputs: [batch_size, src_len]
  292.         dec_inputs: [batch_size, tgt_len]
  293.         '''
  294.         # tensor to store decoder outputs
  295.         # outputs = torch.zeros(batch_size, tgt_len, tgt_vocab_size).to(self.device)
  296.  
  297.         # enc_outputs: [batch_size, src_len, d_model], enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len]
  298.         enc_outputs, enc_self_attns = self.encoder(enc_inputs)
  299.         # dec_outpus: [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]
  300.         dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)
  301.         dec_logits = self.projection(dec_outputs)  # dec_logits: [batch_size, tgt_len, tgt_vocab_size]
  302.         return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns

data部分的源码如下 

  1. import torch
  2. import torch.utils.data as Data
  3.  
  4. # S: Symbol that shows starting of decoding input
  5. # E: Symbol that shows starting of decoding output
  6. # P: Symbol that will fill in blank sequence if current batch data size is short than time steps
  7. sentences = [
  8.     # enc_input           dec_input         dec_output
  9.     ['ich mochte ein bier P', 'S i want a beer .', 'i want a beer . E'],
  10.     ['ich mochte ein cola P', 'S i want a coke .', 'i want a coke . E']
  11. ]
  12.  
  13. # Padding Should be Zero
  14. src_vocab = {'P': 0, 'ich': 1, 'mochte': 2, 'ein': 3, 'bier': 4, 'cola': 5}
  15. src_vocab_size = len(src_vocab)
  16.  
  17. tgt_vocab = {'P': 0, 'i': 1, 'want': 2, 'a': 3, 'beer': 4, 'coke': 5, 'S': 6, 'E': 7, '.': 8}
  18. idx2word = {i: w for i, w in enumerate(tgt_vocab)}
  19. target_vocab_size = len(tgt_vocab)
  20.  
  21. src_len = 5  # enc_input max sequence length
  22. tgt_len = 6  # dec_input(=dec_output) max sequence length
  23.  
  24.  
  25. def make_data(sentences):
  26.     enc_inputs, dec_inputs, dec_outputs = [], [], []
  27.     for i in range(len(sentences)):
  28.         enc_input = [[src_vocab[n] for n in sentences[i][0].split()]]  # [[1, 2, 3, 4, 0], [1, 2, 3, 5, 0]]
  29.         dec_input = [[tgt_vocab[n] for n in sentences[i][1].split()]]  # [[6, 1, 2, 3, 4, 8], [6, 1, 2, 3, 5, 8]]
  30.         dec_output = [[tgt_vocab[n] for n in sentences[i][2].split()]]  # [[1, 2, 3, 4, 8, 7], [1, 2, 3, 5, 8, 7]]
  31.  
  32.         enc_inputs.extend(enc_input)
  33.         dec_inputs.extend(dec_input)
  34.         dec_outputs.extend(dec_output)
  35.  
  36.     return torch.LongTensor(enc_inputs), torch.LongTensor(dec_inputs), torch.LongTensor(dec_outputs)
  37.  
  38.  
  39. enc_inputs, dec_inputs, dec_outputs = make_data(sentences)
  40.  
  41.  
  42. class MyDataSet(Data.Dataset):
  43.     def __init__(self, enc_inputs, dec_inputs, dec_outputs):
  44.         super(MyDataSet, self).__init__()
  45.         self.enc_inputs = enc_inputs
  46.         self.dec_inputs = dec_inputs
  47.         self.dec_outputs = dec_outputs
  48.  
  49.     def __len__(self):
  50.         return self.enc_inputs.shape[0]
  51.  
  52.     def __getitem__(self, idx):
  53.         return self.enc_inputs[idx], self.dec_inputs[idx], self.dec_outputs[idx]
  54.  
  55.  
  56. loader = Data.DataLoader(MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)

对于data部分的代码分析 

对于loader来说，需要设置的主要有三个参数，第一个参数是数据集，第二个参数是batch_size，也就是一次传入多少个数据。

loader = Data.DataLoader(MyDataSet(enc_inputs, dec_inputs, dec_outputs), 2, True)

对于loader中的数据，可以这样进行遍历。

for enc_inputs, dec_inputs, dec_outputs in loader:

 基本的数据的尺度如下，第一个encoder的input是（2，5），第二个decoder的input是（2，6），第三个decoder的output也是（2，6）

  1. tensor([[1, 2, 3, 4, 0],
  2.         [1, 2, 3, 5, 0]])
  3. torch.Size([2, 5])
  4. tensor([[6, 1, 2, 3, 4, 8],
  5.         [6, 1, 2, 3, 5, 8]])
  6. torch.Size([2, 6])
  7. tensor([[1, 2, 3, 4, 8, 7],
  8.         [1, 2, 3, 5, 8, 7]])
  9. torch.Size([2, 6])

 对于模型本身来说，首先接收的输入是enc_inputs也就是最初始的数据，（2，6）的维度的input。第一个接收这个原始的inputs的是encoder。

  1. class Transformer(nn.Module):
  2.     def __init__(self):
  3.         super(Transformer, self).__init__()
  4.         self.encoder = Encoder().cuda()
  5.         self.decoder = Decoder().cuda()
  6.         #这里的意思是，在encoder和decoder后都变成了512维的，然后再转换成target_vocab_size的维度的
  7.         # tgt_vocab = {'P': 0, 'i': 1, 'want': 2, 'a': 3, 'beer': 4, 'coke': 5, 'S': 6, 'E': 7, '.': 8}
  8.         # idx2word = {i: w for i, w in enumerate(tgt_vocab)}
  9.         # idx2word = {0: 'P', 1: 'i', 2: 'want', 3: 'a', 4: 'beer', 5: 'coke', 6: 'S', 7: 'E', 8: '.'}
  10.         # target_vocab_size = len(tgt_vocab)
  11.         #为什么要转换成 target_vocab_size这个维度呢，因为你有这么多单词，要判断概率最大的是哪一个。
  12.         self.projection = nn.Linear(d_model, target_vocab_size, bias=False).cuda()
  13.  
  14.     def forward(self, enc_inputs, dec_inputs):
  15.         '''
  16.         enc_inputs: [batch_size, src_len]
  17.         dec_inputs: [batch_size, tgt_len]
  18.         '''
  19.         # tensor to store decoder outputs
  20.         # outputs = torch.zeros(batch_size, tgt_len, tgt_vocab_size).to(self.device)
  21.  
  22.         # enc_outputs: [batch_size, src_len, d_model], enc_self_attns: [n_layers, batch_size, n_heads, src_len, src_len]
  23.         enc_outputs, enc_self_attns = self.encoder(enc_inputs)
  24.         # dec_outpus: [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]
  25.         dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)
  26.         dec_logits = self.projection(dec_outputs)  # dec_logits: [batch_size, tgt_len, tgt_vocab_size]
  27.         return dec_logits.view(-1, dec_logits.size(-1)), enc_self_attns, dec_self_attns, dec_enc_attns

 1.Encoder部分的代码分析

Encoder的初始化函数包括三个部分，

1.词编码（Embedding）

2.位置编码（PositionalEncoding）

3.若干个Encoder层（EncoderLayer）

其中词编码和位置编码都是唯一的，而可以包含若干个EncoderLayer，层数是可以手动设置。

  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)
  5.         #词向量，src_vocab_size 有多少个词库，d_model是要转换的维度。
  6.  
  7.  
  8.         self.pos_emb = PositionalEncoding(d_model)
  9.         #返回的是一个二维的矩阵
  10.  
  11.         self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
  12.  
  13.     def forward(self, enc_inputs):
  14.         '''
  15.         enc_inputs: [batch_size, src_len]
  16.         '''
  17.         enc_outputs = self.src_emb(enc_inputs) # [batch_size, src_len, d_model]
  18.         enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1) # [batch_size, src_len, d_model]
  19.         enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs) # [batch_size, src_len, src_len]
  20.         enc_self_attns = []
  21.         for layer in self.layers:
  22.             # enc_outputs: [batch_size, src_len, d_model], enc_self_attn: [batch_size, n_heads, src_len, src_len]
  23.             enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)
  24.             enc_self_attns.append(enc_self_attn)
  25.         return enc_outputs, enc_self_attns

 （1）在Encoder中首先进入的是Embedding层。

  1. init中的词编码如下：
  2. self.src_emb = nn.Embedding(src_vocab_size, d_model)
  3. forward中的词编码如下：
  4. enc_outputs = self.src_emb(enc_inputs)

1）对于nn.Embedding()，他接收两个参数，
一个参数是num_embeddings: int,也就是所编码的这个语言有多少个词库，因为这里数据是手写的，所以很短，是6.
src_vocab = {'P': 0, 'ich': 1, 'mochte': 2, 'ein': 3, 'bier': 4, 'cola': 5}
src_vocab_size = len(src_vocab)
另一个参数是embedding_dim: int,也就是想要编码生成的维度，在这里是512.
2）对于enc_outputs = self.src_emb(enc_inputs) # [batch_size, src_len, d_model]。输入的是enc_inputs也就是原始的最开始输入的数据，他的维度是（2，5）.经过输出之后的维度是（2，5，512）也就是说经过第一层词编码后，所得到的enc_outputs是（2，5，512）的维度。

（2）在Encoder中第二次进入的是Positional层。

  1. 在init中的函数如下
  2. self.pos_emb = PositionalEncoding(d_model)
  3. 在forward中的函数如下
  4. enc_outputs = self.pos_emb(enc_outputs.transpose(0, 1)).transpose(0, 1) # [batch_size, src_len, d_model]

进入positionalembedding层的是经过词编码的outputs也就是（2，5，512）的维度的tensor。

进入positional_embedding前的输入需要进行维度互换，在positional_embedding里面这个输入的维度是（5，2，512）而经过之后的还是（5，2，512）只不过是对于输入的x添加了位置信息。而出来之后的输入又经过了一遍transpose，所以最终的输出的维度还是（2，5，512）。位置编码的代码如下：

  1. class PositionalEncoding(nn.Module):
  2.     def __init__(self, d_model, dropout=0.1, max_len=5000):
  3.         super(PositionalEncoding, self).__init__()
  4.         self.dropout = nn.Dropout(p=dropout)
  5.  
  6.         #pe的维度是（5000，512）
  7.         pe = torch.zeros(max_len, d_model)
  8.  
  9.         #position是一个5000行1列的tensor
  10.         position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
  11.  
  12.         #div_term是一个256长度的一维tensor
  13.         div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
  14.  
  15.         pe[:, 0::2] = torch.sin(position * div_term)
  16.         pe[:, 1::2] = torch.cos(position * div_term)
  17.  
  18.         pe = pe.unsqueeze(0).transpose(0, 1)
  19.         #最终的pe是一个torch.Size([5000, 1, 512])的维度
  20.         self.register_buffer('pe', pe)
  21.  
  22.     def forward(self, x):
  23.         '''
  24.         x: [seq_len, batch_size, d_model]
  25.         '''
  26.         x = x + self.pe[:x.size(0), :]
  27.         return self.dropout(x)

（3）在Encoder中第三次进入的是get_attn_pad_mask，

在这里seq_q和seq_k都是刚才的输入，原始输入，他的维度是（2，5）

  1. def get_attn_pad_mask(seq_q, seq_k):
  2.     '''
  3.     seq_q: [batch_size, seq_len]
  4.     seq_k: [batch_size, seq_len]
  5.     seq_len could be src_len or it could be tgt_len
  6.     seq_len in seq_q and seq_len in seq_k maybe not equal
  7.     '''
  8.     batch_size, len_q = seq_q.size()
  9.     batch_size, len_k = seq_k.size()
  10.     # eq(zero) is PAD token
  11.     pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)  # [batch_size, 1, len_k], True is masked
  12.     return pad_attn_mask.expand(batch_size, len_q, len_k)  # [batch_size, len_q, len_k]

这个函数的输出如下图所示： 

（4）最后一步进入的是layer层，也就是Encoderlayer层，最主要的计算都在这里。

  1. init中的layer如下
  2. self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
  3.  
  4. forward中的layer如下
  5. enc_self_attns = []
  6.         for layer in self.layers:
  7.             # enc_outputs: [batch_size, src_len, d_model], enc_self_attn: [batch_size, n_heads, src_len, src_len]
  8.             enc_outputs, enc_self_attn = layer(enc_outputs, enc_self_attn_mask)
  9.             enc_self_attns.append(enc_self_attn)

如图所示，刚才红框的部分就是真正的Encoder所做的事情，

我们发现，EncoderLayer的部分很简单，主要包括两项

（1） MultiHeadAttention（多头注意力）

（2）PoswiseFeedForwardNet（前馈神经网络）

其中多头注意力主要是进行点积的计算也就是QKV的计算，而前馈神经网络主要是信息的凝聚和维度的变换。

  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.         '''
  9.         enc_inputs: [batch_size, src_len, d_model]
  10.         enc_self_attn_mask: [batch_size, src_len, src_len]
  11.         '''
  12.         # enc_outputs: [batch_size, src_len, d_model], attn: [batch_size, n_heads, src_len, src_len]
  13.         enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V
  14.         enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size, src_len, d_model]
  15.         return enc_outputs, attn

layer(enc_outputs, enc_self_attn_mask)，注意这里的输入enc_outputs的维度是（2，5，512），而enc_self_attn_mask的维度是(2,5,5).layer的enc_outputs对应的是EncoderLayers里面的enc_inputs,也就是说对于forward中的enc_outputs, 
attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask)，
他传入的三个参数enc_inputs都是上一层的enc_outputs，就是（2，5，512）的维度。enc_self_attn_mask也就是上一层的，其维度为（2，5，5）

 多头注意力的部分，

  1. class MultiHeadAttention(nn.Module):
  2.     def __init__(self):
  3.         super(MultiHeadAttention, self).__init__()
  4.         self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)
  5.         #d_k * n_heads     64 * 8
  6.         self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)
  7.         self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)
  8.         self.fc = nn.Linear(n_heads * d_v, d_model, bias=False)
  9.  
  10.     #input_Q  （2，5，512）    attn_mask （2，5，5）
  11.     def forward(self, input_Q, input_K, input_V, attn_mask):
  12.             # '''
  13.             # input_Q: [batch_size, len_q, d_model] （2，5，512）
  14.             # input_K: [batch_size, len_k, d_model]
  15.             # input_V: [batch_size, len_v(=len_k), d_model]
  16.             # attn_mask: [batch_size, seq_len, seq_len]
  17.             # '''
  18.         #print("input_Q的维度", input_Q.shape)
  19.         residual, batch_size = input_Q, input_Q.size(0)
  20.             # (B, S, D) -proj-> (B, S, D_new) -split-> (B, S, H, W) -trans-> (B, H, S, W)
  21.             # D_new这个新的维度就是原本的维度 × n个头，也就是
  22.         Q = self.W_Q(input_Q).view(batch_size, -1, n_heads, d_k).transpose(1,2)
  23.             # Q: [batch_size, n_heads, len_q, d_k]
  24.  
  25.         K = self.W_K(input_K).view(batch_size, -1, n_heads, d_k).transpose(1,2)
  26.             # K: [batch_size, n_heads, len_k, d_k]
  27.  
  28.         V = self.W_V(input_V).view(batch_size, -1, n_heads, d_v).transpose(1,2)
  29.             # V: [batch_size, n_heads, len_v(=len_k), d_v]
  30.  
  31.  
  32.  
  33.         attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
  34.         # attn_mask : [batch_size, n_heads, seq_len, seq_len]
  35.  
  36.         # context: [batch_size, n_heads, len_q, d_v], attn: [batch_size, n_heads, len_q, len_k]
  37.         context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)
  38.  
  39.  
  40.         context = context.transpose(1, 2).reshape(batch_size, -1,n_heads * d_v)
  41.         # context: [batch_size, len_q, n_heads * d_v]
  42.  
  43.  
  44.         output = self.fc(context)  # [batch_size, len_q, d_model]
  45.         return nn.LayerNorm(d_model).cuda()(output + residual), attn

所谓的W_Q,K,V矩阵就是Linear层，如init中所示：这里的d_k 和 n_heads都是之前设置好的参数，d_k是64，而n_heads是8。

self.W_Q = nn.Linear(d_model, d_k * n_heads, bias=False)
self.W_K = nn.Linear(d_model, d_k * n_heads, bias=False)
self.W_V = nn.Linear(d_model, d_v * n_heads, bias=False)

在forwar中，第一步就是获取残差residual 以及batch_size

residual, batch_size = input_Q, input_Q.size(0)

第二步就是获取乘出来的Q，

Q = self.W_Q(input_Q).view(batch_size, -1, n_heads, d_k).transpose(1,2),
Q的维度是（2，5，8，64）经过transpose之后（2，8，5，64）.
W_Q(input_Q)这是第一步，第一步的input_Q的维度是（2，5，512），经过W_Q之后的维度还是
（2，5，512），虽然维度是没有变化，但是所要学习的W_Q也就是这一个Linear层的参数。
同理K和V也是如此：
K = self.W_K(input_K).view(batch_size, -1, n_heads, d_k).transpose(1,2)
V = self.W_V(input_V).view(batch_size, -1, n_heads, d_v).transpose(1,2)
总结一下维度的信息，Q，K，V都是（2，8，5，64）

第三步是将之前乘出来的attention_mask进行维度拓展，其实就是复制了n_heads的份数。

attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)进行操作之前，attn_mask的维度是（2，5，5），在进行操作后的维度就是（2，8，5，5），也就是 attn_mask : [batch_size, n_heads, seq_len, seq_len]。
总结一下维度的信息，attn_mask的维度是（2，8，5，5）

第四步是进行点击运算来得到context和attn，所需要的输入是之前利用Linear层和input_q所乘出来的Q,K,V,以及attn_mask。

context, attn = ScaledDotProductAttention()(Q, K, V, attn_mask)
        # Q，K，V都是（2，8，5，64）。attn_mask的维度是（2，8，5，5）#

具体的ScaledDotProductAttention函数如下所示：

  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.         '''
  12.         scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)  # scores : [batch_size, n_heads, len_q, len_k]
  13.  
  14.         scores.masked_fill_(attn_mask, -1e9)  # Fills elements of self tensor with value where mask is True.
  15.  
  16.         attn = nn.Softmax(dim=-1)(scores)
  17.         context = torch.matmul(attn, V)  # [batch_size, n_heads, len_q, d_v]
  18.  
  19.         return context, attn
第一步，scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)，因为Q和K的维度都是（2，8，5，64）将K的维度变换后是（2，8，64，5）所以乘出来的维度是（2，8，5，5）。总结，在这里scores的维度是（2，8，5，5）
第二步，scores.masked_fill_(attn_mask, -1e9)，将attn_mask的为true的部分变成负数，这样经过softmax的时候，这个部分就会变成接近于0的数，所以不会产生影响。
第三步，attn = nn.Softmax(dim=-1)(scores)，会将其中的每行进行softmax也就是每一行相加是等于1的。如下图所示

第四步，context = torch.matmul(attn, V)，return context, attn
attn的维度是（2，8，5，5）而V的维度是（2，8，5，64）所以context的维度是（2，8，5，64）.
总结一下维度，在第四步输入的attn是（2，8，5，5）而V是（2，8，5，64）所以他俩相乘的维度是（2，8，5，64），最终返回的context的维度就是（2，8，5，64）.

第五步，将context的维度从（2，8，5，64）->（2，5，8，64）->（2，5，512）

context = context.transpose(1, 2).reshape(batch_size, -1,n_heads * d_v)

第六步，经过全连接层,然后return，这个全连接层的维度是不变的

output = self.fc(context)
return nn.LayerNorm(d_model).cuda()(output + residual), attn
在这里，最终返回的结果的维度是（2，5，512）attn的维度是（2，8，5，5）

  1. class PoswiseFeedForwardNet(nn.Module):
  2.     def __init__(self):
  3.         super(PoswiseFeedForwardNet, self).__init__()
  4.         self.fc = nn.Sequential(
  5.             nn.Linear(d_model, d_ff, bias=False),
  6.             nn.ReLU(),
  7.             nn.Linear(d_ff, d_model, bias=False)
  8.         )
  9.     def forward(self, inputs):
  10.         '''
  11.         inputs: [batch_size, seq_len, d_model]
  12.         '''
  13.         residual = inputs
  14.         output = self.fc(inputs)
  15.         return nn.LayerNorm(d_model).cuda()(output + residual) # [batch_size, seq_len, d_model]

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

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

  

闽ICP备14008679号