Transformer是Google在2017年提出的用于机器翻译的模型：

Transformer内部本质上是一个Encoder-Decoder（编码器-解码器）结构：

Transformer中抛弃了传统的CNN和RNN，整个网络结构完全由Attention机制组成，并且采用了6层Encoder-Decoder结构：

很显然了，Transformer只有分为两大部分：编码器、解码器。这里只看其中一个Encoder-Decoder结构，剩余5个一样一样的。

以一个简单的例子进行说明：

输入： Why do we work?（我们为何工作? 后面以中文字符分析）

上图左右两个红框，左侧红框是编码器Encoder，右侧红框是解码器Decoder。

编码器负责将自然语言序列映射为隐藏层（上图第2步），即含有自然语言序列的数学表达。

解码器负责将隐藏层再映射为自然语言序列，从而使我们可以解决各种问题，如情感分析、机器翻译、摘要生成、语义关系抽取等。

简单说下，上图每一步都做了什么：

　　输入自然语言序列到编码器：Why do we work?（为啥要工作）；

　　编码器输出得到隐藏层，再将其输入到解码器；

　　输入<start>(起始)符号到解码器；

　　解码器得到第一个字： “为”；

　　将解码器得到的第一个字“为”再次从上图解码器结构的下端输入解码器；

　　解码器得到第二个字：“什”；

　　同样将解码器得到的第二个字“什”再次从上图解码器结构的下端输入解码器；

　　如此，直到解码器输出<end>终止符，即序列生成完成。

解码器和编码器的结构类似，本文对编码器部分进行讲解：把自然语言序列映射为隐藏层的数学表达的过程。

为便于理解学习，将编码器分为4部分依次讲解。

1. 位置嵌入

输入维度为[batch size, sequence length]的数据X，例如：我们为什么工作。

batch size就是一个batch的大小，这里只有一句话，所以batch size为1，sequence length是句子长度，共7个字，所以输入数据维度是[1,7].

我们不能直接将这句话输入到编码器中，因为transformer不认识，需要先进行字嵌入操作，得到上图中的X_embedding.

简单点说，就是文字-->字向量的转换，这种转换是将文字转换为计算机认识的数学表示，用到的方法就是Word2Vec，Word2Vec的具体细节可以暂时不用了解，知道要用到，先拿来用就好。

得到的X_embedding的维度是：[batch size, sequence length, embedding dimension]。enbedding dimension的大小由Word2Vec决定，transformer采用512长度的字向量。所以X_embedding的维度是[1, 7, 512]。

至此，输入的“我们为什么工作”，可以用一个矩阵来表示：

我们知道，文字的先后顺序，很重要。

比如吃饭没、没吃饭、没饭吃、饭吃没、饭没吃，同样三个字，顺序颠倒，所表达的含义就不同了。

--->关于Position Embedding:

因为前面说过模型本身并不包含RNN、CNN，因此无法捕捉到序列的顺序/位置信息，例如将K, V(需要先验知识：关于attention机制中Q K V三矩阵的常识)按行打乱，那么attention之后的顺序是一样的。

但是序列信息又非常重要，代表全局结构，因此必须将序列的token相对或绝对position信息利用起来。

这里每个token的position embedding 向量维度也是 $d_{model}=512,$ 然后将原本的input embedding和position embedding加起来组成最终的embedding作为encoder/decoder的输入。其中position embedding计算公式如下:

其中 $pos$ 表示位置index， $i$ 表示dimension index。

Position Embedding本身是一个绝对位置的信息，但在语言中，相对位置也很重要，Google选择前述的位置向量公式的一个重要原因是：由于我们有:

这表明位置p+k的向量可以表示成位置p的向量的线性变换，这提供了表达相对位置信息的可能性。

在其他NLP论文中，大家也都看过position embedding，通常是一个训练的向量，但是position embedding只是extra features，有该信息会更好，但是没有性能也不会产生极大下降，因为RNN、CNN本身就能够捕捉到位置信息，但是在Transformer模型中，Position Embedding是位置信息的唯一来源，因此是该模型的核心成分，并非是辅助性质的特征。

也可以采用训练的position embedding，但是试验结果表明相差不大，因此论文选择了sin position embedding，因为

这样可以直接计算embedding而不需要训练，减少了训练参数
这样允许模型将position embedding扩展到超过了training set中最长position的position，例如测试集中出现了更大的position，sin position embedding依然可以给出结果，但不存在训练到的embedding。

--->继续：

所以我们知道文字的位置信息很重要，Tranformer 没有类似 RNN 的循环结构，没有捕捉顺序序列的能力。

为了保留这种位置信息提供给 Tranformer 进行学习，我们需要用到位置嵌入。

加入位置信息的方式非常多，最简单的可以是直接将绝对坐标 0,1,2 编码。

Tranformer 采用的是 sin-cos 规则，使用了 sin 和 cos 函数的线性变换给模型提供位置信息：

上式中，pos指的是句中字的位置，取值范围是[0, 𝑚𝑎𝑥 𝑠𝑒𝑞𝑢𝑒𝑛𝑐𝑒 𝑙𝑒𝑛𝑔𝑡ℎ)，i指的是字嵌入的维度，取值范围是[0, 𝑒𝑚𝑏𝑒𝑑𝑑𝑖𝑛𝑔 𝑑𝑖𝑚𝑒𝑛𝑠𝑖𝑜𝑛)。 d_model就是 𝑒𝑚𝑏𝑒𝑑𝑑𝑖𝑛𝑔 𝑑𝑖𝑚𝑒𝑛𝑠𝑖𝑜𝑛 的大小。

上面有 sin 和 cos 的一组公式，也就是对应着 𝑒𝑚𝑏𝑒𝑑𝑑𝑖𝑛𝑔 𝑑𝑖𝑚𝑒𝑛𝑠𝑖𝑜𝑛 维度的一组奇数和偶数的序号的维度，从而产生不同的周期性变化。

可以通过代码简单看下效果：

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import math

def get_positional_encoding(max_seq_len, embed_dim):
    # 初始化一个positional encoding
    # embed_dim: 字嵌入的维度
    # max_seq_len: 最大的序列长度
    positional_encoding = np.array([
        [pos / np.power(10000, 2 * i / embed_dim) for i in range(embed_dim)]
        if pos != 0 else np.zeros(embed_dim) for pos in range(max_seq_len)])
    positional_encoding[1:, 0::2] = np.sin(positional_encoding[1:, 0::2])  # dim 2i 偶数
    positional_encoding[1:, 1::2] = np.cos(positional_encoding[1:, 1::2])  # dim 2i+1 奇数
    # 归一化, 用位置嵌入的每一行除以它的模长
    # denominator = np.sqrt(np.sum(position_enc**2, axis=1, keepdims=True))
    # position_enc = position_enc / (denominator + 1e-8)
    return positional_encoding
    
positional_encoding = get_positional_encoding(max_seq_len=100, embed_dim=16)
plt.figure(figsize=(10,10))
sns.heatmap(positional_encoding)
plt.title("Sinusoidal Function")
plt.xlabel("hidden dimension")
plt.ylabel("sequence length")
plt.legend()
plt.show()

可以看到，位置嵌入在 𝑒𝑚𝑏𝑒𝑑𝑑𝑖𝑛𝑔 𝑑𝑖𝑚𝑒𝑛𝑠𝑖𝑜𝑛 （也是hidden dimension ）维度上随着维度序号增大，周期变化会越来越慢，而产生一种包含位置信息的纹理。

这样，产生独一的纹理位置信息，模型从而学到位置之间的依赖关系和自然语言的时序特性。最后，将 X_embedding 和 位置嵌入 相加，输入给下一层。

2. 自注意力层（self attention mechanism）

多头的意义在于，QK^T得到的矩阵就叫做注意力矩阵，它可以表示，每个字与其他字的相似程度。因为向量点积值越大，表明两个向量越接近。

我们的目的是，让每个字都含有当前这个句子中所有字的信息，用注意力层，我们做到了。

需要注意的是，在上面 𝑠𝑒𝑙𝑓 𝑎𝑡𝑡𝑒𝑛𝑡𝑖𝑜𝑛 的计算过程中，我们通常使用 𝑚𝑖𝑛𝑖 𝑏𝑎𝑡𝑐ℎ，也就是一次计算多句话，上文举例只用了一个句子。

每个句子的长度是不一样的，需要按照最长的句子的长度统一处理。对于较短的句子，做padding操作，一般用0填充。

3. 残差链接和层归一化

加入了残差设计和层归一化操作，目的是为了防止梯度消失，加快收敛。

1）残差设计

我们在上一步得到了经过注意力矩阵加权之后的V，也就是Attention(Q, K, V)，将其转置，使其和X_embeding维度一致，也就是[𝑏𝑎𝑡𝑐ℎ 𝑠𝑖𝑧𝑒, 𝑠𝑒𝑞𝑢𝑒𝑛𝑐𝑒 𝑙𝑒𝑛𝑔𝑡ℎ, 𝑒𝑚𝑏𝑒𝑑𝑑𝑖𝑛𝑔 𝑑𝑖𝑚𝑒𝑛𝑠𝑖𝑜𝑛] ，然后把他们加起来做残差连接，直接元素相加，因为他们的维度一致:

X_embeding + Attention(Q, K, V)

在之后的运算里，每经过一个模块的运算，都要把运算之前的值和运算之后的值相加，从而得到残差连接，训练的时候可以使梯度直接走捷径反传到最初始层:

2）层归一化

作用是把神经网络中隐藏层归一为标准正态分布，也就是 𝑖.𝑖.𝑑 独立同分布，以起到加快训练速度，加速收敛的作用。

上式中以矩阵的行 (𝑟𝑜𝑤) 为单位求均值：

上式中以矩阵的行 (𝑟𝑜𝑤) 为单位求方差：

然后用每一行的每一个元素减去这行的均值，再除以这行的标准差，从而得到归一化后的数值，ε是为了防止除0；

之后引入两个可训练参数来α、β来弥补归一化过程中损失掉的信息，注意表示元素相乘而不是点积，我们一般初始化α为全1，β为全0。

代码层面非常简单，单头 attention 操作如下：

class ScaledDotProductAttention(nn.Module):
    ''' Scaled Dot-Product Attention '''

    def __init__(self, temperature, attn_dropout=0.1):
        super().__init__()
        self.temperature = temperature
        self.dropout = nn.Dropout(attn_dropout)

    def forward(self, q, k, v, mask=None):
        # self.temperature是论文中的d_k ** 0.5，防止梯度过大
        # QxK/sqrt(dk)
        attn = torch.matmul(q / self.temperature, k.transpose(2, 3))

        if mask is not None:
            # 屏蔽不想要的输出
            attn = attn.masked_fill(mask == 0, -1e9)
        # softmax+dropout
        attn = self.dropout(F.softmax(attn, dim=-1))
        # 概率分布xV
        output = torch.matmul(attn, v)

        return output, attn

Multi-Head Attention 实现在 ScaledDotProductAttention 基础上构建：

class MultiHeadAttention(nn.Module):
    ''' Multi-Head Attention module '''

    # n_head头的个数，默认是8
    # d_model编码向量长度，例如本文说的512
    # d_k, d_v的值一般会设置为 n_head * d_k=d_model，
    # 此时concat后正好和原始输入一样，当然不相同也可以，因为后面有fc层
    # 相当于将可学习矩阵分成独立的n_head份
    def __init__(self, n_head, d_model, d_k, d_v, dropout=0.1):
        super().__init__()
        # 假设n_head=8，d_k=64
        self.n_head = n_head
        self.d_k = d_k
        self.d_v = d_v
        # d_model输入向量，n_head * d_k输出向量
        # 可学习W^Q，W^K,W^V矩阵参数初始化
        self.w_qs = nn.Linear(d_model, n_head * d_k, bias=False)
        self.w_ks = nn.Linear(d_model, n_head * d_k, bias=False)
        self.w_vs = nn.Linear(d_model, n_head * d_v, bias=False)
        # 最后的输出维度变换操作
        self.fc = nn.Linear(n_head * d_v, d_model, bias=False)
        # 单头自注意力
        self.attention = ScaledDotProductAttention(temperature=d_k ** 0.5)
        self.dropout = nn.Dropout(dropout)
        # 层归一化
        self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)

    def forward(self, q, k, v, mask=None):
        # 假设qkv输入是(b,100,512),100是训练每个样本最大单词个数
        # 一般qkv相等，即自注意力
        residual = q
        # 将输入x和可学习矩阵相乘，得到(b,100,512)输出
        # 其中512的含义其实是8x64，8个head，每个head的可学习矩阵为64维度
        # q的输出是(b,100,8,64),kv也是一样
        q = self.w_qs(q).view(sz_b, len_q, n_head, d_k)
        k = self.w_ks(k).view(sz_b, len_k, n_head, d_k)
        v = self.w_vs(v).view(sz_b, len_v, n_head, d_v)

        # 变成(b,8,100,64)，方便后面计算，也就是8个头单独计算
        q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)

        if mask is not None:
            mask = mask.unsqueeze(1)   # For head axis broadcasting.
        # 输出q是(b,8,100,64),维持不变,内部计算流程是：
        # q*k转置，除以d_k ** 0.5，输出维度是b,8,100,100即单词和单词直接的相似性
        # 对最后一个维度进行softmax操作得到b,8,100,100
        # 最后乘上V，得到b,8,100,64输出
        q, attn = self.attention(q, k, v, mask=mask)

        # b,100,8,64-->b,100,512
        q = q.transpose(1, 2).contiguous().view(sz_b, len_q, -1)
        q = self.dropout(self.fc(q))
        # 残差计算
        q += residual
        # 层归一化，在512维度计算均值和方差，进行层归一化
        q = self.layer_norm(q)

        return q, attn

前馈网络：

class PositionwiseFeedForward(nn.Module):
    ''' A two-feed-forward-layer module '''

    def __init__(self, d_in, d_hid, dropout=0.1):
        super().__init__()
        # 两个fc层，对最后的512维度进行变换
        self.w_1 = nn.Linear(d_in, d_hid) # position-wise
        self.w_2 = nn.Linear(d_hid, d_in) # position-wise
        self.layer_norm = nn.LayerNorm(d_in, eps=1e-6)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        residual = x

        x = self.w_2(F.relu(self.w_1(x)))
        x = self.dropout(x)
        x += residual

        x = self.layer_norm(x)

        return x