八、BERT[2018]

1. 语言模型预训练已被证明对改善许多自然语言处理任务是有效的。这些任务包括：

   • sentence-level 的任务，如自然语言推理 natural language inference 和转述paraphrasing ，其目的是通过整体分析来预测句子之间的关系。
   • token-level 的任务，如命名实体识别 named entity recognition: NER 和 SQuAD 问答 question answering: QA ，其中模型需要在 token-level 产生细粒度的输出。

   目前有两种策略将预训练的 language representation 应用于下游任务： feature-based 和 fine-tuning ：

   • feature-based方法（如 ELMo）使用 tasks-specific 架构，其中使用预训练的 representation作为额外的特征。
   • fine-tuning方法（如 GPT ），引入了最小的 task-specific 参数，并通过简单地微调 pretrained parameter 从而对下游任务进行训练。

   在之前的工作中，这两种方法在pre-training 期间共享相同的目标函数，其中它们使用单向语言模型来学习通用的 language representation 。

   即，feature-based方法和fine-tuning方法采用相同的预训练方式，但是在应用到下游任务阶段才有所差异。

   论文 《BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding》 认为：目前的技术严重限制了 pre-trained representation 的能力，特别是对于微调 fine-tuning 方法。主要的限制是：标准的语言模型是单向的，这就限制了在预训练中可以使用的架构。例如，在 GPT 中，作者使用了一个从左到右的架构，其中在 Transformer 的self-attention layer 中每个 token 只能关注前面的 token 。

   • 对于sentence-level 的任务，这样的限制是次优的。
   • 对于 token-level 的任务（如 SQuAD 问答任务），当应用基于微调的方法时，这样的限制可能是毁灭性的。因为在这种情况下，从两个方向融合上下文是至关重要的（因为可能需要关注后面的 token 而不是前面的，从而找到问题的答案）。

   在论文 《BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding》 中，作者通过从 Transfromer 中提出 Bidirectional Encoder Representation: BERT 来改善基于微调的方法。BERT 通过提出一个新的预训练目标来解决前面提到的单向约束：masked language model: MLM 任务，其灵感来自 Cloze 任务（即，完形填空任务）。 MLM 从输入中随机掩码一些 token ，任务的目标是仅根据上下文来预测被掩码单词的原始 vocabulary id 。与从左到右的语言模型预训练不同的是，MLM 目标允许representation 同时融合左侧和右侧的上下文，这使得我们可以预训练一个深度的双向 Transformer 。除了MLM ，论文还引入了一个 next sentence prediction: NSP 任务来联合预训练 text-pair representation 。

   论文贡献如下：

   • 作者证明了双向预训练对 language representation 的重要性。与 《Improving language understanding with unsupervised learning》使用单向语言模型进行预训练不同，BERT 使用 MLM 来实现 pre-trained deep bidirectional representation 。这也与 ELMo相反，后者使用独立训练的从左到右和从右到左的语言模型的浅层拼接 shallow concatenation 。
   • 作者表明，预训练的 representation 消除了许多严重工程化的 task-specific 架构的需要。BERT 是第一个基于微调的 representation model ，它在大量的 sentence-level 和 token-level 任务上取得了SOTA 的性能，超过了许多具有 task-specific 架构的系统。
   • BERT 推动了 11 项 NLP 任务的 state-of-the-art 。作者还报告了BERT 的大量消融实验，表明 BERT 模型的双向特性是唯一最重要的新贡献。

2. 相关工作：

   • feature-based 方法：几十年来，学习广泛适用的 word representation 一直是一个活跃的研究领域，包括非神经方法和神经方法。预训练的 word embeddin 被认为是现代 NLP 系统的一个组成部分，与从头开始学习的 embedding 相比，有很大的改进。

     这些方法已被推广到更粗的粒度，如 sentence embedding 或 paragraph embedding 。与传统的 word embedding 一样，这些学到的 representation 通常也被用作下游模型的特征。

     ELMo 沿着不同的维度推广了传统的 word embedding 研究。他们提出从语言模型中提取 context-sensitive 的特征。当将contextual word embedding 与现有的 task-specific 架构相结合时，ELMo 推进了几个主要 NLP benchmark 的 SOTA ，包括 SQuAD 上的问答、情感分析 sentiment analysis 和命名实体识别 named entity recognition 。

   • fine-tuning 方法：最近从语言模型中进行迁移学习的一个趋势是，在为下游监督任务微调同一模型之前，在语言模型目标上预训练该模型架构。这些方法的优点是，只需要从头开始学习非常少的参数。至少部分由于这一优势，GPT 在 GLUE benchmark 的许多 sentence-level 任务上取得了当时 SOTA 的结果。

   • 从监督数据 supervised data 迁移学习：虽然无监督预训练的优势在于几乎有不限量的数据可用，但也有工作表明，可以从具有大型数据集的监督任务中有效地迁移学习，如自然语言推理和机器翻译 machine translation 。在 NLP 之外，计算机视觉领域的研究也证明了从大型预训练模型进行迁移学习的重要性，其中一个有效的秘方是：对基于 ImageNet 预训练的模型进行微调。

8.1 模型

8.1.1 模型架构

1. BERT 的模型架构是一个多层的、双向的 Transformer encoder ，基于 《Attention is allyou need》描述的原始实现。由于最近 Transformer 的使用已经变得无处不在，而且我们的实现实际上与原版相同，因此我们将省略对模型架构的详细描述，请读者参考 《Attention is allyou need》 以及 《The Annotated Transformer》 等优秀出版物。

   在这项工作中，我们将层数（即 Transformer block）记做 $L$$L$ 、 hidden size 记做 $H$$H$ 、self-attention head 数记做 $A$$A$ 。 在所有情况下，我们将 feed-forward/filter size 设为 $4H$$4H$ ，即，$H=768$$H=768$ 时设为的 $3072$$3072$、$H=1024$$H=1024$ 时设为 4096 。我们主要报告两种模型尺寸的结果：

   • BERT_BASE：$L=12$$L=12$，$H=768$$H=768$，$A=12$$A=12$，总的参数规模 110M 。
   • BERT_LARGE：$L=24$$L=24$，$H=1024$$H=1024$，$A=16$$A=16$，总的参数规模 340M 。

   前馈神经网络是一个双层的全连接网络，输入维度为 $H$$H$、中间层的维度为 $4H$$4H$ 、输出层的维度为 $H$$H$ 。

   BERT_BASE 被选择为具有与 GPT 相同的模型大小，以便于比较。然而，关键的是，BERT Transformer 使用的是双向自注意力，而GPT Transformer 使用的是受约束的自注意力（每个token 只能关注其左侧的上下文）。我们注意到，在文献中，双向 Transformer 通常被称为 Transformer encoder ，而只关注左侧上下文的 Transformer 被称为 Transformer decoder （因为它可以用于文本生成）。

   BERT、GPT 和 ELMo 之间的比较如下图所示。

   

8.1.2 Input Representation

1. 我们的 input representation 能够在一个token 序列中明确地表示单个文本句子或一对文本句子（如，[Question, Answer] ）。对于一个给定的token ，它的 input representation 是由相应的token embedding、segment emebdding 和 position embedding 相加而成的。下图给出了我们的 input representation 的直观表示。

   具体而言：

   • 我们使用具有 30k 个 token 的vocabulary 的 WordPiece embedding （《Google’s neural machine translation system: Bridging the gap between human and machine translation》）。我们用 ## 指示被拆分的 word piece 。

   • 我们使用学到的 positional embedding ，最大可以支持长度为 512 个 token 的序列。

   • 每个序列的第一个 token 总是特殊的 classification embedding ，即 [CLS]。与这个 token 相对应的 final hidden state （即 Transformer 的输出）被用作分类任务的 aggregate sequence representation。对于非分类任务，这个向量被忽略。

   • sentence pair 被打包成一个单一的序列。我们以两种方式区分这些句子。

     • 首先，我们用一个特殊的 token（即，[SEP]）将这两个句子分开。（注意，每个句子的结尾都有一个 [SEP] ）

     • 其次，我们在第一句的每个 token 上添加一个学到的 segment A Embedding ，在第二句的每个 token 上添加一个学到的 segment B Embedding 。

       假设 segment 编号为 1 和 2，那么segment A embedding 就是 segment=1 对应的 embedding，segment B embedding 就是 segment=2 对应的 embedding。

     对于单个句子的输入，我们只使用 segment A Embedding 。注意，segment A 也称作 sentence A，因为这里一个句子就是一个 segment 。

     进一步地，我们是否可以对句子内部的子句、或者短语也作为更细粒度的 segment 来提供 embedding ？

   

8.1.3 预训练任务

1. 与 ELMo 和 GPT 不同，我们没有使用传统的从左到右、或从右到左的语言模型来预训练 BERT 。相反，我们使用两个新颖的无监督预训练任务对 BERT 进行预训练。

a. Task1: Maksed LM

1. 直观而言，我们有理由相信：深度双向模型严格来说比 left-to-right 的模型、或浅层拼接了 left-to-right and right-to-left 的模型更强大。不幸的是，标准的 conditional language model 只能从左到右或从右到左进行训练，因为双向条件会让每个词在multi-layered context 中间接地 "看到自己" 。

   为了训练深度双向 representation ，我们采取了一种直接的方法，即随机掩码一定比例的 input token ，然后只预测那些被掩码的 token。我们把这个过程称为 "masked LM"（MLM），尽管它在文献中经常被称为 Cloze task 。在这种情况下，对应于 mask token 的 final hidden vector 被馈入 output softmax （输出空间为整个 vocabulary），就像在标准语言模型中一样。在我们所有的实验中，对于每个序列我们随机掩码 15% 的 WordPiece token 。

   与降噪自编码器不同的是，我们只预测被掩码的单词，而不是重建整个输入。

   被掩码的 token 填充以 [MASK] 。

2. 尽管这确实允许我们获得一个双向的预训练模型，但这种方法有两个缺点：

   • 首先，我们在预训练和微调之间产生了不匹配 mismatch，因为在微调过程中从来没有看到 [MASK] 这个 token 。

     为了缓解这一问题，我们并不总是用实际的 [MASK] token 来替换被掩码的 token。相反，训练数据生成器随机选择 15% 的 token （例如，在句子 "my dog is hairy" 中它选择了hairy ），然后它将执行以下程序：

     • 80% 的情况下用 [MASK] token 替换该词，例如，"my dog is hairy" --> "my dog is [MASK]"。
     • 10% 的情况下用一个随机的词来替换这个词，例如，"my dog is hairy" --> "my dog is apple"。
     • 10% 的情况下保持该词不变，例如，"my dog is hairy" --> "my dog is hairy"。这样做的目的是为了使 representation 偏向于实际观察到的单词。

     Transformer encoder 不知道哪些单词会被要求预测、哪些单词已经被随机词所取代，所以它被迫保持每个 input token 的 distributional contextual representation 。此外，由于随机替换只发生在所有 token 的 1.5%（即 15% 的 10%），这似乎并不损害模型的语言理解能力。

     似乎论文并没有实验来验证这一点。

   • 其次，每个 batch 中只有 15% 的token 被预测，这表明可能需要更多的 pre-training step 来使模型收敛。在实验部分，我们证明了 MLM 的收敛速度确实比left-to-right 的模型（预测每个 token ）稍慢，但是 MLM 模型的经验改进 empirical improvement 远远超过了增加的训练成本。

b. Task2: Next Sentence Prediction

1. 许多重要的下游任务，如 Question Answering: QA 和 Natural Language Inference: NLI ，都是基于对两个文本句子之间关系的理解，而语言建模并没有直接捕获到这一点。为了训练一个能够理解句子关系的模型，我们预训练了一个二元化的 next sentence prediction task ，该任务可以从任何单语种的语料库中简单地生成。

   具体而言，在为每个预训练样本选择句子 A 和句子 B 时：

   • 50% 的情况下句子 B 是紧随句子 A 的实际的下一句。
   • 50% 的情况下句子 B 是语料库中的一个随机句子。

   例如：

   ​x
   Input = [CLS] the man went to [MASK] store [SEP] he bought a gallon [MASK] milk [SEP]
   Label = IsNext
   
   Input = [CLS] the man [MASK] to the store [SEP] penguin [MASK] are flight ##less birds [SEP]
   Label = NotNext
   

   我们完全随机地选择 NotNext 句子，最终的预训练模型在这个任务中达到了 97% ~ 98% 的准确率。尽管该任务很简单，但我们在实验中证明，针对这个任务的预训练对 QA 和 NLI 都非常有利。

   实际上后续的论文表明：NSP 预训练任务是没什么作用甚至是有害的。

8.1.4 预训练程序

1. 预训练程序主要遵循现有的关于语言模型预训练的文献。对于预训练语料库，我们使用 BooksCorpus（800M 单词）和 English Wikipedia （2500M 单词）的组合。对于 Wikipedia ，我们只提取文本段落，忽略了 list、table 、和 header 。至关重要的是，我们使用document-level 语料库而不是混洗过的 sentence-level 语料库（如 Billion Word Benchmark ）从而提取长的连续文本序列。

   为了生成每个训练输入序列，我们从语料库中采样两个区间 span 的文本，我们称之为 "句子"，尽管它们通常比单个句长得多（但也可能更短）。

   • 第一个句子接受 Segment A Embedding ，第二个句子接受 Segment B Embedding 。
   • 50% 的情况下句子 B 是紧随句子 A 之后的实际的下一句，50% 的情况下句子 B 是一个随机的句子。这是用于 next sentence prediction 任务。
   • 这两个句子被采样，使得合并后的长度小于等于 512 个 token 。

   语言模型的 masking 是在 WordPiece tokenization 之后进行的，其中使用 15% 的均匀的掩码率 masking rate ，并没有对部分 word piece 给予特殊考虑。

2. 我们用 batch size = 256 来训练一百万个 step ，每个 mini-batch 有 256 * 512 = 128000 个 token （这里是近似值，精确值为 131072 ），因此相当于在 0.33B 单词的语料库上训练 40 个 epoch 。

   • 我们使用 Adam 优化器，学习率为${10}^{-4}$$10^{-4}$，${\beta }_1=0.9,{\beta }_2=0.999$$\beta_1=0.9, \beta_2=0.999$，L2 权重衰减为 0.01 。学习率在前 10000 步进行 warmup ，学习率线性衰减。
   • 我们在所有 layer 上使用 0.1 的 dropout rate 。
   • 遵循 GPT ，我们使用 gelu 激活函数不是标准的 relu 。
   • training loss 是 mean masked LM likelihood 和 mean next sentence prediction likelihood 之和。

3. BERT_BASE 的训练在 Pod configuration 的 4 Cloud TPUs 上进行（共 16 个TPU 芯片）。BERT_LARGE 的训练在 16 Cloud TPUs 上进行（共 64个TPU芯片）。BERT_BASE 和 BERT_LARGE 的预训练都需要 4 天的时间来完成。

8.1.5 微调程序

1. 对于 sequence-level 分类任务，BERT 的微调是直接的。为了获得输入序列的固定维度的、被池化的 representation ，我们采用输入的第一个 token 的 final hidden state ，这对应于特殊的[CLS] 对应的 word embedding 。我们把这个向量表示为 $\overrightarrow{\mathbf{c}}\in {\mathbb{R}}^H$$\mathbf{\vec c}\in \mathbb R^H$ 。在微调过程中，唯一新增的参数是分类层 $\mathbf{W}\in {\mathbb{R}}^{K\times H}$$\mathbf W\in \mathbb R^{K\times H}$，其中 $K$$K$ 是类别标签的数量。标签概率 $\overrightarrow{\mathbf{p}}\in {\mathbb{R}}^K$$\mathbf{\vec p}\in \mathbb R^K$ 是用标准的 softmax 计算的，即 $\overrightarrow{\mathbf{p}}=\text{softmax}\left(\overrightarrow{\mathbf{c}}{\mathbf{W}}^{\mathrm{\top }}\right)$$\mathbf{\vec p} = \text{softmax}\left(\mathbf{\vec c}\mathbf W^\top\right)$ 。BERT 和 $\mathbf{W}$$\mathbf W$ 的所有参数都是联合微调的，以使ground-truth 标签的对数概率最大化。

   对于 span-level 和 token-level 的预测任务，上述过程必须以 task-specific 的方式稍作修改。细节在实验部分给出。

2. 对于微调，模型的大部分超参数与预训练时相同，除了 batch size 、learning rate 和训练 epoch 的数量。 dropout rate 始终保持在 0.1。最佳的超参数值是 task-specific的，但我们发现以下数值范围在所有任务中都能很好地发挥作用：Batch size 为 16 、32 ；Learning rate (Adam) 为5e-5、3e-5、2e-5 ；epoch 数量为3、4 。

   微调采用更小的 batch size、更小的学习率、更少的 epoch 。

   我们还观察到：大数据集（例如，100k+ 带标记的训练样本）对超参数选择的敏感性远低于小数据集。

   微调通常是非常快的，所以简单地对上述超参数进行暴力搜索并选择在验证集上表现最好的模型是合理的。

8.1.6 BERT 和 GPT 的对比

1. 与 BERT 最具可比性的、现有的预训练方法是OpenAI GPT，它在一个大型文本语料库上训练了一个 left-to-right 的 Transformer 语言模型。事实上，BERT 中的许多设计决定都是有意选择的，以尽可能地接近 GPT，从而使这两种方法能够得到最低限度的比较。我们工作的核心论点是：我们提出的两个新颖的预训练任务占了经验改进的大部分，但我们确实注意到 BERT 和 GPT的训练方式还有几个不同之处：

   • GPT 是在 BooksCorpus （800M 单词）上训练的，而 BERT 是在 BooksCorpus和 Wikipedia（ 2500M 单词）上训练的。

     通常而言，更大的预训练语料库会带来更好的微调效果。

   • GPT 使用句子分隔符sentence separator （[SEP]）和 classifier token （[CLS]），它们仅在微调期间引入；而 BERT 在预训练期间学习 [SEP]、[CLS] 和 segment A/B embedding。

   • GPT 被训练了 1M 个 step ，batch size 为 32000 个单词；BERT 被训练了 1M 个 step ，batch size 为 128000 个词。

   • GPT 在所有微调实验中使用相同的学习率 5e-5 ；BERT 选择了 task-specific 的、用于微调的学习率，这个学习率在验证集上表现最好。

   为了隔绝 isolate 这些差异的影响，我们在实验部分进行了大量消融实验，证明大部分的改进实际上来自新颖的预训练任务。

8.2 实验

8.2.1 GLUE 数据集

1. General Language Understanding Evaluation: GLUE基准是各种自然语言理解 natural language understanding 任务的集合。大多数 GLUE 数据集已经存在多年，但 GLUE的目的是：

   • 首先，对这些数据集进行规范的 Train/Dev/Test 的拆分。
   • 其次，建立一个 evaluation server 从而缓解评估不一致和测试集过拟合的问题。GLUE 并未提供测试集的标签，用户必须将他们的预测上传到 GLUE server 进行评估，并对提交的次数有所限制。

2. GLUE benchmark 包括以下数据集：

   • Multi-Genre Natural Language Inference: MNLI：是一个大规模、众包式的蕴含分类 entailment classification任务。给定一对句子，任务的目标是：预测第二个句子相对于第一个句子是蕴含关系entailment 、矛盾关系contradiction 还是中性关系 neutral 。

   • Quora Question Pairs: QQP：是一个二元分类任务，任务的目标是确定在 Quora 上提出的两个问题是否在语义上等价 semantically equivalent 。

   • Question Natural Language Inference: QNLI：是 Stanford Question Answering Dataset 的一个版本，它被转换为一个二元分类任务。正样本是 sentence 确实包含正确答案的 (question, sentence) pair ，负样本是 sentence 中不包含答案的 (question, sentence) pair 。

   • Stanford Sentiment Treebank: SST-2 ：是一个二元单句分类任务，由从电影评论中提取的句子组成，并具有人类对这些评论的情感的注释 annotation 。

   • Corpus of Linguistic Acceptability: CoLA：是一个二元单句分类任务，任务的目标是预测一个英语句子是否在语言上 "acceptable "。

   • Semantic Textual Similarity Benchmark: STS-B：是一个从新闻 headlines 和其他来源抽取的 sentence pair 的集合。它们被标记为 1 ~ 5 分，表示这两个句子在语义上的相似程度。

   • Microsoft Research Paraphrase Corpus: MRPC：从在线新闻来源中自动提取的 sentence pair 组成，并由人类注释该 sentence pair 是否具有语义上的等价性。

   • Recognizing Textual Entailment: RTE：是一个类似于 MNLI 的二元蕴含任务，但训练数据少得多。

   • Winograd NLI: WNLI：是一个小型自然语言推理 natural language inference 数据集，源于 《The winograd schema challenge》。GLUE的网页指出：这个数据集的构建存在问题，而且每一个提交给 GLUE 的训练好的系统的表现都比一个简单的 baseline 更差。这个简单的 baseline 直接预测 majority class，并达到 65.1 的准确率。因此，出于对 OpenAI GPT 的公平比较，我们排除了这个数据集。对于我们的 GLUE submission ，我们总是预测 majority class 。

     即，对于每一个测试样本，预测它的类别为训练集中出现概率最高的那个类别（即 majority class ）。

3. 为了在 GLUE上进行微调，我们根据前文所述来表示输入序列或 sequence pair ，并使用对应于第一个输入 token（[CLS]）的final hidden vector $\overrightarrow{\mathbf{c}}\in {\mathbb{R}}^H$$\mathbf{\vec c}\in \mathbb R^H$ 作为 aggregate representation 。这在下图 (a) 和 (b) 中得到了直观的证明。在微调过程中引入的唯一新参数是一个分类层 $\mathbf{W}\in {\mathbb{R}}^{K\times H}$$\mathbf W\in \mathbb R^{K\times H}$ ，其中 $K$$K$ 是类别标签的数量。我们用 $\overrightarrow{\mathbf{c}}$$\mathbf{\vec c}$ 和 $\mathbf{W}$$\mathbf W$ 计算一个标准的分类损失，即$\log \left(\text{softmax}\left(\overrightarrow{\mathbf{c}}{\mathbf{W}}^{\mathrm{\top }}\right)\right)$$\log\left(\text{softmax}\left(\mathbf{\vec c}\mathbf W^\top \right)\right)$ 。

   因为 GLUE 数据集都是文本分类任务。

   • 对于所有的 GLUE 任务，我们使用 batch size = 32 以及 3 个 epoch 。

   • 对于每个任务，我们用 5e-5、4e-5、3e-5、2e-5的学习率进行微调，并选择在验证集上表现最好的一个。

   • 此外，对于 BERT_LARGE ，我们发现微调在小数据集上有时是不稳定的（也就是说，一些 runs 会产生退化degenerate 的结果），所以我们运行了几个随机重启 random restart ，并选择了在验证集上表现最好的模型。

     通过随机重启，我们使用相同的 pre-trained checkpoint ，但在微调期间进行不同的数据混洗和 classifier layer 初始化 。

   • 我们注意到，GLUE 数据集不包括测试集的标签，我们只为每个 BERT_BASE 和 BERT_LARGE 做一次 evaluation server submission 。

   从图 (a) 中看到，在微调期间只有一个 [SEP] 符号，这与预训练阶段不一致。在预训练阶段每个句子的末尾都添加一个 [SEP] 。这种不一致是否影响效果？可以通过实验来评估。

   

4. 实验结果如下表所示：

   • BERT_BASE 和 BERT_LARGE 在所有任务上的表现都大大超过了现有的系统，分别比 SOTA 的系统获得了 4.4% 和 6.7% 的平均精确度提升。请注意，BERT_BASE 和 OpenAI GPT 在 attention masking 之外的模型架构方面几乎是相同的。

   • 对于最大和最广泛报道的GLUE 任务 MNLI ，BERT （这里是 BERT_LARGE ）相比 SOTA 获得了 4.7% 的绝对提升。

   • 在 GLUE 的官方排行榜上，BERT_LARGE 获得了80.4分；相比之下，排在榜首的系统（即 OpenAI GPT）截至本文撰写之日获得了 72.8 分。

     下图中的 Average 稍有差异，因为这里我们排除了有问题的 WNLI 数据集。

   • 值得注意的是，BERT_LARGE 在所有任务中都显著优于 BERT_BASE，即使是那些训练数据非常少的任务。BERT 模型大小的影响将在下面的实验中进行更深入的探讨。

   

8.2.2 SQuAD v1.1

1. Standford Question Answering Dataset: SQuAD 是一个由 10 万个众包的 (question, answer) pair 组成的集合。给定一个问题和来自维基百科中包含答案的段落，任务的目标是预测该段落中的答案文本的区间 answer text span 。例如：

   xxxxxxxxxx
   Input Question: Where do water droplets collide with ice crystals to form precipitation?
   Input Paragraph:
     ... Precipitation forms as smaller droplets coalesce via collision with other rain drops or ice crystals within a cloud. ...
   Output Answer: within a cloud
   

   这种类型的区间预测任务 span prediction task 与 GLUE 的序列分类任务截然不同，但我们能够以一种直接的方式使 BERT在SQuAD上运行。

   就像 GLUE 一样，我们将输入的问题和段落表示为一个 single packed sequence ，其中 question 使用 segment A embedding ，段落使用 segment B embedding 。在微调过程中学习到的唯一的新参数是一个 start vector $\overrightarrow{\mathbf{s}}\in {\mathbb{R}}^H$$\mathbf{\vec s}\in \mathbb R^H$ 和一个 end vector $\overrightarrow{\mathbf{e}}\in {\mathbb{R}}^H$$\mathbf{\vec e}\in \mathbb R^H$ 。令第 $i$$i$ 个 input token 在 BERT 中的的 final hidden vector 表示为 ${\overrightarrow{\mathbf{t}}}_i\in {\mathbb{R}}^H$$\mathbf{\vec t}_i\in \mathbb R^H$。如 Figure 3(c) 所示。然后，单词 $i$$i$ 是 answer span 的起点start 的概率被计算为 ${\overrightarrow{\mathbf{t}}}_i$$\mathbf{\vec t}_i$ 和 $\overrightarrow{\mathbf{s}}$$\mathbf{\vec s}$ 的内积，然后在当前段落中所有单词之上取 softmax ：

   $$\begin{array}{}\text{(1)}& p_i=\frac{\exp ({\overrightarrow{\mathbf{t}}}_i\cdot \overrightarrow{\mathbf{s}})}{\sum _j\exp ({\overrightarrow{\mathbf{t}}}_j\cdot \overrightarrow{\mathbf{s}})}\end{array}$$

   其中 $j$$j$ 取值为从段落开始到段落结束。

   同样的公式用于 answer span 的终点end ，最大得分的 span 被用作预测。训练目标是正确的起点位置和终点位置的对数可能性。

   这里假设起点和终点之间是相互独立的。实际上这种假设通常不成立，终点和起点之间存在关联，如终点的位置大于等于起点。

2. 我们用 5e-5 的学习率和 batch size = 32 训练了 3 个 epoch 。在推理时，由于终点预测并没有考虑以起点为条件，我们增加了终点必须在起点之后的约束条件，但没有使用其他启发式方法。tokenized labeled span 被调整回原始的 untokenized input 以进行评估。

   因为经过了 tonenization 之后，原始的单词被拆分为 word piece，这将影响 span 的位置。

3. 结果如下表所示。SQuAD采用了高度严格的测试程序，提交者必须手动联系 SQuAD 的组织者，在一个隐藏的测试集上运行他们的系统，所以我们只提交了我们最好的系统进行测试。下表中显示的结果是我们第一次也是唯一一次向 SQuAD 提交的测试结果。

   我们注意到：SQuAD 排行榜上的榜首结果没有最新的公开的系统描述，而且在训练他们的系统时允许使用任何公共数据。因此，我们在提交的系统中使用了非常适度的数据增强：在 SQuAD 和 TriviaQA 上联合训练。

   我们表现最好的系统相比排行榜上榜首的系统高出 +1.5 F1 （以 ensembling 系统的方式 ）和 +1.7 F1 （以 single 系统的方式）。事实上，我们的单一 BERT 模型在F1 得分方面优于 top ensemble system 。如果我们只对 SQuAD 进行微调（不包括TriviaQA），我们会损失0.1-0.4 F1 ，但仍然以很大的优势胜过所有现有系统。

   BERT ensemble 使用了 7 个模型，它们分别使用不同的预训练 checkpoint 和 fine-tuning seed 。

   

8.2.3 Named Entity Recognition

1. 为了评估 token tagging 任务的性能，我们在 CoNLL 2003 命名实体识别（NER）数据集上对 BERT 进行了微调。这个数据集由 20 万个训练单词组成，这些单词被标注为人物 Person 、组织Organization、位置Location、杂项Miscellaneous 、或其他Other（非命名实体）。

   • 为了进行微调，我们将每个token $i$$i$ 的 final hidden representation ${\overrightarrow{\mathbf{t}}}_i\in {\mathbb{R}}^H$$\mathbf{\vec t}_i\in \mathbb R^H$ 馈入分类层。预测不以周围的预测为条件（即，non-autoregressive 和 no CRF ）。

   • 为了与 WordPiece tokenization兼容，我们将每个 CoNLL-tokenized input word 馈入我们的 WordPiece tokenizer ，并使用与第一个 sub-token 对应的 hidden state 作为分类器的输入。例如：

     xxxxxxxxxx
     Jim   Hen   ##son was a puppet ##eer
     I-PER I-PER X     O   O O      X
     

     其中 X 没有预测。Figure 3(d)中也给出了一个直观的表示。在NER 中使用了 cased WordPiece model（即，保留字母的大小写） ，而在所有其他任务中则使用了 uncased model （即，所有字母转化为小写）。

   结果如下表所示。BERT_LARGE 在 CoNLL-2003 NER Test 中优于现有的 SOTA （Cross-View Training with multi-task learning）达到 +0.2 的改进。

   如果在 BERT 的 final hidden representation 之上再接入自回归或 CRF，预期将得到更好的效果。

   

8.2.4 SWAG

1. Situations With Adversarial Generations: SWAG 数据集包含11.3 万个 sentence-pair completion 的样本，评估了 grounded commonsense inference 。

   给定视频字幕数据集中的一个句子，任务是在四个选项中决定最合理的延续concatenation。例如：

   xxxxxxxxxx
   A girl is going across a set of monkey bars. She
   (i) jumps up across the monkey bars.
   (ii) struggles onto the bars to grab her head.
   (iii) gets to the end and stands on a wooden plank.
   (iv) jumps up and does a back flip.
   

   将 BERT 应用于 SWAG 数据集类似于 GLUE 。对于每个样本，我们构建四个输入序列，每个序列都包含给定句子（句子 A ）和一个可能的延续（句子B ）的拼接。我们引入的唯一 task-specific 参数是一个向量 $\overrightarrow{\mathbf{v}}\in {\mathbb{R}}^H$$\mathbf{\vec v}\in \mathbb R^H$，它与 final aggregate representation ${\overrightarrow{\mathbf{c}}}_i\in {\mathbb{R}}^H$$\mathbf{\vec c}_i\in \mathbb R^H$ 的内积表示每个选项 $i$$i$ 的得分。我们计算在四个选项上的 softmax：

   $$\begin{array}{}\text{(2)}& p_i=\frac{\exp (\overrightarrow{\mathbf{v}}\cdot {\overrightarrow{\mathbf{c}}}_i)}{\sum _{j=1}^4\exp (\overrightarrow{\mathbf{v}}\cdot {\overrightarrow{\mathbf{c}}}_j)}\end{array}$$

   我们用 2e-5 的学习率和 batch size = 16 对模型进行了 3 个 epoch 的微调。结果如下表所示。BERT_LARGE 比作者的 baseline （即，ESIM+ELMo系统）要提高 27.1% 。

   

8.2.5 消融研究

1. 尽管我们已经展示了极其强大的经验结果，但迄今为止所提出的结果并没有将 BERT 框架的每个方面 aspect 的具体贡献分离出来。这里我们对 BERT 的一些方面进行了消融实验，以便更好地了解其相对重要性。

a. 预训练任务的效果

1. 我们的核心主张claim 之一是 BERT 的深度双向性deep bidirectionality ，这是由 masked LM pre-training 实现的并且是BERT与以前的工作相比最重要的一个改进。为了证明这一主张，我们评估了两个新模型，它们使用了与 BERT_BASE 完全相同的预训练数据、微调方案、以及 Transformer超参数。

   • No NSP：该模型使用 MLM 任务预训练，但是没有 NSP 任务。

   • LTR & No NSP：该模型使用 Left-to-Right: LTR 的语言模型来训练，而不是使用MLM 来训练 。在这种情况下，我们预测每一个input word ，不应用任何 masking 。在微调时也应用了 left-only 约束，因为我们发现：用 left-only-context 进行预训练然后用 bidirectional context 进行微调总是更糟糕。此外，这个模型没有使用 NSP 任务进行预训练。

     这与OpenAI GPT有直接的可比性，但使用了我们更大的训练数据集、我们的input representation 、以及我们的微调方案。

     BERT 在预训练期间学习 [SEP]、[CLS] 和 segment A/B embedding，而 GPT 仅在微调期间学习这些 input representation 。

2. 结果如下表所示。

   • 我们首先检查了NSP任务带来的影响。可以看到：去掉NSP对 QNLI、MNLI和SQuAD的性能有很大的伤害。这些结果表明，我们的预训练方法对于获得前面介绍的强大的经验结果至关重要。

     后续的 XLNet 和 RoBERTa 都表明：NSP 任务不重要。而且 RoBERTa 的作者认为：BERT 得出 NSP 任务重要的原因是，BERT 的输入是两个句子的拼接，因此如果此时没有 NSP 任务则效果较差。在 RoBERTa 中，由于没有 NSP 任务，因此预训练样本就是一个完整的、来自单个文件的文档块。

   • 接下来，我们通过比较 "No NSP "和 "LTR & No NSP "来评估训练 bidirectional representation 的影响。LTR 模型在所有任务上的表现都比MLM模型更差，在 MRPC和 SQuAD上的下降幅度非常大。

     • 对于SQuAD，直观而言，LTR 模型在span 预测和 token 预测方面的表现非常差，因为 token-level hidden state 没有右侧的上下文。
     • 对于 MRPC 而言，不清楚这种糟糕的表现是由于数据量小还是由于任务的性质，但是我们发现这种糟糕的表现在多次随机重启的full 超参数扫描中是一致的。

   • 为了加强 LTR 系统，我们尝试在它上面添加一个随机初始化的 BiLSTM 进行微调。这确实大大改善了 SQuAD 的结果，但结果仍然比预训练的双向模型差得多。它还损害了其它所有四个 GLUE 任务的性能。

   • 我们认识到：也可以像 ELMo 那样，单独训练LTR和 RTL模型，并将每个 token 表示为两个模型的拼接。然而：

     • 首先，这种方法比单一的双向模型要贵两倍。
     • 其次，这种方法对像 QA 这样的任务来说是不直观的，因为 RTL 模型不能以答案作为条件来回答问题（即，条件概率 $P(\text{question}\mid \text{answer})$$P(\text{question}\mid \text{answer})$。
     • 最后，这种方法严格来说不如深度双向模型 deep bidirectional model 强大，因为深度双向模型可以选择使用 left context 或 right context 。

   

b. Model Size 的效果

1. 这里我们探讨了模型大小对微调任务准确性的影响。我们训练了一些具有不同层数、隐单元、以及注意力头的 BERT 模型。除此之外，我们还使用了与前面所述相同的超参数和训练程序。

   选定的 GLUE 任务的结果如下表所示。在这个表中，我们报告了 5 次随机重启微调的平均验证准确率。可以看到：

   • 更大的模型在所有四个数据集上都导致了一致的准确性提高，即使是只有 3600 个标记的训练样本的 MRPC 。

   • 同样令人惊讶的是，我们能够在相对于现有文献已经相当大的模型之上实现如此显著的改进。例如：

     • 《Attention is all you need》探索的最大的 Transformer 是 (L=6，H=1024，A=16)，编码器的参数为100M 。
     • 而我们在文献中发现的最大的Transformer 是 (L=64，H=512，A=2)，参数为 235M （《Character-level language modeling with deeper self-attention》）。
     • 相比之下，BERT_BASE 包含 110M 参数，BERT_LARGE 包含 340M 参数。

     多年以来人们都知道，增加模型规模将导致大型任务（如机器翻译、语言建模）的持续改进，这可以通过下表所示的 held-out 训练数据的 LM perplexity 来证明。然而，我们认为这是第一项工作，证明了扩展到极端的 model size 也会导致在非常小型的任务上有很大的改进，只要模型已经被充分地预训练过。

     即，增加模型规模不仅对大型任务有效，对小型任务也有效（模型需要被预训练）。

   

c. 训练步数的效果

1. 下图展示了从一个已经预训练了 $k$$k$ 个 step 的 checkpoint 进行微调后的 MNLI 验证准确性。这使我们能够回答以下问题。

   • 问题：BERT 是否真的需要如此大量的预训练（128,000 words/batch * 1,000,000 steps）来实现高的微调准确率？

     答案：是的。BERT_BASE 预训练一百万步时，与五十万步相比，在 MNLI 上实现了接近 1.0% 的微调准确率提升。

   • 问题：MLM 预训练的收敛速度是否比 LTR 预训练慢，因为每个 batch 中只有 15% （而不是 100% ）的单词被预测？

     答案：是的，MLM模型的收敛速度比LTR 稍慢。然而，就绝对准确率而言，MLM 模型几乎从一开始就超过了 LTR 模型。

   

d. Feature-based Approach with BERT

1. 迄今为止，所有的 BERT 结果都采用了微调方法，即在预训练的模型中加入一个简单的分类层，并在下游任务中联合微调所有的参数。然而，feature-based 的方法，即从预训练的模型中抽取固定的特征，具有一定的优势：

   • 首先，并不是所有的 NLP 任务都可以很容易地用 Transformer 编码器架构来表示，因此需要增加一个 task-specific 的模型架构。
   • 其次，如果能够一次性地预先计算好训练数据的 expensive representation ，然后在这个 representation 的基础上用不太昂贵的模型进行许多实验，这有很大的计算优势。

   这里我们通过在 CoNLL-2003 NER 任务上生成类似于 ELMo 的 pre-trained contextual representation 来评估 BERT 在 feature-based 的方法中的表现如何。为了做到这一点，我们使用与本文在 Named Entity Recognition 章节中相同的 input representation ，但是使用 BERT 的一个或多个层的激活值而没有微调任何参数。这些 contextual embedding 被用作一个双层 BiLSTM 的输入，这个双层 BiLSTM 具有 768 维并且是随机初始化的，并且这个双层 BiLSTM 位于最终的分类层之前。

   结果如下表所示。表现最好的方法是将预训练的 Transformer 的最后四个隐层的 token representation 拼接起来，这比微调整个模型仅相差 0.3 F1 。这表明：BERT 对微调方法和 feature-based 方法都是有效的。

   

九、XLNet[2019]

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}$。

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