详解Transformer结构

详解Transformer结构

Transformer在深度学习中一直占据着很重要的地位，不仅在NLP领域中会使用到，也创建CV领域，在2021年Transformer也在CV领域大杀四方。本文详解Transformer结构，带大家熟悉Transformer每个部分的原理和作用。

本文主要回答以下几个问题：

Transformer背景介绍？

Transformer的整体架构是什么样的？

Transformer中每个细节部分的原理和作用是什么？

论文：https://arxiv.org/abs/1706.03762

Transformer背景介绍？

注意力(Attention)机制由Bengio团队2015年提出(链接如下)，近些年广泛应用在深度学习等各个领域。

https://arxiv.org/pdf/1409.0473.pdf

Bengio 大神其实是借鉴了生物在观察、学习、思考行为中的过程的一种独特的生理机制，这种机制就是 Attention 机制。大家都能有感觉，我们在获取信息的时候，通常是先从宏观上建立一个比较模糊的认识，然后又在宏观的认识下，发现一些比较重要的信息，对于这些重要的信息，我们会花费更多的注意力进行观察、学习和思考。例如在计算机视觉方向用于捕捉图像上的感受野，或者NLP中用于定位关键token或者特征，这些都是注意力的作用。

正如论文的题目所说，Transformer抛弃了传统的CNN和RNN，整个网络结构完全是由Attention机制组成。作者采用Attention机制的原因是考虑到RNN（或者LSTM，GRU等）的计算限制为顺序的，也就是说RNN系列算法只能从左向右依次计算或者从右向左依次计算，这种机制带来了两个问题：

时间步t的计算依赖t-1时刻的计算结果，这样限制了模型的并行能力；

顺序计算反向传播过程中会出现梯度爆炸和梯度消失的现象，尽管LSTM等门机制的结构在一定程度上缓解了这种现象，但是并未完全解决。

Transformer的提出解决了上面两个问题，首先它使用了Attention机制，将序列中的任意两个位置之间的距离是缩小为一个常量，在分析预测更长的文本时,捕捉间隔较长的语义关联效果更好；其次它不是类似RNN的顺序结构，因此具有更好的并行性，符合现有的GPU框架，能够利用分布式GPU进行并行训练，提升模型训练效率。

下面是一张测评比较图，可以看出Attention在预测长文本任务中效果最佳：

图1 注意力机制在预测长文本中效果

在著名的SOTA机器翻译榜单上, 几乎所有排名靠前的模型都使用Transformer，如图2所示。

图2 机器翻译模型SOTA榜单

Transformer的整体架构是什么样的？

首先来说一下Transformer的用途：

基于seq2seq架构的Transformer模型可以完成NLP领域的一些典型任务, 如机器翻译, 文本生成，同时又可以通过构建预训练语言模型，用于不同任务的迁移学习。

图3 Transformer总体架构图

Transformer的整体架构可以分为四个模块：

输入模块

编码模块

解码模块

输出模块

输入模块结构：

源文本嵌入层及其位置编码器

目标文本嵌入层及其位置编码器

图4 输入模块结构

编码器模块结构：

由N个编码器层堆叠而成

每个编码器层由两个子层连接结构组成

第一个子层连接结构包括一个多头自注意力子层、规范化层和一个残差连接

第二个子层连接结构包括一个前馈全连接子层、规范化层和一个残差连接

图5 编码器模块结构

解码器模块:

由N个解码器层堆叠而成

每个解码器层由三个子层连接结构组成

第一个子层连接结构包括一个多头自注意力子层、规范化层和一个残差连接

第二个子层连接结构包括一个多头注意力子层、规范化层和一个残差连接

第三个子层连接结构包括一个前馈全连接子层、规范化层和一个残差连接

图6 解码器模块结构

输出模块结构：

线性层

softmax层

图7 输出模块结构

Transformer中每个细节部分的原理和作用是什么？

这里我们按照上面的结构依次对每个模块的细节部分进行原理分析和代码讲解。

输入模块

1. 文本嵌入层的作用

无论是源文本嵌入还是目标文本嵌入，都是为了将文本中词汇的数字表示转变为向量表示, 希望在高维向量空间中捕捉词汇间的关系。

文本嵌入层的代码分析:

# 导入必备的工具包

import torch

import torch.nn as nn

import math

from torch.autograd import Variable

# 定义Embeddings类来实现文本嵌入层，这里s说明代表两个一模一样的嵌入层, 他们共享参数.

class Embeddings(nn.Module):

def __init__(self, d_model, vocab):

"""类的初始化函数,有两个参数,

d_model: 指词嵌入的维度,

vocab: 指词表的大小

"""

super(Embeddings, self).__init__()

# 调用nn中的预定义层Embedding, 获得一个词嵌入对象self.lut

self.lut = nn.Embedding(vocab, d_model)

# 将d_model传入类中

self.d_model = d_model

def forward(self, x):

# 将x传给self.lut并与根号下self.d_model相乘作为结果返回

return self.lut(x) * math.sqrt(self.d_model)

2. 位置编码器的作用

在Transformer的编码器结构中, 并没有针对词汇位置信息的处理，因此需要在Embedding层后加入位置编码器，将词汇位置不同可能会产生不同语义的信息加入到词嵌入张量中, 以弥补位置信息的缺失.

位置编码器的代码分析:

# 定义位置编码器类

class PositionalEncoding(nn.Module):

def __init__(self, d_model, dropout, max_len=5000):

"""位置编码器类的初始化函数, 共有三个参数

分别是d_model: 词嵌入维度

dropout: 置0比率

max_len: 每个句子的最大长度

"""

super(PositionalEncoding, self).__init__()

# 实例化nn中预定义的Dropout层, 并将dropout传入其中, 获得对象self.dropout

self.dropout = nn.Dropout(p=dropout)

# 初始化一个位置编码矩阵, 它是一个0阵，矩阵的大小是max_len x d_model.

pe = torch.zeros(max_len, d_model)

# 初始化一个绝对位置矩阵, 在这里，词汇的绝对位置用它的索引表示.

# 首先使用arange方法获得一个连续自然数向量，然后再使用unsqueeze方法拓展向量维度使其成为矩阵，

position = torch.arange(0, max_len).unsqueeze(1)

# 绝对位置矩阵初始化之后，接下来就是考虑如何将这些位置信息加入到位置编码矩阵中，

# 最简单思路就是先将max_len x 1的绝对位置矩阵， 变换成max_len x d_model形状，然后覆盖原来的初始位置编码矩阵即可，

# 要做这种矩阵变换，就需要一个1xd_model形状的变换矩阵div_term

div_term = torch.exp(torch.arange(0, d_model, 2) *

-(math.log(10000.0) / d_model))

pe[:, 0::2] = torch.sin(position * div_term)

pe[:, 1::2] = torch.cos(position * div_term)

# 使用unsqueeze拓展维度.

pe = pe.unsqueeze(0)

# 最后把pe位置编码矩阵注册成模型的buffer

self.register_buffer('pe', pe)

def forward(self, x):

"""forward函数的参数是x, 表示文本序列的词嵌入表示"""

# 因为我们默认max_len为5000一般来讲实在太大了，很难有一条句子包含5000个词汇，所以要进行与输入张量的适配.

# 最后使用Variable进行封装，使其与x的样式相同，但是它是不需要进行梯度求解的，因此把requires_grad设置成false.

x = x + Variable(self.pe[:, :x.size(1)],

requires_grad=False)

# 最后使用self.dropout对象进行'丢弃'操作, 并返回结果.

return self.dropout(x)

编码器模块：

1. 掩码张量的作用

Transformer中，掩码张量的主要作用在应用Attention中，用于掩盖未来信息。在训练时会把整个输出结果一次性进行Embedding，但是理论上解码器的的输出却不是一次就能产生最终结果的，而是一次次通过上一次结果综合得出的，因此，未来的信息可能被提前利用。所以，Attention中需要使用掩码张量掩盖未来信息。

生成掩码张量的代码分析:

def subsequent_mask(size):

# 首先需要定义掩码张量的形状

attn_shape = (1, size, size)

# 使用np.ones方法向这个形状中添加1元素,形成上三角阵

# 为了节约空间, 再使其中的数据类型变为无符号8位整形unit8

subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')

# 最后将numpy类型转化为torch中的tensor, 内部做一个1 - 的操作,

# 在这个其实是做了一个三角阵的反转, subsequent_mask中的每个元素都会被1减

return torch.from_numpy(1 - subsequent_mask)

2. 注意力机制

(1)什么是注意力？

我们观察事物时，之所以能够快速判断一种事物，是因为我们大脑能够很快把注意力放在事物最具有辨识度的部分从而作出判断，而并非是从头到尾的观察一遍事物后，才能有判断结果。正是基于这样的理论，就产生了注意力机制。

(2)什么是注意力计算规则？

它需要三个指定的输入Q(query)，K(key)，V(value),，通过公式得到注意力的计算结果，这个结果代表query在key和value作用下的表示。而这个具体的计算规则有很多种, 这里只介绍Transformer用到的这一种。

Transformer使用的注意力计算规则：


(3)什么是注意力机制？

注意力机制是注意力计算规则能够应用在深度学习网络的载体，除了注意力计算规则外，还包括一些必要的全连接层以及相关张量处理，使其与应用网络融为一体。使用自注意力计算规则的注意力机制称为自注意力机制。

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

图8 注意力机制图形表示

注意力计算规则的代码分析:

def Attention(query, key, value, mask=None, dropout=None):

"""注意力机制的实现, 输入分别是query, key, value, mask: 掩码张量"""

# 首先取query的最后一维的大小, 一般情况下就等同于词嵌入维度, 命名为d_k

d_k = query.size(-1)

# 按照注意力公式, 将query与key的转置相乘, 这里面key是将最后两个维度进行转置, 再除以缩放系数根号下d_k, 这种计算方法也称为缩放点积注意力计算.

scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)

# 接着判断是否使用掩码张量

if mask is not None:

# 使用tensor的masked_fill方法, 将掩码张量和scores张量每个位置一一比较, 如果掩码张量处为0

# 则对应的scores张量用-1e9这个值来替换, 如下演示

scores = scores.masked_fill(mask == 0, -1e9)

# 对scores的最后一维进行softmax操作, 使用F.softmax方法, 第一个参数是softmax对象, 第二个是目标维度.

# 这样获得最终的注意力张量

p_attn = F.softmax(scores, dim = -1)

# 之后判断是否使用dropout进行随机置0

if dropout is not None:

# 将p_attn传入dropout对象中进行'丢弃'处理

p_attn = dropout(p_attn)

# 最后, 根据公式将p_attn与value张量相乘获得最终的query注意力表示, 同时返回注意力张量

return torch.matmul(p_attn, value), p_attn

3. 多头注意力机制

多头的意思是每个头都从词义层面分割输出张量，也就是每个头都想获得一组Q，K，V进行注意力机制的计算，句子中每个词只表示句子的一部分，所以将每个词的计算结果拼接到一起形成最终结果。这就是所谓的多头，将每个头获得的输入送到注意力机制中，就形成多头注意力机制。

多头注意力机制结构和计算过程图:

图9 多头注意力结构图

图10 多头注意力机制计算过程

多头注意力机制作用：

这种结构设计能让每个注意力机制去优化每个词汇的不同特征部分，从而均衡同一种注意力机制可能产生的偏差，让词义拥有来自更多元的表达，实验表明可以从而提升模型效果。

多头注意力机制的代码实现:

# 定义一个多头注意力机制类

class MultiHeadedAttention(nn.Module):

def __init__(self, head, embedding_dim, dropout=0.1):

"""在类的初始化时, 会传入三个参数，

head代表头数，

embedding_dim代表词嵌入的维度，

dropout代表进行dropout操作时置0比率，默认是0.1.

"""

super(MultiHeadedAttention, self).__init__()

# 在函数中，首先使用了一个测试中常用的assert语句，判断h是否能被d_model整除，

# 这是因为之后要给每个头分配等量的词特征。也就是embedding_dim/head个.

assert embedding_dim % head == 0

self.d_k = embedding_dim // head

self.head = head

self.linears = clones(nn.Linear(embedding_dim, embedding_dim), 4)

self.attn = None

self.dropout = nn.Dropout(p=dropout)

def forward(self, query, key, value, mask=None):

"""前向逻辑函数, 它的输入参数有四个，前三个就是注意力机制需要的Q, K, V，

最后一个是注意力机制中可能需要的mask掩码张量，默认是None. """

# 如果存在掩码张量mask

if mask is not None:

mask = mask.unsqueeze(0)

batch_size = query.size(0)

# 进入多头处理环节

# 首先利用zip将输入QKV与三个线性层组到一起，然后使用for循环，将输入QKV分别传到线性层中，

# 做完线性变换后，开始为每个头分割输入，这里使用view方法对线性变换的结果进行维度重塑，多加了一个维度h，代表头数，

# 这样就意味着每个头可以获得一部分词特征组成的句子，其中的-1代表自适应维度，

# 计算机会根据这种变换自动计算这里的值.然后对第二维和第三维进行转置操作，

# 为了让代表句子长度维度和词向量维度能够相邻，这样注意力机制才能找到词义与句子位置的关系，

# 从Attention函数中可以看到，利用的是原始输入的倒数第一和第二维.这样我们就得到了每个头的输入.

query, key, value = \

[model(x).view(batch_size, -1, self.head, self.d_k).transpose(1, 2)

for model, x in zip(self.linears, (query, key, value))]

# 得到每个头的输入后，接下来将他们传入到Attention中，

# 这里直接调用之前实现的Attention函数.同时也将mask和dropout传入其中.

x, self.attn = Attention(query, key, value, mask=mask, dropout=self.dropout)

# 通过多头注意力计算后，我们就得到了每个头计算结果组成的4维张量，我们需要将其转换为输入的形状以方便后续的计算，

# 因此这里开始进行第一步处理环节的逆操作，先对第二和第三维进行转置，然后使用contiguous方法，

# 这个方法的作用就是能够让转置后的张量应用view方法，否则将无法直接使用，

# 所以，下一步就是使用view重塑形状，变成和输入形状相同.

x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.head * self.d_k)

# 最后使用线性层列表中的最后一个线性层对输入进行线性变换得到最终的多头注意力结构的输出.

return self.linears[-1](x)

4. 前馈全连接层

考虑注意力机制可能对复杂过程的拟合程度不够, 通过增加两层网络来增强模型的能力。

前馈全连接层的代码分析:

# 通过类PositionwiseFeedForward来实现前馈全连接层

class PositionwiseFeedForward(nn.Module):

def __init__(self, d_model, d_ff, dropout=0.1):

"""初始化函数有三个输入参数分别是d_model, d_ff,和dropout=0.1，第一个是线性层的输入维度也是第二个线性层的输出维度，

因为我们希望输入通过前馈全连接层后输入和输出的维度不变. 第二个参数d_ff就是第二个线性层的输入维度和第一个线性层的输出维度.

最后一个是dropout置0比率."""

super(PositionwiseFeedForward, self).__init__()

# 首先按照我们预期使用nn实例化了两个线性层对象，self.w1和self.w2

# 它们的参数分别是d_model, d_ff和d_ff, d_model

self.w1 = nn.Linear(d_model, d_ff)

self.w2 = nn.Linear(d_ff, d_model)

# 然后使用nn的Dropout实例化了对象self.dropout

self.dropout = nn.Dropout(dropout)

def forward(self, x):

"""输入参数为x，代表来自上一层的输出"""

# 首先经过第一个线性层，然后使用Funtional中relu函数进行激活,

# 之后再使用dropout进行随机置0，最后通过第二个线性层w2，返回最终结果.

return self.w2(self.dropout(F.relu(self.w1(x))))

5. 规范化层

所有深层网络模型都需要用到标准网络层，因为随着网络层数的增加，通过多层的计算后参数可能开始出现过大或过小的情况，这样可能会导致学习过程出现异常，模型可能收敛非常的慢。因此都会在一定层数后接规范化层进行数值的规范化，使其特征数值在合理范围内。

规范化层的代码实现:

# 通过LayerNorm实现规范化层的类

class LayerNorm(nn.Module):

def __init__(self, features, eps=1e-6):

"""初始化函数有两个参数, 一个是features, 表示词嵌入的维度,

另一个是eps它是一个足够小的数, 在规范化公式的分母中出现,

防止分母为0.默认是1e-6."""

super(LayerNorm, self).__init__()

self.a2 = nn.Parameter(torch.ones(features))

self.b2 = nn.Parameter(torch.zeros(features))

self.eps = eps

def forward(self, x):

"""输入参数x代表来自上一层的输出"""

# 在函数中，首先对输入变量x求其最后一个维度的均值，并保持输出维度与输入维度一致.

# 接着再求最后一个维度的标准差，然后就是根据规范化公式，用x减去均值除以标准差获得规范化的结果，

# 最后对结果乘以我们的缩放参数，即a2，*号代表同型点乘，即对应位置进行乘法操作，加上位移参数b2.返回即可.

mean = x.mean(-1, keepdim=True)

std = x.std(-1, keepdim=True)

return self.a2 * (x - mean) / (std + self.eps) + self.b2

6. 子层连接结构

如图11所示，输入到每个子层以及规范化层的过程中，还使用了残差连接，我们把这一部分结构整体叫做子层连接（代表子层及其链接结构），在每个编码器层中，都有两个子层，这两个子层加上周围的链接结构就形成了两个子层连接结构。

子层连接结构图:

图11 子层连接结构

子层连接结构的代码分析:

# 使用SublayerConnection来实现子层连接结构的类

class SublayerConnection(nn.Module):

def __init__(self, size, dropout=0.1):

"""它输入参数有两个, size以及dropout， size一般都是词嵌入维度的大小

"""

super(SublayerConnection, self).__init__()

self.norm = LayerNorm(size)

self.dropout = nn.Dropout(p=dropout)

def forward(self, x, sublayer):

# 我们首先对输出进行规范化，然后将结果传给子层处理，之后再对子层进行dropout操作，

# 随机停止一些网络中神经元的作用，来防止过拟合. 最后还有一个add操作，

# 因为存在跳跃连接，所以是将输入x与dropout后的子层输出结果相加作为最终的子层连接输出。

return x + self.dropout(sublayer(self.norm(x)))

7. 编码器层

作为编码器的组成单元, 每个编码器层完成一次对输入的特征提取过程, 即编码过程。

编码器层的构成图:

图12 编码器结构

编码器层的代码分析:

# 使用EncoderLayer类实现编码器层

class EncoderLayer(nn.Module):

def __init__(self, size, self_attn, feed_forward, dropout):

"""它的初始化函数参数有四个，分别是size，其实就是我们词嵌入维度的大小，它也将作为我们编码器层的大小,

第二个self_attn，之后我们将传入多头自注意力子层实例化对象, 并且是自注意力机制,

第三个是feed_froward, 之后我们将传入前馈全连接层实例化对象, 最后一个是置0比率dropout."""

super(EncoderLayer, self).__init__()

# 首先将self_attn和feed_forward传入其中.

self.self_attn = self_attn

self.feed_forward = feed_forward

# 如图所示, 编码器层中有两个子层连接结构, 所以使用clones函数进行克隆

self.sublayer = clones(SublayerConnection(size, dropout), 2)

# 把size传入其中

self.size = size

def forward(self, x, mask):

"""forward函数中有两个输入参数，x和mask，分别代表上一层的输出，和掩码张量mask."""

# 里面就是按照结构图左侧的流程. 首先通过第一个子层连接结构，其中包含多头自注意力子层，

# 然后通过第二个子层连接结构，其中包含前馈全连接子层. 最后返回结果.

x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))

return self.sublayer[1](x, self.feed_forward)

8. 编码器

编码器用于对输入进行指定的特征提取过程, 也称为编码, 由N个编码器层堆叠而成。

编码器的结构图:

图13 编码器结构

编码器的代码分析:

# 使用Encoder类来实现编码器

class Encoder(nn.Module):

def __init__(self, layer, N):

"""初始化函数的两个参数分别代表编码器层和编码器层的个数"""

super(Encoder, self).__init__()

# 首先使用clones函数克隆N个编码器层放在self.layers中

self.layers = clones(layer, N)

# 再初始化一个规范化层, 它将用在编码器的最后面.

self.norm = LayerNorm(layer.size)

def forward(self, x, mask):

"""forward函数的输入和编码器层相同, x代表上一层的输出, mask代表掩码张量"""

# 首先就是对我们克隆的编码器层进行循环，每次都会得到一个新的x，

# 这个循环的过程，就相当于输出的x经过了N个编码器层的处理.

# 最后再通过规范化层的对象self.norm进行处理，最后返回结果.

for layer in self.layers:

x = layer(x, mask)

return self.norm(x)

解码器模块：

1. 解码器层

作为解码器的组成单元, 每个解码器层根据给定的输入向目标方向进行特征提取操作，即解码过程。

解码器层的代码实现:

# 使用DecoderLayer的类实现解码器层

class DecoderLayer(nn.Module):

def __init__(self, size, self_attn, src_attn, feed_forward, dropout):

""" 初始化函数的参数有5个

第一个是分别是size，代表词嵌入的维度大小, 同时也代表解码器层的尺寸，

第二个是self_attn，多头自注意力对象，也就是说这个注意力机制需要Q=K=V，

第三个是src_attn，多头注意力对象，这里Q!=K=V，

第四个是前馈全连接层对象，

最后是droupout置0比率。

"""

super(DecoderLayer, self).__init__()

# 在初始化函数中， 主要就是将这些输入传到类中

self.size = size

self.self_attn = self_attn

self.src_attn = src_attn

self.feed_forward = feed_forward

# 按照结构图使用clones函数克隆三个子层连接对象.

self.sublayer = clones(SublayerConnection(size, dropout), 3)

def forward(self, x, memory, source_mask, target_mask):

"""forward函数中的参数有4个，

分别是来自上一层的输入x，

来自编码器层的语义存储变量mermory，

以及源数据掩码张量和目标数据掩码张量.

"""

# 将memory表示成m方便之后使用

m = memory

# 将x传入第一个子层结构，第一个子层结构的输入分别是x和self-attn函数，因为是自注意力机制，所以Q,K,V都是x，

# 最后一个参数是目标数据掩码张量，这时要对目标数据进行遮掩，因为此时模型可能还没有生成任何目标数据，

# 比如在解码器准备生成第一个字符或词汇时，我们其实已经传入了第一个字符以便计算损失，

# 但是我们不希望在生成第一个字符时模型能利用这个信息，因此我们会将其遮掩，同样生成第二个字符或词汇时，

# 模型只能使用第一个字符或词汇信息，第二个字符以及之后的信息都不允许被模型使用.

x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, target_mask))

# 接着进入第二个子层，这个子层中常规的注意力机制，q是输入x; k，v是编码层输出memory，

# 同样也传入source_mask，但是进行源数据遮掩的原因并非是抑制信息泄漏，而是遮蔽掉对结果没有意义的字符而产生的注意力值，

# 以此提升模型效果和训练速度. 这样就完成了第二个子层的处理.

x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, source_mask))

# 最后一个子层就是前馈全连接子层，经过它的处理后就可以返回结果.这就是我们的解码器层结构.

return self.sublayer[2](x, self.feed_forward)

2. 解码器

根据编码器的结果以及上一次预测的结果, 对下一次可能出现的'值'进行特征表示。

解码器结构图：

图14 解码器结构

解码器的代码分析:

# 使用类Decoder来实现解码器

class Decoder(nn.Module):

def __init__(self, layer, N):

"""初始化函数的参数有两个，第一个就是解码器层layer，第二个是解码器层的个数N."""

super(Decoder, self).__init__()

# 首先使用clones方法克隆了N个layer，然后实例化了一个规范化层.

# 因为数据走过了所有的解码器层后最后要做规范化处理.

self.layers = clones(layer, N)

self.norm = LayerNorm(layer.size)

def forward(self, x, memory, source_mask, target_mask):

"""forward函数中的参数有4个，x代表目标数据的嵌入表示，memory是编码器层的输出，

source_mask, target_mask代表源数据和目标数据的掩码张量"""

# 然后就是对每个层进行循环，当然这个循环就是变量x通过每一个层的处理，

# 得出最后的结果，再进行一次规范化返回即可.

for layer in self.layers:

x = layer(x, memory, source_mask, target_mask)

return self.norm(x)

输出模块

1.线性层

通过对上一步的线性变化得到指定维度的输出, 也就是转换维度的作用。

2.softmax层

使最后一维的向量中的数字缩放到0-1的概率值域内, 并满足他们的和为1。

线性层和softmax层的代码分析:

# nn.functional工具包装载了网络层中那些只进行计算, 而没有参数的层

import torch.nn.functional as F

# 将线性层和softmax计算层一起实现, 因为二者的共同目标是生成最后的结构

# 因此把类的名字叫做Generator, 生成器类

class Generator(nn.Module):

def __init__(self, d_model, vocab_size):

"""初始化函数的输入参数有两个, d_model代表词嵌入维度, vocab_size代表词表大小."""

super(Generator, self).__init__()

# 首先就是使用nn中的预定义线性层进行实例化, 得到一个对象self.project等待使用,

# 这个线性层的参数有两个, 就是初始化函数传进来的两个参数: d_model, vocab_size

self.project = nn.Linear(d_model, vocab_size)

def forward(self, x):

"""前向逻辑函数中输入是上一层的输出张量x"""

# 在函数中, 首先使用上一步得到的self.project对x进行线性变化,

# 然后使用F中已经实现的log_softmax进行的softmax处理.

# 在这里之所以使用log_softmax是因为和我们这个pytorch版本的损失函数实现有关, 在其他版本中将修复.

# log_softmax就是对softmax的结果又取了对数, 因为对数函数是单调递增函数,

# 因此对最终我们取最大的概率值没有影响. 最后返回结果即可.

return F.log_softmax(self.project(x), dim=-1)

Finally

通过上面的四个模块的介绍，我们已经完成了所有组成部分的原理介绍和实现 接下来就来实现完整的编码器-解码器结构。

编码器-解码器结构的代码实现：

# 使用EncoderDecoder类来实现编码器-解码器结构

class EncoderDecoder(nn.Module):

def __init__(self, encoder, decoder, source_embed, target_embed, generator):

"""初始化函数中有5个参数, 分别是编码器对象, 解码器对象,

源数据嵌入函数, 目标数据嵌入函数, 以及输出部分的类别生成器对象

"""

super(EncoderDecoder, self).__init__()

# 将参数传入到类中

self.encoder = encoder

self.decoder = decoder

self.src_embed = source_embed

self.tgt_embed = target_embed

self.generator = generator

def forward(self, source, target, source_mask, target_mask):

"""在forward函数中，有四个参数, source代表源数据, target代表目标数据,

source_mask和target_mask代表对应的掩码张量"""

# 在函数中, 将source, source_mask传入编码函数, 得到结果后,

# 与source_mask，target，和target_mask一同传给解码函数.

return self.generator(self.decode(self.encode(source, source_mask), source_mask,

target, target_mask))

def encode(self, source, source_mask):

"""编码函数, 以source和source_mask为参数"""

# 使用src_embed对source做处理, 然后和source_mask一起传给self.encoder

return self.encoder(self.src_embed(source), source_mask)

def decode(self, memory, source_mask, target, target_mask):

"""解码函数, 以memory即编码器的输出, source_mask, target, target_mask为参数"""

# 使用tgt_embed对target做处理, 然后和source_mask, target_mask, memory一起传给self.decoder

return self.decoder(self.tgt_embed(target), memory, source_mask, target_mask)

Tansformer模型构建过程的代码分析:

def make_model(source_vocab, target_vocab, N=6,

d_model=512, d_ff=2048, head=8, dropout=0.1):

"""该函数用来构建模型, 有7个参数，分别是源数据特征(词汇)总数，目标数据特征(词汇)总数，

编码器和解码器堆叠数，词向量映射维度，前馈全连接网络中变换矩阵的维度，

多头注意力结构中的多头数，以及置零比率dropout."""

# 首先得到一个深度拷贝命令，接下来很多结构都需要进行深度拷贝，

# 来保证他们彼此之间相互独立，不受干扰.

c = copy.deepcopy

# 实例化了多头注意力类，得到对象attn

attn = MultiHeadedAttention(head, d_model)

# 然后实例化前馈全连接类，得到对象ff

ff = PositionwiseFeedForward(d_model, d_ff, dropout)

# 实例化位置编码类，得到对象position

position = PositionalEncoding(d_model, dropout)

# 根据结构图, 最外层是EncoderDecoder，在EncoderDecoder中，

# 分别是编码器层，解码器层，源数据Embedding层和位置编码组成的有序结构，

# 目标数据Embedding层和位置编码组成的有序结构，以及类别生成器层.

# 在编码器层中有Attention子层以及前馈全连接子层，

# 在解码器层中有两个Attention子层以及前馈全连接层.

model = EncoderDecoder(

Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),

Decoder(DecoderLayer(d_model, c(attn), c(attn),

c(ff), dropout), N),

nn.Sequential(Embeddings(d_model, source_vocab), c(position)),

nn.Sequential(Embeddings(d_model, target_vocab), c(position)),

Generator(d_model, target_vocab))

# 模型结构完成后，接下来就是初始化模型中的参数，比如线性层中的变换矩阵

# 这里一但判断参数的维度大于1，则会将其初始化成一个服从均匀分布的矩阵，

for p in model.parameters():

if p.dim() > 1:

nn.init.xavier_uniform(p)

return model

到此就要和大家说再见了，我们再来回顾一下Transformer的整体架构！！！

图15 Transformer YYDS