Attention机制最早在视觉领域提出，由 GoogleMind 2014年发表《Recurrent Models of Visual Attention》，使Attention机制流行起来，论文采用了RNN模型，并加入了Attention机制来进行图像的分类。

2005年，Bahdanau等人在论文《Neural Machine Translation by Jointly Learning to Align and Translate》中，将attention机制首次应用在nlp领域，其采用Seq2Seq+Attention模型来进行机器翻译，并且得到了效果的提升，Seq2Seq With Attention中进行了介绍。

2017 年，Google 机器翻译团队在NIPS 2017上发表的《Attention is All You Need》中，完全抛弃了RNN和CNN等网络结构，而仅仅采用Attention机制来进行机器翻译任务，并且取得了很好的效果，注意力机制也成为了大家近期的研究热点。

Transformer 是 Google 的团队在 2017 年基于 Attention机制 提出的一种 NLP 经典模型，现在比较火热的 Bert 也是基于Transformer。Transformer 模型采用 Self-Attention机制，抛弃了RNN顺序结构，使得模型可以并行化训练，而且能够拥有全局信息。

2018年，Google团队又将由 Self-Attention机制 构建的Transformer 迁移到CV领域，发表了《Image Transformer》，至此Transformer开始引爆CV圈。

注意力机制一种是 软注意力(Soft-Attention)，另一种是 强注意力(Hard-Attention)

• 软注意力的关键点在于，这种注意力更关注区域或通道，而且软注意力是确定性的注意力，学习完后可以直接通过网络生成，最重要的一点是，软注意力机制是可微分的，这是非常重要的，可以微分的注意力就可以通过神经网络算出梯度，并且前向传播和反向传播来学习得到的注意力的权重；
• 强注意力 与软注意力不同点在于，强注意力更加关注点，也就是图像中的每个点都有可能延伸出注意力，同时强注意力是一个随机的预测过程，更强调动态变化，当然，最关键的是强注意力是一个不可微分的注意力，训练过程往往是通过增强学习来完成；

1、NLP Self-Attention

1.1 处理Sequence数据的模型：

Transformer是一个Sequence to Sequence model，特别之处在于它大量用到了self-attention。要处理一个Sequence，最常想到的就是使用RNN，它的输入是一串vector sequence，输出是另一串vector sequence，如下图1左所示。

如果假设是一个single directional的RNN，那当输出$b_4$ 时，默认$a_1,a_2,a_3,a_4$ 都已经看过了。如果假设是一个bi-directional的RNN，那当输出 $b_{任意}$ 时，默认$a_1,a_2,a_3,a_4$ 都已经看过了。RNN非常擅长于处理input是一个sequence的状况。

那RNN有什么样的问题呢？ 它的问题就在于：RNN很不容易并行化 (hard to parallel)。

为什么说RNN很不容易并行化呢？假设在single directional的RNN的情形下，你今天要算出$b_4$ ，就必须要先看$a_1$ 再看$a_2$ 再看$a_3$ 再看$a_4$ ，所以这个过程很难平行处理。所以今天就有人提出把CNN拿来取代RNN，如下图1右所示。其中，橘色的三角形表示一个filter，每次扫过3个向量$a$ ，扫过一轮以后，就输出了一排结果，使用橘色的小圆点表示。这是第一个橘色的filter的过程，还有其他的filter，比如图2中的黄色的filter，它经历着与 橘色的filter 相似的过程，又输出一排结果，使用黄色的小圆点表示。

所以，用CNN，你确实也可以做到跟RNN的输入输出类似的关系，也可以做到输入是一个sequence，输出是另外一个sequence。

但是，表面上CNN和RNN可以做到相同的输入和输出，但是CNN只能考虑非常有限的内容。比如在我们右侧的图中CNN的filter只考虑了3个vector，不像RNN可以考虑之前的所有vector。但是CNN也不是没有办法考虑很长时间的dependency的，你只需要堆叠filter，多堆叠几层，上层的filter就可以考虑比较多的资讯，比如，第二层的filter (蓝色的三角形)看了6个vector，所以，只要叠很多层，就能够看很长时间的资讯。

而CNN的一个好处是：
它是可以并行化的 (can parallel)，不需要等待红色的filter算完，再算黄色的filter。但是必须要叠很多层filter，才可以看到长时的资讯。所以今天有一个想法：self-attention，如下图3所示，目的是使用self-attention layer取代RNN所做的事情。

所以重点是：我们有一种新的layer，叫self-attention，它的输入和输出和RNN是一模一样的，输入一个sequence，输出一个sequence，它的每一个输出$b_1-b_4$都看过了整个的输入sequence，这一点与bi-directional RNN相同。但是神奇的地方是：它的每一个输出$b_1-b_4$可以并行化计算。

Attention

为了理解注意力的计算，我们可以将注意力的计算与数据库世界进行比较。当我们在数据库中进行搜索时，我们提交一个查询（Q），并在可用数据中搜索一个或多个满足查询的键。输出是与查询最相关的键关联的值。

注意力计算的情况非常相似。我们首先把要计算注意力的句子看作一组向量。每个单词，通过一个单词嵌入机制，被编码成一个向量。我们认为这些向量是搜索的关键，关于我们正在搜索的查询，它可以是来自同一个句子（自我注意）或来自另一个句子的单词。在这一点上，我们需要计算查询和每个可用键之间的相似性，通过缩放点积进行数学计算。这个过程将返回一系列实际值，可能彼此非常不同，但是由于我们希望获得0和1之间的权重，其和等于1，因此我们对结果应用SoftMax。一旦获得了权重，我们就必须将每个单词的权重以及它与查询的相关性乘以表示它的向量。我们最终返回这些产品的组合作为注意向量。

为了建立这种机制，我们使用 linear layers，从输入向量开始，通过矩阵乘法生成键、查询和值。键和查询的组合将允许在这两个集合之间获得最正确的匹配，其结果将与值组合以获得最相关的组合。

1.2 Self-attention：

那么self-attention具体是怎么做的呢？

首先假设我们的input是图4的$x_1-x_4$，是一个sequence，每一个input (vector)先乘上一个矩阵$W$得到embedding，即向量$a_1-a_4$ 。接着这个embedding进入self-attention层，每一个向量$a_1-a_4$分别乘上3个不同的transformation matrix $W_q,W_k,W_v$ ，以向量$a_1$为例，分别得到3个不同的向量$q_1,k_1,v_1$。

接下来使用每个query $q$去对每个key $k$ 做attention，attention就是匹配这2个向量有多接近，比如我现在要对$q^1$和$k^2$做attention，我就可以把这2个向量做scaled inner product，得到 ${\alpha }_{1,1}$。接下来你再拿$q^1$和$k^2$做attention，得到${\alpha }_{1,2}$，你再拿$q^1$和$k^3$做attention，得到${\alpha }_{1,3}$，你再拿$1^1$和$k^4$做attention，得到${\alpha }_{1,4}$。那这个scaled inner product具体是怎么计算的呢？

$${\alpha }_{a,i}=q^1\cdot k^i/\sqrt{d}\text{\hspace{1em}(1)}$$

式中，$d$是$q$跟$k$的维度。因为$q\cdot k$的数值会随着dimension的增大而增大，所以要除以 $\sqrt{dimension}$ 的值，相当于归一化的效果。

接下来要做的事如图6所示，把计算得到的所有 ${\alpha }_{1,i}$ 值取 softmax 操作。

取完 softmax 操作以后，我们得到了 ${\hat{\alpha }}_{1,i}$ ，我们用它和所有的 $v^i$ 值进行相乘。具体来讲，把${\hat{\alpha }}_{1,1}$乘上$v^1$，把${\hat{\alpha }}_{1,2}$乘上$v^2$，把${\hat{\alpha }}_{1,3}$乘上 $v^3$ ，把${\hat{\alpha }}_{1,4}$乘上 $v^4$，把结果通通加起来得到 $b^1$，所以，今天在产生$b^1$ 的过程中用了整个sequence的资讯 (Considering the whole sequence)。

• 如果要考虑local的information，则只需要学习出相应的 ${\hat{\alpha }}_{1,i}=0$，$b^1$ 就不再带有那个对应分支的信息了；
• 如果要考虑global的information，则只需要学习出相应的 ${\hat{\alpha }}_{1,i}\ne 0$，$b^1$ 就带有全部的对应分支的信息了。

同样的方法，也可以计算出 $b^2,b^3,b^4$，如下图8所示， $b^2$ 就是拿query $q^2$去对其他的 $k$ 做attention，得到 ${\hat{\alpha }}_{2,i}$，再与value值 $v^i$ 相乘取weighted sum得到的。

经过了以上一连串计算，self-attention layer做的事情跟RNN是一样的，只是它可以并行的得到layer输出的结果，如图9所示。现在我们要用矩阵表示上述的计算过程。

首先输入的embedding是 $I=[a^1,a^2,a^3,a^4]$ ，然后用 $I$ 乘以transformation matrix $W^q$ 得到 $Q=[q^1,q^2,q^3,q^4]$ ，它的每一列代表着一个vector $q$。同理，用 $I$ 乘以 transformation matrix $W^k$ 得到 $K=[k^1,k^2,k^3,k^4]$ ，它的每一列代表着一个vector $k$。用 $I$ 乘以transformation matrix $W^v$得到 $Q=[v^1,v^2,v^3,v^4]$，它的每一列代表着一个vector $v$。

接下来是 $k$ 与 $q$ 的attention过程，我们可以把vector $k$ 横过来变成行向量，与列向量 $q$ 做内积，这里省略了$\sqrt{d}$ 。这样，$\alpha$ 就成为了 $4\times 4$ 的矩阵，它由4个行向量拼成的矩阵和4个列向量拼成的矩阵做内积得到，如图11所示。

在得到 $\hat{A}$ 以后，如上文所述，要得到 $b^1$ ， 就要使用 ${\hat{\alpha }}_{1,i}$ 分别与 $b^i$ 相乘再求和得到，所以 $\hat{A}$ 要再左乘 $V$ 矩阵。

到这里你会发现这个过程可以被表示为，如图12所示：输入矩阵 $I\in R(d,N)$ 分别乘上3个不同的矩阵 $W_q,W_k,W_v\in R(d,d)$ 得到3个中间矩阵 $Q,K,V\in R(d,N)$。它们的维度是相同的。把 $K$转置之后与 $Q$ 相乘得到Attention矩阵 $A\in R(N,N)$ ，代表每一个位置两两之间的attention。再将它取 softmax 操作得到 $\hat{A}\in R(N,N)$，最后将它乘以 $V$ 矩阵得到输出vector $O\in R(d,N)$ 。

$$\hat{A}=softmax(A)=K^T\cdot Q\text{\hspace{1em}(2)}$$
$$O=V\cdot \hat{A}\text{\hspace{1em}(3)}$$

1.3 Multi-head Self-attention：

但是，如果我们想把注意力集中在一个单词上，这个机制就足够了，但是如果我们想从几个角度看这个句子，然后并行计算几次注意力，会怎么样？我们使用所谓的多头注意力 Multi - Head Attention。

以2个head的情况为例：由 $a^i$ 生成的 $q^i$ 进一步乘以2个转移矩阵变为 $q^{i,1}$ 和$q^{i,2}$ ，同理由 $a^i$ 生成的 $k^i$ 进一步乘以2个转移矩阵变为 $k^{i,1}$ 和 $k^{i,2}$ ，由 $a^i$生成的 $v^i$ 进一步乘以2个转移矩阵变为 $v^{i,1}$ 和 $v^{i,2}$ 。接下来$q^{i,1}$ 再与$k^{i,1}$ 做attention，得到weighted sum的权重$\alpha$ ，再与$v^{i,1}$ 做weighted sum得到最终的 $b^{i,1}(i=1,2...,N)$ 。同理得到 $b^{i,2}(i=1,2...,N)$ 。现在我们有了 $b^{i,1}(i=1,2...,N)\in R(d,1)$ 和 $b^{i,2}(i=1,2...,N)\in R(d,1)$ ，可以把它们concat起来，再通过一个transformation matrix调整维度，使之与刚才的 $b^i(i=1,2...,N)\in R(d,1)$ 维度一致(这步如图13所示)。

从下图14可以看到 Multi-Head Attention 包含多个 Self-Attention 层，首先将输入 $X$ 分别传递到 2个不同的 Self-Attention 中，计算得到 2 个输出结果。得到2个输出矩阵之后，Multi-Head Attention 将它们拼接在一起 (Concat)，然后传入一个Linear层，得到 Multi-Head Attention 最终的输出 $Z$。可以看到 Multi-Head Attention 输出的矩阵 $Z$ 与其输入的矩阵 $X$ 的维度是一样的。

这里有一组Multi-head Self-attention的解果，其中绿色部分是一组query和key，红色部分是另外一组query和key，可以发现绿色部分其实更关注global的信息，而红色部分其实更关注local的信息。

1.4 Positional Encoding：

以上是multi-head self-attention的原理，但是还有一个问题是：现在的self-attention中没有位置的信息，一个单词向量的“近在咫尺”位置的单词向量和“远在天涯”位置的单词向量效果是一样的，没有表示位置的信息(No position information in self attention)。所以你输入"A打了B"或者"B打了A"的效果其实是一样的，因为并没有考虑位置的信息。所以在self-attention原来的paper中，作者为了解决这个问题所做的事情是如下图16所示：

具体的做法是：给每一个位置规定一个表示位置信息的向量 $e^i$ ，让它与 $a^i$ 加在一起之后作为新的 $a^i$ 参与后面的运算过程，但是这个向量 $e^i$ 是由人工设定的，而不是神经网络学习出来的。每一个位置都有一个不同的 $e^i$。

那到这里一个自然而然的问题是：
为什么是 $e^i$与$a^i$ 相加？为什么不是concatenate？加起来以后，原来表示位置的资讯不就混到 $a^i$里面去了吗？不就很难被找到了吗？

这里提供一种解答这个问题的思路：

如图15所示，我们先给每一个位置的 $x^i\in R(d,1)$ append一个one-hot编码的向量 $p^i\in R(d,1)$，得到一个新的输入向量 $x_p^i\in R(d+N,1)$ ，这个向量作为新的输入，乘以一个transformation matrix $W=[W^I,W^P]\in R(d,d+N)$。那么：

$$W\cdot x_p^i=W^I,W^P\cdot \left[\begin{array}{c}{x}^i\\ p^i\end{array}\right]=W^I\cdot x^i+W^P\cdot p^i=a^i+e^i\text{\hspace{1em}(4)}$$

所以，$e^i$与 $a^i$ 相加就等同于把原来的输入 $x^i$ concat一个表示位置的独热编码 $p^i$，再做transformation。

这个与位置编码乘起来的矩阵 $W^P$ 是手工设计的，如图17所示。

Transformer 中除了单词的 Embedding，还需要使用位置 Embedding 表示单词出现在句子中的位置。因为 Transformer 不采用 RNN 的结构，而是使用全局信息，不能利用单词的顺序信息，而这部分信息对于 NLP 来说非常重要。所以 Transformer 中使用位置 Embedding 保存单词在序列中的相对或绝对位置。

位置 Embedding 用 PE表示，PE 的维度与单词 Embedding 是一样的。PE 可以通过训练得到，也可以使用某种公式计算得到。在 Transformer 中采用了后者，计算公式如下：

$$P{E}_{pos,2i}=sin(pos/10000^{2i/d_{m}odel})\text{\hspace{1em}(5.1)}$$
$$P{E}_{pos,2i+1}=cos(pos/10000^{2i/d_{m}odel})\text{\hspace{1em}(5.2)}$$

式中， $pos$ 表示token在sequence中的位置，例如第一个token “我” 的 $pos=0$ 。

# 式(5)的位置编码
class PositionalEncoding(nn.Module):
    def __init__(self, d_hid, n_position=200):
        super(PositionalEncoding, self).__init__()
        self.register_buffer('pos_table', self._get_sinusoid_encoding_table(n_position, d_hid))     # Not a parameter

    def _get_sinusoid_encoding_table(self, n_position, d_hid):
        ''' Sinusoid position encoding table
        TODO: make it with torch instead of numpy
        '''

        def get_position_angle_vec(position):
            return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]

        sinusoid_table          = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])
        sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i
        sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1
        return torch.FloatTensor(sinusoid_table).unsqueeze(0)

    def forward(self, x):
        return x + self.pos_table[:, :x.size(1)].clone().detach()

$i$，或者准确意义上是 $2i$ 和 $2i+1$ 表示了Positional Encoding的维度，$i$ 的取值范围是：$[0,...,d_{model}/2]$ 。所以当 $pos$ 为1时，对应的Positional Encoding可以写成：

$$PE(1)=[sin(1/10000^{0/512}),cos(1/10000^{0/512}),sin(1/10000^{2/512}),sin(1/10000^{2/512}),...]$$

式中，$d_{model}=512$ 。底数是10000。为什么要使用10000呢，这个就类似于玄学了，原论文中完全没有提啊，这里不得不说说论文的readability的问题，即便是很多高引的文章，最基本的内容都讨论不清楚，所以才出现像上面提问里的讨论，说实话这些论文还远远没有做到easy to follow。这里我给出一个假想：$10000^{1/512}$ 是一个比较接近1的数（1.018），如果用100000，则是1.023。这里只是猜想一下，其实大家应该完全可以使用另一个底数。

这个式子的好处是：

• 每个位置有一个唯一的positional encoding。
• 使 $PE$ 能够适应比训练集里面所有句子更长的句子，假设训练集里面最长的句子是有 20 个单词，突然来了一个长度为 21 的句子，则使用公式计算的方法可以计算出第 21 位的 Embedding。
• 可以让模型容易地计算出相对位置，对于固定长度的间距 $k$，任意位置的 ${PE}_{pos+k}$ 都可以被 $P{E}_{pos}$ 的线性函数表示，因为三角函数特性：

$$\begin{gathered} cos(\alpha +\beta )=cos(\alpha )cos(\beta )-sin(\alpha )sin(\beta ) \\ sin(\alpha +\beta )=sin(\alpha )cos(\beta )+cos(\alpha )sin(\beta ) \end{gathered}$$

接下来我们看看self-attention在 sequence2sequence model 里面是怎么使用的，我们可以把Encoder-Decoder中的 RNN 用self-attention取代掉。

2、Vision Self-Attention

由于卷积核作用的感受野是局部的，需要经过累积多层之后才能把图像不同部分的区域关联起来，所以在 CVPR2018 Hu J等人提出了 SENet，从特征通道层面上统计图像的全局信息。

Self-Attention 是从 NLP 中借鉴而来的思想，因此保留了 Query、key 和 Value等名称；
Feature maps 是由基本的深度卷积网络得到的特征图，如ResNet、VGG等，通常将 backbone 最后两个下采样层去除，使获得的特征图是输入图像的 1/8 大小。

Self-Attention 结构分为三个分支，分别是 query、key、value，计算分为三步：

1. 将query和每个key进行相似度计算得到权重，常用的相似度计算有：点积、拼接、感受机等；
2. 使用softmax函数对权重进行归一化；
3. 将权重和相应的 value进行加权求和得到最后的 Attention

class Self_Attn(nn.Module):
    """ Self attention Layer"""

    def __init__(self, in_dim, activation):
        super(Self_Attn, self).__init__()
        self.chanel_in 	= in_dim
        self.activation = activation

        self.q_conv 	= nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=(1,1))
        self.k_conv 	= nn.Conv2d(in_channels=in_dim, out_channels=in_dim // 8, kernel_size=(1,1))
        self.v_conv 	= nn.Conv2d(in_channels=in_dim, out_channels=in_dim     , kernel_size=(1,1))
        self.gamma      = nn.Parameter(torch.zeros(1))

        self.softmax    = nn.Softmax(dim=-1)

    def forward(self, x):
        """
            inputs :
                x : input feature maps( B x C x W x H)
            returns :
                out : self attention value + input feature
                attention: B x N x N (N is Width*Height)
        """
        m_batchsize, C, width, height = x.size()
        proj_query  = self.q_conv(x).view(m_batchsize, -1 , width * height).permute(0, 2, 1)     # B X C X (N)
        proj_key    = self.k_conv(x).view(m_batchsize, -1 , width * height)                      # B X C x (W*H)
        energy      = torch.bmm(proj_query, proj_key)       # transpose check
        attention   = self.softmax(energy)                  # B X (N) X (N)
        proj_value  = self.v_conv(x).view(m_batchsize, -1 , width * height)     # B X C X N

        out         = torch.bmm(proj_value, attention.permute(0, 2, 1))
        out         = out.view(m_batchsize, C, width, height)
        out         = self.gamma * out + x

        return out, attention

假设 feature maps 的大小为： B、C、W、H

在初始化函数中，定义了三个 1x1 卷积，分别是 query_conv、key_conv、value_conv

• 在query_conv卷积中，输入为 (B、C、W、H) 输出为 (B、C/8、W、H)
• 在key_conv卷积中，输入为 (B、C、W、H) 输出为 (B、C/8、W、H)
• 在value_conv卷积中， 输入为(B、C、W、H) 输出为 (B、C、W、H)

步骤一

proj_query = self.query_conv(x).view(m_batchsize,-1,width*height).permute(0,2,1)

proj_query 本质上就是卷积，只不过加入了 reshape 操作；

• 先对输入 feature maps 进行query_conv 卷积，输出为 (B、C/8、WH)；
• view函数调整输出的维度，
  就单张 feature map而言，就是将 WxH 大小拉直，变成 1x(WxH)；
  就 batchsize 而言，输出就是 B、C/8、WH ；
• permute函数对 第二维、第三维进行倒置，输出为 B、WH、C/8；

proj_query 中的第 i 行表示 第 i 个像素位置上所有通道的值；

proj_key =  self.key_conv(x).view(m_batchsize,-1,width*height)

proj_key 与 proj_query 相似，只是没有最后一步倒置，输出为 B、C/8、WH，proj_key 中的第 j 行表示第 j 个像素位置上所有通道的值；

步骤二

energy =  torch.bmm(proj_query,proj_key)

将 batch_size 中每一对 proj_query 和 proj_key 分别进行矩阵相乘，输出为 B、WH、WH ，Energy中的 第(i,j) 是将 proj_query 中的 第 i 行与 proj_key 中的第 j 行点乘而得。
意义在于： energy 中的 第 (i,j) 位置的元素是指输入特征图第 j 个元素对第 i 个元素的影响，从而实现全局上下文任意两个元素的依赖关系。

步骤三

attention = self.softmax(energy)

将 energy 进行 softmax 归一化，是对行归一化；归一化后每行的和为1，对于 (i,j) 位置即可理解为第 j 位置对 i 位置的权重，所有的 j 对 i 位置的权重之和为 1，此时得到 attention_map；

proj_value = self.value_conv(x).view(m_batchsize,-1,width*height)

proj_value 和 proj_query 与 proj_key 一样，只是输入为 B、C、W、H，输出为 B、C、WH，从 self-attention 结构图中可以知道 proj_value 是与 attention_map 进行矩阵相乘，即：

out = torch.bmm(proj_value,attention.permute(0,2,1) )
out = out.view(m_batchsize,C,width,height)

在对 proj_value 与attention_map 点乘之前，先对attention进行转置。这是由于attention中每一行的权重之和为1，是原特征图第j个位置对第i个位置的权重，将其转置之后，每一列之和为1；
proj_value的每一行与attention中的每一列点乘，将权重施加于proj_value上，输出为B×C×(W×H)。

步骤四

out = self.gamma*out + x

这一步是对 attention 之后的out进行加权，x是原始的特征图，将其叠加在原始特征图上。Gamma是经过学习得到的，初始gamma为0，输出即原始特征图，随着学习的深入，在原始特征图上增加了加权的attention，得到特征图中任意两个位置的全局依赖关系。

3、缺陷

在所有这些很好的解释之后，你可能会认为transformer是完美的，没有任何缺陷。很显然，它不是这样的，它的优点之一也是它的缺点，计算注意！

为了计算每个单词相对于所有其他单词的注意力，必须执行N²计算，即使部分可并行，仍然非常昂贵。有了这样的复杂性，试想一下，在一段几百字的文字上，多次计算注意力意味着什么。

从图形上你可以想象一个矩阵，它必须填充每个单词相对于其他单词的注意力值，这显然是有昂贵的成本。必须指出的是，通常在解码器上，可以计算隐藏的注意，避免计算查询词和所有后续词之间的注意。

有些人可能会争论，但如果transformer带来的许多好处都与注意力机制有关，那么我们真的需要上面提到的所有结构吗？但2017年的第一份谷歌大脑论文不是说“注意力就是你所需要的一切”吗？当然是合法的，但在2021年3月，谷歌研究人员再次发表了一篇题为“注意力不是你所需要的全部”的论文。那是什么意思？研究人员进行了实验，分析了在没有transformer任何其他组件的情况下进行的自我注意机制的行为，发现它以双指数速率收敛到秩1矩阵。这意味着这种机制本身实际上是无用的。那么为什么transformer如此强大呢？

这是由于减少矩阵秩的自我注意机制与transformer的另外两个组成部分跳跃连接和MLP之间的拉锯战。

第一种方法允许路径的分布多样化，避免获得所有相同的路径，这大大降低了矩阵被降为秩1的概率。MLP由于其非线性，因此能够提高生成矩阵的秩。相反，有人表明，规范化在避免这种自我注意机制的行为方面没有作用。因此，注意力不是你所需要的全部，而是transformer架构设法利用它的优势来取得令人印象深刻的结果。