文献阅读：RoFormer: Enhanced Transformer with Rotary Position Embedding

文献阅读：RoFormer: Enhanced Transformer with Rotary Position Embedding
- 1. 工作简介
- 2. 常见位置编码方式
  - 1. 绝对位置编码
    - 1. Bert
    - 2. Attention Is All You Need
  - 2. 相对位置编码
    - 1. 经典相对位置编码
    - 2. XLNet
    - 3. T5
    - 4. DeBerta
- 3. RoPE方法介绍
- 4. 实验效果考察
  - 1. 翻译任务上的表现
  - 2. 预训练任务上的表现
  - 3. GLUE下游Finetune效果
  - 4. 中文任务中效果表达
- 5. 总结 & 思考
- 6. 参考链接
文献链接：https://arxiv.org/abs/2104.09864

1. 工作简介

这篇文章是苏剑林的一篇关于Transformer当中的位置编码的优化考察。

众所周知，transformer的attention机制本身是不带有位置信息的，因此对于文本序列，attention机制本身就会丢失掉原文当中的序列信息，造成信息缺失，影响到模型的效果表达，这个应该已经算是面试中常见的八股文问题了。

但是，对于位置编码的具体实现，大概会去考虑这个问题的人就大幅减少了。而苏剑林这里就是对这部分内容进行了详细的考察和优化尝试，这点真心还是很佩服他的。

2. 常见位置编码方式

首先，我们来考察一下现有的一些位置编码的方法。

这部分的内容我们主要参考苏剑林的博客《让研究人员绞尽脑汁的Transformer位置编码》进行一些自己的整理。

1. 绝对位置编码

1. Bert

绝对位置编码的一个典型的例子就是Bert模型。

他的思路非常的简单粗暴，既然attention层本身无法识别位置信息，那么我就在输入当中显式地多加一个序列位置信号，然后让模型自己去学习这个序列位置信号的分布。

具体来说，就是讲原本的输入x_i 变成了x_i p_i ，其中，p_i 表示的就是第i个位置的绝对位置编码。

这种编码方式的好处在于说简单直接，而且模型直接参数拟合的方式也不会产生人为的信号偏差，但是缺点在于说推理阶段只能使用训练中预先定义好的位置编码，比如bert，最大输入句长就是512，超过了512模型就失去了编码能力。

此外，位置编码的训练充分度也会是一个需要考虑的问题。

2. Attention Is All You Need

绝对位置编码的另一个典型例子就是vanilla transformer。

不过，不同于Bert那样直接交给模型去训练position embedding，经典Transformer的位置Embedding的定义是直接通过三角函数的方式进行预先定义好的。

他的出发点在于说参考了三角函数的性质：

left{ begin{aligned} cos(alpha beta) &= cosalpha cdot cosbeta - sinalpha cdot sinbeta \ sin(alpha beta) &= sinalpha cdot cosbeta - cosalpha cdot sinbeta end{aligned} right.

这个性质刚好可以用于描述两个位置之间的相对距离关系。

因此，文中先验地给出一个人工预设的位置编码如下：

left{ begin{aligned} p_{k, 2i} &= sin(k/10000^{2i/d}) \ p_{k, 2i 1} &= cos(k/10000^{2i/d} end{aligned} right.

其中，k 表示第k 个位置，2i, 2i 1 in [0, d) ，表示position embedding当中某一个具体维度上的值。

可以看到，这样的情况下位置表征就是先验确定的了，我们无需交由模型进行额外地拟合，而且长度使用上也更加自由，基本没有长度限制，但是代价就是给模型增加了人工的先验限制，学习到的embedding特征不但要满足token本身的信息表征，还要满足三角函数形式的数据分布表达，收缩了解空间的表达域。

2. 相对位置编码

在考察相对位置编码之前，我们首先来看一下位置编码到底做的是一个什么样的事。

它本质上就是在原本的词向量x_i 上面额外地加上一个用于标定位置信息的位置向量p_i ，从而使得attention层的输入带有位置信息。

我们将attention层的运算进行具体的展开如下：

left{ begin{aligned} Q &= (x p) cdot W_Q \ K &= (x p) cdot W_K \ V &= (x p) cdot W_V \ A &= softmax(frac{Q cdot K^T}{sqrt{d}}) \ O &= A cdot V end{aligned} right.

我们将位置向量p 写入之后可以得到:

left{ begin{aligned} Q cdot K^T &= xW_Q cdot W_K^T x^T xW_Q cdot W_K^T p^T pW_Q cdot W_K^T x^T pW_Q cdot W_K^T p^T\ O &= A cdot (xW_V pW_V) end{aligned} right.

因此，事实上位置向量的加入本质上也可以通过加入偏置矩阵的方式直接作用到Attention矩阵A 以及V 上面。

1. 经典相对位置编码

相对位置编码的思路来自于文献Self-Attention with Relative Position Representations。

如前所述，位置编码的核心就是给每一个位置添加一个具体的position embedding从而令attention层的输入可以识别出其具体的位置，但是由于句长的无限性所以限制了绝对位置编码的使用方法。

而相对位置编码的核心思路就是说通过一个滑动窗口，换句话来说，就是对于每一个位置i,j ，如果它们的相对距离相同，那么他们共享同一个position向量。

而对于句长特别长的输入，如果两个位置i,j 的距离特别大，那么我们就对其做一个截断，从而规避掉句长带来的限制。

而关于这部分内容的具体实现，文中首先去除了Query当中包含的位置信息，从而将Attention矩阵和输出Output变成了如下的形式：

left{ begin{aligned} Q &= x cdot W_Q \ K &= x cdot W_K \ V &= x cdot W_V \ A &= softmax(frac{Q cdot (K pW_K)^T}{sqrt{d}}) \ O &= A cdot (V pW_V) end{aligned} right.

然后，文中将两个位置相关的矩阵直接替换成了两个相对位置的偏移矩阵，具体而言：

left{ begin{aligned} A &= softmax(frac{Q cdot (K R_K)^T}{sqrt{d}}) \ O &= A cdot (V R_V) end{aligned} right.

其中，R_{i,j} 表示第j 个位置相对于第i 个位置的位置偏移向量，具体而言：

R_{i, j} = P[clip(i-j, p_{min}, p_{max})]

因此，R是一个三维矩阵，即R_K, R_V in mathbb{R}^{n times n times d} 。

故在计算中会略带一点特殊，具体而言可以表达如下：

代码语言：javascript复制

Attn = tf.math.softmax(
    (tf.einsum("bik,bjk->bij", Q, K)   tf.einsum("bik,ijk->bij", Q, R))/tf.math.sqrt(d)
)
O =  tf.einsum("bij,bjk->bik", Attn, V)   tf.einsum("bij,ijk->bik", Attn, R)

2. XLNet

XLNet较之经典的相对位置编码进一步移除了V上面的位置信息，所有的位置信息全部都只发生在attention矩阵上面。

因此，我们这里只需要考察attention矩阵在这里的具体形式。

如前所述，Attention权重矩阵事实上就是Query（Q ）和Key（K ）的内积，调整权重之后求一个softmax，因此，我们只需要看Q 和K 的内积部分即可。

事实上，在后续的各种相对位置编码当中，似乎都已经只在Attention矩阵当中加入位置信息来影响权重分布，而不会对value加入权重信息。

言归正传，XLNet的位置编码加入的方式具体如下：

Q cdot K^T = xW_Q cdot W_K^T x^T xW_Q cdot R^T uW_Q cdot W_K^T x^T vW_Q cdot R^T

其中，R 的定义和经典相对位置编码中的定义相同，而u,v 则是两个可训练的向量。

换成伪代码即：

代码语言：javascript复制

Attn = tf.math.softmax(
    (
        tf.einsum("bik,bjk->bij", Q, K) 
          tf.einsum("bik,ijk->bij", Q, R) 
          tf.einsum("bik,bjk->bij", tf.matmul(u, W_Q), K) 
          tf.einsum("bik,ijk->bij", tf.matmul(v, W_Q), R)
    )/tf.math.sqrt(d)
)
O =  tf.einsum("bij,bjk->bik", Attn, V)

3. T5

T5的位置信息编码则更加暴力一些，都不是使用相对位置的偏置向量，而是直接给出一个偏置矩阵，然后对这个矩阵进行训练。

具体而言：

Q cdot K^T = xW_Q cdot W_K^T x^T B

其中，B in mathbb{R}^{n times n} 就是一个权重矩阵。

代码语言：javascript复制

Attn = tf.math.softmax(
    (tf.einsum("bik,bjk->bij", Q, K)   B)/tf.math.sqrt(d)
)
O =  tf.einsum("bij,bjk->bik", Attn, V)

4. DeBerta

DeBerta矩阵的定义与T5相反，T5是去除了位置与token的交叉项，只保留相对位置产生的偏移矩阵，而DeBerta与之相反，它去除掉了相对位置产生的偏置矩阵，但是留下了两个位置与token之间的交叉项，并将之用相对位置矩阵的方式进行保留。

具体而言：

Q cdot K^T = xW_Q cdot W_K^T x^T xW_Q cdot W_K^T R^T R W_Q cdot W_K^T x^T

用伪代码表述就是：

代码语言：javascript复制

Attn = tf.math.softmax(
    (
        tf.einsum("bik,bjk->bij", tf.matmul(x, W_Q), tf.matmul(x, W_K)) 
          tf.einsum("bik,ijk->bij", tf.einsum("bil,lk->bik", x, W_Q), tf.einsum("kl,ijk->ijl", W_K, R)) 
          tf.einsum("ijk,bjk->bij", tf.einsum("ijk,kl->ijl", R, W_Q), tf.einsum("bil,lk->bik", x, W_K))
    )/tf.math.sqrt(d)
)
O =  tf.einsum("bij,bjk->bik", Attn, V)

3. RoPE方法介绍

RoPE（Rotary Position Embedding）位置编码是Rofermer这篇文献的核心贡献点。

他的核心想法就是，借用苏剑林自己的话说：

通过绝对位置编码的方式实现相对位置编码。

如前，我们已经注意到了，相对位置编码在实现上是直接作用于attention权重矩阵的，这样的实现方式使得类似Linformer这种直接先对Attention矩阵中间结果进行投影的方式无法实现（关于Linformer相关的内容也可以参考我的博客文献阅读：Linformer: Self-Attention with Linear Complexity）。

因此，苏剑林基于复数相乘的特性设计了如下的位置编码函数：

left{ begin{aligned} f_q(x_m, m) &= (W_Q x_m) cdot e^{imtheta} \ f_k(x_n, n) &= (W_K x_n) cdot e^{intheta} \ g(x_m, x_n, m, n) &= Re[(W_Q x_m) (W_K x_n) e^{i(m-n) theta}] end{aligned} right.

对于二维情况，我们可以给出一组可行解：

f(q, m) = begin{pmatrix} cos mtheta & -sin mtheta \ sin mtheta & cos mtheta end{pmatrix} begin{pmatrix} q_0 \ q_1 end{pmatrix}

我们很快可以仿照上述方式给出一组高维情况下的可行解：

此时，由R矩阵的稀疏性，我们可以直接用下述变换来进行替换：

f(q, m) = begin{pmatrix} cos mtheta_0 \ cos mtheta_0 \ cos mtheta_{d/2-1} \ cos mtheta_{d/2-1} end{pmatrix} otimes begin{pmatrix} q_0 \ q_1 \ ... \ q_{d-2} \ q_{d-1} end{pmatrix} begin{pmatrix} sin mtheta_0 \ sin mtheta_0 \ sin mtheta_{d/2-1} \ sin mtheta_{d/2-1} end{pmatrix} otimes begin{pmatrix} -q_1 \ q_0 \ ... \ -q_{d-1} \ q_{d-2} end{pmatrix}

而关于其具体实现，我们摘录苏剑林在他们自己在GitHub上面的伪代码实现如下：

代码语言：javascript复制

sinusoidal_pos.shape = [1, seq_len, hidden_size] # Sinusoidal position embeddings
qw.shape = [batch_size, seq_len, num_heads, hidden_size]  # query hiddens
kw.shape = [batch_size, seq_len, num_heads, hidden_size]  # key hiddens

cos_pos = repeat_elements(sinusoidal_pos[..., None, 1::2], rep=2, axis=-1)
sin_pos = repeat_elements(sinusoidal_pos[..., None, ::2], rep=2, axis=-1)
qw2 = stack([-qw[..., 1::2], qw[..., ::2]], 4)
qw2 = reshape(qw2, shape(qw))
qw = qw * cos_pos   qw2 * sin_pos
kw2 = K.stack([-kw[..., 1::2], kw[..., ::2]], 4)
kw2 = K.reshape(kw2, K.shape(kw))
kw = kw * cos_pos   kw2 * sin_pos

# Attention
a = tf.einsum('bjhd,bkhd->bhjk', qw, kw)