精通-Transformers-全-
精通 Transformers(全)
原文:
zh.annas-archive.org/md5/a6f6476d556185fc0ddb2dae043823f3译者:飞龙
序言
在过去的 20 年间,我们在自然语言处理(NLP)领域已经见证了巨大的变化。在此期间,我们经历了不同的范式,最终进入了由神奇的Transformers架构主宰的新时代。这种深度学习架构是通过继承多种方法而形成的。诸如上下文词嵌入、多头自注意力、位置编码、可并行化的架构、模型压缩、迁移学习和跨语言模型等方法都在其中。从各种基于神经网络的自然语言处理方法开始,Transformers架构逐渐演变成为一个基于注意力的编码器-解码器架构,并持续至今。现在,我们在文献中看到了这种架构的新成功变体。有些出色的模型只使用了其编码器部分,比如 BERT,或者只使用了其解码器部分,比如 GPT。
在整本书中,我们将涉及这些自然语言处理方法,并且能够轻松使用来自 Hugging Face 社区的 Transformers 库与Transformers模型进行交互。我们将逐步提供各种自然语言处理问题的解决方案,涵盖从摘要到问答等广泛的话题。我们将看到,借助Transformers的帮助,我们可以取得最先进的结果。
本书的受众
本书适合深度学习研究人员、实践型自然语言处理从业者,以及希望以Transformers架构开始自己学习之旅的机器学习/自然语言处理教育者和学生。初级机器学习知识和良好的 Python 掌握能力将帮助您更好地理解本书的内容。
本书涵盖的内容
第一章,从词袋模型到Transformers,简要介绍了自然语言处理的历史,对比了传统方法、深度学习模型(如 CNN、RNN 和 LSTM)与Transformers模型。
第二章,主题的实践导论,深入探讨了如何使用Transformers模型。我们将通过实例描述分词器和 BERT 等模型。
第三章,自编码语言模型,将让您了解如何从头开始在任何给定语言上训练自编码语言模型。此训练将包括模型的预训练和特定任务的训练。
第四章,自回归和其他语言模型,探讨了自回归语言模型的理论细节,并教会您如何在其特定语料库上进行预训练。您将学会如何在自己的文本上预训练 GPT-2 等任何语言模型,并将其用于诸如语言生成等各种任务。
第五章,微调语言模型进行文本分类,是您将学习如何配置预训练模型进行文本分类以及如何为任何文本分类下游任务,例如情感分析或多类分类进行微调的地方。
第六章,微调语言模型进行标记分类,教您如何微调语言模型以用于诸如 NER、POS 标注和问答等标记分类任务。
第七章,文本表示,是您将学习有关文本表示技术以及如何有效利用 Transformer 架构,特别是对于无监督任务,例如聚类、语义搜索和主题建模的地方。
第八章,高效 Transformer 的工作,向您展示了如何通过蒸馏、修剪和量化将经过训练的模型制作成高效模型。然后,您将了解到关于高效稀疏 Transformer 的知识,例如 Linformer 和 BigBird,以及如何与它们一起工作。
第九章,跨语言和多语言语言建模,是您将学习有关多语言和跨语言语言模型预训练以及单语和多语预训练之间的区别的地方。该章节还涵盖了因果语言建模和翻译语言建模等其他主题。
第十章,服务 Transformer 模型,将详细介绍如何在具有 CPU/GPU 的环境中提供基于 Transformer 的 NLP 解决方案。还将在此处描述使用 TensorFlow Extended(TFX)进行机器学习部署。
第十一章,注意力可视化和实验跟踪,将涵盖两个不同的技术概念:注意力可视化和实验跟踪。我们将使用诸如 exBERT 和 BertViz 等复杂工具来进行实践。
要充分利用本书
要遵循本书,您需要具备 Python 编程语言的基本知识。您还需要了解自然语言处理、深度学习以及深度神经网络的基础知识。
重要提示
本书中的所有代码都是在 Python 3.6 版本中执行的,因为 Python 3.9 版本中的一些库仍处于开发阶段。

如果您使用的是本书的数字版,我们建议您自己输入代码或从本书的 GitHub 代码库中获取代码(链接在下一节中提供)。这样做可以帮助您避免与复制粘贴代码相关的任何潜在错误。
下载示例代码文件
您可以从 GitHub 上下载本书的示例代码文件,网址为github.com/PacktPublishing/Mastering-Transformers。若代码有更新,将在 GitHub 仓库中更新。
我们还有其他代码捆绑包,来自我们丰富的图书和视频目录,可在github.com/PacktPublishing/找到。欢迎查阅!
代码实践
本书的代码实践视频可在bit.ly/3i4vFzJ观看。
下载彩色图片
我们还提供了一个 PDF 文件,其中包含本书中使用的截图和图表的彩色图像。您可以在此处下载:static.packt-cdn.com/downloads/9781801077651_ColorImages.pdf。
使用的惯例
本书中使用了许多文本惯例。
文本中的代码:表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、废弃的 URL、用户输入和 Twitter 句柄。举个例子:"短于max_sen_len(最大句子长度)的序列将使用PAD值填充,直到其长度达到max_sen_len。"
代码块显示如下:
max_sen_len=max([len(s.split()) for s in sentences])
words = ["PAD"]+ list(set([w for s in sentences for w in s.split()]))
word2idx= {w:i for i,w in enumerate(words)}
max_words=max(word2idx.values())+1
idx2word= {i:w for i,w in enumerate(words)}
train=[list(map(lambda x:word2idx[x], s.split())) for s in sentences]
当我们希望引起您对代码块的特别关注时,相关行或条目将以粗体显示:
[default]
exten => s,1,Dial(Zap/1|30)
exten => s,2,Voicemail(u100)
exten => s,102,Voicemail(b100)
exten => i,1,Voicemail(s0)
任何命令行输入或输出均以以下形式呈现:
$ conda activate transformers
$ conda install -c conda-forge tensorflow
粗体:表示新术语、重要词汇或屏幕上看到的词语。例如,菜单或对话框中的词以粗体显示。举个例子:"现在我们必须关注特定模型在给定环境下的计算成本(随机存取存储器(RAM),CPU 和 GPU),包括内存使用和速度。"
提示或重要笔记
如此呈现。
第一部分:介绍 - 领域内的最新发展,安装和 Hello World 应用程序
在本节中,您将以初级水平了解 Transformer 的各个方面。您将通过加载社区提供的预训练语言模型编写您的第一个hello-world程序,并在有或没有 GPU 的情况下运行相关代码。本节还将详细说明安装和使用tensorflow,pytorch,conda,transformers和sentenceTransformers库。
本节包括以下章节:
-
第一章, 从词袋模型到 Transformer
-
第二章, 主题的实践介绍
第一章:从词袋模型到 Transformer
在本章中,我们将讨论在过去的 20 年中自然语言处理(NLP)发生了什么变化。我们经历了不同的范式,最终进入了 Transformer 架构的时代。所有这些范式都帮助我们更好地表示单词和文档以解决问题。分布语义描述了单词或文档的意义,具有矢量表示,观察在文集中的分布证据。矢量用于在受控和非受控流程中解决许多问题。对于语言生成问题,n-gram 语言模型长期以来一直被用作传统方法。然而,这些传统方法存在许多缺点,在整整一章中我们将进行讨论。
我们将进一步讨论经典的深度学习(DL)架构,如循环神经网络(RNNs),前馈神经网络(FFNNs)和卷积神经网络(CNNs)。这些架构已经改善了该领域问题的性能,并克服了传统方法的局限。然而,这些模型也存在各自的问题。最近,由于 Transformer 模型在从文本分类到文本生成的所有 NLP 任务中的有效性,它们引起了巨大的兴趣。然而,主要的成功在于 Transformer 有效地提高了多语言和多任务 NLP 问题的性能,以及单语言和单任务。这些贡献使得迁移学习(TL)在 NLP 中更为可能,其目标是使模型可在不同任务或不同语言中重复使用。
从注意机制开始,我们将简要讨论 Transformer 架构和之前 NLP 模型的区别。与理论讨论并行,我们将展示流行的 NLP 框架的实际示例。为简单起见,我们将选择尽可能简短的入门代码示例。
在本章中,我们将涵盖以下主题:
-
NLP 向 Transformer 的演变
-
理解分布语义
-
利用深度学习
-
Transformer 架构概述
-
使用 Transformer 进行迁移学习
技术要求
我们将使用 Jupyter Notebook 来运行需要安装python >=3.6.0及以下包的编码练习:
-
sklearn -
nltk==3.5.0 -
gensim==3.8.3 -
fasttext -
keras>=2.3.0 -
Transformers >=4.00
所有带有编码练习的笔记本都可在以下 GitHub 链接处找到:github.com/PacktPublishing/Advanced-Natural-Language-Processing-with-Transformers/tree/main/CH01。
查看以下链接以查看视频代码示例:bit.ly/2UFPuVd
NLP 向 Transformer 的发展
过去 20 年来,我们已经看到了自然语言处理(NLP)领域的深刻变化。在这段时间里,我们经历了不同的范式,最终进入了一个主要由神奇的Transformer架构主导的新时代。这种架构并非从天而降。从各种基于神经网络的 NLP 方法开始,它逐渐演变成了基于注意力的编码-解码类型的架构,并且仍在不断发展。过去十年中,由于以下发展,该架构及其各种变体取得了成功:
-
上下文词嵌入
-
更好的子词标记算法,用于处理未知单词或稀有单词
-
将额外的记忆标记注入到句子中,比如
Doc2vec中的段落 ID或来自 Transformer 的双向编码器表示(BERT)中的分类(CLS)标记 -
注意力机制,克服将输入句子强制编码到一个上下文向量中的问题
-
多头自注意力
-
用于处理单词顺序的位置编码
-
可并行化的架构,使训练和微调更快
-
模型压缩(蒸馏、量化等)
-
TL(跨语言、多任务学习)
多年来,我们使用了传统的 NLP 方法,例如n-gram 语言模型、基于 TF-IDF 的信息检索模型和one-hot 编码的文档-术语矩阵。所有这些方法都为解决许多 NLP 问题(如序列分类、语言生成、语言理解等)做出了很大贡献。另一方面,这些传统的 NLP 方法也有其自身的弱点—例如,在解决稀疏性、未知单词表示、跟踪长期依赖关系等问题上存在不足。为了应对这些弱点,我们开发了基于深度学习的方法,如以下所示:
-
RNNs
-
CNNs
-
FFNNs
-
几种 RNNs、CNNs 和 FFNNs 的变种
2013 年,作为两层 FFNN 单词编码器模型,Word2vec通过产生短而稠密的单词表示(称为词嵌入)解决了维度问题。这个早期模型成功地产生了快速而有效的静态词嵌入。它通过预测上下文中的目标单词或基于滑动窗口预测相邻单词,将无监督的文本数据转换为受监督的数据(自监督学习)。GloVe,另一个被广泛使用和普遍流行的模型,认为基于计数的模型可能比神经模型更好。它利用语料库的全局和局部统计数据来学习基于单词共现统计的嵌入。它在一些句法和语义任务上表现良好,如下面的截图所示。截图告诉我们,术语之间的嵌入偏移有助于应用矢量导向推理。我们可以学习性别关系的泛化,这是从男人和女人之间的偏移关系推导出来的语义关系(男人-> 女人)。然后,我们可以通过将男演员的矢量和之前计算出的偏移矢量相加来算出女演员的矢量。同样,我们可以学习词的复数形式。例如,如果给出Actor,Actors和Actress的矢量,我们可以估算Actresses的矢量:

图 1.1 - 用于关系提取的单词嵌入偏移
递归和卷积架构,比如 RNN、长短期记忆(LSTM)和 CNN,开始在序列到序列(seq2seq)问题中被用作编码器和解码器。这些早期模型的主要挑战是多义词。由于给每个单词分配了单一的固定表示,因此忽略了单词的含义,这对多义词和句子语义尤其是一个严重的问题。
进一步的先驱神经网络模型,比如通用语言模型微调(ULMFit)和语言模型嵌入(ELMo),成功地对句子级信息进行编码,并最终缓解了一词多义的问题,与静态词嵌入不同。这两种重要方法基于 LSTM 网络。它们还引入了预训练和微调的概念。它们帮助我们应用迁移学习,利用在大量文本数据集上进行常规任务训练的预训练模型。然后,我们可以很容易地通过在目标任务上继续对预训练网络进行训练,进行微调。这些表示与传统的词嵌入不同,每个单词表示是整个输入句子的函数。现代 Transformer 架构充分利用了这个想法。
与此同时,注意力机制的想法在自然语言处理领域引起了强烈的印象,并取得了显著的成功,特别是在 seq2seq 问题上。早期的方法会传递最后一个状态(称为输入句子中的加拿大政府,用于英语到土耳其语的翻译任务。在输出句子中,Kanada Hükümeti 标记与输入短语建立了强连接,并与输入中的其他单词建立了较弱的连接,如下方截图所示:

图 1.2 – 注意力机制的草图可视化
因此,这种机制使得模型在翻译、问答和文本摘要等 seq2seq 问题中更加成功。
2017 年,基于 Transformer 的编码器-解码器模型被提出并被发现成功。该设计基于 FFNN,丢弃了 RNN 的递归,并仅使用注意力机制(Vaswani et al., All you need is attention, 2017)。到目前为止,基于 Transformer 的模型已经克服了其他方法所面临的许多困难,并成为了一个新的范式。在本书中,你将探索并理解 Transformer 模型的工作原理。
理解分布语义
分布语义描述了单词的含义,并通过矢量表示,最好是查看其分布证据,而不是查看其预定义的词典定义。该理论表明,在相似环境中共同出现的单词倾向于共享相似的含义。这最早由学者哈里斯提出(Distributional Structure Word, 1954)。例如,诸如狗和猫这样的相似单词大多在相同的上下文中共同出现。分布式方法的一个优点是帮助研究人员理解和监测单词随时间和领域的语义演变,也被称为词汇语义变化问题。
多年来,传统方法一直应用词袋模型(BoW)和 n-gram 语言模型来构建单词和句子的表示。在词袋模型中,单词和文档以一种稀疏的方式表示为 one-hot 编码,也被称为向量空间模型(VSM)。
多年来,这些 one-hot 编码技术已解决了文本分类、单词相似度、语义关系提取、单词意义消歧等许多自然语言处理问题。另一方面,n-gram 语言模型为单词序列分配概率,以便我们可以计算一个序列属于语料库的概率,或者基于给定语料库生成一个随机序列。
BoW 实现
一种词袋(BoW)是一种文档的表征技术,通过计算其中的单词来实现。该技术的主要数据结构是文档词项矩阵。让我们用 Python 看一个 BoW 的简单实现。以下代码片段说明了如何使用 Python 的 sklearn 库为一个三句话的玩具语料库构建文档词项矩阵:
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np
import pandas as pd
toy_corpus= ["the fat cat sat on the mat",
"the big cat slept",
"the dog chased a cat"]
vectorizer=TfidfVectorizer()
corpus_tfidf=vectorizer.fit_transform(toy_corpus)
print(f"The vocabulary size is \
{len(vectorizer.vocabulary_.keys())} ")
print(f"The document-term matrix shape is\
{corpus_tfidf.shape}")
df=pd.DataFrame(np.round(corpus_tfidf.toarray(),2))
df.columns=vectorizer.get_feature_names()
代码的输出是一个文档词项矩阵,如下图所示。其大小为 (3 x 10),但在现实场景中,矩阵的大小可以增长到更大的数字,例如 10K x 10M:

图 1.3 – 文档词项矩阵
表格表示的是一种基于计数的数学矩阵,在其中单元格的值按照词频-逆文档频率(TF-IDF)加权模式进行转换。此方法不关心单词的位置。由于单词顺序强烈决定了含义,忽略它会导致意义丧失。这是 BoW 方法中的常见问题,最终通过 RNN 中的递归机制和Transformers中的位置编码得到解决。
矩阵中的每一列代表词汇表中一个词的向量,每一行代表一个文档的向量。可以应用语义相似性指标来计算单词和文档的相似性或非相似性。大多数情况下,我们使用二元组,例如 cat_sat 和 the_street 来丰富文档的表示。例如,当参数 ngram_range=(1,2) 传递给 TfidfVectorizer 时,它构建一个包含 unigrams (big, cat, dog) 和 bigrams (big_cat, big_dog) 的向量空间。因此,这样的模型也被称为词袋式 n-grams,它是BoW的自然扩展。
如果一个词在每篇文章中都经常出现,那么它可以被视为高频词,例如 and 和 the。相反,一些词在文章中很少出现,称为低频(或稀有)词。由于高频和低频词可能会妨碍模型的正常工作,因此在这里使用了 TF-IDF 作为解决方案,这是最重要和著名的加权机制之一。
the 没有区分力,而 chased 可能具有高信息量,可以提供关于文本主题的线索。这是因为高频词(停用词,功能词)在理解文档时具有很少的区分能力。
词的区分度也取决于领域,例如,DL 文章列表中几乎每篇文章都可能有单词 network。IDF 可以通过使用单词的文档频率(DF)来缩小所有词的权值,其中单词的 DF 通过单词出现在的文档数计算得出。词频(TF)是文档中词(术语)的原始计数。
一种基于 TF-IDF 的 BoW 模型的一些优缺点列举如下:

表 1 - TF-IDF BoW 模型的优缺点
克服维度问题
为了克服 BoW 模型的维度问题,潜在语义分析(LSA)被广泛用于在低维空间中捕捉语义。它是一种线性方法,捕捉术语之间的成对相关性。基于 LSA 的概率方法仍然可以被看作是一个隐藏主题变量的单层。然而,当前的 DL 模型包括多个隐藏层,参数量达到数十亿。除此之外,基于 Transformer 的模型表明,它们可以比传统模型更好地发现潜在表示。
对于自然语言理解(NLU)任务,传统的流水线从一些准备步骤开始,如 tokenization、stemming、noun phrase detection、chunking、stop-word elimination 等等。之后,使用任何加权模式构建文档-术语矩阵,其中 TF-IDF 是最流行的。最后,该矩阵作为 机器学习(ML)流水线、情感分析、文档相似性、文档聚类或测量查询与文档之间关联分数的表格化输入。同样,术语被表示为一个表格矩阵,并且可以作为一个 token 分类问题的输入,其中我们可以应用命名实体识别、语义关系提取等。
分类阶段包括对监督式机器学习算法的直接实现,如支持向量机(SVM)、随机森林、逻辑回归、朴素贝叶斯和多个学习器(Boosting 或 Bagging)。实际上,这样一个流水线的实现可以简单地编码如下:
from sklearn.pipeline import make_pipeline
from sklearn.svm import SVC
labels= [0,1,0]
clf = SVC()
clf.fit(df.to_numpy(), labels)
如前面的代码所示,我们可以轻松地应用 sklearn 应用程序编程接口(API)来进行适配操作。为了将学习到的模型应用于训练数据,执行以下代码:
clf.predict(df.to_numpy())
Output: array([0, 1, 0])
让我们继续下一节吧!
语言建模与生成
对于语言生成问题,传统方法是基于利用 n-gram 语言模型。这也被称为马尔可夫过程,它是一种随机模型,其中每个词(事件)都依赖于前面的一部分词—unigram、bigram 或 n-gram,如下所述:
-
一元组(所有词都是独立的,没有链):这估计了词汇表中每个词的概率,简单地通过它在总词数中的频率计算得到。
-
二元组(一阶马尔可夫过程):这估计了 P(wordi | wordi-1),即 wordi 取决于 wordi-1 的概率,简单地通过 P(wordi,wordi-1) 与 P(wordi-1) 的比率计算得到。
-
N 元组(N 阶马尔可夫过程):这估计了 P(wordi | word0, ..., wordi-1)。
让我们用自然语言工具包(NLTK)库进行一个简单的语言模型实现。在以下实现中,我们使用最大似然估计器(MLE)训练了一个n=2的模型。我们可以选择任何 n-gram 顺序,比如n=1代表 unigrams,n=2代表 bigrams,n=3代表 trigrams 等等:
import nltk
from nltk.corpus import gutenberg
from nltk.lm import MLE
from nltk.lm.preprocessing import padded_everygram_pipeline
nltk.download('gutenberg')
nltk.download('punkt')
macbeth = gutenberg.sents('shakespeare-macbeth.txt')
model, vocab = padded_everygram_pipeline(2, macbeth)
lm=MLE(2)
lm.fit(model,vocab)
print(list(lm.vocab)[:10])
print(f"The number of words is {len(lm.vocab)}")
nltk包首先下载古腾堡语料库,其中包括来自古腾堡项目电子文本存档的一些文本,托管在www.gutenberg.org。它还下载用于标点处理的punkt分词器工具。该分词器使用无监督算法将原始文本划分为句子列表。nltk包已经包含了一个预先训练的英文punkt分词器模型,用于缩写词和搭配词。在使用之前,可以对任何语言的一系列文本进行训练。在后续章节中,我们将讨论如何为 Transformer 模型训练不同和更高效的分词器。以下代码展示了语言模型目前学到的内容:
print(f"The frequency of the term 'Macbeth' is {lm.counts['Macbeth']}")
print(f"The language model probability score of 'Macbeth' is {lm.score('Macbeth')}")
print(f"The number of times 'Macbeth' follows 'Enter' is {lm.counts[['Enter']]['Macbeth']} ")
print(f"P(Macbeth | Enter) is {lm.score('Macbeth', ['Enter'])}")
print(f"P(shaking | for) is {lm.score('shaking', ['for'])}")
这是输出:
The frequency of the term 'Macbeth' is 61
The language model probability score of 'Macbeth' is 0.00226
The number of times 'Macbeth' follows 'Enter' is 15
P(Macbeth | Enter) is 0.1875
P(shaking | for) is 0.0121
n-gram 语言模型保留n-gram计数,并计算生成句子的条件概率。lm=MLE(2)代表最大似然估计,在每个令牌的概率中得出最可能的句子。以下代码使用<s>开头条件生成一个包含 10 个单词的随机句子:
lm.generate(10, text_seed=['<s>'], random_seed=42)
输出如下所示:
['My', 'Bosome', 'franchis', "'", 's', 'of', 'time', ',', 'We', 'are']
我们可以通过text_seed参数提供特定的起始条件,使得生成受到前文的影响。在我们先前的例子中,前文是<s>,这是一个特殊的令牌,表示句子的开头。
到目前为止,我们已经讨论了传统 NLP 模型的基础范式,并用流行的框架提供了非常简单的实现。现在我们将转向 DL 部分,讨论神经语言模型如何塑造 NLP 领域,以及神经模型如何克服传统模型的局限性。
利用 DL
NLP 是 DL 架构广泛且成功应用的领域之一。几十年来,在词和句子表示中特别出现了成功的架构。在本节中,我们将分享这些不同方法的故事,并介绍常用的框架。
学习词嵌入
自从能够在更大的数据集上训练更复杂的神经架构以构建短而密集的表示以来,基于神经网络的语言模型有效地解决了特征表示和语言建模问题。2013 年,Word2vec 模型,这是一种流行的词嵌入技术,使用了简单而有效的架构来学习高质量的连续词表示。它在各种句法和语义语言任务上的表现优于其他模型,如情感分析、释义检测、关系提取等等。该模型的另一个关键因素是其更低的计算复杂性。它最大化了给定任何周围上下文词的当前词的概率,或者反之亦然。
以下代码段说明了如何为剧作 麦克白 的句子训练词向量:
from gensim.models import Word2vec
model = Word2vec(sentences=macbeth, size=100, window= 4, min_count=10, workers=4, iter=10)
该代码通过一个长度为 5 的滑动窗口训练具有 100 个向量大小的词嵌入。为了可视化词嵌入,我们需要通过应用主成分分析(PCA)将维度降低到 3,如下面的代码片段所示:
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
import random
np.random.seed(42)
words=list([e for e in model.wv.vocab if len(e)>4])
random.shuffle(words)
words3d = PCA(n_components=3,random_state=42).fit_transform(model.wv[words[:100]])
def plotWords3D(vecs, words, title):
...
plotWords3D(words3d, words, "Visualizing Word2vec Word Embeddings using PCA")
这是输出:

图 1.4 – 用 PCA 可视化词嵌入
如图所示,莎士比亚剧作的主要角色——麦克白、马尔科姆、班克、麦克达夫等——被映射到彼此附近。同样,辅助动词shall、should 和 would 出现在图 1.4的左下方,彼此靠近。我们还可以通过使用嵌入偏移来捕获类似 man-woman= uncle-aunt 的类比。有关此主题的更多有趣视觉示例,请查看以下项目:projector.tensorflow.org/。
类似 Word2vec 的模型通过采用基于预测的神经架构来学习词嵌入。它们对一些目标函数和附近词预测进行梯度下降。虽然传统方法采用基于计数的方法,但神经模型设计了一个基于预测的架构用于分布语义。基于计数的方法还是基于预测的方法对于分布式词表示更好? GloVe 方法解决了这个问题,并认为这两种方法并没有明显的区别。Jeffrey Penington 等人甚至支持基于计数的方法可能更成功,因为它们捕捉了全局统计信息。他们指出 GloVe 在词类比、词相似性和命名实体识别(NER)任务上胜过其他神经网络语言模型。
然而,这两种范式对于未知单词和单词语义问题并没有提供有效的解决方案。它们不利用子词信息,因此无法学习稀有和未知单词的嵌入。
FastText,另一个广泛使用的模型,提出了一种使用子词信息的新的丰富方法,其中每个单词被表示为一组字符 n-gram。该模型为每个字符 n-gram 设置一个常量向量,并将单词表示为其子向量的和,这是 Hinrich Schütze 首次引入的一种想法(Word Space, 1993)。模型可以计算即使对于未见过的单词也可以学习单词的内部结构,例如后缀/词缀,这在形态丰富的语言(如芬兰语、匈牙利语、土耳其语、蒙古语、韩语、日语、印尼语等)中尤为重要。当前,现代 Transformer 架构使用各种子词标记化方法,例如WordPiece,SentencePiece或字节对编码(BPE)。
RNN 的简要概述
RNN 模型可以通过在较早的时间步中滚动其他标记的信息来学习每个标记表示,并在最后一个时间步学习句子表示。这种机制在许多方面都被发现有益,概述如下:
-
首先,RNN 可以在语言生成或音乐生成的一对多模型中进行重新设计。
-
其次,多对一模型可用于文本分类或情感分析。
-
最后,多对多模型用于 NER 问题。多对多模型的第二个用途是解决编码器-解码器问题,例如机器翻译,问答和文本摘要。
与其他神经网络模型一样,RNN 模型接受通过令牌化算法生成的标记,该算法将整个原始文本分解为原子单位,也称为标记。此外,它将标记单元与数字向量(标记嵌入)相关联,这些向量在训练期间学习。作为替代方案,我们可以事先将嵌入式学习任务分配给著名的单词嵌入算法,例如 Word2vec 或 FastText。
以下是句子The cat is sad.的 RNN 架构的简单示例,其中 x0 是the的向量嵌入,x1 是cat的向量嵌入,依此类推。图 1.5说明了一个被展开成完整深度神经网络(DNN)的 RNN。
The cat is sad.序列,我们关心一个包含五个词的序列。每一层的隐藏状态充当网络的记忆。它编码了所有先前时间步和当前时间步发生了什么的信息。这在下图中表示:

图 1.5 - 一个 RNN 架构
以下是 RNN 架构的一些优势:
-
可变长度输入:具有处理可变长度输入的能力,无论输入的句子大小如何。我们可以将 3 个或 300 个词的句子喂给网络而不更改参数。
-
关注单词顺序:它按顺序逐个处理序列中的单词,关心单词的位置。
-
适用于各种模式(多对多,一对多):我们可以使用相同的循环范式训练机器翻译模型或情感分析。这两种架构都将基于 RNN。
RNN 架构的缺点如下:
-
长期依赖问题:当我们处理一个非常长的文档并尝试链接相距很远的术语时,我们需要关心并编码这些术语之间的所有不相关的其他术语。
-
容易出现梯度爆炸或消失问题:当处理长文档时,更新最初几个单词的权重是一个大问题,这会导致模型由于梯度消失问题而无法训练。
-
难以应用并行训练:并行化将主问题分解为更小的问题,并同时执行解决方案,但是 RNN 遵循经典的顺序方法。每一层都强烈依赖于前面的层,这使得并行化变得不可能。
-
计算速度随序列长度增加而变慢:对于短文本问题,RNN 可能非常高效。但它在处理长文档时速度非常慢,而且存在长期依赖问题。
尽管理论上 RNN 可以在许多时间步骤上处理信息,但在现实世界中,长文档和长期依赖等问题是不可能发现的。长序列在许多深层中被表示。许多研究已经解决了这些问题,其中一些概述如下:
-
Hochreiter 和 Schmidhuber。长短期记忆。1997 年。
-
Bengio 等人。用梯度下降学习长期依赖性是困难的。1993 年。
-
K. Cho 等人。使用 RNN 编码器-解码器学习短语表示的统计机器翻译。2014 年。
LSTM 和门控循环单元
LSTM(Schmidhuber,1997)和门控循环单元(GRUs)(Cho,2014)是 RNN 的新变种,已经解决了长期依赖问题,并引起了极大关注。LSTM 特别是针对长期依赖问题进行了开发。LSTM 模型的优势在于它使用了额外的细胞状态,这是 LSTM 单元顶部的水平序列线。该细胞状态由专用门控制,用于忘记、插入或更新操作。LSTM 架构的复杂单元如下图所示:

图 1.6 – 一个 LSTM 单元
它能够决定以下内容:
-
我们将在细胞状态中存储什么样的信息
-
哪些信息将被遗忘或删除
在原始 RNN 中,为了学习 I 令牌的状态,它会在 timestep0 和 timestepi-1 之间递归处理先前令牌的整个状态。携带来自较早时间步的完整信息会导致梯度消失问题,使得模型无法训练。LSTM 中的门机制允许架构在某个时间步跳过一些不相关的令牌或记住长期状态以便学习当前令牌状态。
GRU 在很多方面与 LSTM 相似,主要区别在于 GRU 不使用细胞状态。相反,该架构简化了,将细胞状态的功能转移到隐藏状态,并且只包括两个门:一个 更新门 和一个 重置门。更新门确定了来自先前和当前时间步的信息将被推送多远。这个特性帮助模型保留了过去的相关信息,从而最小化了梯度消失问题的风险。重置门检测到不相关的数据并使模型忘记它们。
一个使用 Keras 的 LSTM 的温和实现
我们需要从 通用语言理解评估(GLUE)基准中下载 斯坦福情感树库(SST-2)情感数据集。我们可以通过运行以下代码来实现这一点:
$ wget https://dl.fbaipublicfiles.com/glue/data/SST-2.zip
$ unzip SST-2.zip
重要提示
SST-2:这是一个完全标记的解析树,允许在英语中进行完整的情感分析。该语料库最初包括约 12K 个从电影评论中提取的单个句子。它使用斯坦福解析器进行解析,并包含由三名人类评审员注释的 200K 多个唯一短语。有关更多信息,请参见 Socher 等人,用组合矢量语法解析,EMNLP。2013 (nlp.stanford.edu/sentiment)。
下载数据后,让我们将其作为 pandas 对象读取,如下所示:
import tensorflow as tf
import pandas as pd
df=pd.read_csv('SST-2/train.tsv',sep="\t")
sentences=df.sentence
labels=df.label
我们需要设置最大句子长度,构建词汇表和字典(word2idx,idx2words),最后将每个句子表示为索引列表而不是字符串。我们可以通过运行以下代码来实现这一点:
max_sen_len=max([len(s.split()) for s in sentences])
words = ["PAD"]+\
list(set([w for s in sentences for w in s.split()]))
word2idx= {w:i for i,w in enumerate(words)}
max_words=max(word2idx.values())+1
idx2word= {i:w for i,w in enumerate(words)}
train=[list(map(lambda x:word2idx[x], s.split()))\
for s in sentences]
比 max_sen_len(最大句子长度)短的序列将使用 PAD 值填充,直到它们的长度达到 max_sen_len。另一方面,更长的序列将被截断,以使其适合 max_sen_len。以下是实现:
from keras import preprocessing
train_pad = preprocessing.sequence.pad_sequences(train,
maxlen=max_sen_len)
print('Train shape:', train_pad.shape)
Output: Train shape: (67349, 52)
我们准备设计和训练一个 LSTM 模型,如下所示:
from keras.layers import LSTM, Embedding, Dense
from keras.models import Sequential
model = Sequential()
model.add(Embedding(max_words, 32))
model.add(LSTM(32))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',loss='binary_crossentropy', metrics=['acc'])
history = model.fit(train_pad,labels, epochs=30, batch_size=32, validation_split=0.2)
模型将训练 30 个 epochs。为了绘制 LSTM 模型到目前为止学到了什么,我们可以执行以下代码:
import matplotlib.pyplot as plt
def plot_graphs(history, string):
...
plot_graphs(history, 'acc')
plot_graphs(history, 'loss')
该代码生成以下图表,显示了基于 LSTM 的文本分类的训练和验证性能:

图 1.7 – LSTM 网络的分类性能
正如我们之前提到的,基于 RNN 的编码器-解码器模型的主要问题是它为一个序列生成一个固定的表示。 但是,注意机制使得 RNN 能够专注于输入标记的某些部分,并将它们映射到输出标记的某些部分。 发现这种注意机制非常有用,并已成为 Transformer 架构的基本思想之一。 我们将在接下来的部分以及整本书的讨论中讨论 Transformer 架构如何利用注意力。
CNN 的简要概述
CNN 在计算机视觉方面取得成功后,也被用于 NLP,用于建模句子或语义文本分类等任务。 在许多实践中,CNN 由卷积层组成,然后是一个密集的神经网络。 卷积层对数据进行处理以提取有用的特征。 与任何 DL 模型一样,卷积层扮演自动化特征提取的角色。 在 NLP 的情况下,这个特征层是由一个嵌入层提供输入,该层将句子以 one-hot 矢量化格式作为输入。 这些 one-hot 矢量是通过为组成句子的每个单词生成一个token-id来生成的。 以下截图的左侧显示了句子的 one-hot 表示:

图 1.8 - One-hot 矢量
每个由 one-hot 矢量表示的标记都被送入嵌入层。 嵌入层可以通过随机值或使用预训练的单词向量(如 GloVe、Word2vec 或 FastText)进行初始化。 然后,该句子将转换为一个 NxE 形状的密集矩阵(其中N是句子中标记的数量,E是嵌入的大小)。 以下截图说明了 1D CNN 如何处理该密集矩阵:

图 1.9 - 五个标记的句子的 1D CNN 网络
卷积将在不同层和核之上进行。 卷积层的超参数是核大小和核的数量。 值得注意的是,这里应用的是 1D 卷积,原因是标记嵌入不能被视为局部的,我们希望应用能够依次看到多个标记的核。 您可以将其视为具有指定窗口的 n-gram。 使用浅层 TL 结合 CNN 模型也是这些模型的另一个良好的能力。 正如以下截图所示,我们还可以用许多标记的表示的组合来传播网络,正如 2014 年由 Yoon Kim 提出的研究中所建议的那样,《句子分类的卷积神经网络》:

图 1.10 - CNN 中许多表示的组合
例如,我们可以使用三个嵌入层而不是一个,并为每个令牌连接它们。在这种设置下,如果所有三个不同的嵌入的大小为 128,则诸如fell的令牌将具有大小为 3x128 的向量。这些嵌入可以使用来自 Word2vec、GloVe 和 FastText 的预训练向量进行初始化。每一步的卷积运算将使用其各自的三个向量来查看 N 个单词(N 是卷积滤波器的大小)。这里使用的卷积类型是 1D 卷积。这里的维度表示进行操作时可能的移动。例如,2D 卷积将沿两个轴移动,而 1D 卷积只沿一个轴移动。下面的屏幕截图显示了它们之间的区别:

图 1.11 – 卷积方向
以下代码片段是一个处理与 LSTM 管道中使用的相同数据的 1D CNN 实现。它包括Conv1D和MaxPooling层的组合,以及GlobalMaxPooling层。我们可以通过调整参数并添加更多层来扩展该管道以优化模型:
from keras import layers
model = Sequential()
model.add(layers.Embedding(max_words, 32, input_length=max_sen_len))
model.add(layers.Conv1D(32, 8, activation='relu'))
model.add(layers.MaxPooling1D(4))
model.add(layers.Conv1D(32, 3, activation='relu'))
model.add(layers.GlobalMaxPooling1D())
model.add(layers.Dense(1, activation= 'sigmoid')
model.compile(loss='binary_crossentropy', metrics=['acc'])
history = model.fit(train_pad,labels, epochs=15, batch_size=32, validation_split=0.2)
结果表明,CNN 模型与其 LSTM 对应物表现出可比较的性能。虽然 CNN 在图像处理中已成为标准,但我们已经看到了许多成功应用 CNN 在 NLP 中。而 LSTM 模型被训练用于识别跨越时间的模式,CNN 模型则识别跨越空间的模式。
Transformer 架构概述
Transformer模型因其在从文本分类到文本生成等巨大范围的 NLP 问题中的有效性而受到极大关注。注意力机制是这些模型的重要部分,并发挥着非常关键的作用。在 Transformer 模型出现之前,注意力机制被提出作为帮助改进传统 DL 模型(如 RNNs)的工具。为了更好地理解 Transformer 及其对 NLP 的影响,我们将首先研究注意力机制。
注意力机制
Bahdanau 等人(2015 年)提出了注意力机制的第一个变体之一。该机制基于这样一个事实,即基于 RNN 的模型(如 GRUs 或 LSTMs)在诸如token-id之类的任务上存在信息瓶颈,并以递归方式处理它(编码器)。然后,处理过的中间表示被馈送到另一个递归单元(解码器)以提取结果。这种雪崩般的信息就像一个滚动的球,消耗了所有的信息,而将其滚动出来对于解码器部分来说是困难的,因为解码器部分并没有看到所有的依赖关系,只获得中间表示(上下文向量)作为输入。
为了调整这个机制,Bahdanau 提出了一种注意机制,在中间隐藏值上使用权重。这些权重可以调整模型在每个解码步骤中对输入的关注程度。这种出色的指导帮助模型在特定任务中,比如 NMT(许多对许多任务),做出了很大的帮助。这里提供了一个典型注意机制的示意图:

图 1.12 – 注意机制
不同的注意机制提出了不同的改进。 加性,乘性,一般 和 点积 注意机制出现在这些机制家族中。后者,这是一个带有缩放参数的修改版本,被称为缩放点积注意力。这种特定的注意类型是 Transformer 模型的基础,被称为多头注意力机制。加性注意力也是之前在 NMT 任务中引入的一项显着变化。你可以在这里看到不同类型的注意机制的概述:

表 2 – 注意机制的类型(图片灵感来自 https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html )
由于注意机制不仅限于 NLP,它们也被用于各种领域的不同用例,从计算机视觉到语音识别。以下截图展示了一个用于神经图像字幕训练的多模态方法的可视化(K Xu 等,Show, attend and tell: Neural image caption generation with visual attention, 2015):

图 1.13 – 计算机视觉中的注意机制
下图所示的多头注意机制是 Transformer 架构中的一个重要部分:

图 1.14 – 多头注意机制
接下来,让我们了解多头注意机制。
多头注意机制
在深入研究缩放点积注意力机制之前,最好先对自注意力有一个良好的理解。如图 1.15所示,自注意力是一种缩放自注意力机制的基本形式。该机制使用一个显示为X的输入矩阵,并在X中的各个项目之间产生注意力分数。我们将X视为一个 3x4 矩阵,其中 3 代表令牌的数量,4 代表嵌入大小。图 1.15中的Q也称为查询,K称为键,V称为值。在产生Q、K和V之前,三种类型的矩阵被称为theta、phi和g,它们与X相乘。查询(Q)和键(K)之间的乘积结果产生一个注意力分数矩阵。这也可以看作是一个数据库,我们使用查询和键来了解各种项目在数值评估方面的关联程度。注意力分数和V矩阵的乘积产生这种类型的注意力机制的最终结果。其被称为自注意力的主要原因是因为它的统一输入X; Q、K和V是从X计算出来的。你可以在下图中看到所有这些的描述:

图 1.15 – 注意力机制的数学表示(图片来源于 https://blogs.oracle.com/datascience/multi-head-self-attention-in-nlp )
一个缩放点积注意力机制与自注意力(点积)机制非常相似,只是它使用了一个缩放因子。另一方面,多头部分确保模型能够在各个层面上查看输入的各个方面。Transformer 模型关注编码器注释和来自过去层的隐藏值。Transformer 模型的架构没有逐步流程; 相反,它使用位置编码来获取有关输入序列中每个令牌位置的信息。嵌入值(随机初始化)和位置编码的固定值的串联值是输入传递到第一个编码器部分中的层,并通过体系结构传播,如下图所示:

图 1.16 – 一个 Transformer
通过评估不同频率的正弦和余弦波来获取位置信息。位置编码的一个示例在以下截图中可视化:

图 1.17 – 位置编码(图片来源于 http://jalammar.github.io/illustrated-Transformer/ )
在下面的流行截图中给出了 Transformer 架构和缩放点积注意力机制的性能的一个很好的例子:

图 1.18 – Transformer 的注意力映射(图片灵感来自 https://ai.googleblog.com/2017/08/Transformer-novel-neural-network.html )
它 这个词在不同的语境中指代不同的实体,正如前面的截图所示。使用 Transformer 架构的另一个改进在于并行性。传统的顺序循环模型如 LSTM 和 GRU 并没有这样的能力,因为它们逐个处理输入标记。另一方面,前馈层的速度会更快一些,因为单个矩阵乘法比循环单元要快得多。多头注意力层的堆叠可以更好地理解复杂的句子。一个很好的多头注意力机制的可视化示例如下截图所示:

图 1.19 – 多头注意力机制(图片灵感来自 https://imgur.com/gallery/FBQqrxw )
在注意力机制的解码器侧,采用了与编码器非常相似的方法,但有一些小的修改。多头注意力机制是相同的,但也使用了编码器堆栈的输出。这个编码被提供给第二个多头注意力层中的每个解码器堆栈。这个小修改在解码时引入了编码器堆栈的输出。这个修改让模型在解码时意识到编码器输出,并同时在训练期间帮助它在各个层之间有更好的梯度流动。解码器层末端的最终 softmax 层用于为各种用例提供输出,例如原始 Transformer 架构引入的 NMT。
这个架构有两个输入,分别标注为输入和输出(向右移动)。一个始终存在(输入),无论是训练还是推断,而另一个只存在于训练和推断中,它由模型产生。我们之所以不在推断中使用模型预测,是为了防止模型自行出错。但这是什么意思呢?想象一个神经机器翻译模型试图将一句英文翻译成法文——在每个步骤中,它都会对一个词进行预测,并使用该预测的词来预测下一个词。但如果在某个步骤出错了,那么后面的所有预测都会错误。为了防止模型像这样出错,我们提供正确的词作为右移版本。
下图显示了一个 Transformer 模型的可视化示例。它展示了一个具有两个编码器和两个解码器层的 Transformer 模型。这张图中的 加法 & 标准化 层从这张图中的 前馈 层接收输入后添加和标准化它:

图 1.20 – Transformer 模型(图片灵感来自 http://jalammar.github.io/illustrated-Transformer/ )
另一个由基于 Transformer 架构使用的主要改进是基于一种简单的通用文本压缩方案,以防止输入端出现未见标记。这种方法通过使用不同的方法(如字节对编码和句子片段编码)进行,提高了 Transformer 在处理未见标记时的性能。它还在模型遇到形态接近的标记时指导模型。这样的标记在过去是不可见的,并且在训练中很少使用,然而,在推理中可能会看到。在某些情况下,训练中会看到其部分内容;在形态丰富的语言(如土耳其语、德语、捷克语和拉脱维亚语)的情况下会发生后者。例如,模型可能看到单词 training,但没有看到 trainings。在这种情况下,它可以将 trainings 标记为 training+s。当我们将它们视为两个部分时,这两者是常见的。
基于 Transformer 的模型具有相当普遍的特征——例如,它们都是基于这种原始架构的,不同之处在于它们使用和不使用的步骤。在某些情况下,会做出较小的改进——例如,改进多头注意力机制。
使用 Transformer 进行 TL
TL 是人工智能(AI)和机器学习(ML)的一个领域,旨在使模型可在不同任务中重用,例如,在给定任务(如 A)上训练的模型可在不同任务(如 B)上重用(微调)。在 NLP 领域,通过使用可以捕获语言理解的 Transformer-like 架构来实现这一目标。这种模型称为语言模型——它们为其训练的语言提供了一个模型。TL 不是一种新技术,它已经被用于各种领域,如计算机视觉。ResNet、Inception、VGG 和 EfficientNet 是可以用作预训练模型的示例,可在不同的计算机视觉任务上进行微调。
浅层 TL 使用诸如 Word2vec、GloVe 和 Doc2vec 这样的模型在 NLP 中也是可能的。它被称为 浅层,因为这种 TL 背后没有模型,而是利用了预训练的单词/标记向量。你可以使用这些标记或文档嵌入模型,接着使用分类器,或者将它们与其他模型(如 RNNs)结合使用,而不是使用随机嵌入。
在 NLP 中使用 Transformer 模型进行 TL 也是可能的,因为这些模型可以在没有任何标注数据的情况下学习一门语言本身。语言建模是一种用于为各种问题训练可转移权重的任务。掩码语言建模是用于学习一门语言本身的方法之一。与 Word2vec 的基于窗口的模型预测中心词元相似,掩码语言建模采用类似的方法,但有关键差异。给定一个概率,每个词都被掩码并替换为特殊标记,如 [MASK]。语言模型(在我们的情况下是基于 Transformer 的模型)必须预测被掩码的词。与 Word2vec 不同,不是使用一个窗口,而是给出整个句子,模型的输出必须是相同的带有掩码词的句子。
使用 Transformer 架构进行语言建模的第一个模型之一是BERT,它基于 Transformer 架构的编码器部分。通过在训练语言模型之前和之后使用相同的方法,BERT 完成了掩码语言建模。BERT 是一个可转移的语言模型,适用于不同的 NLP 任务,如标记分类、序列分类,甚至问答任务。
每一个任务都是对 BERT 进行微调的任务,一旦一个语言模型被训练完成。BERT 最为人所知的是其在基础 Transformer 编码器模型上的关键特性,通过改变这些特性,提出了不同版本的它——小型、微型、基础、大型和超大型。上下文嵌入使得模型能够根据所处的上下文正确理解每个单词的含义——例如,单词 冷 在两个不同的句子中可能有不同的含义:冷酷无情的杀手 和 寒冷的天气。编码器部分的层数、输入维度、输出嵌入维度和多头注意机制的数量是这些关键特性,如下面的截图所示:

图 1.21 – BERT 的预训练和微调流程(图片灵感来自 J. Devlin 等人,《Bert: Pre-training of deep bidirectional Transformers for language understanding》,2018 年)
如你所见,在图 1.21中,预训练阶段还包括另一个称为下一句预测的目标。我们知道,每个文档由相互跟随的句子组成,而模型理解语言的另一个重要部分是理解句子之间的关系,换句话说,它们是否相关。为了完成这些任务,BERT 引入了特殊的标记,如[CLS]和[SEP]。[CLS]标记是一个最初没有意义的标记,用作所有任务的起始标记,并包含关于句子的所有信息。在诸如 NSP 之类的序列分类任务中,会在此标记的输出(0位置的输出)之上使用分类器。它还有助于评估句子的意义或捕获其语义,例如,当使用孪生 BERT 模型时,通过诸如余弦相似度之类的度量来比较不同句子的这两个[CLS]标记非常有帮助。另一方面,[SEP]用于区分两个句子,它仅用于分隔两个句子。在预训练之后,如果有人打算在情感分析等序列分类任务上对 BERT 进行微调,那么他们将在[CLS]的输出嵌入之上使用一个分类器。值得注意的是,在微调期间,所有 TL 模型都可以被冻结或释放;冻结意味着将模型内的所有权重和偏差视为常量,并停止对它们进行训练。在情感分析的示例中,如果模型被冻结,只有分类器会被训练,而不是模型。
摘要
通过这一章,我们现在来到了结束。你现在应该对 NLP 方法和方法的演变有所了解,从 BoW 到 Transformers。我们看了如何实现基于 BoW、RNN 和 CNN 的方法,并了解了 Word2vec 是什么,以及它如何通过浅层 TL 改进传统的 DL 方法。我们还深入了解了 Transformer 架构的基础,以 BERT 为例。到本章结束时,我们已经了解了 TL 以及 BERT 如何利用它。
到目前为止,我们已经学习了继续阅读下一章所必需的基本信息。我们了解了基于 Transformer 的架构的主要思想以及如何使用此架构应用 TL。
在下一节中,我们将看到如何从头开始运行一个简单的 Transformer 示例。将提供有关安装步骤的相关信息,并且还将详细调查与数据集和基准的工作。
参考文献
-
Mikolov, T., Chen, K., Corrado, G. & Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781.
-
Bahdanau, D., Cho, K. & Bengio, Y. (2014). Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473.
-
Pennington, J., Socher, R. & Manning, C. D. (2014, 十月). GloVe: 用于词表示的全局向量. 在 2014 年自然语言处理会议(EMNLP)论文集中的论文 (pp. 1532-1543).
-
Hochreiter, S. & Schmidhuber, J. (1997). 长短期记忆网络. 神经计算, 9(8), 1735-1780.
-
Bengio, Y., Simard, P, & Frasconi, P. (1994). 使用梯度下降学习长期依赖关系困难. IEEE 神经网络交易, 5(2), 157-166.
-
Cho, K., Van Merriënboer, B., Gulcehre, C., Bahdanau, D., Bougares, F., Schwenk, H. & Bengio, Y. (2014). 使用 RNN 编码器-解码器学习短语表示进行统计机器翻译. arXiv 预印本 arXiv:1406.1078.
-
Kim, Y. (2014). 句子分类的卷积神经网络. CoRR abs/1408.5882 (2014). arXiv 预印本 arXiv:1408.5882.
-
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N. & Polosukhin, I. (2017). 注意力就是一切. arXiv 预印本 arXiv:1706.03762.
-
Devlin, J., Chang, M. W., Lee, K. & Toutanova, K. (2018). Bert: 深度双向 Transformer 的预训练用于语言理解. arXiv 预印本 arXiv:1810.04805.
第二章:主题的实践介绍
到目前为止,我们已经总体了解了基于深度学习(DL)方法的自然语言处理(NLP)的演变。我们也学习了一些有关 Transformer 及其各自架构的基本信息。在本章中,我们将深入研究如何使用 transformer 模型。在本章中,像双向编码器表示的 Transformer(BERT)这样的分词器和模型将以更加技术性的细节进行描述,并提供实际示例,包括如何加载分词器/模型和使用社区提供的预训练模型。但在使用任何特定模型之前,我们需要了解使用安装 Anaconda 所需的安装步骤以提供必要的环境。在安装步骤中,将涵盖在各种操作系统如 Linux、Windows 和 macOS 上安装库和程序的内容。还会展示PyTorch和TensorFlow的安装,在CPU和GPU的两个版本上。还提供了一个Google Colaboratory(Google Colab)安装 Transformer 库的快速指南。还有一个专门讨论在 PyTorch 和 TensorFlow 框架中使用模型的部分。
HuggingFace 模型存储库也是本章的另一个重要部分,讨论了查找不同模型和使用各种管道的步骤,例如,详细介绍了像双向自回归 Transformer(BART)、BERT 和表格解析(TAPAS)这样的模型,以及一瞥生成式预训练 Transformer 2(GPT-2)文本生成。然而,这只是一个概述,在本章中涉及到的部分是准备环境和使用预训练模型,这里不讨论模型训练,因为这在接下来的章节中被赋予了更重要的意义。
一切就绪,我们已经了解了如何通过社区提供的模型使用Transformer库进行推理,接下来介绍datasets库。在这里,我们将介绍加载各种数据集、基准测试和使用指标的方法。加载特定数据集并从中获取数据是我们在这里主要关注的领域之一。这里还会考虑跨语言数据集以及如何使用datasets库中的本地文件。datasets库中的map和filter函数是模型训练的重要函数,并且在本章中也会被研究。
本章是书中的重要部分,因为这里更详细地介绍了datasets库。了解如何使用社区提供的模型并准备好系统以供接下来的内容是非常重要的。
总而言之,本章中我们将涵盖以下主题:
-
使用 Anaconda 安装 Transformer
-
使用语言模型和分词器进行工作
-
使用社区提供的模型进行工作
-
处理基准测试和数据集
-
速度和内存的基准测试
技术要求
您需要安装接下来列出的库和软件。虽然拥有最新版本是一个优点,但是强制安装与彼此兼容版本是必须的。有关 HuggingFace Transformer 的最新版本安装的更多信息,请查看它们在huggingface.co/transformers/installation.html的官方网页:
-
Anaconda
-
Transformer 4.0.0
-
PyTorch 1.1.0
-
TensorFlow 2.4.0
-
数据集 1.4.1
最后,本章中显示的所有代码都可以在本书的 GitHub 存储库 https://github.com/PacktPublishing/Mastering-Transformer/tree/main/CH02 中找到。
点击以下链接查看动态代码演示视频:bit.ly/372ek48
使用 Anaconda 安装 Transformer
Transformer库。但是,也可以在没有 Anaconda 的帮助下安装此库。使用 Anaconda 的主要动机是更容易解释过程并调节使用的软件包。
要开始安装相关库,安装 Anaconda 是必须的一步。Anaconda 文档提供了官方指南,简单介绍了为常见操作系统(macOS,Windows 和 Linux)安装 Anaconda 的步骤。
Linux 安装
用户可以享受许多 Linux 发行版,但其中Ubuntu是偏爱的之一。在本节中,将介绍安装 Anaconda 的步骤。请按以下步骤进行:
-
从 https://www.anaconda.com/products/individual#Downloads 下载 Linux 版本的 Anaconda 安装程序并转到 Linux 部分,如下截图所示:
![图 2.1 - Linux 的 Anaconda 下载链接]()
图 2.1 - Linux 的 Anaconda 下载链接
-
运行
bash命令来安装它并完成以下步骤: -
打开终端并运行以下命令:
bash Terminal./FilePath/For/Anaconda.sh -
按下Enter键查看许可协议,如果你不想全部阅读,按
Q键,然后执行以下操作: -
点击是同意。
-
点击
conda根环境。 -
在终端中运行
python命令后,您应该看到 Python 版本信息后出现 Anaconda 提示符。 -
您可以通过从终端运行
anaconda-navigator命令来访问 Anaconda Navigator。结果,您将看到 Anaconda 图形用户界面(GUI)开始加载相关模块,如下面的截图所示:

图 2.2 - Anaconda Navigator
让我们继续下一节!
Windows 安装
下面的步骤描述了如何在 Windows 操作系统上安装 Anaconda:
-
从 https://www.anaconda.com/products/individual#Downloads 下载安装程序并转到 Windows 部分,如下截图所示:
![图 2.3 – Windows 上的 Anaconda 下载链接]()
图 2.3 – Windows 上的 Anaconda 下载链接
-
打开安装程序并通过点击我同意按钮按照指南进行操作。
-
选择安装位置,如下截图所示:
![图 2.4 – Windows 上的 Anaconda 安装程序]()
图 2.4 – Windows 上的 Anaconda 安装程序
-
不要忘记从 Windows shell 或 Windows 命令行检查
python命令:![图 2.5 – Windows 上的 Anaconda 安装程序高级选项]()
图 2.5 – Windows 上的 Anaconda 安装程序高级选项
-
按照其余的安装说明进行操作并完成安装。
现在您应该能够从开始菜单启动 Anaconda Navigator。
macOS 上的安装
安装 Anaconda 在 macOS 上必须遵循以下步骤:
-
从 https://www.anaconda.com/products/individual#Downloads 下载安装程序并转到 macOS 部分,如下截图所示:
![图 2.6 – macOS 上的 Anaconda 下载链接]()
图 2.6 – macOS 上的 Anaconda 下载链接
-
打开安装程序。
-
按照说明并点击安装按钮在预定义位置安装 macOS,如下截图所示。你可以更改默认目录,但不建议这样做:

图 2.7 – macOS 上的 Anaconda 安装程序
完成安装后,您应该能够访问 Anaconda Navigator。
安装 TensorFlow、PyTorch 和 Transformer
安装 TensorFlow 和 PyTorch 作为用于 DL 的两个主要库可以通过pip或conda本身进行。conda提供了一个用于更轻松安装这些库的命令行界面(CLI)。
为了进行干净的安装并避免中断其他环境,最好为huggingface库创建一个conda环境。您可以通过运行以下代码来实现:
conda create -n Transformer
此命令将创建一个空的环境以安装其他库。一旦创建,我们需要激活它,如下:
conda activate Transformer
安装Transformer库非常简单,只需运行以下命令:
conda install -c conda-forge tensorflow
conda install -c conda-forge pytorch
conda install -c conda-forge Transformer
conda install命令中的-c参数让 Anaconda 使用额外的渠道来搜索库。
请注意,必须安装 TensorFlow 和 PyTorch,因为Transformer库同时使用这两个库。另一个注意事项是,通过 Conda 轻松处理 TensorFlow 的 CPU 和 GPU 版本。如果在tensorflow之后简单地放置–gpu,它将自动安装 GPU 版本。通过cuda库(GPU 版本)安装 PyTorch 时,需要相关库,如cuda,但conda会自动处理这个,不需要进一步的手动设置或安装。以下屏幕截图显示了conda如何自动处理安装 PyTorch GPU 版本,安装相关的cudatoolkit和cudnn库:

图 2.8 – 使用 Conda 安装 PyTorch 和相关 cuda 库
请注意,所有这些安装也可以在没有conda的情况下进行,但使用 Anaconda 的原因是它的易用性。在使用环境或安装 TensorFlow 或 PyTorch 的 GPU 版本方面,Anaconda 像魔术一样工作,是一个很好的时间节省工具。
使用 Google Colab 进行安装
即使使用 Anaconda 节省时间且有用,但在大多数情况下,不是每个人都有这样好的和合理的计算资源可用。在这种情况下,Google Colab 是一个很好的替代方案。在 Colab 中安装Transformer库的命令如下进行:
!pip install Transformer
在语句前加上感叹号会使代码在 Colab shell 中运行,这相当于在终端中而不是使用 Python 解释器运行代码。这将自动安装Transformer库。
使用语言模型和分词器
在本节中,我们将介绍如何使用Transformer库与语言模型及其相关的分词器。为了使用任何指定的语言模型,我们首先需要导入它。我们将从谷歌提供的 BERT 模型开始,并使用其预训练版本,如下所示:
>>> from Transformer import BERTTokenizer
>>> tokenizer = \
BERTTokenizer.from_pretrained('BERT-base-uncased')
前面代码片段的第一行导入了 BERT 分词器,第二行下载了 BERT 基础版本的预训练分词器。请注意,无大小写版本是使用无大小写字母训练的,因此字母出现在大写或小写中都没有关系。要测试并查看输出,必须运行以下代码行:
>>> text = "Using Transformer is easy!"
>>> tokenizer(text)
这将是输出:
{'input_ids': [101, 2478, 19081, 2003, 3733, 999, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1]}
input_ids 显示每个标记的标记 ID,token_type_ids 显示每个标记的类型,它们分隔了第一个和第二个序列,如下面的屏幕截图所示:

图 2.9 – BERT 的序列分隔
attention_mask 是用于显示Transformers模型序列的起始和结束的 0 和 1 的掩码,以防止不必要的计算。每个分词器都有将特殊标记添加到原始序列的自己方式。对于 BERT 分词器,它在序列的开头添加了一个 [CLS] 标记,在序列的结尾添加了一个 [SEP] 标记,可以通过 101 和 102 观察到。这些数字来自预训练分词器的标记 ID。
分词器可用于基于 PyTorch 和 TensorFlow 的 Transformer 模型。为了每个模型都有输出,必须在 return_tensors 中使用 pt 和 tf 关键字。例如,您可以通过简单运行以下命令来使用分词器:
>>> encoded_input = tokenizer(text, return_tensors="pt")
encoded_input 具有将被 PyTorch 模型使用的标记化文本。为了运行模型,例如 BERT 基础模型,可以使用以下代码从 huggingface 模型存储库下载模型:
>>> from Transformer import BERTModel
>>> model = BERTModel.from_pretrained("BERT-base-uncased")
分词器的输出可以通过以下代码行传递给已下载的模型:
>>> output = model(**encoded_input)
这将以嵌入和交叉注意输出的形式给您模型的输出。
在加载和导入模型时,您可以指定要使用的模型的版本。如果您只需在模型名称前加上 TF,Transformer 库将加载其 TensorFlow 版本。以下代码显示了如何加载和使用 TensorFlow 版本的 BERT base:
from Transformer import BERTTokenizer, TFBERTModel
tokenizer = \
BERTTokenizer.from_pretrained('BERT-base-uncased')
model = TFBERTModel.from_pretrained("BERT-base-uncased")
text = " Using Transformer is easy!"
encoded_input = tokenizer(text, return_tensors='tf')
output = model(**encoded_input)
对于特定任务,如使用语言模型填充掩码,huggingface 设计了准备就绪的管道。例如,可以在以下代码片段中看到填充掩码的任务:
>>> from Transformer import pipeline
>>> unmasker = \
pipeline('fill-mask', model='BERT-base-uncased')
>>> unmasker("The man worked as a [MASK].")
此代码将生成以下输出,显示分数和可能放置在 [MASK] 标记中的标记:
[{'score': 0.09747539460659027, 'sequence': 'the man worked as a carpenter.', 'token': 10533, 'token_str': 'carpenter'}, {'score': 0.052383217960596085, 'sequence': 'the man worked as a waiter.', 'token': 15610, 'token_str': 'waiter'}, {'score': 0.049627091735601425, 'sequence': 'the man worked as a barber.', 'token': 13362, 'token_str': 'barber'}, {'score': 0.03788605332374573, 'sequence': 'the man worked as a mechanic.', 'token': 15893, 'token_str': 'mechanic'}, {'score': 0.03768084570765495, 'sequence': 'the man worked as a salesman.', 'token': 18968, 'token_str': 'salesman'}]
要使用 pandas 获取清晰的视图,请运行以下代码:
>>> pd.DataFrame(unmasker("The man worked as a [MASK]."))
结果可以在以下截图中看到:

图 2.10 – BERT 填充掩码的输出
到目前为止,我们已经学习了如何加载和使用预训练的 BERT 模型,并了解了分词器的基础知识,以及模型的 PyTorch 和 TensorFlow 版本之间的区别。在下一节中,我们将学习如何使用社区提供的模型,通过加载不同的模型,阅读模型作者提供的相关信息,并使用不同的管道,如文本生成或问答(QA)管道。
使用社区提供的模型
Hugging Face 拥有大量由来自大型人工智能(AI)和信息技术(IT)公司(如谷歌和 Facebook)的合作者提供的社区模型。还有许多个人和大学提供的有趣模型。访问和使用它们也非常容易。要开始,请访问他们网站上提供的 Transformer 模型目录( https://huggingface.co/models ),如下截图所示:

图 2.11 – Hugging Face 模型库
除了这些模型,还有很多好用的数据集可供 NLP 任务使用。要开始使用其中一些模型,你可以通过关键字搜索或只需指定你的主要 NLP 任务和流水线来探索它们。
例如,我们正在寻找一个表格 QA 模型。在找到我们感兴趣的模型之后,从 Hugging Face 网站(huggingface.co/google/tapas-base-finetuned-wtq)会提供类似下面这个页面:

图 2.12 – TAPAS 模型页面
右侧有一个面板,你可以在这里测试这个模型。请注意,这是一个可以回答关于提供给模型的表格的问题的表格 QA 模型。如果你问一个问题,它会用高亮显示的方式来回复你。以下截图展示了它如何获取输入并为特定表格提供答案:

图 2.13 – 使用 TAPAS 进行表格 QA
每个模型都有一个由模型作者提供的页面,也被称为huggingface库页面,并查看作者提供的示例(huggingface.co/gpt2),如下截图所示:

图 2.14 – 来自 Hugging Face GPT-2 页面的文本生成代码示例
使用流水线是推荐的,因为所有繁琐的工作都由Transformer库处理好了。举个例子,假设你需要一个开箱即用的零-shot 分类器。下面的代码片段展示了实现和使用这样一个预训练模型是多么容易:
>>> from Transformer import pipeline
>>> classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
>>> sequence_to_classify = "I am going to france."
>>> candidate_labels = ['travel', 'cooking', 'dancing']
>>> classifier(sequence_to_classify, candidate_labels)
上述代码将提供以下结果:
{'labels': ['travel', 'dancing', 'cooking'], 'scores': [0.9866883158683777, 0.007197578903287649, 0.006114077754318714], 'sequence': 'I am going to france.'}
我们已经完成了安装和hello-world应用程序部分。到目前为止,我们介绍了安装过程,完成了环境设置,并体验了第一个 transformer 流水线。接下来,我们将介绍datasets库,这将是我们接下来的实验章节中的必备工具。
与基准和数据集一起工作
在介绍datasets库之前,我们最好先谈谈重要的基准,比如Transformer库,我们可以将从一个特定任务学到的内容转移到一个相关任务中,这被称为迁移学习(TL)。通过在相关问题之间迁移表示,我们能够训练出共享通用语言知识的通用模型,也就是多任务学习(MTL)。TL 的另一个方面是跨语言传递知识(多语言模型)。
重要的基准指标
在这一部分中,我们将介绍被基于 Transformer 的架构广泛使用的重要基准。这些基准专门对 MTL 和多语言以及零-shot 学习做出了很大贡献,包括许多具有挑战性的任务。我们将看看以下基准:
-
GLUE
-
SuperGLUE
-
XTREME
-
XGLUE
-
SQuAD
为了使用更少的页面,我们只详细介绍 GLUE 基准的任务,所以我们先看看这个基准。
GLUE 基准
最近的研究指出,多任务训练方法可以比单任务学习获得更好的结果,作为一个特定任务的特定模型。在这个方向上,为了 MTL 引入了 GLUE 基准,这是一个用于评估 MTL 模型在一系列任务上的性能的工具和数据集集合。它提供了一个公共排行榜,用于监控基准测试提交的性能,以及一个总结 11 个任务的单一数字度量标准。该基准包括许多基于现有任务的理解句子任务,这些任务涵盖了各种数据集,包括不同大小、文本类型和难度级别的文本。这些任务按照以下三种类型分类:
-
单句子任务
-
CoLA:Corpus of Linguistic Acceptability 数据集。这个任务由来自语言学理论文章的英语可接受性判断组成。
-
pos/neg标签。 -
相似度和释义任务
-
MRPC:Microsoft Research Paraphrase Corpus 数据集。这个任务是看一对句子是否语义上等价。
-
QQP:Quora Question Pairs 数据集。这个任务决定一对问题是否语义上等价。
-
STS-B:Semantic Textual Similarity Benchmark 数据集。这个任务是从新闻标题中抽取的句子对集合,其相似性得分在 1 到 5 之间。
-
推理任务
-
MNLI:Multi-Genre Natural Language Inference 语料库。这是一组带有文本蕴涵的句子对。任务是预测文本是否蕴涵假设(蕴涵)、否定假设(否定)或者既不是(中性)。
-
QNLI:Question Natural Language Inference 数据集。这是 SQuAD 的转换版本。任务是检查一个句子是否包含问题的答案。
-
RTE:Recognizing Textual Entailment 数据集。这是一个文本蕴涵挑战任务,将来自各种来源的数据结合起来。这个数据集类似于前面的 QNLI 数据集,其中任务是检查第一个文本是否蕴涵第二个文本。
-
WNLI:Winograd Natural Language Inference 架构挑战。这原本是一个代词解析任务,将一个代词和一个句子中的短语联系起来。GLUE 将问题转换为句子对分类,如下面详细说明。
SuperGLUE 基准
与 Glue 类似,SuperGLUE是一个新的基准测试,具有一组更难的语言理解任务,并提供大约八项语言任务的公共排行榜,借鉴了现有数据,与 GLUE 的类似,都使用单一数字性能指标。其背后的动机是,截至撰写本书,在写作时间,当前的 GLUE 得分(90.8)超过人类表现(87.1)。因此,SuperGLUE 提供了一个更具挑战性和多样化的任务,以实现通用目的的语言理解技术。
你可以在gluebenchmark.com上访问 GLUE 和 SuperGLUE 基准测试。
XTREME 基准测试
近年来,自然语言处理研究人员越来越注重学习通用表示而不是单一任务,可以应用于许多相关任务。构建通用语言模型的另一种方法是使用多语言任务。已经观察到最近的多语言模型,如多语言 BERT(mBERT)和 XLM-R,预训练了大量的多语言语料库,当将它们转移到其他语言时表现更好。因此,这里的主要优势是跨语言泛化使我们能够通过零样本跨语言传输在资源匮乏的语言中构建成功的自然语言处理应用程序。
在这个方向上,XTREME基准测试已经设计好。它目前包括约 40 种属于 12 个语言家族的不同语言,并包括需要在各种句法或语义水平上进行推理的 9 个不同任务。然而,将模型扩展到覆盖超过 7000 种世界语言仍然具有挑战性,并存在语言覆盖和模型能力之间的权衡。有关此事的更多详细信息,请查看以下链接:sites.research.google/xtreme。
XGLUE 基准测试
XGLUE是另一个跨语言基准测试,用于评估和改进自然语言理解(NLU)和自然语言生成(NLG)的跨语言预训练模型的性能。它最初由 19 种语言的 11 项任务组成。与 XTREME 的主要区别在于,每项任务的训练数据仅在英语中可用。这迫使语言模型仅从英语文本数据中学习,并将这些知识传递给其他语言,这被称为零样本跨语言传输能力。第二个区别是它同时具有 NLU 和 NLG 任务。有关此事的更多详细信息,请查看以下链接:microsoft.github.io/XGLUE/。
SQuAD 基准测试
SQuAD是 NLP 领域中广泛使用的 QA 数据集。它提供了一组 QA 对,用于评估 NLP 模型的阅读理解能力。它包含一系列问题、一个阅读段落和由众包工作者在一系列维基百科文章上注释的答案。问题的答案是阅读段落中的一段文本。最初的版本,SQuAD1.1,在数据集收集时没有一个无法回答的选项,因此每个问题都有一个在阅读段落中某处可以找到的答案。即使这看起来不可能,NLP 模型也被强制回答问题。SQuAD2.0 是一个改进版本,其中 NLP 模型不仅在可能时必须回答问题,而且在不可能回答时也必须弃权。SQuAD2.0 包含由众包工作者以与可回答问题相似的方式编写的 50,000 个无法回答的问题。此外,它还有来自 SQuAD1.1 的 100,000 个问题。
使用应用程序编程接口访问数据集
datasets库通过 Hugging Face hub 为加载、处理和共享数据集提供了非常高效的实用工具。与 TensorFlow 数据集一样,它使直接从原始数据集主机下载、缓存和动态加载集合变得更加容易。该库还提供了与数据一起的评估指标。事实上,hub 不持有或分发数据集。相反,它保留了关于数据集的所有信息,包括所有者、预处理脚本、描述和下载链接。我们需要检查我们是否有权限使用相应许可证下的数据集。要查看其他功能,请查看相应数据集在 GitHub 存储库下的dataset_infos.json和DataSet-Name.py文件,网址为github.com/huggingface/datasets/tree/master/datasets。
让我们从安装dataset库开始,如下所示:
pip install datasets
以下代码自动使用 Hugging Face hub 加载cola数据集。datasets.load_dataset()函数如果数据尚未缓存,则从实际路径下载加载脚本:
from datasets import load_dataset
cola = load_dataset('glue', 'cola')
cola['train'][25:28]
重要提示
数据集的可重用性:当您多次运行代码时,datasets库会开始缓存您的加载和操作请求。它首先存储数据集,并开始缓存您在数据集上的操作,例如拆分、选择和排序。您会看到一条警告消息,例如reusing dataset xtreme (/home/savas/.cache/huggingface/dataset...)或loading cached sorted...。
在前面的示例中,我们从 GLUE 基准测试中下载了cola数据集,并从其中的train拆分中选择了一些示例。
目前,有 661 个 NLP 数据集和 21 个度量标准用于各种任务,如以下代码片段所示:
from pprint import pprint
from datasets import list_datasets, list_metrics
all_d = list_datasets()
metrics = list_metrics()
print(f"{len(all_d)} datasets and {len(metrics)} metrics exist in the hub\n")
pprint(all_d[:20], compact=True)
pprint(metrics, compact=True)
这是输出结果:
661 datasets and 21 metrics exist in the hub.
['acronym_identification', 'ade_corpus_v2', 'adversarial_qa', 'aeslc', 'afrikaans_ner_corpus', 'ag_news', 'ai2_arc', 'air_dialogue', 'ajgt_twitter_ar', 'allegro_reviews', 'allocine', 'alt', 'amazon_polarity', 'amazon_reviews_multi', 'amazon_us_reviews', 'ambig_qa', 'amttl', 'anli', 'app_reviews', 'aqua_rat']
['accuracy', 'BERTscore', 'bleu', 'bleurt', 'comet', 'coval', 'f1', 'gleu', 'glue', 'indic_glue', 'meteor', 'precision', 'recall', 'rouge', 'sacrebleu', 'sari', 'seqeval', 'squad', 'squad_v2', 'wer', 'xnli']
数据集可能具有多个配置。例如,作为一个聚合基准的 GLUE 有许多子集,如前面提到的 CoLA、SST-2 和 MRPC。要访问每个 GLUE 基准数据集,我们传递两个参数,第一个是glue,第二个是其示例数据集(cola或sst2)中的特定数据集。同样,维基百科数据集提供了几种语言的几种配置。
数据集带有DatasetDict对象,包括多个Dataset实例。当使用拆分选择(split='...')时,我们会得到Dataset实例。例如,CoLA数据集带有DatasetDict,其中包含三个拆分:train、validation和test。虽然训练和验证数据集包括两个标签(1表示可接受,0表示不可接受),但测试拆分的标签值为-1,表示无标签。
让我们看一下CoLA数据集对象的结构,如下所示:
>>> cola = load_dataset('glue', 'cola')
>>> cola
DatasetDict({
train: Dataset({
features: ['sentence', 'label', 'idx'],
num_rows: 8551 })
validation: Dataset({
features: ['sentence', 'label', 'idx'],
num_rows: 1043 })
test: Dataset({
features: ['sentence', 'label', 'idx'],
num_rows: 1063 })
})
cola['train'][12]
{'idx': 12, 'label':1,'sentence':'Bill rolled out of the room.'}
>>> cola['validation'][68]
{'idx': 68, 'label': 0, 'sentence': 'Which report that John was incompetent did he submit?'}
>>> cola['test'][20]
{'idx': 20, 'label': -1, 'sentence': 'Has John seen Mary?'}
数据集对象具有一些额外的元数据信息,这可能对我们有所帮助:split、description、citation、homepage、license和info。让我们运行以下代码:
>>> print("1#",cola["train"].description)
>>> print("2#",cola["train"].citation)
>>> print("3#",cola["train"].homepage)
1# GLUE, the General Language Understanding Evaluation benchmark(https://gluebenchmark.com/) is a collection of resources for training,evaluating, and analyzing natural language understanding systems.2# @article{warstadt2018neural, title={Neural Network Acceptability Judgments}, author={Warstadt, Alex and Singh, Amanpreet and Bowman, Samuel R}, journal={arXiv preprint arXiv:1805.12471}, year={2018}}@inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019}}3# https://nyu-mll.github.io/CoLA/
GLUE 基准提供了许多数据集,如前所述。让我们下载 MRPC 数据集,如下所示:
>>> mrpc = load_dataset('glue', 'mrpc')
类似地,要访问其他 GLUE 任务,我们将更改第二个参数,如下所示:
>>> load_dataset('glue', 'XYZ')
为了对数据可用性进行合理性检查,运行以下代码片段:
>>> glue=['cola', 'sst2', 'mrpc', 'qqp', 'stsb', 'mnli',
'mnli_mismatched', 'mnli_matched', 'qnli', 'rte',
'wnli', 'ax']
>>> for g in glue:
_=load_dataset('glue', g)
XTREME(使用跨语言数据集)是另一个我们已经讨论过的流行跨语言数据集。让我们从 XTREME 集中选择MLQA示例。MLQA 是 XTREME 基准的子集,专为评估跨语言问答模型的性能而设计。它包括约 5,000 个基于 SQuAD 格式的抽取式问答实例,涵盖七种语言,即英语、德语、阿拉伯语、印地语、越南语、西班牙语和简体中文。
例如,MLQA.en.de是一个英德问答示例数据集,可以按如下方式加载:
>>> en_de = load_dataset('xtreme', 'MLQA.en.de')
>>> en_de \
DatasetDict({
test: Dataset({features: ['id', 'title', 'context', 'question', 'answers'], num_rows: 4517
}) validation: Dataset({ features: ['id', 'title', 'context', 'question', 'answers'], num_rows: 512})})
将其视为 pandas DataFrame 可能更方便,如下所示:
>>> import pandas as pd
>>> pd.DataFrame(en_de['test'][0:4])
以下是前述代码的输出:

图 2.15 – 英德跨语言问答数据集
使用 datasets 库进行数据操作
数据集带有许多子集的字典,其中split参数用于决定要加载哪些子集或子集的哪一部分。如果默认情况下为none,它将返回所有子集(train、test、validation或任何其他组合)的数据集字典。如果指定了split参数,它将返回单个数据集而不是字典。对于以下示例,我们只检索cola数据集的train子集:
>>> cola_train = load_dataset('glue', 'cola', split ='train')
我们可以得到一个train和validation子集的混合,如下所示:
>>> cola_sel = load_dataset('glue', 'cola', split = 'train[:300]+validation[-30:]')
split表达式意味着获取train的前 300 个示例和validation的最后 30 个示例,结果为cola_sel。
我们可以应用不同的组合,如下所示的拆分示例:
-
如下所示是来自
train和validation的前 100 个示例:split='train[:100]+validation[:100]' -
train的 50%和validation的最后 30%,如下所示:split='train[:50%]+validation[-30%:]' -
train的前 20%和从validation的切片 [30:50] 中的示例,如下所示:split='train[:20%]+validation[30:50]'
排序、索引和洗牌
以下执行调用 cola_sel 对象的 sort() 函数。我们看到前 15 个和最后 15 个标签:
>>> cola_sel.sort('label')['label'][:15]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> cola_sel.sort('label')['label'][-15:]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
我们已经熟悉 Python 的切片表示法。同样,我们也可以使用类似的切片表示法或索引列表来访问多行,如下所示:
>>> cola_sel[6,19,44]
{'idx': [6, 19, 44],
'label': [1, 1, 1],
'sentence':['Fred watered the plants flat.',
'The professor talked us into a stupor.',
'The trolley rumbled through the tunnel.']}
我们按以下方式洗牌数据集:
>>> cola_sel.shuffle(seed=42)[2:5]
{'idx': [159, 1022, 46],
'label': [1, 0, 1],
'sentence': ['Mary gets depressed if she listens to the Grateful Dead.',
'It was believed to be illegal by them to do that.',
'The bullets whistled past the house.']}
重要提示
种子值:在洗牌时,我们需要传递一个种子值来控制随机性,实现作者和读者之间的一致输出。
缓存和可重用性
使用缓存文件可以通过内存映射(如果数据集适合驱动器)使用快速后端加载大型数据集。这种智能缓存有助于保存和重用在驱动器上执行的操作结果。要查看关于数据集的缓存日志,运行以下代码:
>>> cola_sel.cache_files
[{'filename': '/home/savas/.cache/huggingface...,'skip': 0, 'take': 300}, {'filename': '/home/savas/.cache/huggingface...','skip': 1013, 'take': 30}]
数据集过滤和映射函数
我们可能想要处理数据集的特定选择。例如,我们可以仅检索具有 cola 数据集中包含术语 kick 的句子,如下面的执行所示。datasets.Dataset.filter() 函数返回包含 kick 的句子,其中应用了匿名函数和 lambda 关键字:
>>> cola_sel = load_dataset('glue', 'cola', split='train[:100%]+validation[-30%:]')
>>> cola_sel.filter(lambda s: "kick" in s['sentence'])["sentence"][:3]
['Jill kicked the ball from home plate to third base.', 'Fred kicked the ball under the porch.', 'Fred kicked the ball behind the tree.']
以下过滤用于从集中获取正面(可接受的)示例:
>>> cola_sel.filter(lambda s: s['label']== 1 )["sentence"][:3]
["Our friends won't buy this analysis, let alone the next one we propose.",
"One more pseudo generalization and I'm giving up.",
"One more pseudo generalization or I'm giving up."]
在某些情况下,我们可能不知道类标签的整数代码。假设我们有许多类,而 culture 类的代码难以记住在 10 个类中。我们可以在我们之前的示例中传递一个 acceptable 标签给 str2int() 函数,代替在我们之前的示例中给出整数代码 1,即 acceptable 的代码,如下所示:
>>> cola_sel.filter(lambda s: s['label']== cola_sel.features['label'].str2int('acceptable'))["sentence"][:3]
这产生与之前执行相同的输出。
用映射函数处理数据
datasets.Dataset.map() 函数在数据集上迭代,对集合中的每个示例应用处理函数,并修改示例的内容。以下执行显示添加一个新的 'len' 特征,表示句子的长度:
>>> cola_new=cola_sel.map(lambda e:{'len': len(e['sentence'])})
>>> pd.DataFrame(cola_new[0:3])
这是前面代码片段的输出:

图 2.16 – 带有附加列的 Cola 数据集
作为另一个示例,以下代码片段在 20 个字符后剪切句子。我们不创建新特征,而是更新句子特性的内容,如下所示:
>>> cola_cut=cola_new.map(lambda e: {'sentence': e['sentence'][:20]+ '_'})
输出如下所示:

图 2.17 – 带有更新的 Cola 数据集
使用本地文件工作
要从本地文件加载数据集(在csv、text或json中),以及加载脚本load_dataset()到通用加载脚本。如下代码片段所示,在../data/文件夹中,有三个 CSV 文件(a.csv、b.csv和c.csv),这些文件是从 SST-2 数据集中随机选择的玩具示例。我们可以加载单个文件,如data1对象所示,合并多个文件,如data2对象所示,或进行数据集分割,如data3所示:
from datasets import load_dataset
data1 = load_dataset('csv', data_files='../data/a.csv', delimiter="\t")
data2 = load_dataset('csv', data_files=['../data/a.csv','../data/b.csv', '../data/c.csv'], delimiter="\t")
data3 = load_dataset('csv', data_files={'train':['../data/a.csv','../data/b.csv'], 'test':['../data/c.csv']}, delimiter="\t")
为了以其他格式获取文件,我们传递json或text而不是csv,如下所示:
>>> data_json = load_dataset('json', data_files='a.json')
>>> data_text = load_dataset('text', data_files='a.txt')
到目前为止,我们已经讨论了如何加载、处理和操作数据集,这些数据集要么已经托管在 Hub 上,要么在我们的本地驱动器上。现在,我们将研究如何为 Transformer 模型训练准备数据集。
准备数据集以进行模型训练
让我们从标记化过程开始吧。每个模型都有自己的标记化模型,在实际的语言模型之前进行了训练。我们将在下一章节详细讨论这个问题。为了使用标记器,我们应该已经安装了Transformer库。下面的示例从预训练的distilBERT-base-uncased模型加载了标记器模型。我们使用map和带有lambda的匿名函数将标记器应用于data3中的每个拆分。如果在map函数中选择了batched为True,它会将一批例子传递给tokenizer函数。batch_size值默认为1000,这是传递给函数的每批例子的数量。如果没有选择,则整个数据集作为单个批次传递。代码可以在这里看到:
from Transformer import DistilBERTTokenizer
tokenizer = \ DistilBERTTokenizer.from_pretrained('distilBERT-base-uncased')
encoded_data3 = data3.map(lambda e: tokenizer( e['sentence'], padding=True, truncation=True, max_length=12), batched=True, batch_size=1000)
如下输出所示,我们看到了data3和encoded_data3之间的区别,这里添加了两个额外特征——attention_mask和input_ids——并相应地添加到了数据集中。我们已经在本章的前面部分介绍了这两个特征。简而言之,input_ids是与句子中每个标记对应的索引。这些特征是 Transformer 的Trainer类需要的特征,我们将在接下来的微调章节中讨论。
我们通常一次传递多个句子(称为max_length参数,在这个玩具示例中为12)。我们还截断较长的句子以符合最大长度。代码可以在下面的代码片段中看到:
>>> data3
DatasetDict({
train: Dataset({
features: ['sentence','label'], num_rows: 199 })
test: Dataset({
features: ['sentence','label'], num_rows: 100 })})
>>> encoded_data3
DatasetDict({
train: Dataset({
features: ['attention_mask', 'input_ids', 'label', 'sentence'],
num_rows: 199 })
test: Dataset({
features: ['attention_mask', 'input_ids', 'label', 'sentence'],
num_rows: 100 })})
>>> pprint(encoded_data3['test'][12])
{'attention_mask': [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], 'input_ids': [101, 2019, 5186, 16010, 2143, 1012, 102, 0, 0, 0, 0, 0], 'label': 0, 'sentence': 'an extremely unpleasant film . '}
我们已经完成了datasets库的使用。到目前为止,我们已经评估了数据集的所有方面。我们涵盖了类似于 GLUE 的基准测试,在这里,我们考虑了分类指标。在接下来的部分中,我们将专注于如何对速度和内存的计算性能进行基准测试,而不是分类。
速度和内存基准测试
仅仅比较大型模型在特定任务或基准上的分类性能已经不再足够。现在,我们必须关注特定环境对于特定模型的计算成本(Transformer库,PyTorchBenchmark和TensorFlowBenchmark使得可以为 TensorFlow 和 PyTorch 的模型进行基准测试。
在我们开始实验之前,我们需要检查我们的 GPU 能力,采用以下执行:
>>> import torch
>>> print(f"The GPU total memory is {torch.cuda.get_device_properties(0).total_memory /(1024**3)} GB")
The GPU total memory is 2.94921875 GB
输出是从 NVIDIA GeForce GTX 1050 (3 Transformer库当前仅支持单设备基准测试。当我们在 GPU 上进行基准测试时,我们需要指示 Python 代码将在哪个 GPU 设备上运行,这是通过设置CUDA_VISIBLE_DEVICES环境变量来完成的。例如,export CUDA_VISIBLE_DEVICES=0。 0表示将使用第一个cuda设备。
在接下来的代码示例中,我们探索了两个网格。我们比较了四个随机选择的预训练 BERT 模型,如models数组中所列。要观察的第二个参数是sequence_lengths。我们将批量大小保持为4。如果您有更好的 GPU 容量,可以将批量值扩展到 4-64 的范围以及其他参数的搜索空间:
from Transformer import PyTorchBenchmark, PyTorchBenchmarkArguments
models= ["BERT-base-uncased","distilBERT-base-uncased","distilroBERTa-base", "distilBERT-base-german-cased"]
batch_sizes=[4]
sequence_lengths=[32,64, 128, 256,512]
args = PyTorchBenchmarkArguments(models=models, batch_sizes=batch_sizes, sequence_lengths=sequence_lengths, multi_process=False)
benchmark = PyTorchBenchmark(args)
重要注意事项
TensorFlow 的基准测试:本部分的代码示例是用于 PyTorch 基准测试的。对于 TensorFlow 的基准测试,我们简单地使用TensorFlowBenchmarkArguments和TensorFlowBenchmark相应的类。
我们已准备通过运行以下代码进行基准测试实验:
>>> results = benchmark.run()
这可能会花费一些时间,这取决于您的 CPU/GPU 容量和参数选择。如果遇到内存不足的问题,您应该采取以下措施来解决问题:
-
重新启动您的内核或操作系统。
-
在开始之前删除内存中所有不必要的对象。
-
设置较低的批处理大小,例如 2,甚至 1。
以下输出显示了推理速度性能。由于我们的搜索空间有四种不同的模型和五种不同的序列长度,我们在结果中看到了 20 行:

图 2.18 – 推理速度性能
同样,我们将看到 20 种不同情景的推理内存使用情况,如下所示:

图 2.19 – 推理内存使用情况
为了观察跨参数的内存使用情况,我们将使用存储统计数据的results对象进行绘制。以下执行将绘制模型和序列长度的推理时间性能:
import matplotlib.pyplot as plt
plt.figure(figsize=(8,8))
t=sequence_lengths
models_perf=[list(results.time_inference_result[m]['result'][batch_sizes[0]].values()) for m in models]
plt.xlabel('Seq Length')
plt.ylabel('Time in Second')
plt.title('Inference Speed Result')
plt.plot(t, models_perf[0], 'rs--', t, models_perf[1], 'g--.', t, models_perf[2], 'b--^', t, models_perf[3], 'c--o')
plt.legend(models)
plt.show()
如下截图所示,两个 DistillBERT 模型表现出近似的结果,并且比其他两个模型表现更好。BERT-based-uncased模型在特别是序列长度增加时表现不佳:

图 2.20 – 推理速度结果
要绘制内存性能,请使用results对象的memory_inference_result结果,而不是前述代码中显示的time_inference_result。
欲了解更多有趣的基准测试示例,请查看以下链接:
现在我们完成了本节,成功地完成了本章。恭喜您完成安装,运行第一个hello-world变换器程序,使用datasets库并进行基准测试!
总结
在本章中,我们涵盖了各种入门主题,并且也亲手操作了hello-world变换器应用程序。另一方面,这一章在将迄今所学应用于即将到来的章节方面起着关键作用。那么,到目前为止学到了什么呢?我们迈出了第一小步,设置了环境和系统安装。在这个背景下,anaconda软件包管理器帮助我们安装了主要操作系统所需的模块。我们还介绍了语言模型、社区提供的模型和分词过程。此外,我们介绍了多任务(GLUE)和跨语言基准测试(XTREME),这使得这些语言模型变得更强大和更准确。我们介绍了datasets库,该库为社区提供的 NLP 数据集提供了高效的访问方式。最后,我们学会了如何评估特定模型在内存使用和速度方面的计算成本。变换器框架使得可以为 TensorFlow 和 PyTorch 的模型进行基准测试。
本节中使用的模型已由社区预先训练并与我们共享。现在,轮到我们训练语言模型并将其传播给社区了。
在下一章中,我们将学习如何训练 BERT 语言模型以及分词器,并了解如何与社区共享它们。
第二部分:变换模型-从自编码到自回归模型
在本节中,您将了解自编码模型(如 BERT)和自回归模型(如 GPT)的架构。您将学习如何为各种自然语言理解和生成问题训练、测试和微调模型。您还将学习如何与社区共享模型,以及如何微调社区共享的其他预训练语言模型。
本节包括以下章节:
-
第三章, 自编码语言模型
-
第四章, 自回归和其他语言模型
-
第五章, 文本分类的语言模型微调
-
第六章, 标记分类的语言模型微调
-
第七章, 文本表示
第三章:自动编码语言模型
在上一章中,我们查看并研究了如何使用 HuggingFace 的 Transformers 的典型 Transformer 模型。到目前为止,所有主题都包括如何使用预定义或预构建模型,而对于特定模型及其训练的信息较少。
在本章中,我们将了解如何从头开始在任何给定语言上训练自动编码语言模型。这种训练将包括模型的预训练和任务特定训练。首先,我们将从 BERT 模型的基本知识和其工作原理开始。然后,我们将使用一个简单且小型的语料库来训练语言模型。之后,我们将看看如何将该模型用于任何 Keras 模型内。
为了了解本章将学到的内容,我们将讨论以下主题:
-
BERT——其中之一自动编码语言模型
-
任何语言的自动编码语言模型训练
-
与社区共享模型
-
了解其他自动编码模型
-
使用标记化算法工作
技术要求
本章的技术要求如下:
-
Anaconda
-
Transformers >= 4.0.0
-
PyTorch >= 1.0.2
-
TensorFlow >= 2.4.0
-
数据集 >= 1.4.1
-
标记器
请还要检查第三章对应的 GitHub 代码:
github.com/PacktPublishing/Advanced-Natural-Language-Processing-with-Transformers/tree/main/CH03.
查看以下链接以查看代码实战视频:bit.ly/3i1ycdY
BERT——其中之一自动编码语言模型
来自变换器的双向编码器表示,也被称为BERT,是最早使用编码器 Transformer 堆栈的自动编码语言模型之一,稍作修改用于语言建模。
BERT 架构是基于 Transformer 原始实现的多层 Transformer 编码器。Transformer 模型本身最初用于机器翻译任务,但 BERT 所做的主要改进是利用该体系结构的这一部分来提供更好的语言建模。这种语言模型在预训练之后,能够提供对其训练语言的全局理解。
BERT 语言模型预训练任务
要清楚了解 BERT 所使用的遮罩语言建模,让我们更详细地定义它。遮罩语言建模是训练模型的任务,输入是一句话,其中有一些遮罩标记,输出是填满遮罩标记的完整句子。但是这样做为什么能帮助模型在分类等下游任务中获得更好的结果呢?答案很简单:如果模型能够完成完形填空测试(一种通过填写空白来评估语言理解能力的语言测试),那么它就对语言本身有了一般的理解。对于其他任务,它已经进行了预训练(通过语言建模),并且将表现更好。
这是一道完形填空的例子:
乔治·华盛顿是 ___ 州的第一任总统。
预期 United 应该填入空白处。对于遮罩语言模型,应用了同样的任务,需要填补遮罩标记。不过,遮罩标记是从一句话中随机选择的。
BERT 受训的另一个任务是下一句预测(NSP)。这个预训练任务确保 BERT 不仅学习了预测遮罩标记中所有令牌之间的关系,还帮助其理解两个句子之间的关系。会选择一对句子,并在它们之间放上一个[SEP] 分隔符令牌。数据集中还知道第二个句子是在第一个句子之后还是之前。
以下是 NSP 的示例:
读者需要填写空白。比特币价格相比其他替代币高得太多了。
在这个例子中,模型需要预测为否定(这两个句子之间没有关联)。
这两种预训练任务使 BERT 能够对语言本身有所了解。BERT 令牌嵌入为每个令牌提供上下文嵌入。上下文嵌入意味着每个令牌的嵌入与周围令牌完全相关。与 Word2Vec 和其他模型不同,BERT 为每个令牌嵌入提供更好的信息。另一方面,NSP 任务使 BERT 能够为[CLS] 令牌提供更好的嵌入。正如在第一章中讨论的那样,此令牌提供关于整个输入的信息。[CLS] 用于分类任务,并且在预训练部分学习整个输入的总体嵌入。下图显示了 BERT 模型的整体外观。图 3.1 显示了 BERT 模型的相应输入和输出:

图 3.1 – BERT 模型
让我们继续下一部分!
深入了解 BERT 语言模型
标记器是许多 NLP 应用程序中各自流水线中最重要的部分之一。 对于 BERT,使用的是 WordPiece 标记。 通常,WordPiece,SentencePiece和BytePairEncoding(BPE)是最广为人知的三种标记器,由不同的基于 Transformer 的架构使用,也将在接下来的部分中介绍。 BERT 或任何其他基于 Transformer 的架构使用子词标记化的主要原因是这些标记器处理未知标记的能力。
BERT 还使用位置编码来确保将标记的位置提供给模型。如果您还记得章节 1,从词袋模型到 Transformer,BERT 和类似的模型使用非顺序操作,如密集神经层。 传统模型,如基于 LSTM 和 RNN 的模型,通过序列中标记的顺序获得位置。 为了为 BERT 提供这些额外信息,位置编码非常有用。
BERT 的预训练(如自动编码模型)为模型提供了语言信息,但在实践中,当处理不同的问题,如序列分类,标记分类或问题回答时,会使用模型输出的不同部分。
例如,在序列分类任务(如情感分析或句子分类)的情况下,原始 BERT 文章提出了必须使用最后一层的[CLS]嵌入。然而,还有其他研究使用 BERT 进行分类,使用不同的技术(使用所有标记的平均标记嵌入,在最后一层部署 LSTM,甚至在最后一层之上使用 CNN)。 序列分类的最后一个[CLS]嵌入可以被任何分类器使用,但提出的,也是最常见的方法是使用具有输入大小等于最终标记嵌入大小和输出大小等于类数量的 softmax 激活函数的密集层。 当输出可能是多标签并且问题本身是多标签分类问题时,使用 sigmoid 也是另一种选择。
为了给您更详细的关于 BERT 如何实际工作的信息,以下说明显示了一个 NSP 任务的示例。请注意,这里对标记化进行了简化,以便更好地理解:

图 3.2 - 用于 NSP 任务的 BERT 示例
BERT 模型有不同的变体,具有不同的设置。例如,输入大小是可变的。在前面的示例中,它被设置为512,而模型可以接受的最大序列大小是512。但是,这个大小包括特殊标记[CLS]和[SEP],因此它会被缩减为510。另一方面,使用 WordPiece 作为标记器会产生子词标记,作为序列输入之前可以有较少的词,标记化之后,大小会增加,因为标记器会将词分解为子词,如果在预训练语料库中没有看到它们常见。
以下图显示了 BERT 用于不同任务的示例。对于 NER 任务,使用每个令牌的输出,而不是[CLS]。在问答情景中,使用[SEP]分隔符令牌将问题和答案连接起来,然后使用最后一层的Start/End和Span输出标记答案。在这种情况下,Paragraph是Question所询问的Context:

图 3.3 – 用于各种 NLP 任务的 BERT 模型
不管这些任务如何,BERT 最重要的能力是对文本的上下文表示。它成功的原因在于 Transformer 编码器架构,它以密集向量的形式表示输入。这些向量可以通过非常简单的分类器轻松转换为输出。
到目前为止,您已经了解了 BERT 以及它的工作原理。您已经详细了解了 BERT 可以用于的各种任务的重要信息以及这种架构的重要要点。
在下一节中,您将学习如何预先训练 BERT,并在训练后使用它。
任何语言的自编码语言模型训练
我们已经讨论了 BERT 的工作原理以及可以使用 HuggingFace 库提供的预训练版本。在本节中,您将学习如何使用 HuggingFace 库来训练您自己的 BERT。
在开始之前,有一个很重要的问题,那就是需要有良好的训练数据,这将用于语言建模。这些数据称为语料库,通常是一大堆数据(有时经过预处理和清理)。这些无标签的语料库必须适合您希望训练语言模型的用例;例如,如果您尝试为英语单独创建一个特殊的 BERT。尽管有成千上万的巨大优秀数据集,比如 Common Crawl(commoncrawl.org/),我们更倾向于一个小一点的数据集,以便更快地训练。
50K 电影评论的 IMDB 数据集(可在www.kaggle.com/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews找到)是一个用于情感分析的大型数据集,但如果您将其用作语料库来训练语言模型,则算是小型的:
-
你可以使用以下代码轻松下载并保存为
.txt格式,用于语言模型和分词器训练:import pandas as pd imdb_df = pd.read_csv("IMDB Dataset.csv") reviews = imdb_df.review.to_string(index=None) with open("corpus.txt", "w") as f: f.writelines(reviews) -
在准备语料库之后,必须训练分词器。
tokenizers库提供了快速简单的 WordPiece 分词器训练。为了在你的语料库上训练它,需要运行以下代码:>>> from tokenizers import BertWordPieceTokenizer >>> bert_wordpiece_tokenizer =BertWordPieceTokenizer() >>> bert_wordpiece_tokenizer.train("corpus.txt") -
这将训练分词器。你可以通过使用训练好的
tokenizer对象的get_vocab()函数来访问训练好的词汇表。你可以通过以下代码获取词汇表:>>> bert_wordpiece_tokenizer.get_vocab()以下是输出:
{'almod': 9111, 'events': 3710, 'bogart': 7647, 'slapstick': 9541, 'terrorist': 16811, 'patter': 9269, '183': 16482, '##cul': 14292, 'sophie': 13109, 'thinki': 10265, 'tarnish': 16310, '##outh': 14729, 'peckinpah': 17156, 'gw': 6157, '##cat': 14290, '##eing': 14256, 'successfully': 12747, 'roomm': 7363, 'stalwart': 13347,...} -
保存分词器以供以后使用是必不可少的。使用对象的
save_model()函数并提供目录将保存分词器词汇表供以后使用:>>> bert_wordpiece_tokenizer.save_model("tokenizer") -
你可以使用
from_file()函数重新加载它:>>> tokenizer = \ BertWordPieceTokenizer.from_file("tokenizer/vocab.txt") -
你可以按照以下示例使用分词器:
>>> tokenized_sentence = \ tokenizer.encode("Oh it works just fine") >>> tokenized_sentence.tokens ['[CLS]', 'oh', 'it', 'works', 'just', 'fine','[SEP]']特殊的标记
[CLS]和[SEP]将自动添加到标记列表中,因为 BERT 需要它们来处理输入。 -
让我们尝试使用我们的分词器来另一个句子:
>>> tokenized_sentence = \ tokenizer.encode("ohoh i thougt it might be workingg well") ['[CLS]', 'oh', '##o', '##h', 'i', 'thoug', '##t', 'it', 'might', 'be', 'working', '##g', 'well', '[SEP]'] -
对于嘈杂和拼写错误的文本,似乎是一个很好的分词器。现在你已经准备好并保存了你的分词器,你可以训练你自己的 BERT。第一步是使用
Transformers库中的BertTokenizerFast。你需要使用以下命令加载上一步训练好的分词器:>>> from Transformers import BertTokenizerFast >>> tokenizer = \ BertTokenizerFast.from_pretrained("tokenizer")我们使用了
BertTokenizerFast,因为它是由 HuggingFace 文档建议使用的。还有BertTokenizer,根据库文档中的定义,它没有实现快速版本那么快。在大多数预训练模型的文档和卡片中,强烈建议使用BertTokenizerFast版本。 -
下一步是通过以下命令准备语料库以加快训练速度:
>>> from Transformers import LineByLineTextDataset >>> dataset = \ LineByLineTextDataset(tokenizer=tokenizer, file_path="corpus.txt", block_size=128) -
并且需要为掩码语言建模提供数据收集器:
>>> from Transformers import DataCollatorForLanguageModeling >>> data_collator = DataCollatorForLanguageModeling( tokenizer=tokenizer, mlm=True, mlm_probability=0.15)数据收集器获取数据并为训练准备好。例如,上面的数据收集器获取数据并准备好使用概率为
0.15的掩码语言建模。使用这种机制的目的是在运行时进行预处理,这样可以使用更少的资源。另一方面,它会减慢训练过程,因为每个样本都必须在训练时动态进行预处理。 -
训练参数还为训练器在训练阶段提供信息,可以使用以下命令设置:
>>> from Transformers import TrainingArguments >>> training_args = TrainingArguments( output_dir="BERT", overwrite_output_dir=True, num_train_epochs=1, per_device_train_batch_size=128) -
现在我们将创建 BERT 模型本身,我们将使用默认配置(注意力头数、Transformer 编码器层数等):
>>> from Transformers import BertConfig, BertForMaskedLM >>> bert = BertForMaskedLM(BertConfig()) -
最后一步是创建一个训练器对象:
>>> from Transformers import Trainer >>> trainer = Trainer(model=bert, args=training_args, data_collator=data_collator, train_dataset=dataset) -
最后,你可以使用以下命令训练你的语言模型:
>>> trainer.train()它会显示一个进度条,指示训练的进度:
![图 3.4 - BERT 模型训练进度]()
图 3.4 - BERT 模型训练进度
在模型训练过程中,将使用名为
runs的日志目录存储步骤检查点:![图 3.5 – BERT 模型检查点]()
图 3.5 – BERT 模型检查点
-
训练结束后,您可以使用以下命令轻松保存模型:
>>> trainer.save_model("MyBERT")直到目前为止,您已经学会了如何训练您希望的任何特定语言的 BERT。您已经学会了如何训练标记器和 BERT 模型,使用您准备的语料库。
-
您提供的 BERT 默认配置是此训练过程中最关键的部分,它定义了 BERT 的架构和超参数。您可以使用以下代码查看这些参数:
>>> from Transformers import BertConfig >>> BertConfig()输出如下:
![图 3.6 – BERT 模型配置]()
图 3.6 – BERT 模型配置
如果您希望复制
max_position_embedding、num_attention_heads、num_hidden_layers、intermediate_size和hidden_size,直接影响训练时间。将它们增加会显著增加大型语料库的训练时间。 -
例如,您可以使用以下代码轻松为小型 BERT 制作新配置以加快训练速度:
>>> tiny_bert_config = \ BertConfig(max_position_embeddings=512, hidden_size=128, num_attention_heads=2, num_hidden_layers=2, intermediate_size=512) >>> tiny_bert_config以下是代码的结果:
![图 3.8 – 小型 BERT 模型配置]()
图 3.8 – 小型 BERT 模型配置
-
使用相同的方法,我们可以使用这个配置制作一个微小的 BERT 模型:
>>> tiny_bert = BertForMaskedLM(tiny_bert_config) -
并且使用相同的参数进行训练,您可以训练这个微小的新 BERT:
>>> trainer = Trainer(model=tiny_bert, args=training_args, data_collator=data_collator, train_dataset=dataset) >>> trainer.train()输出如下:
![图 3.9 – 小型 BERT 模型配置]()
图 3.9 – 小型 BERT 模型配置
显然,训练时间显著减少,但您应该意识到这是一个具有更少层和参数的微小版 BERT,不如 BERT Base 好。
到目前为止,您已经学会了如何从头开始训练自己的模型,但需要注意的是在处理用于训练语言模型的数据集或利用它执行特定任务的数据集时,使用
datasets库是更好的选择。 -
BERT 语言模型也可以作为嵌入层与任何深度学习模型结合使用。例如,您可以加载任何预训练的 BERT 模型或您在上一步中训练过的自己的版本。以下代码显示了如何加载它以在 Keras 模型中使用:
>>> from Transformers import\ TFBertModel, BertTokenizerFast >>> bert = TFBertModel.from_pretrained( "bert-base-uncased") >>> tokenizer = BertTokenizerFast.from_pretrained( "bert-base-uncased") -
但您不需要整个模型;相反,您可以使用以下代码访问层:
>>> bert.layers [<Transformers.models.bert.modeling_tf_bert.TFBertMainLayer at 0x7f72459b1110>] -
如您所见,只有一个来自
TFBertMainLayer的单层,您可以在 Keras 模型中访问它。但在使用之前,最好先测试它,看看它提供了什么样的输出:>>> tokenized_text = tokenizer.batch_encode_plus( ["hello how is it going with you", "lets test it"], return_tensors="tf", max_length=256, truncation=True, pad_to_max_length=True) >>> bert(tokenized_text)输出如下:
![图 3.10 – BERT 模型输出]()
图 3.10 – BERT 模型输出
如结果所示,有两个输出:一个是最后的隐藏状态,一个是 pooler 输出。最后的隐藏状态提供了来自 BERT 的所有标记嵌入,同时在开头和结尾分别加上了[CLS]和[SEP]标记。
-
现在你已经了解了 TensorFlow 版本的 BERT 更多信息,你可以使用这个新的嵌入创建一个 keras 模型:
from tensorflow import keras import tensorflow as tf max_length = 256 tokens = keras.layers.Input(shape=(max_length,), dtype=tf.dtypes.int32) masks = keras.layers.Input(shape=(max_length,), dtype=tf.dtypes.int32) embedding_layer = bert.layers0[0][:,0,:] dense = tf.keras.layers.Dense(units=2, activation="softmax")(embedding_layer) model = keras.Model([tokens,masks],dense) -
模型对象,即一个 Keras 模型,有两个输入:一个用于标记,一个用于掩码。标记具有来自分词器输出的
token_ids,掩码将具有attention_mask。让我们试一试,看会发生什么:>>> tokenized = tokenizer.batch_encode_plus( ["hello how is it going with you", "hello how is it going with you"], return_tensors="tf", max_length= max_length, truncation=True, pad_to_max_length=True) -
使用
tokenizer时重要的是使用max_length、truncation和pad_to_max_length这些参数。这些参数确保你通过将其填充到之前定义的 256 的最大长度来获得可用形状的输出。现在你可以使用这个样本运行模型了:>>>model([tokenized["input_ids"],tokenized["attention_mask"]])以下是输出结果:
![图 3.11 – BERT 模型分类输出]()
图 3.11 – BERT 模型分类输出
-
当训练模型时,你需要使用
compile函数进行编译:>>> model.compile(optimizer="Adam", loss="categorical_crossentropy", metrics=["accuracy"]) >>> model.summary()输出如下:
![图 3.12 – BERT 模型摘要]()
图 3.12 – BERT 模型摘要
-
从模型摘要中,你可以看到模型有 109,483,778 个可训练参数,包括 BERT。但如果你有预训练好的 BERT 模型,并且想要在特定任务的训练中冻结它,你可以使用以下命令:
>>> model.layers[2].trainable = False据我们所知,嵌入层的层索引为 2,因此我们可以简单地冻结它。如果你重新运行 summary 函数,你会看到可训练参数减少到了 1,538,这是最后一层的参数个数:
![图 3.13 – 包括较少可训练参数的 BERT 模型摘要]()
图 3.13 – BERT 模型摘要,包括较少的可训练参数
-
如你所记得的,我们使用了 IMDB 情感分析数据集来训练语言模型。现在你可以用它来训练基于 Keras 的情感分析模型。但首先,你需要准备输入和输出:
import pandas as pd imdb_df = pd.read_csv("IMDB Dataset.csv") reviews = list(imdb_df.review) tokenized_reviews = \ tokenizer.batch_encode_plus(reviews, return_tensors="tf", max_length=max_length, truncation=True, pad_to_max_length=True) import numpy as np train_split = int(0.8 * \ len(tokenized_reviews["attention_mask"])) train_tokens = tokenized_reviews["input_ids"]\ [:train_split] test_tokens = tokenized_reviews["input_ids"][train_split:] train_masks = tokenized_reviews["attention_mask"]\ [:train_split] test_masks = tokenized_reviews["attention_mask"]\ [train_split:] sentiments = list(imdb_df.sentiment) labels = np.array([[0,1] if sentiment == "positive" else\ [1,0] for sentiment in sentiments]) train_labels = labels[:train_split] test_labels = labels[train_split:] -
最后,你的数据准备好了,你可以拟合你的模型:
>>> model.fit([train_tokens,train_masks],train_labels, epochs=5)
在拟合模型之后,你的模型就准备好使用了。到目前为止,你已经学会了如何对分类任务进行模型训练。你已经学会了如何保存它,在下一节中,你将学会如何与社区分享训练好的模型。
与社区共享模型
HuggingFace 提供了一个非常方便的模型共享机制:
-
你可以简单地使用以下
cli工具进行登录:Transformers-cli login -
使用你自己的凭据登录后,你可以创建一个仓库:
Transformers-cli repo create a-fancy-model-name -
你可以为
a-fancy-model-name参数随意取任何模型名称,然后确保你安装了 git-lfs 是非常重要的:git lfs installGit LFS 是一个用于处理大文件的 Git 扩展。HuggingFace 预训练模型通常是大文件,需要额外的库(如 LFS)来处理 Git。
-
然后,你可以克隆你刚刚创建的仓库:
git clone https://huggingface.co/username/a-fancy-model-name -
随后,您可以随意向仓库中添加和删除,然后,就像使用 Git 一样,您必须运行以下命令:
git add . && git commit -m "Update from $USER" git push
自编码模型依赖于原始 Transformer 左编码器一侧,非常有效地解决分类问题。尽管 BERT 是自编码模型的典型示例,但文献中讨论了许多替代方案。让我们看一下这些重要的替代方案。
理解其他自编码模型
在这部分中,我们将回顾略微修改原始 BERT 的自编码模型替代方案。这些替代方案的重新实现通过利用许多来源(优化预训练过程和层或头的数量、改进数据质量、设计更好的目标函数等)导致了更好的下游任务。改进的来源大致分为两部分:更好的架构设计选择 和 预训练控制。
最近共享了许多有效的替代方案,因此不可能在这里理解和解释它们全部。我们可以看一些文献中引用最多的模型和 NLP 基准测试中使用最多的模型。让我们从 Albert 开始,作为对架构设计选择特别关注的 BERT 的重新实现。
引入 ALBERT
语言模型的性能被认为随着其规模的增大而提高。然而,由于内存限制和较长的训练时间,训练这些模型变得更加具有挑战性。为了解决这些问题,Google 团队提出了 Albert 模型(A Lite BERT 用于语言表示的自监督学习),这实际上是通过利用几种新技术对 BERT 架构进行重新实现,从而减少了内存消耗并增加了训练速度。新设计导致语言模型比原始 BERT 更好地扩展。与原始 BERT-large 模型相比,Albert 参数减少了 18 倍,训练速度提高了 1.7 倍。
Albert 模型主要由对原始 BERT 的三种修改组成:
-
因子化嵌入参数化
-
跨层参数共享
-
句间连贯性损失
前两种修改是与原始 BERT 中模型大小和内存消耗问题相关的参数减少方法。第三种对应于一个新的目标函数:句子顺序预测(SOP),取代了原始 BERT 的 下一句预测(NSP)任务,从而导致了一个更薄的模型和更好的性能。
使用分解嵌入参数化将大词汇嵌入矩阵分解为两个小矩阵,这两个矩阵将隐藏层的大小与词汇表的大小分开。这种分解将嵌入参数从 O(V × H) 减少到 O(V × E + E × H),其中 V 是 词汇表,H 是 隐藏层大小,E 是 嵌入,如果满足 H >> E,则可以更有效地利用总模型参数。
跨层参数共享可以防止网络加深时总参数数量的增加。这一技术被认为是提高参数效率的另一种方式,因为我们可以通过共享或复制来保持参数大小较小。在原始论文中,他们尝试了许多共享参数的方法,例如跨层仅共享 FF 参数、仅共享注意力参数或整个参数。
Albert 的另一个修改是跨句连贯性损失。正如我们已经讨论过的,BERT 架构利用了两种损失计算,即 Masked Language Modeling (MLM) 损失和 NSP。NSP 使用二进制交叉熵损失来预测原始文本中是否连续出现两个段落。负例通过从不同文档中选择两个段落获得。然而,Albert 团队批评 NSP 是一个主题检测问题,被认为是一个相对容易的问题。因此,团队提出了一个基于连贯性而不是主题预测的损失。他们利用了 SOP 损失,它主要关注建模句子间的连贯性而不是主题预测。SOP 损失使用与 BERT 相同的正例技术(即来自同一文档的两个连续段落),并将相同的两个连续段落作为负例,但交换它们的顺序。然后,模型被迫学习更细粒度的话语层面的连贯性特性之间的区别。
-
让我们使用
Transformers库来比较原始的 BERT 和 Albert 配置。以下代码片段展示了如何配置一个 BERT-Base 初始模型。如您在输出中所见,参数数量约为 110 M:#BERT-BASE (L=12, H=768, A=12, Total Parameters=110M) >> from Transformers import BertConfig, BertModel >> bert_base= BertConfig() >> model = BertModel(bert_base) >> print(f"{model.num_parameters() /(10**6)}\ million parameters") 109.48224 million parameters -
以下代码片段显示了如何使用
Transformers库定义具有两个类AlbertConfig和AlbertModel的 Albert 模型:# Albert-base Configuration >>> from Transformers import AlbertConfig, AlbertModel >>> albert_base = AlbertConfig(hidden_size=768, num_attention_heads=12, intermediate_size=3072,) >>> model = AlbertModel(albert_base) >>> print(f"{model.num_parameters() /(10**6)}\ million parameters") 11.683584 million parameters由此,默认 Albert 配置指向 Albert-xxlarge。我们需要设置隐藏大小、注意力头数和中间大小以适应 Albert-base。代码显示 Albert-base 模式为 11M,比 BERT-base 模型小 10 倍。ALBERT 的原始论文报告了以下表格中的基准性能:
![图 3.14 – Albert 模型基准测试]()
图 3.14 – Albert 模型基准测试
-
从这一点开始,为了从头开始训练一个 Albert 语言模型,我们需要通过使用统一的 Transformers API 在前面的章节中已经说明过的类似阶段。在这里没有必要解释相同的步骤!相反,让我们加载一个已经训练好的 Albert 语言模型,如下所示:
from Transformers import AlbertTokenizer, AlbertModel tokenizer = \ AlbertTokenizer.from_pretrained("albert-base-v2") model = AlbertModel.from_pretrained("albert-base-v2") text = "The cat is so sad ." encoded_input = tokenizer(text, return_tensors='pt') output = model(**encoded_input) -
上述代码片段从 HuggingFace hub 或我们的本地缓存目录下载 Albert 模型权重及其配置,如果已经缓存,则表示您已经调用了
AlbertTokenizer.from_pretrained()函数。由于该模型对象是一个预训练语言模型,目前我们可以对该模型做的事情是有限的。我们需要在下游任务上对其进行训练,以便将其用于推理,这将是后续章节的主要主题。相反,我们可以利用其掩码语言模型目标,如下所示:from Transformers import pipeline fillmask= pipeline('fill-mask', model='albert-base-v2') pd.DataFrame(fillmask("The cat is so [MASK] ."))以下是输出:

图 3.15 – albert-base-v2 的填充遮罩输出结果
fill-mask 管道使用 SoftMax() 函数计算每个词汇标记的分数,并对概率最高的标记进行排序,其中 cute 是获胜者,概率得分为 0.281。您可能注意到 token_str 列中的条目以 _ 字符开头,这是由于 Albert 的分词器的 metaspace 组件造成的。
让我们来看看下一个备选项,RoBERTa,它主要侧重于预训练阶段。
RoBERTa
鲁棒优化的 BERT 预训练方法(RoBERTa)是另一种流行的 BERT 重新实现。它在训练策略上提供了更多的改进,而不是架构设计。它在 GLUE 上的几乎所有单个任务中都优于 BERT。动态遮罩是其原始设计选择之一。虽然对于某些任务来说,静态遮罩更好,但 RoBERTa 团队表明,动态遮罩可以在整体性能方面表现良好。让我们比较与 BERT 的变化并总结所有功能如下:
架构的变化如下:
-
移除下一句预测训练目标
-
动态地改变遮罩模式,而不是静态的遮罩,这是通过在将序列馈送到模型时生成遮罩模式来完成的
-
BPE 子词分词器
训练的变化如下:
-
控制训练数据:使用更多的数据,如 160 GB,而不是最初在 BERT 中使用的 16 GB。在研究中考虑到的不仅是数据的大小,还有质量和多样性。
-
较长的迭代次数,最多达到 500K 的预训练步骤。
-
更长的批量大小。
-
更长的序列,这导致更少的填充。
-
一个大的 50K BPE 词汇表,而不是 30K BPE 词汇表。
多亏了Transformers统一的 API,就像上面的 Albert 模型管道一样,我们将 RoBERTa 模型初始化如下:
>>> from Transformers import RobertaConfig, RobertaModel
>>> conf= RobertaConfig()
>>> model = RobertaModel(conf)
>>> print(f"{model.num_parameters() /(10**6)}\
million parameters")
109.48224 million parameters
为了加载预训练模型,我们执行以下代码片段:
from Transformers import RobertaTokenizer, RobertaModel
tokenizer = \
RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaModel.from_pretrained('roberta-base')
text = "The cat is so sad ."
encoded_input = tokenizer(text, return_tensors='pt')
output = model(**encoded_input)
这些行说明了模型如何处理给定的文本。目前,最后一层的输出表示并不有用。正如我们已经多次提到的那样,我们需要对主要语言模型进行微调。以下执行使用 roberta-base 模型应用 fill-mask 函数:
>>> from Transformers import pipeline
>>> fillmask= pipeline("fill-mask ",model="roberta-base",
tokenizer=tokenizer)
>>> pd.DataFrame(fillmask("The cat is so <mask> ."))
以下是输出:

图 3.16 – roberta-base 的填充掩码任务结果
类似于之前的 ALBERT fill-mask 模型,这个流水线对适当的候选词进行排名。请忽略令牌中的前缀 Ġ – 这是由字节级 BPE 分词器生成的编码空格字符,我们稍后会讨论。您应该已经注意到我们在 ALBERT 和 RoBERTa 流水线中使用了 [MASK] 和 <mask> 令牌,以便为掩码令牌留出位置。这是由于 tokenizer 的配置。要了解将使用哪个令牌表达式,您可以检查 tokenizer.mask_token。请参阅以下执行:
>>> tokenizer = \
AlbertTokenizer.from_pretrained('albert-base-v2')
>>> print(tokenizer.mask_token)
[MASK]
>>> tokenizer = \
RobertaTokenizer.from_pretrained('roberta-base')
>>> print(tokenizer.mask_token)
<mask>
为了确保正确使用掩码令牌,我们可以将 fillmask.tokenizer.mask_token 表达式添加到管道中,如下所示:
fillmask(f"The cat is very\
{fillmask.tokenizer.mask_token}.")
ELECTRA
ELECTRA 模型(由 Kevin Clark 等人于 2020 年提出)专注于利用被替换的令牌检测训练目标的新掩码语言模型。在预训练期间,模型被迫学习区分真实输入令牌和合成生成的替换令牌,其中合成的负例是从可信令牌而不是随机抽样的令牌中抽样的。Albert 模型批评了 BERT 的 NSP 目标,认为它是一个主题检测问题,并且使用了低质量的负例。ELECTRA 训练两个神经网络,一个生成器和一个鉴别器,前者产生高质量的负例,而后者区分原始令牌和替换令牌。我们从计算机视觉领域知道了 GAN 网络,在这个网络中,生成器G产生假图像,并试图欺骗鉴别器D,而鉴别器网络试图避免被欺骗。ELECTRA 模型几乎应用了相同的生成器-鉴别器方法来用高质量的合成生成的可信替换替换原始令牌。
为了不重复与其他示例相同的代码,我们只提供了一个简单的 fill-mask 示例作为 Electra 生成器,如下所示:
fillmask = \
pipeline("fill-mask", model="google/electra-small-generator")
fillmask(f"The cat is very \{fillmask.tokenizer.mask_token} .")
您可以在以下链接中看到完整的模型列表:huggingface.co/Transformers/model_summary.html。
模型检查点可以在 huggingface.co/models 找到。
干得好!我们终于完成了自动编码模型部分。现在我们将转向标记化算法,这对于 Transformers 的成功具有重要影响。
使用标记化算法工作
在本章的开头部分,我们使用了特定的分词器,即BertWordPieceTokenizer来训练 BERT 模型。现在值得在这里详细讨论标记化过程。标记化是将文本输入分割成标记并在将其馈送到神经网络架构之前为每个标记分配一个标识符的一种方式。最直观的方法是根据空格将序列分割成较小的块。然而,这种方法不符合一些语言的要求,例如日语,并且也可能导致巨大的词汇问题。几乎所有的 Transformer 模型都利用子词标记化来降低维度,不仅编码训练中未见过的罕见(或未知)单词,而且还为每个单词分配一个唯一的标识符。标记化依赖于这样一个思想,即包括罕见单词或未知单词在内的每个单词都可以分解为在训练语料库中广泛出现的有意义的较小块。
一些传统的标记器是在 Moses 和nltk库中开发的,应用了先进的基于规则的技术。但是与 Transformers 一起使用的标记化算法基于自监督学习,并从语料库中提取规则。基于规则的标记化的简单直观解决方案是使用字符、标点符号或空格。基于字符的标记化会导致语言模型丢失输入的含义。尽管它可以减少词汇量,这是好的,但它使模型难以通过字符c、a和t的编码来捕获cat的含义。此外,输入序列的维度变得非常大。同样,基于标点符号的模型不能正确处理一些表达,例如haven't或ain't。
最近,一些先进的子词标记化算法,如 BPE,已成为 Transformer 架构的一个组成部分。这些现代标记化过程由两个阶段组成:预标记化阶段只是使用空格或语言相关的规则将输入分割为标记。其次,标记化训练阶段是为了训练分词器并基于标记构建一个合理大小的基本词汇表。在训练我们自己的分词器之前,让我们加载一个预训练的分词器。以下代码加载了一个土耳其分词器,类型为BertTokenizerFast,词汇量为 32K:
>>> from Transformers import AutoModel, AutoTokenizer
>>> tokenizerTUR = AutoTokenizer.from_pretrained(
"dbmdz/bert-base-turkish-uncased")
>>> print(f"VOC size is: {tokenizerTUR.vocab_size}")
>>> print(f"The model is: {type(tokenizerTUR)}")
VOC size is: 32000
The model is: Transformers.models.bert.tokenization_bert_fast.BertTokenizerFast
以下代码加载了一个英语 BERT 分词器,用于bert-base-uncased模型:
>>> from Transformers import AutoModel, AutoTokenizer
>>> tokenizerEN = \
AutoTokenizer.from_pretrained("bert-base-uncased")
>>> print(f"VOC size is: {tokenizerEN.vocab_size}")
>>> print(f"The model is {type(tokenizerEN)}")
VOC size is: 30522
The model is ... BertTokenizerFast
让我们看看它们是如何工作的!我们使用这两个标记器对单词telecommunication进行标记化:
>>> word_en="telecommunication"
>>> print(f"is in Turkish Model ? \
{word_en in tokenizerTUR.vocab}")
>>> print(f"is in English Model ? \
{word_en in tokenizerEN.vocab}")
is in Turkish Model ? False
is in English Model ? True
word_en标记已经在英语分词器的词汇表中,但不在土耳其分词器的词汇表中。所以让我们看看土耳其分词器会发生什么:
>>> tokens=tokenizerTUR.tokenize(word_en)
>>> tokens
['tel', '##eco', '##mm', '##un', '##ica', '##tion']
由于土耳其分词器模型的词汇表中没有这样一个词,它需要将单词分解成对它有意义的部分。所有这些分割的标记已经存储在模型词汇表中。请注意以下执行的输出:
>>> [t in tokenizerTUR.vocab for t in tokens]
[True, True, True, True, True, True]
让我们使用我们已经加载的英语分词器对相同的单词进行分词:
>>> tokenizerEN.tokenize(word_en)
['telecommunication']
由于英语模型在基础词汇表中有单词telecommunication,它不需要将其分割成部分,而是将其作为一个整体。通过从语料库中学习,分词器能够将一个单词转换为大部分语法逻辑的子部分。让我们以土耳其语的一个难例为例。作为一种聚合语言,土耳其语允许我们在一个词干上加入许多后缀,构成非常长的单词。以下是土耳其语中使用的最长单词之一(来源于en.wikipedia.org/wiki/Longest_word_in_Turkish):
Muvaffakiyetsizleştiricileştiriveremeyebileceklerimizdenmişsinizcesine
它的意思是仿佛你是我们中那些我们不能轻易快速地使成为失败者的人之一。土耳其 BERT 分词器可能在训练中没有见过这个单词,但它已经看到了它的部分;muvaffak(成功)作为词干,##iyet(成功性),##siz(不成功),##leş(变得不成功),等等。当将结果与维基百科文章进行比较时,土耳其分词器提取出了在土耳其语中看起来是语法合乎逻辑的组件。
>>> print(tokenizerTUR.tokenize(long_word_tur))
['muvaffak', '##iyet', '##siz', '##les', '##tir', '##ici', '##les', '##tir', '##iver', '##emeye', '##bilecekleri', '##mi', '##z', '##den', '##mis', '##siniz', '##cesine']
土耳其分词器是 WordPiece 算法的一个例子,因为它与 BERT 模型协同工作。几乎所有的语言模型,包括 BERT、DistilBERT 和 ELECTRA,都需要一个 WordPiece 分词器。
现在,我们准备研究用于 Transformers 的分词方法。首先,我们将简要讨论一下 BPE、WordPiece 和 SentencePiece 的广泛使用的分词,然后用 HuggingFace 的快速分词器库进行训练。
字节对编码
BPE 是一种数据压缩技术。它会扫描数据序列,并迭代地用一个单一的符号替换最常见的字节对。它最初是在Neural Machine Translation of Rare Words with Subword Units, Sennrich et al. 2015中提出来解决机器翻译中未知单词和稀有单词的问题。目前,它成功应用于 GPT-2 和许多其他领先的模型中。许多现代分词算法都是基于这样的压缩技术。
它将文本表示为字符 n-gram 的序列,也称为字符级子词。训练首先从语料库中看到的所有 Unicode 字符(或符号)的词汇表开始。对于英语来说,这可能很小,但对于日语等字符丰富的语言来说可能很大。然后,它迭代计算字符二元组,并将最常见的字符替换为特殊的新符号。例如,t 和 h 是频繁出现的符号。我们用 th 符号替换连续的符号。该过程一直迭代运行,直到词汇表达到所需的词汇量为止。最常见的词汇量约为 30K。
BPE 在表示未知词时特别有效。然而,它可能无法保证处理包含罕见子词或罕见词的情况。在这种情况下,它将罕见字符与特殊符号
WordPiece 分词
WordPiece 是另一种广泛与 BERT、DistilBERT 和 Electra 配合使用的流行分词算法。它由 Schuster 和 Nakajima 在 2012 年提出,旨在解决日语和韩语语音问题。该工作的动机是,虽然对于英语来说不是一个大问题,但对于许多亚洲语言来说,分词是重要的预处理,因为在这些语言中,空格很少使用。因此,在亚洲语言的自然语言处理研究中,我们经常会遇到分词方法。与 BPE 类似,WordPiece 使用大型语料库来学习词汇和合并规则。虽然 BPE 和 BBPE 基于共现统计学习合并规则,但 WordPiece 算法使用最大似然估计从语料库中提取合并规则。它首先用 Unicode 字符(也称为词汇符号)初始化词汇表。它将训练语料库中的每个词视为符号列表(最初是 Unicode 字符),然后根据最大似然估计从所有可能的候选符号对中选择两个符号进行合并,而不是根据频率。该生产管道持续进行,直到达到所需的词汇量为止。
Sentence piece 分词
以前的标记化算法将文本视为以空格分隔的单词列表。这种基于空格的分割在一些语言中不起作用。在德语中,复合名词是没有空格的,例如 menschenrechte(人权)。解决方案是使用特定于语言的预标记器。在德语中,NLP 流水线利用复合分割模块来检查一个词是否可以分解为较小的词。然而,东亚语言(例如中文、日文、韩文和泰文)之间不使用空格。下划线_字符,这也是我们之前在 Albert 模型示例的输出中看到_的原因。其他使用 SentencePiece 的流行语言模型有 XLNet、Marian 和 T5。
到目前为止,我们已经讨论了子词标记化方法。现在是时候开始使用tokenizers库进行训练实验了。
标记化器库
您可能已经注意到,以前的代码示例中土耳其语和英语的已经训练好的标记化器是Transformers库的一部分。另一方面,HuggingFace 团队独立于Transformers库提供了tokenizers库,以便更快地给我们更多的自由。该库最初是用 Rust 编写的,这使得多核并行计算成为可能,并且用 Python 进行了包装(github.com/huggingface/tokenizers)。
要安装tokenizers库,我们使用这个:
$ pip install tokenizers
tokenizers库提供了几个组件,以便我们从预处理原始文本到解码标记化单元 ID 构建端到端的分词器:
Normalizer→ PreTokenizer → 建模 → 后处理 → 解码
下图描述了标记化流水线:

图 3.17 – 标记化流水线
-
规范化器允许我们应用原始文本处理,例如小写处理、剥离、Unicode 规范化和去除重音。
-
预标记器为下一个训练阶段准备语料库。它根据规则(例如空格)将输入拆分为标记。
-
模型训练是一个子词标记化算法,例如BPE、BBPE和WordPiece,我们已经讨论过了。它发现子词/词汇并学习生成规则。
-
后处理提供了与 Transformer 模型(如 BertProcessors)兼容的高级类构造。我们主要是在馈送给架构之前,向标记化的输入中添加特殊标记,例如[CLS]和[SEP]。
-
解码器负责将标记 ID 转换回原始字符串。它只是用来检查发生了什么。
训练 BPE
让我们使用莎士比亚的戏剧来训练一个 BPE 分词器:
-
加载如下:
import nltk from nltk.corpus import gutenberg nltk.download('gutenberg') nltk.download('punkt') plays=['shakespeare-macbeth.txt','shakespeare-hamlet.txt', 'shakespeare-caesar.txt'] shakespeare=[" ".join(s) for ply in plays \ for s in gutenberg.sents(ply)]对于所有的分词算法,我们需要一个后处理器(
TemplateProcessing)。我们需要自定义后处理器以便为特定的语言模型提供方便的输入。例如,以下模板适用于 BERT 模型,因为它需要在输入开头有[CLS]标记,在末尾和中间都有[SEP]标记。 -
我们如下定义模板:
from tokenizers.processors import TemplateProcessing special_tokens=["[UNK]","[CLS]","[SEP]","[PAD]","[MASK]"] temp_proc= TemplateProcessing( single="[CLS] $A [SEP]", pair="[CLS] $A [SEP] $B:1 [SEP]:1", special_tokens=[ ("[CLS]", special_tokens.index("[CLS]")), ("[SEP]", special_tokens.index("[SEP]")), ], ) -
我们导入必要的组件来构建一个端到端的分词流程:
from tokenizers import Tokenizer from tokenizers.normalizers import \ (Sequence,Lowercase, NFD, StripAccents) from tokenizers.pre_tokenizers import Whitespace from tokenizers.models import BPE from tokenizers.decoders import BPEDecoder -
我们首先实例化BPE如下:
tokenizer = Tokenizer(BPE()) -
预处理部分有两个组件:normalizer和pre-tokenizer。我们可能有多个 normalizer。因此,我们组成一个包含多个 normalizer 的
Sequence,其中NFD()是一个 Unicode 正规化组件,而StripAccents()会移除重音符号。对于 pre-tokenization,Whitespace()会根据空格来分隔文本。由于解码器组件必须与模型兼容,因此选择了BPEDecoder作为BPE模型的解码器:tokenizer.normalizer = Sequence( [NFD(),Lowercase(),StripAccents()]) tokenizer.pre_tokenizer = Whitespace() tokenizer.decoder = BPEDecoder() tokenizer.post_processor=temp_proc -
好了!我们已经准备好对数据进行分词器训练。以下代码实例化
BpeTrainer(),它帮助我们通过设置超参数来组织整个训练过程。由于我们的莎士比亚语料库相对较小,我们将词汇表大小参数设置为 5K。对于大规模项目,我们使用更大的语料库,通常将词汇表大小设置在 30K 左右:>>> from tokenizers.trainers import BpeTrainer >>> trainer = BpeTrainer(vocab_size=5000, special_tokens= special_tokens) >>> tokenizer.train_from_iterator(shakespeare, trainer=trainer) >>> print(f"Trained vocab size:\ {tokenizer.get_vocab_size()}" ) Trained vocab size: 5000我们已经完成了训练!
重要提示
从文件系统训练:为了开始训练过程,我们将一个内存中的莎士比亚对象作为字符串列表传递给
tokenizer.train_from_iterator()。对于一个具有大语料库的大规模项目,我们需要设计一个 Python 生成器,主要通过消耗文件系统的文件而不是内存存储来产生字符串行。您还应该在上面的 BERT 训练部分检查tokenizer.train(),以便从文件系统存储中进行训练。 -
让我们随机选取一句来自 Macbeth 剧本的句子,将其命名为
sen,并使用我们的新分词器对其进行分词:>>> sen= "Is this a dagger which I see before me,\ the handle toward my hand?" >>> sen_enc=tokenizer.encode(sen) >>> print(f"Output: {format(sen_enc.tokens)}") Output: ['[CLS]', 'is', 'this', 'a', 'dagger', 'which', 'i', 'see', 'before', 'me', ',', 'the', 'hand', 'le', 'toward', 'my', 'hand', '?', '[SEP]'] -
多亏了上面的后处理器函数,我们在正确的位置看到了额外的[CLS]和[SEP]标记。由于我们传递给模型的是 Macbeth 剧本中的一句话,模型已经知道这个句子,所以只有一个分割单词handle(hand,le)。此外,我们使用了一个小语料库,分词器没有强制使用压缩。让我们传递一个有挑战性的短语
Hugging Face,分词器可能不认识:>>> sen_enc2=tokenizer.encode("Macbeth and Hugging Face") >>> print(f"Output: {format(sen_enc2.tokens)}") Output: ['[CLS]', 'macbeth', 'and', 'hu', 'gg', 'ing', 'face', '[SEP]'] -
术语
Hugging被转换为小写,并拆分为三段hu,gg,ing,因为模型的词汇表包含了除Hugging之外的所有其他标记。现在让我们传递两个句子:>>> two_enc=tokenizer.encode("I like Hugging Face!", "He likes Macbeth!") >>> print(f"Output: {format(two_enc.tokens)}") Output: ['[CLS]', 'i', 'like', 'hu', 'gg', 'ing', 'face', '!', '[SEP]', 'he', 'li', 'kes', 'macbeth', '!', '[SEP]']请注意,后处理器将
[SEP]标记作为指示器插入。 -
是时候保存模型了。我们可以保存子词分词模型,也可以保存整个分词流程。首先,让我们仅保存 BPE 模型:
>>> tokenizer.model.save('.') ['./vocab.json', './merges.txt'] -
有关词汇和合并规则,模型保存了两个文件。
merge.txt文件由 4948 个合并规则组成:$ wc -l ./merges.txt 4948 ./merges.txt -
前五条规则按如下所示排名,我们会发现 (
t,h) 是由于成为最常见的一对而排名第一。对于测试,模型会扫描文本输入,如果适用,会首先尝试合并这两个符号:$ head -3 ./merges.txt t h o u a n th e r eBPE 算法根据频率对规则进行排序。当您在莎士比亚语料库中手动计算字符二元组时,您会发现 (
t,h) 是最常见的一对。 -
现在让我们保存和加载整个分词流程:
>>> tokenizer.save("MyBPETokenizer.json") >>> tokenizerFromFile = \ Tokenizer.from_file("MyBPETokenizer.json") >>> sen_enc3 = \ tokenizerFromFile.encode("I like Hugging Face and Macbeth") >>> print(f"Output: {format(sen_enc3.tokens)}") Output: ['[CLS]', 'i', 'like', 'hu', 'gg', 'ing', 'face', 'and', 'macbeth', '[SEP]']
我们成功重新加载了分词器!
训练 WordPiece 模型
在本节中,我们将训练 WordPiece 模型:
-
我们首先导入必要的模块:
from tokenizers.models import WordPiece from tokenizers.decoders import WordPiece \ as WordPieceDecoder from tokenizers.normalizers import BertNormalizer -
以下代码示例创建一个空的 WordPiece 分词器,并准备好进行训练。
BertNormalizer是一个预定义的规范化序列,包括文本清理、变换重音、处理中文字符和小写化的过程:tokenizer = Tokenizer(WordPiece()) tokenizer.normalizer=BertNormalizer() tokenizer.pre_tokenizer = Whitespace() tokenizer.decoder= WordPieceDecoder() -
现在,我们创建一个适当的训练器,
WordPieceTrainer()用于WordPiece(),以组织训练过程:>>> from tokenizers.trainers import WordPieceTrainer >>> trainer = WordPieceTrainer(vocab_size=5000,\ special_tokens=["[UNK]", "[CLS]", "[SEP]",\ "[PAD]", "[MASK]"]) >>> tokenizer.train_from_iterator(shakespeare, trainer=trainer) >>> output = tokenizer.encode(sen) >>> print(output.tokens) ['is', 'this', 'a', 'dagger', 'which', 'i', 'see', 'before', 'me', ',', 'the', 'hand', '##le', 'toward', 'my', 'hand', '?'] -
让我们使用
WordPieceDecoder()正确处理句子:>>> tokenizer.decode(output.ids) 'is this a dagger which i see before me, the handle toward my hand?' -
我们在输出中没有遇到任何
[UNK]标记,因为分词器以某种方式知道或分割输入进行编码。让我们强制模型生成[UNK]标记,就像下面的代码中所示。让我们向分词器传递一句土耳其语的句子:>>> tokenizer.encode("Kralsın aslansın Macbeth!").tokens '[UNK]', '[UNK]', 'macbeth', '!']做得好!我们有一些未知标记,因为分词器无法从合并规则和基础词汇中找到给定单词的拆分方式。
到目前为止,我们已经设计好了从规范化组件到解码器组件的分词流程。另一方面,tokenizers库为我们提供了一个已经准备好的(未经训练的)空的分词流程,其中包括适当的组件,用于快速创建生产原型。以下是一些预先制作的分词器:
-
CharBPETokenizer:原始的 BPE -
ByteLevelBPETokenizer:BPE 的字节级版本 -
SentencePieceBPETokenizer:与SentencePiece使用的 BPE 兼容的 BPE 实现 -
BertWordPieceTokenizer:著名的 BERT 分词器,使用 WordPiece
以下代码导入了这些分词流程:
>>> from tokenizers import (ByteLevelBPETokenizer,
CharBPETokenizer,
SentencePieceBPETokenizer,
BertWordPieceTokenizer)
所有这些分词流程都已经为我们设计好。其余的流程(如训练、保存模型和使用分词器)与之前的 BPE 和 WordPiece 训练过程相同。
做得好!我们取得了巨大的进展,并且已经训练了我们的第一个 Transformer 模型以及其分词器。
摘要
在本章中,我们从理论和实践两方面体验了自动编码模型。从对 BERT 的基本知识开始,我们从零开始训练了它以及相应的分词器。我们还讨论了如何在其他框架内工作,例如 Keras。除了 BERT,我们还回顾了其他自动编码模型。为了避免过多的代码重复,我们没有提供训练其他模型的完整实现。在 BERT 训练期间,我们训练了 WordPiece 分词算法。在最后一部分,我们检查了其他分词算法,因为讨论和理解它们都是值得的。
自动编码模型使用原始 Transformer 的左解码器侧,主要用于分类问题的微调。在下一章中,我们将讨论并学习 Transformer 的右解码器部分,以实现语言生成模型。
第四章:自回归模型与其他语言模型
我们研究了text2text 应用的细节,例如总结,释义和机器翻译。
本章将涵盖以下主题:
-
使用 AR 模型工作
-
使用序列到序列(Seq2Seq)模型工作
-
AR 语言模型训练
-
使用 AR 模型进行自然语言生成
-
使用
simpletransformers进行总结和机器翻译微调
技术要求
为成功完成本章,需要以下库/软件包:
-
Anaconda
-
transformers 4.0.0 -
pytorch 1.0.2 -
tensorflow 2.4.0 -
datasets 1.4.1 -
tokenizers -
simpletransformers 0.61
所有具有编码练习的笔记本将在以下 GitHub 链接上提供:github.com/PacktPublishing/Mastering-Transformers/tree/main/CH04。
点击以下链接查看代码运行的实例:bit.ly/3yjn55X
使用 AR 模型工作
Transformers架构最初旨在对诸如机器翻译或总结之类的 Seq2Seq 任务有效,但随后它已被用于各种 NLP 问题,从标记分类到指代消解。随后的作品开始分别并更有创意地使用架构的左部分和右部分。在预训练阶段使用的目标,也被称为[MASK]符号,在微调阶段的数据中不存在,导致预训练和微调之间存在不一致。其次,BERT 模型可以说假定遮盖的标记是彼此独立的。
另一方面,AR 模型避免了关于独立性的假设,并且不会受到预训练和微调不一致引起的困扰,因为它们依赖于对先前标记的下一个标记的预测而不对其进行遮盖。它们仅利用具有遮盖自我注意力的解码器部分的Transformers。它们阻止模型向当前词的右侧(或向当前词的左侧)的字词进行前向方向(或后向方向)的访问,这称为单向性。它们也称为因果语言模型(CLMs),因为它们是单向的。
AE 和 AR 模型之间的区别在这里简单地描述了:

图 4.1 - AE 与 AR 语言模型
GPT 及其两个后继者(GPT-2,GPT-3),Transformer-XL和XLNet是文献中流行的 AR 模型之一。尽管 XLNet 基于自回归,但它以某种方式成功地以双向方式利用了单词的上下文,借助基于排列的语言目标。现在,我们开始介绍它们,并展示如何训练这些模型以进行各种实验。让我们先看一下 GPT。
介绍以及使用 GPT 训练模型
AR 模型由多个 transformer 块组成。每个块包含一个掩码多头自注意力层和一个逐点前馈层。最后一个 transformer 块中的激活被馈入 softmax 函数,产生整个词汇表上的单词概率分布,以预测下一个单词。
在原始的 GPT 论文《通过生成预训练来改善语言理解》(2018)中,作者们解决了传统的基于机器学习(ML)的自然语言处理(NLP)流水线面临的几个瓶颈。例如,这些流水线首先需要大量的任务特定数据和任务特定的架构。其次,很难应用具有最小架构更改的任务感知输入转换到预训练模型中。由 OpenAI 团队设计的原始 GPT 及其后继者(GPT-2 和 GPT-3)专注于缓解这些瓶颈。原始 GPT 研究的主要贡献是,预训练模型不仅为单一任务取得了令人满意的结果,而且为各种任务取得了令人满意的结果。通过从未标记的数据中学习生成模型,这称为无监督预训练,该模型只需通过相对少量的任务特定数据进行监督微调,这称为监督微调。这种两阶段方案在其他 transformer 模型中被广泛使用,其中无监督预训练后跟着监督微调。
为了尽可能使 GPT 架构尽可能通用,只有输入被以任务特定的方式转换,而整个架构保持几乎不变。这种遍历式方法将文本输入转换为根据任务的有序序列,以便预训练模型能够从中理解任务。图 4.2 的左侧(启发自原始论文)说明了原始 GPT 工作中使用的 transformer 架构和训练目标。右侧显示了如何为几个任务进行微调时转换输入。
简单来说,对于单序列任务,如文本分类,输入原样通过网络,并且线性层采用最后的激活来做出决策。对于句对任务,如文本蕴涵,由两个序列组成的输入用分隔符标记,如 图 4.2 中的第二个示例所示。在这两种情况下,架构看到统一的令牌序列被预训练模型处理。在文本蕴涵的情况下,这种转换中使用的分隔符帮助预训练模型知道哪一部分是前提或假设。多亏了输入转换,我们不必在任务之间对架构进行重大更改。
你可以在这里看到输入转换的表示:

图 4.2 - 输入转换(灵感来自论文)
GPT 及其两个后继模型主要关注寻找特定的架构设计,其中不需要进行微调阶段。基于这个想法,一个模型可以非常熟练,也就是说,它在预训练阶段可以学习到关于语言的大部分信息,微调阶段所需的工作很少。因此,大多数任务的微调过程可以在三个时期内完成,并且对于大部分任务,相对较小的示例即可。极端情况下,零样本学习旨在禁用微调阶段。其基本思想是,模型可以在预训练阶段学习到关于语言的大量信息。对于所有基于 Transformer 的模型来说尤其如此。
原始 GPT 的后继模型
GPT-2(参见论文语言模型是无监督多任务学习者(2019))是原始 GPT-1 的后继者,它是在比原始模型更多的训练数据 WebText 上训练的一个更大的模型。它在没有进行微调的零样本设置中,在八个任务中的七个任务上取得了最新的结果,但在一些任务中成功有限。在测量长程依赖性的较小数据集上取得了可比较的结果。GPT-2 的作者认为语言模型不一定需要明确的监督来学习一个任务。相反,当它们在一个巨大而多样的网页数据集上进行训练时,它们可以学习这些任务。GPT-2 被认为是一个通用系统,用P(output|input, task-i)替换了原始 GPT 中的学习目标P(output|input),其中模型在相同输入情况下,根据特定任务来生成不同的输出,也就是说,GPT-2 通过训练相同的无监督模型学习了多个任务。一个单独的预训练模型通过学习目标便能学习到不同的能力。我们在其他研究中也看到了类似的多任务和元任务设置。这种转变到多任务学习(MTL)使得可以对同一个输入进行多种不同的任务。但是这些模型是如何确定执行哪个任务呢?他们通过零样本任务转移来实现。
与原始 GPT 相比,GPT-2 没有具体任务的微调,并且能够在零样本任务转移的设置中工作,在这个设置中,所有下游任务都是预测条件概率的一部分。任务在输入中以某种方式组织,模型应该理解下游任务的性质,并相应地提供答案。例如,对于英文到土耳其语的 MT 任务,它不仅取决于输入,还取决于任务。输入被排列成英文句子后跟随土耳其句子,有一个分隔符,模型可以从中了解到任务是英文到土耳其语的翻译。
OpenAI 团队使用了 1750 亿个参数训练了 GPT-3 模型(参见论文语言模型是几次学习者(2020)),比 GPT-2 大 100 倍。GPT-2 和 GPT-3 的架构类似,主要区别通常在于模型大小和数据集数量/质量。由于数据集中的大量数据和所训练的大量参数,它在零次学习、一次学习和少次学习(K=32)设置下在许多下游任务上取得了更好的结果,而无需进行任何基于梯度的微调。团队表明,对于许多任务,包括翻译、问答(QA)和掩码标记任务,随着参数大小和示例数量的增加,模型性能也提高了。
Transformer-XL
由于在最初的设计和上下文分段中缺乏循环,Transformers模型受固定长度上下文的困扰,尽管它们能够学习长期依赖关系。大多数Transformers将文档分成一系列固定长度(主要为 512)的段,其中跨段的任何信息流均不可能。因此,语言模型无法捕捉超出这个固定长度限制之外的长期依赖性。此外,分段过程不考虑句子边界。一个段可能荒谬地由一个句子的后半部分和它的后继者的前半部分组成,因此在预测下一个标记时,语言模型可能会缺少必要的上下文信息。这一问题被研究称为上下文分段问题。
为了解决和克服这些问题,Transformers-XL 作者(参见论文Transformers-XL:超越固定长度上下文的专注语言模型(2019))提出了一种新的Transformers架构,包括一个段级别的循环机制和一种新的位置编码方案。这种方法启发了许多后续模型。它不仅限于两个连续的段,因为有效的上下文可以延伸到两个段之外。循环机制在每两个连续段之间起作用,导致对若干段的跨度到一定程度。模型可以处理的最大可能依赖长度受层数和段长度的限制。
XLNet
屏蔽语言建模(MLM)主导了基于Transformers的体系结构的预训练阶段。然而,它在过去面临过批评,因为在预训练阶段存在屏蔽标记,但在微调阶段不存在,这导致了预训练和微调之间的差异。由于这种缺失,模型可能无法利用在预训练阶段学到的所有信息。 XLNet(参见论文XLNet: Generalized Autoregressive Pretraining for Language Understanding(2019))用置换语言建模(PLM)取代了 MLM,这是输入标记的随机排列,以克服这一瓶颈。排列语言建模使每个标记位置利用来自所有位置的上下文信息,从而捕捉到双向上下文。客观函数只是对因子化顺序进行排列,并定义标记预测的顺序,但不改变序列的自然位置。简而言之,模型在置换后选择一些标记作为目标,然后在其余标记和目标的自然位置的条件下进一步尝试预测它们。这使得可以双向使用 AR 模型。
XLNet 利用了 AE 和 AR 模型的优势。它确实是一个广义的 AR 模型,然而,由于基于排列的语言建模,它可以关注来自左右上下文的标记。除了其客观函数,XLNet 由两个重要机制组成:它将 Transformer-XL 的段级循环机制集成到其框架中,并包括了针对目标感知表示的两流注意力机制的慎重设计。
让我们在接下来的部分讨论这些模型,使用Transformers的两部分。
与 Seq2Seq 模型一起工作
Transformers的左编码器和右解码器部分通过交叉注意力相连,这有助于每个解码器层关注最终编码器层。这自然地促使模型产生与原始输入紧密相关的输出。原始Transformers——Seq2Seq 模型通过以下方案实现了这一点:
输入标记-> 嵌入-> 编码器-> 解码器-> 输出标记
Seq2Seq 模型保留了Transformers的编码器和解码器部分。T5,双向和自回归Transformers(BART)和用于抽象摘要序列到序列模型的提取间隙句子进行预训练(PEGASUS)是流行的 Seq2Seq 模型之一。
T5
大多数 NLP 架构,从 Word2Vec 到Transformers,通过预测使用上下文(相邻)词语的掩码词来学习嵌入和其他参数。我们将 NLP 问题视为词预测问题。一些研究将几乎所有 NLP 问题都视为问答或令牌分类。同样,T5(参见 2019 年的论文探索统一文本到文本Transformers的迁移学习极限)提出了一个统一框架,通过将它们转换为文本到文本问题来解决许多任务。T5 的潜在理念是将所有 NLP 任务都转换为文本到文本(Seq2Seq)问题,其中输入和输出都是标记列表,因为已发现文本到文本框架有益于将相同模型应用于从问答到文本摘要等不同的 NLP 任务中。
下图,受原始论文启发,展示了 T5 如何在一个统一框架内解决四种不同的 NLP 问题—MT,语言可接受性,语义相似性和摘要:

图 4.3 – T5 框架图
T5 模型大致遵循原始编码器-解码器Transformers模型。修改是在层归一化和位置嵌入方案中进行的。T5 使用相对位置嵌入,而不是使用正弦位置嵌入或学习嵌入,这在Transformers架构中变得越来越普遍。T5 是一个单一模型,可以处理各种任务,例如语言生成。更重要的是,它将任务转换为文本格式。该模型接受由任务前缀和附加的输入组成的文本。我们将标记的文本数据集转换为{'inputs': '....', 'targets': ...'}格式,其中我们将目的作为前缀插入输入。然后,我们用标记数据训练模型,使其学会做什么以及如何做。如前图所示,在英语-德语翻译任务中,输入"translate English to German: That is good."会产生"das is gut."。同样,任何带有"summarize:"前缀的输入都将由该模型汇总。
介绍 BART
与 XLNet 一样,BART 模型(参见 2019 年的论文BART:用于自然语言生成、翻译和理解的去噪序列到序列预训练)利用了 AE 和 AR 模型的方案。它使用标准 Seq2Seq Transformers架构,稍作修改。BART 是一个使用各种破坏性方法来破坏文档的预训练模型。该研究对该领域的主要贡献在于它允许我们应用多种类型的创造性破坏方案,如下图所示:

图 4.4 – 受原始 BART 论文启发的图
我们将详细查看每个方案,如下所示:
-
[MASK]符号,与 BERT 模型相同。 -
标记删除:从文档中随机删除标记。模型被迫确定哪些位置被删除。
-
[MASK]标记。还有[MASK]标记插入。 -
句子重排:输入中的句子被分割并随机打乱顺序。
-
文档旋转:文档被旋转,以便以随机选择的标记(在前面的图表中为
C)开头。目标是找到文档的起始位置。
BART 模型可以通过多种方式进行微调,用于下游应用,如 BERT。对于序列分类任务,输入经过编码器和解码器,并将解码器的最终隐藏状态视为学习到的表示。然后,简单的线性分类器可以进行预测。同样,对于标记分类任务,整个文档被馈送到编码器和解码器中,并且最终解码器的最后状态是每个标记的表示。基于这些表示,我们可以解决标记分类问题,我们将在第六章中讨论,用于标记分类的微调语言模型。 命名实体识别(NER)和 词性标注(POS)任务可以使用这个最终表示来解决,其中 NER 识别文本中的人物和组织等实体,而 POS 将每个标记与它们的词汇类别联系起来,比如名词、形容词等。
对于序列生成,BART 模型的解码器块,即 AR 解码器,可以直接微调用于生成序列的任务,例如抽象 QA 或摘要。BART 的作者(Lewis,Mike 等)使用了两个标准摘要数据集:CNN/DailyMail 和 XSum 来训练模型。作者还表明,可以使用编码器部分——消耗源语言——和解码器部分——生成目标语言中的词语——作为单个预训练解码器用于 MT。他们用一个新的随机初始化的编码器替换了编码器嵌入层,以学习源语言中的词语。然后,模型以端到端的方式进行训练,该方式训练新编码器将外语单词映射到 BART 可以去噪到目标语言的输入。新编码器可以使用单独的词汇表,包括原始 BART 模型中的外语。
在 HuggingFace 平台上,我们可以通过以下代码行访问原始预训练的 BART 模型:
AutoModel.from_pretrained('facebook/bart-large')
当我们调用transformers库中的标准summarization流水线时,如下代码行所示,将加载一个经过精简预训练的 BART 模型。此调用隐式加载了"sshleifer/distilbart-cnn-12-6"模型及其相应的分词器,如下所示:
summarizer = pipeline("summarization")
以下代码明确加载相同的模型和相应的分词器。代码示例接受要进行总结的文本并输出结果:
from transformers import BartTokenizer, BartForConditionalGeneration, BartConfig
from transformers import pipeline
model = \
BartForConditionalGeneration.from_pretrained('sshleifer/distilbart-cnn-12-6')
tokenizer = BartTokenizer.from_pretrained('sshleifer/distilbart-cnn-12-6')
nlp=pipeline("summarization", model=model, tokenizer=tokenizer)
text='''
We order two different types of jewelry from this
company the other jewelry we order is perfect.
However with this jewelry I have a few things I
don't like. The little Stone comes out of these
and customers are complaining and bringing them
back and we are having to put new jewelry in their
holes. You cannot sterilize these in an autoclave
as well because it heats up too much and the glue
does not hold up so the second group of these that
we used I did not sterilize them that way and the
stones still came out. When I use a dermal clamp
to put the top on the stones come out immediately.
DO not waste your money on this particular product
buy the three mm. that has the claws that hold the
jewelry in those are perfect. So now I'm stuck
with jewelry that I can't sell not good for
business.'''
q=nlp(text)
import pprint
pp = pprint.PrettyPrinter(indent=0, width=100)
pp.pprint(q[0]['summary_text'])
(' The little Stone comes out of these little stones and customers are complaining and bringing ' 'them back and we are having to put new jewelry in their holes . You cannot sterilize these in an ' 'autoclave because it heats up too much and the glue does not hold up so the second group of ' 'these that we used I did not sterilize them that way and the stones still came out .')
在下一节中,我们将动手学习如何训练这样的模型。
AR 语言模型训练
在本节中,您将了解如何训练自己的 AR 语言模型。我们将从 GPT-2 开始,并深入了解其用于训练的不同功能,使用transformers库。
您可以找到任何特定的语料库来训练您自己的 GPT-2,但是在本示例中,我们使用了简·奥斯汀的《爱玛》,这是一部浪漫小说。强烈建议在更大的语料库上进行训练,以获得更一般的语言生成。
在我们开始之前,值得注意的是,我们使用了 TensorFlow 的本地训练功能来展示所有 Hugging Face 模型都可以直接在 TensorFlow 或 PyTorch 上进行训练,如果您愿意的话。请按照以下步骤:
-
您可以使用以下命令下载Emma小说的原始文本:
wget https://raw.githubusercontent.com/teropa/nlp/master/resources/corpora/gutenberg/austen-emma.txt -
第一步是在你打算训练 GPT-2 的语料库上训练
BytePairEncoding分词器。以下代码将从tokenizers库导入BPE分词器:from tokenizers.models import BPE from tokenizers import Tokenizer from tokenizers.decoders import ByteLevel as ByteLevelDecoder from tokenizers.normalizers import Sequence, Lowercase from tokenizers.pre_tokenizers import ByteLevel from tokenizers.trainers import BpeTrainer -
如您所见,在此示例中,我们打算通过添加更多功能(如
Lowercase规范化)来训练更高级的分词器。要创建一个tokenizer对象,可以使用以下代码:tokenizer = Tokenizer(BPE()) tokenizer.normalizer = Sequence([ Lowercase() ]) tokenizer.pre_tokenizer = ByteLevel() tokenizer.decoder = ByteLevelDecoder()第一行从
BPE分词器类创建一个分词器。对于规范化部分,已添加Lowercase,并将pre_tokenizer属性设置为ByteLevel以确保我们的输入为字节。decoder属性也必须设置为ByteLevelDecoder以能够正确解码。 -
接下来,将使用
50000的最大词汇量和来自ByteLevel的初始字母训练分词器,如下所示:trainer = BpeTrainer(vocab_size=50000, inital_alphabet=ByteLevel.alphabet(), special_tokens=[ "<s>", "<pad>", "</s>", "<unk>", "<mask>" ]) tokenizer.train(["austen-emma.txt"], trainer) -
还需要添加特殊的标记以进行考虑。为了保存分词器,需要创建一个目录,如下所示:
!mkdir tokenizer_gpt -
您可以通过运行以下命令保存分词器:
tokenizer.save("tokenizer_gpt/tokenizer.json") -
现在分词器已保存,是时候预处理语料库并使其准备好进行 GPT-2 训练了,但首先,重要的导入不能被遗忘。执行导入的代码如下所示:
from transformers import GPT2TokenizerFast, GPT2Config, TFGPT2LMHeadModel -
分词器可以通过使用
GPT2TokenizerFast加载,如下所示:tokenizer_gpt = GPT2TokenizerFast.from_pretrained("tokenizer_gpt") -
还必须添加特殊标记及其标记,如下所示:
tokenizer_gpt.add_special_tokens({ "eos_token": "</s>", "bos_token": "<s>", "unk_token": "<unk>", "pad_token": "<pad>", "mask_token": "<mask>" }) -
您还可以通过运行以下代码来双重检查是否一切都正确:
tokenizer_gpt.eos_token_id >> 2此代码将输出当前分词器的
2。 -
您也可以通过执行以下代码对一个句子进行测试:
tokenizer_gpt.encode("<s> this is </s>") >> [0, 265, 157, 56, 2]对于此输出,
0是句子的开头,265、157和56与句子本身相关,EOS 被标记为2,即</s>。 -
创建配置对象时必须使用这些设置。以下代码将创建一个
config对象和 GPT-2 模型的 TensorFlow 版本:config = GPT2Config( vocab_size=tokenizer_gpt.vocab_size, bos_token_id=tokenizer_gpt.bos_token_id, eos_token_id=tokenizer_gpt.eos_token_id ) model = TFGPT2LMHeadModel(config) -
在运行
config对象时,您可以看到配置以字典格式显示,如下所示:config >> GPT2Config { "activation_function": "gelu_new", "attn_pdrop": 0.1, "bos_token_id": 0, "embd_pdrop": 0.1, "eos_token_id": 2, "gradient_checkpointing": false, "initializer_range": 0.02, "layer_norm_epsilon": 1e-05, "model_type": "gpt2", "n_ctx": 1024, "n_embd": 768, "n_head": 12, "n_inner": null, "n_layer": 12, "n_positions": 1024, "resid_pdrop": 0.1, "summary_activation": null, "summary_first_dropout": 0.1, "summary_proj_to_labels": true, "summary_type": "cls_index", "summary_use_proj": true, "transformers_version": "4.3.2", "use_cache": true, "vocab_size": 11750}如您所见,其他设置未被触及,有趣的部分是
vocab_size被设置为11750。背后的原因是我们将最大词汇量设置为50000,但语料库较少,只有11750。 -
现在,您可以准备好为预训练做好语料库的准备,如下所示:
with open("austen-emma.txt", "r", encoding='utf-8') as f: content = f.readlines() -
现在,内容将包括原始文件中的所有原始文本,但需要删除每一行的
'\n'并删除少于10个字符的行,如下所示:content_p = [] for c in content: if len(c)>10: content_p.append(c.strip()) content_p = " ".join(content_p)+tokenizer_gpt.eos_token -
删除短行将确保模型在长序列上进行训练,以生成更长的序列。在前述代码段的末尾,
content_p具有经连接的原始文件,并在末尾添加了eos_token。但您也可以采取不同的策略—例如,您可以通过在每一行后添加</s>来将每一行分开,这将帮助模型识别句子何时结束。但我们的目的是使其能够更长的序列而无需遇到 EOS。代码见如下片段:tokenized_content = tokenizer_gpt.encode(content_p)前述代码片段中的 GPT 标记生成器将对整个文本进行标记化,使其成为一个整体的长令牌 ID 序列。
-
现在,是时候为训练制作样本了,如下所示:
sample_len = 100 examples = [] for i in range(0, len(tokenized_content)): examples.append(tokenized_content[i:i + sample_len]) -
前述代码使
examples从给定文本的特定部分开始,每个大小为100,并在100个令牌后结束:train_data = [] labels = [] for example in examples: train_data.append(example[:-1]) labels.append(example[1:])在
train_data中,将会有一系列从头到第 99 个令牌的大小为99的序列,标签将具有从1到100的令牌序列。 -
为了加快训练速度,需要将数据制作成 TensorFlow 数据集的形式,如下所示:
Import tensorflow as tf buffer = 500 batch_size = 16 dataset = tf.data.Dataset.from_tensor_slices((train_data, labels)) dataset = dataset.shuffle(buffer).batch(batch_size, drop_remainder=True)buffer是用于对数据进行洗牌的缓冲区大小,batch_size是训练的批量大小。drop_remainder用于丢弃余数,如果余数小于16,则丢弃。 -
现在,您可以指定您的
optimizer,loss和metrics属性,如下所示:optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5, epsilon=1e-08, clipnorm=1.0) loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy') model.compile(optimizer=optimizer, loss=[loss, *[None] * model.config.n_layer], metrics=[metric]) -
你希望,该模型已经编译并准备好进行训练的周期数量,如下所示:
epochs = 10 model.fit(dataset, epochs=epochs)您将看到类似于这样的输出:

图 4.5 – 使用 TensorFlow/Keras 进行 GPT-2 训练
现在,我们将看看如何使用 AR 模型进行 NLG。现在你已经保存了模型,它将用于在下一节中生成句子。
到目前为止,你已经学会了如何训练自己的 NLG 模型。在下一节中,我们描述如何利用 NLG 模型进行语言生成。
使用 AR 模型进行 NLG
在上一节中,你已经学会了如何在自己的语料库上训练 AR 模型。结果,你已经训练了自己的 GPT-2 版本。但对于问题“我该如何使用它?”的缺失答案仍然存在。为了回答这个问题,让我们继续如下进行:
-
让我们从您刚刚训练的模型开始生成句子,如下所示:
def generate(start, model): input_token_ids = tokenizer_gpt.encode(start, return_tensors='tf') output = model.generate( input_token_ids, max_length = 500, num_beams = 5, temperature = 0.7, no_repeat_ngram_size=2, num_return_sequences=1 ) return tokenizer_gpt.decode(output[0])在前面代码片段中定义的
generate函数接受一个start字符串,并生成遵循该字符串的序列。您可以更改参数,例如将max_length设置为较小的序列大小或将num_return_sequences设置为不同的生成。 -
让我们尝试一个空字符串,如下所示:
generate(" ", model)我们得到以下输出:
![图 4.6 – GPT-2 文本生成示例]()
图 4.6 – GPT-2 文本生成示例
正如您从之前的输出中所看到的那样,即使文本的语义不太动人,但在许多情况下,语法几乎是正确的。
-
现在,让我们尝试不同的开始,将
max_length设置为较低值,比如30,如下所示:generate("wetson was very good") >> 'wetson was very good; but it, that he was a great must be a mile from them, and a miss taylor in the house;'正如您回忆
西斯顿是小说中的一个角色。 -
要保存模型,您可以使用以下代码使其可重复使用以发布或在不同应用程序中使用:
model.save_pretrained("my_gpt-2/") -
为确保您的模型正确保存,您可以尝试加载它,如下所示:
model_reloaded = TFGPT2LMHeadModel.from_pretrained("my_gpt-2/")两个文件被保存——一个
config文件和一个model.h5文件,用于 TensorFlow 版本。我们可以在以下截图中看到这两个文件:![图 4.7 – 语言模型 save_pretrained 输出]()
图 4.7 – 语言模型 save_pretrained 输出
-
Hugging Face 还有一个必须使用的标准文件名标准——这些标准文件名可通过以下导入获得:
from transformers import WEIGHTS_NAME, CONFIG_NAME, TF2_WEIGHTS_NAME但是,在使用
save_pretrained函数时,不需要放置文件名,只需目录即可。 -
Hugging Face 还有
AutoModel和AutoTokenizer类,正如您从之前的章节中所见。您也可以使用这个功能来保存模型,但在这之前仍然需要手动完成一些配置。第一件事就是将分词器以适当的格式保存以供AutoTokenizer使用。您可以通过使用save_pretrained来实现这一点,如下所示:tokenizer_gpt.save_pretrained("tokenizer_gpt_auto/")这是输出:
![图 4.8 – Tokenizer save_pretrained 输出]()
图 4.8 – Tokenizer save_pretrained 输出
-
在您指定的目录中显示了文件列表,但
tokenizer_config必须手动更改以便可用。首先,您应该将其重命名为config.json,其次,您应该在model_type属性中添加一个属性为gpt2,如下所示:{"model_type":"gpt2", ... } -
现在,一切准备就绪,您可以简单地使用这两行代码加载
model和tokenizer:model = AutoModel.from_pretrained("my_gpt-2/", from_tf=True) tokenizer = AutoTokenizer.from_pretrained("tokenizer_gpt_auto")然而,不要忘记将
from_tf设置为True,因为您的模型是以 TensorFlow 格式保存的。
到目前为止,您已经学会了如何使用tensorflow和transformers预训练和保存自己的文本生成模型。您还学会了如何保存一个预训练模型并准备将其用作自动模型。在接下来的部分,您将学习如何使用其他模型的基础知识。
使用 simpletransformers 进行摘要和 MT 微调
到目前为止,你已经学会了从头开始训练语言模型的基础知识和高级方法,但是从头开始训练自己的语言模型并不总是可行的,因为有时会存在低计算能力等障碍。在本节中,你将学习如何针对特定的 MT 和摘要任务对自己的数据集进行语言模型的微调。请按照以下步骤进行操作:
-
要开始,你需要安装
simpletransformers库,如下所示:pip install simpletransformers -
下一步是下载包含你的平行语料库的数据集。这个平行语料库可以是任何类型的 Seq2Seq 任务。对于本例,我们将使用 MT 示例,但你可以使用任何其他数据集来完成其他任务,比如释义、摘要,甚至将文本转换为 SQL。
你可以从
www.kaggle.com/seymasa/turkish-to-english-translation-dataset/version/1下载数据集。 -
下载并解压数据后,需要为列标题添加
EN和TR,以便更容易使用。你可以使用pandas加载数据集,如下所示:import pandas as pd df = pd.read_csv("TR2EN.txt",sep="\t").astype(str) -
必须向数据集添加 T5 特定的命令,以使其了解正在处理的命令。你可以使用以下代码完成这项工作:
data = [] for item in digitrons(): data.append(["translate english to turkish", item[1].EN, item[1].TR]) -
然后,你可以重组 DataFrame,就像这样:
df = pd.DataFrame(data, columns=["prefix", "input_text", "target_text"])结果如下截图所示:
![图 4.9 – 英-土机器翻译平行语料库]()
图 4.9 – 英-土机器翻译平行语料库
-
接下来,运行以下代码导入所需的类:
from simpletransformers.t5 import T5Model, T5Args -
使用以下代码定义训练参数:
model_args = T5Args() model_args.max_seq_length = 96 model_args.train_batch_size = 20 model_args.eval_batch_size = 20 model_args.num_train_epochs = 1 model_args.evaluate_during_training = True model_args.evaluate_during_training_steps = 30000 model_args.use_multiprocessing = False model_args.fp16 = False model_args.save_steps = -1 model_args.save_eval_checkpoints = False model_args.no_cache = True model_args.reprocess_input_data = True model_args.overwrite_output_dir = True model_args.preprocess_inputs = False model_args.num_return_sequences = 1 model_args.wandb_project = "MT5 English-Turkish Translation" -
最后,你可以加载任何你想微调的模型。以下是我们选择的一个:
model = T5Model("mt5", "google/mt5-small", args=model_args, use_cuda=False)如果你的 CUDA 内存不足以容纳 mT5,不要忘记将
use_cuda设置为False。 -
使用以下代码可以拆分
train和evalDataFrames:train_df = df[: 470000] eval_df = df[470000:] -
最后一步是使用以下代码开始训练:
model.train_model(train_df, eval_data=eval_df)训练结果将如下所示:
![图 4.10 – mT5 模型评估结果]()
图 4.10 – mT5 模型评估结果
这表明了评估和训练损失。
-
你可以使用以下代码简单加载和使用模型:
model_args = T5Args() model_args.max_length = 512 model_args.length_penalty = 1 model_args.num_beams = 10 model = T5Model("mt5", "outputs", args=model_args, use_cuda=False)现在可以使用
model_predict函数进行从英语到土耳其语的翻译。
simpletransformers库使得从序列标记到 Seq2Seq 模型的训练变得非常简单和可用。
干得漂亮!我们已经学会了如何训练自己的 AR 模型,并且到达了本章的结束。
摘要
在本章中,我们学习了关于 AR 语言模型的各个方面,从预训练到微调。我们通过训练生成语言模型和在诸如 MT 等任务上进行微调来查看此类模型的最佳特征。我们了解了更复杂模型如 T5 的基础知识,并使用这种模型执行了 MT。我们还使用了simpletransformers库。我们在自己的语料库上训练了 GPT-2,并使用它生成了文本。我们学会了如何保存它,并使用AutoModel。我们还深入研究了如何训练和使用 BPE,使用tokenizers库。
在下一章中,我们将看到如何为文本分类微调模型。
参考文献
这里有一些参考资料,你可以用来扩展我们在本章学到的内容:
-
Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. 和 Sutskever, I.(2019)。语言模型是无监督多任务学习者。OpenAI 博客,1(8),
9。 -
Lewis, M., Liu, Y., Goyal, N., Ghazvininejad, M., Mohamed, A.,Levy, O. 和 Zettlemoyer, L.(2019)。BART: 用于自然语言生成、翻译和理解的去噪序列到序列预训练。arXiv 预印本 arXiv:1910.13461。
-
Xue, L., Constant, N., Roberts, A., Kale, M., Al-Rfou, R.,Siddhant, A. 和 Raffel, C.(2020)。mT5: 一个大规模多语言预训练文本到文本转换器。arXiv 预印本 arXiv:2010.11934。
-
Raffel, C.,Shazeer, N.,Roberts, A.,Lee, K.,Narang, S.,Matena, M. 和 Liu, P. J.(2019)。探索统一文本到文本转换器的迁移学习极限。arXiv 预印本 arXiv:1910.10683。
-
Yang, Z.,Dai, Z.,Yang, Y.,Carbonell, J.,Salakhutdinov, R. 和 Le, Q. V.(2019)。XLNet: 用于语言理解的广义自回归预训练。arXiv 预印本 arXiv:1906.08237。
-
Dai, Z., Yang, Z., Yang, Y., Carbonell, J.,Le, Q. V. 和 Salakhutdinov, R.(2019)。Transformer-xl: 超越固定长度上下文的关注语言模型。arXiv 预印本 arXiv:1901.02860。
第五章:文本分类的语言模型微调
在本章中,我们将学习如何配置预训练模型进行文本分类,并如何对其进行微调以适应任何文本分类的下游任务,例如情感分析或多类分类。我们还将讨论如何处理句对和回归问题,涵盖一个实现。我们将使用 GLUE 等知名数据集,以及我们自己的定制数据集。然后,我们将利用 Trainer 类,该类处理了训练和微调过程的复杂性。
首先,我们将学习如何使用 Trainer 类进行单句二元情感分类微调。然后,我们将使用原生 PyTorch 进行情感分类的训练,而不使用 Trainer 类。在多类分类中,将考虑超过两个类别。我们将有七个类别分类微调任务要执行。最后,我们将训练一个文本回归模型,以预测具有句子对的数值。
本章将涵盖以下主题:
-
文本分类简介
-
对单句二元分类微调 BERT 模型
-
使用原生 PyTorch 训练分类模型
-
使用自定义数据集对 BERT 进行多类分类微调
-
对句对回归进行 BERT 的微调
-
利用
run_glue.py对模型进行微调
技术要求
我们将使用 Jupyter Notebook 运行我们的编程练习。您需要 Python 3.6+。确保已安装以下软件包:
-
sklearn -
Transformers 4.0+
-
datasets
所有本章编程练习的笔记本将在以下 GitHub 链接上提供:github.com/PacktPublishing/Mastering-Transformers/tree/main/CH05。
查看以下链接以观看代码演示视频:
文本分类简介
文本分类(也称为文本分类)是将文档(句子、Twitter 帖子、书籍章节、电子邮件内容等)映射到预定义列表(类别)中的一种方式。在具有正负标签的两类情况下,我们称之为二元分类 - 更具体地说,是情感分析。对于多于两个类别的情况,我们称之为多类分类,其中类别是相互排斥的,或者称之为多标签分类,其中类别不是相互排斥的,这意味着一个文档可以获得多个标签。例如,一篇新闻文章的内容可能同时涉及体育和政治。除了这种分类之外,我们可能希望对文档进行范围为[-1,1]的评分或在[1-5]范围内对其进行排名。我们可以用回归模型解决这种问题,其中输出的类型是数值而不是分类。
幸运的是,变换器架构使我们能够高效地解决这些问题。对于句对任务,如文档相似性或文本蕴涵,输入不是单一句子,而是两个句子,如下图所示。我们可以评分两个句子在语义上相似的程度,或者预测它们是否在语义上相似。另一个句对任务是文本蕴涵,其中问题定义为多类分类。在 GLUE 基准测试中,两个序列被消耗:蕴含/矛盾/中性:

图 5.1 – 文本分类方案
让我们通过微调预训练的 BERT 模型开始我们的训练过程,针对一个常见问题:情感分析。
为单句二元分类微调 BERT 模型
在本节中,我们将讨论如何使用流行的IMDb 情感数据集,通过微调预训练的 BERT 模型进行情感分析。使用 GPU 可以加快我们的学习过程,但如果您没有这样的资源,您也可以通过 CPU 进行微调。让我们开始吧:
-
要了解并保存当前设备的信息,我们可以执行以下代码行:
from torch import cuda device = 'cuda' if cuda.is_available() else 'cpu' -
我们将在这里使用
DistilBertForSequenceClassification类,它是从DistilBert类继承而来,顶部有一个特殊的序列分类头。我们可以利用这个分类头来训练分类模型,其中默认类别数为2:from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification model_path= 'distilbert-base-uncased' tokenizer = DistilBertTokenizerFast.from_pre-trained(model_path) model = \ DistilBertForSequenceClassification.from_pre-trained(model_path, id2label={0:"NEG", 1:"POS"}, label2id={"NEG":0, "POS":1}) -
注意传递给模型的两个参数称为
id2label和label2id,用于推理。或者,我们可以实例化一个特定的config对象并将其传递给模型,如下所示:config = AutoConfig.from_pre-trained(....) SequenceClassification.from_pre-trained(.... config=config) -
现在,让我们选择一个名为
IMDB Dataset的流行情感分类数据集。原始数据集包含两组数据:25,000 个训练示例和 25 个测试示例。我们将数据集分成测试集和验证集。请注意,数据集的前一半示例为正面,而后一半的示例都为负面。我们可以按以下方式分布示例:from datasets import load_dataset imdb_train= load_dataset('imdb', split="train") imdb_test= load_dataset('imdb', split="test[:6250]+test[-6250:]") imdb_val= \ load_dataset('imdb', split="test[6250:12500]+test[-12500:-6250]") -
让我们检查数据集的形状:
>>> imdb_train.shape, imdb_test.shape, imdb_val.shape ((25000, 2), (12500, 2), (12500, 2)) -
您可以根据计算资源的情况从数据集中取出一小部分。对于较小的部分,您应该运行以下代码,选择 4,000 个示例进行训练,1,000 个进行测试,以及 1,000 个进行验证,如下所示:
imdb_train= load_dataset('imdb', split="train[:2000]+train[-2000:]") imdb_test= load_dataset('imdb', split="test[:500]+test[-500:]") imdb_val= load_dataset('imdb', split="test[500:1000]+test[-1000:-500]") -
现在,我们可以将这些数据集通过
tokenizer模型,使它们准备好进行训练:enc_train = imdb_train.map(lambda e: tokenizer( e['text'], padding=True, truncation=True), batched=True, batch_size=1000) enc_test = imdb_test.map(lambda e: tokenizer( e['text'], padding=True, truncation=True), batched=True, batch_size=1000) enc_val = imdb_val.map(lambda e: tokenizer( e['text'], padding=True, truncation=True), batched=True, batch_size=1000) -
让我们看看训练集的样子。注意力掩码和输入 ID 是由分词器添加到数据集中的,以便 BERT 模型进行处理:
import pandas as pd pd.DataFrame(enc_train)输出如下:
![]()
图 5.2 – 编码后的训练数据集
此时,数据集已准备好用于训练和测试。
Trainer类(TFTrainer用于 TensorFlow)和TrainingArguments类(TFTrainingArguments用于 TensorFlow)将帮助我们处理训练的许多复杂性。我们将在TrainingArguments类中定义我们的参数集,然后将其传递给Trainer对象。让我们定义每个训练参数的作用:
![]()
表 1 - 不同训练参数定义表
-
若要获取更多信息,请查看
TrainingArguments的 API 文档,或在 Python notebook 中执行以下代码:TrainingArguments? -
虽然像 LSTM 这样的深度学习架构需要许多 epoch,有时超过 50 个,但对于基于 transformer 的微调,由于迁移学习,我们通常会满足于 3 个 epoch 的数量。大部分时间,这个数量已经足够进行微调,因为预训练模型在预训练阶段已经学到了很多关于语言的知识,通常需要大约 50 个 epoch。要确定正确的 epoch 数量,我们需要监控训练和评估损失。我们将学习如何在第十一章中跟踪训练,注意力可视化和实验追踪。
-
对于许多下游任务问题,这将足够用。在训练过程中,我们的模型检查点将被保存在
./MyIMDBModel文件夹中,每 200 步保存一次:from transformers import TrainingArguments, Trainer training_args = TrainingArguments( output_dir='./MyIMDBModel', do_train=True, do_eval=True, num_train_epochs=3, per_device_train_batch_size=32, per_device_eval_batch_size=64, warmup_steps=100, weight_decay=0.01, logging_strategy='steps', logging_dir='./logs', logging_steps=200, evaluation_strategy= 'steps', fp16= cuda.is_available(), load_best_model_at_end=True ) -
在实例化
Trainer对象之前,我们将定义compute_metrics()方法,它可以帮助我们监控训练过程中特定指标的进展,如 Precision、RMSE、Pearson 相关性、BLEU 等。文本分类问题(如情感分类或多类分类)大多使用微平均或宏平均 F1 进行评估。而宏平均方法平等对待每个类别,微平均对每个文本或每个标记的分类决策平等对待。微平均等于模型正确决策的次数与总决策次数的比率。而宏平均方法计算每个类别的 Precision、Recall 和 F1 的平均分数。对于我们的分类问题,宏平均更方便进行评估,因为我们希望给每个标签平等的权重,如下所示:from sklearn.metrics import accuracy_score, Precision_Recall_fscore_support def compute_metrics(pred): labels = pred.label_ids preds = pred.predictions.argmax(-1) Precision, Recall, f1, _ = \ Precision_Recall_fscore_support(labels, preds, average='macro') acc = accuracy_score(labels, preds) return { 'Accuracy': acc, 'F1': f1, 'Precision': Precision, 'Recall': Recall } -
我们几乎已经准备好开始训练过程。现在,让我们实例化
Trainer对象并启动它。Trainer类是一个非常强大和优化的工具,用于组织 PyTorch 和 TensorFlow(TFTrainer用于 TensorFlow)的复杂训练和评估过程,这得益于transformers库:trainer = Trainer( model=model, args=training_args, train_dataset=enc_train, eval_dataset=enc_val, compute_metrics= compute_metrics ) -
最后,我们可以开始训练过程:
results=trainer.train()前面的调用开始记录指标,我们将在第十一章,注意力可视化和实验跟踪中更详细地讨论这些内容。整个 IMDb 数据集包括 25,000 个训练示例。使用批量大小为 32,我们有 25K/32 约等于 782 个步骤,并且对于 3 个时期还有 2,346 个步骤(782 x 3),如下所示的进度条显示:
![]()
图 5.3 – Trainer 对象生成的输出
-
Trainer对象保留了验证损失最小的检查点。它选择了步骤 1,400 处的检查点,因为该步骤的验证损失最小。让我们在三个(训练/测试/验证)数据集上评估最佳检查点:>>> q=[trainer.evaluate(eval_dataset=data) for data in [enc_train, enc_val, enc_test]] >>> pd.DataFrame(q, index=["train","val","test"]).iloc[:,:5]输出如下:
![]()
图 5.4 – 分类模型在训练/验证/测试数据集上的性能
-
干得好!我们成功完成了训练/测试阶段,并获得了 92.6 的准确度和 92.6 的宏平均 F1 值。为了更详细地监视您的训练过程,您可以调用高级工具,如 TensorBoard。这些工具会解析日志,并使我们能够跟踪各种指标以进行全面分析。我们已经在
./logs文件夹下记录了性能和其他指标。只需在我们的 Python 笔记本中运行tensorboard函数就足够了,如下面的代码块所示(我们将在第十一章中详细讨论 TensorBoard 和其他监控工具的可视化和实验跟踪):%reload_ext tensorboard %tensorboard --logdir logs -
现在,我们将使用模型进行推理以检查其是否正常工作。让我们定义一个预测函数来简化预测步骤,如下所示:
def get_prediction(text): inputs = tokenizer(text, padding=True,truncation=True, max_length=250, return_tensors="pt").to(device) outputs = \ model(inputs["input_ids"].to(device),inputs["attention_mask"].to(device)) probs = outputs[0].softmax(1) return probs, probs.argmax() -
现在,运行模型进行推理:
>>> text = "I didn't like the movie it bored me " >>> get_prediction(text)[1].item() 0 -
我们在这里得到的是
0,表示的是负面。我们已经定义了哪个 ID 表示哪个标签。我们可以使用这种映射方案来获取标签。或者,我们可以将所有这些乏味的步骤简单地传递给一个专用的 API,即 Pipeline,这是我们已经熟悉的。在实例化之前,让我们保存最佳模型以进行进一步的推理:model_save_path = "MyBestIMDBModel" trainer.save_model(model_save_path) tokenizer.save_pre-trained(model_save_path)Pipeline API 是使用预训练模型进行推理的简便方法。我们从保存模型的位置加载模型并将其传递给 Pipeline API,其余工作由其完成。我们可以跳过保存步骤,而是直接将
model和tokenizer对象在内存中传递给 Pipeline API。如果这样做,将获得相同的结果。 -
如下面的代码所示,当我们执行二元分类时,需要将 Pipeline 的任务名称参数指定为
sentiment-analysis:>>> from transformers import pipeline, \ DistilBertForSequenceClassification, DistilBertTokenizerFast >>> model = \ DistilBertForSequenceClassification.from_pre-trained("MyBestIMDBModel") >>> tokenizer= \ DistilBertTokenizerFast.from_pre-trained("MyBestIMDBModel") >>> nlp= pipeline("sentiment-analysis", model=model, tokenizer=tokenizer) >>> nlp("the movie was very impressive") Out: [{'label': 'POS', 'score': 0.9621992707252502}] >>> nlp("the text of the picture was very poor") Out: [{'label': 'NEG', 'score': 0.9938313961029053}]Pipeline 知道如何处理输入,并某种方式学会了哪个 ID 表示哪个(
POS或NEG)标签。它还产生类别概率。干得好!我们已经使用
Trainer类为 IMDb 数据集微调了情感预测模型。在接下来的部分中,我们将使用原生 PyTorch 进行相同的二元分类培训。我们还将使用其他数据集。
使用原生 PyTorch 训练分类模型
Trainer类非常强大,我们要感谢 HuggingFace 团队提供了这样一个有用的工具。然而,在本节中,我们将从头开始微调预训练模型,以了解其内部运行原理。让我们开始吧:
-
首先,让我们加载用于微调的模型。我们将在这里选择
DistilBERT,因为它是 BERT 的一个小型、快速和廉价版本:from transformers import DistilBertForSequenceClassification model = DistilBertForSequenceClassification.from_pre-trained('distilbert-base-uncased') -
要对任何模型进行微调,我们需要将其设置为训练模式,如下所示:
model.train() -
现在,我们必须加载分词器:
from transformers import DistilBertTokenizerFast tokenizer = DistilBertTokenizerFast.from_pre-trained('bert-base-uncased') -
由于
Trainer类已经为我们组织好了整个过程,我们在之前的 IMDb 情感分类练习中没有处理优化和其他训练设置。现在,我们需要自己实例化优化器。在这里,我们必须选择AdamW,它是 Adam 算法的一个实现,但修复了权重衰减。最近的研究表明,AdamW产生的训练损失和验证损失比使用 Adam 训练的模型更好。因此,在许多 transformer 训练过程中,它是一个广泛使用的优化器:from transformers import AdamW optimizer = AdamW(model.parameters(), lr=1e-3)要从头开始设计微调过程,我们必须了解如何实现单步前向传播和反向传播。我们可以通过 transformer 层传递一个批次并获得输出,该输出由分词器生成的
input_ids和attention_mask组成,并使用真实标签计算损失。正如我们所看到的,输出包含loss和logits两部分。现在,loss.backward()通过使用输入和标签评估模型来计算张量的梯度。optimizer.step()执行单个优化步骤并使用计算的梯度更新权重,这称为反向传播。当我们很快将所有这些行放入一个循环中时,我们还将添加optimizer.zero_grad(),它清除所有参数的梯度。在循环开始时调用这一点非常重要;否则,我们可能会积累多个步骤的梯度。输出的第二个张量是logits。在深度学习的上下文中,logits(logistic units 的缩写)是神经架构的最后一层,由实数作为预测值组成。在分类的情况下,logits 需要通过 softmax 函数转换为概率。否则,它们只是用于回归的标准化值。 -
如果我们想要手动计算损失,我们就不能将标签传递给模型。由于这个原因,模型只产生 logits,而不计算损失。在下面的示例中,我们正在手动计算交叉熵损失:
from torch.nn import functional labels = torch.tensor([1,0,1]) outputs = model(input_ids, attention_mask=attention_mask) loss = functional.cross_entropy(outputs.logits, labels) loss.backward() optimizer.step() loss Output: tensor(0.6101, grad_fn=<NllLossBackward>) -
有了这个,我们学会了如何将批量输入通过网络的前向方向在单个步骤中进行传递。现在,是时候设计一个循环,以批量迭代整个数据集来训练模型进行多个 epochs。为此,我们将首先设计
Dataset类。它是torch.Dataset的子类,继承成员变量和函数,并实现__init__()和__getitem()__抽象函数:from torch.utils.data import Dataset class MyDataset(Dataset): def __init__(self, encodings, labels): self.encodings = encodings self.labels = labels def __getitem__(self, idx): item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()} item['labels'] = torch.tensor(self.labels[idx]) return item def __len__(self): return len(self.labels) -
通过拿取另一个情感分析数据集 SST-2 数据集,即斯坦福情感树库 v2(SST2)来对情感分析的模型进行微调。我们还将加载 SST-2 的相应度量进行评估,如下所示:
import datasets from datasets import load_dataset sst2= load_dataset("glue","sst2") from datasets import load_metric metric = load_metric("glue", "sst2") -
我们将相应地提取句子和标签:
texts=sst2['train']['sentence'] labels=sst2['train']['label'] val_texts=sst2['validation']['sentence'] val_labels=sst2['validation']['label'] -
现在,我们可以通过标记器传递数据集并实例化
MyDataset对象,使 BERT 模型可以与它们一起工作:train_dataset= MyDataset(tokenizer(texts, truncation=True, padding=True), labels) val_dataset= MyDataset(tokenizer(val_texts, truncation=True, padding=True), val_labels) -
让我们实例化一个
Dataloader类,它提供了通过加载顺序迭代数据样本的接口。这也有助于批处理和内存固定:from torch.utils.data import DataLoader train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=16, shuffle=True) -
以下行检测设备并适当地定义
AdamW优化器:from transformers import AdamW device = \ torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') model.to(device) optimizer = AdamW(model.parameters(), lr=1e-3)到目前为止,我们知道如何实现前向传播,这是我们处理一批示例的地方。在这里,批量数据通过神经网络的前向方向进行传递。在单个步骤中,每层从第一层到最后一层都由批量数据处理,根据激活函数,传递到下一层。为了在多个 epochs 中遍历整个数据集,我们设计了两个嵌套循环:外部循环是为了 epochs,而内部循环是为了每批次的步骤。内部部分由两个块组成;一个用于训练,另一个用于评估每个 epochs。您可能已经注意到,我们在第一个训练循环中调用了
model.train(),当移动第二个评估块时,我们调用了model.eval()。这很重要,因为我们使模型处于训练和推理模式。 -
我们已经讨论了内部块。注意,我们通过相应的
metric对象跟踪模型的性能:for epoch in range(3): model.train() for batch in train_loader: optimizer.zero_grad() input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) outputs = \ model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs[0] loss.backward() optimizer.step() model.eval() for batch in val_loader: input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) outputs = \ model(input_ids, attention_mask=attention_mask, labels=labels) predictions=outputs.logits.argmax(dim=-1) metric.add_batch( predictions=predictions, references=batch["labels"], ) eval_metric = metric.compute() print(f"epoch {epoch}: {eval_metric}") OUTPUT: epoch 0: {'accuracy': 0.9048165137614679} epoch 1: {'accuracy': 0.8944954128440367} epoch 2: {'accuracy': 0.9094036697247706}做得好!我们已经对模型进行了微调,并获得了大约 90.94 的准确度。剩下的流程,如保存、加载和推理,将类似于我们在
Trainer类中所做的。
有了这个,我们已经完成了二元分类。在下一节中,我们将学习如何为非英语语言实现多类分类模型。
用自定义数据集对多类分类进行 BERT 微调
在本节中,我们将对土耳其 BERT,即BERTurk,进行多类分类下游任务的微调,其自定义数据集包含从土耳其报纸编制的七个类别。我们将从获取数据集开始。或者,您可以在本书的 GitHub 存储库中找到它,或者从www.kaggle.com/savasy/ttc4900 获取它:
-
首先,在 Python 笔记本中运行以下代码以获取数据:
!wget https://raw.githubusercontent.com/savasy/TurkishTextClassification/master/TTC4900.csv -
从加载数据开始:
import pandas as pd data= pd.read_csv("TTC4900.csv") data=data.sample(frac=1.0, random_state=42) -
让我们用
id2label和label2id组织 ID 和标签,以使模型弄清楚哪个 ID 指代哪个标签。我们还将NUM_LABELS的数量传递给模型,以指定 BERT 模型顶部薄分类头层的大小:labels=["teknoloji","ekonomi","saglik","siyaset","kultur","spor","dunya"] NUM_LABELS= len(labels) id2label={i:l for i,l in enumerate(labels)} label2id={l:i for i,l in enumerate(labels)} data["labels"]=data.category.map(lambda x: label2id[x.strip()]) data.head()输出如下:
![]()
图 5.5 – 文本分类数据集 – TTC 4900
-
让我们使用 pandas 对象计算并绘制类别数量:
data.category.value_counts().plot(kind='pie')如下图所示,数据集的类别已经被相当分配:
![]()
图 5.6 – 类别分布
-
以下执行实例化一个序列分类模型,带有标签数量(
7)、标签 ID 映射和一个土耳其 BERT 模型(dbmdz/bert-base-turkish-uncased),即 BERTurk。要检查这一点,请执行以下操作:>>> model -
输出将是模型的摘要,太长了,无法在此处显示。相反,让我们通过以下代码关注最后一层:
(classifier): Linear(in_features=768, out_features=7, bias=True) -
你可能已经注意到我们没有选择
DistilBert,因为没有预先训练好的uncasedDistilBert适用于土耳其语:from transformers import BertTokenizerFast tokenizer = BertTokenizerFast.from_pre-trained("dbmdz/bert-base-turkish-uncased", max_length=512) from transformers import BertForSequenceClassification model = BertForSequenceClassification.from_pre-trained("dbmdz/bert-base-turkish-uncased", num_labels=NUM_LABELS, id2label=id2label, label2id=label2id) model.to(device) -
现在,让我们准备训练(%50)、验证(%25)和测试(%25)数据集,如下所示:
SIZE= data.shape[0] ## sentences train_texts= list(data.text[:SIZE//2]) val_texts= list(data.text[SIZE//2:(3*SIZE)//4 ]) test_texts= list(data.text[(3*SIZE)//4:]) ## labels train_labels= list(data.labels[:SIZE//2]) val_labels= list(data.labels[SIZE//2:(3*SIZE)//4]) test_labels= list(data.labels[(3*SIZE)//4:]) ## check the size len(train_texts), len(val_texts), len(test_texts) (2450, 1225, 1225) -
以下代码将三个数据集的句子进行标记化,并将它们的标记转换为整数(
input_ids),然后将它们输入 BERT 模型:train_encodings = tokenizer(train_texts, truncation=True, padding=True) val_encodings = tokenizer(val_texts, truncation=True, padding=True) test_encodings = tokenizer(test_texts, truncation=True, padding=True) -
我们已经实现了
MyDataset类(请参阅第 14 页)。该类继承自抽象的Dataset类,通过重写__getitem__和__len__()方法来使用任何数据加载器返回数据集的项目和大小,分别预期返回:train_dataset = MyDataset(train_encodings, train_labels) val_dataset = MyDataset(val_encodings, val_labels) test_dataset = MyDataset(test_encodings, test_labels) -
由于我们有一个相对较小的数据集,我们将保持批处理大小为
16。请注意,TrainingArguments的其他参数几乎与之前的情感分析实验相同:from transformers import TrainingArguments, Trainer training_args = TrainingArguments( output_dir='./TTC4900Model', do_train=True, do_eval=True, num_train_epochs=3, per_device_train_batch_size=16, per_device_eval_batch_size=32, warmup_steps=100, weight_decay=0.01, logging_strategy='steps', logging_dir='./multi-class-logs', logging_steps=50, evaluation_strategy="steps", eval_steps=50, save_strategy="epoch", fp16=True, load_best_model_at_end=True ) -
情感分析和文本分类是相同评估指标的对象;即宏平均的宏平均 F1、精度和召回率。因此,我们不会重新定义
compute_metric()函数。以下是实例化Trainer对象的代码:trainer = Trainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=val_dataset, compute_metrics= compute_metrics ) -
最后,让我们开始训练过程:
trainer.train()输出如下:
![]()
图 5.7 – 文本分类的 Trainer 类的输出
-
要检查训练好的模型,我们必须在三个数据集拆分上评估微调的模型,如下所示。我们的最佳模型是在步骤 300 微调的,损失为 0.28012:
q=[trainer.evaluate(eval_dataset=data) for data in [train_dataset, val_dataset, test_dataset]] pd.DataFrame(q, index=["train","val","test"]).iloc[:,:5]输出如下:
![图 5.8 – 文本分类模型在训练/验证/测试数据集上的性能]()
图 5.8 – 文本分类模型在训练/验证/测试数据集上的性能
分类准确率约为 92.6,而 F1 宏平均约为 92.5。在文献中,许多方法都在这个土耳其基准数据集上进行了测试。它们大多采用 TF-IDF 和线性分类器、word2vec 嵌入,或基于 LSTM 的分类器,最好的 F1 也达到了 90.0。与这些方法相比,除了 transformer,微调的 BERT 模型表现更佳。
-
与任何其他实验一样,我们可以通过 TensorBoard 跟踪实验:
%load_ext tensorboard %tensorboard --logdir multi-class-logs/ -
让我们设计一个运行推理模型的函数。如果你想看到真实标签而不是 ID,你可以使用我们模型的
config对象,如下面的predict函数所示:def predict(text): inputs = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors="pt").to("cuda") outputs = model(**inputs) probs = outputs[0].softmax(1) return probs, probs.argmax(),model.config.id2label[probs.argmax().item()] -
现在,我们准备调用
predict函数进行文本分类推理。以下代码对一个关于足球队的句子进行分类:text = "Fenerbahçeli futbolcular kısa paslarla hazırlık çalışması yaptılar" predict(text) (tensor([[5.6183e-04, 4.9046e-04, 5.1385e-04, 9.9414e-04, 3.4417e-04, 9.9669e-01, 4.0617e-04]], device='cuda:0', grad_fn=<SoftmaxBackward>), tensor(5, device='cuda:0'), 'spor') -
正如我们所看到的,该模型正确地预测了句子为体育(
spor)。现在,是时候保存模型并使用from_pre-trained()函数重新加载它了。以下是代码:model_path = "turkish-text-classification-model" trainer.save_model(model_path) tokenizer.save_pre-trained(model_path) -
现在,我们可以重新加载已保存的模型,并借助
pipeline类进行推理:model_path = "turkish-text-classification-model" from transformers import pipeline, BertForSequenceClassification, BertTokenizerFast model = BertForSequenceClassification.from_pre-trained(model_path) tokenizer= BertTokenizerFast.from_pre-trained(model_path) nlp= pipeline("sentiment-analysis", model=model, tokenizer=tokenizer) -
您可能已经注意到任务的名称是
sentiment-analysis。这个术语可能令人困惑,但这个参数实际上会返回最终的TextClassificationPipeline。让我们运行 pipeline:>>> nlp("Sinemada hangi filmler oynuyor bugün") [{'label': 'kultur', 'score': 0.9930670261383057}] >>> nlp("Dolar ve Euro bugün yurtiçi piyasalarda yükseldi") [{'label': 'ekonomi', 'score': 0.9927696585655212}] >>> nlp("Bayern Münih ile Barcelona bugün karşı karşıya geliyor. Maçı İngiliz hakem James Watts yönetecek!") [{'label': 'spor', 'score': 0.9975664019584656}]这就是我们的模型!它已经成功预测了。
到目前为止,我们已经实现了两个单句任务;即情感分析和多类分类。在下一节,我们将学习如何处理句对输入,以及如何使用 BERT 设计回归模型。
为句对回归微调 BERT 模型
回归模型被认为是用于分类的,但最后一层只包含一个单元。这不是通过 softmax logistic 回归进行处理,而是进行了归一化。为了指定模型并在顶部放置单单元头层,我们可以直接通过BERT.from_pre-trained()方法传递num_labels=1参数,或者通过Config对象传递此信息。最初,这需要从预训练模型的config对象中复制,如下所示:
from transformers import DistilBertConfig, DistilBertTokenizerFast, DistilBertForSequenceClassification
model_path='distilbert-base-uncased'
config = DistilBertConfig.from_pre-trained(model_path, num_labels=1)
tokenizer = DistilBertTokenizerFast.from_pre-trained(model_path)
model = \
DistilBertForSequenceClassification.from_pre-trained(model_path, config=config)
嗯,我们的预训练模型由于num_labels=1参数具有单单元头层。现在,我们准备用我们的数据集对模型进行微调。在这里,我们将使用语义文本相似性基准(STS-B),它是从各种内容中引用的句对集合,如新闻标题等。每对句子都被注释了从 1 到 5 的相似度分数。我们的任务是微调 BERT 模型以预测这些分数。我们将遵循文献,使用皮尔逊/斯皮尔曼相关系数评估模型。让我们开始吧:
-
以下代码加载了数据。原始数据被分成了三部分。然而,测试分组没有标签,因此我们可以将验证数据分为两部分,如下所示:
import datasets from datasets import load_dataset stsb_train= load_dataset('glue','stsb', split="train") stsb_validation = load_dataset('glue','stsb', split="validation") stsb_validation=stsb_validation.shuffle(seed=42) stsb_val= datasets.Dataset.from_dict(stsb_validation[:750]) stsb_test= datasets.Dataset.from_dict(stsb_validation[750:]) -
让我们通过 pandas 将
stsb_train训练数据整理整齐:pd.DataFrame(stsb_train)训练数据如下所示:
![图 5.9 – STS-B 训练数据集]()
图 5.9 – STS-B 训练数据集
-
运行以下代码以检查三个集合的形状:
stsb_train.shape, stsb_val.shape, stsb_test.shape ((5749, 4), (750, 4), (750, 4)) -
运行以下代码对数据集进行分词:
enc_train = stsb_train.map(lambda e: tokenizer( e['sentence1'],e['sentence2'], padding=True, truncation=True), batched=True, batch_size=1000) enc_val = stsb_val.map(lambda e: tokenizer( e['sentence1'],e['sentence2'], padding=True, truncation=True), batched=True, batch_size=1000) enc_test = stsb_test.map(lambda e: tokenizer( e['sentence1'],e['sentence2'], padding=True, truncation=True), batched=True, batch_size=1000) -
分词器使用
[SEP]分隔符合并两个句子,并为句对生成单个input_ids和一个attention_mask,如下所示:pd.DataFrame(enc_train)输出如下:
![图 5.10 – 编码训练数据集]()
from transformers import TrainingArguments, Trainer training_args = TrainingArguments( output_dir='./stsb-model', do_train=True, do_eval=True, num_train_epochs=3, per_device_train_batch_size=32, per_device_eval_batch_size=64, warmup_steps=100, weight_decay=0.01, logging_strategy='steps', logging_dir='./logs', logging_steps=50, evaluation_strategy="steps", save_strategy="epoch", fp16=True, load_best_model_at_end=True ) -
当前回归任务与以前的分类任务之间的另一个重要区别是
compute_metrics的设计。在这里,我们的评估指标将基于皮尔逊相关系数和斯皮尔曼秩相关,遵循文献中提供的通用做法。我们还提供了均方误差(MSE)、均方根误差(RMSE)和平均绝对误差(MAE)等常用的度量标准,特别是对于回归模型:import numpy as np from scipy.stats import pearsonr from scipy.stats import spearmanr def compute_metrics(pred): preds = np.squeeze(pred.predictions) return {"MSE": ((preds - pred.label_ids) ** 2).mean().item(), "RMSE": (np.sqrt (( (preds - pred.label_ids) ** 2).mean())).item(), "MAE": (np.abs(preds - pred.label_ids)).mean().item(), "Pearson" : pearsonr(preds,pred.label_ids)[0], "Spearman's Rank":spearmanr(preds,pred.label_ids)[0] } -
现在,让我们实例化
Trainer对象:trainer = Trainer( model=model, args=training_args, train_dataset=enc_train, eval_dataset=enc_val, compute_metrics=compute_metrics, tokenizer=tokenizer )运行训练,像这样:
train_result = trainer.train()输出如下:
![图 5.11 – 文本回归的训练结果]()
图 5.11 – 文本回归的训练结果
-
计算的最佳验证损失为
0.544973,在步骤450。让我们在该步骤评估最佳检查点模型,如下所示:q=[trainer.evaluate(eval_dataset=data) for data in [enc_train, enc_val, enc_test]] pd.DataFrame(q, index=["train","val","test"]).iloc[:,:5]输出如下:
![图 5.12 – 训练/验证/测试数据集上的回归性能]()
图 5.12 – 训练/验证/测试数据集上的回归性能
在测试数据集上,皮尔逊和斯皮尔曼相关分数分别约为 87.54 和 87.28。我们没有得到 SoTA 结果,但基于 GLUE Benchmark 排行榜,我们得到了一个可比较的 STS-B 任务结果。请查看排行榜!
-
现在我们准备好进行推断模型了。让我们来看以下两个意思相同的句子,并将它们传递给模型:
s1,s2="A plane is taking off.","An air plane is taking off." encoding = tokenizer(s1,s2, return_tensors='pt', padding=True, truncation=True, max_length=512) input_ids = encoding['input_ids'].to(device) attention_mask = encoding['attention_mask'].to(device) outputs = model(input_ids, attention_mask=attention_mask) outputs.logits.item() OUTPUT: 4.033723831176758 -
以下代码使用了负面句对,这意味着句子在语义上是不同的:
s1,s2="The men are playing soccer.","A man is riding a motorcycle." encoding = tokenizer("hey how are you there","hey how are you", return_tensors='pt', padding=True, truncation=True, max_length=512) input_ids = encoding['input_ids'].to(device) attention_mask = encoding['attention_mask'].to(device) outputs = model(input_ids, attention_mask=attention_mask) outputs.logits.item() OUTPUT: 2.3579328060150146 -
最后,我们将保存模型,如下所示:
model_path = "sentence-pair-regression-model" trainer.save_model(model_path) tokenizer.save_pre-trained(model_path)
干得好!我们可以祝贺自己,因为我们成功完成了三项任务:情感分析、多类别分类和句对回归。
利用 run_glue.py 对模型进行微调
我们目前已经使用原生 PyTorch 和 Trainer 类从头设计了一个微调架构。HuggingFace 社区还提供了另一个强大的脚本,称为 run_glue.py,用于 GLUE 基准测试和 GLUE 类似的分类下游任务。这个脚本可以为我们处理和组织整个训练/验证过程。如果你想进行快速原型设计,应该使用这个脚本。它可以微调 HuggingFace hub 上的任何预训练模型。我们也可以用任何格式的自己的数据来提供给它。
请转到以下链接获取脚本并了解更多信息:github.com/huggingface/transformers/tree/master/examples。
该脚本可以执行九种不同的 GLUE 任务。通过该脚本,我们可以做到目前为止我们使用Trainer类所做的一切。任务名称可以是以下 GLUE 任务之一:cola、sst2、mrpc、stsb、qqp、mnli、qnli、rte或wnli。
以下是微调模型的脚本方案:
export TASK_NAME= "My-Task-Name"
python run_glue.py \
--model_name_or_path bert-base-cased \
--task_name $TASK_NAME \
--do_train \ --do_eval \
--max_seq_length 128 \
--per_device_train_batch_size 32 \
--learning_rate 2e-5 \
--num_train_epochs 3 \
--output_dir /tmp/$TASK_NAME/
社区提供了另一个名为run_glue_no_trainer.py的脚本。与原始脚本的主要区别在于,这个无 Trainer 的脚本给了我们更多改变优化器选项或添加任何自定义的机会。
总结
在本章中,我们讨论了如何针对任何文本分类的下游任务对预训练模型进行微调。我们使用情感分析、多类别分类和句子对分类(具体而言,句子对回归)对模型进行了微调。我们使用了一个著名的 IMDb 数据集和我们自己的自定义数据集来训练模型。虽然我们利用了Trainer类来处理训练和微调过程的复杂性,但我们学会了如何使用原生库从头开始训练,以了解transformers库中的前向传播和反向传播。总而言之,我们讨论并进行了使用 Trainer 进行微调单句分类、使用原生 PyTorch 进行情感分类、单句多类别分类以及微调句子对回归。
在下一章中,我们将学习如何针对任何标记分类的下游任务(如词性标注或命名实体识别)对预训练模型进行微调。
第六章:为标记分类对语言模型进行微调
在本章中,我们将学习为标记分类对语言模型进行微调。本章探讨了诸如命名实体识别(NER)、词性(POS)标注和问答(QA)等任务。我们将学习如何将特定语言模型微调用于此类任务。我们将更多地关注 BERT,而不是其他语言模型。您将学习如何使用 BERT 应用 POS、NER 和 QA。您将熟悉这些任务的理论细节,如它们各自的数据集以及如何执行它们。完成本章后,您将能够使用 Transformers 执行任何标记分类。
在本章中,我们将为以下任务微调 BERT:为 NER 和 POS 等标记分类问题微调 BERT,为 NER 问题微调语言模型,并将 QA 问题视为起始/终止标记分类。
本章将涵盖以下主题:
-
介绍标记分类
-
为 NER 进行语言模型微调
-
使用标记分类进行问答
技术要求
我们将使用 Jupyter Notebook 运行我们的编码练习,并且需要安装 Python 3.6+ 和以下软件包:
-
sklearn -
transformers 4.0+ -
数据集 -
seqeval
所有带有编码练习的笔记本都将在以下 GitHub 链接中提供:github.com/PacktPublishing/Mastering-Transformers/tree/main/CH06。
查看以下链接以查看实际代码视频:bit.ly/2UGMQP2
介绍标记分类
将标记序列中的每个标记分类的任务称为标记分类。该任务要求特定模型能够将每个标记分类到一个类别中。POS 和 NER 是这一标准中最知名的两个任务。然而,QA 也是另一个属于这一类别的重要 NLP 任务。我们将在以下章节讨论这三个任务的基础知识。
理解 NER
在标记分类类别中一个著名的任务是 NER - 将每个标记识别为实体或非实体,并识别每个检测到的实体的类型。例如,文本可以同时包含多个实体 - 人名、地名、组织名和其他类型的实体。以下文本是 NER 的明显示例:
乔治·华盛顿是美利坚合众国的总统之一。
乔治·华盛顿是一个人名,而美利坚合众国是一个地名。序列标注模型应该能够以标签的形式标记每个单词,每个标签都包含有关该标签的信息。BIO 的标签是标准 NER 任务中通用的标签。
以下表格是标签及其描述的列表:

表 1 – BIOS 标签及其描述表
从这个表格可以看出,B 表示标记的开始,I 表示标记的内部,而 O 则表示实体的外部。这就是为什么这种类型的标注被称为 BIO。例如,前面显示的句子可以使用 BIO 进行标注:
[B-PER|George] [I-PER|Washington] [O|is] [O|one] [O|the] [O|presidents] [O|of] [B-LOC|United] [I-LOC|States] [I-LOC|of] [I-LOC|America] [O|.]
因此,序列必须以 BIO 格式进行标记。一个样本数据集可以使用如下格式:

图 6.1 – CONLL2003 数据集
除了我们见过的 NER 标签外,该数据集还包含了 POS 标签
理解 POS 标记
POS 标记,或语法标记,是根据给定文本中的各自词的词性对其进行标注。举个简单的例子,在给定文本中,识别每个词的角色,如名词、形容词、副词和动词都被认为是词性标注。然而,从语言学角度来看,除了这四种角色外还有很多其他角色。
在 POS 标签的情况下,有各种变化,但是宾州树库的 POS 标签集是最著名的之一。下面的截图显示了这些角色的摘要和相应的描述:

图 6.2 – 宾州树库 POS 标签
POS 任务的数据集如 图 6.1 所示进行了标注。
这些标签的标注在特定的 NLP 应用中非常有用,是许多其他方法的基石之一。Transformers和许多先进模型在其复杂的结构中某种程度上能理解单词之间的关系。
理解 QA
QA 或阅读理解任务包括一组阅读理解文本,并相应地提出问题。这个范围内的示例数据集包括 SQUAD 或 斯坦福问答数据集。该数据集由维基百科文本和关于它们提出的问题组成。答案以原始维基百科文本的片段形式给出。
以下截图显示了这个数据集的一个示例:

图 6.3 – SQUAD 数据集示例
突出显示的红色部分是答案,每个问题的重要部分用蓝色突出显示。要求一个良好的 NLP 模型按照问题对文本进行分割,这种分割可以通过序列标注的形式进行。模型会将答案的开始和结束部分标记为答案的起始和结束部分。
到目前为止,你已经学会了现代 NLP 序列标注任务的基础知识,如 QA、NER 和 POS。在接下来的部分,你将学习如何对这些特定任务进行 BERT 微调,并使用 datasets 库中相关的数据集。
为 NER 微调语言模型
在本节中,我们将学习如何为 NER 任务微调 BERT。我们首先从 datasets 库开始,并加载 conll2003 数据集。
数据集卡片可在 huggingface.co/datasets/conll2003 上访问。以下截图显示了来自 HuggingFace 网站的此模型卡片:

图 6.4 – 来自 HuggingFace 的 CONLL2003 数据集卡片
从此截图中可以看出,模型是在此数据集上进行训练的,目前可用,并在右侧面板中列出。但是,还有关于数据集的描述,例如其大小和特征:
-
要加载数据集,使用以下命令:
import datasets conll2003 = datasets.load_dataset("conll2003")将出现一个下载进度条,下载和缓存完成后,数据集将准备好供使用。以下截图显示了进度条:
![图 6.5 – 下载和准备数据集]()
图 6.5 – 下载和准备数据集
-
您可以通过使用以下命令访问训练样本轻松地检查数据集:
>>> conll2003["train"][0]下图显示了结果:
![图 6.6 – 从 datasets 库获取的 CONLL2003 训练样本]()
图 6.6 – 从 datasets 库获取的 CONLL2003 训练样本
-
前述截图显示了 POS 和 NER 的相应标签。我们将仅使用此部分的 NER 标签。您可以使用以下命令获取此数据集中可用的 NER 标签:
>>> conll2003["train"].features["ner_tags"] -
结果也显示在 图 6.7 中。所有 BIO 标签都显示在此处,共有九个标签:
>>> Sequence(feature=ClassLabel(num_classes=9, names=['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC'], names_file=None, id=None), length=-1, id=None) -
下一步是加载 BERT 分词器:
from transformers import BertTokenizerFast tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased") -
tokenizer类也可以处理基于空格的分词句子。我们需要启用我们的分词器以处理基于空格的分词句子,因为命名实体识别任务为每个标记有一个基于标记的标签。在这个任务中,标记通常是基于空格分词的单词,而不是 BPE 或任何其他分词器的标记。根据所说的内容,让我们看看tokenizer如何与基于空格的分词句子一起使用:>>> tokenizer(["Oh","this","sentence","is","tokenized","and", "splitted","by","spaces"], is_split_into_words=True)正如您所见,仅需将
is_split_into_words设置为True,问题就解决了。 -
在使用数据进行训练之前,必须对数据进行预处理。为此,我们必须使用以下函数并将其映射到整个数据集中:
def tokenize_and_align_labels(examples): tokenized_inputs = tokenizer(examples["tokens"], truncation=True, is_split_into_words=True) labels = [] for i, label in enumerate(examples["ner_tags"]): word_ids = \ tokenized_inputs.word_ids(batch_index=i) previous_word_idx = None label_ids = [] for word_idx in word_ids: if word_idx is None: label_ids.append(-100) elif word_idx != previous_word_idx: label_ids.append(label[word_idx]) else: label_ids.append(label[word_idx] if label_all_tokens else -100) previous_word_idx = word_idx labels.append(label_ids) tokenized_inputs["labels"] = labels return tokenized_inputs -
此函数将确保我们的标记和标签正确对齐。此对齐是必需的,因为标记是分割成片段的,但单词必须是一个整体。要测试并查看此函数的工作原理,您可以将单个样本提供给它并运行它:
q = tokenize_and_align_labels(conll2003['train'][4:5]) print(q)结果如下所示:
>>> {'input_ids': [[101, 2762, 1005, 1055, 4387, 2000, 1996, 2647, 2586, 1005, 1055, 15651, 2837, 14121, 1062, 9328, 5804, 2056, 2006, 9317, 10390, 2323, 4965, 8351, 4168, 4017, 2013, 3032, 2060, 2084, 3725, 2127, 1996, 4045, 6040, 2001, 24509, 1012, 102]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'labels': [[-100, 5, 0, -100, 0, 0, 0, 3, 4, 0, -100, 0, 0, 1, 2, -100, -100, 0, 0, 0, 0, 0, 0, 0, -100, -100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, -100]]} -
但是这个结果是不可读的,所以您可以运行以下代码以获得可读版本:
for token, label in zip(tokenizer.convert_ids_to_tokens(q["input_ids"][0]),q["labels"][0]): print(f"{token:_<40} {label}")结果如下所示:
![图 6.7 – tokenize 和 align 函数的结果]()
图 6.7 – tokenize 和 align 函数的结果
-
这个函数与数据集的映射可以通过
datasets库的map函数完成:>>> tokenized_datasets = \ conll2003.map(tokenize_and_align_labels, batched=True) -
接下来,需要加载具有相应标签数量的 BERT 模型:
from transformers import\ AutoModelForTokenClassification model = AutoModelForTokenClassification.from_pretrained("bert-base-uncased", num_labels=9) -
模型将被加载并准备好进行训练。在接下来的步骤中,我们必须准备好训练器和训练参数:
from transformers import TrainingArguments, Trainer args = TrainingArguments( "test-ner", evaluation_strategy = "epoch", learning_rate=2e-5, per_device_train_batch_size=16, per_device_eval_batch_size=16, num_train_epochs=3, weight_decay=0.01, ) -
需要准备数据收集器。它将在训练数据集上应用批量操作,以使用更少的内存并执行更快。您可以像下面这样做:
from transformers import \ DataCollatorForTokenClassification data_collator = \ DataCollatorForTokenClassification(tokenizer) -
为了能够评估模型的性能,在 HuggingFace 的
datasets库中有许多任务的许多指标可用。我们将使用用于 NER 的序列评估指标。seqeval 是一个用于评估序列标记算法和模型的良好 Python 框架。需要安装seqeval库:pip install seqeval -
之后,您可以加载指标:
>>> metric = datasets.load_metric("seqeval") -
通过以下代码,很容易看出指标是如何工作的:
example = conll2003['train'][0] label_list = \ conll2003["train"].features["ner_tags"].feature.names labels = [label_list[i] for i in example["ner_tags"]] metric.compute(predictions=[labels], references=[labels])结果如下:
![图 6.8 – seqeval 指标的输出]()
图 6.8 – seqeval 指标的输出
对于样本输入,计算各种指标,如准确率、F1 分数、精确度和召回率。
-
以下函数用于计算指标:
import numpy as np def compute_metrics(p): predictions, labels = p predictions = np.argmax(predictions, axis=2) true_predictions = [ [label_list[p] for (p, l) in zip(prediction, label) if l != -100] for prediction, label in zip(predictions, labels) ] true_labels = [ [label_list[l] for (p, l) in zip(prediction, label) if l != -100] for prediction, label in zip(predictions, labels) ] results = \ metric.compute(predictions=true_predictions, references=true_labels) return { "precision": results["overall_precision"], "recall": results["overall_recall"], "f1": results["overall_f1"], "accuracy": results["overall_accuracy"], } -
最后一步是制作训练器并相应地对其进行训练:
trainer = Trainer( model, args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, compute_metrics=compute_metrics ) trainer.train() -
运行
trainer的train函数后,结果如下所示:![图 6.9-运行 train 后的 Trainer 结果]()
图 6.9-运行 train 后的 Trainer 结果
-
在训练后,必须保存模型和分词器:
model.save_pretrained("ner_model") tokenizer.save_pretrained("tokenizer") -
如果您希望使用管道(pipeline)使用模型,则必须读取配置文件,并根据
label_list对象中使用的标签正确分配label2id和id2label:id2label = { str(i): label for i,label in enumerate(label_list) } label2id = { label: str(i) for i,label in enumerate(label_list) } import json config = json.load(open("ner_model/config.json")) config["id2label"] = id2label config["label2id"] = label2id json.dump(config, open("ner_model/config.json","w")) -
之后,您可以像以下示例一样轻松使用模型:
from transformers import pipeline model = \ AutoModelForTokenClassification.from_pretrained("ner_model") nlp = \ pipeline("ner", model=mmodel, tokenizer=tokenizer) example = "I live in Istanbul" ner_results = nlp(example) print(ner_results)然后结果将如下所示:
[{'entity': 'B-LOC', 'score': 0.9983942, 'index': 4, 'word': 'istanbul', 'start': 10, 'end': 18}]
到目前为止,您已经学会了如何使用 BERT 应用 POS。您了解了如何使用 Transformers 训练自己的 POS 标注模型,并对模型进行了测试。在接下来的部分,我们将专注于 QA。
使用令牌分类进行问答
一个QA问题通常被定义为一个 NLP 问题,给定一个文本和一个问题,需要 AI 返回一个答案。通常,这个答案可以在原始文本中找到,但对于这个问题存在不同的方法。在视觉问答(VQA)的情况下,问题涉及的是视觉实体或视觉概念,而不是文本,但问题本身是以文本形式呈现的。
一些 VQA 的示例如下:

图 6.10 – VQA 示例
VQA 中大多数模型都是多模态模型,可以理解视觉上下文以及问题,并能正确生成答案。然而,单模全文本 QA 或者仅 QA 是基于文本上下文和文本问题以及相应的文本答案:
-
SQUAD 是问答领域中最知名的数据集之一。要查看 SQUAD 的示例并对其进行检查,您可以使用以下代码:
from pprint import pprint from datasets import load_dataset squad = load_dataset("squad") for item in squad["train"][1].items(): print(item[0]) pprint(item[1]) print("="*20)以下是结果:
answers {'answer_start': [188], 'text': ['a copper statue of Christ']} ==================== Context ('Architecturally, the school has a Catholic character. Atop the Main ' "Building's gold dome is a golden statue of the Virgin Mary. Immediately in " 'front of the Main Building and facing it, is a copper statue of Christ with ' 'arms upraised with the legend "Venite Ad Me Omnes". Next to the Main ' 'Building is the Basilica of the Sacred Heart. Immediately behind the ' 'basilica is the Grotto, a Marian place of prayer and reflection. It is a ' 'replica of the grotto at Lourdes, France where the Virgin Mary reputedly ' 'appeared to Saint Bernadette Soubirous in 1858\. At the end of the main drive ' '(and in a direct line that connects through 3 statues and the Gold Dome), is ' 'a simple, modern stone statue of Mary.') ==================== Id '5733be284776f4190066117f' ==================== Question 'What is in front of the Notre Dame Main Building?' ==================== Title 'University_of_Notre_Dame' ====================但是,SQUAD 数据集还有第 2 版,其中有更多的训练样本,并且强烈建议使用它。为了全面了解如何为 QA 问题训练模型的可能性,我们将重点放在解决这个问题的当前部分上。
-
要开始,使用以下代码加载 SQUAD 第 2 版:
from datasets import load_dataset squad = load_dataset("squad_v2") -
在加载 SQUAD 数据集之后,您可以通过使用以下代码查看此数据集的详细信息:
>>> squad结果如下:
![图 6.11 – SQUAD 数据集(第 2 版)详细信息]()
图 6.11 – SQUAD 数据集(第 2 版)详细信息
SQUAD 数据集的详细信息将显示在图 6.11中。正如您所看到的,有超过 130,000 个训练样本和超过 11,000 个验证样本。
-
就像我们对 NER 所做的那样,我们必须预处理数据,使其具有适合模型使用的正确形式。为此,您必须首先加载您的分词器,只要您使用预训练模型并希望为 QA 问题进行微调:
from transformers import AutoTokenizer model = "distilbert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(model)正如您所看到的,我们将使用
distillBERT模型。根据我们的 SQUAD 示例,我们需要向模型提供不止一个文本,一个用于问题,一个用于上下文。因此,我们的分词器需要将这两个文本并排放在一起,并使用特殊的
[SEP]标记将它们分开,因为distillBERT是基于 BERT 的模型。在 QA 范围内还有另一个问题,即上下文的大小。上下文的大小可以比模型输入大小长,但我们不能将其缩减到模型接受的大小。对于某些问题,我们可能可以这样做,但在 QA 中,答案可能在被截断的部分中。我们将向您展示一个示例,展示我们如何使用文档步幅来解决此问题。
-
以下是一个示例,展示了如何使用
tokenizer:max_length = 384 doc_stride = 128 example = squad["train"][173] tokenized_example = tokenizer( example["question"], example["context"], max_length=max_length, truncation="only_second", return_overflowing_tokens=True, stride=doc_stride ) -
步幅是用于返回第二部分的窗口的文档步幅,而
return_overflowing_tokens标志向模型提供有关是否应返回额外标记的信息。tokenized_example的结果不止一个标记化输出,而是有两个输入 ID。在以下,您可以看到结果:>>> len(tokenized_example['input_ids']) >>> 2 -
因此,您可以通过运行以下
for循环看到完整的结果:for input_ids in tokenized_example["input_ids"][:2]: print(tokenizer.decode(input_ids)) print("-"*50)结果如下:
[CLS] beyonce got married in 2008 to whom? [SEP] on april 4, 2008, beyonce married jay z. she publicly revealed their marriage in a video montage at the listening party for her third studio album, i am... sasha fierce, in manhattan's sony club on october 22, 2008\. i am... sasha fierce was released on november 18, 2008 in the united states. the album formally introduces beyonce's alter ego sasha fierce, conceived during the making of her 2003 single " crazy in love ", selling 482, 000 copies in its first week, debuting atop the billboard 200, and giving beyonce her third consecutive number - one album in the us. the album featured the number - one song " single ladies ( put a ring on it ) " and the top - five songs " if i were a boy " and " halo ". achieving the accomplishment of becoming her longest - running hot 100 single in her career, " halo "'s success in the us helped beyonce attain more top - ten singles on the list than any other woman during the 2000s. it also included the successful " sweet dreams ", and singles " diva ", " ego ", " broken - hearted girl " and " video phone ". the music video for " single ladies " has been parodied and imitated around the world, spawning the " first major dance craze " of the internet age according to the toronto star. the video has won several awards, including best video at the 2009 mtv europe music awards, the 2009 scottish mobo awards, and the 2009 bet awards. at the 2009 mtv video music awards, the video was nominated for nine awards, ultimately winning three including video of the year. its failure to win the best female video category, which went to american country pop singer taylor swift's " you belong with me ", led to kanye west interrupting the ceremony and beyonce [SEP] -------------------------------------------------- [CLS] beyonce got married in 2008 to whom? [SEP] single ladies " has been parodied and imitated around the world, spawning the " first major dance craze " of the internet age according to the toronto star. the video has won several awards, including best video at the 2009 mtv europe music awards, the 2009 scottish mobo awards, and the 2009 bet awards. at the 2009 mtv video music awards, the video was nominated for nine awards, ultimately winning three including video of the year. its failure to win the best female video category, which went to american country pop singer taylor swift's " you belong with me ", led to kanye west interrupting the ceremony and beyonce improvising a re - presentation of swift's award during her own acceptance speech. in march 2009, beyonce embarked on the i am... world tour, her second headlining worldwide concert tour, consisting of 108 shows, grossing $ 119\. 5 million. [SEP] --------------------------------------------------正如您可以从前面的输出中看到的那样,使用 128 个标记的窗口,剩余的上下文再次复制到了第二个输出的输入 ID 中。
另一个问题是结束跨度,在数据集中不可用,而是给出了答案的开始跨度或开始字符。很容易找到答案的长度并将其添加到起始跨度,这将自动产生结束跨度。
-
现在,我们已经了解了该数据集的所有细节以及如何处理它们,我们可以轻松地将它们组合在一起,制作一个预处理函数(链接:
github.com/huggingface/transformers/blob/master/examples/pytorch/question-answering/run_qa.py):def prepare_train_features(examples): # tokenize examples tokenized_examples = tokenizer( examples["question" if pad_on_right else "context"], examples["context" if pad_on_right else "question"], truncation="only_second" if pad_on_right else "only_first", max_length=max_length, stride=doc_stride, return_overflowing_tokens=True, return_offsets_mapping=True, padding="max_length", ) # map from a feature to its example sample_mapping = \ tokenized_examples.pop("overflow_to_sample_mapping") offset_mapping = \ tokenized_examples.pop("offset_mapping") tokenized_examples["start_positions"] = [] tokenized_examples["end_positions"] = [] # label impossible answers with CLS # start and end token are the answers for each one for i, offsets in enumerate(offset_mapping): input_ids = tokenized_examples["input_ids"][i] cls_index = \ input_ids.index(tokenizer.cls_token_id) sequence_ids = \ tokenized_examples.sequence_ids(i) sample_index = sample_mapping[i] answers = examples["answers"][sample_index] if len(answers["answer_start"]) == 0: tokenized_examples["start_positions"].\ append(cls_index) tokenized_examples["end_positions"].\ append(cls_index) else: start_char = answers["answer_start"][0] end_char = \ start_char + len(answers["text"][0]) token_start_index = 0 while sequence_ids[token_start_index] != / (1 if pad_on_right else 0): token_start_index += 1 token_end_index = len(input_ids) - 1 while sequence_ids[token_end_index] != (1 if pad_on_right else 0): token_end_index -= 1 if not (offsets[token_start_index][0] <= start_char and offsets[token_end_index][1] >= end_char): tokenized_examples["start_positions"].append(cls_index) tokenized_examples["end_positions"].append(cls_index) else: while token_start_index < len(offsets) and offsets[token_start_index][0] <= start_char: token_start_index += 1 tokenized_examples["start_positions"].append(token_start_index - 1) while offsets[token_end_index][1] >= end_char: token_end_index -= 1 tokenized_examples["end_positions"].append(token_end_index + 1) return tokenized_examples -
将此函数映射到数据集将应用所有所需的更改:
>>> tokenized_datasets = squad.map(prepare_train_features, batched=True, remove_columns=squad["train"].column_names) -
就像其他示例一样,您现在可以加载预训练的模型进行微调:
from transformers import AutoModelForQuestionAnswering, TrainingArguments, Trainer model = AutoModelForQuestionAnswering.from_pretrained(model) -
下一步是创建训练参数:
args = TrainingArguments( "test-squad", evaluation_strategy = "epoch", learning_rate=2e-5, per_device_train_batch_size=16, per_device_eval_batch_size=16, num_train_epochs=3, weight_decay=0.01, ) -
如果我们不打算使用数据收集器,我们将为模型训练器提供一个默认的数据收集器:
from transformers import default_data_collator data_collator = default_data_collator -
现在,一切准备就绪,可以制作训练器:
trainer = Trainer( model, args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, ) -
训练器可以与
train函数一起使用:trainer.train()结果将如下所示:
![图 6.12 - 训练结果]()
图 6.12 - 训练结果
如您所见,该模型使用三个 epochs 进行训练,并报告验证和训练中的损失输出。
-
像其他模型一样,您可以轻松地使用以下函数保存此模型:
>>> trainer.save_model("distillBERT_SQUAD")如果您想使用您保存的模型或任何在 QA 上训练的其他模型,则
transformers库提供了一个易于使用和实施的管道,无需额外努力。 -
通过使用这个管道功能,您可以使用任何模型。以下是使用 QA 管道的示例:
from transformers import pipeline qa_model = pipeline('question-answering', model='distilbert-base-cased-distilled-squad', tokenizer='distilbert-base-cased')管道只需要两个输入,即模型和 tokenizer,即可使模型准备就绪。但是,在给定示例中,您还需要给它一个管道类型,即 QA。
-
下一步是给它提供所需的输入,即
context和question:>>> question = squad["validation"][0]["question"] >>> context = squad["validation"][0]["context"] The question and the context can be seen by using following code: >>> print("Question:") >>> print(question) >>> print("Context:") >>> print(context) Question: In what country is Normandy located? Context: ('The Normans (Norman: Nourmands; French: Normands; Latin: Normanni) were the ' 'people who in the 10th and 11th centuries gave their name to Normandy, a ' 'region in France. They were descended from Norse ("Norman" comes from ' '"Norseman") raiders and pirates from Denmark, Iceland and Norway who, under ' 'their leader Rollo, agreed to swear fealty to King Charles III of West ' 'Francia. Through generations of assimilation and mixing with the native ' 'Frankish and Roman-Gaulish populations, their descendants would gradually ' 'merge with the Carolingian-based cultures of West Francia. The distinct ' 'cultural and ethnic identity of the Normans emerged initially in the first ' 'half of the 10th century, and it continued to evolve over the succeeding ' 'centuries.') -
该模型可以使用以下示例:
>>> qa_model(question=question, context=context)结果如下所示:
{'answer': 'France', 'score': 0.9889379143714905, 'start': 159, 'end': 165,}
到目前为止,您已经学会了如何在想要的数据集上进行训练。您还学会了如何使用管道使用训练好的模型。
概述
在本章中,我们讨论了如何对预训练模型进行微调以适用于任何令牌分类任务。我们探讨了在 NER 和 QA 问题上微调模型的方法。使用预训练和微调后的模型在特定任务中使用管道进行详细说明,并给出了示例。我们还了解了这两个任务的各种预处理步骤。保存在特定任务上微调的预训练模型是本章的另一个重点学习内容。我们还看到了如何将具有比模型输入更长序列大小的 QA 等任务的有限输入大小的模型进行训练的可能性。在本章中,更高效地使用标记器以具有文档间距和文档步幅的文档分割也是另一个重要内容。
在下一章中,我们将讨论使用 Transformer 进行文本表示的方法。通过学习本章,您将学习如何执行零/少量样本学习和语义文本聚类。
第七章:文本表示
到目前为止,我们已经使用transformers库解决了分类和生成问题。文本表示是现代自然语言处理(NLP)中的另一个关键任务,特别是对于无监督任务,如聚类、语义搜索和主题建模。通过使用诸如Universal Sentence Encoder(USE)和带有附加库(如句子转换器)的 Siamese BERT(Sentence-BERT)等各种模型来表示句子将在此处进行解释。还将解释使用 BART 进行零样本学习,并学习如何利用它。还将描述少样本学习方法和无监督使用案例,如语义文本聚类和主题建模。最后,将涵盖一次性学习用例,如语义搜索。
本章将涵盖以下主题:
-
句子嵌入简介
-
句子相似度模型的基准测试
-
使用 BART 进行零样本学习
-
使用 FLAIR 进行语义相似性实验
-
使用 Sentence-BERT 进行文本聚类
-
使用 Sentence-BERT 进行语义搜索
技术要求
我们将使用 Jupyter 笔记本来运行我们的编程练习。为此,您将需要 Python 3.6+和以下软件包:
-
sklearn -
transformers >=4.00 -
datasets -
sentence-transformers -
tensorflow-hub -
flair -
umap-learn -
bertopic
本章中编程练习的所有笔记本将在以下 GitHub 链接上提供:
github.com/PacktPublishing/Mastering-Transformers/tree/main/CH07
查看以下链接以查看代码演示视频:bit.ly/2VcMCyI
句子嵌入简介
预训练的 BERT 模型不能产生高效且独立的句子嵌入,因为它们始终需要在端到端的监督设置中进行微调。这是因为我们可以将预训练的 BERT 模型视为一个不可分割的整体,语义分布在所有层中,而不仅仅是最后一层。如果不进行微调,单独使用其内部表示可能是无效的。而且,难以处理无监督任务,如聚类、主题建模、信息检索或语义搜索。例如,在聚类任务中,我们必须评估许多句子对,这导致了巨大的计算开销。
幸运的是,对原始 BERT 模型进行了许多修改,如Sentence-BERT(SBERT),以生成语义有意义且独立的句子嵌入。我们将在接下来讨论这些方法。在自然语言处理文献中,提出了许多神经句子嵌入方法,用于将单个句子映射到一个公共特征空间(向量空间模型),其中通常使用余弦函数(或点积)来衡量相似度,欧氏距离用于衡量不相似度。
以下是一些可以通过句子嵌入有效解决的应用程序:
-
句子对任务
-
信息检索
-
问答
-
重复问题检测
-
释义检测
-
文档聚类
-
主题建模
最简单但最有效的神经句子嵌入操作是对句子中单词的嵌入进行平均池化。为了更好地表示这一点,一些早期的神经方法以无监督方式学习句子嵌入,例如 Doc2Vec、Skip-Thought、FastSent 和 Sent2Vec。Doc2Vec 利用了令牌级的分布理论和一个目标函数来预测相邻的单词,类似于 Word2Vec。该方法注入了一个额外的内存令牌(称为transformers库),这个额外的令牌充当了表示上下文或文档嵌入的一部分的内存。SkipThought 和 FastSent 被认为是句子级方法,其中目标函数用于预测相邻的句子。这些模型从相邻的句子及其上下文中提取句子的含义,以获取必要的信息。
一些其他方法,例如 InferSent,利用监督学习和多任务迁移学习来学习通用句子嵌入。InferSent 训练各种监督任务以获得更高效的嵌入。基于 RNN 的监督模型,如 GRU 或 LSTM,利用最后的隐藏状态(或堆叠的整个隐藏状态)在监督设置中获取句子嵌入。我们在第一章中涉及了 RNN 方法,从词袋模型到 Transformer。
交叉编码器与双编码器
到目前为止,我们已经讨论了如何训练基于 Transformer 的语言模型,并在半监督和监督环境中对其进行微调。正如我们在前几章中所学到的,多亏了 Transformer 架构,我们取得了成功的结果。一旦在预训练模型的顶部放置了特定于任务的稀疏线性层,在特定于任务的标记数据上对网络的所有权重进行了微调(不仅仅是最后一个特定于任务的稀疏层),我们也经历了 BERT 架构如何在不需要任何架构修改的情况下,对两个不同组的任务(单句或句对)进行微调。唯一的不同之处在于,对于句对任务,句子被连接并用 SEP 标记标记。因此,自注意力应用于连接句子的所有标记。这是 BERT 模型的一个巨大优势,即输入句子可以在每一层从彼此那里获取必要的信息。最终,它们同时被编码。这被称为交叉编码。
然而,关于交叉编码器存在两个缺点,SBERT 作者和Humeau 等人,2019 年已经解决了这些缺点,具体如下:
-
由于需要处理太多可能的组合,交叉编码器设置对许多句子对任务并不方便。例如,要从 1,000 个句子的列表中获取两个最接近的句子,交叉编码器模型(BERT)需要大约 500,000(
n(n-1)/2)个推断计算。因此,与 SBERT 或 USE 等替代方案相比,速度会非常慢。这是因为这些替代方案产生独立的句子嵌入,其中相似性函数(余弦相似性)或不相似性函数(欧氏或曼哈顿距离)可以轻松应用。请注意,这些相似性/不相似性函数可以在现代架构上有效执行。此外,借助优化的索引结构,我们可以将比较或聚类许多文档的计算复杂度从许多小时减少到几分钟。 -
由于其监督特性,BERT 模型无法推导出独立的有意义的句子嵌入。很难将预训练的 BERT 模型直接用于无监督任务,例如聚类、语义搜索或主题建模。BERT 模型为文档中的每个标记生成固定大小的向量。在无监督设置中,可以通过对标记向量进行平均或汇总,再加上 SEP 和 CLS 标记,来获得文档级表示。稍后,我们将看到 BERT 的这种表示产生的句子嵌入低于平均水平,并且其性能分数通常比 Word2Vec、FastText 或 GloVe 等词嵌入汇聚技术差。
或者,双编码器(如 SBERT)将一个句子对独立映射到语义向量空间,如下图所示。由于表示是分开的,双编码器可以为每个输入缓存编码的输入表示,从而实现快速推断时间。 BERT 的成功双编码器修改之一是 SBERT。基于孪生网络和三重网络结构,SBERT 微调 BERT 模型以产生语义上有意义且独立的句子嵌入。
以下图显示了双编码器架构:

图 7.1 - 双编码器架构
您可以在public.ukp.informatik.tu-darmstadt.de/reimers/sentence-transformers/v0.2/找到数百个已经通过不同目标训练的预训练 SBERT 模型。
我们将在下一节中使用其中一些。
对句子相似度模型进行基准测试。
有许多语义文本相似性模型可用,但强烈建议您使用度量标准对它们的能力和差异进行基准测试并加以理解。Papers With Code提供了这些数据集的列表,网址为paperswithcode.com/task/semantic-textual-similarity。
此外,在每个数据集中有许多模型输出,这些输出是按其结果排名的。这些结果是从上述文章中获取的。
GLUE 提供了大多数这些数据集和测试,但它不仅适用于语义文本相似性。GLUE,代表General Language Understanding Evaluation,是一个用于评估具有不同 NLP 特性的模型的通用基准。有关 GLUE 数据集及其用法的更多详细信息,请参阅第二章,主题的实际介绍。让我们在继续之前先看看它:
-
要从 GLUE 基准加载度量标准和 MRPC 数据集,您可以使用以下代码:
from datasets import load_metric, load_dataset metric = load_metric('glue', 'mrpc') mrpc = load_dataset('glue', 'mrpc')此数据集中的样本标记为
1和0,这表示它们是否相似或不相似。您可以使用任何模型,无论其体系结构如何,来为给定的两个句子生成值。换句话说,模型应将这两个句子分类为零和一。 -
假设模型产生值,并且这些值存储在一个名为
predictions的数组中。您可以轻松地使用这个度量标准与预测一起查看 F1 和准确度值:labels = [i['label'] for i in dataset['test']] metric.compute(predictions=predictions, references=labels) -
一些语义文本相似性数据集,如Semantic Textual Similarity Benchmark (STSB),具有不同的度量标准。例如,此基准使用 Spearman 和 Pearson 相关性,因为输出和预测值在 0 到 5 之间,并且是浮点数,而不是在 0 和 1 之间,这是一个回归问题。以下代码显示了此基准的一个示例:
metric = load_metric('glue', 'stsb') metric.compute(predictions=[1,2,3],references=[5,2,2])预测和参考与Microsoft Research Paraphrase Corpus (MRPC)中的相同;预测是模型的输出,而参考是数据集的标签。
-
为了得到两个模型之间的比较结果,我们将使用 RoBERTa 的精简版本,并在 STSB 上测试这两个模型。首先,您必须加载两个模型。以下代码显示了如何在加载和使用模型之前安装所需的库:
pip install tensorflow-hub pip install sentence-transformers -
正如我们之前提到的,下一步是加载数据集和度量标准:
from datasets import load_metric, load_dataset stsb_metric = load_metric('glue', 'stsb') stsb = load_dataset('glue', 'stsb') -
然后,我们必须加载两个模型:
import tensorflow_hub as hub use_model = hub.load( "https://tfhub.dev/google/universal-sentence-encoder/4") from sentence_transformers import SentenceTransformer distilroberta = SentenceTransformer( 'stsb-distilroberta-base-v2') -
这两个模型都为给定的句子提供嵌入。为了比较两个句子之间的相似性,我们将使用余弦相似度。以下函数以批量形式接受句子,并利用 USE 为每对句子提供余弦相似度:
import tensorflow as tf import math def use_sts_benchmark(batch): sts_encode1 = \ tf.nn.l2_normalize(use_model(tf.constant(batch['sentence1'])), axis=1) sts_encode2 = \ tf.nn.l2_normalize(use_model(tf.constant(batch['sentence2'])), axis=1) cosine_similarities = \ tf.reduce_sum(tf.multiply(sts_encode1,sts_encode2),axis=1) clip_cosine_similarities = \ tf.clip_by_value(cosine_similarities,-1.0, 1.0) scores = 1.0 - \ tf.acos(clip_cosine_similarities) / math.pi return scores -
通过小幅修改,相同的函数也可以用于 RoBERTa。这些小修改仅用于替换嵌入函数,该函数对于 TensorFlow Hub 模型和 transformers 是不同的。以下是修改后的函数:
def roberta_sts_benchmark(batch): sts_encode1 = \ tf.nn.l2_normalize(distilroberta.encode(batch['sentence1']), axis=1) sts_encode2 = \ tf.nn.l2_normalize(distilroberta.encode(batch['sentence2']), axis=1) cosine_similarities = \ tf.reduce_sum(tf.multiply(sts_encode1, sts_encode2), axis=1) clip_cosine_similarities = tf.clip_by_value(cosine_similarities, -1.0, 1.0) scores = 1.0 - tf.acos(clip_cosine_similarities) / math.pi return scores -
将这些函数应用于数据集将为每个模型生成相似性得分:
use_results = use_sts_benchmark(stsb['validation']) distilroberta_results = roberta_sts_benchmark( stsb['validation']) -
对两个结果使用度量标准会产生 Spearman 和 Pearson 相关值:
results = { "USE":stsb_metric.compute( predictions=use_results, references=references), "DistillRoberta":stsb_metric.compute( predictions=distilroberta_results, references=references) } -
您可以简单地使用 pandas 以对比的方式查看结果:
import pandas as pd pd.DataFrame(results)输出如下所示:

图 7.2 – DistilRoberta 和 USE 上的 STSB 验证结果
在本节中,你了解了语义文本相似性的重要基准。无论模型如何,你学会了如何使用这些度量标准之一来量化模型表现。在接下来的部分,你将了解几种少样本学习模型。
使用 BART 进行零样本学习
在机器学习领域,零样本学习指的是可以执行任务而无需明确训练的模型。在 NLP 的情况下,假设有一个模型可以预测一些文本被分配给模型给出的类别的概率。然而,这种学习方式的有趣之处在于模型并没有接受这些类别的训练。
随着许多可以进行迁移学习的高级语言模型的崛起,零样本学习应运而生。在 NLP 的情况下,这种学习是由 NLP 模型在测试时执行的,模型在那里看到属于新类别的样本,以前没有看到过这些样本。
这种学习通常用于分类任务,其中类别和文本都被表示,比较两者的语义相似性。这两者的表现形式是嵌入向量,而相似度度量(如余弦相似度或一个预训练分类器如一个稠密层)输出句子/文本被分类为类别的概率。
我们可以使用许多方法和方案来训练这些模型,但最早使用的方法之一是从包含在元部分中的关键字标签的互联网页面中提取。欲了解更多信息,请阅读以下文章和博文:amitness.com/2020/05/zero-shot-text-classification/。
而不是使用如此庞大的数据,有像 BART 这样使用多样式自然语言推理(MNLI)数据集对其进行微调并检测两个不同句子之间关系的语言模型。此外,HuggingFace 模型存储库包含许多为零样本学习实现的模型。他们还提供了一个零样本学习流水线,以方便使用。
例如,来自Facebook AI Research(FAIR)的 BART 正在以下代码中用于执行零样本文本分类:
from transformers import pipeline
import pandas as pd
classifier = pipeline("zero-shot-classification",
model="facebook/bart-large-mnli")
sequence_to_classify = "one day I will see the world"
candidate_labels = ['travel',
'cooking',
'dancing',
'exploration']
result = classifier(sequence_to_classify, candidate_labels)
pd.DataFrame(result)
结果如下:

图 7.3 – 使用 BART 进行零样本学习的结果
你可以看到,旅行和探索标签的概率最高,但最可能的是旅行。
然而,有时一个样本可能属于多个类别(多标签)。HuggingFace 为此提供了一个名为multi_label的参数。以下示例使用了这个参数:
result = classifier(sequence_to_classify,
candidate_labels,
multi_label=True)
Pd.DataFrame(result)
因此,它更改为以下内容:

图 7.4 – 使用 BART 进行零样本学习的结果(multi_label = True)
您可以进一步测试结果,看看模型在使用与旅行标签非常相似的标签时的表现。例如,您可以看看在标签列表中添加moving和going后,模型的表现如何。
还有其他模型也利用标签和上下文之间的语义相似性来进行零样本分类。在少样本学习的情况下,模型会给出一些样本,但这些样本不足以单独训练一个模型。模型可以利用这些样本来执行诸如语义文本聚类之类的任务,稍后将会解释。
现在您已经学会了如何使用 BART 进行零样本学习,您应该了解它的工作原理。例如,BART 是在旅行上进行了微调,并将第二个句子的内容(例如有一天我会看到世界)。根据这一点,如果这两个句子可以相互接续,那么这意味着标签和内容在语义上相关。以下的代码示例展示了如何直接使用 BART 模型,而不需要零样本分类的流程以前的描述:
from transformers \
import AutoModelForSequenceClassification,\
AutoTokenizer
nli_model = AutoModelForSequenceClassification\
.from_pretrained(
"facebook/bart-large-mnli")
tokenizer = AutoTokenizer\
.from_pretrained(
"facebook/bart-large-mnli")
premise = "one day I will see the world"
label = "travel"
hypothesis = f'This example is {label}.'
x = tokenizer.encode(
premise,
hypothesis,
return_tensors='pt',
truncation_strategy='only_first')
logits = nli_model(x)[0]
entail_contradiction_logits = logits[:,[0,2]]
probs = entail_contradiction_logits.softmax(dim=1)
prob_label_is_true = probs[:,1]
print(prob_label_is_true)
结果如下:
tensor([0.9945], grad_fn=<SelectBackward>)
您也可以将第一个句子称为假设,将包含标签的句子称为前提。根据结果,前提可以蕴涵假设,这意味着假设被标签为前提。
到目前为止,您已经学会了如何使用基于 NLI 微调模型的零样本学习。接下来,您将学习如何利用语义文本聚类和语义搜索来进行少样本/一样本学习。
使用 FLAIR 进行语义相似性实验
在这个实验中,我们将通过flair库对句子表示模型进行定性评估,这对我们来说真的简化了获取文档嵌入的过程。
我们将采用以下方法进行实验:
-
文档平均池嵌入
-
基于 RNN 的嵌入
-
BERT 嵌入
-
SBERT 嵌入
在开始实验之前,我们需要安装这些库:
!pip install sentence-transformers
!pip install dataset
!pip install flair
对于定性评估,我们定义了一组相似的句子对和一组不相似的句子对(每组各五对)。我们期望嵌入模型应该分别度量高分和低分。
句子对是从 SBS Benchmark 数据集中提取的,我们在第六章中已经熟悉了句对回归部分,用于令牌分类的语言模型微调。对于相似的句对,两个句子完全等价,并且它们分享相同的含义。
在 STSB 数据集中,随机抽取了相似分数约为 5 的对,如下所示:
import pandas as pd
similar=[
("A black dog walking beside a pool.",
"A black dog is walking along the side of a pool."),
("A blonde woman looks for medical supplies for work in a suitcase. ",
" The blond woman is searching for medical supplies in a suitcase."),
("A doubly decker red bus driving down the road.",
"A red double decker bus driving down a street."),
("There is a black dog jumping into a swimming pool.",
"A black dog is leaping into a swimming pool."),
("The man used a sword to slice a plastic bottle.",
"A man sliced a plastic bottle with a sword.")]
pd.DataFrame(similar, columns=["sen1", "sen2"])
输出如下:

图 7.5 – 相似对列表
这是来自 STS-B 数据集的相似度得分约为 0 的不相似句子列表:
import pandas as pd
dissimilar= [
("A little girl and boy are reading books. ",
"An older child is playing with a doll while gazing out the window."),
("Two horses standing in a field with trees in the background.",
"A black and white bird on a body of water with grass in the background."),
("Two people are walking by the ocean.",
"Two men in fleeces and hats looking at the camera."),
("A cat is pouncing on a trampoline.",
"A man is slicing a tomato."),
("A woman is riding on a horse.",
"A man is turning over tables in anger.")]
pd.DataFrame(dissimilar, columns=["sen1", "sen2"])
输出如下:

图 7.6 – 不相似对列表
现在,让我们准备好评估嵌入模型所需的函数。以下sim()函数计算两个句子之间的余弦相似度;即,s1,s2:
import torch, numpy as np
def sim(s1,s2):
s1=s1.embedding.unsqueeze(0)
s2=s2.embedding.unsqueeze(0)
sim=torch.cosine_similarity(s1,s2).item()
return np.round(sim,2)
在这个实验中使用的文档嵌入模型都是预训练模型。我们将文档嵌入模型对象和句子对列表(相似或不相似)传递给以下evaluate()函数,一旦模型编码了句子嵌入,它将计算列表中每对的相似度得分,以及列表的平均值。函数的定义如下:
from flair.data import Sentence
def evaluate(embeddings, myPairList):
scores=[]
for s1, s2 in myPairList:
s1,s2=Sentence(s1), Sentence(s2)
embeddings.embed(s1)
embeddings.embed(s2)
score=sim(s1,s2)
scores.append(score)
return scores, np.round(np.mean(scores),2)
现在,是时候评估句子嵌入模型了。我们将从平均池化方法开始!
平均词嵌入
平均词嵌入(或文档池化)对句子中的所有单词应用均值池化操作,其中所有单词嵌入的平均值被视为句子嵌入。以下执行实例化了基于 GloVe 向量的文档池嵌入。请注意,虽然我们这里只使用了 GloVe 向量,但 flair API 允许我们使用多个单词嵌入。以下是代码定义:
from flair.data import Sentence
from flair.embeddings\
import WordEmbeddings, DocumentPoolEmbeddings
glove_embedding = WordEmbeddings('glove')
glove_pool_embeddings = DocumentPoolEmbeddings(
[glove_embedding]
)
让我们评估 GloVe 池模型的相似对,如下所示:
>>> evaluate(glove_pool_embeddings, similar)
([0.97, 0.99, 0.97, 0.99, 0.98], 0.98)
结果似乎很好,因为那些得到的值非常高,这是我们期望的。然而,模型也产生了高得分,例如对于不相似列表的平均得分为 0.94。我们的期望值应该小于 0.4。我们稍后在本章将讨论为什么会得到这个值。以下是执行情况:
>>> evaluate(glove_pool_embeddings, dissimilar)
([0.94, 0.97, 0.94, 0.92, 0.93], 0.94)
接下来,让我们对同一问题评估一些 RNN 嵌入。
基于 RNN 的文档嵌入
让我们基于 GloVe 嵌入实例化一个 GRU 模型,默认的DocumentRNNEmbeddings模型是 GRU:
from flair.embeddings \
import WordEmbeddings, DocumentRNNEmbeddings
gru_embeddings = DocumentRNNEmbeddings([glove_embedding])
运行评估方法:
>>> evaluate(gru_embeddings, similar)
([0.99, 1.0, 0.94, 1.0, 0.92], 0.97)
>>> evaluate(gru_embeddings, dissimilar)
([0.86, 1.0, 0.91, 0.85, 0.9], 0.9)
同样,我们得到了不相似列表的高分。这并不是我们从句子嵌入中想要的。
基于 Transformer 的 BERT 嵌入
以下执行实例化了一个池化最终层的bert-base-uncased模型:
from flair.embeddings import TransformerDocumentEmbeddings
from flair.data import Sentence
bert_embeddings = TransformerDocumentEmbeddings(
'bert-base-uncased')
运行评估,如下所示:
>>> evaluate(bert_embeddings, similar)
([0.85, 0.9, 0.96, 0.91, 0.89], 0.9)
>>> evaluate(bert_embeddings, dissimilar)
([0.93, 0.94, 0.86, 0.93, 0.92], 0.92)
这更糟糕!不相似列表的得分高于相似列表的得分。
句子-BERT 嵌入
现在,让我们将 Sentence-BERT 应用于区分相似对和不相似对的问题,如下所示:
-
首先,警告:我们需要确保
sentence-transformers包已经被安装:!pip install sentence-transformers -
正如我们之前提到的,Sentence-BERT 提供了各种预训练模型。我们将选择
bert-base-nli-mean-tokens模型进行评估。以下是代码:from flair.data import Sentence from flair.embeddings \ import SentenceTransformerDocumentEmbeddings sbert_embeddings = SentenceTransformerDocumentEmbeddings( 'bert-base-nli-mean-tokens') -
让我们评估模型:
>>> evaluate(sbert_embeddings, similar) ([0.98, 0.95, 0.96, 0.99, 0.98], 0.97) >>> evaluate(sbert_embeddings, dissimilar) ([0.48, 0.41, 0.19, -0.05, 0.0], 0.21)干得好!SBERT 模型产生了更好的结果。模型为不相似列表产生了较低的相似度得分,这是我们所期望的。
-
现在,我们将进行一个更难的测试,我们将向模型传递相互矛盾的句子。我们将定义一些棘手的句子对,如下所示:
>>> tricky_pairs=[ ("An elephant is bigger than a lion", "A lion is bigger than an elephant") , ("the cat sat on the mat", "the mat sat on the cat")] >>> evaluate(glove_pool_embeddings, tricky_pairs) ([1.0, 1.0], 1.0) >>> evaluate(gru_embeddings, tricky_pairs) ([0.87, 0.65], 0.76) >>> evaluate(bert_embeddings, tricky_pairs) ([1.0, 0.98], 0.99) >>> evaluate(sbert_embeddings, tricky_pairs) ([0.93, 0.97], 0.95)有趣!分数非常高,因为句子相似性模型类似于主题检测,并且衡量内容相似性。当我们看句子时,它们分享相同的内容,尽管它们彼此矛盾。内容是关于狮子和大象或猫和垫子。因此,模型产生了高相似度分数。由于 GloVe 嵌入方法池化了单词的平均值而不关心单词顺序,它将两个句子视为相同。另一方面,GRU 模型产生了较低的值,因为它关心单词顺序。令人惊讶的是,即使是 SBERT 模型也没有产生有效的分数。这可能是由于 SBERT 模型中使用的基于内容相似性的监督。
-
要正确检测具有三个类别(即中性、矛盾和蕴含)的两个句子对的语义,我们必须在 MNLI 上使用一个经过微调的模型。以下代码块显示了一个示例,使用了在 XNLI 上进行了微调的 XLM-Roberta,使用相同的例子:
from transformers \ Import AutoModelForSequenceClassification, AutoTokenizer nli_model = AutoModelForSequenceClassification\ .from_pretrained( 'joeddav/xlm-roberta-large-xnli') tokenizer = AutoTokenizer\ .from_pretrained( 'joeddav/xlm-roberta-large-xnli') import numpy as np for permise, hypothesis in tricky_pairs: x = tokenizer.encode(premise, hypothesis, return_tensors='pt', truncation_strategy='only_first') logits = nli_model(x)[0] print(f"Permise: {permise}") print(f"Hypothesis: {hypothesis}") print("Top Class:") print(nli_model.config.id2label[np.argmax( logits[0].detach().numpy()). ]) print("Full softmax scores:") for i in range(3): print(nli_model.config.id2label[i], logits.softmax(dim=1)[0][i].detach().numpy()) print("="*20) -
输出将显示每个正确的标签:
Permise: An elephant is bigger than a lion Hypothesis: A lion is bigger than an elephant Top Class: contradiction Full softmax scores: contradiction 0.7731286 neutral 0.2203285 entailment 0.0065428796 ==================== Permise: the cat sat on the mat Hypothesis: the mat sat on the cat Top Class: entailment Full softmax scores: contradiction 0.49365467 neutral 0.007260764 entailment 0.49908453 ====================
在某些问题中,NLI 比语义文本更优先,因为它旨在找到矛盾或蕴含,而不是原始的相似度得分。对于下一个样本,同时使用两个句子进行蕴含和矛盾。这有点主观,但对于模型来说,第二个句子对似乎是在蕴含和矛盾之间的非常微妙的选择。
使用 Sentence-BERT 进行文本聚类
对于聚类算法,我们将需要一个适用于文本相似度的模型。让我们在这里使用paraphrase-distilroberta-base-v1模型进行变化。我们将首先加载亚马逊极性数据集进行我们的聚类实验。该数据集包括了从 18 年前到 2013 年 3 月期间的亚马逊网页评论。原始数据集包含超过 3500 万条评论。这些评论包括产品信息、用户信息、用户评分和用户评论。让我们开始吧:
-
首先,通过洗牌随机选择 10K 条评论,如下所示:
import pandas as pd, numpy as np import torch, os, scipy from datasets import load_dataset dataset = load_dataset("amazon_polarity",split="train") corpus=dataset.shuffle(seed=42)[:10000]['content'] -
现在语料库已准备好进行聚类。以下代码示例实例化了一个使用预训练的
paraphrase-distilroberta-base-v1模型的句子转换器对象:from sentence_transformers import SentenceTransformer model_path="paraphrase-distilroberta-base-v1" model = SentenceTransformer(model_path) -
使用以下执行对整个语料库进行编码,其中模型将一系列句子映射到一系列嵌入向量:
>>> corpus_embeddings = model.encode(corpus) >>> corpus_embeddings.shape (10000, 768) -
这里,向量大小为
768,这是 BERT-base 模型的默认嵌入大小。从现在开始,我们将继续使用传统的聚类方法。我们选择Kmeans,因为它是一种快速且广泛使用的聚类算法。我们只需要将聚类数目(K)设置为5。实际上,这个数目可能不是最优的。有许多技术可以确定最优的聚类数目,比如肘部法或轮廓法。然而,让我们把这些问题放在一边。以下是执行过程:>>> from sklearn.cluster import KMeans >>> K=5 >>> kmeans = KMeans( n_clusters=5, random_state=0).fit(corpus_embeddings) >>> cls_dist=pd.Series(kmeans.labels_).value_counts() >>> cls_dist 3 2772 4 2089 0 1911 2 1883 1 1345在这里,我们得到了五个评论的聚类。从输出中我们可以看到,我们有相当均匀的聚类。聚类的另一个问题是我们需要了解这些聚类意味着什么。作为一个建议,我们可以对每个聚类应用主题分析或检查基于聚类的 TF-IDF 来了解内容。现在,让我们基于聚类中心来看另一种做法。Kmeans 算法计算聚类中心,称为质心,它们保存在
kmeans.cluster_centers_属性中。质心只是每个聚类中向量的平均值。因此,它们都是虚拟点,不是现有的数据点。让我们假设距离质心最近的句子将是相应聚类的最具代表性的例子。 -
让我们尝试找到每个中心点最接近的一个真实句子嵌入。如果你愿意,你可以捕捉多于一个句子。以下是代码:
distances = \ scipy.spatial.distance.cdist(kmeans.cluster_centers_, corpus_embeddings) centers={} print("Cluster", "Size", "Center-idx", "Center-Example", sep="\t\t") for i,d in enumerate(distances): ind = np.argsort(d, axis=0)[0] centers[i]=ind print(i,cls_dist[i], ind, corpus[ind] ,sep="\t\t")输出如下:
![图 7.7 – 聚类中心]()
图 7.7 – 聚类中心
通过这些代表性句子,我们可以推断出聚类。看起来 Kmeans 将评论聚类成了五个不同的类别:电子产品、音频 CD/音乐、DVD 电影、书籍 和 家具与家居。现在,让我们在 2D 空间中可视化句子点和聚类中心。我们将使用均匀流形近似和投影(UMAP)库来降低维度。你还可以使用其他广泛使用的 NLP 降维技术,如 t-SNE 和 PCA(参见第一章,从词袋模型到Transformers)。
-
我们需要安装
umap库,如下所示:!pip install umap-learn -
以下执行将所有嵌入都降维并映射到 2D 空间:
import matplotlib.pyplot as plt import umap X = umap.UMAP( n_components=2, min_dist=0.0).fit_transform(corpus_embeddings) labels= kmeans.labels_fig, ax = plt.subplots(figsize=(12, 8)) plt.scatter(X[:,0], X[:,1], c=labels, s=1, cmap='Paired') for c in centers: plt.text(X[centers[c],0], X[centers[c], 1],"CLS-"+ str(c), fontsize=18) plt.colorbar()输出如下:

图 7.8 – 聚类点可视化
在前面的输出中,点根据其聚类成员资格和质心的颜色进行了着色。看起来我们选择了正确的聚类数目。
为了捕捉主题并解释聚类,我们简单地将句子(每个聚类一个句子)定位在聚类的中心附近。现在,让我们用主题建模的更准确方法来捕捉主题。
使用 BERTopic 进行主题建模
您可能熟悉许多用于从文档中提取主题的无监督主题建模技术;潜在狄利克雷分配 (LDA) 主题建模和非负矩阵分解 (NMF) 是文献中广泛应用的传统技术。BERTopic 和 Top2Vec 是两个重要的基于转换器的主题建模项目。在本节中,我们将把 BERTopic 模型应用到我们的亚马逊语料库中。它利用了 BERT 嵌入和基于类的 TF-IDF 方法,以获取易于解释的主题。
首先,BERTopic 模型通过使用句子转换器或任何句子嵌入模型对句子进行编码,然后进行聚类步骤。聚类步骤分为两个阶段:首先通过UMAP减少了嵌入的维度,然后通过Hierarchical Density-Based Spatial Clustering of Applications with Noise (HDBSCAN)对减少的向量进行了聚类,从而得到了相似文档的分组。在最后阶段,通过每个聚类的 TF-IDF 来捕获主题,模型提取了每个聚类的最重要单词,而不是每个文档,并为每个聚类获取主题的描述。让我们开始吧:
-
首先,让我们安装必要的库,如下所示:
!pip install bertopic重要提示
您可能需要重新启动运行时,因为此安装将更新一些已加载的包。因此,从 Jupyter 笔记本中,转到运行时 | 重新启动运行时。
-
如果您想使用自己的嵌入模型,您需要实例化并将其传递给 BERTopic 模型。我们将实例化一个句子转换器模型,并将其传递给 BERTopic 的构造函数,如下所示:
from bertopic import BERTopic sentence_model = SentenceTransformer( "paraphrase-distilroberta-base-v1") topic_model = BERTopic(embedding_model=sentence_model) topics, _ = topic_model.fit_transform(corpus) topic_model.get_topic_info()[:6]输出如下:

图 7.9 – BERTopic 结果
请注意,使用相同参数的不同 BERTopic 运行可能会产生不同的结果,因为 UMAP 模型是随机的。现在,让我们看看第五个主题的词分布,如下所示:
topic_model.get_topic(5)
输出如下:

图 7.10 – 主题模型的第五个主题词
主题词是那些在语义空间中与主题向量接近的词语。在这个实验中,我们没有对语料库进行聚类,而是将这种技术应用到整个语料库中。在我们之前的例子中,我们分析了最接近的句子的聚类。现在,我们可以通过将主题模型分别应用到每个聚类中来找到主题。这非常简单,您可以自己运行它。
有关更多详细信息和有趣的主题建模应用,请参阅 Top2Vec 项目github.com/ddangelov/Top2Vec。
使用 Sentence-BERT 进行语义搜索
我们可能已经熟悉基于关键字的搜索(布尔模型),在这种模型中,对于给定的关键字或模式,我们可以检索与模式匹配的结果。或者,我们可以使用正则表达式,我们可以定义高级模式,例如词法-句法模式。这些传统方法无法处理同义词(例如,car 与 automobile 相同)或词义问题(例如,bank 是指河流的一侧还是金融机构)。虽然第一个同义词情况由于漏掉了不应错过的文件而导致低召回率,但第二个情况由于捕获了不应捕获的文件而导致低精度。基于向量或语义的搜索方法可以通过构建查询和文档的密集数值表示来克服这些缺点。
让我们为常见问题(FAQs)建立一个案例研究,这些问题在网站上处于闲置状态。我们将利用语义搜索问题内的常见问题资源。常见问题包含经常被问到的问题。我们将使用来自世界自然基金会(WWF)的常见问题,这是一个自然非政府组织(www.wwf.org.uk/)。
给定这些描述,很容易理解使用语义模型执行语义搜索与一次性学习问题非常相似,其中我们只有一个类别的一次性学习(一个样本),并且我们希望根据它重新排序其余的数据(句子)。您可以重新定义问题,即根据给定样本搜索与给定样本在语义上接近的样本,或者根据样本进行二元分类。您的模型可以提供相似度度量,并且将使用此度量对所有其他样本进行重新排序。最终的有序列表是搜索结果,根据语义表示和相似度度量进行重新排序。
WWF 在他们的网页上有 18 个问题和答案。我们将它们定义为 Python 列表对象,称为 wf_faq,用于此实验:
-
我还没有收到我的领养包裹。我该怎么办?
-
我将多快收到我的领养包裹?
-
我该如何续订我的领养?
-
我该如何更改我的地址或其他联系方式?
-
如果我不住在英国,我可以领养一只动物吗?
-
如果我领养了一只动物,我会是唯一领养该动物的人吗?
-
我的包裹中没有包含证书?
-
我的领养是一份礼物,但不会准时送达。我该怎么办?
-
我可以用一次性付款支付领养费用吗?
-
在下订单后,我可以更改领养包裹的交付地址吗?
-
我的领养将持续多久?
-
我将多久收到有关我所领养动物的更新?
-
你们有哪些动物可以领养?
-
如何查找更多关于我所领养动物的信息?
-
我的领养费用如何使用?
-
你们的退款政策是什么?
-
我的直接付款出现了错误;我可以收到退款吗?
-
我该如何更改你们与我联系的方式?
用户可以自由提出任何问题。我们需要评估 FAQ 中哪个问题与用户的问题最相似,这是quora-distilbert-base模型的目标。SBERT hub 中有两个选项 - 一个用于英语,另一个用于多语言,如下所示:
-
quora-distilbert-base:这是为 Quora 重复问题检测检索而微调的。 -
quora-distilbert-multilingual:这是quora-distilbert-base的多语言版本。它使用 50 多种语言的平行数据进行微调。
让我们按照以下步骤构建一个语义搜索模型:
-
以下是 SBERT 模型的实例化:
from sentence_transformers import SentenceTransformer model = SentenceTransformer('quora-distilbert-base') -
让我们对 FAQ 进行编码,如下所示:
faq_embeddings = model.encode(wwf_faq) -
让我们准备五个问题,使它们分别与常见问题解答中的前五个问题相似;也就是说,我们的第一个测试问题应该与常见问题解答中的第一个问题相似,第二个问题应该与第二个问题相似,依此类推,这样我们就可以轻松地跟踪结果。让我们将问题定义在
test_questions列表对象中并对其进行编码,如下所示:test_questions=["What should be done, if the adoption pack did not reach to me?", " How fast is my adoption pack delivered to me?", "What should I do to renew my adoption?", "What should be done to change address and contact details ?", "I live outside of the UK, Can I still adopt an animal?"] test_q_emb= model.encode(test_questions) -
以下代码测量每个测试问题与常见问题解答中每个问题之间的相似度,然后对它们进行排名:
from scipy.spatial.distance import cdist for q, qe in zip(test_questions, test_q_emb): distances = cdist([qe], faq_embeddings, "cosine")[0] ind = np.argsort(distances, axis=0)[:3] print("\n Test Question: \n "+q) for i,(dis,text) in enumerate( zip( distances[ind], [wwf_faq[i] for i in ind])): print(dis,ind[i],text, sep="\t")输出如下所示:
![图 7.11 – 问题-问题相似度]()
图 7.11 – 问题-问题相似度
在这里,我们可以看到按顺序的索引
0、1、2、3和4,这意味着模型成功地找到了预期的相似问题。 -
对于部署,我们可以设计以下
getBest()函数,它接受一个问题并返回 FAQ 中最相似的K个问题:def get_best(query, K=5): query_emb = model.encode([query]) distances = cdist(query_emb,faq_embeddings,"cosine")[0] ind = np.argsort(distances, axis=0) print("\n"+query) for c,i in list(zip(distances[ind], ind))[:K]: print(c,wwf_faq[i], sep="\t") -
让我们提出一个问题:
get_best("How do I change my contact info?",3)输出如下所示:
![图 7.12 – 相似问题的相似度结果]()
图 7.12 – 相似问题的相似度结果
-
如果输入的问题与常见问题解答中的问题不相似怎么办?以下是这样一个问题:
get_best("How do I get my plane ticket \ if I bought it online?")输出如下所示:

图 7.13 – 不相似问题的相似度结果
最佳不相似度分数为 0.35。因此,我们需要定义一个阈值,例如 0.3,以便模型忽略高于该阈值的问题,并显示未找到相似答案。
除了问题-问题对称搜索相似度之外,我们还可以利用 SBERT 的问题-答案不对称搜索模型,例如msmarco-distilbert-base-v3,它是在大约 50 万个 Bing 搜索查询数据集上训练的。它被称为 MSMARCO Passage Ranking。该模型帮助我们衡量问题和上下文的相关性,并检查答案是否在段落中。
总结
在本章中,我们学习了关于文本表示方法的知识。我们学习了如何使用不同和多样的语义模型执行零/少/一次学习等任务。我们还学习了关于 NLI 及其在捕获文本语义方面的重要性。此外,我们还研究了一些有用的用例,如基于 Transformer 的语义模型进行语义搜索、语义聚类和主题建模。我们学习了如何可视化聚类结果,并了解了在此类问题中中心点的重要性。
在下一章中,您将学习关于高效 Transformer 模型的知识。您将学习有关蒸馏、修剪和量化基于 Transformer 的模型的知识。您还将学习有关不同和高效的 Transformer 架构,这些架构改进了计算和内存效率,并学习如何在 NLP 问题中使用它们。
进一步阅读
请参阅本章中涉及的以下作品/论文,以获取有关涉及主题的更多信息:
-
Lewis, M., Liu, Y., Goyal, N., Ghazvininejad, M., Mohamed, A., Levy, O., ... & Zettlemoyer, L. (2019). Bart:用于自然语言生成、翻译和理解的去噪序列到序列预训练。arXiv 预印本 arXiv:1910.13461。
-
Pushp, P. K., & Srivastava, M. M. (2017). 一次训练,随处测试:用于文本分类的零样本学习。arXiv 预印本 arXiv:1712.05972。
-
Reimers, N., & Gurevych, I. (2019). Sentence-bert:使用孪生 BERT 网络的句子嵌入。arXiv 预印本 arXiv:1908.10084。
-
Liu, Y., Ott, M., Goyal, N., Du, J., Joshi, M., Chen, D., ... & Stoyanov, V. (2019). Roberta:一个鲁棒优化的 BERT 预训练方法。arXiv 预印本 arXiv:1907.11692。
-
Williams, A., Nangia, N., & Bowman, S. R. (2017). 用于通过推理理解句子的广覆盖挑战语料库。arXiv 预印本 arXiv:1704.05426。
-
Cer, D., Yang, Y., Kong, S. Y., Hua, N., Limtiaco, N., John, R. S., ... & Kurzweil, R. (2018). 通用句子编码器。arXiv 预印本 arXiv:1803.11175。
-
Yang, Y., Cer, D., Ahmad, A., Guo, M., Law, J., Constant, N., ... & Kurzweil, R. (2019). 用于语义检索的多语言通用句子编码器。arXiv 预印本 arXiv:1907.04307。
-
Humeau, S., Shuster, K., Lachaux, M. A., & Weston, J. (2019). Poly-encoders:用于快速和准确的多句子评分的 Transformer 架构和预训练策略。arXiv 预印本 arXiv:1905.01969。
第三部分:高级主题
完成本节后,您将获得如何在有限的计算能力下训练长上下文 NLP 任务等具有挑战性的问题的高效模型的经验,以及如何处理多语言和跨语言语言建模。您将了解监控模型内部部分以进行解释和解释,并跟踪您的模型训练性能所需的工具。您还将能够在真实生产环境中提供模型服务。
本节包括以下章节:
-
第八章, 使用高效 Transformer
-
第九章, 跨语言和多语言语言建模
-
第十章, 为 Transformer 模型提供服务
-
第十一章, 注意力可视化和实验跟踪
第八章:使用高效的Transformers
到目前为止,您已经学会了如何设计自然语言处理(NLP)架构,以实现使用Transformers的成功任务执行。在本章中,您将学习如何使用蒸馏、修剪和量化将训练模型变为高效的模型。其次,您还将了解到关于高效稀疏Transformers的知识,如 Linformer、BigBird、Performer 等。您将看到它们在各种基准测试中的表现,例如内存与序列长度和速度与序列长度的比较。您还将看到模型尺寸缩减的实际用途。
随着在有限的计算能力下运行大型神经模型变得困难,本章的重要性凸显出来。拥有像 DistilBERT 这样的轻量级通用语言模型是很重要的。然后可以像其未蒸馏的对应物一样对其进行微调以获得良好的性能。基于Transformers的架构由于Transformers中注意力点积的二次复杂度而面临复杂性瓶颈,尤其是对于长上下文 NLP 任务。字符级语言模型、语音处理和长文档是长上下文问题的一部分。近年来,我们已经看到了使自注意更加高效的许多进展,例如 Reformer、Performer 和 BigBird。
简而言之,在本章中,您将学习以下主题:
-
介绍高效、轻量和快速的Transformers
-
用于模型尺寸缩减的实施
-
使用高效的自注意力
技术要求
我们将使用 Jupyter Notebook 运行我们的编码练习,需要 Python 3.6+,并且需要安装以下软件包:
-
TensorFlow
-
PyTorch
-
Transformers >=4.00
-
数据集
-
句子Transformers
-
py3nvml
所有包含编码练习的笔记本都可以在以下 GitHub 链接中找到:
github.com/PacktPublishing/Mastering-Transformers/tree/main/CH08
查看以下链接以查看代码演示视频:
介绍高效、轻量和快速的Transformers
基于Transformers的模型在许多 NLP 问题上已经明显取得了最先进的结果,但代价是二次内存和计算复杂度。我们可以总结如下有关复杂性的问题:
-
由于自注意机制的存在,模型无法有效地处理长序列,这是因为其随序列长度呈二次方增长。
-
通过使用典型 GPU 进行的实验设置,可以处理包含 512 个标记的句子进行训练和推断。然而,较长的条目可能会引起问题。
-
NLP 模型从 BERT-base 的 1.1 亿参数增长到 Turing-NLG 的 170 亿参数,再到 GPT-3 的 1750 亿参数。这一概念引起了人们对计算和内存复杂性的担忧。
-
我们还需要关注成本、生产、可复制性和可持续性。因此,我们需要更快、更轻的转换器,特别是在边缘设备上。
已经提出了几种方法来减少计算复杂性和内存占用。其中一些方法侧重于改变体系结构,而其他一些方法不改变原始体系结构,而是改进已训练模型或训练阶段。我们将它们分为两组,模型大小缩减和高效自注意力。
可以使用三种不同的方法来实现模型大小缩减:
-
知识蒸馏
-
剪枝
-
量化
这三个方法都有各自的方式来缩小模型的大小,我们将在 模型大小缩减的实现 部分进行简要描述。
在知识蒸馏中,较小的转换器(学生)可以传输大型模型(教师)的知识。我们训练学生模型,使其能够模仿教师的行为或对相同的输入产生相同的输出。蒸馏模型可能性能不如教师模型。压缩、速度和性能之间存在权衡。
剪枝是机器学习中用于通过删除对产生结果的贡献较小的模型部分来减小模型尺寸的模型压缩技术。最典型的例子是决策树剪枝,它有助于减少模型复杂性并增加模型的泛化能力。量化将模型权重类型从较高分辨率更改为较低分辨率。例如,我们使用典型的浮点数(float64),每个权重占用 64 位内存。相反,我们可以在量化中使用 int8,每个权重占用 8 位内存,并且在表示数字时自然精度较低。
自注意力头不适用于长序列。为了解决这个问题,已经提出了许多不同的方法。最有效的方法是自注意力稀疏化,我们将很快讨论。另一个最常用的方法是内存高效的反向传播。该方法在缓存中间结果和重新计算之间平衡了权衡。在正向传播期间计算的中间激活在反向传播期间需要用来计算梯度。梯度检查点可以减少内存占用和计算量。另一种方法是管道并行算法。小批量被分成微批量,并行管道利用了正向和反向操作期间的等待时间,同时将批量传输到 GPU 或 TPU 等深度学习加速器中。
参数共享可以被看作是朝向高效深度学习的第一种方法之一。 最典型的例子是循环神经网络(RNN),如第一章中所述,从词袋模型到 Transformer,在展开表示的单元中使用了共享参数。 因此,可训练参数的数量不受输入大小的影响。 一些共享的参数,也称为权重绑定或权重复制,会扩展网络,以减少可训练参数的数量。 例如,Linformer 在头和层之间共享投影矩阵。 Reformer 通过牺牲性能来共享查询和键。
现在让我们试着用相应的实际例子来理解这些问题。
模型大小缩减的实现
尽管基于 Transformer 的模型在 NLP 许多方面取得了最先进的成果,它们通常共享同样的问题:它们是庞大的模型,速度不够快无法使用。 在业务案例中,如果需要将它们嵌入到移动应用程序或 Web 界面中,如果尝试使用原始模型,似乎是不可能的。
为了提高这些模型的速度和大小,提出了一些技术,列举如下:
-
蒸馏(又称为知识蒸馏)
-
精简
-
量化
对于每种技术,我们提供一个单独的小节来解决技术和理论洞察。
使用 DistilBERT 进行知识蒸馏
从一个更大的模型向一个更小的模型转移知识的过程称为知识蒸馏。 换句话说,有一个老师模型和一个学生模型;老师通常是一个更大更强大的模型,而学生则更小更弱。
这种技术被用于各种问题,从视觉到声学模型和自然语言处理。 这种技术的典型实现如图 8.1所示:

图 8.1 - 用于图像分类的知识蒸馏
DistilBERT 是这一领域最重要的模型之一,引起了研究者甚至企业的关注。 这个模型试图模仿 BERT-Base 的行为,参数少了 50%,但实现了老师模型 95%的性能。
细节如下:
-
DistilBert 压缩了 1.7 倍,速度提高了 1.6 倍,相对性能提高了 97%(与原始 BERT 相比)。
-
Mini-BERT 压缩了 6 倍,速度提高了 3 倍,相对性能提高了 98%。
-
TinyBERT 压缩了 7.5 倍,速度提高了 9.4 倍,相对性能提高了 97%。
用于训练模型的蒸馏训练步骤在 PyTorch 中非常简单(原始描述和代码可在medium.com/huggingface/distilbert-8cf3380435b5找到):
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Optimizer
KD_loss = nn.KLDivLoss(reduction='batchmean')
def kd_step(teacher: nn.Module,
student: nn.Module,
temperature: float,
inputs: torch.tensor,
optimizer: Optimizer):
teacher.eval()
student.train()
with torch.no_grad():
logits_t = teacher(inputs=inputs)
logits_s = student(inputs=inputs)
loss = KD_loss(input=F.log_softmax(
logits_s/temperature,
dim=-1),
target=F.softmax(
logits_t/temperature,
dim=-1))
loss.backward()
optimizer.step()
optimizer.zero_grad()
这种模型监督训练为我们提供了一个行为非常类似于基础模型的较小模型。然而,这里使用的损失函数是Kullback-Leibler损失,以确保学生模型模仿了老师模型的好坏方面,并且对最后 softmax logits 的决策没有修改。这个损失函数显示了两个分布之间的不同程度;差异越大,损失值越高。使用这个损失函数的原因是使学生模型尽可能地模仿老师的行为。BERT 和 DistilBERT 的 GLUE 宏分数只相差 2.8%。
精简Transformers
精简包括根据预先指定的标准在每一层上将权重设置为零的过程。例如,一个简单的精简算法可以获取每层的权重并将低于阈值的权重设置为零。这种方法消除了值非常低且不会对结果产生太大影响的权重。
同样地,我们还精简了Transformers网络的一些多余部分。精简后的网络更有可能比原始网络更好地泛化。我们看到了成功的精简操作,因为精简过程可能保留了真实的潜在解释因素并且丢弃了多余的子网络。但是我们仍然需要训练一个大型网络。合理的策略是尽可能地训练一个大型神经网络。然后,丢弃一些不太明显的权重或单元,这些权重或单元的移除对模型性能的影响很小。
有两种方法:
-
非结构化精简:不管它们位于神经网络的哪个部分,都移除具有较小显著性(或最小权重幅度)的个别权重。
-
结构化精简:此方法精简头部或层。
然而,精简过程必须与现代 GPU 兼容。
大多数库,如 Torch 或 TensorFlow,都具有此功能。我们将描述如何使用 Torch 对模型进行精简。有许多不同的精简方法(基于幅度或基于互信息)。其中一个最容易理解和实现的方法是 L1 精简方法。此方法获取每一层的权重并将具有最低 L1 范数的权重置为零。您还可以指定在精简后必须将多少百分比的权重转换为零。为了使这个示例更容易理解并展示它对模型的影响,我们将使用 第七章 中的文本表示示例。我们将精简模型并查看精简后的表现:
-
我们将使用 Roberta 模型。您可以使用以下代码加载模型:
from sentence_transformers import SentenceTransformer distilroberta = SentenceTransformer('stsb-distilroberta-base-v2') -
您还需要加载指标和数据集进行评估:
from datasets import load_metric, load_dataset stsb_metric = load_metric('glue', 'stsb') stsb = load_dataset('glue', 'stsb') mrpc_metric = load_metric('glue', 'mrpc') mrpc = load_dataset('glue','mrpc') -
为了评估模型,就像在 第七章 中,文本表示,您可以使用以下函数:
import math import tensorflow as tf def roberta_sts_benchmark(batch): sts_encode1 = tf.nn.l2_normalize( distilroberta.encode(batch['sentence1']), axis=1) sts_encode2 = tf.nn.l2_normalize( distilroberta.encode(batch['sentence2']), axis=1) cosine_similarities = tf.reduce_sum( tf.multiply(sts_encode1, sts_encode2), axis=1) clip_cosine_similarities = tf.clip_by_value(cosine_similarities,-1.0,1.0) scores = 1.0 -\ tf.acos(clip_cosine_similarities) / math.pi return scores -
当然,还必须设置标签:
references = stsb['validation'][:]['label'] -
并且运行基础模型而不对其进行任何更改:
distilroberta_results = roberta_sts_benchmark(stsb['validation']) -
在所有这些事情完成之后,这是我们实际开始修剪模型的步骤:
from torch.nn.utils import prune pruner = prune.L1Unstructured(amount=0.2) -
上述代码使用每层 20%的 L1 范数修剪创建了一个修剪对象。要将其应用于模型,可以使用以下代码:
state_dict = distilroberta.state_dict() for key in state_dict.keys(): if "weight" in key: state_dict[key] = pruner.prune(state_dict[key])它将迭代地修剪所有具有权重名称的层;换句话说,我们将修剪所有重量层,而不触及有偏差的层。当然,您也可以出于实验目的尝试这样做。
-
再次加载状态字典到模型中是很有必要的:
distilroberta.load_state_dict(state_dict) -
现在我们已经完成了所有事情,可以测试新模型:
distilroberta_results_p = roberta_sts_benchmark(stsb['validation']) -
为了对结果进行良好的可视化表示,可以使用以下代码:
import pandas as pd pd.DataFrame({ "DistillRoberta":stsb_metric.compute(predictions=distilroberta_results, references=references), "DistillRobertaPruned":stsb_metric.compute(predictions=distilroberta_results_p, references=references) })以下截图显示了结果:

图 8.2 - 原始模型和修剪模型的比较
但你所做的是,你消除了模型 20%的所有权重,减少了它的大小和计算成本,并且性能下降了 4%。但是,这一步骤可以与量化等其他技术结合使用,在下一小节中进行探索。
这种修剪类型应用于层中的一些权重;但是,也有可能完全丢弃某些部分或层的Transformers架构,例如,可以丢弃一部分关注头,并跟踪更改。
PyTorch 还提供了其他类型的修剪算法,例如迭代和全局修剪,值得一试。
量化
量化是一种信号处理和通信术语,通常用于强调所提供的数据的准确度。更多的位数意味着数据分辨率方面的更高准确度和精度。例如,如果您有一个用 4 位表示的变量,并且您想将其量化为 2 位,这意味着您需要降低分辨率的准确度。使用 4 位,您可以指定 16 个不同的状态,而使用 2 位,您只能区分 4 个状态。换句话说,通过将数据的分辨率从 4 位降低到 2 位,您可以节省 50%的空间和复杂度。
许多流行的库,例如 TensorFlow,PyTorch 和 MXNET,都支持混合精度运算。回想一下第五章中TrainingArguments类中使用的fp16参数。fP16可以提高计算效率,因为现代 GPU 对降低精度的数学运算提供了更高的效率,但结果是在fP32中累积。混合精度可以减少训练所需的内存使用,从而允许我们增加批处理大小或模型大小。
量化可以应用于模型权重,以减少其分辨率并节省计算时间,内存和存储空间。在本小节中,我们将尝试为我们在上一小节中修剪的模型进行量化:
-
为此,使用以下代码以 8 位整数表示量化模型,而不是浮点数:
import torch distilroberta = torch.quantization.quantize_dynamic( model=distilroberta, qconfig_spec = { torch.nn.Linear : torch.quantization.default_dynamic_qconfig, }, dtype=torch.qint8) -
然后,使用以下代码获得评估结果:
distilroberta_results_pq = roberta_sts_benchmark(stsb['validation']) -
而且,你可以看到结果:
pd.DataFrame({ "DistillRoberta":stsb_metric.compute(predictions=distilroberta_results, references=references), "DistillRobertaPruned":stsb_metric.compute(predictions=distilroberta_results_p, references=references), "DistillRobertaPrunedQINT8":stsb_metric.compute(predictions=distilroberta_results_pq, references=references) })结果如下:
![图 8.3 - 原始模型、修剪模型和量化模型的比较]()
图 8.3 - 原始模型、修剪模型和量化模型的比较
-
到目前为止,你只是使用了一个经蒸馏的模型,对其进行了修剪,然后对其进行了量化,以减少其大小和复杂性。让我们看看通过保存模型你节省了多少空间:
distilroberta.save("model_pq")为了查看模型大小,使用以下代码:
ls model_pq/0_Transformer/ -l --block-size=M | grep pytorch_model.bin -rw-r--r-- 1 root 191M May 23 14:53 pytorch_model.bin如你所见,它是 191MB。模型的初始大小为 313MB,这意味着我们设法将模型的大小减小到其原始大小的 61%,并且在性能方面只损失了 6%-6.5%。请注意,
block-size参数可能在 Mac 上失败,必须使用-lh。
直到这一点,你已经了解了在工业使用中实际模型准备方面的修剪和量化。然而,你也获得了关于蒸馏过程及其如何有用的信息。有许多其他方法可以进行修剪和量化,在阅读本节之后可以迈出的良好一步。有关更多信息和指南,你可以查看github.com/huggingface/block_movement_pruning的运动修剪。这种修剪是一种简单且确定性的一阶权重修剪方法。它利用训练中的权重变化来找出哪些权重更有可能未被使用以减少对结果的影响。
使用高效的自注意力
高效的方法限制了注意机制以实现有效的Transformers模型,因为Transformers的计算和存储复杂度大部分都是由自注意机制导致的。关于输入序列长度的注意机制以二次方式进行缩放。对于短输入,二次复杂度可能不是一个问题。但是,要处理更长的文件,我们需要改进能够与序列长度线性缩放的注意机制。
我们大致可以将高效的注意力解决方案分为三种类型:
-
使用固定模式的稀疏注意力
-
可学习的稀疏模式
-
低秩因式分解/核函数
接下来,让我们以基于固定模式的稀疏注意力开始。
使用固定模式的稀疏注意力
回想一下,注意力机制由查询、键和值组成,可能如此粗略地表述:

在这里,Score函数,大多数情况下是 softmax,执行 QKT 乘法,需要 O(n2)的内存和计算复杂度,因为一个标记位置在完全自注意力模式下会关注所有其他标记位置以构建其位置嵌入。我们对所有标记位置重复相同的过程以获取它们的嵌入,从而导致了二次复杂性问题。这是一种非常昂贵的学习方式,特别是对于长文本 NLP 问题。自然而然地会问,我们是否需要如此密集的交互,或者是否有更廉价的方法来进行计算?许多研究人员已经解决了这个问题,并采用了各种技术来缓解复杂性负担,并降低自注意机制的二次复杂性。他们在性能、计算和内存之间进行了权衡,特别是对于长文档。
减少复杂性的最简单方法是使完全自注意力矩阵稀疏化,或者找到另一种更廉价的方式来近似完全注意力。稀疏注意力模式制定了如何在不干扰层间信息流的情况下连接/断开某些位置,这有助于模型跟踪长期依赖关系并构建句子级编码。
完全自注意力和稀疏注意力依次在图 8.4中描述,其中行对应输出位置,列对应输入位置。完全自注意力模型会直接在任意两个位置之间传递信息。另一方面,在局部滑动窗口注意力中,也就是稀疏注意力,如图右侧所示,空白单元格意味着相应的输入-输出位置之间没有交互。图中的稀疏模型基于特定手动设计的规则,也就是固定模式。更具体地说,它是局部滑动窗口注意力,是最早提出的方法之一,也被称为基于本地固定模式的方法。其背后的假设是有用的信息位于每个位置的相邻位置。每个查询标记都会关注到其位置左侧和右侧窗口/2 个关键标记。在下面的示例中,窗口大小选为 4。这个规则在 transformer 的每一层中都适用。在一些研究中,随着向更深层移动,窗口大小会增加。
以下图简要描述了完全注意力和稀疏注意力之间的区别:

图 8.4 - 完全注意力与稀疏注意力
在稀疏模式下,信息通过模型中的连接节点(非空单元格)传输。例如,稀疏注意力矩阵的输出位置 7 不能直接关注输入位置 3(请参见Figure 8.4右侧的稀疏矩阵),因为单元格(7,3)被视为空。但是,位置 7 间接关注位置 3 通过标记位置 5,即(7->5, 5->3 => 7->3)。该图还说明了,虽然全自注意会产生 n2 个活动单元格(顶点),但稀疏模型大致为5×n。
另一个重要类型是全局注意力。少量选定的标记或少量注入的标记被用作全局注意力,可以关注所有其他位置,并被它们关注。因此,任意两个标记位置之间的最大路径距离等于 2。假设我们有一个句子[GLB, the, cat, is, very, sad],其中Global(GLB)是一个注入的全局标记,窗口大小为 2,这意味着一个标记只能关注其直接的左右标记以及 GLB。 cat 到 sad 之间没有直接交互。但我们可以遵循 cat-> GLB, GLB-> sad 交互,这通过 GLB 标记创建了一个超链接。全局标记可以从现有标记中选择或像(CLS)那样添加。如下截图所示,前两个标记位置被选为全局标记:

图 8.5 – 全局注意力
顺便说一句,这些全局标记也不必在句子开头。例如,longformer 模型除了前两个标记外,还会随机选择全局标记。
有四种更常见的模式。随机注意力(Figure 8.6中的第一个矩阵)用于通过从现有标记中随机选择来促进信息流动。但大多数情况下,我们将随机注意力作为组合模式(左下角矩阵)的一部分,该模式由其他模型的组合组成。扩张注意力类似于滑动窗口,但在窗口中加入了一些间隙,如Figure 8.6右上方所示:

图 8.6 – 随机、扩张、组合和分块
分块模式(Figure 8.6右下角)为其他模式提供了基础。它将标记分块成固定数量的块,这对于长文本问题特别有用。例如,当使用块大小为 512 来分块 4096x4096 的注意力矩阵时,就形成了 8 个(512x512)查询块和键块。许多高效的模型,如 BigBird 和 Reformer,大多数将标记分块以减少复杂性。
需要注意的是,提出的模式必须得到加速器和库的支持。一些注意力模式,如扩张模式,需要特殊的矩阵乘法,在撰写本章时,当前的深度学习库,如 PyTorch 或 TensorFlow,不直接支持。
我们已经准备好进行一些高效 transformer 的实验。我们将使用 Transformers 库支持的模型,并具有 HuggingFace 平台上的检查点。Longformer是使用稀疏注意力的模型之一。它使用滑动窗口和全局注意力的组合。它还支持扩张的滑动窗口注意力:
-
在开始之前,我们需要安装
py3nvml包进行基准测试。请记住,我们已经讨论过如何在第二章,对主题的实际介绍中应用基准测试:!pip install py3nvml -
我们还需要检查我们的设备,以确保没有正在运行的进程:
!nvidia-smi输出如下:
![图 8.7 – GPU 使用情况]()
图 8.7 – GPU 使用情况
-
目前,Longformer 的作者分享了一些检查点。以下代码片段加载了 Longformer 检查点
allenai/longformer-base-4096并处理了一个长文本:from transformers import LongformerTokenizer, LongformerForSequenceClassification import torch tokenizer = LongformerTokenizer.from_pretrained( 'allenai/longformer-base-4096') model=LongformerForSequenceClassification.from_pretrained( 'allenai/longformer-base-4096') sequence= "hello "*4093 inputs = tokenizer(sequence, return_tensors="pt") print("input shape: ",inputs.input_ids.shape) outputs = model(**inputs) -
输出如下:
input shape: torch.Size([1, 4096])如图所示,Longformer 可以处理长度达
4096的序列。当我们传递长度超过4096的序列时,这是限制时,您将收到错误IndexError: index out of range in self。
Longformer 的默认attention_window是512,这是每个标记周围的关注窗口的大小。通过以下代码,我们实例化了两个 Longformer 配置对象,第一个是默认 Longformer,第二个是一个更轻量级的 Longformer,我们将窗口大小设置为较小的值,例如 4,这样模型就变得更轻:
-
请注意以下示例。我们将始终调用
XformerConfig.from_pretrained()。这个调用不会下载模型检查点的实际权重,而是仅从 HuggingFace Hub 下载配置。在本节中,由于我们不会进行微调,我们只需要配置:from transformers import LongformerConfig, \ PyTorchBenchmark, PyTorchBenchmarkArguments config_longformer=LongformerConfig.from_pretrained( "allenai/longformer-base-4096") config_longformer_window4=LongformerConfig.from_pretrained( "allenai/longformer-base-4096", attention_window=4) -
有了这些配置实例,您可以将配置对象传递给 Longformer 模型,使用自己的数据集训练您的 Longformer 语言模型,如下所示:
from transformers import LongformerModel model = LongformerModel(config_longformer)除了训练 Longformer 模型,您还可以将训练过的检查点微调到下游任务。要这样做,您可以继续应用
第三章中所示的代码进行语言模型训练,以及第 05-06 章进行微调。 -
现在我们将利用
PyTorchBenchmark比较这两种配置在各种输入长度[128, 256, 512, 1024, 2048, 4096]下的时间和内存性能,如下所示:sequence_lengths=[128,256,512,1024,2048,4096] models=["config_longformer","config_longformer_window4"] configs=[eval(m) for m in models] benchmark_args = PyTorchBenchmarkArguments( sequence_lengths= sequence_lengths, batch_sizes=[1], models= models) benchmark = PyTorchBenchmark( configs=configs, args=benchmark_args) results = benchmark.run() -
输出如下:

图 8.8 – 基准结果
一些关于PyTorchBenchmarkArguments的提示:如果你想看到训练和推断的性能,你应该将参数training设置为True(默认为False)。你可能还想看到您当前的环境信息。您可以通过设置no_env_print为False来做到这一点;默认为True。
让我们通过可视化性能来使其更易解释。为此,我们定义了一个plotMe()函数,因为我们将来在进一步的实验中也将需要该函数。该函数默认情况下绘制推断性能,以及正确限制的运行时间复杂性或内存占用:
-
这里是函数定义:
import matplotlib.pyplot as plt def plotMe(results,title="Time"): plt.figure(figsize=(8,8)) fmts= ["rs--","go--","b+-","c-o"] q=results.memory_inference_result if title=="Time": q=results.time_inference_result models=list(q.keys()) seq=list(q[models[0]]['result'][1].keys()) models_perf=[list(q[m]['result'][1].values()) \ for m in models] plt.xlabel('Sequence Length') plt.ylabel(title) plt.title('Inference Result') for perf,fmt in zip(models_perf,fmts): plt.plot(seq, perf,fmt) plt.legend(models) plt.show() -
让我们看看两个 Longformer 配置的计算性能,如下所示:
plotMe(results)这绘制了以下图表:
![图 8.9 – 随序列长度的速度性能(Longformer)]()
图 8.9 – 随序列长度的速度性能(Longformer)
在这个和后面的例子中,我们看到重型模型和轻型模型之间的主要差异是从长度 512 开始。前图显示了长子模型(窗口长度为 4)在时间复杂度方面如预期的表现更好。我们还看到两个 Longformer 模型用线性时间复杂度处理输入。
-
让我们从内存性能的角度评估这两个模型:
plotMe(results, "Memory")这绘制了以下内容:
![图 8.10 – 随序列长度的内存性能(Longformer)]()
图 8.10 – 随序列长度的内存性能(Longformer)
再次强调,直到长度 512,没有实质性的差异。从长度 512 开始,我们看到与时间性能类似的内存性能。显然,Longformer 自注意力的内存复杂性是线性的。另一方面,我要提醒你的是,我们尚未对模型任务性能做出任何评论。
非常感谢
PyTorchBenchmark脚本,我们已经交叉检验了这些模型。当我们选择应该用哪种配置来训练语言模型时,这个脚本非常有用。这在开始真正的语言模型训练和微调之前将是至关重要的。另一个利用稀疏注意力的表现最佳模型是 BigBird(Zohen 等,2020)。作者声称他们的稀疏注意力机制(他们将其称为广义注意力机制)在线性时间内保留了香草Transformers的全自注意机制的所有功能。作者将注意力矩阵视为有向图,因此他们利用了图论算法。他们从图稀疏化算法中汲取灵感,该算法用较少的边或顶点逼近给定图
G的图G'。BigBird 是一个分块注意力模型,可以处理长度达
4096的序列。它首先通过打包查询和密钥一起将注意力模式分块化,然后对这些块定义注意力。他们利用了随机、滑动窗口和全局注意力。 -
让我们加载并使用与 Longformer Transformers模型相似的 BigBird 模型检查点配置。HuggingFace Hub 的开发人员共享了几个 BigBird 检查点。我们选择了原始的 BigBird 模型,
google/bigbird-roberta-base,它从一个 RoBERTa 检查点开始预热。再次强调,我们不是下载模型检查点权重,而是下载配置。BigBirdConfig实现允许我们比较完全自注意和稀疏注意。因此,我们可以观察和检查稀疏化是否将完全注意的 O(n²)复杂性降低到更低的水平。再次强调,最多达到 512 的长度,我们并没有清楚地观察到二次复杂性。我们可以从这个级别开始观察复杂性。将注意类型设置为原始全功能将为我们提供完全自注意模型。为了比较,我们创建了两种类型的配置:第一个是 BigBird 的原始稀疏方法,第二个是使用完全自注意模型的模型。 -
我们依次称它们为
sparseBird和fullBird:from transformers import BigBirdConfig # Default Bird with num_random_blocks=3, block_size=64 sparseBird = BigBirdConfig.from_pretrained( "google/bigbird-roberta-base") fullBird = BigBirdConfig.from_pretrained( "google/bigbird-roberta-base", attention_type="original_full") -
请注意,对于最多 512 个序列长度,由于块大小和序列长度不一致,BigBird 模型将作为完全自注意模式运行:
sequence_lengths=[256,512,1024,2048, 3072, 4096] models=["sparseBird","fullBird"] configs=[eval(m) for m in models] benchmark_args = PyTorchBenchmarkArguments( sequence_lengths=sequence_lengths, batch_sizes=[1], models=models) benchmark = PyTorchBenchmark( configs=configs, args=benchmark_args) results = benchmark.run()输出如下:
![图 8.11 – 基准结果(BigBird)]()
图 8.11 – 基准结果(BigBird)
-
再次,我们将时间性能绘制如下:
plotMe(results)这绘制了以下内容:
![图 8.12 – 速度性能(BigBird)]()
图 8.12 – 速度性能(BigBird)
在一定程度上,完全自注意模型的性能优于稀疏模型。然而,我们可以观察到
fullBird的二次时间复杂性。因此,在一定程度上,当接近尾声时,我们也看到稀疏注意模型突然超越它。 -
让我们按如下方式检查内存复杂性:
plotMe(results,"Memory")这是输出:

图 8.13 – 内存性能(BigBird)
在上图中,我们可以清楚地看到线性和二次内存复杂性。再次强调,在某一点(本例中长度为 2,000),我们无法说出清晰的区别。
接下来,让我们讨论可学习模式,并使用可以处理更长输入的模型。
可学习模式
基于学习的模式是固定(预定义)模式的替代方案。这些方法以无监督数据驱动的方式提取模式。它们利用一些技术来衡量查询和键之间的相似性,以正确地对它们进行聚类。这个Transformers家族首先学习如何对令牌进行聚类,然后限制交互以获得注意矩阵的最佳视图。
现在,我们将对 Reformer 进行一些实验,作为基于可学习模式的重要高效模型之一。在此之前,让我们先了解 Reformer 模型对 NLP 领域的贡献,如下所示:
-
它采用了
[a,b,c]和[d,e,f],标记d无法参与到其直接上下文c中。为了解决这个问题,Reformer 会用参数增加每个块的前面相邻块的数量。 -
Reformer 最重要的贡献是利用局部敏感哈希(LSH)函数,它将相似的查询向量分配相同的值。通过仅比较最相似的向量来近似注意力,可以帮助我们减少维度,然后将矩阵稀疏化。这是一个安全的操作,因为 softmax 函数受大值的影响很大,可以忽略不相似的向量。此外,与其查找给定查询的相关键,只查找相似的查询并进行桶分配。也就是说,查询的位置只能参与到其他具有高余弦相似度的查询的位置。
-
为了减少内存占用,Reformer 使用可逆残差层,避免了需要存储所有层的激活以便后续反向传播的需要,遵循可逆残差网络(RevNet)的方式,因为任意层的激活都可以从后续层的激活中恢复。
需要注意的是,Reformer 模型和许多其他高效的 transformer 在实践中被批评为,只有当输入长度非常长时才比普通 transformer 更高效(REF:Efficient Transformers:A Survey,Yi Tay,Mostafa Dehghani,Dara Bahri,Donald Metzler)。我们在早期的实验中也有类似的观察(请参见 BigBird 和 Longformer 实验)。
-
现在我们将对 Reformer 进行一些实验。再次感谢 HuggingFace 社区,Transformers 库为我们提供了 Reformer 的实现及其预训练检查点。我们将加载原始检查点
google/reformer-enwik8的配置,并调整一些设置以使其在完全自注意模式下工作。当我们将lsh_attn_chunk_length和local_attn_chunk_length设置为16384时,这是 Reformer 可以处理的最大长度,Reformer 实例将没有进行局部优化的机会,而是自动以完全注意力的方式工作,我们称之为fullReformer。至于原始的 Reformer,我们使用来自原始检查点的默认参数实例化它,并称之为sparseReformer如下:from transformers import ReformerConfig fullReformer = ReformerConfig\ .from_pretrained("google/reformer-enwik8", lsh_attn_chunk_length=16384, local_attn_chunk_length=16384) sparseReformer = ReformerConfig\ .from_pretrained("google/reformer-enwik8") sequence_lengths=[256, 512, 1024, 2048, 4096, 8192, 12000] models=["fullReformer","sparseReformer"] configs=[eval(e) for e in models]请注意,Reformer 模型可以处理长度最长为
16384的序列。但是对于完全自注意模式,由于我们环境的加速器容量限制,注意力矩阵无法适应 GPU,并且我们会收到 CUDA 内存不足的警告。因此,我们将最大长度设置为12000。如果您的环境适合,您可以增加它。 -
让我们进行基准实验如下:
benchmark_args = PyTorchBenchmarkArguments( sequence_lengths=sequence_lengths, batch_sizes=[1], models=models) benchmark = PyTorchBenchmark( configs=configs, args=benchmark_args) result = benchmark.run()输出如下:
![图 8.14 – 基准结果]()
图 8.14 – 基准结果
-
让我们将时间性能结果可视化如下:
plotMe(result)输出如下:
![图 8.15 – 速度性能(Reformer)]()
图 8.15 – 速度性能(Reformer)
-
我们可以看到模型的线性和二次复杂度。通过运行以下行,我们可以观察到内存占用的类似特征:
plotMe(result,"Memory Footprint")它绘制了以下内容:

图 8.16 – 内存使用(Reformer)
正如预期的那样,具有稀疏注意力的 Reformer 产生了一个轻量级模型。然而,正如之前所说的,我们在某个长度上难以观察到二次/线性复杂度。正如所有这些实验所指示的,高效Transformers可以减轻长文本的时间和内存复杂度。那么任务性能呢?它们在分类或摘要任务中的准确性如何?为了回答这个问题,我们将开始一个实验或查看相关模型的性能报告中的性能。对于实验,您可以通过实例化一个高效模型而不是一个普通的Transformers来重复chapter 04和chapter 05中的代码。您可以使用我们将在Chapter 11中详细讨论的模型跟踪工具来跟踪模型性能并对其进行优化,注意可视化和实验跟踪。
低秩分解、核方法和其他方法
高效模型的最新趋势是利用完整自注意力矩阵的低秩近似。这些模型被认为是最轻量级的,因为它们可以将自注意力的复杂度从O(n2)降低到O(n),无论是在计算时间还是内存占用上。选择一个非常小的投影维度k,使得k << n,那么内存和空间复杂度会大大降低。Linformer 和 Synthesizer 是能够通过低秩分解高效近似完整注意力的模型。它们通过线性投影来分解原始Transformers的点积* N×N* 注意力。
核关注是另一种最近我们看到的方法家族,通过核化来改善效率。核是一个将两个向量作为参数并返回它们的投影与特征映射的乘积的函数。它使我们能够在高维特征空间中操作,甚至不需要计算数据在该高维空间中的坐标,因为在该空间内的计算变得更加昂贵。这就是核技巧发挥作用的时候。基于核化的高效模型使我们能够重写自注意力机制,以避免显式计算N×N矩阵。在机器学习中,我们最常听到的有关核方法的算法是支持向量机,其中径向基函数核或多项式核被广泛使用,特别是用于非线性。对于Transformers,最引人注目的例子是Performer和线性Transformers。
摘要
本章的重要性在于我们学会了如何在有限的计算能力下减轻运行大型模型的负担。我们首先讨论并实施了如何使用蒸馏、剪枝和量化使训练模型变得高效的方法。预训练一个较小的通用语言模型,比如 DistilBERT,是很重要的。这样的轻量化模型可以与非蒸馏的模型相比,在各种问题上都能够取得良好的性能。
其次,我们了解了如何使用近似技术,例如 Linformer、BigBird、Performer 等,将完整的自注意力矩阵替换为稀疏矩阵的高效稀疏 Transformer。我们已经看到它们在各种基准测试中的性能表现,如计算复杂度和内存复杂度。这些例子向我们展示了这些方法能够将二次复杂度降低到线性复杂度,而不损害性能。
在下一章中,我们将讨论其他重要主题:跨语言/多语言模型。
参考文献
-
Sanh, V., Debut, L., Chaumond, J., & Wolf, T. (2019). DistilBERT,BERT 的精简版:更小、更快、更便宜、更轻量化. arXiv 预印本 arXiv:1910.01108。
-
Choromanski, K., Likhosherstov, V., Dohan, D., Song, X., Gane, A., Sarlos, T., & Weller, A. (2020). 重新思考注意力机制:表演者方法. arXiv 预印本 arXiv:2009.14794。
-
Wang, S., Li, B., Khabsa, M., Fang, H., & Ma, H. (2020). Linformer:具有线性复杂性的自注意力机制. arXiv 预印本 arXiv:2006.04768。
-
Zaheer, M., Guruganesh, G., Dubey, A., Ainslie, J., Alberti, C., Ontanon, S., ... & Ahmed, A. (2020). 大鸟:针对更长序列的 Transformer. arXiv 预印本 arXiv:2007.14062。
-
Tay, Y., Dehghani, M., Bahri, D., & Metzler, D. (2020). 高效 Transformer:一项调查. arXiv 预印本 arXiv:2009.06732。
-
Tay, Y., Bahri, D., Metzler, D., Juan, D. C., Zhao, Z., & Zheng, C. (2020). 合成器:重新思考 Transformer 模型中的自注意力机制. arXiv 预印本 arXiv:2005.00743。
-
Kitaev, N., Kaiser, Ł., & Levskaya, A. (2020). Reformer:高效 Transformer. arXiv 预印本 arXiv:2001.04451。
-
Fournier, Q., Caron, G. M., & Aloise, D. (2021). 关于更快、更轻量化 Transformer 的实用调查. arXiv 预印本 arXiv:2103.14636。
第九章:跨语言和多语言语言建模
到目前为止,你已经学习了很多关于基于 transformer 的架构的知识,从仅编码器模型到仅解码器模型,从高效的 transformers 到长上下文的 transformers。你还学习了基于 Siamese 网络的语义文本表示。然而,我们讨论了所有这些模型都是从单语问题的角度出发的。我们假设这些模型只是理解单一语言,并且无法对文本进行通用的理解,无论语言本身如何。事实上,其中一些模型具有多语言变体;多语言双向编码器表示模型(mBERT),多语言文本到文本转换 transformer(mT5),以及多语言双向和自回归 transformer(mBART),仅举几例。另一方面,一些模型专门设计用于多语言目的,采用跨语言目标进行训练。例如,跨语言语言模型(XLM)就是这样一种方法,本章将详细介绍。
在本章中,将介绍语言之间的知识共享概念,以及Byte-Pair 编码(BPE)对分词部分的影响,也是另一个重要的主题,为了实现更好的输入。将详细说明使用跨语言自然语言推理(XNLI)语料库进行跨语言句子相似性的任务。将通过实际的现实问题的具体例子,如多语言意图分类等自然语言处理(NLP)中的跨语言分类和跨语言句子表示利用另一种语言进行训练和测试的任务。
简而言之,你将在本章学习以下主题:
-
翻译语言建模和跨语言知识共享
-
XLM 和 mBERT
-
跨语言相似性任务
-
跨语言分类
-
跨语言零-shot 学习
-
多语言模型的基本局限性
技术要求
本章的代码在该书的 GitHub 仓库中的github.com/PacktPublishing/Mastering-Transformers/tree/main/CH09下找到。我们将使用 Jupyter Notebook 来运行我们的编码练习,需要 Python 3.6.0+,并且需要安装以下软件包:
-
tensorflow -
pytorch -
transformers >=4.00 -
datasets -
sentence-transformers -
umap-learn -
openpyxl
查看以下链接,观看《代码实战》视频:
翻译语言建模和跨语言知识共享
迄今为止,你已经了解了遮罩语言建模(MLM)作为填空任务。然而,基于神经网络的语言建模根据方法本身和其实际用途分为三类,如下所示:
-
MLM
-
因果语言建模(CLM)
-
翻译语言建模(TLM)
也很重要的是,还有其他预训练方法,例如下一句预测(NSP)和句子顺序预测(SOP),但我们只考虑了基于令牌的语言建模。这三种方法是文献中使用的主要方法。如前几章中描述和详细介绍的MLM,与语言学习中的填空任务非常接近。
CLM的定义是预测下一个令牌,后面跟着一些前面的令牌。例如,如果你看到以下上下文,你可以轻松预测下一个令牌:
Transformers改变了自然语言...
正如你所看到的,只有最后一个令牌被屏蔽,前面的令牌都给了模型,让它预测最后一个。这个令牌将会是processing,如果再次给你这个令牌的上下文,你可能会以一个""令牌结束。为了在这种方法上进行良好的训练,需要不屏蔽第一个令牌,因为模型只有一个句子的开始令牌来组成一个句子。这个句子可以是任何东西!下面是一个例子:
...
你会预测出什么?可以是任何东西。为了更好的训练和更好的结果,需要至少给出第一个令牌,如下所示:
Transformers...
而模型需要预测变化;在给出Transformers改变...后,需要预测the,依此类推。这种方法非常类似于 N-grams 和P(wn|wn-1, wn-2 ,…,w0),其中wn是要预测的令牌,而其余令牌是它前面的令牌。具有最大概率的令牌是预测的令牌。
这些是用于单语模型的目标。那么,对于跨语言模型可以做些什么?答案是TLM,它与 MLM 非常相似,但有一些变化。不是给定一个单一语言的句子,而是给模型一个包含不同语言的句子对,用一个特殊的令牌分隔开。模型需要预测这些语言中任意一个中的随机屏蔽的令牌。
下面的句子对就是这样一个任务的例子:

图 9.1 - 土耳其和英语之间的跨语言关系示例
给定这两个屏蔽的句子,模型需要预测缺失的令牌。在这个任务中,有些场合下,模型可以访问到其中一个语言中缺失的令牌(例如,在图 9.1中的句子对中分别为doğal和language)。
另一个例子,你可以看到波斯语和土耳其语句子的同一对。在第二个句子中,değiştirdiler 标记可以被第一个句子中的多个标记(一个被掩码)关注到。在下面的例子中,单词 تغییر 缺失,但 değiştirdiler 的含义是 تغییر دادند****。

图 9.2 – 波斯语和土耳其语之间的跨语言关系示例
因此,一个模型可以学习这些含义之间的映射。就像一个翻译模型一样,我们的 TLM 也必须学习这些语言之间的复杂性,因为机器翻译(MT)不仅仅是一个标记到标记的映射。
XLM 和 mBERT
在本节中我们选择了两个模型进行解释:mBERT 和 XLM。我们选择这些模型是因为它们对应于写作本文时最好的两种多语言类型。mBERT 是一个在不同语言语料库上使用 MLM 建模训练的多语言模型。它可以单独为许多语言进行操作。另一方面,XLM 是使用 MLM、CLM 和 TLM 语言建模在不同语料库上训练的,可以解决跨语言任务。例如,它可以通过将它们映射到共同的向量空间来测量两种不同语言句子的相似度,而这在 mBERT 中是不可能的。
mBERT
你对来自第三章的 BERT 自动编码器模型以及如何在指定语料库上使用 MLM 进行训练已经很熟悉了。想象一下提供了一个广泛且庞大的语料库,不是来自单一语言,而是来自 104 种语言。在这样的语料库上进行训练将会产生一个多语言版本的 BERT。然而,在如此广泛的语言上进行训练将会增加模型的大小,在 BERT 的情况下是不可避免的。词汇量会增加,因此嵌入层的大小会因为更多的词汇而变大。
与单语言预训练的 BERT 相比,这个新版本能够在一个模型内处理多种语言。然而,这种建模的缺点是,该模型不能在语言之间进行映射。这意味着在预训练阶段,模型并未学习到关于不同语言的这些标记的语义含义之间的映射。为了为这个模型提供跨语言映射和理解,有必要在一些跨语言监督任务上对其进行训练,比如XNLI数据集中提供的任务。
使用这个模型与你在之前章节中使用的模型一样简单(更多详情请参见 huggingface.co/bert-base-multilingual-uncased)。以下是你需要开始的代码:
from transformers import pipeline
unmasker = pipeline('fill-mask', model='bert-base-
multilingual-uncased')
sentences = [
"Transformers changed the [MASK] language processing",
"Transformerlar [MASK] dil işlemeyi değiştirdiler",
"ترنسفرمرها پردازش زبان [MASK] را تغییر دادند"
]
for sentence in sentences:
print(sentence)
print(unmasker(sentence)[0]["sequence"])
print("="*50)
输出结果将如下代码片段所示呈现:
Transformers changed the [MASK] language processing
transformers changed the english language processing
==================================================
Transformerlar [MASK] dil işlemeyi değiştirdiler
transformerlar bu dil islemeyi degistirdiler
==================================================
ترنسفرمرها پردازش زبان [MASK] را تغییر دادند
ترنسفرمرها پردازش زبانی را تغییر دادند
==================================================
正如你所见,它可以为各种语言执行 fill-mask。
XLM
语言模型的跨语言预训练,例如 XLM 方法所示,基于三种不同的预训练目标。MLM、CLM 和 TLM 被用来预训练 XLM 模型。这种预训练的顺序是使用所有语言之间共享的 BPE 分词器执行的。共享标记的原因在于,在具有相似标记或子词的语言情况下,共享标记提供了较少的标记,而另一方面,这些标记可以在预训练过程中提供共享的语义。例如,一些标记在许多语言中的书写和含义非常相似,因此这些标记对所有语言都使用 BPE 进行共享。另一方面,一些在不同语言中拼写相同的标记可能具有不同的含义——例如,在德语和英语环境中 was 是共享的。幸运的是,自注意力机制帮助我们使用周围的上下文消除 was 的含义歧义。
这种跨语言建模的另一个主要改进是它还在 CLM 上进行了预训练,这使得它在需要句子预测或完成时更加合理。换句话说,这个模型对语言有一定的理解,能够完成句子、预测缺失的标记,并利用其他语言源预测缺失的标记。
下图显示了跨语言建模的整体结构。你可以在 arxiv.org/pdf/1901.07291.pdf 上阅读更多内容。

图 9.3 – MLM 和 TLM 跨语言建模的预训练
XLM 模型的更新版本也被发布为XLM-R,其在训练和使用的语料库中有轻微的更改。XLM-R 与 XLM 模型相同,但在更多的语言和更大的语料库上进行了训练。CommonCrawl 和 Wikipedia 语料库被聚合,XLM-R 在其中进行 MLM 的训练。然而,XNLI 数据集也用于 TLM。下图显示了 XLM-R 预训练使用的数据量:

图 9.4 – 数据量(GB)(对数刻度)
在添加新语言进行训练数据时,有许多优点和缺点——例如,添加新语言并不总是会提高自然语言推理(NLI)的整体模型。XNLI 数据集通常用于多语言和跨语言 NLI。从前面的章节中,您已经看到了多样化体裁 NLI(MNLI)数据集用于英语;XNLI 数据集与之几乎相同,但具有更多的语言,而且还有句子对。然而,仅在此任务上进行训练是不够的,它不会涵盖 TLM 预训练。对于 TLM 预训练,会使用更广泛的数据集,例如OPUS(开源平行语料库的缩写)的平行语料库。该数据集包含来自不同语言的字幕,经过对齐和清理,由许多软件来源提供的翻译,如 Ubuntu 等。
以下截图显示了 OPUS (opus.nlpl.eu/trac/) 及其用于搜索和获取数据集信息的组件:
.jpg)
图 9.5 – OPUS
描述使用跨语言模型的步骤如下:
-
对先前的代码进行简单更改,您就可以看到 XLM-R 如何执行掩码填充。首先,您必须更改模型,如下所示:
unmasker = pipeline('fill-mask', model='xlm-roberta-base') -
之后,您需要将掩码标记从
[MASK]更改为<mask>,这是 XLM-R 的特殊标记(或简称为tokenizer.mask_token)。以下是完成此操作的代码:sentences = [ "Transformers changed the <mask> language processing", "Transformerlar <mask> dil işlemeyi değiştirdiler", "ترنسفرمرها پردازش زبان <mask" را تغییر دادند ] -
然后,您可以运行相同的代码,如下所示:
for sentence in sentences: print(sentence) print(unmasker(sentence)[0]["sequence"]) print("="*50) -
结果将如此显示:
Transformers changed the <mask> language processing Transformers changed the human language processing ================================================== Transformerlar <mask> dil işlemeyi değiştirdiler Transformerlar, dil işlemeyi değiştirdiler ================================================== ترنسفرمرها پردازش زبان [MASK] را تغییر دادند ترنسفرمرها پردازش زبانی را تغییر دادند ================================================== -
但从土耳其语和波斯语的例子中可以看出,模型仍然犯了错误;例如,在波斯文本中,它只是添加了
ی,在土耳其版本中,它添加了,。对于英文句子,它添加了human,这不是我们所期望的。这些句子并没有错,但不是我们所期望的。然而,这一次,我们有一个使用 TLM 训练的跨语言模型;所以,让我们通过连接两个句子并给模型一些额外的提示来使用它。我们开始吧:print(unmasker("Transformers changed the natural language processing. </s> Transformerlar <mask> dil işlemeyi değiştirdiler.")[0]["sequence"]) -
结果将如下所示:
Transformers changed the natural language processing. Transformerlar doğal dil işlemeyi değiştirdiler. -
就这样!模型现在已经做出了正确的选择。让我们再玩一会儿,看看它的表现如何,如下所示:
print(unmasker("Earth is a great place to live in. </s> زمین جای خوبی برای <mask> کردن است.")[0]["sequence"])这是结果:
Earth is a great place to live in. زمین جای خوبی برای زندگی کردن است.
干得好!到目前为止,您已经了解了诸如 mBERT 和 XLM 等多语言和跨语言模型。在下一节中,您将学习如何使用这些模型进行多语言文本相似性。您还将看到一些用例,例如多语言抄袭检测。
跨语言相似性任务
跨语言模型能够以统一的形式表示文本,其中句子来自不同的语言,但意思相近的句子在向量空间中被映射到相似的向量上。XLM-R,正如前一节详细介绍的那样,是这个领域中成功的模型之一。现在,让我们看一些在这方面的应用。
跨语言文本相似性
在以下示例中,您将看到如何使用在 XNLI 数据集上预训练的跨语言语言模型来从不同语言中找到相似的文本。一个使用情景是需要为此任务提供抄袭检测系统。我们将使用来自阿塞拜疆语的句子,并查看 XLM-R 是否能找到相似的英语句子——如果有的话。两种语言的句子是相同的。下面是要执行的步骤:
-
首先,您需要为此任务加载一个模型,如下所示:
from sentence_transformers import SentenceTransformer, util model = SentenceTransformer("stsb-xlm-r-multilingual") -
随后,我们假设已经准备好两个单独列表形式的句子,如下代码段所示:
azeri_sentences = ['Pişik çöldə oturur', 'Bir adam gitara çalır', 'Mən makaron sevirəm', 'Yeni film möhtəşəmdir', 'Pişik bağda oynayır', 'Bir qadın televizora baxır', 'Yeni film çox möhtəşəmdir', 'Pizzanı sevirsən?'] english_sentences = ['The cat sits outside', 'A man is playing guitar', 'I love pasta', 'The new movie is awesome', 'The cat plays in the garden', 'A woman watches TV', 'The new movie is so great', 'Do you like pizza?'] -
接下来的步骤是利用 XLM-R 模型将这些句子表示为向量空间。您只需简单地使用模型的
encode函数即可实现这一点,如下所示:azeri_representation = model.encode(azeri_sentences) english_representation = \ model.encode(english_sentences) -
最后一步,我们将在另一种语言表示中搜索第一种语言的语义相似句子,如下所示:
results = [] for azeri_sentence, query in zip(azeri_sentences, azeri_representation): id_, score = util.semantic_search( query,english_representation)[0][0].values() results.append({ "azeri": azeri_sentence, "english": english_sentences[id_], "score": round(score, 4) }) -
为了看到这些结果的清晰形式,您可以使用 pandas DataFrame,如下所示:
import pandas as pd pd.DataFrame(results)然后,您将看到结果及其匹配分数,如下所示:

图 9.6 – 抄袭检测结果(XLM-R)
如果我们接受最高分句子被改写或翻译的话,在一种情况下模型会错(第 4 行),但是有一个阈值并接受比它高的值是有用的。我们将在接下来的章节中展示更全面的实验。
另外,还有可用的双编码器。这些方法提供了两个句子的对编码,并对结果进行分类以训练模型。在这种情况下,语言无关 BERT 句子嵌入(LaBSE)也可能是一个不错的选择,并且在sentence-transformers库和TensorFlow Hub中也有提供。LaBSE 是基于 Transformers 的双编码器,类似于 Sentence-BERT,其中两个具有相同参数的编码器与基于双语句子相似性的损失函数相结合。
使用相同的示例,您可以很简单地将模型更改为 LaBSE,并重新运行之前的代码(步骤 1),如下所示:
model = SentenceTransformer("LaBSE")
结果显示在下面的屏幕截图中:

图 9.7 – 抄袭检测结果(LaBSE)
正如您所见,LaBSE 在这种情况下表现更好,第 4 行的结果这次是正确的。LaBSE 的作者声称它在查找句子的翻译方面效果非常好,但在查找不完全相同的句子方面则不那么好。对于在翻译用于窃取知识产权材料的情况下查找抄袭,它是一个非常有用的工具。然而,还有许多其他因素会改变结果—例如,每种语言的预训练模型的资源大小和语言对的性质也很重要。为了进行合理的比较,我们需要进行更全面的实验,并考虑许多因素。
可视化跨语言文本相似性
现在,我们将测量和可视化两个句子之间的文本相似度程度,其中一个句子是另一个的翻译。Tatoeba是这样的句子和翻译的免费集合,它是 XTREME 基准测试的一部分。社区的目标是在许多参与者的支持下获得高质量的句子翻译。我们现在将采取以下步骤:
-
我们将从这个集合中获取俄语和英语句子。在开始工作之前,请确保安装了以下库:
!pip install sentence_transformers datasets transformers umap-learn -
加载句子对,如下所示:
from datasets import load_dataset import pandas as pd data=load_dataset("xtreme","tatoeba.rus", split="validation") pd.DataFrame(data)[["source_sentence","target_sentence"]]让我们来看一下输出,如下所示:
![图 9.8 – 俄语-英语句子对]()
图 9.8 – 俄语-英语句子对
-
首先,我们将取前 K=30 个句子对进行可视化,稍后我们将对整个集合运行实验。现在,我们将使用我们已经在上一个示例中使用过的句子转换器对它们进行编码。以下是代码的执行:
from sentence_transformers import SentenceTransformer model = SentenceTransformer("stsb-xlm-r-multilingual") K=30 q=data["source_sentence"][:K] + data["target_sentence"][:K] emb=model.encode(q) len(emb), len(emb[0]) Output: (60, 768) -
现在我们有了长度为 768 的 60 个向量。我们将用
id 12)坚持不靠近。 -
为了全面分析,现在让我们测量整个数据集。我们将对所有源和目标句子—1K 对—进行如下编码:
source_emb=model.encode(data["source_sentence"]) target_emb=model.encode(data["target_sentence"]) -
我们计算所有对之间的余弦相似度,将它们保存在
sims变量中,并绘制一个直方图,如下所示:from scipy import spatial sims=[ 1 - spatial.distance.cosine(s,t) \ for s,t in zip(source_emb, target_emb)] plt.hist(sims, bins=100, range=(0.8,1)) plt.show()这是输出:
![图 9.10 – 英语和俄语句子对的相似性直方图]()
图 9.10 – 英语和俄语句子对的相似性直方图
-
可以看到,得分非常接近 1。这是我们对一个良好的跨语言模型的期望。所有相似性测量的平均值和标准差也支持跨语言模型的性能,如下所示:
>>> np.mean(sims), np.std(sims) (0.946, 0.082) -
您可以自行运行相同的代码以用于除俄语外的其他语言。当您将其与
fra)、tam)等一起运行时,您将得到以下结果表。该表表明,在您的实验中,该模型在许多语言中表现良好,但在其他语言中失败,例如南非荷兰语或泰米尔语:

表 1 - 其他语言的跨语言模型性能
在本节中,我们将跨语言模型应用于衡量不同语言之间的相似性。在下一节中,我们将以监督的方式利用跨语言模型。
跨语言分类
到目前为止,你已经了解到跨语言模型能够在语义向量空间中理解不同语言,其中相似的句子无论其语言如何,在向量距离上都是接近的。但是在我们只有少量样本可用的用例中,如何利用这种能力呢?
例如,你正在尝试为一个聊天机器人开发意图分类,其中第二语言只有少量或没有样本可用;但是对于第一语言——比如英语——你有足够的样本。在这种情况下,可以冻结跨语言模型本身,只需为任务训练一个分类器。训练好的分类器可以在第二语言上进行测试,而不是在其训练语言上进行测试。
在本节中,你将学习如何在英语中训练跨语言模型进行文本分类,并在其他语言中进行测试。我们选择了一个被称为高棉语(en.wikipedia.org/wiki/Khmer_language)的非常低资源语言,该语言在柬埔寨、泰国和越南共有 1600 万人口使用。网络上几乎没有相关资源,很难找到用于训练模型的好数据集。然而,我们可以使用一个好的互联网电影数据库(IMDb)情感数据集,其中包含了电影评论的情感分析数据。我们将使用该数据集来评估我们的模型在其未经训练的语言上的表现。
下图清晰地展示了我们将要遵循的流程。模型在左侧使用训练数据进行训练,然后将该模型应用于右侧的测试集。请注意,MT 和句子编码器映射在流程中起着重要作用:

图 9.11 - 跨语言分类流程
加载和训练用于跨语言测试的模型所需的步骤概述如下:
-
第一步是加载数据集,如下所示:
from datasets import load_dataset sms_spam = load_dataset("imdb") -
在使用数据之前,你需要对数据集进行洗牌以打乱样本顺序,如下所示:
imdb = imdb.shuffle() -
下一步是从该数据集中制作一个良好的测试分割,该数据集使用的是高棉语。为了做到这一点,你可以使用诸如谷歌翻译之类的翻译服务。首先,你应该将该数据集保存为 Excel 格式,如下所示:
imdb_x = [x for x in imdb['train'][:1000]['text']] labels = [x for x in imdb['train'][:1000]['label']] import pandas as pd pd.DataFrame(imdb_x, columns=["text"]).to_excel( "imdb.xlsx", index=None) -
随后,你可以将其上传到谷歌翻译,并获取该数据集的高棉语翻译(
translate.google.com/?sl=en&tl=km&op=docs),如下面的截图所示:![图 9.12 - 谷歌文档翻译器]()
图 9.12 - 谷歌文档翻译器
-
选择并上传文档后,它将为您提供高棉语的翻译版本,您可以将其复制并粘贴到 Excel 文件中。还需要将其再次保存为 Excel 格式。结果将是一个 Excel 文档,是原始垃圾邮件/正常邮件英文数据集的翻译。您可以通过运行以下命令使用 pandas 读取它:
pd.read_excel("KHMER.xlsx")结果将如下所示:
![图 9.13 – IMDB 数据集高棉语版。]()
图 9.13 – IMDb 数据集高棉语版。
-
但是,只需要文本,因此您应该使用以下代码:
imdb_khmer = list(pd.read_excel("KHMER.xlsx").text) -
现在您有了两种语言和标签的文本,您可以按如下方式拆分训练和测试验证:
from sklearn.model_selection import train_test_split train_x, test_x, train_y, test_y, khmer_train, khmer_test = train_test_split(imdb_x, labels, imdb_khmer, test_size = 0.2, random_state = 1) -
下一步是使用 XLM-R 跨语言模型提供这些句子的表征。首先,您应该加载模型,如下所示:
from sentence_transformers import SentenceTransformer model = SentenceTransformer("stsb-xlm-r-multilingual") -
现在,您可以像这样获取表征:
encoded_train = model.encode(train_x) encoded_test = model.encode(test_x) encoded_khmer_test = model.encode(khmer_test) -
但是,您不应忘记将标签转换为
numpy格式,因为当使用 Keras 模型的fit函数时,TensorFlow 和 Keras 只处理numpy数组。以下是如何执行此操作的方式:import numpy as np train_y = np.array(train_y) test_y = np.array(test_y) -
现在一切准备就绪,让我们为分类表征制作一个非常简单的模型,如下所示:
import tensorflow as tf input_ = tf.keras.layers.Input((768,)) classification = tf.keras.layers.Dense( 1, activation="sigmoid")(input_) classification_model = \ tf.keras.Model(input_, classification) classification_model.compile( loss=tf.keras.losses.BinaryCrossentropy(), optimizer="Adam", metrics=["accuracy", "Precision", "Recall"]) -
您可以使用以下函数拟合您的模型:
classification_model.fit( x = encoded_train, y = train_y, validation_data=(encoded_test, test_y), epochs = 10) -
并且显示了
20个时期的训练结果,如下所示:![图 9.14 – IMDb 数据集英文版的训练结果]()
图 9.14 – IMDb 数据集英文版的训练结果
-
正如您所见,我们使用了英文测试集来查看模型在不同时期的性能,并且在最终时期报告如下:
val_loss: 0.5226 val_accuracy: 0.7150 val_precision: 0.7600 val_recall: 0.6972 -
现在我们已经训练了我们的模型并在英文上进行了测试,让我们在高棉语测试集上进行测试,因为我们的模型从未见过任何英文或高棉语的样本。以下是完成此操作的代码:
classification_model.evaluate(x = encoded_khmer_test, y = test_y)以下是结果:
loss: 0.5949 accuracy: 0.7250 precision: 0.7014 recall: 0.8623
到目前为止,您已经学会了如何利用跨语言模型在资源稀缺的语言中发挥作用。当您可以在很少的样本或没有样本的情况下使用这种能力时,它会产生巨大的影响和差异。在接下来的部分中,您将学习如何在没有样本可用的情况下使用零样本学习,即使是对于像英语这样的高资源语言也是如此。
跨语言零样本学习
在之前的部分中,您已经学会了如何使用单语模型执行零样本文本分类。使用 XLM-R 进行多语言和跨语言零样本分类与先前使用的方法和代码相同,因此我们将在这里使用mT5。
mT5 是基于 Transformers 的编码器-解码器架构的大规模多语言预训练语言模型,也与T5相同。 T5 在英语上预训练,而 mT5 在来自多语言通用爬虫(mC4)的 101 种语言上进行了训练。
在 HuggingFace 存储库(huggingface.co/alan-turing-institute/mt5-large-finetuned-mnli-xtreme-xnli)上可以找到经过 XNLI 数据集精调的 mT5 模型。
T5 模型及其变体 mT5 是完全的文本-to-文本模型,这意味着它将为它所给的任何任务生成文本,即使任务是分类或 NLI。因此,在推断这个模型的情况下,需要额外的步骤。我们将采取以下步骤:
-
第一步是加载模型和分词器,如下所示:
from torch.nn.functional import softmax from transformers import\ MT5ForConditionalGeneration, MT5Tokenizer model_name = "alan-turing-institute/mt5-large-finetuned-mnli-xtreme-xnli" tokenizer = MT5Tokenizer.from_pretrained(model_name) model = MT5ForConditionalGeneration\ .from_pretrained(model_name) -
接下来,让我们提供用于零样本分类的样本 - 一个句子和标签,如下所示:
sequence_to_classify = \ "Wen werden Sie bei der nächsten Wahl wählen? " candidate_labels = ["spor", "ekonomi", "politika"] hypothesis_template = "Dieses Beispiel ist {}."正如您所看到的,序列本身是德语的(
"在下次选举中你会投票给谁?"),但标签是用土耳其语写的("spor","ekonomi","politika")。hypothesis_template说:"这个例子是 ...",用德语表达。 -
下一步是设置蕴涵、
CONTRADICTS和NEUTRAL的标签IDs,这将在将来推断生成的结果时使用。以下是您需要执行此操作的代码:ENTAILS_LABEL = "_0" NEUTRAL_LABEL = "_1" CONTRADICTS_LABEL = "_2" label_inds = tokenizer.convert_tokens_to_ids([ ENTAILS_LABEL, NEUTRAL_LABEL, CONTRADICTS_LABEL]) -
您会记得,T5 模型使用前缀来知道它应该执行的任务。以下函数提供了 XNLI 前缀,以及用适当格式表示的前提和假设:
def process_nli(premise, hypothesis): return f'xnli: premise: {premise} hypothesis: {hypothesis}' -
接下来,对于每个标签,将生成一个句子,如下面的代码片段所示:
pairs =[(sequence_to_classify,\ hypothesis_template.format(label)) for label in candidate_labels] seqs = [process_nli(premise=premise, hypothesis=hypothesis) for premise, hypothesis in pairs] -
您可以通过打印它们来查看生成的序列,如下所示:
print(seqs) ['xnli: premise: Wen werden Sie bei der nächsten Wahl wählen? hypothesis: Dieses Beispiel ist spor.', 'xnli: premise: Wen werden Sie bei der nächsten Wahl wählen? hypothesis: Dieses Beispiel ist ekonomi.', 'xnli: premise: Wen werden Sie bei der nächsten Wahl wählen? hypothesis: Dieses Beispiel ist politika.']这些序列简单地表明任务是由
xnli:编码的;前提句子是"在下次选举中你会投票给谁?"(德语),而假设是"这个例子是政治","这个例子是体育", 或者"这个例子是经济"。 -
在下一步中,您可以对序列进行标记化,并将它们提供给模型根据其生成文本,如下所示:
inputs = tokenizer.batch_encode_plus(seqs, return_tensors="pt", padding=True) out = model.generate(**inputs, output_scores=True, return_dict_in_generate=True,num_beams=1) -
生成的文本实际上为词汇表中的每个标记给出了分数,而我们要找的是蕴涵、矛盾和中性分数。您可以使用它们的标记
IDs获取它们的分数,如下所示:scores = out.scores[0] scores = scores[:, label_inds] -
您可以通过打印它们来查看这些分数,就像这样:
>>> print(scores) tensor([[-0.9851, 2.2550, -0.0783], [-5.1690, -0.7202, -2.5855], [ 2.7442, 3.6727, 0.7169]]) -
对于我们的目的,中性分数是不需要的,我们只需要与蕴涵相比较的矛盾。因此,您可以使用以下代码仅获取这些分数:
entailment_ind = 0 contradiction_ind = 2 entail_vs_contra_scores = scores[:, [entailment_ind, contradiction_ind]] -
现在您有了这些对样本序列的每个分数,您可以在其上应用
softmax层来获得概率,如下所示:entail_vs_contra_probas = softmax(entail_vs_contra_scores, dim=1) -
要查看这些概率,您可以使用
print,像这样:>>> print(entail_vs_contra_probas) tensor([[0.2877, 0.7123], [0.0702, 0.9298], [0.8836, 0.1164]]) -
现在,您可以通过选择它们并在其上应用
softmax层来比较这三个样本的蕴涵概率,如下所示:entail_scores = scores[:, entailment_ind] entail_probas = softmax(entail_scores, dim=0) -
要查看值,可以使用
print,如下所示:>>> print(entail_probas) tensor([2.3438e-02, 3.5716e-04, 9.7620e-01]) -
结果意味着最高概率属于第三个序列。为了更好地看到它,使用以下代码:
>>> print(dict(zip(candidate_labels, entail_probas.tolist()))) {'ekonomi': 0.0003571564157027751, 'politika': 0.9762046933174133, 'spor': 0.023438096046447754}
整个过程可以总结如下:每个标签都赋予模型前提,并且模型为词汇表中的每个标记生成分数。我们使用这些分数来找出蕴涵标记在矛盾上的分数有多少。
多语言模型的基本限制
尽管多语言和跨语言模型前景可期,将影响自然语言处理工作的方向,但它们仍然存在一些局限性。许多最近的工作都解决了这些局限性。目前,与其单语言对应模型相比,mBERT 模型在许多任务中表现略逊一筹,并且可能并不是训练良好的单语言模型的潜在替代品,这就是为什么单语言模型仍然被广泛使用的原因。
该领域的研究表明,多语言模型遭受所谓的多语言诅咒,因为它们试图适当地代表所有语言。将新语言添加到多语言模型会提高其性能,直到某一点为止。然而,也有观察到,在此点之后添加语言会降低性能,这可能是由于共享的词汇表。与单语言模型相比,多语言模型在参数预算方面受到了显著的限制。它们需要将其词汇表分配给 100 多种语言中的每一种。
通过指定的分词器的能力,可以归因于现有的单语和多语言模型之间的性能差异。Rust 等人在 2021 年的研究How Good is Your Tokenizer? On the Monolingual Performance of Multilingual Language Models(arxiv.org/abs/2012.15613)表明,当在多语言模型上附加专用的语言特定分词器而不是通用分词器(共享的多语言分词器)时,它会提高该语言的性能。
一些其他的发现表明,目前不可能通过一个单一模型来代表世界上所有的语言,原因是不同语言的资源分配不平衡。作为解决方案,可以过度采样资源稀缺语言,而对资源充足的语言进行欠采样。另一个观察结果是,两种语言之间的知识转移如果这些语言相近会更加高效。如果它们是远离的语言,这种转移可能几乎没有效果。这个观察结果可能解释了我们在先前的跨语言句对实验中为南非荷兰语和泰米尔语获得更差的结果。
然而,关于这个主题有大量的工作,并且这些局限性随时可能被克服。在撰写本文时,XML-R 团队最近提出了两个新模型——XLM-R XL 和 XLM-R XXL,它们分别在 XNLI 上比原始 XLM-R 模型提高了 1.8%和 2.4%的平均准确性。
调优多语言模型的性能
现在,让我们检查多语言模型的微调性能是否真的比单语言模型差。例如,让我们回想一下在第五章中的七个类别的土耳其文本分类示例,文本分类的语言模型微调。在那个实验中,我们对土耳其特定的单语言模型进行了微调,并取得了良好的结果。我们将重复相同的实验,保持一切不变,但将土耳其单语模型分别替换为 mBERT 和 XLM-R 模型。我们将这样做:
-
让我们再次回顾一下那个例子中的代码。我们对
"dbmdz/bert-base-turkish-uncased"模型进行了微调,如下所示:from transformers import BertTokenizerFast tokenizer = BertTokenizerFast.from_pretrained( "dbmdz/bert-base-turkish-uncased") from transformers import BertForSequenceClassification model = \ BertForSequenceClassification.from_pretrained("dbmdz/bert-base-turkish-uncased",num_labels=NUM_LABELS, id2label=id2label, label2id=label2id)使用单语言模型,我们得到了以下性能值:
![图 9.15 – 单语言文本分类性能(来自第五章,文本分类的语言模型微调)]()
图 9.15 – 单语言文本分类性能(来自第五章,文本分类的语言模型微调)
-
要使用 mBERT 进行微调,我们只需替换前面的模型实例化行。现在,我们将使用
"bert-base-multilingual-uncased"多语言模型。我们像这样实例化它:from transformers import \ BertForSequenceClassification, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained( "bert-base-multilingual-uncased") model = BertForSequenceClassification.from_pretrained( "bert-base-multilingual-uncased", num_labels=NUM_LABELS, id2label=id2label, label2id=label2id) -
编码上没有太大的区别。当我们保持所有其他参数和设置完全相同运行实验时,我们得到以下性能值:
![图 9.16 – mBERT 微调性能]()
图 9.16 – mBERT 微调性能
哦!与单语言模型相比,多语言模型在所有指标上的表现差约 2.2%。
-
让我们为相同问题微调
"xlm-roberta-base"XLM-R 模型。我们将执行以下 XLM-R 模型初始化代码:from transformers import AutoTokenizer, XLMRobertaForSequenceClassification tokenizer = AutoTokenizer.from_pretrained( "xlm-roberta-base") model = XLMRobertaForSequenceClassification\ .from_pretrained("xlm-roberta-base", num_labels=NUM_LABELS, id2label=id2label,label2id=label2id) -
再次,我们保持所有其他设置完全相同。我们得到以下 XML-R 模型的性能值:

图 9.17 – XLM-R 微调性能
不错!XLM 模型确实给出了可比较的结果。获得的结果与单语言模型相当接近,差异约为 1.0%。因此,虽然单语言结果在某些任务中可能比多语言模型更好,但我们可以通过多语言模型获得令人满意的结果。这样想吧:我们可能不想为了持续 10 天或更长时间的 1%的性能而训练整个单语言模型。对我们来说,这种小的性能差异可能是可以忽略不计的。
摘要
在本章中,您了解了多语言和跨语言语言模型预训练,以及单语言和多语言预训练之间的区别。还涵盖了 CLM 和 TLM,并且您对它们有了了解。您了解了如何在各种用例中使用跨语言模型,比如语义搜索,抄袭和零样本文本分类。您还了解到,可以使用跨语言模型在来自一种语言的数据集上进行训练,然后在完全不同的语言上进行测试。评估了多语言模型的微调性能,并得出结论,一些多语言模型可以替代单语言模型,显著地将性能损失降至最低。
在下一章中,您将学习如何部署Transformers模型以解决实际问题,并以工业规模进行生产训练。
参考文献
-
Conneau, A., Lample, G., Rinott, R., Williams, A., Bowman, S. R., Schwenk, H. and Stoyanov, V. (2018). XNLI: 评估跨语言句子表示. arXiv 预印本 arXiv:1809.05053.
-
薛,L.,康斯坦特,N.,罗伯茨,A.,卡勒,M.,阿尔-福,R.,西达,A. and 拉菲尔,C. (2020). mT5:一个大规模多语种预训练文本到文本Transformers. arXiv 预印本 arXiv:2010.11934.
-
Lample, G. and Conneau, A. (2019). 跨语言语言模型预训练. arXiv 预印本 arXiv:1901.07291.
-
Conneau, A., Khandelwal, K., Goyal, N., Chaudhary, V., Wenzek, G., Guzmán, F. and Stoyanov, V. (2019). 在规模上无监督的跨语言表示学习. arXiv 预印本 arXiv:1911.02116.
-
冯,F.,杨,Y.,Cer,D.,阿里瓦扎甘,N.和王,W.(2020). 无语言 bert 句子嵌入. arXiv 预印本 arXiv:2007.01852.
-
Rust, P., Pfeiffer, J., Vulić, I., Ruder, S. and Gurevych, I. (2020). 你的分词器有多好?关于多语言语言模型的单语性能. arXiv 预印本 arXiv:2012.15613.
-
Goyal, N., Du, J., Ott, M., Anantharaman, G. and Conneau, A. (2021). 用于多语言掩模语言建模的大规模Transformers. arXiv 预印本 arXiv:2105.00572.
第十章:提供 Transformer 模型
到目前为止,我们已经探讨了围绕 Transformer 的许多方面,你已经学会了如何从头开始训练和使用 Transformer 模型。您还学会了如何为许多任务进行微调。然而,我们仍然不知道如何在生产中提供这些模型。与任何其他现实生活和现代解决方案一样,基于自然语言处理(NLP)的解决方案必须能够在生产环境中提供服务。然而,在开发这种解决方案时必须考虑响应时间等指标。
本章将介绍如何在具有 CPU/GPU 的环境中提供基于 Transformer 的 NLP 解决方案。将在此处描述用于机器学习部署的TensorFlow Extended(TFX)解决方案。还将说明用于作为 API 提供 Transformer 的其他解决方案,例如 FastAPI。您还将了解 Docker 的基础知识,以及如何将您的服务 docker 化并使其可部署。最后,您将学习如何使用 Locust 对基于 Transformer 的解决方案进行速度和负载测试。
在本章中,我们将涵盖以下主题:
-
快速 API 变换器模型服务
-
Docker 化 APIs
-
使用 TFX 进行更快的变换器模型服务
-
使用 Locust 进行负载测试
技术要求
我们将使用 Jupyter Notebook、Python 和 Dockerfile 来运行我们的编码练习,这将需要 Python 3.6.0。需要安装以下软件包:
-
TensorFlow
-
PyTorch
-
Transformer >=4.00
-
快速 API
-
Docker
-
Locust
现在,让我们开始吧!
本章中的所有编码练习笔记本将在以下 GitHub 链接中提供: github.com/PacktPublishing/Mastering-Transformers/tree/main/CH10。
点击以下链接查看动态演示视频: bit.ly/375TOPO
快速 API 变换器模型服务
有许多我们可以用来提供服务的 web 框架。 Sanic、Flask 和 fastAPI 只是一些例子。然而,fastAPI 最近因其速度和可靠性而备受关注。在本节中,我们将使用 fastAPI 并根据其文档学习如何构建服务。我们还将使用pydantic来定义我们的数据类。让我们开始吧!
-
在开始之前,我们必须安装
pydantic和 fastAPI:$ pip install pydantic $ pip install fastapi -
下一步是使用
pydantic为装饰 API 输入的数据模型进行建模。但是在形成数据模型之前,我们必须了解我们的模型是什么,并确定其输入。我们将使用问答(QA)模型。正如你从第六章中所知,Fine-Tuning Language Models for Token Classification,输入是问题和上下文的形式。
-
通过使用以下数据模型,您可以创建 QA 数据模型:
from pydantic import BaseModel class QADataModel(BaseModel): question: str context: str -
我们必须只加载模型一次,而不是为每个请求加载它;相反,我们将预加载它一次并重复使用它。因为每次我们向服务器发送请求时,端点函数都会被调用,这将导致模型每次都被加载:
from transformers import pipeline model_name = 'distilbert-base-cased-distilled-squad' model = pipeline(model=model_name, tokenizer=model_name, task='question-answering') -
下一步是为调节应用程序创建一个 fastAPI 实例:
from fastapi import FastAPI app = FastAPI() -
然后,您必须使用以下代码创建一个 fastAPI 端点:
@app.post("/question_answering") async def qa(input_data: QADataModel): result = model(question = input_data.question, context=input_data.context) return {"result": result["answer"]} -
对于使该函数以异步模式运行,重要的是使用
async;这将使请求并行运行。您还可以使用workers参数来增加 API 的工作线程数,并使其同时回答不同和独立的 API 调用。 -
使用
uvicorn,您可以运行应用程序并将其作为 API 提供。Uvicorn 是用于 Python API 的高速服务器实现,使其尽可能快速运行。使用以下代码:if __name__ == '__main__': uvicorn.run('main:app', workers=1) -
请记住,上述代码必须保存在
.py文件中(例如main.py)。您可以使用以下命令运行它:$ python main.py结果如下,您将在终端中看到以下输出:
![图 10.1 – fastAPI 实战]()
图 10.1 – fastAPI 实战
-
下一步是使用并测试它。我们可以使用许多工具来做这件事,但 Postman 是其中之一。在学习如何使用 Postman 之前,请使用以下代码:
$ curl --location --request POST 'http://127.0.0.1:8000/question_answering' \ --header 'Content-Type: application/json' \ --data-raw '{ "question":"What is extractive question answering?", "context":"Extractive Question Answering is the task of extracting an answer from a text given a question. An example of a question answering dataset is the SQuAD dataset, which is entirely based on that task. If you would like to fine-tune a model on a SQuAD task, you may leverage the `run_squad.py`." }'结果如下:
{"answer":"the task of extracting an answer from a text given a question"}Curl 是一个有用的工具,但不如 Postman 方便。Postman 带有图形用户界面,比起是一个 CLI 工具的 curl 更易于使用。要使用 Postman,请从
www.postman.com/downloads/安装它。 -
安装完 Postman 后,您可以轻松使用它,如下截图所示:
![图 10.2 – Postman 使用]()
图 10.2 – Postman 使用
-
设置 Postman 以使用您的服务的每个步骤在上述截图中都有编号。让我们来看看它们:
-
选择 POST 作为您的方法。
-
输入完整的端点 URL。
-
选择 Body。
-
将 Body 设置为 raw。
-
选择 JSON 数据类型。
-
以 JSON 格式输入您的输入数据。
-
单击 Send。
您将在 Postman 的底部部分看到结果。
在下一节中,您将学习如何将基于 fastAPI 的 API docker 化。学习 Docker 基础知识对于使您的 API 可打包并更容易部署至关重要。
Docker 化 API
为了在生产过程中节省时间并简化部署过程,使用 Docker 是至关重要的。对于隔离您的服务和应用程序非常重要。此外,请注意,相同的代码可以在任何地方运行,而不受底层操作系统的限制。为了实现这一点,Docker 提供了出色的功能和打包。在使用它之前,您必须按照 Docker 文档中推荐的步骤安装它(docs.docker.com/get-docker/):
-
首先,将
main.py文件放置在 app 目录中。 -
接下来,您必须通过指定以下内容来删除代码的最后一部分:
if __name__ == '__main__': uvicorn.run('main:app', workers=1) -
下一步是为您的 fastAPI 创建一个 Dockerfile;您之前已经创建过了。为此,您必须创建一个包含以下内容的 Dockerfile:
FROM python:3.7 RUN pip install torch RUN pip install fastapi uvicorn transformers EXPOSE 80 COPY ./app /app CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] -
然后,您可以构建您的 Docker 容器:
$ docker build -t qaapi . And easily start it: $ docker run -p 8000:8000 qaapi因此,您现在可以使用
8000端口访问您的 API。但是,您仍然可以使用 Postman,如前一节所述,fastAPI Transformer model serving。
到目前为止,您已经学会了如何基于 Transformer 模型创建自己的 API,并使用 fastAPI 提供服务。然后学习了如何 dockerize 它。重要的是要知道,关于 Docker,您必须学习许多选项和设置;我们这里只覆盖了 Docker 的基础知识。
在下一节中,您将学习如何使用 TFX 来改进您的模型服务。
使用 TFX 进行更快的 Transformer 模型服务
TFX 提供了一种更快速和更高效的方式来提供基于深度学习的模型。但是在使用之前,您必须了解一些重要的关键点。模型必须是来自 TensorFlow 的保存模型类型,以便它可以被 TFX Docker 或 CLI 使用。让我们来看一看:
-
您可以通过使用来自 TensorFlow 的保存模型格式来执行 TFX 模型服务。有关 TensorFlow 保存模型的更多信息,请阅读官方文档:
www.tensorflow.org/guide/saved_model。要从 Transformers 创建保存模型,您只需使用以下代码:from transformers import TFBertForSequenceClassification model = \ TFBertForSequenceClassification.from_pretrained("nateraw/bert-base-uncased-imdb", from_pt=True) model.save_pretrained("tfx_model", saved_model=True) -
在理解如何使用它来为 Transformers 提供服务之前,需要拉取 TFX 的 Docker 镜像:
$ docker pull tensorflow/serving -
这将拉取正在提供的 TFX Docker 容器。下一步是运行 Docker 容器并将保存的模型复制到其中:
$ docker run -d --name serving_base tensorflow/serving -
您可以使用以下代码将保存的文件复制到 Docker 容器中:
$ docker cp tfx_model/saved_model tfx:/models/bert -
这将把保存的模型文件复制到容器中。但是,您必须提交更改:
$ docker commit --change "ENV MODEL_NAME bert" tfx my_bert_model -
现在一切都准备就绪,您可以终止 Docker 容器:
$ docker kill tfx这将停止容器的运行。
现在模型已经准备好,并且可以通过 TFX Docker 提供服务,您可以简单地与另一个服务一起使用它。我们需要另一个服务来调用 TFX 的原因是,基于 Transformer 的模型有一个由 tokenizer 提供的特殊输入格式。
-
为此,您必须创建一个 fastAPI 服务,该服务将模拟由 TensorFlow 服务容器提供的 API。在编写代码之前,您应该通过给予它运行 BERT-based 模型的参数来启动 Docker 容器。这将帮助您修复任何错误:
$ docker run -p 8501:8501 -p 8500:8500 --name bert my_bert_model -
下面的代码包含了
main.py文件的内容:import uvicorn from fastapi import FastAPI from pydantic import BaseModel from transformers import BertTokenizerFast, BertConfig import requests import json import numpy as np tokenizer =\ BertTokenizerFast.from_pretrained("nateraw/bert-base-uncased-imdb") config = BertConfig.from_pretrained("nateraw/bert-base-uncased-imdb") class DataModel(BaseModel): text: str app = FastAPI() @app.post("/sentiment") async def sentiment_analysis(input_data: DataModel): print(input_data.text) tokenized_sentence = [dict(tokenizer(input_data.text))] data_send = {"instances": tokenized_sentence} response = \ requests.post("http://localhost:8501/v1/models/bert:predict", data=json.dumps(data_send)) result = np.abs(json.loads(response.text)["predictions"][0]) return {"sentiment": config.id2label[np.argmax(result)]} if __name__ == '__main__': uvicorn.run('main:app', workers=1) -
我们加载了
config文件,因为标签存储在其中,我们需要它们以在结果中返回。您可以简单地使用python运行此文件:$ python main.py现在,您的服务已经启动并准备就绪。您可以使用 Postman 访问它,如下图所示:

图 10.3—基于 TFX 服务的 Postman 输出
TFX Docker 中新服务的整体架构如下图所示:

图 10.4—基于 TFX 服务的架构
到目前为止,您已经学会了如何使用 TFX 提供模型。然而,您还需要学会如何使用 Locust 进行负载测试。了解服务的限制以及何时通过量化或修剪进行优化是非常重要的。在下一节中,我们将描述如何使用 Locust 在高负载下测试模型性能。
使用 Locust 进行负载测试
我们可以使用许多应用程序来对服务进行负载测试。这些应用程序和库中的大多数都提供了有关服务的响应时间和延迟的有用信息。它们还提供了有关故障率的信息。Locust 是这一目的最好的工具之一。我们将使用它来对三种用于提供基于 Transformer 的模型的方法进行负载测试:仅使用 fastAPI、使用 docker 化的 fastAPI 以及使用 fastAPI 进行 TFX-based 服务。让我们开始吧:
-
首先,我们必须安装 Locust:
$ pip install locust此命令将安装 Locust。下一步是使提供相同任务的所有服务使用相同的模型。修正此测试的最重要的两个参数将确保所有服务均被设计成满足单一目的。使用相同的模型将帮助我们凝固其他任何内容,并集中于方法的部署性能。
-
一切准备就绪后,您可以开始测试 API 的负载。您必须准备一个
locustfile来定义您的用户及其行为。以下代码是一个简单的locustfile:from locust import HttpUser, task from random import choice from string import ascii_uppercase class User(HttpUser): @task def predict(self): payload = {"text": ''.join(choice(ascii_uppercase) for i in range(20))} self.client.post("/sentiment", json=payload)通过使用
HttpUser并创建从中继承的User类,我们可以定义一个HttpUser类。@task装饰器对于定义用户生成后必须执行的任务至关重要。predict函数是用户生成后将重复执行的实际任务。它将生成一个长度为20的随机字符串并发送到您的 API。 -
要开始测试,您必须启动您的服务。一旦您启动了服务,运行以下代码以启动 Locust 负载测试:
$ locust -f locust_file.pyLocust 将根据您在
locustfile中提供的设置启动。您的终端将显示以下内容:![图 10.5—启动 Locust 负载测试后的终端]()
图 10.5—启动 Locust 负载测试后的终端
正如您所看到的,您可以打开网络接口的 URL,即 http://0.0.0.0:8089 。
-
打开 URL 之后,您将看到一个界面,如下截图所示:
![图 10.6—Locust 网络接口]()
图 10.6—Locust 网络接口
-
我们将把要模拟的总用户数设定为10,生成速率设定为
1,主机设定为http://127.0.0.1:8000,这是我们服务运行的地方。在设置这些参数之后,点击开始 swarming。 -
此时,界面将会改变,测试将开始。要随时停止测试,点击停止按钮。
-
你还可以点击Charts选项卡查看结果的可视化:
![图 10.7 – 来自 Charts 选项卡的 Locust 测试结果]()
图 10.7 – 来自 Charts 选项卡的 Locust 测试结果
-
现在 API 的测试准备好了,让我们测试所有三个版本并比较结果,看哪个执行效果更好。请记住,服务必须在你要提供服务的机器上独立测试。换句话说,你必须一次运行一个服务并测试它,关闭服务,运行另一个服务并测试它,依此类推。
结果显示在下表中:

表 1 – 比较不同实现的结果
在上表中,每秒请求数(RPS)表示 API 每秒响应的请求数,而平均响应时间(RT)表示服务响应给定调用所需的毫秒数。这些结果显示了基于 TFX 的 fastAPI 是最快的。它具有更高的 RPS 和较低的平均 RT。所有这些测试都是在一台配有 Intel(R) Core(TM) i7-9750H CPU 和 32 GB RAM、GPU 禁用的机器上进行的。
在这一节中,你学习了如何测试你的 API 并测量其性能,重要参数如 RPS 和 RT。然而,真实世界的 API 还可以执行许多其他压力测试,比如增加用户数量使其表现得像真实用户一样。要执行这样的测试并以更真实的方式报告其结果,重要的是阅读 Locust 的文档并学习如何执行更高级的测试。
总结
在这一章中,你学习了使用 fastAPI 提供 Transformer 模型的基础知识。你还学会了如何以更高级和更有效的方式提供模型,比如使用 TFX。然后,你学习了负载测试和创建用户的基础知识。让这些用户分组生成或逐个生成,然后报告压力测试的结果,是本章的另一个主要主题。之后,你学习了 Docker 的基础知识以及如何将你的应用程序打包成 Docker 容器的形式。最后,你学会了如何提供基于 Transformer 的模型。
在下一章中,你将学习 Transformer 的解构、模型视图,并使用各种工具和技术监视训练。
参考资料
-
Locust 文档:
docs.locust.io -
TFX 文档:
www.tensorflow.org/tfx/guide -
FastAPI 文档:
fastapi.tiangolo.com -
Docker 文档:
docs.docker.com -
HuggingFace TFX 服务:
huggingface.co/blog/tf-serving
第十一章:注意力可视化和实验跟踪
在本章中,我们将涵盖两个不同的技术概念,注意力可视化 和 实验跟踪,并通过诸如 exBERT 和 BertViz 等复杂工具来实践它们。这些工具提供了重要的可解释性和可解释性功能。首先,我们将讨论如何利用这些工具来可视化注意力的内部部分。解释所学的表示是很重要的,也要理解 Transformer 中自注意力头所编码的信息。我们将看到某些头部对应于语法或语义的某个方面。其次,我们将学习如何通过记录和使用 TensorBoard 和 Weights & Biases(W&B)来监视实验。这些工具使我们能够高效地托管和跟踪实验结果,例如损失或其他指标,这有助于我们优化模型训练。通过本章的学习,您将学会如何使用 exBERT 和 BertViz 查看自己模型的内部部分,并最终能够利用 TensorBoard 和 W&B 监视和优化模型。
我们将在本章中涵盖以下主题:
-
解释注意力头
-
跟踪模型指标
技术要求
本章的代码可在 github.com/PacktPublishing/Mastering-Transformers/tree/main/CH11 找到,这是本书的 GitHub 代码库。我们将使用 Jupyter Notebook 运行需要 Python 3.6.0 或更高版本的编码练习,并且需要安装以下包:
-
tensorflow -
pytorch -
Transformers >=4.00 -
tensorboard -
wandb -
bertviz -
ipywidgets
查看以下链接以查看代码演示视频:
解释注意力头
与大多数深度学习(DL)架构一样,Transformer 模型的成功以及它们如何学习尚未完全理解,但我们知道,Transformer —— 令人惊讶地 —— 学到了许多语言特征。大量的学到的语言知识分布在预训练模型的隐藏状态和自注意头中。已经发表了大量的最新研究,并开发了许多工具,以理解和更好地解释这些现象。
感谢一些自然语言处理(NLP)社区工具,我们能够解释 Transformer 模型中自注意力头所学到的信息。由于令牌之间的权重,头部可以被自然地解释。我们很快会在本节的进一步实验中看到,某些头对应于语法或语义的某个方面。我们还可以观察到表面级模式和许多其他语言特征。
在本节中,我们将使用社区工具进行一些实验来观察这些模式和注意头部的特征。最近的研究已经揭示了自注意的许多特征。在我们进行实验之前,让我们先介绍一些。例如,大多数头部倾向于关注分隔符标记,如分隔符(SEP)和分类(CLS),因为这些标记永远不被屏蔽,并且特别携带段级信息。另一个观察是,大多数头部很少关注当前标记,但一些头部专门关注下一个或上一个标记,特别是在较早的层中。以下是最近研究中发现的其他模式列表,我们可以在我们的实验中轻松观察到:
-
同一层中的注意头表现出类似的行为。
-
特定头对应于语法或语义关系的特定方面。
-
一些头部对直接对象倾向于关注它们的动词,例如<lesson, take>或<car, drive>。
-
在一些头中,名词修饰语会关注它们的名词(例如the hot water;the next layer),或所有格代词会关注头部(例如her car)。
-
一些头部对被动助动词进行编码,例如Been damaged, was taken。
-
在一些头部中,指代提及关注自己,例如talks-negotiation, she-her, President-Biden。
-
较低的层通常包含有关词位置的信息。
-
语法特征在 transformer 中较早出现,而高级语义信息出现在更上层。
-
最终层是最具任务特异性的,并因此对下游任务非常有效。
为了观察这些模式,我们可以在这里使用两个重要工具exBERT和BertViz。这些工具功能几乎相同。我们将从 exBERT 开始。
用 exBERT 可视化注意力头部
exBERT 是一个可视化工具,用于查看 Transformers 内部部分。我们将使用它来可视化BERT-base-cased模型的自注意头部,这是 exBERT 界面的默认模型。除非另有说明,我们将在以下示例中使用BERT-base-cased模型。这包含 12 层,每层 12 个自注意头部,共计 144 个自注意头部。
我们将逐步学习如何使用 exBERT,如下所示:
-
让我们点击由Hugging Face托管的 exBERT 链接:
huggingface.co/exbert。 -
输入句子The cat is very sad.并查看输出,如下所示:
![图 11.1 – exBERT 界面]()
图 11.1 – exBERT 界面
在上面的屏幕截图中,左侧的标记关注右侧的标记。线条的厚度代表权重的值。由于 CLS 和 SEP 标记具有非常频繁和密集的连接,我们简化起见切断了与它们相关的链接。请参阅隐藏特殊标记切换按钮。现在我们看到的是第 1 层的关注映射,其中线条对应于所有头部上权重的总和。这被称为多头注意力机制,其中 12 个头部并行工作。这个机制可以让我们捕捉比单头注意力更广泛的关系。这就是为什么我们在图 11.1中看到一个广泛的关注模式。我们还可以通过点击头部列观察任何特定的头部。
如果您在左侧悬停在一个标记上,您将看到将它连接到右侧的具体权重。有关使用界面的更详细信息,请阅读文章exBERT:一个用于探索Transformers模型中学到表示的可视分析工具,作者本杰明·胡佛,亨德里克·施特罗贝尔特,塞巴斯蒂安·格赫尔曼,2019 年,或观看以下链接的视频:
exbert.net/。 -
现在,我们将尝试支持本节介绍部分中其他研究人员的发现。让我们以某些头部专门关注下一个或前一个标记,尤其是在较早的层模式为例,看是否有一个头部支持这一点。
-
在本章的其余部分中,我们将使用<层编号,头部编号>符号来表示特定的自注意头部,在这里,指数从 exBERT 的 1 开始,从 BertViz 的 0 开始。例如,❤️,7>表示 exBERT 第三层的第七个头部。当您选择<2,5>(或<4,12>或<6,2>)头部时,您将得到以下输出,其中每个标记只关注前一个标记:
![图 11.2 – 上一个标记关注模式]()
图 11.2 – 上一个标记关注模式
-
对于<2, 12>和❤️, 4>头部,您将得到一个模式,其中每个标记都与下一个标记关联,如下所示:
![图 11.3 – 下一个标记关注模式]()
图 11.3 – 下一个标记关注模式
这些头部对其他输入句子具有相同的功能,即它们独立于输入工作。您可以自己尝试不同的句子。
我们可以使用注意力头部进行先进的语义任务,例如使用探测分类器进行代词消解。首先,我们将从定性上检查内部表示是否具有代词消解(或核指代消解)的能力。代词消解被认为是一项具有挑战性的语义关系任务,因为代词与其先行词之间的距离通常非常大。
-
现在,我们拿句子The cat is very sad. Because it could not find food to eat. 作为例子。当你检查每个头部时,你会注意到<9,9>和<9,12>头部编码了代词关系。当你悬停在<9,9>头上的it时,我们会得到以下输出:
![图 11.4 – <9,9>头部的指代模式]()
图 11.4 – <9,9>头部的指代模式
<9,12>头也用于代词关系。同样,在悬停在it上时,我们得到以下输出:
![图 11.5 – <9,12>头部的指代模式]()
图 11.5 – <9,12>头部的指代模式
从上述截图中,我们看到it代词强烈关注它的先行词cat。我们稍微改变一下句子,让it代词现在指代food标记而不是cat,就像the cat did not eat the food because it was not fresh中一样。如下截图所示,与<9,9>头相关的截图中,it正确地关注了它的先行词food,如预期所示:
![图 11.6 – 第二个例子的<9,9>头部的模式]()
图 11.6 – 第二个例子的<9,9>头部的模式
-
让我们再做一次运行,这次代词指代的是cat,就像The cat did not eat the food because it was very angry中一样。在<9,9>头中,it 标记大部分关注cat标记,如下截图所示:
![图 11.7 – 第二个输入的<9,9>头部的模式]()
图 11.7 – 第二个输入的<9,9>头部的模式
-
我觉得这些例子已经足够了。现在,我们将以不同的方式使用 exBERT 模型来评估模型的容量。让我们重新启动 exBERT 界面,选择最后一层(第 12 层),并保留所有头部。然后,输入句子the cat did not eat the food.并将food标记掩码。双击掩码掩码了food标记,如下所示:

图 11.8 – 通过掩码评估模型
当你悬停在那个被掩码的标记上时,你可以看到Bert-base-cased模型的预测分布,如上述截图所示。第一个预测是food,这是预期的。有关工具的更详细信息,你可以使用 exBERT 的网页,位于exbert.net/。
干得好!在下一节中,我们将使用 BertViz 并编写一些 Python 代码来访问注意力头。
使用 BertViz 进行多尺度注意力头的可视化
现在,我们将编写一些代码来使用 BertViz 可视化头,这是一个可视化 Transformer 模型中注意力的工具,就像 exBERT 一样。它是由 Jesse Vig 在 2019 年开发的(Transformer 模型中注意力的多尺度可视化,Jesse Vig,2019)。它是 Tensor2Tensor 可视化工具(Jones, 2017)工作的延伸。我们可以通过 Python 应用程序编程接口(API)监视模型的内部部分进行多尺度定性分析。BertViz 的优点在于,我们可以通过 Python 应用程序编程接口(API)使用大多数 Hugging Face 托管的模型(如双向编码器转换器表示(BERT)、生成的预训练转换器(GPT)和跨语言语言模型(XLM))。因此,我们也将能够使用非英语模型或任何预训练模型。我们将很快一起检查这样的示例。您可以从以下 GitHub 链接访问 BertViz 资源和其他信息:github.com/jessevig/bertviz。
与 exBERT 类似,BertViz 在一个界面中可视化注意力头。此外,它支持鸟瞰视角和低级别的神经元视角,我们可以观察个别神经元如何相互作用以构建注意力权重。一个有用的演示视频可在以下链接找到:vimeo.com/340841955。
在开始之前,我们需要安装必要的库,如下所示:
!pip install bertviz ipywidgets
然后我们导入以下模块:
from bertviz import head_view
from Transformers import BertTokenizer, BertModel
BertViz 支持三种视图:头视图、模型视图和神经元视图。让我们逐一检查这些视图。不过,首先需要指出的是,在 exBERT 中,我们从 1 开始索引层和头。但在 BertViz 中,我们从 0 开始索引,与 Python 编程相同。如果我说 exBERT 中的一个 <9,9> 头,它的 BertViz 对应物是 <8,8>。
让我们从头视图开始。
注意力头视图
头视图是 BertViz 中我们在前一节中使用 exBERT 已经体验过的等价物。注意力头视图可视化基于一个或多个注意力头的注意力模式在所选层中:
-
首先,我们定义一个
get_bert_attentions()函数,用于检索给定模型和给定句对的注意力和标记。函数定义如下代码块所示:def get_bert_attentions(model_path, sentence_a, sentence_b): model = BertModel.from_pretrained(model_path, output_attentions=True) tokenizer = BertTokenizer.from_pretrained(model_path) inputs = tokenizer.encode_plus(sentence_a, sentence_b, return_tensors='pt', add_special_tokens=True) token_type_ids = inputs['token_type_ids'] input_ids = inputs['input_ids'] attention = model(input_ids, token_type_ids=token_type_ids)[-1] input_id_list = input_ids[0].tolist() tokens = tokenizer.convert_ids_to_tokens(input_id_list) return attention, tokens -
在下面的代码片段中,我们加载了
bert-base-cased模型,并检索了给定两个句子的标记和相应的注意力。然后我们在最后调用了head_view()函数来可视化注意力。以下是代码执行:model_path = 'bert-base-cased' sentence_a = "The cat is very sad." sentence_b = "Because it could not find food to eat." attention, tokens=get_bert_attentions(model_path, sentence_a, sentence_b) head_view(attention, tokens)代码输出是一个界面,如下所示:
![图 11.9 - BertViz 的头视图输出]()
图 11.9 - BertViz 的头视图输出
图 11.9 左侧是首先出现的界面。在任何左侧的令牌上悬停将显示从该令牌出发的注意力。顶部的彩色块对应于注意力头。双击其中的任何一个将选择它并丢弃其余部分。较粗的注意力线表示更高的注意力权重。
请记住,在前面的 exBERT 示例中,我们观察到 <9,9> 头(由于索引的原因,在 BertViz 中等效于 <8, 8>)具有代词-先行关系。我们观察到相同的模式在 图 11.9 中,选择第 8 层和第 8 头。然后,当我们悬停在 它 上时,在 图 11.9 的右侧看到了界面,它 强烈关注 cat 和 it 令牌。那么,在其他预训练语言模型中我们能观察到这些语义模式吗?虽然其它模型中头部不一定完全相同,但一些头部可能会编码这些语义特性。我们也从最近的工作中得知,语义特征主要编码在较高的层中。
-
让我们在土耳其语言模型中寻找一个指代模式。以下代码加载了一个土耳其
bert-base模型并取了一个句子对。我们在这里观察到,<8,8> 头在土耳其语言模型中具有与英语模型相同的语义特征,如下所示:model_path = 'dbmdz/bert-base-turkish-cased' sentence_a = "Kedi çok üzgün." sentence_b = "Çünkü o her zamanki gibi çok fazla yemek yedi." attention, tokens=\ get_bert_attentions(model_path, sentence_a, sentence_b) head_view(attention, tokens)从前面的代码中,
sentence_a和sentence_b意味着 The cat is sad 和 Because it ate too much food as usual,当悬停在o(它)上时,它 关注 Kedi(猫),如下所示:![图 11.10 – 土耳其语言模型中的指代模式]()
图 11.10 – 土耳其语言模型中的指代模式
除了
o之外的所有其他标记大多数关注到了 SEP 分隔符标记,这是 BERT 架构中所有头部中的一种主导行为模式。 -
作为头视图的最后一个示例,我们将解释另一个语言模型,并继续查看模型视图特性。这次,我们选择
bert-base-german-cased德语语言模型并将其可视化为输入——即,我们用于土耳其语的同一个句对的德语等价句对。 -
以下代码加载了一个德语模型,消耗了一对句子,并对其进行了可视化:
model_path = 'bert-base-german-cased' sentence_a = "Die Katze ist sehr traurig." sentence_b = "Weil sie zu viel gegessen hat" attention, tokens=\ get_bert_attentions(model_path, sentence_a, sentence_b) head_view(attention, tokens) -
当我们检查头部时,我们可以再次在第 8 层中看到指代模式,但这次是在第 11 个头部。要选择 <8,11> 头部,从下拉菜单中选择第 8 层并双击最后的头部,如下所示:

图 11.11 – 德语语言模型中的指代关系模式
如你所见,在悬停在 sie 上时,你会看到对 Die Katze 的强烈关注。虽然这个 <8,11> 头是最强大的指代关系头(在计算语言学文献中被称为先行关系),这种关系可能已经传播到许多其他头中。为了观察它,我们必须逐个检查所有的头。
另一方面,BertViz 的模型视图功能让我们基本了解所有头一次看到。 让我们在下一节中看一下。
模型视图
模型视图允许我们全面查看所有头和层的注意力。 自注意力头以表格形式显示,行和列分别对应层和头。 每个头以可点击的缩略图形式呈现,其中包括注意力模型的总体形状。
这个视图可以告诉我们 BERT 是如何工作的,并且更容易解释。 许多最近的研究,比如BERTology 初级入门:我们知道 BERT 如何工作,Anna Rogers,Olga Kovaleva,Anna Rumshisky,2021,找到了一些关于层行为的线索并达成了共识。 我们已经在解释注意头部分列出了其中一些。 您可以使用 BertViz 的模型视图自行测试这些事实。
让我们查看一下我们刚刚使用的德语语言模型,如下:
-
首先,导入以下模块:
from bertviz import model_view from Transformers import BertTokenizer, BertModel -
现在,我们将使用 Jesse Vig 开发的
show_model_view()包装函数。 您可以在以下链接找到原始代码:github.com/jessevig/bertviz/blob/master/notebooks/model_view_bert.ipynb。 -
您还可以在我们书本的 GitHub 链接中找到函数定义,链接地址为
github.com/PacktPublishing/Mastering-Transformers/tree/main/CH11。 这里只是放出函数头部:def show_model_view(model, tokenizer, sentence_a, sentence_b=None, hide_delimiter_attn=False, display_mode="dark"): . . . -
让我们再次加载德语模型。 如果您已经加载了它,可以跳过前五行。 这是您需要的代码:
model_path='bert-base-german-cased' sentence_a = "Die Katze ist sehr traurig." sentence_b = "Weil sie zu viel gegessen hat" model = BertModel.from_pretrained(model_path, output_attentions=True) tokenizer = BertTokenizer.from_pretrained(model_path) show_model_view(model, tokenizer, sentence_a, sentence_b, hide_delimiter_attn=False, display_mode="light")这是输出结果:
![图 11.12 – 德语语言模型的模型视图]()
图 11.12 – 德语语言模型的模型视图
这个视图帮助我们轻松观察到许多模式,比如下一个令牌(或上一个令牌)的注意力模式。 正如我们在解释注意头部分中提到的,令牌通常倾向于关注定界符,具体来说是在下层关注 CLS 定界符,在上层关注 SEP 定界符。 因为这些令牌未被屏蔽,它们可以促进信息的流动。 在最后的层中,我们只观察到 SEP 定界符为中心的注意力模式。 可以推测,SEP 用于收集段级信息,然后用于跨句任务,比如下一句预测(NSP)或编码句级含义。
另一方面,我们观察到指代关系模式主要编码在 <8,1>, <8,11>, <10,1>, and <10,7> 头部。 再次可以明确说,<8, 11> 头部是编码德语模型中指代关系的最强头部,我们已经讨论过。
-
当您点击该缩略图时,您将看到相同的输出,如下:

图 11.13 – 模型视图中<8,11>头部的放大图
你可以再次悬停在标记上,查看映射关系。
我认为头视图和模型视图的工作已经足够了。现在,让我们通过神经元视图拆解模型,并试图理解这些头部是如何计算权重的。
神经元视图
到目前为止,我们已经可视化了给定输入的计算权重。神经元视图可视化了查询中的神经元和关键向量,以及基于相互作用计算标记之间的权重。我们可以追踪任意两个标记之间的计算阶段。
接下来,我们将加载德语模型,并可视化刚刚处理过的同一句对,以保持连贯性。我们执行以下代码:
from bertviz.Transformers_neuron_view import BertModel, BertTokenizer
from bertviz.neuron_view import show
model_path='bert-base-german-cased'
sentence_a = "Die Katze ist sehr traurig."
sentence_b = "Weil sie zu viel gegessen hat"
model = BertModel.from_pretrained(model_path, output_attentions=True)
tokenizer = BertTokenizer.from_pretrained(model_path)
model_type = 'bert'
show(model, model_type, tokenizer, sentence_a, sentence_b, layer=8, head=11)
这就是输出:

图 11.14 – 核指关系模式的神经元视图(头部<8,11>)
这个视图帮助我们追踪了我们在左边选择的sie标记到右边其他标记的注意力计算。正值是蓝色的,负值是橙色的。颜色的强度代表了数值的大小。查询sie与Die和Katze的键非常相似。如果你仔细观察图案,你会注意到这些向量有多么相似。因此,它们的点积要比其他的比较更高,这建立了这些标记之间强烈的注意力。我们还可以追踪点积和 Softmax 函数的输出,当我们向右移动时。当点击左边的其他标记时,你也可以追踪其他的计算。
现在,让我们为相同的输入选择一个头部承载的下一个标记的注意力模式,并对其进行追踪。为此,我们选择<2,6> 头部。在这个模式中,几乎所有的注意力都集中在下一个字上。我们再次点击sie标记,如下所示:

图 11.15 – 下一个标记注意力模式的神经元视图(<2,6>头部)
现在,sie 标记的注意力集中在下一个标记上,而不是它自己的先行词(Die Katze)。当我们仔细观察查询和候选键时,我们会发现与sie的查询最相似的键是下一个标记zu。同样地,在这过程中我们可以看到点乘和 Softmax 函数是如何应用的。
在下一节,我们将简要讨论解释Transformers(Transformers)的探针分类器。
通过解读Transformers的探针分类器理解 BERT 的内部部分
DL 学到的内容的不透明性导致了许多关于这些模型解释的研究。我们试图回答这样的问题:Transformer 模型的哪些部分负责某些语言特征,或者输入的哪些部分导致模型做出特定的决定。为了做到这一点,除了可视化内部表示之外,我们还可以对表示进行分类器训练,以预测一些外部形态、句法或语义属性。因此,我们可以确定是否将内部 表示 与外部 属性 关联起来。模型的成功训练将是这种关联的定量证据——即,语言模型已经学会了与外部属性相关的信息。这种方法称为 探测分类器 方法,是自然语言处理和其他 DL 研究中的一种重要分析技术。基于注意力的探测分类器以注意力映射作为输入,并预测外部属性,如共指关系或头部修饰关系。
如前面的实验所示,我们可以使用get_bert_attention()函数获取给定输入的自注意权重。我们可以直接将这些权重传递到分类管道中,而不是将它们可视化。因此,在监督下,我们可以确定哪个头适合哪个语义特征——例如,我们可以通过标记数据找出哪些头适合共指。
现在,让我们转向模型跟踪部分,这对于构建高效的模型至关重要。
跟踪模型指标
到目前为止,我们已经训练了语言模型,并简单分析了最终结果。我们还没有观察训练过程或比较使用不同选项进行训练。在本节中,我们将简要讨论如何监视模型训练。为此,我们将处理如何跟踪之前在第五章中开发的模型的训练,文本分类的语言模型微调。
在这个领域开发了两个重要的工具——一个是 TensorBoard,另一个是 W&B。前者可以将训练结果保存到本地驱动器,并在实验结束时将其可视化。后者则可以在云平台上实时监视模型训练进度。
本节将是对这些工具的简要介绍,不会详细讨论它们,因为这超出了本章的范围。
让我们从 TensorBoard 开始。
使用 TensorBoard 跟踪模型训练
TensorBoard 是专门用于 DL 实验的可视化工具。它有许多功能,如跟踪、训练、将嵌入投射到较低的空间和可视化模型图。我们主要用它来跟踪和可视化诸如损失之类的指标。对于 Transformers 来说,使用 TensorBoard 跟踪指标是如此容易,只需在模型训练代码中添加几行就足够了。一切几乎保持不变。
现在,我们将重复第五章中进行的互联网电影数据库(IMDb)情感微调实验,对文本分类进行语言模型微调,并将跟踪指标。在该章节中,我们已经使用由4 千(4K)个训练数据集、1 千验证集和 1 千测试集组成的 IMDb 数据集训练了一个情感模型。现在,我们将其调整为适用于 TensorBoard。有关 TensorBoard 的更多详细信息,请访问 www.tensorflow.org/tensorboard。
让我们开始:
-
首先,如果尚未安装 TensorBoard,我们要这样安装:
!pip install tensorboard -
从第五章,对文本分类进行语言模型微调,保持 IMDb 情感分析的其他代码行不变,我们将训练参数设置如下:
from Transformers import TrainingArguments, Trainer training_args = TrainingArguments( output_dir='./MyIMDBModel', do_train=True, do_eval=True, num_train_epochs=3, per_device_train_batch_size=16, per_device_eval_batch_size=32, logging_strategy='steps', logging_dir='./logs', logging_steps=50, evaluation_strategy="steps", save_strategy="epoch", fp16=True, load_best_model_at_end=True ) -
在上述代码片段中,
logging_dir的值将很快作为参数传递给 TensorBoard。由于训练数据集大小为 4K,训练批大小为 16,每个时期有 250 步(4K/16),意味着三个时期有 750 步。 -
我们将
logging_steps设置为 50,这是一个采样间隔。随着间隔的减小,记录了有关模型性能上升或下降的更多细节。稍后我们将做另一个实验,在第 27 步降低这个采样间隔。 -
现在,每隔 50 步,模型性能将根据我们在
compute_metrics()中定义的指标进行测量。所要测量的指标包括准确率、F1 值、精确率和召回率。因此,我们将记录 15 次(750/50)性能测量。当我们运行trainer.train()时,这将开始训练过程,并在logging_dir='./logs'目录下记录日志。 -
我们将
load_best_model_at_end设置为True,以便管道加载在损失方面表现最佳的任何检查点。一旦训练完成,您将注意到最佳模型从checkpoint-250加载,其损失得分为0.263。 -
现在,我们唯一需要做的就是调用以下代码来启动 TensorBoard:
%reload_ext tensorboard %tensorboard --logdir logs这是输出:
![图 11.16 – TensorBoard 训练历史可视化]()
图 11.16 – TensorBoard 训练历史可视化
您可能已经注意到,我们可以跟踪之前定义的指标。水平轴从 0 到 750 步,这是我们之前计算的步数。我们不会在这里详细讨论 TensorBoard。让我们只看一下eval/loss 图表。当您点击左下角的最大化图标时,您将会看到以下图表:
![图 11.17 – TensorBoard eval/loss 图表,记录步长为 50]()
图 11.17 – TensorBoard eval/loss 图表,记录步长为 50
在前面的截图中,我们将 TensorBoard 仪表板左侧的滑块控制器的平滑度设置为 0,以更精确地查看分数并关注全局最小值。如果你的实验波动性很高,平滑功能可以很好地显示整体趋势。它的功能类似于滑动平均(MA)。这张图表支持我们之前的观察,最佳损失测量值为0.2658,在第250步时获得。
-
由于
logging_steps设置为10,我们获得了高分辨率,如下面的截图所示。因此,我们将记录 75(750 步/10 步)个性能测量值。当我们以这个分辨率重新运行整个流程时,我们在第 220 步获得了最佳模型,损失得分为 0.238,比之前的实验更好。结果可以在下面的截图中看到。由于分辨率更高,我们自然会观察到更多的波动:

图 11.18 - 记录步骤为 10 的更高分辨率 eval/loss 图表
目前我们不再使用 TensorBoard。让我们开始使用 W&B!
使用 W&B 实时跟踪模型训练
与 TensorBoard 不同,W&B 在云平台提供了一个仪表板,我们可以在一个单一的中心追踪和备份所有实验。它还允许我们与团队进行开发和共享。训练代码在我们的本地机器上运行,而日志保存在 W&B 云中。最重要的是,我们可以实时跟踪训练过程并立即与社区或团队分享结果。
我们可以通过对现有代码进行非常小的更改来为我们的实验启用 W&B:
-
首先,我们需要在
wandb.ai创建一个帐户,然后安装 Python 库,如下所示:!pip install wandb -
再次,我们将采用 IMDb 情感分析代码并进行微小的更改。首先,让我们导入库并登录到
wandB,如下所示:import wandb !wandb loginwandb请求一个 API 密钥,你可以很容易地在以下链接找到:wandb.ai/authorize。 -
或者,你可以将
WANDB_API_KEY环境变量设置为你的 API 密钥,如下所示:!export WANDB_API_KEY=e7d********* -
再次保持整个代码不变,我们只需向
TrainingArguments添加两个参数,report_to="wandb"和run_name="...",即可在 W&B 中启用日志记录,如下所示:training_args = TrainingArguments( ... the rest is same ... run_name="IMDB-batch-32-lr-5e-5", report_to="wandb" ) -
当你调用
trainer.train()后,日志将开始记录在云端。调用后,请检查云端仪表板并查看其变化。一旦trainer.train()调用成功完成,我们执行以下代码告诉wandB我们已完成:wandb.finish()执行还会在本地输出运行历史,如下所示:

图 11.19 - W&B 的本地输出
当你连接到 W&B 提供的链接时,你将进入一个看起来类似于这样的界面:

图 11.20 – 在 W&B 仪表板上单次运行的在线可视化
该可视化为单次运行的结果提供了一个总结的性能结果。正如您所看到的,我们可以追踪在compute_metric()函数中定义的指标。
现在,让我们来看一下评估损失。下面的截图显示了与 TensorBoard 提供的完全相同的绘图,其中最小损失约为 0.2658,在第 250 步发生:

图 11.21 – 在 W&B 仪表板上 IMDb 实验的 eval/loss 绘图
到目前为止,我们只对单次运行进行了可视化。W&B 允许我们跨多次运行动态地探索结果—例如,我们可以可视化使用不同超参数的模型的结果,如学习率或批量大小。为此,我们适当地实例化一个TrainingArguments对象,并为每次运行相应地更改run_name="..."。
下面的截图显示了我们使用不同超参数进行的几个 IMDb 情感分析运行。我们还可以看到我们更改的批量大小和学习率:

图 11.22 – 在 W&B 仪表板上探索多次运行的结果
W&B 提供了有用的功能—例如,它自动化了超参数优化和搜索可能模型的空间,称为 W&B Sweeps。除此之外,它还提供了与图形处理单元(GPU)消耗有关的系统日志,中央处理单元(CPU)利用率等等。更详细的信息,请查看以下网站:wandb.ai/home。
干得好!在最后一节参考资料中,我们将更多关注技术工具,因为使用这样的实用工具对于开发更好的模型至关重要。
总结
在本章中,我们介绍了两个不同的技术概念:注意力可视化和实验跟踪。我们首先使用 exBERT 在线界面可视化了注意力头。然后,我们研究了 BertViz,我们编写 Python 代码来查看三个 BertViz 可视化:头部视图,模型视图和神经元视图。BertViz 界面给了我们更多控制,以便我们可以使用不同的语言模型。此外,我们还能观察到如何计算 tokens 之间的注意权重。这些工具为我们提供了解释性和利用性的重要功能。我们还学会了如何跟踪我们的实验以获得更高质量的模型和进行错误分析。我们利用了两种工具来监视训练:TensorBoard 和 W&B。这些工具用来有效地跟踪实验并优化模型训练。
恭喜!你通过展现出的极大毅力和坚持不懈完成了这本书的阅读之旅。现在你可以放心了,因为你已经装备好了需要的工具,并且准备好开发和实现高级自然语言处理应用。
参考文献
-
exBERT:一种用于探索 Transformer 模型中学习表示的视觉分析工具,本杰明·胡佛,亨德里克·斯特罗贝尔特,塞巴斯蒂安·盖尔曼,2019。
-
Vig, J., 2019. Transformer 模型中的多尺度注意力可视化。arXiv 预印本 arXiv:1906.05714。
-
Clark, K., Khandelwal, U., Levy, O. 和 Manning, C.D., 2019. BERT 看什么?BERT 注意力分析。arXiv 预印本 arXiv:1906.04341.7
-
Biewald, L., 权重与偏差的实验追踪, 2020。软件可在
wandb.com获得,2(5)。 -
Rogers, A., Kovaleva, O. 和 Rumshisky, A., 2020. BERT 学习入门:我们对 BERT 如何工作的了解. 计算语言学协会交易,
8, pp.842-866。 -
W&B:
wandb.ai -
TensorBoard:
www.tensorflow.org/tensorboard -
exBert—Hugging Face:
huggingface.co/exbert -
exBERT:
exbert.net/











































































浙公网安备 33010602011771号