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

攻克 Transformer 之代码精讲+实战，以及《变形金刚》结构_变形金刚transformer 编码

作者：花生_TL007 | 2024-04-06 22:21:40

赞

踩

变形金刚transformer 编码

Transformer模型完全基于注意力机制，没有任何卷积层或循环神经网络层。尽管transformer最初是应⽤于在⽂本数据上的序列到序列学习，但现在已经推广到各种现代的深度学习中，例如语⾔、视觉、语音和强化学习领域。

本文章进行实战：利用Transformer把英语翻译成法语（Pytorch框架）

Transformer系列往期博客链接直达：攻克 Transformer & 注意力机制的查询、键和值 & 有无参数的Nadaraya-Watson核回归
攻克 Transformer && 评分函数（加性注意力、缩放点积注意力）

目录

（1）多头注意力

（2）基于位置的前馈网络

（3）残差网络后进行层规范化

（4）transformer编码器块

（5）transformer编码器

（6）transformer解码器块

（7）transformer解码器

（8）训练

（9）测试

（10）可视化权重

（11）总结

（12）完整代码

Transformer作为编码器－解码器架构的⼀个实例，其整体架构图在图1 中展示。

正如所见到的，transformer是由编码器和解码器组成的；transformer的编码器和解码器是基于⾃注意力的模块叠加而成的；源序列和目标序列的嵌⼊层先加上位置编码（positional encoding），再分别输⼊到编码器和解码器中。

图1 Transformer架构

=============Transformer 编码器=============

从宏观角度来看，transformer的编码器是由多个相同的层叠加而成的，每个层都有两个子层。第⼀个⼦层是多头⾃注意力汇聚；第⼆个子层是基于位置的前馈网络。编码器由n个编码块组成，前n-1个编码块的输出作为编码块的输入，具体来说，在计算编码器的⾃注意力时，查询、键和值都来⾃前⼀个编码器层的输出。每个子层都采用了残差连接。在残差连接的加法计算之后，紧接着应用层规范化。因此，输入序列对应的每个位置，transformer 编码器都将输出⼀个 d 维表示向量。

=============Transformer 解码器=============

Transformer解码器也是由多个相同的层叠加而成的，并且层中使用了残差连接和层规范化。除了编码器中描述的两个子层之外，解码器还在这两个子层之间插⼊了第三个子层，称为编码器—解码器注意力层。在编码器－解码器注意力中，查询来自前⼀个解码器层的输出，而键和值来自整个编码器的输出。在解码器自注意力中，查询、键和值都来自上⼀个解码器层的输出。但是，解码器中的每个位置只能考虑该位置之前的所有位置。这种掩蔽注意力保留了自回归（auto-regressive）属性，确保预测仅依赖于已生成的输出词元。

补充：自回归模型_百度百科

自回归模型（英语：Autoregressive model，简称AR模型），是统计上一种处理时间序列的方法，用同一变数例如x的之前各期，亦即x1至xt-1来预测本期xt的表现，并假设它们为一线性关系。因为这是从回归分析中的线性回归发展而来，只是不用x预测y，而是用x预测 x（自己）；所以叫做自回归。

Transformer“编码器-解码器”网络模型结构：
EncoderDecoder(

  编码器
  (encoder): TransformerEncoder(

    嵌入层
    (embedding): Embedding(184, 32)

    位置编码
    (pos_encoding): PositionalEncoding(

    舍弃
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (blks): Sequential(

     第一个编码器块
      (block0): EncoderBlock(

          多头注意力
        (attention): MultiHeadAttention(

           缩放点击注意力
          (attention): DotProductAttention(

            舍弃
            (dropout): Dropout(p=0.1, inplace=False)
          )

          全连接层（线性变换）
          (W_q): Linear(in_features=32, out_features=32, bias=False)
          (W_k): Linear(in_features=32, out_features=32, bias=False)
          (W_v): Linear(in_features=32, out_features=32, bias=False)
          (W_o): Linear(in_features=32, out_features=32, bias=False)
        )

        第一个 加&规范化
        (addnorm1): AddNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (ln): LayerNorm((32,), eps=1e-05, elementwise_affine=True)
        )

        基于位置的前馈神经网络
        (ffn): PositionWiseFFN(
          (dense1): Linear(in_features=32, out_features=64, bias=True)
          (relu): ReLU()  激活函数
          (dense2): Linear(in_features=64, out_features=32, bias=True)
        )

        第二个 加&规范化
        (addnorm2): AddNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (ln): LayerNorm((32,), eps=1e-05, elementwise_affine=True)
        )
      )

     第二个编码器块
      (block1): EncoderBlock(
        (attention): MultiHeadAttention(
          (attention): DotProductAttention(
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (W_q): Linear(in_features=32, out_features=32, bias=False)
          (W_k): Linear(in_features=32, out_features=32, bias=False)
          (W_v): Linear(in_features=32, out_features=32, bias=False)
          (W_o): Linear(in_features=32, out_features=32, bias=False)
        )
        (addnorm1): AddNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (ln): LayerNorm((32,), eps=1e-05, elementwise_affine=True)
        )
        (ffn): PositionWiseFFN(
          (dense1): Linear(in_features=32, out_features=64, bias=True)
          (relu): ReLU()
          (dense2): Linear(in_features=64, out_features=32, bias=True)
        )
        (addnorm2): AddNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (ln): LayerNorm((32,), eps=1e-05, elementwise_affine=True)
        ))))

解码器同编码器类似

（1）多头注意力

在实践中，当给定相同的查询、键和值的集合时，我们希望模型可以基于相同的注意⼒机制学习到不同的⾏为，然后将不同的⾏为作为知识组合起来，捕获序列内各种范围的依赖关系（例如，短距离依赖和长距离依赖关系）。因此，允许注意力机制组合使用查询、键和值的不同子空间表示可能是有益的。

为此，与其只使⽤单独⼀个注意力汇聚，我们可以⽤独⽴学习得到的h组不同的线性投影（linear projections） 来变换查询、键和值。然后，这h组变换后的查询、键和值将并⾏地送到注意⼒汇聚中。最后，将这h个注意力汇聚的输出拼接在⼀起，并且通过另⼀个可以学习的线性投影进⾏变换，以产⽣最终输出，这种设计被称为多头注意力（multihead attention）。对于h个注意力汇聚输出，每⼀个注意⼒汇聚都被称作⼀个头。

图2 展示了使用全连接层来实现可学习的线性变换的多头注意力。

 图2 多头注意力：多个头连结然后线性变换 

多头注意力代码：（此处选择缩放点积注意力作为注意力汇聚）

  1. class MultiHeadAttention(nn.Module):
  2.     """多头注意力"""
  3.     # 100, 100, 100, 100, 5, 0.5
  4.     def __init__(self, key_size, query_size, value_size, num_hiddens,
  5.                  num_heads, dropout, bias=False, **kwargs):
  6.         super(MultiHeadAttention, self).__init__(**kwargs)
  7.         self.num_heads = num_heads
  8.         self.DP_Attention = d2l.DotProductAttention(dropout)  # 缩放点积注意力，舍弃50%的神经元参数
  9.  
  10.         # 输入样本的大小、输出样本的大小、偏置设置为False
  11.         self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)  # [100, 100]
  12.         self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)  # [100, 100]
  13.         self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)  # [100, 100]
  14.         self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)  # [100, 100]
  15.  
  16.     # [2, 4, 100], [2, 6, 100], [2, 6, 100], torch.tensor([3, 2])
  17.     def forward(self, queries, keys, values, valid_lens):
  18.         # queries，keys，values的形状:(batch_size，查询或者“键－值”对的个数，num_hiddens)
  19.         # valid_lens　的形状:(batch_size，)或(batch_size，查询的个数)
  20.         # 经过变换后，输出的 queries，keys，values　的形状:
  21.         # (batch_size*num_heads，查询或者“键－值”对的个数，num_hiddens/num_heads)
  22.         queries = transpose_qkv(self.W_q(queries), self.num_heads)
  23.         keys = transpose_qkv(self.W_k(keys), self.num_heads)
  24.         values = transpose_qkv(self.W_v(values), self.num_heads)
  25.         # print(queries)
  26.  
  27.         if valid_lens is not None:
  28.             # 在轴0，将第一项（标量或者矢量）复制num_heads次，
  29.             # 然后如此复制第二项，然后诸如此类。
  30.             valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)
  31.             # print(valid_lens)  # tensor([3, 3, 3, 3, 3, 2, 2, 2, 2, 2])
  32.             print("valid_lens:", valid_lens.size())
  33.  
  34.         # output的形状:(batch_size*num_heads，查询的个数，num_hiddens/num_heads)
  35.         # torch.Size([10, 4, 20])、torch.Size([10, 6, 20])、torch.Size([10, 6, 20])、torch.Size([10])
  36.         output = self.DP_Attention(queries, keys, values, valid_lens)
  37.  
  38.         # output_concat的形状:(batch_size，查询的个数，num_hiddens)
  39.         output_concat = transpose_output(output, self.num_heads)
  40.         return self.W_o(output_concat)
  41.

为了能够使多个头并行计算，上面的MultiHeadAttention类将使用下面定义的两个转置函数。具体来说， transpose_output函数反转了transpose_qkv函数的操作。

  1. # [2, 4, 100]/[2, 6, 100], 5
  2. def transpose_qkv(X, num_heads):
  3.     """为了多注意力头的并行计算而变换形状"""
  4.     # 输入X的形状:(batch_size，查询或者“键－值”对的个数，num_hiddens)
  5.     # 输出X的形状:(batch_size，查询或者“键－值”对的个数，num_heads，num_hiddens/num_heads)
  6.     # reshape(-1)：首先把张量中的所有元素平铺，然后在变形成指定的形状
  7.     X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)  # 2*4*100/2*4*5 = 20, -1就代表20
  8.     # print(X.size())
  9.  
  10.     # 输出X的形状:(batch_size，num_heads，查询或者“键－值”对的个数, num_hiddens/num_heads)
  11.     X = X.permute(0, 2, 1, 3)  # 更改矩阵形状 torch.Size([2, 5, 4, 20])
  12.     # print(X.size())
  13.  
  14.     # 最终输出的形状:(batch_size*num_heads,查询或者“键－值”对的个数, num_hiddens/num_heads)
  15.     output = X.reshape(-1, X.shape[2], X.shape[3])  # 2*5*4*20/4*20 = 10, -1就代表10
  16.     print("transpose_qkv:", output.size())
  17.  
  18.     return output
  19.  
  20.  
  21. # [10, 4, 20], 5
  22. def transpose_output(X, num_heads):
  23.     """逆转transpose_qkv函数的操作"""
  24.     # print(X.size())
  25.     X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])  # [2, 5, 4, 20]
  26.     X = X.permute(0, 2, 1, 3)  # [2, 4, 5, 20]
  27.     output = X.reshape(X.shape[0], X.shape[1], -1)  # [2, 4, 100]
  28.     print("transpose_output:", output.size())
  29.  
  30.     return output

 最后，使用键和值相同的例子，测试我们编写的MultiHeadAttention类。

  1. num_hiddens, num_heads = 100, 5
  2. attention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,
  3.                                num_hiddens, num_heads, 0.5)
  4. attention.eval()
  5.  
  6. batch_size, num_queries = 2, 4
  7. num_kvpairs, valid_lens = 6, torch.tensor([3, 2])
  8. X = torch.ones((batch_size, num_queries, num_hiddens))  # [2, 4, 100]
  9. Y = torch.ones((batch_size, num_kvpairs, num_hiddens))  # [2, 6, 100]
  10. print("result:", attention(X, Y, Y, valid_lens).shape)  # torch.Size([2, 4, 100])

 输出：

transpose_qkv: torch.Size([10, 4, 20])
transpose_qkv: torch.Size([10, 6, 20])
transpose_qkv: torch.Size([10, 6, 20])
valid_lens: torch.Size([10])
transpose_output: torch.Size([2, 4, 100])
result: torch.Size([2, 4, 100])

（2）基于位置的前馈网络

基于位置的前馈⽹络对序列中的所有位置的表⽰进⾏变换时使用的是同⼀个多层感知机（MLP），这就是称前馈⽹络是基于位置的原因。

下⾯的例⼦显示，改变张量的最⾥层维度的尺⼨，会改变成基于位置的前馈⽹络的输出尺⼨。因为⽤同⼀个多层感知机对所有位置上的输⼊进⾏变换，所以当所有这些位置的输⼊相同时，它们的输出也是相同的。

  1. class PositionWiseFFN(nn.Module):
  2.     """基于位置的前馈网络"""
  3.     def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs,
  4.                  **kwargs):
  5.         super(PositionWiseFFN, self).__init__(**kwargs)
  6.         self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)
  7.         self.relu = nn.ReLU()
  8.         self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)
  9.  
  10.     def forward(self, X):
  11.         return self.dense2(self.relu(self.dense1(X)))
  12.  
  13.  
  14. # demo
  15. # [2, 3, 4] * [4, 4] * [4, 8] = [2, 3, 8]
  16. ffn = PositionWiseFFN(4, 4, 8)
  17. ffn.eval()
  18. print("基于位置的前馈网络:")
  19. print(ffn(torch.ones((2, 3, 4)))[0])

输出：

基于位置的前馈网络:
tensor([[-0.1039,  0.6010, -0.7257,  0.0406, -0.2380, -0.5354, -1.0672,  0.3957],
            [-0.1039,  0.6010, -0.7257,  0.0406, -0.2380, -0.5354, -1.0672,  0.3957],
            [-0.1039,  0.6010, -0.7257,  0.0406, -0.2380, -0.5354, -1.0672,  0.3957]],
            grad_fn=<SelectBackward0>) 

（3）残差网络后进行层规范化

下面代码由残差连接和紧随其后的层规范化组成，两者都是构建有效的深度架构的关键。

  1. class AddNorm(nn.Module):
  2.     """残差连接后进行层规范化"""
  3.     def __init__(self, normalized_shape, dropout, **kwargs):
  4.         super(AddNorm, self).__init__(**kwargs)
  5.         self.dropout = nn.Dropout(dropout)
  6.         self.ln = nn.LayerNorm(normalized_shape)
  7.  
  8.     def forward(self, X, Y):
  9.         return self.ln(self.dropout(Y) + X)
  10.  
  11.  
  12. # demo
  13. add_norm = AddNorm([3, 4], 0.5)
  14. add_norm.eval()
  15. print("残差连接后进行层规范化:")
  16. print(add_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape)

输出：

残差连接后进行层规范化:
torch.Size([2, 3, 4]) 

补充：

层规范化和批量规范化的⽬标相同，但层规范化是基于特征维度进⾏规范化。尽管批量规范化在计算机视觉中 被广泛应用，但在自然语言处理任务中（输入通常是变长序列）批量规范化通常不如层规范化的效果好。

以下代码对⽐不同维度的层规范化和批量规范化的效果。

  1. ln = nn.LayerNorm(2)  # 层规范化
  2. bn = nn.BatchNorm1d(2)  # 批标准化
  3. X = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)
  4. # 在训练模式下计算 X 的均值和方差
  5. print('layer norm:', ln(X), '\nbatch norm:', bn(X))

 （4）transformer编码器块

有了组成transformer编码器的基础组件，现在可以先实现编码器中的一个层。下⾯的EncoderBlock类包含两个⼦层：多头⾃注意力和基于位置的前馈⽹络，这两个子层都使用了残差连接和紧随的层规范化。

  1. class EncoderBlock(nn.Module):
  2.     """transformer编码器块"""
  3.     def __init__(self, key_size, query_size, value_size, num_hiddens,
  4.                  norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  5.                  dropout, use_bias=False, **kwargs):
  6.         super(EncoderBlock, self).__init__(**kwargs)
  7.         # 多头注意力
  8.         self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size,
  9.                                                 num_hiddens, num_heads, dropout, use_bias)
  10.         # 加 & 规范化（包含残差连接）
  11.         self.addnorm1 = AddNorm(norm_shape, dropout)
  12.         # 逐位前馈网络
  13.         self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)
  14.         # 加 & 规范化（包含残差连接）
  15.         self.addnorm2 = AddNorm(norm_shape, dropout)
  16.  
  17.     # 多头注意力>>>加&规范化>>>逐位前馈网络>>>加&规范化
  18.     def forward(self, X, valid_lens):
  19.         Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))
  20.         return self.addnorm2(Y, self.ffn(Y))
  21.  
  22.  
  23. # demo
  24. X = torch.ones((2, 100, 24))
  25. valid_lens = torch.tensor([3, 2])
  26. encoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)
  27. encoder_blk.eval()
  28. print("transformer编码器块:")
  29. print(encoder_blk(X, valid_lens).shape)

输出：（输入的张量尺寸和输出的张量尺寸大小相同）

transformer编码器块:
torch.Size([2, 100, 24]) 

（5）transformer编码器

在实现下⾯的transformer编码器的代码中，我们堆叠了num_layers个EncoderBlock类的实例。由于我们使⽤的是值范围在−1和1之间的固定位置编码，因此通过学习得到的输⼊的嵌⼊表⽰的值需要先乘以嵌⼊维度的平⽅根进⾏重新缩放，然后再与位置编码相加。

下面的代码指定了超参数来创建⼀个两层的transformer编码器。

  1. class TransformerEncoder(d2l.Encoder):
  2.     """transformer编码器"""
  3.     def __init__(self, vocab_size, key_size, query_size, value_size,
  4.                  num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
  5.                  num_heads, num_layers, dropout, use_bias=False, **kwargs):
  6.         super(TransformerEncoder, self).__init__(**kwargs)
  7.         self.num_hiddens = num_hiddens
  8.         # 嵌入层
  9.         self.embedding = nn.Embedding(vocab_size, num_hiddens)
  10.         # 位置编码
  11.         self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
  12.         # 添加模块（num_layers个transformer编码器块）
  13.         self.blks = nn.Sequential()
  14.         for i in range(num_layers):
  15.             self.blks.add_module("block"+str(i),
  16.                 EncoderBlock(key_size, query_size, value_size, num_hiddens,
  17.                              norm_shape, ffn_num_input, ffn_num_hiddens,
  18.                              num_heads, dropout, use_bias))
  19.  
  20.     def forward(self, X, valid_lens, *args):
  21.         # 因为位置编码值在-1和1之间，因此嵌入值乘以嵌入维度的平方根进行缩放，然后再与位置编码相加。
  22.         X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
  23.         self.attention_weights = [None] * len(self.blks)
  24.         for i, blk in enumerate(self.blks):
  25.             X = blk(X, valid_lens)
  26.             self.attention_weights[i] = blk.attention.attention.attention_weights
  27.         return X
  28.  
  29.  
  30. # demo
  31. encoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)
  32. encoder.eval()
  33. print("transformer编码器:")
  34. print(encoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape)

输出：

transformer编码器:
torch.Size([2, 100, 24]) 

（6）transformer解码器块

transformer解码器也是由多个相同的层组成。在DecoderBlock类中实现的每个层包含了三个⼦层：解码器自注意力、“编码器-解码器”注意力和基于位置的前馈网络。这些⼦层也都被残差连接和紧随的层规范化围绕。

关于序列到序列模型（sequence-to-sequence model），在训练阶段，其输出序列的所有位置（时间步）的词元都是已知的；然而，在预测阶段，其输出序列的词元是逐个生成的。因此，在任何解码器时间步中，只有⽣成的词元才能⽤于解码器的自注意力计算中。

为了在解码器中保留自回归的属性，其掩蔽自注意力设定了参数dec_valid_lens，以便任何查询都只会与解码器中所有已经生成词元的位置（即直到该查询位置为止）进⾏注意力计算。

  1. class DecoderBlock(nn.Module):
  2.     """解码器中第i个块"""
  3.     def __init__(self, key_size, query_size, value_size, num_hiddens,
  4.                  norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  5.                  dropout, i, **kwargs):
  6.         super(DecoderBlock, self).__init__(**kwargs)
  7.         self.i = i
  8.         # 多头注意力
  9.         self.attention1 = d2l.MultiHeadAttention(
  10.             key_size, query_size, value_size, num_hiddens, num_heads, dropout)
  11.         # 加 & 规范化
  12.         self.addnorm1 = AddNorm(norm_shape, dropout)
  13.         # 多头注意力
  14.         self.attention2 = d2l.MultiHeadAttention(
  15.             key_size, query_size, value_size, num_hiddens, num_heads, dropout)
  16.         self.addnorm2 = AddNorm(norm_shape, dropout)
  17.         # 加 & 规范化
  18.         self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens,
  19.                                    num_hiddens)
  20.         # 加 & 规范化
  21.         self.addnorm3 = AddNorm(norm_shape, dropout)
  22.  
  23.     def forward(self, X, state):
  24.         enc_outputs, enc_valid_lens = state[0], state[1]
  25.         # 训练阶段，输出序列的所有词元都在同一时间处理，
  26.         # 因此state[2][self.i]初始化为None。
  27.         # 预测阶段，输出序列是通过词元一个接着一个解码的，
  28.         # 因此state[2][self.i]包含着直到当前时间步第i个块解码的输出表示
  29.         if state[2][self.i] is None:
  30.             key_values = X
  31.         else:
  32.             key_values = torch.cat((state[2][self.i], X), axis=1)
  33.         state[2][self.i] = key_values
  34.         if self.training:
  35.             batch_size, num_steps, _ = X.shape
  36.             # dec_valid_lens的开头:(batch_size,num_steps),
  37.             # 其中每一行是[1,2,...,num_steps]
  38.             dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)
  39.         else:
  40.             dec_valid_lens = None
  41.  
  42.         # 多头注意力>>>加&规范化>>>多头注意力>>>加&规范化>>>逐位前馈网络>>>加&规范化
  43.         X2 = self.attention1(X, key_values, key_values, dec_valid_lens)
  44.         Y = self.addnorm1(X, X2)
  45.         # 编码器－解码器注意力。
  46.         # enc_outputs的开头:(batch_size,num_steps,num_hiddens)
  47.         Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)
  48.         Z = self.addnorm2(Y, Y2)
  49.         return self.addnorm3(Z, self.ffn(Z)), state
  50.  
  51.  
  52. # demo
  53. decoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)
  54. decoder_blk.eval()
  55. X = torch.ones((2, 100, 24))
  56. state = [encoder_blk(X, valid_lens), valid_lens, [None]]
  57. print("解码器中第i个块:")
  58. print(decoder_blk(X, state)[0].shape)

输出：

解码器中第i个块:
torch.Size([2, 100, 24]) 

（7）transformer解码器

 现在我们构建了由num_layers个DecoderBlock实例组成的完整的transformer解码器。最后，通过⼀个全连接层计算所有vocab_size个可能的输出词元的预测值。解码器的⾃注意力权重和编码器解码器注意力权重都被存储下来，⽅便日后可视化的需要。

  1. class TransformerDecoder(d2l.AttentionDecoder):
  2.     """Transformer解码器"""
  3.     def __init__(self, vocab_size, key_size, query_size, value_size,
  4.                  num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
  5.                  num_heads, num_layers, dropout, **kwargs):
  6.         super(TransformerDecoder, self).__init__(**kwargs)
  7.         self.num_hiddens = num_hiddens
  8.         self.num_layers = num_layers
  9.         # 嵌入层
  10.         self.embedding = nn.Embedding(vocab_size, num_hiddens)
  11.         # 位置编码
  12.         self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
  13.         # 添加模块（num_layers个解码器块）
  14.         self.blks = nn.Sequential()
  15.         for i in range(num_layers):
  16.             self.blks.add_module("block"+str(i),
  17.                 DecoderBlock(key_size, query_size, value_size, num_hiddens,
  18.                              norm_shape, ffn_num_input, ffn_num_hiddens,
  19.                              num_heads, dropout, i))
  20.         # 全连接层
  21.         self.dense = nn.Linear(num_hiddens, vocab_size)
  22.  
  23.     def init_state(self, enc_outputs, enc_valid_lens, *args):
  24.         return [enc_outputs, enc_valid_lens, [None] * self.num_layers]
  25.  
  26.     def forward(self, X, state):
  27.         # 位置编码+嵌入层
  28.         X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
  29.         # 定义二维列表，存放 解码器自注意力权重 和 “编码器=解码器”自注意力权重
  30.         self._attention_weights = [[None] * len(self.blks) for _ in range(2)]
  31.         for i, blk in enumerate(self.blks):
  32.             X, state = blk(X, state)
  33.             # 解码器自注意力权重
  34.             self._attention_weights[0][i] = blk.attention1.attention.attention_weights
  35.             # “编码器－解码器”自注意力权重
  36.             self._attention_weights[1][i] = blk.attention2.attention.attention_weights
  37.         return self.dense(X), state  # 最后把参数传入到全连接层之中
  38.  
  39.     def attention_weights(self):
  40.         return self._attention_weights

（8）训练

依照transformer架构来实例化编码器－解码器模型。在这⾥，指定transformer的编码器和解码器都是2层， 都使⽤4头注意⼒。

为了进⾏序列到序列的学习，我们在“英语－法语”机器翻译数据集上训练transformer模型。

  1. # # 训练
  2. # 隐藏层层数，编码器/解码器块数量，舍弃比率，批量大小，num_steps
  3. num_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10
  4. # 学习率，迭代次数，设备选取
  5. lr, num_epochs, device = 0.005, 200, d2l.try_gpu()
  6. # 前馈网络输入层，前馈网络隐藏层，注意力头的数量
  7. ffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4
  8. # 查询，键，值
  9. query_size, key_size, value_size = 32, 32, 32
  10. # AddNorm（规范化的维度）
  11. norm_shape = [32]
  12.  
  13. # 加载文字数据集（英语翻译成法语）
  14. # train_iter:数据集信息
  15. # src_vocab:源（英语）词汇表
  16. # tgt_vocab:法语词汇表
  17. train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
  18.  
  19. encoder = TransformerEncoder(
  20.     len(src_vocab), key_size, query_size, value_size, num_hiddens,
  21.     norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  22.     num_layers, dropout)
  23. # print("编码器返回的结果（Transformer编码器的结构）：")
  24. # print(encoder)
  25.  
  26. decoder = TransformerDecoder(
  27.     len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape,
  28.     ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)
  29. # print("解码器返回的结果（Transformer解码器的结构）：")
  30. # print(decoder)
  31.  
  32. # Transformer“编码器-解码器”网络模型
  33. net = d2l.EncoderDecoder(encoder, decoder)
  34. print("Transformer“编码器-解码器”网络模型结构：")
  35. print(net)
  36.  
  37. # 训练一个序列到序列的模型
  38. # 网络模型，数据集信息，学习率，迭代次数，法语词汇表（标志输出），设备选取
  39. d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)

图3 Epoch-Loss曲线图 

数据集截图：

（9）测试

训练结束后，使⽤transformer模型将⼀些英语句⼦翻译成法语，并且计算它们的BLEU分数。

  • BLEU的全名为：bilingual evaluation understudy，即：双语互译质量评估辅助工具。它是用来评估机器翻译质量的工具。
  • BLEU的设计思想：机器翻译结果越接近专业人工翻译的结果，则越好。BLEU算法实际上就是在判断两个句子的相似程度。
  • 想知道一个句子翻译前后的表示是否意思一致，直接的办法是拿这个句子的标准人工翻译与机器翻译的结果作比较，如果它们是很相似的，说明我的翻译很成功。
  • 因此，BLUE将机器翻译的结果与其相对应的几个参考翻译作比较，算出一个综合分数。这个分数越高说明机器翻译得越好。注意BLEU算法是句子之间的比较，不是词组，也不是段落。
  1. # # 测试
  2. engs = ['go .', "i lost .", 'he\'s calm .', 'i\'m home .']
  3. fras = ['va !', 'j\'ai perdu .', 'il est calme .', 'je suis chez moi .']
  4. # 多维列表
  5. dec_attention_weight_seq = []
  6. for eng, fra in zip(engs, fras):
  7.     # 网络模型、单个英语词汇、英语词汇集、法语词汇集、num_steps，设备选取
  8.     translation, dec_attention_weight_seq = d2l.predict_seq2seq(
  9.         net, eng, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=True)
  10.     print(f'{eng} => {translation}, ',
  11.           f'bleu {d2l.bleu(translation, fra, k=2):.3f}')  # 评分函数（翻译结果同数据集相比较）
  12.  
  13. enc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))
  14. print(enc_attention_weights.shape)

输出：

go .                => va !,                         bleu 1.000
i lost .            => je vous en prie .,      bleu 1.000
he's calm .    => il court .,                   bleu 0.000
i'm home .     => je suis chez moi .,    bleu 1.000
torch.Size([2, 4, 10, 10]) 

在编码器的⾃注意⼒中，查询和键都来⾃相同的输⼊序列。因为填充词元是不携带信息的，因此通过指定输⼊序列的有效⻓度可以避免查询与使⽤填充词元的位置计算注意力。接下来，将逐⾏呈现两层多头注意力的权重。每个注意⼒头都根据查询、键和值的不同的表⽰子空间来表⽰不同的注意⼒。 

  1. d2l.show_heatmaps(
  2.     enc_attention_weights.cpu(), xlabel='Key positions',
  3.     ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],
  4.     figsize=(7, 3.5))
  5. plt.show()

 图4 最后⼀个英语到法语的句子翻译的可视化transformer的注意力权重

（10）可视化权重

为了可视化解码器的⾃注意⼒权重和“编码器－解码器”的注意⼒权重，我们需要完成更多的数据操作⼯作。 例如，我们⽤零填充被掩蔽住的注意⼒权重。值得注意的是，解码器的⾃注意⼒权重和“编码器－解码器” 的注意⼒权重都有相同的查询：即以序列开始词元（beginning-of-sequence,BOS）打头，再与后续输出的词元共同组成序列。

  1. dec_attention_weights_2d = [head[0].tolist()
  2.                             for step in dec_attention_weight_seq
  3.                             for attn in step for blk in attn for head in blk]
  4. dec_attention_weights_filled = torch.tensor(
  5.     pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)
  6. dec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))
  7. dec_self_attention_weights, dec_inter_attention_weights = \
  8.     dec_attention_weights.permute(1, 2, 3, 0, 4)
  9. print(dec_self_attention_weights.shape, dec_inter_attention_weights.shape)
  10.  
  11. # 与编码器的自注意力的情况类似，通过指定输入序列的有效长度，
  12. # [输出序列的查询不会与输入序列中填充位置的词元进行注意力计算]。
  13. # Plusonetoincludethebeginning-of-sequencetoken
  14. d2l.show_heatmaps(
  15.     dec_self_attention_weights[:, :, :, :len(translation.split()) + 1],
  16.     xlabel='Key positions', ylabel='Query positions',
  17.     titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))
  18.  
  19. d2l.show_heatmaps(
  20.     dec_inter_attention_weights, xlabel='Key positions',
  21.     ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],
  22.     figsize=(7, 3.5))

 1. 由于解码器⾃注意⼒的⾃回归属性，查询不会对当前位置之后的“键－值”对进⾏注意⼒计算。

 由上图可以观察到：查询位置之后(主对角线上方)的注意力权重为零，即没有进行注意力计算！

2. 与编码器的⾃注意⼒的情况类似，通过指定输⼊序列的有效⻓度，输出序列的查询不会与输⼊序列中填充位置的词元进⾏注意⼒计算。

由上图可以观察到：指定序列长度后，大于序列长度的位置的注意力权重为零，没有进行注意力计算！

 （11）总结

  • transformer是编码器－解码器架构的⼀个实践，尽管在实际情况中编码器或解码器可以单独使⽤。
  • 在transformer中，多头⾃注意力⽤于表⽰输⼊序列和输出序列，不过解码器必须通过掩蔽机制来保留自回归属性。
  • transformer中的残差连接和层规范化是训练⾮常深度模型的重要⼯具。
  • transformer模型中基于位置的前馈⽹络使⽤同⼀个多层感知机，作用是对所有序列位置的表示进行转换。

 （12）完整代码

  1. import math
  2. import pandas as pd
  3. import torch
  4. from matplotlib import pyplot as plt
  5. from torch import nn
  6. from d2l import torch as d2l
  7.  
  8.  
  9. class PositionWiseFFN(nn.Module):
  10.     """基于位置的前馈网络"""
  11.     def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs,
  12.                  **kwargs):
  13.         super(PositionWiseFFN, self).__init__(**kwargs)
  14.         self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)
  15.         self.relu = nn.ReLU()
  16.         self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)
  17.  
  18.     def forward(self, X):
  19.         return self.dense2(self.relu(self.dense1(X)))
  20.  
  21.  
  22. # demo
  23. # [2, 3, 4] * [4, 4] * [4, 8] = [2, 3, 8]
  24. ffn = PositionWiseFFN(4, 4, 8)
  25. ffn.eval()
  26. print("基于位置的前馈网络:")
  27. print(ffn(torch.ones((2, 3, 4)))[0])
  28.  
  29. ln = nn.LayerNorm(2)  # 层规范化
  30. bn = nn.BatchNorm1d(2)  # 批标准化
  31. X = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)
  32. # 在训练模式下计算 X 的均值和方差
  33. print('layer norm:', ln(X), '\nbatch norm:', bn(X))
  34.  
  35.  
  36. class AddNorm(nn.Module):
  37.     """残差连接后进行层规范化"""
  38.     def __init__(self, normalized_shape, dropout, **kwargs):
  39.         super(AddNorm, self).__init__(**kwargs)
  40.         self.dropout = nn.Dropout(dropout)
  41.         self.ln = nn.LayerNorm(normalized_shape)
  42.  
  43.     def forward(self, X, Y):
  44.         return self.ln(self.dropout(Y) + X)
  45.  
  46.  
  47. # demo
  48. add_norm = AddNorm([3, 4], 0.5)
  49. add_norm.eval()
  50. print("残差连接后进行层规范化:")
  51. print(add_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape)
  52.  
  53.  
  54. class EncoderBlock(nn.Module):
  55.     """transformer编码器块"""
  56.     def __init__(self, key_size, query_size, value_size, num_hiddens,
  57.                  norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  58.                  dropout, use_bias=False, **kwargs):
  59.         super(EncoderBlock, self).__init__(**kwargs)
  60.         # 多头注意力
  61.         self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size,
  62.                                                 num_hiddens, num_heads, dropout, use_bias)
  63.         # 加 & 规范化（包含残差连接）
  64.         self.addnorm1 = AddNorm(norm_shape, dropout)
  65.         # 逐位前馈网络
  66.         self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)
  67.         # 加 & 规范化（包含残差连接）
  68.         self.addnorm2 = AddNorm(norm_shape, dropout)
  69.  
  70.     # 多头注意力>>>加&规范化>>>逐位前馈网络>>>加&规范化
  71.     def forward(self, X, valid_lens):
  72.         Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))
  73.         return self.addnorm2(Y, self.ffn(Y))
  74.  
  75.  
  76. # demo
  77. X = torch.ones((2, 100, 24))
  78. valid_lens = torch.tensor([3, 2])
  79. encoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)
  80. encoder_blk.eval()
  81. print("transformer编码器块:")
  82. print(encoder_blk(X, valid_lens).shape)
  83.  
  84.  
  85. class TransformerEncoder(d2l.Encoder):
  86.     """transformer编码器"""
  87.     def __init__(self, vocab_size, key_size, query_size, value_size,
  88.                  num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
  89.                  num_heads, num_layers, dropout, use_bias=False, **kwargs):
  90.         super(TransformerEncoder, self).__init__(**kwargs)
  91.         self.num_hiddens = num_hiddens
  92.         # 嵌入层
  93.         self.embedding = nn.Embedding(vocab_size, num_hiddens)
  94.         # 位置编码
  95.         self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
  96.         # 添加模块（num_layers个transformer编码器块）
  97.         self.blks = nn.Sequential()
  98.         for i in range(num_layers):
  99.             self.blks.add_module("block"+str(i),
  100.                 EncoderBlock(key_size, query_size, value_size, num_hiddens,
  101.                              norm_shape, ffn_num_input, ffn_num_hiddens,
  102.                              num_heads, dropout, use_bias))
  103.  
  104.     def forward(self, X, valid_lens, *args):
  105.         # 因为位置编码值在-1和1之间，因此嵌入值乘以嵌入维度的平方根进行缩放，然后再与位置编码相加。
  106.         X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
  107.         self.attention_weights = [None] * len(self.blks)
  108.         for i, blk in enumerate(self.blks):
  109.             X = blk(X, valid_lens)
  110.             self.attention_weights[i] = blk.attention.attention.attention_weights
  111.         return X
  112.  
  113.  
  114. # demo
  115. encoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)
  116. encoder.eval()
  117. print("transformer编码器:")
  118. print(encoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape)
  119.  
  120.  
  121. # =================================================================== #
  122. class DecoderBlock(nn.Module):
  123.     """解码器中第i个块"""
  124.     def __init__(self, key_size, query_size, value_size, num_hiddens,
  125.                  norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  126.                  dropout, i, **kwargs):
  127.         super(DecoderBlock, self).__init__(**kwargs)
  128.         self.i = i
  129.         # 多头注意力
  130.         self.attention1 = d2l.MultiHeadAttention(
  131.             key_size, query_size, value_size, num_hiddens, num_heads, dropout)
  132.         # 加 & 规范化
  133.         self.addnorm1 = AddNorm(norm_shape, dropout)
  134.         # 多头注意力
  135.         self.attention2 = d2l.MultiHeadAttention(
  136.             key_size, query_size, value_size, num_hiddens, num_heads, dropout)
  137.         self.addnorm2 = AddNorm(norm_shape, dropout)
  138.         # 加 & 规范化
  139.         self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens,
  140.                                    num_hiddens)
  141.         # 加 & 规范化
  142.         self.addnorm3 = AddNorm(norm_shape, dropout)
  143.  
  144.     def forward(self, X, state):
  145.         enc_outputs, enc_valid_lens = state[0], state[1]
  146.         # 训练阶段，输出序列的所有词元都在同一时间处理，
  147.         # 因此state[2][self.i]初始化为None。
  148.         # 预测阶段，输出序列是通过词元一个接着一个解码的，
  149.         # 因此state[2][self.i]包含着直到当前时间步第i个块解码的输出表示
  150.         if state[2][self.i] is None:
  151.             key_values = X
  152.         else:
  153.             key_values = torch.cat((state[2][self.i], X), axis=1)
  154.         state[2][self.i] = key_values
  155.         if self.training:
  156.             batch_size, num_steps, _ = X.shape
  157.             # dec_valid_lens的开头:(batch_size,num_steps),
  158.             # 其中每一行是[1,2,...,num_steps]
  159.             dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)
  160.         else:
  161.             dec_valid_lens = None
  162.  
  163.         # 多头注意力>>>加&规范化>>>多头注意力>>>加&规范化>>>逐位前馈网络>>>加&规范化
  164.         X2 = self.attention1(X, key_values, key_values, dec_valid_lens)
  165.         Y = self.addnorm1(X, X2)
  166.         # 编码器－解码器注意力。
  167.         # enc_outputs的开头:(batch_size,num_steps,num_hiddens)
  168.         Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)
  169.         Z = self.addnorm2(Y, Y2)
  170.         return self.addnorm3(Z, self.ffn(Z)), state
  171.  
  172.  
  173. # demo
  174. decoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)
  175. decoder_blk.eval()
  176. X = torch.ones((2, 100, 24))
  177. state = [encoder_blk(X, valid_lens), valid_lens, [None]]
  178. print("解码器中第i个块:")
  179. print(decoder_blk(X, state)[0].shape)
  180.  
  181.  
  182. class TransformerDecoder(d2l.AttentionDecoder):
  183.     """Transformer解码器"""
  184.     def __init__(self, vocab_size, key_size, query_size, value_size,
  185.                  num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
  186.                  num_heads, num_layers, dropout, **kwargs):
  187.         super(TransformerDecoder, self).__init__(**kwargs)
  188.         self.num_hiddens = num_hiddens
  189.         self.num_layers = num_layers
  190.         # 嵌入层
  191.         self.embedding = nn.Embedding(vocab_size, num_hiddens)
  192.         # 位置编码
  193.         self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
  194.         # 添加模块（num_layers个解码器块）
  195.         self.blks = nn.Sequential()
  196.         for i in range(num_layers):
  197.             self.blks.add_module("block"+str(i),
  198.                 DecoderBlock(key_size, query_size, value_size, num_hiddens,
  199.                              norm_shape, ffn_num_input, ffn_num_hiddens,
  200.                              num_heads, dropout, i))
  201.         # 全连接层
  202.         self.dense = nn.Linear(num_hiddens, vocab_size)
  203.  
  204.     def init_state(self, enc_outputs, enc_valid_lens, *args):
  205.         return [enc_outputs, enc_valid_lens, [None] * self.num_layers]
  206.  
  207.     def forward(self, X, state):
  208.         # 位置编码+嵌入层
  209.         X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
  210.         # 定义二维列表，存放 解码器自注意力权重 和 “编码器=解码器”自注意力权重
  211.         self._attention_weights = [[None] * len(self.blks) for _ in range(2)]
  212.         for i, blk in enumerate(self.blks):
  213.             X, state = blk(X, state)
  214.             # 解码器自注意力权重
  215.             self._attention_weights[0][i] = blk.attention1.attention.attention_weights
  216.             # “编码器－解码器”自注意力权重
  217.             self._attention_weights[1][i] = blk.attention2.attention.attention_weights
  218.         return self.dense(X), state  # 最后把参数传入到全连接层之中
  219.  
  220.     def attention_weights(self):
  221.         return self._attention_weights
  222.  
  223.  
  224. # =================================================================== #
  225. # # 训练
  226. # 隐藏层层数，编码器/解码器块数量，舍弃比率，批量大小，num_steps
  227. num_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10
  228. # 学习率，迭代次数，设备选取
  229. lr, num_epochs, device = 0.005, 200, d2l.try_gpu()
  230. # 前馈网络输入层，前馈网络隐藏层，注意力头的数量
  231. ffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4
  232. # 查询，键，值
  233. query_size, key_size, value_size = 32, 32, 32
  234. # AddNorm（规范化的维度）
  235. norm_shape = [32]
  236.  
  237. # 加载文字数据集（英语翻译成法语）
  238. # train_iter:数据集信息
  239. # src_vocab:源（英语）词汇表
  240. # tgt_vocab:法语词汇表
  241. train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
  242.  
  243. encoder = TransformerEncoder(
  244.     len(src_vocab), key_size, query_size, value_size, num_hiddens,
  245.     norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
  246.     num_layers, dropout)
  247. # print("编码器返回的结果（Transformer编码器的结构）：")
  248. # print(encoder)
  249.  
  250. decoder = TransformerDecoder(
  251.     len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape,
  252.     ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)
  253. # print("解码器返回的结果（Transformer解码器的结构）：")
  254. # print(decoder)
  255.  
  256. # Transformer“编码器-解码器”网络模型
  257. net = d2l.EncoderDecoder(encoder, decoder)
  258. print("Transformer“编码器-解码器”网络模型结构：")
  259. print(net)
  260.  
  261. # 训练一个序列到序列的模型
  262. # 网络模型，数据集信息，学习率，迭代次数，法语词汇表（标志输出），设备选取
  263. d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
  264.  
  265. # =================================================================== #
  266. # # 测试
  267. engs = ['go .', "i lost .", 'he\'s calm .', 'i\'m home .']
  268. fras = ['va !', 'j\'ai perdu .', 'il est calme .', 'je suis chez moi .']
  269. # 多维列表
  270. dec_attention_weight_seq = []
  271. for eng, fra in zip(engs, fras):
  272.     # 网络模型、单个英语词汇、英语词汇集、法语词汇集、num_steps，设备选取
  273.     translation, dec_attention_weight_seq = d2l.predict_seq2seq(
  274.         net, eng, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=True)
  275.     print(f'{eng} => {translation}, ',
  276.           f'bleu {d2l.bleu(translation, fra, k=2):.3f}')  # 评分函数（翻译结果同数据集相比较）
  277.  
  278. enc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))
  279. print(enc_attention_weights.shape)
  280.  
  281. d2l.show_heatmaps(
  282.     enc_attention_weights.cpu(), xlabel='Key positions',
  283.     ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],
  284.     figsize=(7, 3.5))
  285. plt.show()
  286.  
  287. # =================================================================== #
  288. # # 可视化权重
  289. print(len(dec_attention_weight_seq))
  290. dec_attention_weights_2d = [head[0].tolist()
  291.                             for step in dec_attention_weight_seq
  292.                             for attn in step for blk in attn for head in blk]
  293. dec_attention_weights_filled = torch.tensor(
  294.     pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)
  295. dec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))
  296. dec_self_attention_weights, dec_inter_attention_weights = \
  297.     dec_attention_weights.permute(1, 2, 3, 0, 4)
  298. print(dec_self_attention_weights.shape, dec_inter_attention_weights.shape)
  299.  
  300. # 与编码器的自注意力的情况类似，通过指定输入序列的有效长度，
  301. # [输出序列的查询不会与输入序列中填充位置的词元进行注意力计算]。
  302. # Plusonetoincludethebeginning-of-sequencetoken
  303. d2l.show_heatmaps(
  304.     dec_self_attention_weights[:, :, :, :len(translation.split()) + 1],
  305.     xlabel='Key positions', ylabel='Query positions',
  306.     titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))
  307.  
  308. d2l.show_heatmaps(
  309.     dec_inter_attention_weights, xlabel='Key positions',
  310.     ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],
  311.     figsize=(7, 3.5))

>>>如有疑问，欢迎评论区一起探讨

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

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

  

闽ICP备14008679号