Transformers 自然语言处理（一）（2）-阿里云开发者社区

Transformers 自然语言处理（一）（1）https://developer.aliyun.com/article/1514344

步骤 7：将结果求和

输入＃1 的 3 个注意力值现在将被求和以获得输出矩阵的第一行：

print("Step 7: summed the results to create the first line of the output matrix")
attention_input1=attention1+attention2+attention3
print(attention_input1)

输出是输入＃1 的输出矩阵的第一行：

Step 7: summed the results to create the first line of the output matrix
[1.93662106 6.68310531 1.59506841]]

第二行将是下一个输入，例如输入＃2 的输出。

我们可以在图 2.17中看到x[1]的求和注意力值：

图 2.17：一个输入的求和结果

我们已完成了输入＃1 的步骤。现在我们需要将所有输入的结果添加到模型中。

步骤 8：所有输入的步骤 1 至步骤 7

现在，Transformers可以使用与步骤 1 到步骤 7 描述的相同方法产生输入＃2 和输入＃3 的注意力值，用于一个注意力头。

从这一步开始，我们假设有 3 个学习权重的注意力值，d[model] = 64。现在我们想看到这些原始维度在达到子层输出时是什么样子的。

我们已经详细了解了小模型中的注意力表示过程。让我们直接看结果，假设我们已经生成了 3 个d[model]=64 维的注意力表示：

print("Step 8: Step 1 to 7 for inputs 1 to 3")
#We assume we have 3 results with learned weights (they were not trained in this example)
#We assume we are implementing the original Transformer paper.We will have 3 results of 64 dimensions each
attention_head1=np.random.random((3, 64))
print(attention_head1)

以下输出显示了z[0]的模拟，它代表了头 1 的d[model]=64 维的 3 个输出向量：

Step 8: Step 1 to 7 for inputs 1 to 3
[[0.31982626 0.99175996…(61 squeezed values)…0.16233212]
 [0.99584327 0.55528662…(61 squeezed values)…0.70160307]
 [0.14811583 0.50875291…(61 squeezed values)…0.83141355]]

运行笔记本时，由于向量生成的随机性质，结果将有所不同。

现在，Transformers有一个头的输入的输出向量。下一步是生成 8 个头的输出，以创建注意力子层的最终输出。

步骤 9：注意力子层的头部输出

我们假设我们已经训练了注意力子层的 8 个头。现在，Transformers有 3 个输出向量（3 个输入向量，即单词或词片段）每个d[model] = 64 维：

print("Step 9: We assume we have trained the 8 heads of the attention sublayer")
z0h1=np.random.random((3, 64))
z1h2=np.random.random((3, 64))
z2h3=np.random.random((3, 64))
z3h4=np.random.random((3, 64))
z4h5=np.random.random((3, 64))
z5h6=np.random.random((3, 64))
z6h7=np.random.random((3, 64))
z7h8=np.random.random((3, 64))
print("shape of one head",z0h1.shape,"dimension of 8 heads",64*8)

输出显示了一个头的形状：

Step 9: We assume we have trained the 8 heads of the attention sublayer
shape of one head (3, 64) dimension of 8 heads 512

这 8 个头现在产生了Z：

Z = (Z[0], Z[1], Z[2], Z[3], Z[4], Z[5], Z[6], Z[7])

Transformers将现在连接Z的 8 个元素以产生多头注意力子层的最终输出。

步骤 10：连接头部的输出

Transformers连接了Z的 8 个元素：

MultiHead(Output) = Concat (Z[0], Z[1], Z[2], Z[3], Z[4], Z[5], Z[6], Z[7]) W⁰ = x，d[model]

请注意，Z被乘以W⁰，它是一个被训练的权重矩阵。在这个模型中，我们将假设W⁰是被训练并集成到连接函数中的。

Z[0]到Z[7]被连接在一起：

print("Step 10: Concantenation of heads 1 to 8 to obtain the original 8x64=512 ouput dimension of the model")
output_attention=np.hstack((z0h1,z1h2,z2h3,z3h4,z4h5,z5h6,z6h7,z7h8))
print(output_attention)

输出是Z的连接：

Step 10: Concatenation of heads 1 to 8 to obtain the original 8x64=512 output dimension of the model
[[0.65218495 0.11961095 0.9555153  ... 0.48399266 0.80186221 0.16486792]
 [0.95510952 0.29918492 0.7010377  ... 0.20682832 0.4123836  0.90879359]
 [0.20211378 0.86541746 0.01557758 ... 0.69449636 0.02458972 0.889699  ]]

连接可以可视化为将Z的元素并排堆叠：

图 2.18：注意力子层输出

连接产生了一个标准的d[model]=512 维的输出：

图 2.19：连接 8 个头的输出

现在，层归一化将处理注意力子层。

后层归一化

每个Transformers的注意力子层和每个前馈子层之后都跟随后层归一化（Post-LN）：

图 2.20：后层归一化

后层归一化包含加法函数和层归一化过程。加法函数处理来自子层输入的残余连接。残余连接的目标是确保关键信息不会丢失。后层归一化或层归一化可以描述如下：

LayerNormalization (x + Sublayer(x))

Sublayer(x) 是子层本身。x 是 Sublayer(x) 输入步骤的可用信息。

LayerNormalization 的输入是由 x + Sublayer(x) 产生的向量 v。Transformer 的每个输入和输出都为 d[model] = 512，这标准化了所有过程。

存在许多层归一化方法，且从一个模型到另一个模型存在变化。v = x + Sublayer(x) 的基本概念可以由 LayerNormalization (v) 定义：

变量是：

是维度 d 的 v 的均值。因此：

是维度 d 的标准差 v。因此：

是一个缩放参数。
是一个偏置向量。

这个版本的 LayerNormalization (v) 展示了许多可能的后归一化方法的基本思想。下一个子层现在可以处理后归一化或 LayerNormalization (v) 的输出。在这种情况下，子层是一个前馈网络。

子层 2：前馈网络

前馈网络 (FFN) 的输入是前一个子层的后归一化输出 d[model] = 512：

图 2.21：前馈子层

FFN 子层可以描述如下：

编码器和解码器中的 FFN 是全连接的。
FFN 是一种逐位置的网络。每个位置都是分别且相同方式处理的。
FFN 包含两个层，并应用 ReLU 激活函数。
FFN 层的输入和输出为 d[model] = 512，但内部层更大，为 d[ff] =2048。
FFN 可以被视为使用大小为 1 的卷积执行两次。

考虑到这个描述，我们可以描述优化和标准化的 FFN 如下：

FFN(x) = max (0, xW[1] + b[1]) W[2]+b[2]

FFN 的输出经过了后归一化，如前一节所述。然后输出被发送到编码器堆栈的下一层和解码器堆栈的多头注意力层。

现在让我们来探索解码器堆栈。

解码器堆栈

Transformer 模型的解码器层是与编码器层类似的层堆栈。每个解码器堆栈层具有以下结构：

图 2.22：Transformer 解码器堆栈的一层

对于 Transformer 模型的所有 N=6 层，解码器层的结构与编码器相同。每一层包含三个子层：多头掩码注意力机制，多头注意力机制和全连接的逐位置前馈网络。

解码器有一个第三个主要子层，即遮罩式多头注意力机制。在此子层的输出中，在给定位置，随后的单词被掩盖，以便 Transformer 在不看到序列的其余部分的情况下基于其推断。因此，在这个模型中，它无法看到序列的未来部分。

每个 Transformer 模型中的三个主要子层都被一个残差连接，Sublayer(x)，像编码器堆栈中一样：

层归一化 (x + Sublayer(x))

嵌入层子层只存在于堆栈的底层，就像编码器堆栈一样。解码器堆栈的每个子层的输出都具有恒定的维度，d[model]，就像编码器堆栈一样，包括嵌入层和残差连接的输出。

我们可以看到，设计者们努力创建了对称的编码器和解码器堆栈。

每个子层的结构和解码器功能与编码器类似。在本节中，当我们需要时，我们可以参考编码器来获得相同的功能。我们只关注解码器和编码器之间的差异。

输出嵌入和位置编码

解码器子层的结构与编码器子层的大部分相同。输出嵌入层和位置编码函数与编码器堆栈中的相同。

在我们通过 Vaswani 等人 (2017) 提出的模型中探索 Transformer 的用法时，输出是我们需要学习的翻译。我选择使用法语翻译：

Output=Le chat noir était assis sur le canapé et le chien marron dormait sur le tapis

这个输出是英文输入句子的法语翻译：

Input=The black cat sat on the couch and the brown dog slept on the rug.

输出的词经过词嵌入层，然后是位置编码函数，就像编码器堆栈的第一层一样。

让我们看一下解码器堆栈的多头注意力层的具体属性。

注意力层

Transformer 是一个自回归模型。它使用先前的输出序列作为额外的输入。解码器的多头注意力层使用与编码器相同的过程。

然而，遮罩式多头注意力子层 1 只允许注意力应用到当前位置及其之前的位置。未来的词对 Transformer 是隐藏的，这迫使它学会预测。

在遮罩式多头注意力子层 1 之后，像在编码器中一样，遵循一个后层归一化过程。

多头注意力子层 2 也只关注到 Transformer 正在预测的当前位置之前的位置，以避免看到它必须预测的序列。

多头注意力子层 2 从编码器中汲取信息，在点积注意力操作期间考虑编码器 (K, V)。该子层还从掩码的多头注意力子层 1（掩码关注）中汲取信息，在点积注意力操作期间还考虑子层 1(Q)。因此，解码器使用编码器的训练信息。我们可以将解码器的自注意力多头子层的输入定义为：

输入 _ 注意力 = (输出 _ 解码器 _ 子层 – 1(Q), 输出 _ 编码器 _ 层(K, V))

在编码器后，会跟随一个后层标准化过程。

然后 Transformer 会进入 FFN 子层，然后是一个后层标准化和线性层。

FFN 子层，后层标准化和线性层

FFN 子层的结构与编码器堆栈的 FFN 相同。FFN 的后层标准化像编码器堆栈的层标准化一样工作。

Transformer 仅每次产生一个元素的输出序列：

输出序列 = (y[1], y[2], … y[n])

线性层产生一个输出序列，其线性函数因模型而异，但依赖于标准方法：

y =w * x + b

w和b是学习参数。

线性层因此会产生序列的下一个可能元素，softmax 函数将其转换为概率元素。

解码器层，如编码器层，将从层l到l+1，一直到6层 Transformer 堆叠的顶层。

现在让我们看一下 Transformer 是如何训练的以及其性能如何。

训练和性能

最初的 Transformer 是在一个 450 万句对的英德数据集和一个 3600 万句对的英法数据集上进行训练的。

这些数据集来自机器翻译研讨会 (WMT)，如果你希望探索 WMT 数据集，可以在以下链接找到：www.statmt.org/wmt14/

最初的 Transformer 基础模型在装有 8 个 NVIDIA P100 GPU 的计算机上进行了 100,000 步的训练，用时 12 个小时。大型模型则用了 3.5 天进行了 300,000 步的训练。

最初的 Transformer 在 WMT 英法数据集上取得了 41.8 的 BLEU 分数，优于所有以前的机器翻译模型。

BLEU 代表双语评估助手。它是一个评估机器翻译结果质量的算法。

Google 研究和 Google Brain 团队应用了优化策略来提高 Transformer 的性能。例如，使用了 Adam 优化器，但学习率通过首先经历线性增长的预热阶段，然后在之后降低。

应用了不同类型的正则化技术，如残差丢失和丢失，到嵌入之和上。此外，Transformer 应用了标签平滑，避免了通过过于自信的单热输出过拟合。它引入了更不准确的评估，并迫使模型更多、更好地训练。

几种其他 Transformer 模型变体导致了其他模型和用法，我们将在随后的章节中探讨。

在结束本章之前，让我们感受一下 Hugging Face 中可立即使用的变换器模型的简单性，例如。

Hugging Face 中的变换器模型

这一章中所见的一切都可以压缩成一个可立即使用的 Hugging Face 变换器模型。

通过 Hugging Face，你可以用三行代码实现机器翻译！

在 Google Colaboratory 中打开 Multi_Head_Attention_Sub_Layer.ipynb。将笔记本保存到您的 Google Drive 中（确保您有一个 Gmail 帐户）。转到最后两个单元格。

我们首先确保安装了 Hugging Face transformers：

!pip -q install transformers

第一个单元导入了包含几个变换器用法的 Hugging Face 管道：

#@title Retrieve pipeline of modules and choose English to French translation
from transformers import pipeline

然后我们实现 Hugging Face 管道，其中包含了可立即使用的功能。在我们的案例中，为了说明本章的 Transformer 模型，我们激活了翻译模型并输入一句要从英语翻译成法语的句子：

translator = pipeline("translation_en_to_fr")
#One line of code!
print(translator("It is easy to translate languages with transformers", max_length=40))

voilà！翻译显示出来了：

[{'translation_text': 'Il est facile de traduire des langues à l'aide de transformateurs.'}]

Hugging Face 展示了变换器架构如何在可立即使用的模型中使用。

摘要

在本章中，我们首先通过研究变换器架构可以揭示的令人震惊的远距离依赖关系入门。变换器可以执行从书面和口头序列到有意义表示的转换，这在自然语言理解（NLU）的历史上前所未有。

这两个维度，转换的扩展和实现的简化，将人工智能推向了前所未有的水平。

我们探索了从转换问题和序列建模中移除 RNN、LSTM 和 CNN 的大胆方法，以构建 Transformer 架构。编码器和解码器的标准化维度的对称设计使得从一个子层到另一个子层的流程几乎无缝连接。

我们看到，除了移除循环网络模型外，变换器还引入了并行化层，减少了训练时间。我们还发现了其他创新，例如位置编码和掩码多头注意力。

灵活的、原始的 Transformer 架构为许多其他创新变体提供了基础，为更强大的转换问题和语言建模打开了道路。

在接下来的章节中，当描述原始模型的许多变体时，我们将更深入地了解 Transformer 架构的一些方面。

Transformer 的到来标志着一个新一代即用型人工智能模型的开始。例如，Hugging Face 和 Google Brain 使人工智能易于使用，只需几行代码即可实现。

在下一章节，Fine-Tuning BERT Models，我们将探讨原始 Transformer 模型的强大进化。

问题

NLP 转换可以编码和解码文本表示。（真/假）
自然语言理解（NLU）是自然语言处理（NLP）的子集。（真/假）
语言建模算法根据输入序列生成可能的单词序列。（真/假）
一个 Transformer 是一个定制的 LSTM，带有一个 CNN 层。（真/假）
一个 Transformer 不包含 LSTM 或 CNN 层。（真/假）
注意力机制检查序列中的所有标记，而不仅仅是最后一个。（真/假）
一个 Transformer 使用位置向量，而不是位置编码。（真/假）
一个 Transformer 包含一个前馈网络。（真/假）
Transformer 解码器的掩码多头注意力组件防止算法解析给定位置的序列其余部分正在处理的部分。（真/假）
Transformers 能够比 LSTM 更好地分析长距离依赖关系。（真/假）

参考文献

Ashish Vaswani，Noam Shazeer，Niki Parmar，Jakob Uszkoreit，Llion Jones，Aidan N. Gomez，Lukasz Kaiser，Illia Polosukhin，2017，《Attention Is All You Need》，arxiv.org/abs/1706.03762
Hugging Face Transformer 使用说明：huggingface.co/transformers/usage.html
Tensor2Tensor（T2T）介绍：colab.research.google.com/github/tensorflow/tensor2tensor/blob/master/tensor2tensor/notebooks/hello_t2t.ipynb?hl=en
Manuel Romero 的笔记本，链接至 Raimi Karim 的解释：colab.research.google.com/drive/1rPk3ohrmVclqhH7uQ7qys4oznDdAhpzF
谷歌语言研究：research.google/teams/language/
Hugging Face 的研究：huggingface.co/transformers/index.html
The Annotated Transformer：nlp.seas.harvard.edu/2018/04/03/attention.html
Jay Alammar，《The Illustrated Transformer》：jalammar.github.io/illustrated-transformer/

加入我们书籍的 Discord 空间

加入书籍的 Discord 工作区，与作者进行每月的问我任何事会话：

www.packt.link/Transformers

第三章：微调 BERT 模型

在第二章，开始使用Transformers模型的架构中，我们定义了原始 Transformer 架构的构建块。将原始 Transformer 想象成用乐高^® 砖块构建的模型。构建套件包含编码器、解码器、嵌入层、位置编码方法、多头注意力层、掩码多头注意力层、后层规范化、前馈子层和线性输出层等砖块。

砖块有各种大小和形状。你可以花几个小时使用相同的建筑套件构建各种模型！一些构建只需要一些砖块。其他构建将添加一个新的部件，就像我们使用乐高^® 组件构建模型时获得额外的砖块一样。

BERT 向 Transformer 构建套件添加了一个新部件：双向多头注意力子层。当我们人类在理解一个句子时遇到问题时，我们不仅仅查看过去的单词。 BERT 像我们一样，同时查看同一句子中的所有单词。

本章将首先探讨来自Transformers的双向编码表示（BERT）的架构。 BERT 以一种新颖的方式仅使用Transformers的编码器块，并且不使用解码器堆栈。

然后，我们将对预训练的 BERT 模型进行微调。我们将对将进行微调的 BERT 模型进行预训练，该模型由第三方训练并上传到 Hugging Face。 Transformers可以进行预训练。然后，例如，可以在几个 NLP 任务上对预训练的 BERT 进行微调。我们将通过使用 Hugging Face 模块进行下游 Transformer 使用的这种迷人经历。

本章涵盖以下主题：

来自Transformers的双向编码表示（BERT）
BERT 的架构
两步 BERT 框架
准备预训练环境
定义预训练编码器层
定义微调
下游多任务处理
构建微调的 BERT 模型
加载可接受性判断数据集
创建注意力掩码
BERT 模型配置
衡量微调模型的性能

我们的第一步将是探索 BERT 模型的背景。

BERT 的架构

BERT 将双向注意引入了Transformers模型。双向注意需要对原始 Transformer 模型进行许多其他更改。

我们将不会讨论第二章，开始使用Transformers模型的架构中描述的Transformers构建块。您可以随时查阅第二章，以查看有关Transformers构建块的某个方面的评论。在本节中，我们将重点关注 BERT 模型的特定方面。

我们将重点关注Devlin等人（2018）设计的演进，描述了编码器堆栈。我们将首先通过编码器堆栈，然后通过预训练输入环境的准备来描述 BERT 的两步框架：预训练和微调。

让我们首先探索编码器堆栈。

编码器堆栈

我们将从原始变换器模型中采用的第一个构建块是编码器层。正如在第二章 变换器模型架构入门 中描述的那样，编码器层显示在图 3.1中：

图 3.1：编码器层

BERT 模型不使用解码器层。BERT 模型具有编码器堆栈，但没有解码器堆栈。掩码的标记（隐藏要预测的标记）位于编码器的注意力层中，我们将在后续部分中放大 BERT 编码器层时看到。

原始变换器包含一个N=6 层的堆栈。原始变换器的维度数为d[model] = 512。原始变换器的注意力头数为A=8。原始变换器的头部维度是：

BERT 编码器层比原始变换器模型更大。

两个 BERT 模型可以使用编码器层构建：

BERT[BASE]，其中包含N=12 编码器层。d[model] = 768，也可以表示为H=768，就像 BERT 论文中所述。多头注意力子层包含A=12 个头。每个头的维度z[A]与原始变换器模型中保持为 64：

在连接之前，每个多头注意力子层的输出将是 12 个头的输出：

output_multi-head_attention={z[0], z[1], z[2],…, z[11]}

BERT[LARGE]，其中包含N=24 编码器层。d[model] = 1024。多头注意力子层包含A=16 个头。每个头的维度z[A]与原始变换器模型中保持为 64：

在连接之前，每个多头注意力子层的输出将是 16 个头的输出：

output_multi-head_attention={z[0], z[1], z[2],…, z[15]}

模型的大小可以总结如下：

图 3.2：变换器模型

BERT 模型不仅限于这三种配置。这三种配置说明了 BERT 模型的主要方面。有许多变种是可能的。

尺寸和维度在 BERT 风格的预训练中起着至关重要的作用。BERT 模型就像人类一样。BERT 模型随着更多的工作内存（维度）和更多的知识（数据）产生更好的结果。学习大量数据的大型变换器模型将为下游自然语言处理任务更好地进行预训练。

让我们进入第一个子层，看看 BERT 模型中输入嵌入和位置编码的基本方面。

准备预训练输入环境

BERT 模型没有解码器层的堆栈。因此，它没有一个掩码的多头注意力子层。BERT 设计者指出，掩码了其余序列的掩码的多头注意力层妨碍了注意力过程。

掩码的多头注意力层掩盖了超出当前位置的所有标记。例如，采用以下句子：

The cat sat on it because it was a nice rug.

如果我们刚到达单词it，编码器的输入可以是:

The cat sat on it<masked sequence>

这种方法的动机是防止模型看到它应该预测的输出。这种从左到右的方法可以产生相当好的结果。

然而，模型不能通过这种方式学到很多。要知道it指的是什么，我们需要看整个句子，达到rug这个词，并弄清楚it指的是地毯。

BERT 的作者想到了一个主意。为什么不预训练模型使用不同的方法来进行预测？

BERT 的作者提出了双向注意力，让一个注意力头同时从左到右和从右到左关注所有单词。换句话说，编码器的自注意力屏蔽可以在不受解码器的掩码多头注意力子层的阻碍的情况下完成任务。

该模型经过了两项任务的训练。第一种方法是掩码语言建模（MLM）。第二种方法是下一句预测（NSP）。

让我们从掩码语言建模开始。

掩码语言建模

掩码语言建模不需要训练模型，即可预测由可见单词序列后跟掩码序列。

BERT 引入了对句子的双向分析，其中对句子的一个单词进行随机掩盖。

需要注意的是，BERT 应用了WordPiece，一种子词分词的方法，以及学习的位置编码，而不是正弦-余弦方法。

一个潜在的输入序列可能是:

The cat sat on it because it was a nice rug.

当模型到达单词it后，解码器将掩码注意力序列:

The cat sat on it <masked sequence>.

但是 BERT 编码器会将一个随机标记进行掩码以进行预测:

The cat sat on it [MASK] it was a nice rug.

多重注意力子层现在可以看到整个序列，运行自注意力过程，并预测被掩码的标记。

输入标记以一种棘手的方式进行了掩码，以便让模型训练时间更长，但产生更好的结果，采用三种方法：

在数据集的 10%中，出其不意地不掩盖一个标记; 例如:

The cat sat on it [because] it was a nice rug.

在数据集的 10%中，用随机标记替换标记来出其不意; 例如:

The cat sat on it [often] it was a nice rug.

在 80%的数据集中，将一个标记替换为[MASK]标记; 例如:

The cat sat on it [MASK] it was a nice rug.

作者们大胆的方法避免了过拟合，并迫使模型高效训练。

BERT 还经过训练用于执行下一句预测。

下一句预测

第二种训练 BERT 的方法是下一句预测（NSP）。输入包含两个句子。在 50%的情况下，第二个句子是文档的实际第二句。在 50%的情况下，第二个句子是随机选择的，与第一个句子无关。

添加了两个新标记：

[CLS]是一个二元分类标记，添加到第一个序列的开头，以预测第二个序列是否跟随第一个序列。正样本通常是从数据集中取出的连续句子对。负样本是使用来自不同文档的序列创建的。
[SEP]是一个分隔标记，表示序列的结束。

例如，从一本书中摘录的输入句子可能是：

The cat slept on the rug. It likes sleeping all day.

这两个句子将成为一个完整的输入序列：

[CLS] the cat slept on the rug [SEP] it likes sleep ##ing all day[SEP]

这种方法需要额外的编码信息来区分序列 A 和序列 B。

如果我们将整个嵌入过程放在一起，我们得到：

图 3.3：输入嵌入

输入嵌入由标记嵌入、段（句子、短语、单词）嵌入和位置编码嵌入求和得到。

BERT 模型的输入嵌入和位置编码子层可以总结如下：

一系列单词被分解成WordPiece标记。
一个[MASK]标记将随机替换初始的单词标记，用于掩码语言建模训练。
为了分类目的，在序列的开头插入一个[CLS]分类标记。
一个[SEP]标记分隔两个句子（段落、短语）用于 NSP 训练。
将句子嵌入添加到标记嵌入中，使句子 A 的句子嵌入值与句子 B 不同。
学习位置编码。原始 Transformer 的正弦-余弦位置编码方法没有被应用。

还有一些额外的关键特性：

BERT 在其多头注意力子层中使用双向注意力，打开了广阔的学习视野，并理解标记之间的关系。
BERT 引入了无监督嵌入的场景，使用未标记的文本预训练模型。无监督场景迫使模型在多头注意力学习过程中更加努力思考。这使得 BERT 学习语言的构建方式，并将这些知识应用到下游任务中，而不必每次都进行预训练。
BERT 也使用监督学习，在预训练过程中涵盖了所有基础知识。

BERT 改进了 Transformer 的训练环境。现在让我们看看预训练的动机以及它如何帮助微调过程。

预训练和微调 BERT 模型

BERT 是一个两步框架。第一步是预训练，第二步是微调，如图 3.4所示：

图 3.4：BERT 框架

训练一个 Transformer 模型可能需要几个小时，甚至几天。设计架构和参数以及选择适当的数据集来训练 Transformer 模型需要相当长的时间。

预训练是 BERT 框架的第一步，可以分解为两个子步骤：

定义模型的架构：层数、头数、维度和模型的其他构建模块
在MLM和NSP任务上训练模型

BERT 框架的第二步是微调，也可以分解为两个子步骤：

用预训练的 BERT 模型的训练参数初始化所选的下游模型
针对特定下游任务（如文本蕴涵识别（RTE），问答（SQuAD v1.1，SQuAD v2.0）和带有对抗生成的情境（SWAG））微调参数

在本节中，我们介绍了微调 BERT 模型所需的信息。在接下来的章节中，我们将更深入地探讨本节提出的主题：

在第四章，从头开始预训练 RoBERTa 模型中，我们将从头开始预训练一个类似 BERT 的模型的 15 个步骤。我们甚至会编译我们的数据，训练一个分词器，然后训练模型。这一章旨在首先讨论 BERT 的特定构建模块，然后微调现有模型。
在第五章，变形金刚进行下游自然语言处理任务中，我们将遍历许多下游任务，探索GLUE，SQuAD v1.1，SQuAD，SWAG和其他几个自然语言处理评估数据集。我们将运行几个下游变形金刚模型来说明关键任务。本章的目标是微调一个下游模型。
在第七章，GPT-3 引擎的超人变形金刚的崛起中，将探讨 OpenAI GPT-2和GPT-3变形金刚的架构和使用方法。BERT[BASE]被配置得接近于 OpenAI GPT，以展示它产生了更好的性能。然而，OpenAI 变形金刚也在不断进化！我们将看到它们如何达到了超人类的自然语言处理水平。

在本章中，我们将对语言可接受性语料库（CoLA）上进行微调的 BERT 模型进行训练。下游任务基于Alex Warstadt，Amanpreet Singh和Samuel R. Bowman的神经网络可接受性判断。

我们将微调一个 BERT 模型，该模型将确定一个句子的语法可接受性。微调后的模型将获得一定水平的语言能力。

我们已经讨论了 BERT 的架构及其预训练和微调框架。现在让我们来微调一个 BERT 模型。

微调 BERT

本节将微调一个 BERT 模型，以预测可接受性判断的下游任务，并使用马修斯相关系数（MCC）来衡量预测，这将在本章的使用马修斯相关系数进行评估部分进行解释。

在 Google Colab 中打开BERT_Fine_Tuning_Sentence_Classification_GPU.ipynb（确保你有一个电子邮箱账户）。笔记本在本书的 GitHub 存储库的Chapter03中。

笔记本中每个单元格的标题也与本章的每个小节的标题相同或非常接近。

我们将首先探讨为什么变形金刚模型必须考虑硬件约束。

硬件约束

Transformer 模型需要多处理硬件。在 Google Colab 的运行时菜单中，选择更改运行时类型，并在硬件加速器下拉列表中选择GPU。

Transformer 模型是硬件驱动的。我建议在继续本章之前阅读附录 II，Transformer 模型的硬件约束。

程序将使用 Hugging Face 模块，接下来我们将安装它们。

安装 Hugging Face PyTorch 接口的 BERT

Hugging Face 提供了一个预训练的 BERT 模型。Hugging Face 开发了一个名为PreTrainedModel的基类。通过安装这个类，我们可以从预训练模型配置中加载模型。

Hugging Face 提供了 TensorFlow 和 PyTorch 模块。我建议开发者对两种环境都要熟悉。出色的人工智能研究团队会使用其中一种或两种环境。

在本章中，我们将按照以下方式安装所需的模块：

#@title Installing the Hugging Face PyTorch Interface for Bert
!pip install -q transformers

安装将运行，或者满足要求的消息将被显示。

现在我们可以导入程序所需的模块。

Transformers 自然语言处理（一）（3）https://developer.aliyun.com/article/1514347

Transformers 自然语言处理（一）（2）