Transformer实战

引言：Transformer自从2017年提出到现在，已经被广泛应用于NLP各项任务中，尤其是NMT，取得的效果最明显。前面讲了Transformer模型，下面就来介绍一下Transformer实战。已经有很多大神写了Transformer的各种实现，本文参考的是哈佛大学2018年4月的一个实现版本。与以往纯翻译的博客不同，本文侧重整体结构+细节分析，并附上了很多模型局部图以及类的依赖关系图，解释的更加全面和详细。

对于深度学习模型的学习，我个人采用的模式是 论文 + 图 + 公式 + 代码，四者互相参照，即可彻底搞清楚每个细节，以及每个模块的交互方式。就像数学里有句话，“数缺形时少直观，形少数时难入微”，数就是代码，形就是模型图。

运行环境

• Pytorch : 1.1.0
• Python: 3.7

由于harvardnlp这个Transformer的实现版本是基于PyTorch0.3.0的，跑起来会有很多坑，我都列出来了（在遇到的问题标题下）。以下贴出来的代码都是基于PyTorch 1.0及以上的版本。如果不想再踩一遍这些坑，就直接用我的代码吧。

依赖的包

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

模型架构

首先上一个Transformer的模型图：

代码整体架构图：

Encoder-Decoder

由宏观到微观，整体上就是一个Encoder-Decoder的架构，两个Embedding层。

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
        self.tgt_embed = tgt_embed
        self.generator = generator

    def forward(self, src, tgt, src_mask, tgt_mask):
        """Take in and process masked src and target sequences."""
        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):
        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)

以上就是Encoder-Decoder部分了，可以从上图看到，模型最上面还有一个线性连接层和softmax层。

于是还需要一部分模块完成概率归一化输出最终预测结果，命名为Generator。

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):
        # 将最后一个维度进行softmax
        return F.log_softmax(self.proj(x), dim=-1)

Stacks

在Encoder和Decoder内部，都是用N=6个一模一样的层堆叠而成，如图：

Encoder

每个Encoder由6个相同结构的EncoderLayer组成。

def clones(module, N):
    """克隆出N个完全一样的Module"""
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class Encoder(nn.Module):
    """核心Encoder是由N层堆叠而成"""

    def __init__(self, layer, N):
        super(Encoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)

    def forward(self, x, mask):
        """
        将输入x和掩码mask逐层传递下去，
        最后再 LayerNorm 一下。
        """
        for layer in self.layers:
            x = layer(x, mask)
        return self.norm(x)

EncoderLayer

对于每个EncoderLayer来说，内部有两个SublayerConnection。
EncoderLayer代码，可以看到在forward方法里，先进行了self-attention运算 ，再进行了feed-forwad，都使用的SublayerConnection模块计算，只是函数$F(x)$不一样而已。

class EncoderLayer(nn.Module):

    def __init__(self, size, self_attn, feed_forward, dropout):
        super(EncoderLayer, self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 2)

    def forward(self, x, mask):
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
        return self.sublayer[1](x, self.feed_forward)

SublayerConnection

SublayerConnection内部设计基于两个核心：

• 1. 残差连接（Residual connection）
• 2. 层级归一化（Layer normalize）

这两个点，分别对应Transformer模型图里的 Add 和 Norm。

残差连接（Residual connection）

残差连接详细介绍，参考https://juejin.im/post/5b9f1af0e51d450e425eb32d#heading-10

如下图所示，就是在原来正常的结构上添加一条“捷径”x，这样做的好处就是：反向传播时，对x求偏导会多一个常数1，梯度连乘，不会造成梯度消失。

为了适用这些残差连接，所有的 子层(Sublayer)以及嵌入层(Embedding)的维度 $d_{model}$=512。

class SublayerConnection(nn.Module):
    """残差连接"""

    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))

层级归一化（Layer normalize）

LayerNorm的详细介绍 参考 https://juejin.im/post/5b9f1af0e51d450e425eb32d#heading-11。

模型里这一层的作用可以概括为：就是把输入转化成均值为0方差为1的数据。我们在把数据送入激活函数之前进行normalization（归一化），因为我们不希望输入数据落在激活函数的饱和区。

公式表述就是：
$$LN\left(x_i\right)=\alpha \times \frac{x_i-u_L}{\sqrt{{\sigma }_L^2+ϵ}}+\beta$$

class LayerNorm(nn.Module):
    """构建一个 layernorm层，具体细节看论文 https://arxiv.org/abs/1607.06450"""

    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        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

Decoder

Decoder也是由N=6个相同结构的DecoderLayer 组成。

Decoder构造函数和Encoder一样，forward接收的参数比Encoder多了Encoder生成的memory以及目标句子的掩码tgt_mask。大体计算逻辑和Encoder基本一致，只是参数多了两个。

class Decoder(nn.Module):

    def __init__(self, layer, N):
        super(Decoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)

    def forward(self, x, memory, src_mask, tgt_mask):
        for layer in self.layers:
            x = layer(x, memory, src_mask, tgt_mask)
        return self.norm(x)

DecoderLayer

再来看一看DecoderLayer，由3个SublayerConnection构成。比EncoderLayer在构造函数上多了一个src_attn(即源语言句子的attention)。可以看到在forward方法里，先进行了self-attention运算 ，再进行了与Encoder的Attention进行运算，最后再feed-forwad。

class DecoderLayer(nn.Module):

    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        super(DecoderLayer, self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 3)

    def forward(self, x, memory, src_mask, tgt_mask):
        m = memory
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
        return self.sublayer[2](x, self.feed_forward)

Mask

https://jalammar.github.io/images/t/transformer_decoding_2.gif
这个动图上传不上来，只能补一个链接了。

从以上动图可以看出，Decoder是自回归(step by step)的方式生成目标句子的。对于神经机器翻译(NMT)训练来说，采用的监督学习，也就意味着原句子和目标句子都是喂给模型的。那就需要保证，Decoder在生成当前单词的时候，不能看到后面的单词（以上面的例子来说，在翻译 a 的时候，不能看到student以及后面的单词）。这就好比，老师让学生做试卷，不能同时把答案也给他，都有答案了还考个毛线，正确的做法是学生做完后给出答案让他去对比，看看自己哪儿做错了。

为了不让Decoder看到未来的信息，便引出了掩码的概念，其实很简单，代码如下。

def subsequent_mask(size):
    """
    这个掩码是Decoder用到的tgt_mask，因为Decoder不允许看到未来的信息。
    例子：
    print(subsequent_mask(3))
    tensor([[[1, 0, 0],
             [1, 1, 0],
             [1, 1, 1]]], dtype=torch.uint8)

    """
    attn_shape = (1, size, size)
    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
    return torch.from_numpy(subsequent_mask) == 0

Attention

这是整个模型最重要的创新点，Self-Attention，Multi-Head Attention。

Self-Attention

假设下面的句子就是我们需要翻译的输入句：

”The animal didn’t cross the street because it was too tired”

这句话中的"it"指的是什么？它指的是“animal”还是“street”？对于人来说，这其实是一个很简单的问题，但是对于一个算法来说，处理这个问题其实并不容易。Self-Attention的出现就是为了解决这个问题，通过Self-Attention，我们能将“it”与“animal”联系起来。

Self-Attention的本质，简单的来说，就是句子里每个单词受其他单词的影响程度，可以学到语义依赖关系。

在Transformer中，Self-Attention在Encoder、Decoder内部都有应用。

Self-Attention的计算公式如下，除以$\sqrt{d_k}$是为了进行缩放，这里就不介绍了。
$$(Q,K,V)=\mathrm{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
公式不好理解，来张图：

如图所示：

再看代码就明了多了：

def attention(query, key, value, mask=None, dropout=None):
    """Compute 'Scaled Dot Product Attention"""
    d_k = query.size(-1)
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
    if mask:
        # -1e9 是-INF的意思吗？？？还是说近似于0的数值？？？
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim=-1)
    if dropout:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value)

多头计算只是多个Self-Attention并行计算的形式而已。

Multi-Head Attention

多个Self-Attention并行计算就叫多头计算（Multi-Head Attention）模式，这就是Transformer训练速度超快的原因。

多头计算换一种理解，就是可以把它理解为一个集成学习方法。

一个512维的向量，经过8组独立$W^Q$，$W^K$，$W^V$，得到了8组维度为64的$Q、K、V$向量。
$$W_i^Q\in {\mathbb{R}}^{d_{\text{ model }}\times d_k},W_i^K\in {\mathbb{R}}^{d_{\text{ model }}\times d_k},W_i^V\in {\mathbb{R}}^{d_{\text{ model }}\times d_v},W^O\in {\mathbb{R}}^{h{d}_v\times d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}$$

$$\begin{gathered} d_{model}=512 \\ {d}_k=d_v=64 \\ h=8 \end{gathered}$$

8组并行计算Self-Attention的过程就是Multi-Head Attention计算，得到8组维度为64的向量$Z$，然后综合8组$Z$进行变换得到最终的向量$Z$，维度也由原来的8个 $n\times 64$ 变成 $n\times 512$ 。

有趣的是：

$$\frac{512}{8}=64$$

这不就是集成学习的套路吗？以分类任务为例，训练数据有512个特征，现训练8个独立的分类器，每个从数据中随机抽取64个特征训练，得到各自分类结果，最后再综合决策，得到最终分类结果。

class MultiHeadedAttention(nn.Module):

    def __init__(self, h, d_model, dropout=0.1):
        super(MultiHeadedAttention, self).__init__()
        # d_model 必须要被 h 整除
        assert d_model % h == 0
        self.d_k = d_model // h
        self.h = h
        self.dropout = nn.Dropout(p=dropout)
        # Q K V 三个权重，最后合并Z，还有一个线性连接层，所以4个
        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None

    def forward(self, query, key, value, mask=None):
        # 由于self-attention的q, k, v 都是有x经过线性变换得到的，
        # 所以调用forward的时候，传递的参数就是 (x, x, x, mask)
        if mask:
            # 若原来mask的维度是[n, n]，经过unsqueeze后会变成[n, 1, n]
            # 为何要如此操作？？？
            mask = mask.unsqueeze(1)
        # q, k, v 第一个维度是batch
        # 那就是说 q, k, v 是 [n, 64]???
        nbatches = query.size(0)
        # 真正的q,k,v是这一步计算出来的
        # 中间-1那个维度是干嘛的？？？？
        # n  h   d_k  这三个维度是确定的， 还有一个维度是干嘛 的？？？
        query, key, value = [
            l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
            for l, x in zip(self.linears, (query, key, value))
        ]
        # attention 计算得到一堆z
        x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)
        # 将8个z拼接, 变换形态 n x ? x 512 !!!
        x = x.transpose(1, 2).contiguous().view(nbatches, -1, self.h * self.d_k)
        # 得到最终的z
        return self.linears[-1](x)

Position-wise Feed-Forward Networks

上图中很多模型中都有Feed Forward，用的都是如下的结构，只是各自参数独立，两个线性变换，一个Relu非线性函数，一个dropout。先上图，再摆公式，最后代码，是不是非常清晰明了了。

$$\mathrm{FFN}(x)=\max \left(0,x{W}_1+b_1\right)W_2+b_2$$

class PositionwiseFeedForward(nn.Module):

    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))))

Embeddings and Softmax

这个没多少说的，有点不太明白的地方就是—为什么要乘以$\sqrt{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}$？？？

class Embeddings(nn.Module):

    def __init__(self, d_model, 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)

Positional Encoding

我们可能忽略了去介绍一个重要的内容，就是怎么考虑输入序列中单词顺序的方法。
为了解决这个问题，transformer为每个输入单词的词嵌入上添加了一个新向量-位置向量。

为了让模型捕捉到单词的顺序信息，我们添加位置编码向量信息（POSITIONAL ENCODING）-位置编码向量不需要训练，它有一个规则的产生方式。

如果我们的嵌入维度为4，那么实际上的位置编码就如下图所示：

那么生成位置向量需要遵循怎样的规则呢？

观察下面的图形，每一行都代表着对一个矢量的位置编码。因此第一行就是我们输入序列中第一个字的嵌入向量，每行都包含512个值，每个值介于1和-1之间。我们用颜色来表示1，-1之间的值，这样方便可视化的方式表现出来：

$$\begin{array}{rl}P{E}_{(\text{pos},2i)}& =\sin \left(\text{pos}/10000^{2i/d_{\text{ model }}}\right)\\ P{E}_{(\text{pos},2i+1)}& =\cos \left(\text{pos}/10000^{2i/d_{\text{ model }}}\right)\end{array}$$

对于上述公式，代码中进行了对数变换，很容易推导的。

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(dropout)
        # pe 初始化为0，shape为 [n, d_model] 的矩阵，用来存放最终的PositionalEncoding的
        pe = torch.zeros(max_len, d_model)
        # position 表示位置，shape为 [max_len, 1]，从0开始到 max_len
        position = torch.arange(0., max_len).unsqueeze(1)
        # 这个是变形得到的，shape 为 [1, d_model//2]
        div_term = torch.exp(torch.arange(0., d_model, 2) * -(math.log(10000.0) / d_model))
        # 矩阵相乘 (max_len, 1) 与 (1, d_model // 2) 相乘，最后结果 shape   (max_len, d_model // 2)
        # 即所有行，一半的列。（行为句子的长度，列为向量的维度）
        boy = position * div_term
        # 偶数列  奇数列 分别赋值
        pe[:, 0::2] = torch.sin(boy)
        pe[:, 1::2] = torch.cos(boy)
        # 为何还要在前面加一维？？？
        pe = pe.unsqueeze(0)
        # Parameter 会在反向传播时更新
        # Buffer不会，是固定的，本文就是不想让其被修改
        self.register_buffer('pe', pe)

    def forward(self, x):
        # x能和后面的相加说明shape是一致的，也是 (1, sentence_len, d_model)
        # forward 其实就是，将原来的Embedding 再加上 Positional Embedding
        x += Variable(self.pe[:, :x.size(1)], requires_grad=False)
        return self.dropout(x)

拼装模型

把Transformer这个轮子一块一块地拆开了，研究透了，现在我们再把它组装起来。

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."
    c = copy.deepcopy
    attn = MultiHeadedAttention(h, d_model)
    ff = PositionwiseFeedForward(d_model, d_ff, dropout)
    position = PositionalEncoding(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_uniform_(p)
    return model

模型训练

遇到的问题及解决方案

1、RuntimeError: exp_vml_cpu not implemented for ‘Long’。

解决方案：将如下代码：

position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))

改为：

position = torch.arange(0., max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0., d_model, 2) * -(math.log(10000.0) / d_model))

Thanks stackoverflow.

2、IndexError: invalid index of a 0-dim tensor. Use tensor.item() to convert a 0-dim tensor to a Python number。很多关于loss的地方，代码都做了改动。

解决方案：将

return crit(Variable(predict.log()), Variable(torch.LongTensor([1]))).data[0]

改为

return crit(Variable(predict.log()), Variable(torch.LongTensor([1]))).item()

其他的也是这么改

Thanks for github issues

3、运行到 Greedy Decoding，jupyter notebook 的 kernel就挂掉了。是run_epoch的问题，后面有解决方案。

解决方案：

出错的代码是这段：

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)))

这段是个例子，注释掉就行。

4、OSError: [E050] Can’t find model ‘de’. It doesn’t seem to be a shortcut link, a Python package or a valid path to a data directory.

解决方案：在命令行执行如下命令，先下载对应的资源。需要等几分钟。

python -m spacy download de
python -m spacy download en

5、de-en，德英文件下载很慢，还报错。

解决方案：我用IDM（一个多线程下载器，很快）在本地下载好了，然后上传到服务器。一共23MB。

下载地址是：https://wit3.fbk.eu/archive/2016-01//texts/de/en/de-en.tgz

自己下载也行。

上传到项目路径下的 .data/iwslt下面即可。

6、The device argument should be set by using torch.device or passing a string as an argument. This behavior will be deprecated soon and currently defaults to cpu.

解决方案：将model_par = nn.DataParallel(model, device_ids=devices)改为model_par = nn.DataParallel(model)。默认使用全部显卡。

7、又缺少文件。FileNotFoundError: [Errno 2] No such file or directory: ‘iwslt.pt’

解决方案：下载呗。https://s3.amazonaws.com/opennmt-models/iwslt.pt

8、loss 均为整数。

解决方案：将norm转为float再进行乘法运算：

return loss.item() * norm.float()

9、 run_epoch有大问题，跑着跑着，就崩了。全部改一下，复制下面的就好了。

def run_epoch(data_iter, model, loss_compute, epoch = 0):
    "Standard Training and Logging Function"
    start = time.time()
    total_tokens = 0
    total_loss = 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.ntokens)

        total_loss += loss.detach().cpu().numpy()
        total_tokens += batch.ntokens.cpu().numpy()
        tokens += batch.ntokens.cpu().numpy()
        if i % 50 == 1:
            elapsed = time.time() - start
            print("Epoch Step: %d Loss: %f Tokens per Sec: %f" % (i, loss.detach().cpu().numpy() / batch.ntokens.cpu().numpy(), tokens / elapsed))
            start = time.time()
            tokens = 0
    return total_loss / total_tokens

10、RuntimeError: Expected object of backend CUDA but got backend CPU for argument #3 ‘index’。

解决方案：将如下代码

src = batch.src.transpose(0, 1)[:1]
src_mask = (src != SRC.vocab.stoi[""]).unsqueeze(-2)

改为：

src = batch.src.transpose(0, 1)[:1].cuda()
src_mask = (src != SRC.vocab.stoi[""]).unsqueeze(-2).cuda()

总结

参考链接

• github: https://github.com/harvardnlp/annotated-transformer
• blog: http://nlp.seas.harvard.edu/2018/04/03/attention.html
• 采坑记录：https://www.cnblogs.com/shiyublog/p/10909009.html
• 图解Transformer: https://blog.csdn.net/qq_41664845/article/details/84969266
• https://juejin.im/post/5b9f1af0e51d450e425eb32d