Question

1. 无监督表示学习 unsupervised representation learning 在自然语言处理领域取得了巨大的成功。通常情况下，这些方法首先在大规模的无标签文本语料库中预训练神经网络，然后在下游任务中对模型或 representation 进行微调。在这个共同的 high-level 思想下，人们在各种文献中探讨了不同的无监督预训练目标 unsupervised pretraining objective 。其中，自回归 autoregressive: AR 语言建模language modeling 和自编码 autoencoding: AE 是两个最成功的预训练目标。

   自回归语言建模旨在用自回归模型估计文本语料的概率分布。具体而言，给定一个文本序列$\mathbf{x}=(x_1,\cdots ,x_T)$$ \mathbf x = (x_1,\cdots,x_T) $ ，自回归语言建模将 likelihood 分解为前向乘积 forward product$p(\mathbf{x})=\prod _{t=1}^{T}p(x_t\mid {\mathbf{x}}_{<t})$$ p(\mathbf x) = \prod_{t=1}^Tp(x_t\mid \mathbf x_{\lt t}) $ 或后向乘积 backward product$p(\mathbf{x})=\prod _{t=T}^{1}p(x_t\mid {\mathbf{x}}_{>t})$$ p(\mathbf x)= \prod_{t=T}^1 p(x_t\mid \mathbf x_{\gt t}) $ 。一个参数化的模型（例如神经网络）被训练来建模每个条件分布。由于自回归语言模型只被训练来编码单向上下文（前向或后向），所以它不能有效地建模深度双向上下文 deep bidirectional context 。相反，下游的语言理解任务往往需要双向的上下文信息。这就造成了自回归语言建模和有效的预训练之间的 gap 。

   ${\mathbf{x}}_{<t}$$ \mathbf x_{\lt t} $ 为文本序列$\mathbf{x}$$ \mathbf x $ 前$t-1$$ t-1 $ 个位置的子序列，${\mathbf{x}}_{>t}$$ \mathbf x_{\gt t} $ 为文本序列$\mathbf{x}$$ \mathbf x $ 后$T-t$$ T-t $ 个位置的子序列。

   相比之下，基于自编码的预训练并不进行显式的密度估计 density estimation （$p(\mathbf{x})$$ p(\mathbf x) $ 就是文本序列$\mathbf{x}$$ \mathbf x $ 的概率密度），而是旨在从破坏的输入中重建原始数据。一个值得注意的例子是 BERT，它一直是 SOTA 的预训练方法。给定输入的 token 序列，其中输入的某一部分 token 被一个特殊的符号 [MASK] 所取代，模型被训练为从破坏的版本中恢复原始 token 。由于任务目标不包含密度估计，所以 BERT 可以利用双向上下文来重建原始数据。作为一个直接的好处，这弥补了上述自回归语言建模中的 bidirectional information gap ，导致了性能的提高。然而：

   • BERT 在预训练时使用的 [MASK] 等人造符号在微调时不存在于真实数据中，从而导致了 pretrain-finetune 的不一致。
   • 此外，由于 predicted token 在输入中被 masked 了，BERT 不能像自回归语言建模那样使用乘积规则 product rule 建立联合概率模型。换句话说，BERT 假设在给定 unmasked token 的条件下，predicted token 之间是相互独立的。这是过于简化的，因为在自然语言中普遍存在着高阶的、长程的依赖性。

   面对现有语言预训练目标的优点和缺点，在论文 《XLNet: Generalized Autoregressive Pretraining for Language Understanding》工作中，作者提出了一种广义的自回归方法，即 XLNet 。XLNet 同时利用了自回归语言建模和自编码的优点，并避免了它们的局限。

   • 首先，XLNet 不是像传统的自回归模型那样使用固定的前向分解顺序forward factorization order 或后向分解顺序 backword factorization order ，而是最大化关于分解顺序的所有可能的排列组合中，序列的期望对数似然 expected log likelihood 。由于排列操作permutation operation ，每个位置的上下文可以同时由左右两侧的 token 组成。在预期中，每个位置学会利用来自所有位置的上下文信息，即捕获双向的上下文。
   • 其次，作为一个广义的自回归语言模型，XLNet 不依赖于数据破坏 data corruption 。因此，XLNet 不会受到 BERT 所带来的pretrain-finetune discrepancy 的影响。同时，自回归目标还提供了一种自然的方法，可以使用乘积法则对 predicted token 的联合概率进行分解，消除了 BERT 中的独立性假设 independence assumption 。

   除了新颖的预训练目标外，XLNet 还改进了预训练的架构设计。

   • 受自回归语言建模最新进展的启发，XLNet 将 Transformer-XL 的segment 递归机制和相对编码方案 relative encoding scheme 融合到预训练中。根据经验，特别是在涉及较长文本序列的任务中，这会提高下游任务的性能。
   • 简单直接地将 Transformer(-XL) 架构应用于 permutation-based 的语言建模是行不通的，因为分解顺序是任意的、目标是模糊ambiguous 的。作为一个解决方案，作者建议重新参数化 reparameterize Transformer(-XL) 网络从而消除模糊性 ambiguity 。

   根据经验，XLNet 在 18 个任务上取得了 SOTA 的结果，即： 7 个 GLUE 语言理解任务，3个阅读理解任务（包括 SQuAD 和RACE ）、7 个文本分类任务（包括 Yelp 和 IMDB ）、以及 ClueWeb09-B 文档排序任务。在一组公平的比较实验下，XLNet 在多个 benchmark 上一直优于 BERT 。

2. 相关工作：permutation-based 的自回归建模的思想已经在 《Neural autoregressive distribution estimation》 和 《Made: Masked autoencoder for distribution estimation》中进行了探讨，但有几个关键的区别。以前的模型是无序 orderless的，而 XLNet 基本上是顺序感知 order-aware 的（带 positional encoding）。这对语言理解 language understanding 很重要，因为无序模型会退化为 bag-of-word ，缺乏基本的表达能力。

   上述差异源于动机 motivation 的根本差异：以前的模型旨在通过在模型中加入 "无序" 的归纳偏置 inductive bias 来改善密度估计，而 XLNet 的动机是使自回归语言模型学习双向上下文。

9.1 模型

9.1.1 背景

1. 这里我们首先针对语言预训练language pretraining 来回顾并比较传统的自回归语言建模和 BERT 。

2. 给定一个文本序列$\mathbf{x}=[x_1,\cdots ,x_T]$$ \mathbf x = [x_1,\cdots,x_T] $ ，自回归语言模型通过最大化前向自回归分解 forward autoregressive factorization 下的对数似然 likelihood 来进行预训练：

   $$\begin{array}{}\text{(3)}& \underset{\theta }{max}\log p_{\theta }(\mathbf{x})=\sum _{t=1}^T\log p_{\theta }(x_t\mid {\mathbf{x}}_{<t})=\sum _{t=1}^T\log \frac{\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{1:t-1}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x_t))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{1:t-1}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   其中：

   • ${\mathbf{x}}_{<t}={\mathbf{x}}_{1:t-1}=[x_1,\cdots ,x_{t-1}]$$ \mathbf x_{\lt t}=\mathbf x_{1:t-1}=[x_1,\cdots,x_{t-1}] $ 为$\mathbf{x}$$ \mathbf x $ 的前$t-1$$ t-1 $ 个位置的子序列，作为上下文。
   • ${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{1:t-1})$$ \mathbf{\vec h}_\theta(\mathbf x_{1:t-1}) $ 为通过神经网络模型（如 RNN 或 Transformer ）产生的 context representation ，$\theta$$ \theta $ 为模型的参数。
   • $\overrightarrow{\mathbf{e}}(x)$$ \mathbf{\vec e}(x) $ 为$x$$ x $ 的 embedding 。$\mathcal{V}$$ \mathcal V $ 为 vocabulary 。

3. 相比之下，BERT 是基于降噪自编码 denoising auto-encoding 的。具体来说，对于一个文本序列$\mathbf{x}=[x_1,\cdots ,x_T]$$ \mathbf x = [x_1,\cdots,x_T] $ ，BERT 首先通过随机设置$\mathbf{x}$$ \mathbf x $ 中的一部分（例如 15% ）的 token 为特殊符号 [MASK] 从而构建一个破坏的版本$\hat{\mathbf{x}}$$ \hat{\mathbf x} $ 。令这些 masked token 记做$\overline{\mathbf{x}}$$ \bar {\mathbf x} $ ，训练目标是根据$\hat{\mathbf{x}}$$ \hat{\mathbf x} $ 重建$\overline{\mathbf{x}}$$ \bar {\mathbf x} $ ：

   $$\begin{array}{}\text{(4)}& \underset{\theta }{max}\log p_{\theta }(\overline{\mathbf{x}}\mid \hat{\mathbf{x}})\simeq \sum _{t=1}^T{m}_t\log p_{\theta }(x_t\mid \hat{\mathbf{x}})=\sum _{t=1}^T{m}_t\log \frac{\exp ({\overrightarrow{\mathbf{h}}}_{t,\theta }(\hat{\mathbf{x}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x_t))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{h}}}_{t,\theta }(\hat{\mathbf{x}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   其中：

   • $m_t\in \{0,1\}$$ m_t\in \{0,1\} $ 表示$x_t$$ x_t $ 是否被 masked 。
   • ${\mathbf{H}}_{\theta }$$ \mathbf H_\theta $ 是一个 Transformer ，它将一个长度为 T 的文本序列$\hat{\mathbf{x}}$$ \hat{\mathbf x} $ 映射到一个 hidden vector 序列：${\mathbf{H}}_{\theta }(\mathbf{x})=[{\overrightarrow{\mathbf{h}}}_{1,\theta }(\mathbf{x}),\cdots ,{\overrightarrow{\mathbf{h}}}_{T,\theta }(\mathbf{x})]$$ \mathbf H_\theta(\mathbf x) = \left[\mathbf {\vec h}_{1,\theta}(\mathbf x),\cdots,\mathbf {\vec h}_{T,\theta}(\mathbf x)\right] $ 。$\theta$$ \theta $ 为 Transformer 的参数，${\overrightarrow{\mathbf{h}}}_{t,\theta }(\mathbf{x})$$ \mathbf {\vec h}_{t,\theta}(\mathbf x) $ 为位置$t$$ t $ 的 hidden vector 。

   可以看到：在自回归语言建模中，context representation 为${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{1:t-1})$$ \mathbf{\vec h}_\theta(\mathbf x_{1:t-1}) $ ，即模型在位置$t$$ t $ 仅能看到前面$t-1$$ t-1 $ 个位置的 token（即，${\mathbf{x}}_{1:t-1}$$ \mathbf x_{1:t-1} $ ）；在 BERT 中，context representation 为${\overrightarrow{\mathbf{h}}}_{t,\theta }(\mathbf{x})$$ \mathbf {\vec h}_{t,\theta}(\mathbf x) $ ，即模型在位置$t$$ t $ 能够看到所有的 token （即，$\mathbf{x}$$ \mathbf x $ ）。

4. 两种预训练目标的优点和缺点比较如下：

   • 独立性假设 Independence Assumption：正如$\simeq$$ \simeq $ 符号所强调的那样，BERT 基于独立性假设来分解联合条件概率$p_{\theta }(\overline{\mathbf{x}}\mid \hat{\mathbf{x}})$$ p_\theta\left(\bar{\mathbf x}\mid \hat{\mathbf x}\right) $ ，即，所有 mask token$\overline{\mathbf{x}}$$ \bar{\mathbf x} $ 都是独立重建的。

     相比之下，自回归语言建模目标使用普遍适用的乘积规则对$p_{\theta }(\mathbf{x})$$ p_\theta(\mathbf x) $ 进行分解，而没有这种独立性假设。

   • 输入噪声 Input Noise：BERT 的输入包含像 [MASK] 这样的人工符号，而这些符号在下游任务中从未出现过，这就造成了 pretrain-finetune discrepancy。像 BERT 论文中那样用原始 token 替换 [MASK] 并不能解决问题，因为原始 token 只能以很小的概率被使用，否则$\underset{\theta }{max}\log p_{\theta }(\overline{\mathbf{x}}\mid \hat{\mathbf{x}})$$ \max_\theta \log p_\theta\left(\bar{\mathbf x}\mid \hat{\mathbf x}\right) $ 是没有意义的优化（因为要预测的标签就在输入中）。

     相比之下，自回归语言建模并不依赖于任何输入破坏 input corruption ，因此不会受到这个问题的影响。

   • 上下文不一致 Context Dependency：自回归 representation${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{1:t-1})$$ \mathbf{\vec h}_\theta(\mathbf x_{1:t-1}) $ 仅以位置$t$$ t $ 之前的 token 作为条件（即，左侧的 token ）。

     相比之下， BERT representation${\overrightarrow{\mathbf{h}}}_{t,\theta }(\mathbf{x})$$ \mathbf {\vec h}_{t,\theta}(\mathbf x) $ 可以同时获得两侧的上下文信息。因此，BERT 目标允许对模型进行预训练以更好地捕捉双向的上下文。

9.1.2 目标：排列语言建模

1. 根据上面的比较，自回归语言模型和 BERT 拥有各自独特的优势。一个自然的问题是：是否存在一种预训练目标，既能带来两者的优点又能避免它们的缺点？

   借用 orderless NADE （《Neural autoregressive distribution estimation》）的思路，我们提出了排列语言建模 permutation language modeling 目标，它不仅保留了自回归模型的优点，而且还允许模型捕获双向上下文。

   具体而言，对于一个长度为$T$$ T $ 的文本序列$\mathbf{x}$$ \mathbf x $ ，有$T!$$ T! $ 种不同的顺序来进行有效的自回归分解 autoregressive factorization 。直观地说，如果模型参数在所有分解顺序中都是共享的，那么在预期中，模型将学会从两侧的所有位置收集信息。

   为了形式化这个思想，令${\mathcal{Z}}_T$$ \mathcal Z_T $ 是长度为$T$$ T $ 的索引序列$[1,2,\cdots ,T]$$ [1,2,\cdots,T] $ 的所有可能的排列的集合。我们用$z_t$$ z_t $ 和${\mathbf{z}}_{<t}$$ \mathbf z_{\lt t} $ 来表示一个排列$\mathbf{z}\in {\mathcal{Z}}_T$$ \mathbf z \in \mathcal Z_T $ 的第$t$$ t $ 个元素和前$t-1$$ t-1 $ 个元素。那么，我们提出的排列语言建模目标可以表示为：

   $$\begin{array}{}\text{(5)}& \underset{\theta }{max}{\mathbb{E}}_{\mathbf{z}\in {\mathcal{Z}}_T}[\sum _{t=1}^T\log p_{\theta }(x_{z_t}\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})]\end{array}$$

   基本上，对于一个文本序列$\mathbf{x}$$ \mathbf x $ ，我们一次采样一个分解顺序$\mathbf{z}$$ \mathbf z $ ，并根据分解顺序对 likelihood$p_{\theta }(\mathbf{x})$$ p_\theta(\mathbf x) $ 进行分解。由于相同的模型参数在训练期间在所有的分解顺序之间都是共享的，在预期中，$x_t$$ x_t $ 已经看到了序列中每一个可能的元素$x_i\ne x_t$$ x_i\ne x_t $ ，因此能够捕获到双向上下文。此外，由于这个目标适合于自回归框架，它自然避免了前面讨论的独立假设和 pretrain-finetune discrepancy 。

   前向自回归分解和后向自回归分解分别采用了两种特殊的分解顺序：$\mathbf{z}=[1,2,\cdots ,T],\mathbf{z}=[T,T-1,\cdots ,1]$$ \mathbf z=[1,2,\cdots,T], \mathbf z=[T,T-1,\cdots,1] $ 。

2. Permutation 的备注：所提出的目标只是排列分解顺序 factorization order ，而不是序列顺序 sequence order 。换句话说，我们保持原始的序列顺序，使用对应于原始序列的positional encoding ，并依靠 Transformer 中恰当的 attention mask 来实现分解顺序的排列。请注意，这种选择是必要的，因为模型在微调期间只会遇到具有自然顺序的文本序列。

   XLNet 在实现过程中并未采样$\mathbf{z}$$ \mathbf z $ ，而是通过生成合适的 attention mask 来达到采样$\mathbf{z}$$ \mathbf z $ 的效果。

   为了提供一个总体概览，我们在下图中展示了一个例子：给定相同的输入序列$\mathbf{x}$$ \mathbf x $ ，但是以不同的分解顺序来预测 token$x_3$$ x_3 $ 。mem 表示 Transformer-XL 的 memory 机制。

   

9.1.3 架构：双流自注意力

1. 虽然排列语言建模目标具有理想的属性，但是标准 Transformer 的朴素实现 naive implementation 可能无法工作。为了说明这个问题，假设我们使用标准的 softmax 公式对 next-token 分布$p_{\theta }(X_{z_t}\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})$$ p_\theta(X_{z_t}\mid \mathbf x_{\mathbf z_{\lt t}}) $ 进行参数化 parameterize ，即：

   $$\begin{array}{}\text{(6)}& p_{\theta }(X_{z_t}=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})=\frac{\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   其中${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}})$$ \mathbf{\vec h}_\theta(\mathbf x_{\mathbf z_{\lt t}}) $ 表示由共享的 Transformer 网络生成的${\mathbf{x}}_{{\mathbf{z}}_{<t}}$$ \mathbf x_{\mathbf z_{\lt t}} $ 的 hidden representation （通过适当的掩码得到）。

   现在注意到：representation${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}})$$ \mathbf{\vec h}_\theta(\mathbf x_{\mathbf z_{\lt t}}) $ 并不依赖于它将预测哪个位置，即$z_t$$ z_t $ 的值。因此，无论目标位置如何，都会预测出相同的分布，这就无法学习到有用的 representation 。为了避免这个问题，我们建议重新参数化 next-token 分布，使其感知到目标位置：

   $$\begin{array}{}\text{(7)}& p_{\theta }(X_{z_t}=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})=\frac{\exp ({\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   其中${\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t)$$ \mathbf{\vec g}_\theta(\mathbf x_{\mathbf z_{\lt t}},z_t) $ 表示一种新的 representation 类型，它还将目标位置$z_t$$ z_t $ 作为输入。

   原始的 Transformer 没有这个问题，因为 Transformer 输入序列的分解顺序是固定的（$\mathbf{z}=[1,2,\cdots ,T]$$ \mathbf z=[1,2,\cdots,T] $ ），第$t$$ t $ 个要预测的 token 就是位于序列中的位置$t$$ t $ 。

   但是，在排列语言建模目标，由于分解顺序是随机的，因此第$t$$ t $ 个要预测的 token 的位置不确定（可能是原始序列中第一个位置、也可能是原始序列中最后一个位置）。

2. 标准的语言模型参数化失败的例子：考虑两个不同的排列${\mathbf{z}}^{(1)}$$ \mathbf z^{(1)} $ 和${\mathbf{z}}^{(2)}$$ \mathbf z^{(2)} $ ，并且它们之间满足：

   $$\begin{array}{}\text{(8)}& {\mathbf{z}}_{<t}^{(1)}={\mathbf{z}}_{<t}^{(2)},z_t^{(1)}=i\ne j=z_t^{(2)}\end{array}$$

   如果采用标准 Transformer 的朴素实现，则有：

   $$\begin{array}{}\text{(9)}& \underset{z_t^{(1)}=i,{\mathbf{z}}_{<t}^{(1)}={\mathbf{z}}_{<t}}{\underbrace{p_{\theta }(X_i=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})}}=\underset{z_t^{(2)}=j,{\mathbf{z}}_{<t}^{(2)}={\mathbf{z}}_{<t}}{\underbrace{p_{\theta }(X_j=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})}}=\frac{\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}}{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   从效果上看，两个不同的目标位置$i$$ i $ 和$j$$ j $ 共享完全相同的模型预测。然而，这两个位置的 ground-truth 分布应当是不同的。

3. 双流自注意力 Two-Stream Self-Attention：虽然 target-aware representation 的思想消除了 target prediction 中的模糊性 ambiguity ，但如何形式化${\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t)$$ \mathbf{\vec g}_\theta(\mathbf x_{\mathbf z_{\lt t}},z_t) $ 仍然是一个困难的问题。我们提出 "站" 在目标位置$z_t$$ z_t $ ，并依赖位置$z_t$$ z_t $ 通过注意力从上下文${\mathbf{x}}_{{\mathbf{z}}_{<t}}$$ \mathbf x_{\mathbf z_{\lt t}} $ 收集信息。

   目标位置$z_t$$ z_t $ 代表了目标 token 位于原始序列中的位置（而不是排列之后的位置，排列之后的位置就是$t$$ t $ ）。

   为了使这个参数化 parameterization 发挥作用，有两个要求在标准的 Transformer 架构中是矛盾的：

   • 为了预测 token$x_{z_t}$$ x_{z_t} $ ，${\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t)$$ \mathbf{\vec g}_\theta(\mathbf x_{\mathbf z_{\lt t}},z_t) $ 应该只使用位置$z_t$$ z_t $ 而不是内容$x_{z_t}$$ x_{z_t} $ ，否则任务目标就变得非常简单。
   • 为了预测$j>t$$ j>t $ 的其他token$x_{z_j}$$ x_{z_j} $ ，${\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t)$$ \mathbf{\vec g}_\theta(\mathbf x_{\mathbf z_{\lt t}},z_t) $ 也应该编码内容$x_{z_t}$$ x_{z_t} $ 从而提供完整的上下文信息。

   为了解决这样的矛盾，我们建议使用两组 hidden representation 而不是一组：

   • content representation${\overrightarrow{\mathbf{h}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{\le t}})$$ \mathbf{\vec h}_\theta(\mathbf x_{\mathbf z_{\le t}}) $ ，或缩写为${\overrightarrow{\mathbf{h}}}_{z_t}$$ \mathbf{\vec h}_{z_t} $ ，它的作用与 Transformer 中的标准 hidden state 类似。这个 representation 同时编码了上下文和$x_{z_t}$$ x_{z_t} $ 本身。

     注意，这里是小于等于号：${\mathbf{z}}_{\le t}$$ \mathbf z_{\le t} $ 。

   • query representation${\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t)$$ \mathbf{\vec g}_\theta(\mathbf x_{\mathbf z_{\lt t}},z_t) $ ，或缩写为${\overrightarrow{\mathbf{g}}}_{z_t}$$ \mathbf{\vec g}_{z_t} $ ，它只能访问上下文信息${\mathbf{x}}_{{\mathbf{z}}_{<t}}$$ \mathbf x_{\mathbf z_{\lt t}} $ 和位置$z_t$$ z_t $ ，但不能访问内容$x_{z_t}$$ x_{z_t} $ ，如前所述。

   在计算上：

   • 第一层查询流 query stream 以 trainable vector 来初始化（即，${\overrightarrow{\mathbf{g}}}_i^{(0)}=\overrightarrow{\mathbf{w}}$$ \mathbf{\vec g}_i^{(0)}=\mathbf{\vec w} $ ）。
   • 而第一层内容流 content stream 被设置为相应的 word embedding （即，${\overrightarrow{\mathbf{h}}}_i^{(0)}=\overrightarrow{\mathbf{e}}(x_i)$$ \mathbf{\vec h}_i^{(0)} = \mathbf{\vec e}(x_i) $ ）。

   对于每个自注意力层$m=1,2,\cdots ,M$$ m=1,2,\cdots,M $ ，两个表征流 representation stream 用一组共享的参数进行更新：

   $$\begin{array}{}\text{(10)}& \begin{array}{c}{\overrightarrow{\mathbf{g}}}_{z_t}^{(m)}\leftarrow \text{Attention}(\mathbf{Q}={\overrightarrow{\mathbf{g}}}_{z_t}^{(m-1)},\mathbf{K}\mathbf{V}={\overrightarrow{\mathbf{h}}}_{{\mathbf{z}}_{<t}}^{(m-1)};\theta ),\text{query stream:}\text{use}{z}_t\text{but cannot see}{x}_{z_t}\\ {\overrightarrow{\mathbf{h}}}_{z_t}^{(m)}\leftarrow \text{Attention}(\mathbf{Q}={\overrightarrow{\mathbf{h}}}_{z_t}^{(m-1)},\mathbf{K}\mathbf{V}={\overrightarrow{\mathbf{h}}}_{{\mathbf{z}}_{\le t}}^{(m-1)};\theta ),\text{content stream:}\text{use both}{z}_t\text{and}{x}_{z_t}\end{array}\end{array}$$

   其中：$\mathbf{Q},\mathbf{K},\mathbf{V}$$ \mathbf Q,\mathbf K,\mathbf V $ 分别表示注意力操作中的 query, key, value 。

   注意：query stream 中的 key, value 使用${\mathbf{z}}_{<t}$$ \mathbf z_{\lt t} $ （小于号）；content stream 中的 key, value 使用${\mathbf{z}}_{\le t}$$ \mathbf z _{\le t} $ （小于等于号）。

   content representation 的更新规则与标准的自注意力完全相同，因此在微调过程中，我们可以简单地放弃 query stream ，将 content stream 作为普通的 Transformer(-XL) 。

   最后，我们可以使用最后一层的 query representation${\overrightarrow{\mathbf{g}}}_{z_t}^{(M)}$$ \mathbf{\vec g}_{z_t}^{(M)} $ 来计算：

   $$\begin{array}{}\text{(11)}& p_{\theta }(X_{z_t}=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})=\frac{\exp ({\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x))}{\sum _{x^{\prime }\in \mathcal{V}}\exp ({\overrightarrow{\mathbf{g}}}_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{<t}},z_t{)}^{\mathrm{\top }}\overrightarrow{\mathbf{e}}(x^{\prime }))}\end{array}$$

   因为 query representation 包含了位置$z_t$$ z_t $ （而 content representation 不包含$z_t$$ z_t $ ），因此使用 query representation 来计算$p_{\theta }(X_{z_t}=x\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})$$ p_\theta(X_{z_t} = x\mid \mathbf x_{\mathbf z_{\lt t}}) $ 。

   query representation 会利用 content representation 来计算，而 content representation 就是传统的自注意力机制而不会用到 query representation 。

4. 双流自注意力的示意图如下图所示，其中分解顺序为 3 -> 2 -> 4 -> 1 而当位置$t=4$$ t=4 $ ，即$z_t=1$$ z_t=1 $ 。

   • 图 (a)：content stream ，${\overrightarrow{\mathbf{h}}}_1^{(0)}$$ \mathbf{\vec h}_1^{(0)} $ 为 query，$\{{\overrightarrow{\mathbf{h}}}_1^{(0)},{\overrightarrow{\mathbf{h}}}_2^{(0)},{\overrightarrow{\mathbf{h}}}_3^{(0)},{\overrightarrow{\mathbf{h}}}_4^{(0)}\}$$ \left\{\mathbf{\vec h}_1^{(0)},\mathbf{\vec h}_2^{(0)},\mathbf{\vec h}_3^{(0)},\mathbf{\vec h}_4^{(0)}\right\} $ 为 key/value 。

   • 图 (b)：query stream，${\overrightarrow{\mathbf{g}}}_1^{(0)}$$ \mathbf{\vec g}_1^{(0)} $ 为 query，$\{{\overrightarrow{\mathbf{g}}}_2^{(0)},{\overrightarrow{\mathbf{g}}}_3^{(0)},{\overrightarrow{\mathbf{g}}}_4^{(0)}\}$$ \left\{\mathbf{\vec g}_2^{(0)},\mathbf{\vec g}_3^{(0)},\mathbf{\vec g}_4^{(0)}\right\} $ 为 key/value 。

   • 图 (c)：在 attention mask 中，第$i$$ i $ 行代表位置$i$$ i $ （原始序列的顺序）的 mask ，白色代表不可见（掩码）、红色代表可见。 query stream 无法看到当前位置的内容，因此相比 conent stream 的 attention mask，query stream 的 attention mask 掩码了对角线。

     这就是通过生成合适的 attention mask 来达到采样$\mathbf{z}$$ \mathbf z $ 的效果。

     例如，$z_t=1$$ z_t = 1 $ （即 attention mask 的第一行）：

     • 由于 content stream 中它可以看到所有位置（包括它自己），因此 attention mask 第一行全部是红色（可见）。
     • 由于 query stream 中它可以看到除了自己之外的所有其它位置，因此 attention mask 第一行除了第一个位置之外全部是红色。

   

5. 部分预测 Partial Prediction ：虽然排列语言建模目标有几个好处，但由于排列组合，它是一个更具挑战性的优化问题，并在实验中导致收敛缓慢。为了降低优化难度，我们选择仅预测分解顺序中的最后一批 token 。

   正式地，我们把$\mathbf{z}$$ \mathbf z $ 拆分成一个 non-target 子序列${\mathbf{z}}_{\le c}$$ \mathbf z_{\le c} $ 和一个 target 子序列${\mathbf{z}}_{>c}$$ \mathbf z_{\gt c} $ ，其中$c$$ c $ 是拆分点。我们的目标是：给定 non-target 子序列的条件下最大化 target 子序列的对数似然 log-likelihood ，即：

   $$\begin{array}{}\text{(12)}& \underset{\theta }{max}{\mathbb{E}}_{\mathbf{z}\sim {\mathcal{Z}}_T}[\log p_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{>c}}\mid {\mathbf{x}}_{{\mathbf{z}}_{\le c}})]={\mathbb{E}}_{\mathbf{z}\sim {\mathcal{Z}}_T}[\sum _{t=c+1}^T\log p_{\theta }(x_{z_t}\mid {\mathbf{x}}_{{\mathbf{z}}_{<t}})]\end{array}$$

   注意：${\mathbf{z}}_{>c}$$ \mathbf z_{\gt c} $ 被选为目标，因为在给定当前分解顺序$\mathbf{z}$$ \mathbf z $ 的条件下，它拥有序列中最长的上下文。

   我们使用一个超参数$K$$ K $ ，使得大约$1/K$$ 1/K $ 的 token 被选中从而用于预测，即$T/(T-c)\simeq K$$ T/(T-c) \simeq K $ 。对于未被选择的 token ，它们的 query representation 不需要计算，这就节省了速度和内存。

   这里假设序列的长度为$T$$ T $ ，因此$\mathbf{z}\sim {\mathcal{Z}}_T$$ \mathbf z\sim \mathcal Z_T $ 。对于有效长度较短的序列，用$|\mathbf{z}|$$ |\mathbf z| $ 代替上式中的$T$$ T $ 。

6. 这里我们对所提出的排列语言建模目标进行了详细的可视化，包括 reusing memory 机制（又称递归机制）、如何使用注意力掩码来排列分解顺序、以及两个注意力流的区别。如 Figure 3 和 Figure 4 所示，给定当前位置$z_t$$ z_t $ ，注意力掩码由排列（或分解顺序）$\mathbf{z}$$ \mathbf z $ 决定，这样只有排列中$z_t$$ z_t $ 之前出现的 token$z_i,i<t$$ z_i,i\lt t $ 才可以被关注。

   此外，比较 Figure 3 和 Figure 4 ，我们可以看到 query stream 和 content stream 是如何通过 attention mask 在特定排列中工作的。主要的区别是： query stream 不能做自注意力、不能访问当前位置上的 token ，而 content stream 则执行正常的自注意力。

   

   

9.1.4 融合 Transformer-XL 的思想

1. 由于我们的目标函数符合自回归框架，我们将 SOTA 的自回归语言模型 Transformer-XL 纳入我们的预训练框架，并以它命名我们的方法（即，XLNet ）。我们融合了 Transformer-XL 中的两项重要技术，即相对位置编码方案 relative positional encoding scheme 、段递归机制 segment recurrence mechanism 。

   如前所述，我们基于原始序列应用相对位置编码，这很直接。现在我们讨论如何将递归机制融合到所提出的 permutation setting 中，并使模型能够重用 previous segments 的 hidden state 。在不失一般性的情况下，假设我们有来自长序列$\mathbf{s}$$ \mathbf s $ 的两个 segment ，即$\tilde{\mathbf{x}}={\mathbf{s}}_{1:T}$$ \tilde{\mathbf x} = \mathbf s_{1:T} $ ，$\mathbf{x}={\mathbf{s}}_{T+1:2T}$$ \mathbf x=\mathbf s_{T+1:2T} $ 。令$\tilde{\mathbf{z}}$$ \tilde{\mathbf z} $ 和$\mathbf{z}$$ \mathbf z $ 分别表示$[1,\cdots ,T]$$ [1,\cdots,T] $ 和$[T+1,\cdots ,2T]$$ [T+1,\cdots,2T] $ 的排列。然后，基于排列$\tilde{\mathbf{z}}$$ \tilde{\mathbf z} $ ，我们处理第一个 segment ，然后为每个层$m$$ m $ 缓存得到的 content representation${\widetilde{\overrightarrow{\mathbf{h}}}}^{(m)}$$ \tilde{\mathbf{\vec h}}^{(m)} $ 。然后，对于下一个 segment$\mathbf{x}$$ \mathbf x $ ，带有 memory 的注意力机制可以写成：

   $$\begin{array}{}\text{(13)}& {\overrightarrow{\mathbf{h}}}_{z_t}^{(m)}\leftarrow \text{Attention}(\mathbf{Q}={\overrightarrow{\mathbf{h}}}_{z_t}^{(m-1)},\mathbf{K}\mathbf{V}=[{\widetilde{\overrightarrow{\mathbf{h}}}}^{(m-1)},{\overrightarrow{\mathbf{h}}}_{{\mathbf{z}}_{\le t}}^{(m-1)}];\theta )\end{array}$$

   其中$[\cdot ,\cdot ]$$ [\cdot,\cdot] $ 表示沿着序列的维度拼接两个向量序列。

   注意，这里不用缓存 query representation，因为只有 content representation 才会被用来作为 key 和 value 。

   注意：positional encoding 只取决于原始序列中的实际位置。因此，一旦得到 representation${\widetilde{\overrightarrow{\mathbf{h}}}}^{(m)}$$ \tilde{\mathbf{\vec h}}^{(m)} $ ，上述的注意力更新就与$\tilde{\mathbf{z}}$$ \tilde{\mathbf z} $ 无关。这允许在不知道前一个 segment 的分解顺序的情况下缓存和复用 memory 。在预期中，该模型学习利用上一个 segment 的所有分解顺序的 memory 。

   不管前一个 segment 的分解顺序如何，它始终位于当前 segment 之前，因此当前 segment 的任何位置都能看到所有的${\mathbf{s}}_{1:T}$$ \mathbf s_{1:T} $ 。

   query stream 也可以用同样的方法计算（只需要注意力机制中的修改 key 和 value 即可。）。

   最后，Figure 2 (c) 展示了所提出的具有双流注意力的排列语言建模的概况。更详细的介绍参考 Figure 3 和 Figure 4 。

9.1.5 建模多个 Segment

1. 许多下游任务都有多个 input segment ，例如，问答question answering: QA 中包含一个问题和一个上下文段落。我们现在讨论一下我们如何预训练 XLNet 以便在自回归框架中对多个 segment 进行建模。在预训练阶段，遵从 BERT ，我们随机抽取两个 segment （可以来自同一上下文，也可以来自不同的上下文），并将两个 segment 的拼接视为一个序列，以进行排列语言建模。我们仅复用属于同一上下文的 memory。

   具体而言，我们模型的输入与 BERT 类似：[A, SEP, B, SEP, CLS] ，其中 "SEP" 和 "CLS" 是两个特殊符号，"A" 和 "B" 是两个 segment 。尽管我们遵循 two-segment 的数据格式，XLNet-Large 没有使用 next sentence prediction 的目标，因为它在我们的消融研究中没有显示出一致的改进。

   注意，这里用于下游任务，即微调阶段。在预训练阶段，是没有多个 input segment 的，因为预训练没有 next sentence prediction 目标。

2. 相对段编码 Relative Segment Encoding ：从结构上看，与BERT 在每个位置的 word embedding 中增加一个绝对段嵌入 absolute segment embedding 不同，我们从 Transformer-XL 中扩展了 relative encoding 的思想，也对 segment 进行相对编码。

   注意，这里也是用于下游任务，即微调阶段。

   给定序列中的一对位置$i$$ i $ 和$j$$ j $ ，如果$i$$ i $ 和$j$$ j $ 来自同一 segment ，我们使用 segment encoding${\overrightarrow{\mathbf{s}}}_{i,j}={\overrightarrow{\mathbf{s}}}_{+}$$ \mathbf{\vec s}_{i,j} = \mathbf{\vec s}_+ $ ；如果来自不同的 segment ，则${\overrightarrow{\mathbf{s}}}_{i,j}={\overrightarrow{\mathbf{s}}}_{\mathrm{\_}}$$ \mathbf{\vec s}_{i,j} = \mathbf{\vec s}_\_ $ 。其中，${\overrightarrow{\mathbf{s}}}_{+}$$ \mathbf{\vec s}_+ $ 和${\overrightarrow{\mathbf{s}}}_{\mathrm{\_}}$$ \mathbf{\vec s}_\_ $ 是每个注意力头 attention head 的可学习模型参数。换句话说，我们仅考虑这两个位置是否在同一 segment 内，而不是考虑它们来自哪个具体的 segment 。这与 relative encoding 的核心思想是一致的，即，只对位置之间的关系进行建模。

   理论上讲，对于 input segment 数量为 2 的输入， relative encoding 和 absolute encoding 的模型容量是相同的，都是两个待学习的 embedding 参数。但是：

   • 二者的语义不同： relative encoding 的 embedding 空间编码了是否来自于同一个 segment； absolute encoding 的 embedding 空间编码了每个绝对 segment id 。
   • 二者的用法不同： relative encoding 用于计算 relative 注意力系数，然后将这个系数添加到正常的注意力权重中； absolute encoding 直接添加到 word embedding 从而直接计算注意力权重。

   当位置$i$$ i $ attend 位置$j$$ j $ 时（站在位置$i$$ i $ 的角度来看），segment encoding${\overrightarrow{\mathbf{s}}}_{i,j}$$ \mathbf {\vec s}_{i,j} $ 被用来计算注意力权重$a_{i,j}={({\overrightarrow{\mathbf{q}}}_i+\overrightarrow{\mathbf{b}})}^{\mathrm{\top }}{\overrightarrow{\mathbf{s}}}_{i,j}$$ a_{i,j} =\left (\mathbf{\vec q}_i + \mathbf{\vec b}\right) ^\top \mathbf{\vec s}_{i,j} $ ，其中${\overrightarrow{\mathbf{q}}}_i$$ \mathbf{\vec q}_i $ 是标准的注意力操作中的 query 向量，$\overrightarrow{\mathbf{b}}$$ \mathbf{\vec b} $ 是一个可学习的head-specific 的偏置向量 bias vector 。最后，这个值$a_{i,j}$$ a_{i,j} $ 被添加到正常的注意力权重中。

   使用 relative segment encoding 有两个好处：

   • 首先，relative encoding 的归纳偏置 inductive bias 可以改善泛化性。

   • 其次，relative encoding 为那些有两个以上 input segment 的任务中进行微调提供了可能，而这是使用 absolute segment encoding 所不能做到的。

     因为 absolute segment encoding 仅能编码训练期间看到的 segment id（即，segment id = A、segment id = B，这两个 id ）。

9.1.6 讨论和分析

a. 和 BERT 的比较

1. 比较公式$\underset{\theta }{max}\log p_{\theta }(\overline{\mathbf{x}}\mid \hat{\mathbf{x}})$$ \max_\theta \log p_\theta\left(\bar{\mathbf x}\mid \hat{\mathbf x}\right) $ 和$\underset{\theta }{max}{\mathbb{E}}_{\mathbf{z}\sim {\mathcal{Z}}_T}[\log p_{\theta }({\mathbf{x}}_{{\mathbf{z}}_{>c}}\mid {\mathbf{x}}_{{\mathbf{z}}_{\le c}})]$$ \max_{\theta} \mathbb E_{\mathbf z\sim \mathcal Z_T} \left[\log p_\theta(\mathbf x_{\mathbf z_{\gt c}}\mid \mathbf x_{\mathbf z_{\le c}})\right] $ ，我们发现 BERT 和 XLNet 都进行了部分预测，即仅预测序列中 token 的一个子集。

   • 这对 BERT 来说是一个必须的选择，因为如果所有的 token 都被 maksed 了，就不可能做出任何有意义的预测。
   • 此外，对于 BERT 和 XLNet 来说，部分预测仅预测具有足够上下文的 token ，起到了降低优化难度的作用。
   • 然而，前面内容讨论的独立性假设使得 BERT 无法建模预测目标之间的依赖性。

2. 为了更好地理解这种差异，让我们考虑一个具体的例子：[New, York, is, a, city] 。假设 BERT 和 XLNet 都选择 [New, York] 这两个 token 作为预测目标，并最大化$\log p(\text{New York}\mid \text{is a city})$$ \log p(\text{New York}\mid \text{ is a city}) $ 。又假设 XLNet 采样到了分解顺序 [is, a, city, New, York] 。在这种情况下，BERT 和 XLNet 分别简化为以下目标：

   $$\begin{array}{}\text{(14)}& \begin{array}{c}{\mathcal{J}}_{\text{BERT}}=\log p(\text{New}\mid \text{is a city})+\log p(\text{York}\mid \text{is a city})\\ {\mathcal{J}}_{\text{XLNet}}=\log p(\text{New}\mid \text{is a city})+\log p(\text{York}\mid \text{New, is a city})\end{array}\end{array}$$

   注意，XLNet 能够捕捉到一对目标 (New, York) 之间的依赖关系，而这个依赖关系被 BERT 忽略了。尽管在这个例子中，BERT 学到了一些依赖关系，如(New, city) 和 (York, city) 。但是很明显，在相同的目标下，XLNet 总是能学到更多的依赖关系，并且包含 "denser " 的有效训练信号（即，上下文更长）。

3. 为了证明超一般性观点（而不是单个例子），我们现在转向更正式的表达。受之前工作的启发（《Breaking the softmax bottleneck: A high-rank rnn language model》），给定一个序列$\mathbf{x}=[x_1,\cdots ,x_T]$$ \mathbf x=[x_1,\cdots,x_T] $ ，我们定义一组感兴趣的 target-context pair ：$\mathcal{I}=\{(x,\mathcal{U})\}$$ \mathcal I = \{(x,\mathcal U)\} $ ，其中$\mathcal{U}$$ \mathcal U $ 是$\mathbf{x}$$ \mathbf x $ 中的一组 token 从而构成$x$$ x $ 的上下文。直观而言，我们希望模型通过预训练 loss 项$\log p(x\mid \mathcal{U})$$ \log p(x\mid \mathcal U) $ 来学习$x$$ x $ 对$\mathcal{U}$$ \mathcal U $ 的依赖性。例如，给定上述的句子，感兴趣的 pair$\mathcal{I}$$ \mathcal I $ 可以被实例化为：

   $$\begin{array}{}\text{(15)}& \mathcal{I}=\{(x=\text{York},\mathcal{U}=\{\text{New}\}),(x=\text{York},\mathcal{U}=\{\text{city}\}),(x=\text{York},\mathcal{U}=\{\text{New,city}\}),\cdots \}\end{array}$$

   注意：$\mathcal{I}$$ \mathcal I $ 只是一个虚拟的概念，没有唯一的 ground-truth 。无论$\mathcal{I}$$ \mathcal I $ 是如何实例化的，我们的分析都将成立。

   给定一组 target token$\mathcal{T}$$ \mathcal T $ 和一组 non-target token$\mathcal{N}=\mathbf{x}\mathrm{\setminus }\mathcal{T}$$ \mathcal N = \mathbf x\backslash \mathcal T $ ，BERT 和 XLNet 都能最大化$\log p(\mathcal{T}\mid \mathcal{N})$$ \log p(\mathcal T\mid \mathcal N) $ ，但采用不同的公式：

   $$\begin{array}{}\text{(16)}& {\mathcal{J}}_{\text{BERT}}=\sum _{x\in \mathcal{T}}\log p(x\mid \mathcal{N});{\mathcal{J}}_{\text{XLNet}}=\sum _{x\in \mathcal{T}}\log p(x\mid \mathcal{N}\cup {\mathcal{T}}_{<x})\end{array}$$

   其中：${\mathcal{T}}_{<x}$$ \mathcal T_{\lt x} $ 表示$\mathcal{T}$$ \mathcal T $ 中根据分解顺序而位于$x$$ x $ 之前的 token 集合。

   这两个目标都由$\log p(x\mid {\mathcal{C}}_x)$$ \log p(x\mid \mathcal C_x) $ 形式的多个 loss 项组成，其中${\mathcal{C}}_x$$ \mathcal C_x $ 为$x$$ x $ 的上下文。直观而言，如果存在一个 target-context pair$(x,\mathcal{U})\in \mathcal{I}$$ (x,\mathcal U)\in \mathcal I $ ，使得$\mathcal{U}\subseteq {\mathcal{C}}_x$$ \mathcal U\sube \mathcal C_x $ ，那么 loss 项$\log p(x\mid {\mathcal{C}}_x)$$ \log p(x\mid \mathcal C_x) $ 为$x$$ x $ 和$\mathcal{U}$$ \mathcal U $ 之间的依赖性提供了一个训练信号。为便于讨论，如果$\mathcal{U}\subseteq {\mathcal{C}}_x$$ \mathcal U \sube \mathcal C_x $ ，则我们说一个 target-context pair$(x,\mathcal{U})\in \mathcal{I}$$ (x,\mathcal U)\in \mathcal I $ 被一个模型（或目标）所覆盖。

   给定这个定义，我们考虑两种情况：

   • 如果$\mathcal{U}\subseteq \mathcal{N}$$ \mathcal U\sube \mathcal N $ ，则依赖关系$(x,\mathcal{U})$$ (x,\mathcal U) $ 同时被 BERT 和 XLNet 所覆盖。
   • 如果$\mathcal{U}\subseteq \mathcal{N}\cup {\mathcal{T}}_{<x}$$ \mathcal U\sube \mathcal N\cup \mathcal T_{\lt x} $ 且$\mathcal{U}\cap {\mathcal{T}}_{<x}\ne \varphi$$ \mathcal U\cap \mathcal T_{\lt x} \ne \phi $ ，则该依赖关系只能被 XLNet 所覆盖，而无法被 BERT 所覆盖。因此，XLNet 能够比BERT 覆盖更多的依赖关系。换句话说，XLNet 目标包含更有效的训练信号，这将经验empirically 地带来更好的性能。

b. 和语言建模的比较

1. 像 GPT 这样的标准自回归语言模型只能覆盖依赖关系$(x=\text{York},\mathcal{U}=\{\text{New}\})$$ (x=\text{York}, \mathcal U=\{\text{New}\}) $ ，而无法覆盖依赖关系$(x=\text{New},\mathcal{U}=\{\text{York}\})$$ (x=\text{New}, \mathcal U=\{\text{York}\}) $ 。而 XLNet 则能够在所有分解顺序的期望中覆盖这两种情况。

   标准自回归语言建模的这种限制在现实世界的应用中可能是至关重要的。例如，考虑一个 span extraction 的问答任务，其中上下文是 "Thom Yorke is the singer of Radiohead"，问题是 "Who is the singer of Radiohead"。在自回归语言建模中，"Thom Yorke" 的 representation 不依赖于 "Radiohead" ，因此 "Thom Yorke"不会被标准方法（即，在上下文中所有的 token representation 上应用 softmax ）选为答案。

   更正式地说，考虑一个 context-target pair$(x,\mathcal{U})$$ (x,\mathcal U) $ ：

   • 如果$\mathcal{U}\cap {\mathcal{T}}_{<x}\ne \varphi$$ \mathcal U\cap \mathcal T_{\lt x} \ne \phi $ ，其中${\mathcal{T}}_{<x}$$ \mathcal T_{\lt x} $ 表示原始序列中$x$$ x $ 之前的token ，那么自回归语言建模无法覆盖该依赖关系。
   • 相比之下，XLNet 能够覆盖期望中的所有依赖关系。

2. 像 ELMo 这样的方法以浅层的方式将前向语言模型和后向语言模型拼接起来，这不足以对两个方向之间的深层交互进行建模。

c. 弥合语言建模和预训练之间的 gap

1. 由于缺乏双向上下文建模的能力，语言建模和预训练之间一直存在着 gap ，正如前面内容所分析的。一些机器学习从业者甚至质疑：如果语言建模不能直接改善下游任务，那么它是否有意义。

   XLNet 推广了语言建模并弥补了这个 gap 。因此，它进一步 "证实" 了语言建模的研究。此外，针对预训练而利用语言建模研究的快速进展也成为可能。作为一个例子，我们将 Transformer-XL 融合到 XLNet 中，从而证明最新的语言建模进展的有用性。

9.2 实验

9.2.1 预训练和实现

1. 遵从 BERT ，我们使用 BooksCorpus 和 English Wikipedia 作为我们预训练数据的一部分，它们合并起来有 13GB 的纯文本。此外，我们还包括 Giga5 （ 16GB文本）、ClueWeb 2012-B 和 Common Crawl 进行预训练。我们使用启发式方法激进地过滤掉ClueWeb 2012-B 和 Common Crawl 中短的或低质量的文章，结果分别得到 19GB 和 78GB 的文本。

   在使用 SentencePiece （《Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing》）进行 tokenization 后，我们为 Wikipedia 、BooksCorpus、Giga5、ClueWeb 和 Common Crawl 分别得到27.8B、1.09B、4.75B、4.30B 和 19.97B 个 subword piece ，共计 32.89B 个 subword piece。

2. 我们最大的模型 XLNet-Large 具有与 BERT-Large 相同的架构超参数，这导致了相似的模型大小。序列长度和 memory 长度分别被设置为 512 和 384 。

   我们在 512 个 TPU v3 芯片上对 XLNet-Large 进行了 500K 步的训练，使用 Adam 优化器，线性学习率衰减，batch size = 2048 ，这大约需要 2.5 天。据观察，模型在训练结束时仍然对数据欠拟合，但继续预训练对下游任务没有帮助，这表明给定优化算法，模型没有足够的容量来充分利用数据规模。然而，在这项工作中，我们避免训练一个更大的模型，因为它在微调方面的实际用途可能是有限的。

   此外，类似于 BERT-Base ，我们考虑只在 BooksCorpus + Wikipedia 上训练一个 XLNet-Base，用于消融研究、以及和 BERT 的公平比较。

3. 由于引入了递归机制，我们使用了一个双向的 data input pipeline ，其中前向和后向各占 batch size 的一半。

   双向的 data input pipeline 意思是：在 batch 中，既有正序（相对于原始序列顺序）的输入、又有逆序（相对于原始序列顺序）的输入。这是为了配合 span-based 预测。

   因为 span-based 预测直接将原始序列中连续$L$$ L $ 个 token 作为预测目标，顺序不变（如，从 I like New York, because ... 中截取(New, York)）。如果只有正序输入，那么这些预测目标之间只能捕获前向的依赖性（如，p(York | New)）。增加了逆序输入之后，这些预测目标之间就可以捕获后向的依赖性（如，p(New | York)）。注意，这里影响的是预测目标之间的依赖性，而不是预测目标和上下文之间的依赖性。

   为了训练 XLNet-Large ，我们将部分预测常数$K$$ K $ 设置为 6 。我们的微调程序遵循 BERT，除非另有说明。我们采用了一种 span-based 预测的思想，首先采样一个长度$L\in [1,2,\cdots ,5]$$ L\in [1,2,\cdots,5] $ ，然后在$(KL)$$ (KL) $ 个 token 的上下文中随机选择连续的、跨度为$L$$ L $ 的 token 作为预测目标。

   假设随机选择的位置为$(r,r+1,\cdots ,r+L-1)$$ (r,r+1,\cdots,r+L-1) $ ，则将这${\mathbf{z}}_{>c}$$ \mathbf z_{\gt c} $ 固定为$[r,r+1,\cdots ,r+L-1]$$ [r,r+1,\cdots,r+L-1] $ 并且顺序不变。而剩余的位置作为${\mathbf{z}}_{\le c}$$ \mathbf z_{\le c} $ （它们的顺序不重要，因为它们仅作为上下文而不会作为预测目标）。

   这种 span-based 的方法易于实现，但是它强迫预测目标是连续的，且预测目标之间保持原始序列的顺序不变。

4. 预训练 XLNet 的超参数如下表所示。

   

5. 微调 XLNet 的超参数如下表所示。

   Layer-wise decay 是指以自上而下的方式对各个层的学习率进行指数衰减。例如，假设第 24 层使用的学习率为$l$$ l $ ，Layer-wise衰减率为$\alpha$$ \alpha $ ，则第$m$$ m $ 层的学习率为$l\times {\alpha }^{24-m}$$ l\times \alpha ^{24-m} $ 。

   这意味着从上到下，更新的步幅越来越小。这隐含了一个约束：底层的更新更小而顶层的更新越大。

   

9.2.2 RACE 数据集

1. RACE 数据集包含了近 10 万个问题，这些问题来自于 12 到 18 岁之间的中国初高中学生的英语考试，答案由人类专家生成。这是最难的阅读理解数据集之一，涉及到具有挑战性的推理问题。此外，RACE 中段落的平均长度超过 300 ，这比其他流行的阅读理解数据集如 SQuAD 长很多。因此，这个数据集可以作为长文本理解的一个挑战性的 benchmark 。

   在微调过程中，我们使用的序列长度为 640 。如下表所示：

   • 单一模型 XLNet 的准确率比最佳 ensemble 高出 7.6 分。
   • 同样明显的是，XLNet 大大超过了其他预训练的模型，如 BERT 和 GPT 。

   由于 RACE 包含相对较长的段落，我们认为 XLNet 在这个数据集上获得巨大收益的原因之一是：除了自回归目标之外，XLNet 融合了 Transformer-XL 架构从而提高了对长文本建模的能力。

   

9.2.3 SQuAD 数据集

1. SQuAD 是一个具有两个任务的大规模阅读理解数据集。SQuAD1.1 包含了在给定段落中总是有相应答案的问题，而 SQuAD2.0 则引入了不可回答的问题（即，给定段落中不存在答案）。

   为了在 SQuAD2.0 上对 XLNet 进行微调，我们联合应用了类似于分类任务的逻辑回归损失（表明任务是否有答案）、和问答任务的标准 span extraction 损失。由于 v1.1 和 v2.0 在训练集中共享相同的可回答的问题，我们只需在 v2.0 上微调的模型中删除 answerability prediction 部分（即，任务是否有答案的部分），即可对 v1.1 进行评估。由于排行榜头部的方法都采用了某种形式的数据增强，我们在 SQuAD2.0 和 NewsQA 上联合训练了一个 XLNet 从而用于我们的排行榜 submission 。

   如下表所示：

   • XLNet 在排行榜上获得了 SOTA 的单一模型结果，超过了一系列基于 BERT 的方法。
   • 值得注意的是，在 v1.1 中，XLNet 的单一模型在 EM 指标上的表现比人类和最佳 ensemble 分别高出 7.6 分和 2.5 分。
   • 最后，为了与 BERT 直接比较从而消除排行榜 submission 上的额外技巧的影响，我们在验证集上将 XLNet 与 BERT 进行了比较。XLNet 在 v1.1 和 v2.0 的 F1 指标中大大超过了 BERT ，分别超出 3.6 分和 7.0 分。

   

9.2.4 文本分类

1. 遵从以前的文本分类工作（《Character-level convolutional networks for text classification》、《Adversarial training methods for semi-supervised text classification》），我们在以下 benchmark 上评估了 XLNet：IMDB、Yelp-2、Yelp-5、DBpedia、AG、Amazon-2 和 Amazon-5 。

   如下表所示，XLNet 在所有给定的数据集上取得了新的SOTA 结果，与 BERT 相比，在 IMDB、Yelp-2、Yelp-5、Amazon-2 和Amazon-5 上的错误率分别降低了 16%、18%、5%、9% 和 5% 。

   

9.2.5 GLUE 数据集

1. GLUE 数据集是一个包含 9 个自然语言理解任务的集合。测试集标签在公开发布的版本中被删除，所有用户必须在 evaluation server 上提交他们的预测，以获得测试集结果。

   在下表中，我们展示了多种 setting 的结果，包括单任务和多任务、以及单一模型和 ensemble 。

   • 在多任务 setting 中，我们在四个最大的数据集（即，NLI、SST-2、QNLI 和 QQP ）上联合训练 XLNet，并在其他数据集上微调网络。

   • 对于这四个大型数据集，我们只采用了单任务训练。

     即，多任务训练仅用于其他的数据集。

   • 对于 QNLI ，我们在提交测试集时采用了 《Multi-task deep neural networks for natural language understanding》中的 pairwise relevance ranking 方案。然而，为了与 BERT 进行公平的比较，我们对 QNLI 验证集的结果是基于标准的分类范式 classification paradigm 的。

   • 对于 WNLI ，我们使用 《A surprisingly robust trick for winograd schema challenge》 中描述的损失。

   可以看到：

   • 多任务 ensemble 的 XLNet 在公共排行榜的 9 个任务中的 7 个任务上取得了 SOTA 的结果。在最广泛的基准任务 MNLI 上，XLNet 将 "匹配" 和 "不匹配" 的 setting 分别提高了 2.0 分和 1.8 分。

     注意，排行榜上的竞争者采用了比 BERT 更好的技术，如蒸馏、修改的多任务损失、或元学习 meta learning ，但仍然低于XLNet 的表现。而 XLNet 除了使用标准的多任务学习方法外，没有采用额外的技巧。由于排行榜的目的不是为了消融研究或超参数调优，我们只在测试集上评估了我们最好的多任务模型。

   • 为了获得与 BERT 的直接比较，我们在验证集上运行一个单任务 XLNet 。如下表的最上面几行所示，XLNet 一直优于 BERT ，在 RTE、MNLI、CoLA、SST-2 和 STS-B 上分别提高了 13.4 分、3.2 分、3.0 分、2.4 分 和 1.8 分。

   

9.2.6 ClueWeb09-B 数据集

1. 遵从 《Convolutional neural networks for soft-matching n-grams in ad-hoc search》 的 setting，我们使用ClueWeb09-B 数据集来评估文档排序 document ranking 的性能。这些 query 是由 TREC 2009-2012Web Tracks 基于 50M 个文档创建的，任务是对使用标准检索方法检索到的前 100 个文档进行 rerank 。由于 document ranking 或 ad-hoc retrieval 主要涉及 low-level representation ，而不是 high-level 的语义，这个数据集可以作为评估 word embedding 质量的测试平台。

   我们使用预训练好的 XLNet 来抽取文档和 query 的 word embedding 而不进行微调，并采用 kernel pooling network （《End-to-end neural ad-hoc ranking with kernel pooling》）对文档进行排序。

   结果如下表所示：XLNet 大大超过了其他方法，包括使用与我们相同训练程序的 BERT 模型。这说明 XLNet 比 BERT 能更好地学习 low-level 的 word embedding 。

   注意，为了公平比较，我们排除了 《Word-entity duet representations for document ranking》中的结果（ ERR@20 为19.55 ，略差于我们），因为它使用了额外的实体相关数据。

   DCG@k 指标：$\sum _{i=1}^k\frac{\text{hit}(i)}{{\log }_2(i+1)}$$ \sum_{i=1}^k \frac{\text{hit}(i)}{\log_2(i+1)} $ ，其中$\text{hit}(i)$$ \text{hit}(i) $ 表示第$i$$ i $ 个推荐的 item 是否命中真实的目标 item ，取值为 1 或 0 。

   NDCG@k 指标：对 DCG@k 的归一化，归一化分母为$\sum _{i=1}^N\frac{1}{{\log }_2(i+1)}$$ \sum_{i=1}^N \frac{1}{\log_2(i+1)} $ ，其中$N$$ N $ 为总的真实目标 item 数量（小于等于$k$$ k $ ）。

   

9.2.7 消融研究

1. 基于四个具有不同特点的数据集，我们进行了一项消融研究从而了解每个设计选择的重要性。具体来说，我们希望研究的主要有三个方面：

   • 排列语言建模目标的有效性，具体而言，是与 BERT 使用的降噪自编码目标相比。
   • 使用 Transformer-XL 作为 backbone 神经架构、以及采用 segment-level 递归（即，使用 memory ）的重要性。  
   • 一些实施细节的必要性，包括 span-based 的预测、双向 input pipeline 和 next-sentence prediction 。

   考虑到这些目的，在下表中，我们比较了具有不同实施细节的 6 个 XLNet-Base 变体（第 3 ~ 8 行）、原始的 BERT-Base 模型（第1 行），以及一个额外的 Transformer-XL baseline （第 2 行）。这个 Transformer-XL baseline 用 BERT 中使用的降噪自编码 enoising auto-encoding: DAE 目标训练，但具有双向 input pipeline 。为了进行公平的比较，所有的模型都是基于一个12 层的架构，具有与 BERT-Base 相同的模型超参数，并且只对 Wikipedia + BooksCorpus 进行训练。所有报告的结果都是 5 次运行的中位数。

   • 检查结果的第 1 ~ 4 行，我们看到用不同的$K$$ K $ 值训练的两个 full XLNet-Base 模型在各任务中的表现明显优于 BERT 、以及 DAE 训练的 Transformer-XL ，这显示了排列语言建模目标的优越性。

     同时，有趣的是，DAE 训练的 Transformer-XL 在 RACE 和 SQuAD 等长文本的任务中取得了比 BERT 更好的表现，这表明Transformer-XL 在语言建模方面的卓越表现。

     DAE + Transformer-XL 与 BERT 不同的地方在于：相对位置编码、以及 segment-level 递归。

   • 接下来，如果我们去掉 memory 缓存机制（第 5 行），则性能明显下降，特别是对于涉及 4 个任务中最长上下文的 RACE 。

   • 此外，第 6 ~ 7 行显示，span-based 预测和双向 input pipeline 在 XLNet 中都发挥了重要作用。

   • 最后，我们意外地发现，在最初的 BERT 中提出的 next-sentence prediction 目标在我们的 setting 中不一定能带来改进。相反，除了RACE 数据集，next-sentence prediction 往往会损害性能。因此，当我们训练 XLNet-Large 时，我们排除了next-sentence prediction 目标。