Translation Company 推薦哈佛的 Transformer 模型详解

Transformer 模型自从由论文《Attention is All You Need》发表以来，就成为了自然语言处理（NLP）领域的热门话题。不仅在翻译质量上有了显著的改善，这种架构也为许多其他 NLP 任务提供了新的方法。本文将结合代码示例和图片链接，详细介绍 Transformer 模型的架构及其应用。

Transformer 模型的背景

Transformer 模型的出现基于减少顺序计算的目标，这也是扩展神经 GPU、ByteNet 和 ConvS2S 等模型的基础。这些模型利用卷积神经网络（CNN）作为基本构建模块，以并行的方式计算输入和输出的隐藏表示。在这些模型中，连接任意输入或输出位置所需的操作数量会随着位置之间距离的增加而增加，而在 Transformer 中，这个操作数量被减少为一个常数。

Transformer 模型结构

自注意力机制（Self-attention），有时被称为内部注意力，是一种关联单个序列不同位置以计算该序列表示的注意力机制。它已被成功应用于多种任务，如阅读理解、抽象总结、文本蕴涵和学习任务无关的句子表示。Transformer 是第一个完全依赖自注意力来计算输入和输出表示的转导模型，而不使用序列对齐的 RNN 或卷积。

Transformer 的模型架构

大多数竞争激烈的神经序列转导模型都具有编码器-解码器结构。这里的编码器将符号表示的输入序列映射到一系列连续表示。给定这些表示，解码器逐个生成输出序列的符号元素。

class EncoderDecoder(nn.Module):
    """
    标准的编码器-解码器架构。这也是许多其他模型的基础。
    """
    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):
        "处理源和目标序列的掩码。"
        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)

该模型在编码器和解码器中使用堆叠的自注意力和逐点的全连接层。

编码器和解码器堆栈

编码器

编码器由 N=6 个相同的层组成。

def clones(module, N):
    "生产 N 个相同的层。"
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class Encoder(nn.Module):
    "核心编码器是一个 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):
        "依次通过每层处理输入（和掩码）。"
        for layer in self.layers:
            x = layer(x, mask)
        return self.norm(x)

每个子层的输出是 LayerNorm(x + Sublayer(x))，其中 Sublayer(x) 是子层本身实现的函数。

解码器

解码器也由 N=6 个相同的层组成。

class Decoder(nn.Module):
    "具有掩码的通用 N 层解码器。"
    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)

解码器在每个编码器层的两个子层之外插入第三个子层，该子层对编码器堆栈的输出执行多头注意力。

注意力机制

注意力函数可以描述为将查询和一组键-值对映射到输出，查询、键、值和输出都是向量。输出是值的加权和，其中每个值的权重由查询与相应键的兼容性函数计算。

我们称之为“缩放点积注意力”。

def attention(query, key, value, mask=None, dropout=None):
    "计算缩放点积注意力"
    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