Question

1. 尽管 RNN 适应性很广，但是，由于梯度消失和爆炸导致 RNN 很难优化。在LSTM 中引入门控和梯度裁剪技术可能不足以完全解决这一问题。从经验上看，以前的工作发现：LSTM语言模型平均使用200个context words，表明有进一步改进的空间。

   另一方面，注意力机制中的长距离 word pairs 之间的直接联系可能会有助于优化，并学习长期依赖性。最近 《Character-level language modeling with deeper self-attention》 设计了一套辅助损失来训练深度 Transformer 网络从而用于 character-level 语言建模。该方法存在两个问题：

   • 尽管取得了成功，但该模型的训练是在几百个字符的分离的固定长度的 segment 上进行的，没有跨segment 的信息流。 由于固定的上下文长度，该模型无法捕捉到超出预定义上下文长度的任何长期依赖关系。
   • 此外，固定长度的 segment 是通过选择连续的符号块 symbol chunk来创建的，没有考虑句子或任何其他语义边界。因此，该模型缺乏必要的上下文信息从而无法很好地预测前几个symbol ，导致低效的优化和较差的性能。我们把这个问题称为上下文碎片化 context fragmentation 。

   为了解决上述固定长度上下文的局限性，论文 《Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context》提出了一个新的架构，叫做 Transformer-XL（意为 extra long）。论文将递归的概念引入 deep self-attention network。具体而言，论文不是为每个新的segment 从头开始计算 hidden state，而是复用在previous segments 中获得的 hidden state。复用的 hidden state 用于 current segment 的 memory ，在前后 segment 之间建立了一个递归连接 recurrent connection 。因此，建立非常长期的依赖关系的模型成为可能，因为信息可以通过递归连接 recurrent connection 来传播。同时，从前一个segment 传递信息也可以解决上下文碎片化的问题。

   RNN 是在 position 之间构建递归，Universal Transformer 是在 depth 之间构建递归，Transformer-XL 是在 segment 之间构建递归。

   通常一个 segment 代表一个样本，因此这也是样本之间构建递归。

   更重要的是，论文展示了使用相对位置编码 relative positional encoding 而不是绝对位置编码 absolute positional encoding 的必要性，以便在不引起时间混乱的情况下实现状态重用 state reuse。因此，作为一个额外的技术贡献，论文引入了一个简单但更有效的相对位置编码公式，该公式可以泛化到比训练期间看到的长度更长的序列。

   Transformer-XL 在五个数据集上获得了强有力的结果，这些数据集从word-level 语言建模到 character-level 语言建模。Transformer-XL 还能够生成相对连贯的、数千个 token 的长篇文章。

   坤文的主要技术贡献包括：

   • 在纯粹的自注意力模型 self-attention model 中引入递归的概念。
   • 推导出一个新颖的位置编码方案。

   这两种技术构成了一套完整的解决方案，因为其中任何一个单独的技术都不能解决固定长度上下文的问题。Transformer-XL 是第一个在word-level 语言建模到 character-level 语言建模上取得比 RNN 更好结果的自注意力模型。

2. 相关工作：为了捕获语言建模中的长距离上下文，一系列工作直接将更宽上下文的 representation 作为 additional input 输入到网络中。现有的工作有人工定义 context representation 的，也有依靠从数据中学到的document-level topic 。

   例如，可以把非常长上下文的 sum word embedding 作为额外的输入。

   更广泛地说，在通用序列建模中，如何捕获长期依赖性一直是一个长期研究问题。从这个角度来看，由于 LSTM 的普适性，人们在缓解梯度消失问题上做了很多努力来有助于优化，包括更好的初始化、辅助损失、增强的记忆结构memory structure、以及其他的修改RNN内部结构的方法。与他们不同的是，我们的工作是基于 Transformer 架构的，并表明语言建模作为一个现实世界的任务，受益于学习长期依赖性的能力。

3.1 模型

1. 给定一个 token 序列$\mathbf{x}=(x_1,\cdots ,x_T)$$ \mathbf x = (x_1,\cdots,x_T) $ ，语言建模 language modeling 的任务是估计联合概率$P(\mathbf{x})$$ P(\mathbf x) $ 。这个联合概率通常被自回归地分解为：

   $$P(\mathbf{x})=\prod _{t}P(x_t\mid {\mathbf{x}}_{<t})$$

   其中${\mathbf{x}}_{<t}$$ \mathbf x_{\lt t} $ 为序列截止到时刻$t$$ t $ （不包含）的上下文${\mathbf{x}}_{<t}=(x_1,\cdots ,x_{t-1})$$ \mathbf x_{\lt t} = (x_1,\cdots,x_{t-1}) $ 。

   在这项工作中，我们坚持采用标准的神经网络方法来建模条件概率。具体而言：

   • 一个神经网络将上下文${\mathbf{x}}_{<t}$$ \mathbf x_{\lt t} $ 编码到一个固定维度的隐状态 hidden state 中。
   • 然后将隐状态（一个向量）与每个单词的 word embedding相乘，从而得到一组logit 。
   • 将这组 logit 馈入 softmax 函数，从而得到关于 next token 的离散概率分布。

3.1.1 普通的 Transformer

1. 为了将 Transformer 或 self-attention 应用于语言建模，核心问题是如何训练Transformer 从而将一个任意长的上下文有效地编码为固定尺寸的representation 。

   理想的方法是用一个无条件的 Transformer 来处理整个上下文序列，但是由于资源有限，这通常是不可行的。

   一个可行但粗糙的近似方法是：将整个语料库分割成规模可控的较短的 segment，只在每个 segment内训练模型，忽略之前 segment的所有上下文信息。我们称之为普通的 Transformer 模型，并在下图 (a) 中可视化。在这种训练范式下，信息在前向传播和反向传播过程中都不会跨 segment 流动。

   使用固定长度的上下文有两个关键限制：

   • 首先，最大依赖长度被segment 长度所限。在 character-level 语言建模中，segment 长度为几百。
   • 其次，简单地将一个序列分割成固定长度的segment 将导致上下文碎片化问题。

   在评估过程的每一步，普通的 Transformer 模型也会消耗相同长度的segment （与训练 segment 长度相同），但仅在 segment 的最后一个位置做一个预测。然后在下一步，该segment 只向右移动了一个位置，而新的 segment 必须从头开始计算，如图 (b) 所示。这个过程确保了每个预测都利用了最长的上下文，同时也缓解了训练中遇到的上下文碎片化问题。然而，这种评估过程是非常昂贵的。我们将表明：我们提出的架构能够大幅提高评估速度。

   注意：训练阶段和评估阶段有两个地方不一致：

   • segment 移动的步长不一致：训练期间右移$L$$ L $ 个位置（$L$$ L $ 等于 segment 长度），验证期间右移一个位置。
   • 预测位置不一致：训练期间对 segment 的每个位置进行预测，而验证期间仅对 segment 的最后一个位置进行预测。这是为了和 segment 移动步长相匹配，使得每个位置仅进行一次预测。

   之所以训练期间 segment 移动步长更大，个人猜测是为了降低训练样本量。假设 segment 长度固定为$L$$ L $ ，如果移动步长为$L$$ L $ ，则每个训练 epoch 中每个 token 会出现一次；如果移动步长为 1，则每个训练 epoch 中每个 token 会出现$L$$ L $ 次。

   

3.1.2 Segment-Level Recurrence

1. 为了解决使用固定长度上下文的局限性，我们建议在 Transformer 架构中引入一个递归机制。在训练过程中，固定前一个segment 计算好的hidden state 序列，并在处理 next segment 时作为扩展上下文extended context 来重用，如下图 (a) 所示（图中的绿色路径表示扩展上下文）。

   尽管反向传播仍然保持在一个 segment 内，但这个额外的输入（即，前一个 segment 的hidden state 序列 ）允许网络利用历史信息，导致了对长期依赖性的建模能力，并避免了上下文碎片化。

   注意：

   • 在训练过程中，前一个 segment 的 hidden state 序列被冻住，不再更新它们的状态（前向传播）以及梯度（反向传播）。
   • 对于前一个 segment ，需要考虑每一层的 hidden state 序列（而不仅仅是最后一层）。

   

2. 具体而言，假设长度为$L$$ L $ 的连续的两个 segment 为：

   $${\mathbf{x}}_{\tau }=(x_{\tau ,1},\cdots ,x_{\tau ,L}),{\mathbf{x}}_{\tau +1}=(x_{\tau +1,1},\cdots ,x_{\tau +1,L})$$

   记${\mathbf{x}}_{\tau }$$ \mathbf x_\tau $ 的第$n$$ n $ 层 hidden state 序列为：${\mathbf{H}}_{\tau }^{(n)}={({\overrightarrow{\mathbf{h}}}_{\tau ,1}^{(n)},\cdots ,{\overrightarrow{\mathbf{h}}}_{\tau ,L}^{(n)})}^{\mathrm{\top }}\in {\mathbb{R}}^{L\times d}$$ \mathbf H_\tau^{(n)} = \left(\mathbf{\vec h}_{\tau,1}^{(n)},\cdots,\mathbf{\vec h}_{\tau,L}^{(n)}\right)^\top\in \mathbb R^{L\times d} $ ，其中第$i$$ i $ 行表示位置$i$$ i $ 的 hidden state${\overrightarrow{\mathbf{h}}}_{\tau ,i}^{(n)}\in {\mathbb{R}}^d$$ \mathbf{\vec h}_{\tau,i}^{(n)}\in \mathbb R^d $ ，$d$$ d $ 为 hidden state 维度。那么${\mathbf{x}}_{\tau +1}$$ \mathbf x_{\tau+1} $ 第$n$$ n $ 层 hidden state 序列的计算过程为：

   • 拼接第$n-1$$ n-1 $ 层的上下文：${\tilde{\mathbf{H}}}_{\tau +1}^{(n-1)}=\text{SG}\left({\mathbf{H}}_{\tau }^{(n-1)}\right)\circ {\mathbf{H}}_{\tau +1}^{(n-1)}$$ \tilde{\mathbf H}^{(n-1)}_{\tau+1} = \text{SG}\left(\mathbf H_\tau^{(n-1)}\right)\circ \mathbf H_{\tau+1}^{(n-1)} $ ，其中：$\text{SG}(\cdot )$$ \text{SG}(\cdot) $ 表示 stop-gradient，$\circ$$ \circ $ 表示沿着序列长度的维度拼接两个 hidden state 序列。

   • 生成 query, key, value ：

     $$\begin{array}{c}{\mathbf{Q}}_{\tau +1}^{(n)}={\mathbf{H}}_{\tau +1}^{(n-1)}{\mathbf{W}}_q^{\mathrm{\top }}\\ {\mathbf{K}}_{\tau +1}^{(n)}={\tilde{\mathbf{H}}}_{\tau +1}^{(n-1)}{\mathbf{W}}_k^{\mathrm{\top }}\\ {\mathbf{V}}_{\tau +1}^{(n)}={\tilde{\mathbf{H}}}_{\tau +1}^{(n-1)}{\mathbf{W}}_v^{\mathrm{\top }}\end{array}$$

     注意：query 用当前 segment 的上下文，而key/value 用扩展的上下文。这是因为我们只需要计算当前 segment 的 representation，这对应于 query 的形状。

   • 计算第$n$$ n $ 层的 hidden state 序列：${\mathbf{H}}_{\tau +1}^{(n)}=\text{Transformer-Layer}({\mathbf{Q}}_{\tau +1}^{(n)},{\mathbf{K}}_{\tau +1}^{(n)},{\mathbf{V}}_{\tau +1}^{(n)})$$ \mathbf H^{(n)}_{\tau+1} = \text{Transformer-Layer}\left(\mathbf Q^{(n)}_{\tau+1},\mathbf K^{(n)}_{\tau+1},\mathbf V^{(n)}_{\tau+1}\right) $ 。

   与标准的 Transformer 相比，关键的区别在于：key${\mathbf{K}}_{\tau +1}^{(n)}$$ \mathbf K^{(n)}_{\tau+1} $ 和 value${\mathbf{V}}_{\tau +1}^{(n)}$$ \mathbf V^{(n)}_{\tau+1} $ 是根据扩展上下文${\tilde{\mathbf{H}}}_{\tau +1}^{(n-1)}$$ \tilde{\mathbf H}^{(n-1)}_{\tau+1} $ 来计算的，而${\mathbf{H}}_{\tau }^{(n-1)}$$ \mathbf H_\tau^{(n-1)} $ 是从前一个 segment 缓存的。我们通过上图 (a) 中的绿色路径来强调这一特殊设计。由于这种递归机制应用于语料库的每两个连续的 segment ，因此它在hidden state中创造了一个segment-level 的递归。因此，有效利用的上下文可以远远超过两个segment 。

   这对于 batch 的组织是一个挑战，要求前后两个样本之间是连续的，并且不能随机选择样本。

3. 请注意，连续两个 segment 之间，${\mathbf{H}}_{\tau +1}^{(n)}$$ \mathbf H_{\tau+1}^{(n)} $ 和${\mathbf{H}}_{\tau }^{(n-1)}$$ \mathbf H_\tau^{(n-1)} $ 之间的递归依赖关系对每一层都右移了一位（整体右移一位），这与传统的RNN 语言模型中的同层递归不同。因此，最大可能的依赖长度与网络层数、segment 长度呈线性增长，即$O(N\times L)$$ O(N\times L) $ ，如上图 (b) 中的阴影区域所示，这里$N$$ N $ 为网络层数、$L$$ L $ 为 segment 长度。

   ${\overrightarrow{\mathbf{h}}}_{\tau +1,i}^{(n)}$$ \mathbf{\vec h}_{\tau+1,i}^{(n)} $ 依赖于$\{{\overrightarrow{\mathbf{h}}}_{\tau ,i+1}^{(n-1)},\cdots ,{\overrightarrow{\mathbf{h}}}_{\tau ,L}^{(n-1)},{\overrightarrow{\mathbf{h}}}_{\tau +1,1}^{(n-1)},\cdots {\overrightarrow{\mathbf{h}}}_{\tau +1,i}^{(n-1)}\}$$ \left\{\mathbf{\vec h}_{\tau,i+1}^{(n-1)},\cdots,\mathbf{\vec h}_{\tau,L}^{(n-1)},\mathbf{\vec h}_{\tau+1,1}^{(n-1)},\cdots\mathbf{\vec h}_{\tau+1,i}^{(n-1)}\right\} $ ，即第$n-1$$ n-1 $ 层中：序列${\mathbf{x}}_{\tau }$$ \mathbf x_{\tau} $ 的位置$i+1$$ i+1 $ 到位置$L$$ L $ 、以及序列${\mathbf{x}}_{\tau +1}$$ \mathbf x_{\tau+1} $ 中的位置$1$$ 1 $ 到位置$i$$ i $ ，一共$L$$ L $ 个位置。

   对于同层递归，则${\overrightarrow{\mathbf{h}}}_{\tau +1,i}^{(n)}$$ \mathbf{\vec h}_{\tau+1,i}^{(n)} $ 依赖于$\{{\overrightarrow{\mathbf{h}}}_{\tau ,1}^{(n-1)},\cdots ,{\overrightarrow{\mathbf{h}}}_{\tau ,i}^{(n-1)},{\overrightarrow{\mathbf{h}}}_{\tau +1,1}^{(n-1)},\cdots {\overrightarrow{\mathbf{h}}}_{\tau +1,i}^{(n-1)}\}$$ \left\{\mathbf{\vec h}_{\tau,1}^{(n-1)},\cdots,\mathbf{\vec h}_{\tau,i}^{(n-1)},\mathbf{\vec h}_{\tau+1,1}^{(n-1)},\cdots\mathbf{\vec h}_{\tau+1,i}^{(n-1)}\right\} $ 。

4. segment-Level 递归类似于截断的 BPTT （用于训练 RNN 语言模型）。然而，与截断的BPTT不同的是：我们的方法缓存了hidden state 的一个序列，而不仅仅是最后一个 hidden state ，并且应该与相对位置编码技术一起应用。

   注意，segment-Level 递归对于每一层，都需要缓存 hidden state 的一个序列。

5. 除了实现超长上下文和解决上下文碎片化问题，递归方案带来的另一个好处是评估速度明显加快。具体而言，在评估过程中，先前的segment 的 representation 可以被重用，而不是像普通 Transformer 那样从头开始计算。在我们对enwiki8的实验中，Transformer-XL在评估过程中比普通 Transformer 模型快 1800 多倍。

6. 最后，请注意，递归方案不仅限于前面一个segment。理论上，我们可以在GPU内存允许的范围内缓存尽可能多的 previous segments，并在处理当前 segment 时复用所有这些 segment 作为额外的上下文。因此，我们可以缓存一个长度为$M$$ M $ 的 old hidden state 序列，跨越（可能）多个 segment ，并将它们称为 memory${\mathbf{M}}_{\tau }^{(n)}\in {\mathbb{R}}^{M\times d}$$ \mathbf M_\tau^{(n)}\in \mathbb R^{M\times d} $ 。

   总的上下文长度为$L+M$$ L+M $ 。

   在我们的实验中，我们在训练时将$M$$ M $ 设置为等于segment 长度$L$$ L $ ，在评估时将$M$$ M $ 设为$L$$ L $ 的若干倍。

   segment 长度$L$$ L $ 用于划分 segment，上下文长度$M$$ M $ 用于建模上下文，二者的作用不同。

   这里在训练期间和评估期间采用不同的上下文长度，会不会影响评估效果？毕竟训练数据分布和测试数据分布人为地导致了不一致（总的上下文长度不一致）。

3.1.3 Relative Positional Encoding

1. 为了重用前面 segment 的 hidden state ，有一个关键的技术挑战我们还没有解决：如何保持位置信息的一致性？

   在标准的 Transformer 中，序列顺序的信息是由一组位置编码positional encoding 来提供的，表示为$\mathbf{U}\in {\mathbb{R}}^{L_{max}\times d}$$ \mathbf U\in \mathbb R^{L_\max\times d} $ ，其中第$i$$ i $ 行${\overrightarrow{\mathbf{u}}}_i$$ \mathbf{\vec u}_i $ 对应于segment 内第$i$$ i $ 个绝对位置，$L_{max}$$ L_\max $ 定义了最大可能的建模长度。如果我们简单地将这种位置编码应用于我们的递归机制，那么 hidden state 序列的计算方式为：

   $$\begin{array}{c}{\mathbf{H}}_{\tau +1}=f({\mathbf{H}}_{\tau },{\mathbf{E}}_{{\mathbf{x}}_{\tau +1}}+{\mathbf{U}}_{1:L})\\ {\mathbf{H}}_{\tau }=f({\mathbf{H}}_{\tau -1},{\mathbf{E}}_{{\mathbf{x}}_{\tau }}+{\mathbf{U}}_{1:L})\end{array}$$

   其中：

   • ${\mathbf{E}}_{{\mathbf{x}}_{\tau }}\in {\mathbb{R}}^{L\times d}$$ \mathbf E_{\mathbf x_\tau}\in \mathbb R^{L\times d} $ 为 segment${\mathbf{x}}_{\tau }$$ \mathbf x_\tau $ 的 word embedding，$f(\cdot )$$ f(\cdot) $ 为一个变换函数，${\mathbf{U}}_{1:L}$$ \mathbf U_{1:L} $ 为$\mathbf{U}$$ \mathbf U $ 的前$L$$ L $ 行组成的矩阵。
   • ${\mathbf{H}}_{\tau }$$ \mathbf H_\tau $ 作为计算${\mathbf{H}}_{\tau +1}$$ \mathbf H_{\tau+1} $ 的扩展上下文，${\mathbf{E}}_{{\mathbf{x}}_{\tau +1}}+{\mathbf{U}}_{1:L}$$ \mathbf E_{\mathbf x_{\tau+1}} + \mathbf U_{1:L} $ 作为计算${\mathbf{H}}_{\tau +1}$$ \mathbf H_{\tau+1} $ 的 input 。

   $L_{max}\ge L$$ L_\max \ge L $ ，这是因为可能需要在测试期间泛化到 unseen 的序列长度。

   注意，${\mathbf{E}}_{{\mathbf{x}}_{\tau }}$$ \mathbf E_{\mathbf x_\tau} $ 和${\mathbf{E}}_{{\mathbf{x}}_{\tau +1}}$$ \mathbf E_{\mathbf x_{\tau+1}} $ 都与相同的位置编码${\mathbf{U}}_{1:L}$$ \mathbf U_{1:L} $ 相关。因此，该模型没有信息来区分任何$x_{\tau ,j}$$ x_{\tau,j} $ 和$x_{\tau +1,j}$$ x_{\tau+1,j} $ 之间的位置差异，$1\le j\le L$$ 1\le j\le L $ ，从而导致了纯粹的性能损失。

   为解决这个问题，基本的想法是相对位置编码。从概念上讲，位置编码给了模型一个关于如何收集信息的时间线索或 "bias"，也就是说，关注attend 哪个地方。以相对的方式来定义时间bias 是更直观和更可泛化的。例如，当一个query 向量${\overrightarrow{\mathbf{q}}}_{\tau ,i}$$ \mathbf{\vec q} _{\tau,i} $ 关注 key 向量${\left\{{\overrightarrow{\mathbf{k}}}_{\tau ,j}\right\}}_{j\le i}$$ \left\{\mathbf{\vec k}_{\tau,j}\right\}_{j\le i} $ 时，它不需要知道每个key 向量的绝对位置来识别segment 的时间顺序，只要知道每个key 向量${\overrightarrow{\mathbf{k}}}_{\tau ,j}$$ \mathbf{\vec k}_{\tau,j} $ 与${\overrightarrow{\mathbf{q}}}_{\tau ,i}$$ \mathbf{\vec q}_{\tau,i} $ 之间的相对距离（即$i-j$$ i-j $ ）就足够了。

   实际上，人们可以创建一组相对位置编码$\mathbf{R}\in {\mathbb{R}}^{L_{max}\times d}$$ \mathbf R\in \mathbb R^{L_\max\times d} $ ，其中第$i$$ i $ 行${\overrightarrow{\mathbf{r}}}_i\in {\mathbb{R}}^d$$ \mathbf{\vec r}_i\in \mathbb R^d $ 表示两个位置之间的相对距离为$i$$ i $ 。通过将相对距离动态地注入到 attention score，query 向量可以很容易地根据不同距离区分出$x_{\tau ,j}$$ x_{\tau,j} $ 和$x_{\tau +1,j}$$ x_{\tau+1,j} $ 的 representation，使状态重用机制变得可行。同时，我们不会丢失任何时间信息，因为绝对位置可以从相对距离中递归恢复。

2. 此前，相对位置编码的想法已经在机器翻译和音乐生成任务中得到了探索。在这里，我们提供了一种不同的编码形式，它不仅与绝对位置编码有一一对应关系，而且在经验上也具有更好的泛化性。

   • 首先，在标准的 Transformer中，同一个 segment 中的注意力得分可以分解为：

     $$\begin{array}{c}{a}_{i,j}^{\text{abs}}={\left({\mathbf{W}}_q({\overrightarrow{\mathbf{e}}}_{x_i}+{\overrightarrow{\mathbf{u}}}_i)\right)}^{\mathrm{\top }}\left({\mathbf{W}}_k({\overrightarrow{\mathbf{e}}}_{x_j}+{\overrightarrow{\mathbf{u}}}_j)\right)=\\ \underset{(a)}{\underbrace{{\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_k{\overrightarrow{\mathbf{e}}}_{x_j}}}+\underset{(b)}{\underbrace{{\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_k{\overrightarrow{\mathbf{u}}}_j}}+\underset{(c)}{\underbrace{{\overrightarrow{\mathbf{u}}}_i^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_k{\overrightarrow{\mathbf{e}}}_{x_j}}}+\underset{(d)}{\underbrace{{\overrightarrow{\mathbf{u}}}_i^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_k{\overrightarrow{\mathbf{u}}}_j}}\end{array}$$

     其中：${\overrightarrow{\mathbf{e}}}_{x_i}$$ \mathbf{\vec e}_{x_i} $ 为$x_i$$ x_i $ 的 embedding 向量，${\overrightarrow{\mathbf{u}}}_i$$ \mathbf{\vec u}_i $ 为位置$i$$ i $ 的 positional embedding ，${\mathbf{W}}_q$$ \mathbf W_q $ 为 query 的投影矩阵，${\mathbf{W}}_k$$ \mathbf W_k $ 为 key 的投影矩阵。

   • 然后，按照仅依赖于相对位置信息的思路，我们建议重写上述四项为：

     $$a_{i,j}^{\text{rel}}=\underset{(a)}{\underbrace{{\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_{k,E}{\overrightarrow{\mathbf{e}}}_{x_j}}}+\underset{(b)}{\underbrace{{\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_{k,R}{\overrightarrow{\mathbf{r}}}_{i-j}}}+\underset{(c)}{\underbrace{{\overrightarrow{\mathbf{u}}}^{\mathrm{\top }}{\mathbf{W}}_{k,E}{\overrightarrow{\mathbf{e}}}_{x_j}}}+\underset{(d)}{\underbrace{{\overrightarrow{\mathbf{v}}}^{\mathrm{\top }}{\mathbf{W}}_{k,R}{\overrightarrow{\mathbf{r}}}_{i-j}}}$$

     一种更简单直接的改写方式为：$a_{i,j}^{\text{rel}}={\left({\mathbf{W}}_q({\overrightarrow{\mathbf{e}}}_{x_i}+{\overrightarrow{\mathbf{r}}}_{i-j})\right)}^{\mathrm{\top }}\left({\mathbf{W}}_k({\overrightarrow{\mathbf{e}}}_{x_j}+{\overrightarrow{\mathbf{r}}}_{j-i})\right)$$ a_{i,j}^{\text{rel}} = \left(\mathbf W_q\left(\mathbf{\vec e}_{x_i}+\mathbf{\vec r}_{i-j}\right)\right)^\top\left(\mathbf W_k\left(\mathbf{\vec e}_{x_j}+\mathbf{\vec r}_{j-i}\right)\right) $ 。可以通过实验来验证效果。

     • 第一个改变是用相对位置编码${\overrightarrow{\mathbf{r}}}_{i-j}$$ \mathbf{\vec r}_{i-j} $ 来取代 (b) 和 (d) 中的绝对位置编码${\overrightarrow{\mathbf{u}}}_j$$ \mathbf{\vec u}_j $ 。这实质上反映了一个先验，即只有相对距离才是最重要的。注意，$\mathbf{R}$$ \mathbf R $ 是一个正弦编码矩阵，没有可学习的参数。

       实际上，绝对位置在一些任务中也同样重要，例如：句子里的第一个位置和最后一个位置都比较重要，可能包含特殊的语义。

     • 其次，我们引入一个可训练的参数$\overrightarrow{\mathbf{u}}\in {\mathbb{R}}^d$$ \mathbf{\vec u}\in \mathbb R^d $ 来取代 (c) 中的${\left({\mathbf{W}}_q{\overrightarrow{\mathbf{u}}}_i\right)}^{\mathrm{\top }}$$ \left(\mathbf W_q \mathbf{\vec u}_i\right)^\top $ 。在这种情况下，由于 query 向量对所有的 query position 都是相同的，因此这表明无论 query position 如何，对不同的单词的 attentive bias 应该保持不变。

       类似地，我们引入一个可训练的参数$\overrightarrow{\mathbf{v}}\in {\mathbb{R}}^d$$ \mathbf{\vec v}\in \mathbb R^d $ 来取代 (d) 中的${\left({\mathbf{W}}_q{\overrightarrow{\mathbf{u}}}_i\right)}^{\mathrm{\top }}$$ \left(\mathbf W_q \mathbf{\vec u}_i\right)^\top $ 。这表明无论 query position 如何，对不同相对位置的 attentive bias 应该保持不变。

       在绝对位置编码中，query 的位置、key 的位置都很重要，因此需要两个 positional embedding${\overrightarrow{\mathbf{u}}}_i,{\overrightarrow{\mathbf{u}}}_j$$ \mathbf{\vec u}_i,\mathbf{\vec u}_j $ 。

       在绝对位置编码中，只有 query 和 key 的相对位置的编码才重要，因此只有一个 positional embedding${\overrightarrow{\mathbf{r}}}_{i,j}$$ \mathbf{\vec r}_{i,j} $ 。

     • 最后，我们特意将两个权重矩阵${\mathbf{W}}_{k,E}$$ \mathbf W_{k,E} $ 和${\mathbf{W}}_{k,R}$$ \mathbf W_{k,R} $ 分开，分别产生 content-based 和 location-based 的 key 向量。

       $\overrightarrow{\mathbf{u}}$$ \mathbf{\vec u} $ 和$\overrightarrow{\mathbf{v}}$$ \mathbf{\vec v} $ 也分别对应于 content-based 和 location-based 的 attentive bias 向量。

3. 在相对位置编码中，每一项都有直观的含义：

   • ${\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_{k,E}{\overrightarrow{\mathbf{e}}}_{x_j}$$ \mathbf{\vec e}_{x_i}^\top\mathbf W_q^\top\mathbf W_{k,E}\mathbf{\vec e}_{x_j} $ ： 表示基于内容的寻址 addressing。
   • ${\overrightarrow{\mathbf{e}}}_{x_i}^{\mathrm{\top }}{\mathbf{W}}_q^{\mathrm{\top }}{\mathbf{W}}_{k,R}{\overrightarrow{\mathbf{r}}}_{i-j}$$ \mathbf{\vec e}_{x_i}^\top\mathbf W_{q}^\top\mathbf W_{k,R}\mathbf{\vec r}_{i-j} $ ：捕获内容相关的 positional bias 。
   • ${\overrightarrow{\mathbf{u}}}^{\mathrm{\top }}{\mathbf{W}}_{k,E}{\overrightarrow{\mathbf{e}}}_{x_j}$$ \mathbf{\vec u}^\top\mathbf W_{k,E}\mathbf{\vec e}_{x_j} $ ：捕获全局的 content bias 。
   • ${\overrightarrow{\mathbf{v}}}^{\mathrm{\top }}{\mathbf{W}}_{k,R}{\overrightarrow{\mathbf{r}}}_{i-j}$$ \mathbf{\vec v}^\top\mathbf W_{k,R}\mathbf{\vec r}_{i-j} $ ：捕获全局的 positional bias 。

   相比之下，《Self-attention with relative position representations》 仅考虑了 (a), (b) 两项，放弃了 (c), (d) 两个 bias 项。此外，《Self-attention with relative position representations》 将${\mathbf{W}}_k\mathbf{R}$$ \mathbf W_k \mathbf R $ 合并为单个矩阵可训练的矩阵$\hat{\mathbf{R}}$$ \hat{\mathbf R} $ ，这放弃了原始的正弦波位置编码中的 inductive bias 。相比之下，我们的 relative positional embedding$\mathbf{R}$$ \mathbf R $ 采用正弦波公式，从而可以在评估期间泛化到训练期间更长的序列上。

4. 将segment-level 递归与我们提出的 relative positional embedding 相结合，我们最终得到了Transformer-XL架构。

   注意，为了计算所有的 pair$(i,j)$$ (i,j) $ 的${\mathbf{W}}_{k,R}{\overrightarrow{\mathbf{r}}}_{i-j}$$ \mathbf W_{k,R}\mathbf{\vec r}_{i-j} $ ，其计算代价为$O(L^2)$$ O(L^2) $ 。我们在论文附录中展示了一个简单的计算过程，它将成本降低到$O(L)$$ O(L) $ 。

   但是为了计算$a_{i,j}^{\text{rel}}$$ a_{i,j}^{\text{rel}} $ ，仍然需要$O(L^2)$$ O(L^2) $ 的计算复杂度。

3.2 实验

3.2.1 实验结果

1. 这里比较不同数据集上语言建模的效果，评估指标为困惑度 perplexity: PPL 。

2. WikiText-103 数据集：现有最大的具有长期依赖性的 word-level 语言建模 benchmark 。它包含了来自 28K 篇文章的 1.03 亿个训练 token ，每篇文章的平均长度为 3.6K 个 token ，这可以测试建模长期依赖的能力。

   我们将训练时的注意力长度 （即，$L+M$$ L+M $ ）设定为 384 ，评估时设定为1600 。如下表所示，Transformer-XL 超越了之前的 SOTA ，将困惑度从 20.5 降低到 18.3 。

   

3. enwik8 数据集：包含1 亿字节的未处理的维基百科文本。

   24 层的 Transformer-XL 取得了新的SOTA 结果。训练时注意力长度为784，评估时注意力长度为 3800 。

   

4. text8 数据集：包含1亿个经过处理的维基百科字符，这些字符是通过转换为小写字母并删除 [a ~ z]以及空格以外的任何字符而创建的。

   同样地，24 层的 Transformer-XL （超参数与 enwik8 中的相同）取得了新的SOTA 结果。

   

5. One Billion Word 数据集：没有保留任何长期的依赖性，因为句子已经被混洗过了。因此，这个数据集主要测试了只对短期依赖关系进行建模的能力。

   尽管 Transformer-XL 主要是为了更好地捕捉长期依赖性，但它极大地提高了单个模型的 SOTA 。

   

6. Penn Treebank数据集：包含1百万 token，用于验证模型在小数据集上的表现。

   我们对 Transformer-XL 采用了 variational dropout 和 weight average 。通过适当的正则化，Transformer-XL 在没有预训练和微调的模型中取得了新的 SOTA 结果。

   

3.2.2 消融研究

1. 解决长期依赖问题：我们在 WikiText-103 上进行研究，这需要建模长期依赖性。结果如下所示。

   在比较的编码方案中，Shaw et al. (2018)（《Self-attention with relative position representations》）是相对位置编码，而 Vaswani et al. (2017) （《Attention is all you need》）和 Al-Rfou et al. (2018) （《Character-level language modeling with deeper self-attention》）是绝对位置编码。

   Ful/Half 损失指的是：对 segment 中所有位置/最近的一半位置计算交叉熵。我们发现，绝对位置编码只有在 Half 损失的情况下才能很好地工作，因为Half 损失在训练中排除了注意力长度很短的位置，从而获得更好的泛化。

   PPL init 表示评估时使用与训练长度相同的注意力长度；PPL best 表示评估时使用最佳注意力长度（由 Attn Len 列给出）时的结果。

   结论：

   • 递归机制和相对位置编码方案都是实现最佳性能的必要条件。虽然训练期间的反向传播长度只有128，但通过这两种技术，在测试期间注意力长度可以增加到640 。
   • 在 151M 参数的 Transformer-XL 中，测试期间，困惑度随着注意力长度的增加而减少。

   

2. 解决上下文碎片化问题：我们特意选择了一个不需要长期依赖的数据集，这样一来，递归机制的任何改进都可以归因于解决了上下文碎片化问题。具体来说，我们在 One Billion Word 数据集上进行实验，它只能从消除上下文碎片中受益。

   结论：

   • 即使在不需要长期依赖的情况下，使用segment-level 递归机制也能大幅提高性能。这与我们之前的讨论一致，即递归机制解决了上下文碎片化问题。
   • 我们的相对位置编码在短序列上也优于 Shaw et al. (2018) （《Self-attention with relative position representations》）。

   

3.2.3 其它

1. 相对有效长度 Relative Effective Context Length ：Transformer-XL 具有最大的相对有效长度。

   相对有效长度的定义参考原始论文。

   

2. 文本生成：在 WikiText-103 上训练。参考原始论文的附录。

3. 评估速度：由于状态重用，Transformer-XL 在评估时可以达到相比普通 Transformer 快 1874 倍的速度。