            <p><img src="output_0_0.png" alt="png"></p>

“Attention is All You Need”[1]一文中提出的Transformer网络结构最近引起了很多人的关注。Transformer不仅能够明显地提升翻译质量，还为许多NLP任务提供了新的结构。虽然原文写的很清楚，但实际上大家普遍反映很难正确地实现。

所以我们为此文章写了篇注解文档，并给出了一行行实现的Transformer的代码。本文档删除了原文的一些章节并进行了重新排序，并在整个文章中加入了相应的注解。此外，本文档以Jupyter notebook的形式完成，本身就是直接可以运行的代码实现，总共有400行库代码，在4个GPU上每秒可以处理27,000个tokens。

想要运行此工作，首先需要安装PyTorch[2]。这篇文档完整的notebook文件及依赖可在github[3]或 Google Colab[4]上找到。

需要注意的是，此注解文档和代码仅作为研究人员和开发者的入门版教程。这里提供的代码主要依赖OpenNMT[5]实现，想了解更多关于此模型的其他实现版本可以查看Tensor2Tensor[6] （tensorflow版本）和 Sockeye[7]（mxnet版本）。

Alexander Rush (@harvardnlp[8] or srush@seas.harvard.edu)

准备工作

1	# !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn

12345678910

import numpy as npimport torchimport torch.nn as nnimport torch.nn.functional as Fimport math, copy, timefrom torch.autograd import Variableimport matplotlib.pyplot as pltimport seabornseaborn.set_context(context="talk")%matplotlib inline

内容目录

本文注解部分都是以引用的形式给出的，主要内容都是来自原文。

背景

减少序列处理问题的计算量是一个很重要的问题，也是Extended Neural GPU，ByteNet和ConvS2S等网络的动机。上面提到的这些网络都以CNN为基础，并行计算所有输入和输出位置的隐藏表示。在这些模型中，关联来自两个任意输入或输出位置的信号所需的操作数随位置间的距离增长而增长，比如ConvS2S呈线性增长，ByteNet呈线以对数形式增长，这会使学习较远距离的两个位置之间的依赖关系变得更加困难。而在Transformer中，操作次数则被减少到了常数级别。

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

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

模型结构

目前大部分比较热门的神经序列转换模型都有encoder-decoder结构[9]。Encoder将输入序列$(x_1, …, x_n)$ 映射到一个连续表示序列 $\mathbf{z} = (z_1, …, z_n)$。对于编码得到的$\mathbf{z}$，decoder每次解码生成一个符号，直到生成完整的输出序列：$(y_1,…,y_m)$。对于每一步解码，模型都是自回归的[10]，即在生成下一个符号时将先前生成的符号作为附加输入。

1234567891011121314151617181920212223

class EncoderDecoder(nn.Module):"""A standard Encoder-Decoder architecture. Base for this and manyother models."""def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):super(EncoderDecoder, self).__init__()self.encoder = encoderself.decoder = decoderself.src_embed = src_embedself.tgt_embed = tgt_embedself.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)

12345678

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的整体结构如下图所示，在encoder和decoder中都使用了self-attention, point-wise和全连接层。Encoder和decoder的大致结构分别如下图的左半部分和右半部分所示。

png

Encoder和Decoder

Encoder

Encoder由N=6个相同的层组成。

123	def clones(module, N):"Produce N identical layers."return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

123456789101112

class Encoder(nn.Module):"Core encoder is a stack of N layers"def __init__(self, layer, N):super(Encoder, self).__init__()self.layers = clones(layer, N)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:x = layer(x, mask)return self.norm(x)

我们在每两个子层之间都使用了直连层(residual connection) [11]和归一化层 [12]。

123456789101112

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

也就是说，每个子层的输出为 $\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))$，其中 $\mathrm{Sublayer}(x)$ 是由子层自动实现的函数。我们在每个子层的输出上使用dropout，然后将其添加到下一子层的输入并进行规范化。
为了能方便地使用这些直连边，模型中所有的子层和embedding层的输出都设定成了相同的维度，即$d_{\text{model}}=512$。

12345678910111213

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)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的全连接前馈网络。

12345678910111213

class EncoderLayer(nn.Module):"Encoder is made up of self-attn and feed forward (defined below)"def __init__(self, size, self_attn, feed_forward, dropout):super(EncoderLayer, self).__init__()self.self_attn = self_attnself.feed_forward = feed_forwardself.sublayer = clones(SublayerConnection(size, dropout), 2)self.size = size

def forward(self, x, mask):"Follow Figure 1 (left) for connections."x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))return self.sublayer[1](x, self.feed_forward)

Decoder

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

1234567891011

class Decoder(nn.Module):"Generic N layer decoder with masking."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)

除了每个编码器层中的两个子层之外，解码器还插入了第三种子层对编码器栈的输出实行“多头”的attention。与编码器类似，我们在每个子层两端使用residual connection进行短路，然后进行层的规范化处理。

12345678910111213141516

class DecoderLayer(nn.Module):"Decoder is made of self-attn, src-attn, and feed forward (defined below)"def __init__(self, size, self_attn, src_attn, feed_forward, dropout):super(DecoderLayer, self).__init__()self.size = sizeself.self_attn = self_attnself.src_attn = src_attnself.feed_forward = feed_forwardself.sublayer = clones(SublayerConnection(size, dropout), 3)

def forward(self, x, memory, src_mask, tgt_mask):"Follow Figure 1 (right) for connections."m = memoryx = 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)

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

def subsequent_mask(size):"Mask out subsequent positions."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 mask图显示了允许每个目标词（行）查看的位置（列）。在训练期间，当前解码位置的词不能attend到后续位置的词。

123	plt.figure(figsize=(5,5))plt.imshow(subsequent_mask(20)[0])None

png

Attention

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

我们称这种特殊的attention机制为"Scaled Dot-Product Attention"。输入包含维度为$d_k$的query和key，以及维度为$d_v$的value。我们首先分别计算query与各个key的点积，然后将每个点积除以$\sqrt{d_k}$，最后使用softmax函数来获得key的权重。

png

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

$$
\mathrm{Attention}(Q, K, V) = \mathrm{softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

1234567891011

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 is not None: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 [13]和点积（乘积）attention，我们的算法与点积attention很类似，但是 $\frac{1}{\sqrt{d_k}}$ 的比例因子不同。加和attention使用具有单个隐藏层的前馈网络来计算兼容函数。虽然两种方法理论上的复杂度是相似的，但在实践中，点积attention的运算会更快一些，也更节省空间，因为它可以使用高效的矩阵乘法算法来实现。

虽然对于较小的$d_k$，这两种机制的表现相似，但在不放缩较大的$d_k$时，加和attention要优于点积attention [14]。我们怀疑，对于较大的$d_k$，点积大幅增大，将softmax函数推向具有极小梯度的区域（为了阐明点积变大的原因，假设$q$和$k$是独立的随机变量，平均值为$0$，方差$1$，这样他们的点积为 $q \cdot k = \sum_{i=1}^{d_k} q_ik_i$，同样是均值为$0$方差为$d_k$）。为了抵消这种影响，我们用$\frac{1}{\sqrt{d_k}}$来缩放点积。

png

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

$$
\mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head_1}, …, \mathrm{head_h})W^O \
\text{这里的}~\mathrm{head_i} = \mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)
$$

其中参数矩阵为$W^Q_i \in \mathbb{R}^{d_{\text{model}} \times d_k}$, $W^K_i \in \mathbb{R}^{d_{\text{model}} \times d_k}$, $W^V_i \in \mathbb{R}^{d_{\text{model}} \times d_v}$ and $W^O \in \mathbb{R}^{hd_v \times d_{\text{model}}}$。

我们的工作中使用$h=8$个head并行的attention，对每一个head来说有$d_k=d_v=d_{\text{model}}/h=64$，总计算量与完整维度的单个head的attention很相近。

1234567891011121314151617181920212223242526272829303132

class MultiHeadedAttention(nn.Module):def __init__(self, h, d_model, dropout=0.1):"Take in model size and number of heads."super(MultiHeadedAttention, self).__init__()assert d_model % h == 0# We assume d_v always equals d_kself.d_k = d_model // hself.h = hself.linears = clones(nn.Linear(d_model, d_model), 4)self.attn = Noneself.dropout = nn.Dropout(p=dropout)

def forward(self, query, key, value, mask=None):"Implements Figure 2"if mask is not None:# Same mask applied to all h heads.mask = mask.unsqueeze(1)nbatches = query.size(0)

# 1) Do all the linear projections in batch from d_model => h x d_kquery, 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))]

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

# 3) "Concat" using a view and apply a final linear.x = x.transpose(1, 2).contiguous() \.view(nbatches, -1, self.h * self.d_k)return self.linears[-1](x)

Attention在模型中的应用

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

在"encoder-decoder attention"层，query来自先前的解码器层，并且key和value来自encoder的输出。Decoder中的每个位置attend输入序列中的所有位置，这与Seq2Seq模型中的经典的encoder-decoder attention机制[15]一致。
Encoder中的self-attention层。在self-attention层中，所有的key、value和query都来同一个地方，这里都是来自encoder中前一层的输出。Encoder中当前层的每个位置都能attend到前一层的所有位置。
类似的，解码器中的self-attention层允许解码器中的每个位置attend当前解码位置和它前面的所有位置。这里需要屏蔽解码器中向左的信息流以保持自回归属性.具体的实现方式是在缩放后的点积attention中，屏蔽（设为$-\infty$）softmax的输入中所有对应着非法连接的value。

Position-wise前馈网络

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

$$
\mathrm{FFN}(x)=\max(0, xW_1 + b_1) W_2 + b_2
$$

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

12345678910

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序列转化为$d_{\text{model}}$维向量。我们还使用常用的预训练的线性变换和softmax函数将解码器输出转换为预测下一个token的概率。在我们的模型中，我们在两个embedding层和pre-softmax线性变换之间共享相同的权重矩阵，类似于[16]。在embedding层中，我们将这些权重乘以$\sqrt{d_{\text{model}}}$。

12345678

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)

位置编码

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

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

$$
PE_{(pos,2i)} = sin(pos / 10000^{2i/d_{\text{model}}})
$$

$$
PE_{(pos,2i+1)} = cos(pos / 10000^{2i/d_{\text{model}}})
$$

其中$pos$是位置，$i$是维度。也就是说，位置编码的每个维度都对应于一个正弦曲线，其波长形成从$2\pi$到$10000 \cdot 2\pi$的等比级数。我们之所以选择了这个函数，是因为我们假设它能让模型很容易学会attend相对位置，因为对于任何固定的偏移量$k$, $PE_{pos+k}$可以表示为$PE_{pos}$的线性函数。

此外，在编码器和解码器堆栈中，我们在embedding与位置编码的加和上都使用了dropout机制。在基本模型上，我们使用$P_{drop}=0.1$的比率。

1234567891011121314151617181920

class PositionalEncoding(nn.Module):"Implement the PE function."def __init__(self, d_model, dropout, max_len=5000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(p=dropout)

# Compute the positional encodings once in log space.pe = torch.zeros(max_len, 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))pe[:, 0::2] = torch.sin(position * div_term)pe[:, 1::2] = torch.cos(position * div_term)pe = pe.unsqueeze(0)self.register_buffer('pe', pe)

def forward(self, x):x = x + Variable(self.pe[:, :x.size(1)],requires_grad=False)return self.dropout(x)

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

plt.figure(figsize=(15, 5))pe = PositionalEncoding(20, 0)y = pe.forward(Variable(torch.zeros(1, 100, 20)))plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())plt.legend(["dim %d"%p for p in [4,5,6,7]])None

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

完整模型

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

123456789101112131415161718192021

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.deepcopyattn = 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

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

[1] https://arxiv.org/abs/1706.03762

[2] https://pytorch.org/

[3] https://github.com/harvardnlp/annotated-transformer

[4] https://drive.google.com/file/d/1xQXSv6mtAOLXxEMi8RvaW8TW-7bvYBDF/view?usp=sharing

[5] http://opennmt.net

[6] https://github.com/tensorflow/tensor2tensor

[7] https://github.com/awslabs/sockeye

[8] https://twitter.com/harvardnlp

[9] https://arxiv.org/abs/1409.0473

[10] https://arxiv.org/abs/1308.0850

[11] https://arxiv.org/abs/1512.03385

[12] https://arxiv.org/abs/1607.06450

[13] https://arxiv.org/abs/1409.0473

[14] https://arxiv.org/abs/1703.03906

[15] https://arxiv.org/abs/1609.08144

[16] https://arxiv.org/abs/1608.05859

[17] https://arxiv.org/pdf/1705.03122.pdf

            <hr><!-- Pager --><ul class="pager"><li class="previous"><a href="/2019/03/19/共指消解论文-ACL2018/" data-toggle="tooltip" data-placement="top" title="ACL2018论文阅读 (一)">← Previous Post</a></li><li class="next"><a href="/2018/10/09/升级Mojave后iterm2打开变慢/" data-toggle="tooltip" data-placement="top" title="【Mac】升级Mojave后iterm2打开变慢">Next Post →</a></li></ul><!-- duoshuo Share start --><!-- 多说 Share end--><!-- 多说评论框 start --><!-- 多说评论框 end --><!-- disqus comment start --><!-- disqus comment end --></div>

“Attention is All You Need 翻译相关推荐

Attention Is All You Need翻译
摘要主流的序列转换模型都是基于复杂的循环或卷积神经网络,这个模型包含一个编码器和一个解码器.具有最好性能的模型在编码和解码之间通过一个注意力机制链接编解码器.我们提出了一个新的简单网络结构,Tran ...
Diversity Regularized Spatiotemporal Attention for Video-based Person Re-identification 翻译
基于视频的人体再识别的时间规整化时空注意项目地址:https://github.com/ShuangLI59/Diversity-Regularized-Spatiotemporal-Attenti ...
Transformer新内核Synthesizer：低复杂度的attention代替点乘式的注意力机制
论文链接:https://arxiv.org/pdf/2005.00743.pdf 参考文档:https://mp.weixin.qq.com/s/e2Cor8amz7GiFfBGdLXULg 导读 ...
语言模型（五）—— Seq2Seq、Attention、Transformer学习笔记
按:三个月前的一篇笔记,先发出来,后面还会有第二次学习的笔记,两者结合起来看,更加爽口. 本篇笔记5000余字,可细嚼,亦可跳阅. 机器翻译本篇笔记中要开始介绍的Encoder-Decoder模型最 ...
基于attention机制的中英文机器翻译
前言为了准备3月中旬的复试,今天回顾整理一下大三下学期做的机器学习课程设计,当时做的是基于attention机制的中英文机器翻译.参考的资料是pytorch官网的英法文间的机器翻译.pytorch参 ...
基于pytorch+python实现一个中文到英文的神经网络的翻译模型
资源下载地址:https://download.csdn.net/download/sheziqiong/85980607 资源下载地址:https://download.csdn.net/downl ...
PaddlePaddle深度学习实战——英法文翻译机
51CTO技术栈 " 自然语言处理[1]是计算机科学领域与人工智能领域中的另一个重要方向,其中很重要的一点就是语音识别(speech recognition).机器翻译.智能机器人. 与语言 ...
attention加权机制
attention 1.在模型举例在机器翻译的任务当中,翻译得到的每个y的时候,更加关注于某个x,当翻译am的时候,就应该更关注输入当中的是,让机器也具备这种关注的能力. 2.怎么关注?当翻译y1的 ...
Attention Is All You Need 论文笔记
Attention Is All You Need 论文笔记文章目录 Attention Is All You Need 论文笔记背景 Tansformer模型简介 Attention & ...

“Attention is All You Need 翻译