Transformer图解以及相关的概念解析

前言

transformer是目前NLP甚至是整个深度学习领域不能不提到的框架，同时大部分LLM也是使用其进行训练生成模型，所以transformer几乎是目前每一个机器人开发者或者人工智能开发者不能越过的一个框架。接下来本文将从顶层往下去一步步掀开transformer的面纱。

transformer概述

Transformer模型来自论文Attention Is All You Need。

在论文中最初是为了提高机器翻译的效率，它使用了Self-Attention机制和Position Encoding去替代RNN。后来大家发现Self-Attention的效果很好，并且在其它的地方也可以使用Transformer模型。并引出后面的BERT和GPT系列。

大家一般看到的transformer框架如下图所示：

transformer模型概览

首先把模型看成一个黑盒，如下图所示，对于机器翻译来说，它的输入是源语言(法语)的句子，输出是目标语言(英语)的句子。

把黑盒子稍微打开一点，Transformer(或者任何的NMT系统)可以分成Encoder和Decoder两个部分，如下图所示。

再展开一点，Encoder由很多结构一样的Encoder堆叠而成，Decoder也是一样。如下图所示。

每一个Encoder的输入是下一层Encoder输出，最底层Encoder的输入是原始的输入(法语句子)；Decoder也是类似，但是最后一层Encoder的输出会输入给每一个Decoder层，这是Attention机制的要求。

每一层的Encoder都是相同的结构，它由一个Self-Attention层和一个前馈网络(全连接网络)组成，如下图所示。

每一层的Decoder也是相同的结构，它除了Self-Attention层和全连接层之外还多了一个Attention层，这个Attention层使得Decoder在解码时会考虑最后一层Encoder所有时刻的输出。它的结构如下图所示。

transformer流程串联

transformer的串流需要tensor的加入，输入的句子需要通过Embedding把它变成一个连续稠密的向量，如下图所示。

Embedding之后的序列会输入Encoder，首先经过Self-Attention层然后再经过全连接层

我们在计算𝑧𝑖时需要依赖所有时刻的输入𝑥1,…,𝑥𝑛，这是可以用矩阵运算一下子把所有的𝑧𝑖计算出来的。而全连接网络的计算则完全是独立的，计算i时刻的输出只需要输入𝑧𝑖就足够了，因此很容易并行计算。下图更加明确的表达了这一点。图中Self-Attention层是一个大的方框，表示它的输入是所有的𝑥1,…,𝑥𝑛，输出是𝑧1,…,𝑧𝑛。而全连接层每个时刻是一个方框(但不同时刻的参数是共享的)，表示计算𝑟𝑖只需要𝑧𝑖。此外，前一层的输出𝑟1,…,𝑟𝑛直接输入到下一层。

Self-Attention介绍

比如我们要翻译如下句子”The animal didn’t cross the street because it was too tired”(这个动物无法穿越马路，因为它太累了)。这里的it到底指代什么呢，是animal还是street？要知道具体的指代，我们需要在理解it的时候同时关注所有的单词，重点是animal、street和tired，然后根据知识(常识)我们知道只有animal才能tired，而street是不能tired的。Self-Attention用Encoder在编码一个词的时候会考虑句子中所有其它的词，从而确定怎么编码当前词。如果把tired换成narrow，那么it就指代的是street了。

下图是模型的最上一层Encoder的Attention可视化图。这是tensor2tensor这个工具输出的内容。我们可以看到，在编码it的时候有一个Attention Head(后面会讲到)注意到了Animal，因此编码后的it有Animal的语义。

下面我们详细的介绍Self-Attention是怎么计算的，首先介绍向量的形式逐个时刻计算，这便于理解，接下来我们把它写出矩阵的形式一次计算所有时刻的结果。

对于输入的每一个向量(第一层是词的Embedding，其它层是前一层的输出)，我们首先需要生成3个新的向量Q、K和V，分别代表查询(Query)向量、Key向量和Value向量。Q表示为了编码当前词，需要去注意(attend to)其它(其实也包括它自己)的词，我们需要有一个查询向量。而Key向量可以认为是这个词的关键的用于被检索的信息，而Value向量是真正的内容。

具体的计算过程如下图所示。比如图中的输入是两个词”thinking”和”machines”，我们对它们进行Embedding(这是第一层，如果是后面的层，直接输入就是向量了)，得到向量𝑥1,𝑥2。接着我们用3个矩阵分别对它们进行变换，得到向量𝑞1,𝑘1,𝑣1和𝑞2,𝑘2,𝑣2。比如𝑞1=𝑥1𝑊𝑄，图中𝑥1的shape是1x4，𝑊𝑄是4x3，得到的𝑞1是1x3。其它的计算也是类似的，为了能够使得Key和Query可以内积，我们要求𝑊𝐾和𝑊𝑄的shape是一样的，但是并不要求𝑊𝑉和它们一定一样(虽然实际论文实现是一样的)。

每个时刻t都计算出𝑄𝑡,𝐾𝑡,𝑉𝑡之后，我们就可以来计算Self-Attention了。以第一个时刻为例，我们首先计算𝑞1和𝑘1,𝑘2的内积，得到score，过程如下图所示。

接下来使用softmax把得分变成概率，注意这里把得分除以8(𝑑𝑘)之后再计算的softmax，根据论文的说法，这样计算梯度时会更加稳定(stable)。计算过程如下图所示。

接下来用softmax得到的概率对所有时刻的V求加权平均，这样就可以认为得到的向量根据Self-Attention的概率综合考虑了所有时刻的输入信息，计算过程如下图所示。

这里只是演示了计算第一个时刻的过程，计算其它时刻的过程是完全一样的。

softmax示例代码：

import numpy as np
   
def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    # e_x = np.exp(x)
    e_x = np.exp(x )
    return e_x / e_x.sum()
if __name__ == '__main__':
    x = np.array([-3, 2, -1, 0])
    res = softmax(x )
    print(res)                        # [0.0056533  0.83902451 0.04177257 0.11354962]

特别注意，以上过程是可以并行计算的

Multi-Head Attention

论文还提出了Multi-Head Attention的概念。其实很简单，前面定义的一组Q、K和V可以让一个词attend to相关的词，我们可以定义多组Q、K和V，它们分别可以关注不同的上下文。计算Q、K和V的过程还是一样，不过现在变换矩阵从一组(𝑊𝑄,𝑊𝐾,𝑊𝑉)变成了多组(𝑊𝑄0,𝑊𝐾0,𝑊𝑉0) ，(𝑊𝑄1,𝑊𝐾1,𝑊𝑉1)。如下图所示。

对于输入矩阵(time_step, num_input)，每一组Q、K和V都可以得到一个输出矩阵Z(time_step, num_features)。如下图所示。

但是后面的全连接网络需要的输入是一个矩阵而不是多个矩阵，因此我们可以把多个head输出的Z按照第二个维度拼接起来，但是这样的特征有一些多，因此Transformer又用了一个线性变换(矩阵𝑊𝑂)对它进行了压缩。这个过程如下图所示。

上面的步骤涉及很多步骤和矩阵运算，我们用一张大图把整个过程表示出来，如下图所示。

我们已经学习了Transformer的Self-Attention机制，下面我们通过一个具体的例子来看看不同的Attention Head到底学习到了什么样的语义。

从上面两图的对比也能看出使用多个Head的好处——每个Head(在数据的驱动下)学习到不同的语义。

位置编码(Positional Encoding)

我们的目的是用Self-Attention替代RNN，RNN能够记住过去的信息，这可以通过Self-Attention“实时”的注意相关的任何词来实现等价(甚至更好)的效果。RNN还有一个特定就是能考虑词的顺序(位置)关系，一个句子即使词完全是相同的但是语义可能完全不同，比如”北京到上海的机票”与”上海到北京的机票”，它们的语义就有很大的差别。我们上面的介绍的Self-Attention是不考虑词的顺序的，如果模型参数固定了，上面两个句子的北京都会被编码成相同的向量。但是实际上我们可以期望这两个北京编码的结果不同，前者可能需要编码出发城市的语义，而后者需要包含目的城市的语义。而RNN是可以(至少是可能)学到这一点的。当然RNN为了实现这一点的代价就是顺序处理，很难并行。

为了解决这个问题，我们需要引入位置编码，也就是t时刻的输入，除了Embedding之外(这是与位置无关的)，我们还引入一个向量，这个向量是与t有关的，我们把Embedding和位置编码向量加起来作为模型的输入。这样的话如果两个词在不同的位置出现了，虽然它们的Embedding是相同的，但是由于位置编码不同，最终得到的向量也是不同的。

位置编码有很多方法，其中需要考虑的一个重要因素就是需要它编码的是相对位置的关系。比如两个句子：”北京到上海的机票”和”你好，我们要一张北京到上海的机票”。显然加入位置编码之后，两个北京的向量是不同的了，两个上海的向量也是不同的了，但是我们期望Query(北京1)Key(上海1)却是等于Query(北京2)Key(上海2)的。具体的编码算法我们在代码部分再介绍。位置编码加入后的模型如下图所示。

一个具体的位置编码的例子如下图所示。

残差和归一化

每个Self-Attention层都会加一个残差连接，然后是一个LayerNorm层，如下图所示。

下图展示了更多细节：输入𝑥1,𝑥2经self-attention层之后变成𝑧1,𝑧2，然后和残差连接的输入𝑥1,𝑥2加起来，然后经过LayerNorm层输出给全连接层。全连接层也是有一个残差连接和一个LayerNorm层，最后再输出给上一层。

Decoder和Encoder是类似的，如下图所示，区别在于它多了一个Encoder-Decoder Attention层，这个层的输入除了来自Self-Attention之外还有Encoder最后一层的所有时刻的输出。Encoder-Decoder Attention层的Query来自前面一层，而Key和Value则来自Encoder的输出。

此外在解码器的编码器-解码器注意力层中，掩码的使用非常关键，以确保解码器在生成每个目标词时只能使用到源语言句子的信息和它之前已经生成的目标词的信息

pytorch实现transformer

import torch
import torch.nn as nn
import math
# 位置编码模块
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-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 + self.pe[:x.size(0), :]
        return x
# Transformer模型
class TransformerModel(nn.Module):
    def __init__(self, ntoken, d_model, nhead, d_hid, nlayers, dropout=0.5):
        super(TransformerModel, self).__init__()
        self.model_type = 'Transformer'
        self.pos_encoder = PositionalEncoding(d_model)
        self.encoder = nn.Embedding(ntoken, d_model)
        self.transformer = nn.Transformer(d_model, nhead, d_hid, nlayers, dropout)
        self.decoder = nn.Linear(d_model, ntoken)
        self.init_weights()
        self.dropout = nn.Dropout(dropout)
    def generate_square_subsequent_mask(self, sz):
        # 生成后续掩码，用于防止位置信息泄露
        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
        return mask
    def init_weights(self):
        # 初始化权重
        initrange = 0.1
        self.encoder.weight.data.uniform_(-initrange, initrange)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-initrange, initrange)
    def forward(self, src, src_mask):
        # 前向传播
        src = self.encoder(src) * math.sqrt(self.d_model)
        src = self.pos_encoder(src)
        output = self.transformer(src, src, src_key_padding_mask=src_mask)
        output = self.decoder(output)
        return output
# 示例使用
ntokens = 1000  # 词汇表大小
d_model = 512  # 嵌入维度
nhead = 8  # 多头注意力中的头数
d_hid = 2048  # 前馈网络模型的维度
nlayers = 6  # 层数
dropout = 0.2  # dropout比率
model = TransformerModel(ntokens, d_model, nhead, d_hid, nlayers, dropout)
# 示例输入
src = torch.randint(0, ntokens, (10, 32))  # (序列长度, 批量大小)
src_mask = model.generate_square_subsequent_mask(10)  # 创建掩码
output = model(src, src_mask)
print(output)

推理过程

在Transformer模型的机器翻译任务中，解码器生成第一个翻译后的词（通常称为第一个目标词）的过程如下：

1. 起始符号：在解码器的输入序列的开始位置，通常会添加一个特殊的起始符号，如 <sos>（Start Of Sentence）。这个符号告诉模型翻译过程的开始。
   
2. 初始化隐藏状态：解码器的隐藏状态通常初始化为零向量或从编码器的最后一层的输出中获得。这个隐藏状态在生成序列的每一步中都会更新。
   
3. 第一次迭代：在第一次迭代中，解码器的输入只包含起始符号 <sos>。解码器通过以下步骤生成第一个词：
   

• 将起始符号 <sos> 通过嵌入层转换为嵌入向量。
  
• 将这个嵌入向量与编码器的输出一起输入到解码器的第一个注意力层。
  
• 在自注意力层中，使用因果掩码（Look-ahead Mask）确保解码器只能关注到当前位置和之前的词（在这个例子中只有 <sos>）。
  
• 在编码器-解码器注意力层中，解码器可以查看整个编码器的输出，因为这是第一次迭代，解码器需要获取关于整个源语言句子的信息。
  
• 经过解码器的前馈网络后，输出层会生成一个概率分布，表示下一个可能的词。
  
• 选择概率最高的词作为第一个翻译后的词，或者使用贪婪策略、束搜索（Beam Search）等解码策略来选择词。
  

4. 后续迭代：一旦生成了第一个词，它就会被添加到解码器的输入序列中，与 <sos> 一起作为下一步的输入。在后续的迭代中，解码器会继续生成下一个词，直到遇到结束符号 <eos> 或达到最大序列长度。
   

在训练阶段，目标序列的真实词（包括 <sos> 和 <eos>）会用于计算损失函数，并通过反向传播更新模型的权重。在推理阶段，解码器使用上述过程逐步生成翻译，直到生成完整的句子。