Transformer一步步实现

发表于 | 分类于

前言

前面写了两篇关于transformer的原理的文章，分别是

Transformer原理 | Sunrise (forchenxi.github.io)

Transformer block | Sunrise (forchenxi.github.io)

这篇主要是将哈佛大学2018年写的一篇关于transformer的详细注解包括pytorch版本的实现过程《The Annotated Transformer》翻译为中文。

原文地址：The Annotated Transformer (harvard.edu)

知乎翻译文章地址：搞懂Transformer结构，看这篇PyTorch实现就够了 - 知乎 (zhihu.com)

正文

0 准备工作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn 

import numpy as np

import torch

import torch.nn as nn

import torch.nn.functional as F

import math, copy, time

from torch.autograd import Variable

import matplotlib.pyplot as plt

import seaborn

seaborn.set_context(context="talk")

%matplotlib inline

1 背景

减少序列处理任务的计算量是一个很重要的问题，也是Extended Neural GPU、ByteNet和ConvS2S等网络的动机。上面提到的这些网络都以CNN为基础，并行计算所有输入和输出位置的隐藏表示。

在这些模型中，关联来自两个任意输入或输出位置的信号所需的操作数随位置间的距离增长而增长，比如ConvS2S呈线性增长，ByteNet呈现以对数形式增长，这会使学习较远距离的两个位置之间的依赖关系变得更加困难。而在Transformer中，操作次数则被减少到了常数级别。

Self-attention有时候也被称为Intra-attention，是在单个句子不同位置上做的Attention，并得到序列的一个表示。它能够很好地应用到很多任务中，包括阅读理解、摘要、文本蕴涵，以及独立于任务的句子表示。端到端的网络一般都是基于循环注意力机制而不是序列对齐循环，并且已经有证据表明在简单语言问答和语言建模任务上表现很好。

据我们所知，Transformer是第一个完全依靠Self-attention而不使用序列对齐的RNN或卷积的方式来计算输入输出表示的转换模型。

2 模型结构

目前大部分比较热门的神经序列转换模型都有Encoder-Decoder结构。Encoder将输入序列 (x1, x2, ..., xn)映射到一个连续表示序列 z=(z1,....zn)。

对于编码得到的z，Decoder每次解码生成一个符号，直到生成完整的输出序列： (y1,....yn)。对于每一步解码，模型都是自回归的，即在生成下一个符号时将先前生成的符号作为附加输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class EncoderDecoder(nn.Module):
    """
    A standard Encoder-Decoder architecture. Base for this and many other models
    """
    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
        super(EncoderDecoder, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.src_embed = src_embed  # 包含两层，第一层为Embedding层，第二层为position encoding层
        self.tgt_embed = tgt_embed  # 包含两层，第一层为Embedding层，第二层为position encoding层
        self.generator = generator

    def forward(self, src, tgt, src_mask, tgt_mask):
        """
        Take in and process masked src and target sequences
        :param src： 输入文本
        :param tgt: 标签
        :param src_mask: 输入文本的mask
        :param tgt_mask: 输出文本的mask（用于遮蔽的多头注意力）
        """
        return self.decode(self.encode(src, src_mask), src_mask, tgt, tgt_mask)

    def encode(self, src, src_mask):
        return self.encoder(self.src_embed(src), src_mask)

    def decode(self, memory, src_mask, tgt, tgt_mask):
        # memory 是经过encoder得到的输出
        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)


class Generator(nn.Module):
    """
    Define standard linear + softmax generation step.
    """
    def __init__(self, d_model, vocab):
        super(Generator, self).__init__()
        self.proj = nn.Linear(d_model, vocab)

    def forward(self, x):
        return F.log_softmax(self.proj(x), dim=-1)

代码中有一些注释，我是专门针对transformer注释的（即仅在transformer模型结构的前提下，部分属性是这样理解的，如果是其他Encoder-Decoder模型则可能有其他的含义）。Transformer的整体结构如下图所示，在Encoder和Decoder中都使用了Multi-head attention(本质是多个Self-attention), Point-wise和全连接层。

Encoder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def clones(module, n):
    """ 将给定的网络clone n次 """
    return nn.ModuleList([copy.deepcopy(module) for _ in range(n)])


class Encoder(nn.Module):
    """ Encoder 堆叠了N 层 Encoder Layer"""
    def __init__(self, layer, n):
        super(Encoder, self).__init__()
        self.layers = clones(layer, n)  # 这个layer实际就是Encoder Layer
        self.norm = LayerNorm(layer.size)

    def forward(self, x, mask):
        """ Pass the input (and mask) through each layer in turn. """
        for layer in self.layers:  # layers里有N个EncoderLayer，EncoderLayer中包括multi-head、feedforward、sublayer
            x = layer(x, mask)
        return self.norm(x)

我们在每两个子层之间都使用了残差连接(Residual Connection) 和归一化。# BN/LN的计算方式，详见PyTorch正则化和批标准化 | Sunrise (forchenxi.github.io)

1
2
3
4
5
6
7
8
9
10
11
12
13
# LayerNorm可以自行实现，也可以使用Pytorch内置的
class LayerNorm(nn.Module):
    """ Construct a layernorm module (See citation for details)"""
    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))  # features等于dmodel词向量维度
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

也就是说，每个子层的输出为(LayerNorm(x + SubLayer(x)))，其中SubLayer(x)是由子层自动实现的函数。我们在每个子层的输出上使用Dropout，然后将其添加到下一子层的输入并进行归一化。

为了能方便地使用这些残差连接，模型中所有的子层和Embedding层的输出都设定成了相同的维度，即dmodel=512。

这里残差网络的forward方法，sublayer参数由传入的方法而定，在transformer模型中一般有两种情况，一种情况：sublayer是multi-head attention层，进行一次残差连接；另一种情况：sublayer是feed forward层，进行一次残差连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class SublayerConnection(nn.Module):
    """
    残差连接
    A residual connection followed by a layer norm
    Note for code simplicity the norm is first as opposed to last
    """
    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)  # size等于dmodel词向量维度
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        """ Apply residual connection to any sublayer  with the same size"""
        return x + self.dropout(sublayer(self.norm(x)))

每层都有两个子层组成。第一个子层实现了“多头”的 Self-attention，第二个子层则是一个简单的Position-wise的全连接前馈网络。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class EncoderLayer(nn.Module):
    """
    EncoderLayer层里包括一个Multi-head attention + 残差连接 + feedforward + 残差链接
    Encoder 由N个 EncoderLayer组成
    """
    def __init__(self, size, self_attn, feed_forward, dropout):
        """
        :param size: 词向量维度（d_model）
        :param self_attn: Multi-Head Attention
        :param feed_forward:
        :param dropout:
        """
        super(EncoderLayer, self).__init__()
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        # 初始化得到两个残差连接层
        self.sublayer = clones(SublayerConnection(size, dropout), 2)
        self.size = size

    def forward(self, x, mask):
        """
        Follow Figure 1 (left) for connections
        :param x: size(batch, seq_length, d_model)
        :param mask: size(batch, 1, seq_length)，mask在encoder中没啥用，主要是在decoder中实现遮蔽的多头注意力
        """
        # 先使用第一个残差连接层，连接x和多头注意力后的值(lambda y: self.self_attn(y, y, y, mask)，这只是一个参数，在这里并不执行)
        x = self.sublayer[0](x, lambda y: self.self_attn(y, y, y, mask))
        # 再使用第二个残差连接层，连接上一层残差连接得到的x和feed forward后的值
        return self.sublayer[1](x, self.feed_forward)

Decoder

Decoder也是由N=6个相同层组成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Decoder(nn.Module):
    """ Decoder 由N个 DecoderLayer组成."""
    def __init__(self, layer, N):
        super(Decoder, self).__init__()
        self.layers = clones(layer, N)  # 这个layer实际就是DecoderLayer
        self.norm = LayerNorm(layer.size)  # layer.size是d_model

    def forward(self, x, memory, src_mask, tgt_mask):
        """
        :param x:  在decoder中的x实际上是整个训练集的标签
        :param memory: 输入文本经过encoder的输出
        :param src_mask:  输入文本的mask
        :param tgt_mask:  输出文本的mask(用于遮蔽的多头注意力)
        :return:
        """
        for layer in self.layers:
            x = layer(x, memory, src_mask, tgt_mask)
        return self.norm(x)

通过transformer encoder-decoder的图形结构能够看出来，decoder也是由N个DecoderLayer层堆叠而成，但是DecoderLayer相比EncoderLayer，除了multi-head attention和feed forward两个子层之外，还插入了第三种子层对编码器栈的输出实行“多头”的Attention。图中这一子层在原有的两个子层的前面插入，与编码器类似，在每个子层两端使用残差连接进行短路，然后进行层的规范化处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class DecoderLayer(nn.Module):
    """
    Decoder is made of self-attn, src-attn, and feed forward(defined below)
    DecoderLayer中包含 masked multi-head attn(+残差连接)、multi-head attn(+残差连接)、feed forward(+残差连接)
    Decoder由N个DecoderLayer堆叠而成
    """
    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        """
        :param size: 词向量维度
        :param self_attn: 多头注意力（带遮蔽的，masked）
        :param src_attn:  多头注意力（与上面的结构没有本质区别，只不过传入的参数不同）
        :param feed_forward:
        :param dropout:
        """
        super(DecoderLayer, self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sub_layer = clones(SublayerConnection(size, dropout), 3)  # decode layer中需要3层残差连接

    def forward(self, x, memory, src_mask, tgt_mask):
        """ Follow Figure 1(right) for connections """
        m = memory
        x = self.sub_layer[0](x, lambda y: self.self_attn(y, y, y, tgt_mask))
        # 这里使用输入x的src_mask，可能有点疑问？
        x = self.sub_layer[1](x, lambda y: self.src_attn(y, m, m, src_mask))
        return self.sub_layer[2](x, self.feed_forward)

我们还修改解码器中的Self-attention子层以防止当前位置Attend到后续位置。这种Masked的Attention是考虑到输出Embedding会偏移一个位置，确保了生成位置i的预测时，仅依赖小于i的位置处的已知输出，相当于把后面不该看到的信息屏蔽掉。

1
2
3
4
5
6
7
def subsequent_mask(size):
    """ Masked attention 在训练期间，当前解码位置的词不能Attend到后续位置的词  """
    attn_shape = (1, size, size)
    # np.triu(a, k)是取矩阵a的上三角数据，k=0 的时候就是包含对角线和上（下）方的元素，其他值为 0
    # k = 1, 2, ...的时候，对角线向上（下）移动
    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
    return torch.from_numpy(subsequent_mask) == 0

下面的Attention mask图显示了允许每个目标词（行）查看的位置（列）。在训练期间，当前解码位置的词不能Attend到后续位置的词。

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

Attention

Attention函数可以将Query和一组Key-Value对映射到输出，其中Query、Key、Value和输出都是向量。 输出是值的加权和，其中分配给每个Value的权重由Query与相应Key的兼容函数计算。

我们称这种特殊的Attention机制为”Scaled Dot-Product Attention”。输入包含维度为dk的Query和Key，以及维度为dv的Value。 我们首先分别计算Query与各个Key的点积，然后将每个点积除以dk的平方根，最后使用Softmax函数来获得Key的权重。

在具体实现时，我们可以以矩阵的形式进行并行运算，这样能加速运算过程。具体来说，将所有的Query、Key和Value向量分别组合成矩阵Q、K和V，这样输出矩阵可以表示为：

1
2
3
4
5
6
7
8
9
10
def attention(query, key, value, mask=None, dropout=None):
    """ Compute 'Scaled Dot Produce Attenion' """
    d_k = query.size(-1)
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
    if mask is not None:  # masked_fill(tensor, value)，在tensor中为True的位置，填充value
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim=-1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value), p_attn

“多头”机制能让模型考虑到不同位置的Attention，另外“多头”Attention可以在不同的子空间表示不一样的关联关系，使用单个Head的Attention一般达不到这种效果。

我们的工作中使用 ℎ=8个Head并行的Attention，对每一个Head来说有 dk = dv = model /ℎ=64,总计算量与完整维度的单个Head的Attention很相近。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class MultiHeadAttention(nn.Module):
    def __init__(self, h, d_model, dropout=0.1):
        """
        Take in model size and number of heads
        :param h: 注意力头个数
        :param d_model: 词向量维度
        """
        super(MultiHeadAttention, self).__init__()
        assert d_model % h == 0
        # We assume d_v always equals d_k
        self.d_k = d_model // h  # 每个注意力头要计算的词向量维度
        self.h = h
        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None
        self.dropout = nn.Dropout(p=dropout)

    def forward(self, query, key, value, mask=None):
        """
        Implements Figure 2
        query、key、value都是输入x的副本
        """
        if mask is not None:
            # Same mask applied to all h heads
            mask = mask.unsqueeze(1)
        n_batches = query.size(0)
        # 1) Do all the linear projections in batch from d_model => h x dk
        # 先经过一个线性层，然后在第1维增加一维(自适应大小)，将d_model拆分成 h x dk，最后再将第1维和第2维交换
        query, key, value = [
            l(x).view(n_batches, -1, self.h, self.d_k,).transpose(1, 2)
            for l, x in zip(self.linears, (query, key, value))]

        # 2) Apply attention on all the projected vectors in batch
        x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)

        # 2) "Concat" using a view and apply a final linear
        # 这里多头注意力计算完成，再将x恢复成最初的形状
        x = x.transpose(1, 2).contiguous().view(n_batches, -1, self.h*self.d_k)
        return self.linears[-1](x)  # 怎么还要过一层线性层？

Attention在模型中的应用

Transformer中以三种不同的方式使用了“多头”Attention：

1) 在”Encoder-Decoder Attention”层，Query来自先前的解码器层，并且Key和Value来自Encoder的输出。Decoder中的每个位置Attend输入序列中的所有位置，这与Seq2Seq模型中的经典的Encoder-Decoder Attention机制一致。

2) Encoder中的Self-attention层。在Self-attention层中，所有的Key、Value和Query都来同一个地方，这里都是来自Encoder中前一层的输出。Encoder中当前层的每个位置都能Attend到前一层的所有位置。

3) 类似的，解码器中的Self-attention层允许解码器中的每个位置Attend当前解码位置和它前面的所有位置。这里需要屏蔽解码器中向左的信息流以保持自回归属性。具体的实现方式是在缩放后的点积Attention中，屏蔽（设为负无穷）Softmax的输入中所有对应着非法连接的Value。

Position-wise前馈网络

除了Attention子层之外，Encoder和Decoder中的每个层都包含一个全连接前馈网络，分别地应用于每个位置。其中包括两个线性变换，然后使用ReLU作为激活函数。

虽然线性变换在不同位置上是相同的，但它们在层与层之间使用不同的参数。这其实是相当于使用了两个内核大小为1的卷积。这里设置输入和输出的维数为dmodel=512，内层的维度为dff=2048。

1
2
3
4
5
6
7
8
9
10
class PositionWiseFeedForward(nn.Module):
    """Implements FFN equation."""
    def __init__(self, d_model, d_ff, dropout=0.1):
        super(PositionWiseFeedForward, self).__init__()
        self.w_1 = nn.Linear(d_model, d_ff)
        self.w_2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.w_2(self.dropout(F.relu(self.w_1(x))))

Embedding和Softmax

与其他序列转换模型类似，我们使用预学习的Embedding将输入Token序列和输出Token序列转化为dmodel维向量。我们还使用常用的预训练的线性变换和Softmax函数将解码器输出转换为预测下一个Token的概率。在我们的模型中，我们在两个Embedding层和Pre-softmax线性变换之间共享相同的权重矩阵，类似于。在Embedding层中，我们将这些权重乘以根号dmodel。

1
2
3
4
5
6
7
8
9
10
11
12
class Embeddings(nn.Module):
    def __init__(self, d_model, vocab):
        """
        :param d_model: 词向量维度大小
        :param vocab: 词表大小
        """
        super(Embeddings, self).__init__()
        self.lut = nn.Embedding(vocab, d_model)
        self.d_model = d_model

    def forward(self, x):
        return self.lut(x) * math.sqrt(self.d_model)  # 为啥要乘以sqrt(d_model)

位置编码

由于我们的模型不包含递归和卷积结构，为了使模型能够有效利用序列的顺序特征，我们需要加入序列中各个Token间相对位置或Token在序列中绝对位置的信息。在这里，我们将位置编码添加到编码器和解码器栈底部的输入Embedding。由于位置编码与Embedding具有相同的维度dmodel，因此两者可以直接相加。其实这里还有许多位置编码可供选择，其中包括可更新的和固定不变的。

在此项工作中，我们使用不同频率的正弦和余弦函数：

此外，在编码器和解码器堆栈中，我们在Embedding与位置编码的加和上都使用了Dropout机制。 在基本模型上, 我们使用pdrop=0.1的比率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class PositionEncoding(nn.Module):
    """Implement the PE function"""
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        # Compute the positional encoding once in log space
        pe = torch.zeros(max_len, d_model)  # pe用来存储，每个位置-每个维度的位置信息
        position = torch.arange(0, max_len).unsqueeze(1)  # 位置张量，size为(句子长度, 1)
        # torch.arange(0, d_model, 2) ==> 2i，size为d_model/2
        div_term = torch.exp(torch.arange(0, d_model, 2)*-(math.log(10000.0)/d_model))
        # position * div_term 的 size为(句子长度, d_model/2)
        pe[:, 0::2] = torch.sin(position * div_term)  # 偶数维度(2i)，注意不是位置
        pe[:, 1::2] = torch.cos(position * div_term)  # 奇数维度(2i+1)
        pe = pe.unsqueeze(0)  # 增加一维为了保持和x的size一致，可以直接加和
        # 定义pe参数在模型训练时不可更新，即optimizer.step()后不会被更新
        self.register_buffer('pe', pe)  # 并且同时还有self.pe = pe的功效

    def forward(self, x):
        # x的size为(batch, seq_length, d_model),x.size(1)为句子长度
        # 取出给定x的句子长度的位置向量，前提是x<5000,pe的size为(1, 5000, d_model)
        x = x + Variable(self.pe[:, :x.size(1)], requires_grad=True)
        return self.dropout(x)

这里的位置编码的代码实现方式与公式给出的有一定的转变，下面这种实现方式更容易理解

1
2
3
4
5
6
_2i = torch.arange(0, d_model, step=2, device=device).float()
# 'i' means index of d_model (e.g. embedding size = 50, 'i' = [0,50])
# "step=2" means 'i' multiplied with two (same with 2 * i)

pe[:, 0::2] = torch.sin(position / (10000 ** (_2i / d_model)))
pe[:, 1::2] = torch.cos(position / (10000 ** (_2i / d_model)))

上面代码给出的实现方式的转换原理如下：

如下所示，位置编码将根据位置添加正弦曲线。曲线的频率和偏移对于每个维度是不同的。

1
2
3
4
5
6
7
8
9
plt.figure(figsize=(15, 5))
# d_model=20
pe = PositionEncoding(20, 0)
# (batch_size, seq_length, d_model) -> (1, 100, 20)
y = pe.forward(Variable(torch.zeros(1, 100, 20)))
# 展示第0个位置，d_model=4,5,6,7的变化
plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())
plt.legend(["dim %d" % p for p in [4, 5, 6, 7]])
plt.show()

我们也尝试了使用预学习的位置Embedding，但是发现这两个版本的结果基本是一样的。我们选择正弦曲线版本的实现，因为使用此版本能让模型能够处理大于训练语料中最大序了使用列长度的序列。

3 完整模型

下面定义了连接完整模型并设置超参的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def make_model(src_vocab, tgt_vocab, n=6, d_model=512, d_ff=2048, h=8, dropout=0.1):
    """
    Helper: Construct a model from hyperparameters.
    :param src_vocab: 输入文本词表大小
    :param tgt_vocab: 输出标签类别数
    :param n: EncoderLayer/DecoderLayer层数
    :param d_model: 词向量维度大小
    :param d_ff: feed forward层的隐藏层大小
    :param h: 注意力头的个数
    :param dropout:
    :return:
    """
    c = copy.deepcopy
    attn = MultiHeadAttention(h, d_model)
    ff = PositionWiseFeedForward(d_model, d_ff, dropout)
    position = PositionEncoding(d_model, dropout)
    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, src_vocab), c(position)),
        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),
        Generator(d_model, tgt_vocab)
    )

    # This was important from their code.
    # Initialize parameters with Glorot / fan_avg
    for p in model.parameters():
        if p.dim() > 1:
            nn.init.xavier_normal_(p)
    return model


# Small example model
# tmp_model = make_model(10, 10, 2)

4 训练

本节介绍模型的训练方法。

快速穿插介绍训练标准编码器解码器模型需要的一些工具。首先我们定义一个包含源和目标句子的批训练对象用于训练，同时构造掩码。

批和掩码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Batch:
    """object for holding a batch of data with mask during training"""
    def __init__(self, src, trg=None, pad=0):
        self.src = src
        # src的size为(30, 10),unsqueeze(-2)在倒数第二维，即第1维上增加1维，变成(30, 1, 10)
        self.src_mask = (src != pad).unsqueeze(-2)  # src_mask对句子本身不会遮蔽，只会屏蔽句子末尾之后的
        if trg is not None:
            self.trg = trg[:, :-1]  # 最后一个不取
            self.trg_y = trg[:, 1:]  # 第一个不取
            self.trg_mask = self.make_std_mask(self.trg, pad)  # trg_mask用于遮蔽的多头注意力
            # 这里统计数量最好加上item()方法获取纯数字，否则后面计算总是张量(原文未加)
            self.n_tokens = (self.trg_y != pad).data.sum()

    @staticmethod
    def make_std_mask(tgt, pad):
        """ Create a mask to hide padding and future words """
        # tgt_mask的size为(30, 1 ,9)
        tgt_mask = (tgt != pad).unsqueeze(-2)
        # subsequent_mask(x)，返回size为(x, x)的masked tensor
        # (1, x) & (x, x) --> (x, x)，前面的张量与后面张量的每一行进行"与"运算
        tgt_mask = tgt_mask & Variable(
            subsequent_mask((tgt.size(-1))).type_as(tgt_mask.data)
        )
        return tgt_mask

接下来，我们创建一个通用的训练和得分函数来跟踪损失。我们传入一个通用的损失计算函数，它也处理参数更新。

训练循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def run_epoch(data_iter, model, loss_compute):
    """Standard Training and Logging Function"""
    start = time.time()
    total_loss = 0
    total_tokens = 0
    tokens = 0
    for i, batch in enumerate(data_iter):
        out = model.forward(batch.src, batch.trg, batch.src_mask, batch.trg_mask)
        loss = loss_compute(out, batch.trg_y, batch.n_tokens)
        total_loss += loss
        total_tokens += batch.n_tokens
        tokens += batch.n_tokens
        if i % 50 == 1:
            elapsed = time.time() - start
            print("Epoch Step: %d Loss: %f Tokens per Sec: %f" %
                  (i, loss / batch.n_tokens, tokens /elapsed))
            start = time.time()
            tokens = 0
    return total_loss / total_tokens

优化器

注意：这部分非常重要，需要这种设置训练模型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class NoamOpt:
    """Optim wrapper that implements rate."""

    def __init__(self, model_size, factor, warmup, optimizer):
        self.optimizer = optimizer
        self._step = 0
        self.warmup = warmup
        self.factor = factor
        self.model_size = model_size
        self._rate = 0

    def step(self):
        """Update parameters and rate"""
        self._step += 1
        rate = self.rate()
        for p in self.optimizer.param_groups:
            p['lr'] = rate
        self._rate = rate
        self.optimizer.step()

    def rate(self, step=None):
        """更新学习率，在预热中随步数线性地增加学习速率，并且此后与步数的反平方根成比例地减小它。"""
        if step is None:
            step = self._step
        return self.factor * \
            (self.model_size ** (-0.5) *
             min(step ** (-0.5), step * self.warmup ** (-1.5)))


def get_std_opt(model):  # 初始化示例
    return NoamOpt(model.src_embed[0].d_model, 2, 4000,
                   torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

当前模型学习率在不同模型大小和超参数的情况下的曲线示例。

1
2
3
4
5
6
opts = [NoamOpt(512, 1, 4000, None),
        NoamOpt(512, 1, 8000, None),
        NoamOpt(256, 1, 4000, None)]
plt.plot(np.arange(1, 20000), [[opt.rate(i) for opt in opts] for i in range(1, 20000)])
plt.legend(["512:4000", "512:8000", "256:4000"])
plt.show()

正则化&标签平滑

在训练期间，我们采用了平滑值为0.1[2]的标签平滑。 这种做法提高了困惑度，因为模型变得更加不确定，但提高了准确性和BLEU分数。

我们使用KL div loss实现标签平滑。 相比使用独热目标分布，我们创建一个分布，其包含正确单词的置信度和整个词汇表中分布的其余平滑项。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class LabelSmoothing(nn.Module):
    """
    Implement label smoothing.
    https://blog.csdn.net/CHN_ZHero/article/details/107882568（标签平滑的作用）
    它将神经网络的训练目标从“1”调整为“1-label smoothing adjustment”
    对于二分类猫/狗示例，0.1的标签平滑意味着目标答案将是0.90(90%确信)这是一个狗的图像，而0.10(10%确信)这是一只猫
    """

    def __init__(self, size, padding_idx, smoothing=0.0):
        super(LabelSmoothing, self).__init__()
        self.criterion = nn.KLDivLoss(reduction='sum')  # size_average=None，该参数已弃用，等价于reduction=sum
        self.padding_idx = padding_idx
        self.confidence = 1.0 - smoothing  # 置信度为1-smoothing
        self.smoothing = smoothing
        self.size = size
        self.true_dist = None

    def forward(self, x, target):
        assert x.size(1) == self.size  # x的size为(batches, d_model)
        true_dist = x.data.clone()  # true_dist与x的形状相同（其实用torch.full_like更好吧？）
        true_dist.fill_(self.smoothing / (self.size - 2))  # 使用一个给定的值，原地填充张量
        # target的size为(batches,),unsqueeze(1)变成(batches, 1)
        # dim=1，按行填充，将confidence的值根据target.data.unsqueeze(1)的位置填充到true_dist中
        # 其实这里相当于根据标签将每条数据标签为1的位置在true_dist填充上confidence(如果没有标签平滑的话，本来应该是1)
        # 假设target[2, 1, 0]，即相当于在true_dist的(0, 2)、(1, 1)、(2, 0)位置填充上confidence
        target = target.type(torch.int64)  # scatter方法要求索引的数据类型是int64（在下面的测试例子中，定义的target使用的是torch.LongTensor），这里加上这行代码主要是为实际使用准备的
        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)
        true_dist[:, self.padding_idx] = 0  # 填充索引置0
        # torch.nonzero返回张量中非0元素的索引
        mask = torch.nonzero(target.data == self.padding_idx)
        if mask.dim() > 0:
            # 通过按index中给定的顺序 选择索引，用value值填充元素,dim=0按行填充
            true_dist.index_fill_(dim=0, index=mask.squeeze(), value=0.0)
        self.true_dist = true_dist  # 平滑后的标签
        # 计算x和平滑后的标签的损失
        return self.criterion(x, Variable(true_dist, requires_grad=False))

这里标签平滑时的赋值方法：这里假定size个值中有一个为padding值（赋值0），然后还有一个值是真值（赋值confidence），剩下的值的和为1-confidence的，即每个值为smoothing/(size-2)，所有值的加和为1。

在这里，我们可以看到标签平滑的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Example of label smoothing.
crit = LabelSmoothing(5, 0, 0.4)
predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],
                             [0, 0.2, 0.7, 0.1, 0], 
                             [0, 0.2, 0.7, 0.1, 0]])
v = crit(Variable(predict.log()), 
         Variable(torch.LongTensor([2, 1, 0])))

# Show the target distributions expected by the system.
plt.imshow(crit.true_dist)

# true_dist是标签平滑后的标签张量（类似ont-hot编码）
tensor([[0.0000, 0.1333, 0.6000, 0.1333, 0.1333],
        [0.0000, 0.6000, 0.1333, 0.1333, 0.1333],
        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000]])

如果对给定的选择非常有信心，标签平滑实际上会开始惩罚模型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
crit = LabelSmoothing(5, 0, 0.1)


def loss(x):
    d = x + 3 * 1
    predict = torch.FloatTensor([[0, x / d, 1 / d, 1 / d, 1 / d],
                                 ])
    # print(predict)
    tensor_logs = Variable(predict.log())   # 获取predict的自然对数张量
    # 获取张量中的单个值，使用item()方法，原文中的.data[0]在新版本pytorch会报错
    return crit(tensor_logs, Variable(torch.LongTensor([1]))).item()


plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)])
plt.show()

这里惩罚的含义是指啥？没有太搞明白。

当x=1时，d=4，predict = [[0.0000, 0.2500, 0.2500, 0.2500, 0.2500]]

取完对数之后，tensor_logs = [[ -inf, -1.3863, -1.3863, -1.3863, -1.3863]]

根据指定标签（torch.LongTensor([1])）标签平滑后的true_dist为：

tensor([[0.0000, 0.9000, 0.0333, 0.0333, 0.0333]])

计算tensor_logs和true_dist之间的损失值为：0.9514

当x=2时，d=5，predict = [[0.0000, 0.4000, 0.2000, 0.2000, 0.2000]]

取完对数之后，tensor_logs = [[ -inf, -0.9163, -1.6094, -1.6094, -1.6094]]

标签平滑后的true_dist依然为：[[0.0000, 0.9000, 0.0333, 0.0333, 0.0333]]

实际上只要置信度和标签索引保持不变，true_dist也不会改变

计算tensor_logs和true_dist之间的损失值为：0.5507

当x=97时，d=100，predict = [[0.0000, 0.9700, 0.0100, 0.0100, 0.0100]]

tensor_logs = [[ -inf, -0.0305, -4.6052, -4.6052, -4.6052]]

5 第一个例子

数据生成

1
2
3
4
5
6
7
8
def data_gen(v, batch, nbatches):
    """Generate random data for a src-tgt copy task."""
    for i in range(nbatches):
        data = torch.from_numpy(np.random.randint(1, v, size=(batch, 10)))
        data[:, 0] = 1  # 第1列全部设置为1
        src = Variable(data, requires_grad=False)
        tgt = Variable(data, requires_grad=False)
        yield Batch(src, tgt, 0)

损失计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class SimpleLossCompute:
    """A simple loss compute and train function."""

    def __init__(self, generator, criterion, opt=None):
        self.generator = generator
        self.criterion = criterion
        self.opt = opt

    def __call__(self, x, y, norm):
        x = self.generator(x)
        loss = self.criterion(x.contiguous().view(-1, x.size(-1)),
                              y.contiguous().view(-1)) / norm
        loss.backward()
        if self.opt is not None:
            self.opt.step()
            self.opt.optimizer.zero_grad()
        return loss.item() * norm

贪心解码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# Train the simple copy task.
V = 11  # 词表大小和d_model大小都为V
criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)
model = make_model(V, V, n=2)
model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400,
                    torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

for epoch in range(10):
    model.train()
    run_epoch(data_gen(V, 30, 20), model,
              SimpleLossCompute(model.generator, criterion, model_opt))
    model.eval()
    print(run_epoch(data_gen(V, 30, 5), model,
                    SimpleLossCompute(model.generator, criterion, None)))

Epoch Step: 1 Loss: 3.093280 Tokens per Sec: 586.531329
Epoch Step: 1 Loss: 1.909485 Tokens per Sec: 726.383072
1.9016295194625854
Epoch Step: 1 Loss: 2.051487 Tokens per Sec: 529.809671
Epoch Step: 1 Loss: 1.770531 Tokens per Sec: 788.795373
1.7408317565917968
Epoch Step: 1 Loss: 1.886601 Tokens per Sec: 559.833957
Epoch Step: 1 Loss: 1.562290 Tokens per Sec: 897.339057
1.5470689296722413
Epoch Step: 1 Loss: 1.643023 Tokens per Sec: 493.011445
Epoch Step: 1 Loss: 1.215616 Tokens per Sec: 836.769805
1.224960947036743
Epoch Step: 1 Loss: 1.396876 Tokens per Sec: 533.890868
Epoch Step: 1 Loss: 1.098019 Tokens per Sec: 571.227568
1.0235745310783386
Epoch Step: 1 Loss: 1.045339 Tokens per Sec: 573.525423
Epoch Step: 1 Loss: 0.665492 Tokens per Sec: 858.416481
0.7300141215324402
Epoch Step: 1 Loss: 0.818934 Tokens per Sec: 602.079293
Epoch Step: 1 Loss: 0.367751 Tokens per Sec: 878.871592
0.3765665054321289
Epoch Step: 1 Loss: 0.528306 Tokens per Sec: 614.649768
Epoch Step: 1 Loss: 0.305647 Tokens per Sec: 913.799832
0.2516491383314133
Epoch Step: 1 Loss: 0.391734 Tokens per Sec: 603.356469
Epoch Step: 1 Loss: 0.289562 Tokens per Sec: 839.062486
0.284069687128067
Epoch Step: 1 Loss: 0.409052 Tokens per Sec: 544.839550
Epoch Step: 1 Loss: 0.134216 Tokens per Sec: 893.862476
0.16299704611301422

这里面的训练输入值x(src)为1~11之间的随机整数，size为（30, 10），但是随后将每一行的第1维都置为了1（推测是一种特殊标志，即非训练数据的表示）；训练标签y(trg_y)相比x仅是size有所改变，为(30, 9)，其与输入x相对应，剔除掉了每一行的第1维；同样还有一个训练标签trg，其作为输入经过decoder（有masked多头注意力），其损失对比的是模型的输出out和trg_y之间的损失。

到这里好像才刚理解，原来decoder的输入是标签值，但是这里的trg剔除了每一行的最后一维（不太理解为啥），size也是(30, 9)。在第二个遮蔽的多头注意力时，才开始使用encoder输出的memory值。

因为这里的输入x和输出y是相同的值，所以此次训练的任务是一个复制任务。

为简单起见，此代码使用贪心解码来预测翻译。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def greed_decode(model, src, src_mask, max_len, start_symbol):
    memory = model.encode(src, src_mask)
    # ys保存预测结果，一开始只有1个标志位1，size为(1,1)
    ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data)
    for i in range(max_len-1):
        # 输出out的size为(1, ys.size(1), 512)，这里ys是不断增加的，之后每次输入到decoder中，自回归（每一个输出将先前的输出作为附加输入）
        out = model.decode(memory, src_mask, Variable(ys),
                           Variable(subsequent_mask(ys.size(1)).type_as(src.data)))
        # 使用线性层+softmax计算概率（每次取out第2维的最后一个元素，代表当前输出）
        prob = model.generator(out[:, -1])
        _, next_word = torch.max(prob, dim=1)
        next_word = next_word.data[0]
        ys = torch.cat([ys, torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1)
    return ys


model.eval()
# 输入是 (batch, x)，x是1~10的数字（按照我的理解第0维的数字1其实是标志位）
src = Variable(torch.LongTensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]))
# 输入x的遮蔽，其size相比x是在第1维增加一维，因为x在经过embedding层后会增加一维
src_mask = Variable(torch.ones(1, 1, 10))
print(greed_decode(model, src, src_mask, max_len=10, start_symbol=1))

tensor([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10]])