笔记

零样本迁移或零样本学习通常是指在一组标签上训练模型，然后在另一组标签上对其进行评估的任务。在 Transformer 的上下文中，零样本学习也可能是指像 GPT-3 这样的语言模型在下游任务上进行评估的情况，甚至没有对其进行微调。

数据集

在本章中，我们将使用称为 WikiANN 或 PAN-X 的多语言编码器跨语言传输评估 (XTREME) 基准测试的子集。2该数据集包含多种语言的维基百科文章，包括瑞士最常用的四种语言：德语 (62.9%)、法语 (22.9%)、意大利语 (8.4%) 和英语 (5.9%)。每篇文章都以“inside-outside-beginning”（IOB2）格式LOC标注（location）、PER（person）和ORG（organization）标签 。在这种格式中，前缀表示实体的开始，属于同一实体的连续标记被赋予前缀。标记表示令牌不属于任何实体。例如，以下B-I-O句子：

Jeff Dean 是加州谷歌的计算机科学家

将被标记为 IOB2 格式，如表 4-1所示。

表 4-1。使用命名实体注释的序列示例

要在 XTREME 中加载 PAN-X 子集之一，我们需要知道要传递 函数的数据集配置。load_dataset()每当您处理具有多个域的数据集时，都可以使用该get_dataset_config_names()函数找出可用的子集：

from datasets import get_dataset_config_names

xtreme_subsets = get_dataset_config_names("xtreme")
print(f"XTREME has {len(xtreme_subsets)} configurations")

XTREME has 183 configurations

哇，这么多配置！让我们通过查找以“PAN”开头的配置来缩小搜索范围：

panx_subsets = [s for s in xtreme_subsets if s.startswith("PAN")]
panx_subsets[:3]

['PAN-X.af'、'PAN-X.ar'、'PAN-X.bg']

好的，看来我们已经确定了 PAN-X 子集的语法：每个子集都有一个两个字母的后缀，似乎是 ISO 639-1 语言代码。这意味着要加载德语语料库，我们将de代码传递给以下name参数load_dataset()：

from datasets import load_dataset

load_dataset("xtreme", name="PAN-X.de")

为了制作真实的瑞士语料库，我们将根据口语比例从 PAN-X 中抽取德语 ( de)、法语 ( fr)、意大利语 ( it) 和英语 ( ) 语料库。en这将造成语言不平衡，这在现实世界的数据集中很常见，由于缺乏精通该语言的领域专家，获取少数语言的标记示例可能会很昂贵。这个不平衡的数据集将模拟处理多语言应用程序时的常见情况，我们将了解如何构建适用于所有语言的模型。

为了跟踪每种语言，让我们创建一个 Python defaultdict，将语言代码存储为键，并将类型的 PAN-X 语料库存储DatasetDict为值：

from collections import defaultdict
from datasets import DatasetDict

langs = ["de", "fr", "it", "en"]
fracs = [0.629, 0.229, 0.084, 0.059]
# Return a DatasetDict if a key doesn't exist
panx_ch = defaultdict(DatasetDict)

for lang, frac in zip(langs, fracs):
    # Load monolingual corpus
    ds = load_dataset("xtreme", name=f"PAN-X.{lang}")
    # Shuffle and downsample each split according to spoken proportion
    for split in ds:
        panx_ch[lang][split] = (
            ds[split]
            .shuffle(seed=0)
            .select(range(int(frac * ds[split].num_rows))))

在这里，我们使用该shuffle()方法来确保我们不会意外地偏向数据集拆分，同时select() 允许我们根据fracs. Dataset.num_rows让我们通过访问属性来看看我们在训练集中每种语言有多少示例：

import pandas as pd

pd.DataFrame({lang: [panx_ch[lang]["train"].num_rows] for lang in langs},
             index=["Number of training examples"])

根据设计，我们的德语示例比所有其他语言的总和还要多，因此我们将使用它作为起点，从零样本跨语言迁移到法语、意大利语和英语。让我们检查一下德语语料库中的一个例子 ：

element = panx_ch["de"]["train"][0]
for key, value in element.items():
    print(f"{key}: {value}")

langs: ['de', 'de', 'de', 'de', 'de', 'de', 'de', 'de', 'de', 'de', 'de', 'de']
ner_tags: [0, 0, 0, 0, 5, 6, 0, 0, 5, 5, 6, 0]
tokens: ['2.000', 'Einwohnern', 'an', 'der', 'Danziger', 'Bucht', 'in', 'der',
'polnischen', 'Woiwodschaft', 'Pommern', '.']

与我们之前遇到的Dataset对象一样，我们示例的键对应于箭头表的列名，而值表示每列中的条目。特别是，我们看到该 ner_tags列对应于每个实体到类 ID 的映射。这对人眼来说有点神秘，所以让我们用熟悉LOC的PER、 和ORG标签创建一个新列。为此，首先要注意的是我们的Dataset对象有一个features 属性，该属性指定与每一列关联的基础数据类型：

for key, value in panx_ch["de"]["train"].features.items():
    print(f"{key}: {value}")

tokens: Sequence(feature=Value(dtype='string', id=None), length=-1, id=None)
ner_tags: Sequence(feature=ClassLabel(num_classes=7, names=['O', 'B-PER',
'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC'], names_file=None, id=None),
length=-1, id=None)
langs: Sequence(feature=Value(dtype='string', id=None), length=-1, id=None)

该类Sequence指定该字段包含一个特征列表，在这种情况下，它ner_tags对应于一个 ClassLabel特征列表。让我们从训练集中挑选出这个特征如下：

tags = panx_ch["de"]["train"].features["ner_tags"].feature
print(tags)

ClassLabel(num_classes=7, names=['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG',
'B-LOC', 'I-LOC'], names_file=None, id=None)

我们可以使用第 2 章ClassLabel.int2str()中遇到的方法 在训练集中创建一个新列，其中包含每个标签的类名。我们将使用该map() 方法返回 一个dict，其键对应于新列名，值作为类名的 一个 list：

def create_tag_names(batch):
    return {"ner_tags_str": [tags.int2str(idx) for idx in batch["ner_tags"]]}

panx_de = panx_ch["de"].map(create_tag_names)

现在我们有了人类可读格式的标签，让我们看看标记和标签如何与训练集中的第一个示例对齐：

de_example = panx_de["train"][0]
pd.DataFrame([de_example["tokens"], de_example["ner_tags_str"]],
['Tokens', 'Tags'])

标签的存在是LOC有道理的，因为句子“2,000 Einwohnern an der Danziger Bucht in der polnischen Woiwodschaft Pommern”在英语中的意思是“波兰波美拉尼亚省格但斯克湾的 2,000 名居民”，而格但斯克湾是波罗的海的一个海湾海，而“voivodeship”对应于波兰的一个州。

作为快速检查我们在标签中没有任何异常不平衡的情况，让我们计算每个实体在每个拆分中的频率：

from collections import Counter

split2freqs = defaultdict(Counter)
for split, dataset in panx_de.items():
    for row in dataset["ner_tags_str"]:
        for tag in row:
            if tag.startswith("B"):
                tag_type = tag.split("-")[1]
                split2freqs[split][tag_type] += 1
pd.DataFrame.from_dict(split2freqs, orient="index")

这看起来不错——每个拆分的PER、LOC和ORG 频率分布大致相同，因此验证集和测试集应该可以很好地衡量我们的 NER 标注器的泛化能力。接下来，让我们看看一些流行的多语言转换器，以及它们如何适应我们的 NER 任务。

多语言Transformers

除了用于预训练的语料库由多种语言的文档组成之外，多语言转换器涉及与其单语对应物相似的架构和训练程序。这种方法的一个显着特征是，尽管没有接收到明确的信息来区分语言，但由此产生的语言表示能够很好地泛化各种 下游任务的语言。在某些情况下，这种执行跨语言迁移的能力可以产生与单语模型相媲美的结果，从而避免了对每种语言训练一个模型的需要！

为了衡量 NER 的跨语言迁移进度， CoNLL-2002和 CoNLL-2003数据集通常用作英语、荷兰语、西班牙语和德语的基准。该基准包括使用与 PAN-X 相同LOC的 PER、 和类别注释的新闻文章，但它包含不属于前三个组的杂项实体ORG的附加 标签。MISC多语言变压器模型通常以三种不同的方式进行评估：

en

微调英语训练数据，然后评估每种语言的测试集。

each

对单语测试数据进行微调和评估，以衡量每种语言的 性能。

all

微调所有训练数据，以评估每种语言测试集的所有数据。

我们将为我们的 NER 任务采用类似的评估策略，但首先我们需要选择一个模型进行评估。第一个多语言转换器之一是 mBERT，它使用与 BERT 相同的架构和预训练目标，但将来自多种语言的维基百科文章添加到预训练语料库中。从那时起，mBERT 就被 XLM-RoBERTa（或简称 XLM-R）所取代，这就是我们将在本章中考虑的模型。

正如我们在第 3 章中看到的，XLM-R 仅使用 MLM 作为 100 种语言的预训练目标，但其预训练语料库与其前辈相比具有巨大的规模：每种语言的 Wikipedia 转储和 2.5 TB的 Common Crawl 数据来自网络。这个语料库比早期模型中使用的语料库大几个数量级，并为缅甸语和斯瓦希里语等资源匮乏的语言提供了显着的信号提升，这些语言中只有少量的维基百科文章。

模型名称中的 RoBERTa 部分指的是预训练方法与单语 RoBERTa 模型相同。RoBERTa 的开发人员在 BERT 的几个方面进行了改进，特别是完全删除了下一句预测任务。3 XLM-R 还放弃了 XLM 中使用的语言嵌入，并使用 SentencePiece 直接对原始文本进行标记。4除了多语言特性外，XLM-R 和 RoBERTa 之间的显着区别在于各自词汇的大小：250,000 个标记对 55,000 个！

XLM-R 是多语言 NLU 任务的绝佳选择。在下一节中，我们将探讨它如何有效地跨多种语言进行标记。

仔细研究标记化

XLM-R 没有使用 WordPiece 分词器，而是使用了一个名为 SentencePiece 的分词器，它在所有一百种语言的原始文本上进行训练。为了了解 SentencePiece 与 WordPiece 的比较，让我们以通常的方式使用Transformers 加载 BERT 和 XLM-R 标记器：

from transformers import AutoTokenizer

bert_model_name = "bert-base-cased"
xlmr_model_name = "xlm-roberta-base"
bert_tokenizer = AutoTokenizer.from_pretrained(bert_model_name)
xlmr_tokenizer = AutoTokenizer.from_pretrained(xlmr_model_name)

通过编码一小段文本，我们还可以检索每个模型在预训练期间使用的特殊标记：

text = "Jack Sparrow loves New York!"
bert_tokens = bert_tokenizer(text).tokens()
xlmr_tokens = xlmr_tokenizer(text).tokens()

在这里，我们看到BERT 用于句子分类任务的不是[CLS]and标记，而是 XLM-R 使用and来表示序列的开始和结束。这些标记是在标记化的最后阶段添加的，我们将在接下来看到。[SEP]<s><\s>

标记器管道

到目前为止，我们已经将标记化视为将字符串转换为整数的单个操作，我们可以通过模型传递。这并不完全准确，如果我们仔细观察，我们会发现它实际上是一个完整的处理管道，通常由四个步骤组成，如图 4-1所示。

图 4-1。标记化管道中的步骤

让我们仔细看看每个处理步骤，并用例句“杰克斯派洛爱纽约！”来说明它们的效果：

正常化

此步骤对应于您应用于原始字符串以使其“更干净”的一组操作。常见操作包括去除空格和删除重音字符。Unicode 规范化是许多分词器应用的另一种常见的规范化操作，以处理经常存在不同方式来编写相同字符的事实。这会使“相同”字符串的两个版本（即具有相同的抽象字符序列）显得不同；像 NFC、NFD、NFKC 和 NFKD 等 Unicode 规范化方案用标准形式替换了编写相同字符的各种方法。规范化的另一个例子是小写。如果预计模型只接受和使用小写字符，则可以使用此技术来减少所需词汇的大小。标准化后，我们的示例字符串看起来像“杰克麻雀爱纽约！”。

预标记化

此步骤将文本拆分为较小的对象，这些对象为您的标记在训练结束时的上限提供了上限。考虑这一点的一个好方法是 pretokenizer 将您的文本拆分为“单词”，您的最终标记将成为这些单词的一部分。对于允许这样做的语言（英语、德语和许多印欧语系），字符串通常可以拆分为带有空格和标点符号的单词。例如，这一步可能会改变我们的 ["jack", "sparrow", "loves", "new", "york", "!"]. 然后这些词更容易分成子词在管道的下一步中使用字节对编码 (BPE) 或 Unigram 算法。然而，拆分成“单词”并不总是一种微不足道的确定性操作，甚至不是一个有意义的操作。例如，在中文、日文或韩文等语言中，对印欧语单词等语义单元中的符号进行分组可能是具有多个同等有效组的非确定性操作。在这种情况下，最好不要对文本进行预标记，而是使用特定于语言的库进行预标记。

分词器模型

一旦输入文本被规范化和预标记，标记器就会对单词应用子词拆分模型。这是需要在您的语料库上训练的管道部分（或者如果您使用的是预训练的标记器，则已经训练过）。该模型的作用是将词拆分为子词，以减小词汇量，并尽量减少词汇外标记的数量。存在几种子词标记化算法，包括 BPE、Unigram 和 WordPiece。例如，我们正在运行的示例可能看起来像[jack, spa, rrow, loves, new, york, !]应用了分词器模型之后的样子。请注意，此时我们不再有字符串列表，而是整数列表（输入 ID）；为了保持示例说明性，我们保留了单词但删除了引号以指示转换。

后期处理

这是标记化管道的最后一步，其中可以对标记列表应用一些额外的转换——例如，在标记索引的输入序列的开头或结尾添加特殊标记。例如，BERT 风格的分词器会添加分类和分隔符： [CLS, jack, spa, rrow, loves, new, york, !, SEP]. 这个序列（回想一下，这将是一个整数序列，而不是您在此处看到的标记）然后可以馈送到模型中。

回到我们对 XLM-R 和 BERT 的比较，我们现在了解到 SentencePiece 在后处理步骤中添加了<s>and<\s>而不是[CLS]and [SEP]（作为惯例，我们将继续在图形插图中使用[CLS]and ）。[SEP]让我们回到 SentencePiece 分词器，看看它有什么特别之处。

"".join(xlmr_tokens).replace(u"\u2581", " ")

'<s> Jack Sparrow loves New York!</s>'

用于命名实体识别的转换器

在第 2 章中，我们看到对于文本分类，BERT 使用特殊[CLS]标记来表示整个文本序列。然后将该表示通过全连接或密集层馈送，以输出所有离散标签值的分布，如图 4-2所示。

BERT 和其他仅编码器的转换器对 NER 采取了类似的方法，除了每个单独输入令牌的表示被馈送到相同的全 连接层以输出令牌的实体。出于这个原因，NER通常被定义为一个token分类 任务。该过程类似于 图 4-3中的图表。

图 4-3。微调基于编码器的转换器以进行命名实体识别

到目前为止，一切都很好，但是我们应该如何处理标记分​​类任务中的子词呢？例如， 图 4-3中的名字“Christa”被标记为子词“Chr”和“##ista”，那么应该为哪个（s）分配B-PER标签？

在 BERT 论文中，5位作者将此标签分配给第一个子词（在我们的示例中为“Chr”）并忽略了以下子词（“##ista”）。这是我们将在这里采用的约定，我们将用IGN. 我们稍后可以在后处理步骤中轻松地将第一个子词的预测标签传播到后续子词。我们也可以选择包含“##ista”子词的表示，方法是为其分配 B-LOC标签的副本，但这违反了 IOB2 格式。

幸运的是，我们在 BERT 中看到的所有架构方面都继承了 XLM-R，因为它的架构基于 RoBERTa，与 BERT 相同！接下来，我们将看到 Transformers 如何通过微小的修改来支持许多其他任务。

Transformers 模型类的剖析

Transformers 围绕每个架构和任务的专用类进行组织。与不同任务关联的模型类根据 <ModelName>For<Task>约定或AutoModelFor<Task>在使用AutoModel类时命名。

但是，这种方法有其局限性，为了激发更深入地了解Transformers API，请考虑以下场景。假设你有一个很棒的想法来解决一个你想了很久的 NLP 问题，它使用了一个 Transformer 模型。因此，你与老板开会，并通过精心制作的 PowerPoint 演示文稿，宣传如果你最终能解决问题，你可以增加部门的收入。对你丰富多彩的演讲和利润的谈论印象深刻，你的老板慷慨地同意给你一周的时间来建立一个概念验证。对结果感到满意，您立即开始工作。你启动你的 GPU 并打开一个笔记本。你执行 from transformers import BertForTaskXY（注意TaskXY是您想要解决的虚构任务），当可怕的红色充满您的屏幕时，颜色会从您的脸上消失： 。哦，不，您的用例没有 BERT 模型！如果你必须自己实现整个模型，你怎么能在一周内完成这个项目？！你甚至应该从哪里开始？ImportEr⁠ror:​ can⁠not import name BertForTaskXY

不要恐慌！ Transformers 旨在使您能够轻松地为特定用例扩展现有模型。您可以从预训练模型加载权重，并且可以访问特定于任务的辅助函数。这使您可以以很少的开销为特定目标构建自定义模型。在本节中，我们将了解如何实现我们自己的自定义模型。

import torch.nn as nn
from transformers import XLMRobertaConfig
from transformers.modeling_outputs import TokenClassifierOutput
from transformers.models.roberta.modeling_roberta import RobertaModel
from transformers.models.roberta.modeling_roberta import RobertaPreTrainedModel

class XLMRobertaForTokenClassification(RobertaPreTrainedModel):
    config_class = XLMRobertaConfig

    def __init__(self, config):
        super().__init__(config)
        self.num_labels = config.num_labels
        # Load model body
        self.roberta = RobertaModel(config, add_pooling_layer=False)
        # Set up token classification head
        self.dropout = nn.Dropout(config.hidden_dropout_prob)
        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
        # Load and initialize weights
        self.init_weights()

    def forward(self, input_ids=None, attention_mask=None, token_type_ids=None,
                labels=None, **kwargs):
        # Use model body to get encoder representations
        outputs = self.roberta(input_ids, attention_mask=attention_mask,
                               token_type_ids=token_type_ids, **kwargs)
        # Apply classifier to encoder representation
        sequence_output = self.dropout(outputs[0])
        logits = self.classifier(sequence_output)
        # Calculate losses
        loss = None
        if labels is not None:
            loss_fct = nn.CrossEntropyLoss()
            loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
        # Return model output object
        return TokenClassifierOutput(loss=loss, logits=logits,
                                     hidden_states=outputs.hidden_states,
                                     attentions=outputs.attentions)

index2tag = {idx: tag for idx, tag in enumerate(tags.names)}
tag2index = {tag: idx for idx, tag in enumerate(tags.names)}

from transformers import AutoConfig

xlmr_config = AutoConfig.from_pretrained(xlmr_model_name,
                                         num_labels=tags.num_classes,
                                         id2label=index2tag, label2id=tag2index)

import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
xlmr_model = (XLMRobertaForTokenClassification
              .from_pretrained(xlmr_model_name, config=xlmr_config)
              .to(device))

input_ids = xlmr_tokenizer.encode(text, return_tensors="pt")
pd.DataFrame([xlmr_tokens, input_ids[0].numpy()], index=["Tokens", "Input IDs"])

outputs = xlmr_model(input_ids.to(device)).logits
predictions = torch.argmax(outputs, dim=-1)
print(f"Number of tokens in sequence: {len(xlmr_tokens)}")
print(f"Shape of outputs: {outputs.shape}")

Number of tokens in sequence: 10
Shape of outputs: torch.Size([1, 10, 7])

preds = [tags.names[p] for p in predictions[0].cpu().numpy()]
pd.DataFrame([xlmr_tokens, preds], index=["Tokens", "Tags"])

def tag_text(text, tags, model, tokenizer):
    # Get tokens with special characters
    tokens = tokenizer(text).tokens()
    # Encode the sequence into IDs
    input_ids = xlmr_tokenizer(text, return_tensors="pt").input_ids.to(device)
    # Get predictions as distribution over 7 possible classes
    outputs = model(input_ids)[0]
    # Take argmax to get most likely class per token
    predictions = torch.argmax(outputs, dim=2)
    # Convert to DataFrame
    preds = [tags.names[p] for p in predictions[0].cpu().numpy()]
    return pd.DataFrame([tokens, preds], index=["Tokens", "Tags"])

为 NER 标记文本

现在我们已经确定分词器和模型可以对单个示例进行编码，下一步是对整个数据集进行分词，以便我们可以将其传递给 XLM-R 模型进行微调。正如我们在 第 2 章中看到的，数据集提供了一种使用操作标记对象 Dataset 的快速方法map()。为了实现这一点，回想一下，我们首先需要定义一个具有最小签名的函数：

function(examples: Dict[str, List]) -> Dict[str, List]

其中examples相当于 a 的一个切片Dataset，例如 panx_de['train'][:10]. 由于 XLM-R 分词器返回模型输入的输入 ID，我们只需要使用注意掩码和标签 ID 来扩充此信息，标签 ID 对有关与每个 NER 标签关联的令牌的信息进行编码。

按照 Transformers 文档中采用的方法，让我们首先将单词和标签收集为普通列表，看看它是如何与我们的单个德语示例一起工作的：

words, labels = de_example["tokens"], de_example["ner_tags"]

接下来，我们标记每个单词并使用is_split_into_words参数告诉标记器我们的输入序列已经被分割成单词：

tokenized_input = xlmr_tokenizer(de_example["tokens"], is_split_into_words=True)
tokens = xlmr_tokenizer.convert_ids_to_tokens(tokenized_input["input_ids"])
pd.DataFrame([tokens], index=["Tokens"])

在这个例子中，我们可以看到分词器将“Einwohnern”拆分为两个子词，“Einwohner”和“n”。由于我们遵循只有“Einwohner”应该与B-LOC标签相关联的约定，我们需要一种方法来掩盖第一个子词之后的子词表示。幸运的是，tokenized_input 是一个包含一个word_ids()函数的类，可以帮助我们实现这一点：

word_ids = tokenized_input.word_ids()
pd.DataFrame([tokens, word_ids], index=["Tokens", "Word IDs"])

这里我们可以看到word_ids已经将每个子词映射到序列中对应的索引words，所以第一个子词“2.000”被分配索引0，而“Einwohner”和“n”被分配索引1（因为“ Einwohnern”是 words) 中的第二个词。我们还可以看到像<s>和之类的特殊标记<\s>被映射到None. 让我们将 –100 设置为这些特殊标记和我们希望在训练期间屏蔽的子词的标签：

previous_word_idx = None
label_ids = []

for word_idx in word_ids:
    if word_idx is None or word_idx == previous_word_idx:
        label_ids.append(-100)
    elif word_idx != previous_word_idx:
        label_ids.append(labels[word_idx])
    previous_word_idx = word_idx

labels = [index2tag[l] if l != -100 else "IGN" for l in label_ids]
index = ["Tokens", "Word IDs", "Label IDs", "Labels"]

pd.DataFrame([tokens, word_ids, label_ids, labels], index=index)

就是这样！我们可以清楚地看到标签 ID 如何与标记对齐，因此让我们通过定义一个包含所有逻辑的函数来将其扩展到整个数据集：

def tokenize_and_align_labels(examples):
    tokenized_inputs = xlmr_tokenizer(examples["tokens"], truncation=True,
                                      is_split_into_words=True)
    labels = []
    for idx, label in enumerate(examples["ner_tags"]):
        word_ids = tokenized_inputs.word_ids(batch_index=idx)
        previous_word_idx = None
        label_ids = []
        for word_idx in word_ids:
            if word_idx is None or word_idx == previous_word_idx:
                label_ids.append(-100)
            else:
                label_ids.append(label[word_idx])
            previous_word_idx = word_idx
        labels.append(label_ids)
    tokenized_inputs["labels"] = labels
    return tokenized_inputs

我们现在拥有了对每个拆分进行编码所需的所有成分，所以让我们编写一个可以迭代的函数：

def encode_panx_dataset(corpus):
    return corpus.map(tokenize_and_align_labels, batched=True,
                      remove_columns=['langs', 'ner_tags', 'tokens'])

通过将此函数应用于对象，我们每次拆分DatasetDict都会得到一个编码 对象。Dataset让我们用它来编码我们的德语语料库：

panx_de_encoded = encode_panx_dataset(panx_ch["de"])

现在我们有了一个模型和一个数据集，我们需要定义一个性能指标。

绩效指标

评估 NER 模型类似于评估文本分类模型，通常报告精度、召回率和 F 1分数的结果。唯一的微妙之处是，一个实体的所有单词都需要被正确预测，才能使预测被视为正确。幸运的是，有一个名为 seqeval的漂亮库专为此类任务而设计。例如，给定一些占位符 NER 标签和模型预测，我们可以通过 seqeval 的classification_report()函数计算指标：

from seqeval.metrics import classification_report

y_true = [["O", "O", "O", "B-MISC", "I-MISC", "I-MISC", "O"],
          ["B-PER", "I-PER", "O"]]
y_pred = [["O", "O", "B-MISC", "I-MISC", "I-MISC", "I-MISC", "O"],
          ["B-PER", "I-PER", "O"]]
print(classification_report(y_true, y_pred))

              precision    recall  f1-score   support

        MISC       0.00      0.00      0.00         1
         PER       1.00      1.00      1.00         1

   micro avg       0.50      0.50      0.50         2
   macro avg       0.50      0.50      0.50         2
weighted avg       0.50      0.50      0.50         2

正如我们所看到的，seqeval期望预测和标签作为列表的列表，每个列表对应于我们验证或测试集中的单个示例。为了在训练期间整合这些指标，我们需要一个函数来获取模型的输出并将它们转换为seqeval期望的列表。下面通过确保我们忽略与后续子词关联的标签 ID 来解决问题：

import numpy as np

def align_predictions(predictions, label_ids):
    preds = np.argmax(predictions, axis=2)
    batch_size, seq_len = preds.shape
    labels_list, preds_list = [], []

    for batch_idx in range(batch_size):
        example_labels, example_preds = [], []
        for seq_idx in range(seq_len):
            # Ignore label IDs = -100
            if label_ids[batch_idx, seq_idx] != -100:
                example_labels.append(index2tag[label_ids[batch_idx][seq_idx]])
                example_preds.append(index2tag[preds[batch_idx][seq_idx]])

        labels_list.append(example_labels)
        preds_list.append(example_preds)

    return preds_list, labels_list

配备性能指标后，我们可以继续实际训练模型。

微调 XLM-RoBERTa

我们现在拥有微调模型的所有要素！我们的第一个策略是在 PAN-X 的德语子集上微调我们的基础模型，然后评估其在法语、意大利语和英语上的零样本跨语言性能。像往常一样，我们将使用 

TransformerTrainer来处理我们的训练循环，所以首先我们需要使用TrainingArguments类定义训练属性：

from transformers import TrainingArguments

num_epochs = 3
batch_size = 24
logging_steps = len(panx_de_encoded["train"]) // batch_size
model_name = f"{xlmr_model_name}-finetuned-panx-de"
training_args = TrainingArguments(
    output_dir=model_name, log_level="error", num_train_epochs=num_epochs,
    per_device_train_batch_size=batch_size,
    per_device_eval_batch_size=batch_size, evaluation_strategy="epoch",
    save_steps=1e6, weight_decay=0.01, disable_tqdm=False,
    logging_steps=logging_steps, push_to_hub=True)

在这里，我们在每个 epoch 结束时评估模型对验证集的预测，调整权重衰减，并设置 save_steps为较大的数字以禁用检查点，从而加快训练速度。

这也是确保我们登录到 Hugging Face Hub 的一个好点（如果您在终端中工作，则可以huggingface-cli login改为执行命令）：

from huggingface_hub import notebook_login

notebook_login()

我们还需要告诉Trainer如何计算验证集上的指标，所以在这里我们可以使用align_predictions()我们之前定义的函数来提取seqeval所需格式的预测和标签来计算F 1 -score：

from seqeval.metrics import f1_score

def compute_metrics(eval_pred):
    y_pred, y_true = align_predictions(eval_pred.predictions,
                                       eval_pred.label_ids)
    return {"f1": f1_score(y_true, y_pred)}

最后一步是定义一个数据整理器，以便我们可以将每个输入序列填充到批处理中的最大序列长度。 Transformers 为令牌分类提供了一个专用的数据整理器，它将与输入一起填充标签：

from transformers import DataCollatorForTokenClassification

data_collator = DataCollatorForTokenClassification(xlmr_tokenizer)

填充标签是必要的，因为与文本分类任务不同，标签也是序列。这里的一个重要细节是标签序列填充了值 –100，正如我们所见，PyTorch 损失函数会忽略该值。

我们将在本章的课程中训练几个模型，因此我们将避免Trainer通过创建一个model_init()方法来为每个模型初始化一个新模型。此方法加载未经训练的模型并在调用开始时train()调用：

def model_init():
    return (XLMRobertaForTokenClassification
            .from_pretrained(xlmr_model_name, config=xlmr_config)
            .to(device))

我们现在可以将所有这些信息与编码数据集一起传递给Trainer：

from transformers import Trainer

trainer = Trainer(model_init=model_init, args=training_args,
                  data_collator=data_collator, compute_metrics=compute_metrics,
                  train_dataset=panx_de_encoded["train"],
                  eval_dataset=panx_de_encoded["validation"],
                  tokenizer=xlmr_tokenizer)

然后按如下方式运行训练循环并将最终模型推送到 Hub：

trainer.train() trainer.push_to_hub(commit_message="Training completed!")

这些 F1 分数对于 NER 模型来说非常好。为了确认我们的模型按预期工作，让我们在简单示例的德语翻译上对其进行测试：

text_de = "Jeff Dean ist ein Informatiker bei Google in Kalifornien"
tag_text(text_de, tags, trainer.model, xlmr_tokenizer)

有用！但是我们永远不应该对基于单个示例的性能过于自信。相反，我们应该对模型的错误进行适当而彻底的调查。在下一节中，我们将探讨如何为 NER 任务执行此操作。

错误分析

在我们深入研究 XLM-R 的多语言方面之前，让我们花一点时间来调查一下我们模型的错误。正如我们在第 2 章中看到的，对模型进行彻底的错误分析是训练和调试转换器（以及一般的机器学习模型）时最重要的方面之一。有几种故障模式看起来模型表现良好，但在实践中它有一些严重的缺陷。训练可能失败的例子包括：

• 我们可能不小心掩盖了太多的令牌，也掩盖了我们的一些标签，以获得真正有希望的损失下降。

• 该compute_metrics()函数可能存在高估真实性能的错误。

• 我们可能会将 NER 中的零类或O实体作为普通类包括在内，这将严重扭曲准确性和F 1 -score，因为它是多数类。

当模型的性能比预期的差很多时，查看错误可以产生有用的见解并揭示仅通过查看代码很难发现的错误。而且即使模型表现良好并且代码中没有错误，错误分析仍然是了解模型优缺点的有用工具。这些是我们在生产环境中部署模型时始终需要牢记的方面。

对于我们的分析，我们将再次使用我们可以使用的最强大的工具之一，即查看具有最高损失的验证示例。我们可以重用我们在第 2 章中构建的用于分析序列分类模型的大部分函数，​​但现在我们将计算样本序列中每个标记的损失。

让我们定义一个可以应用于验证集的方法：

from torch.nn.functional import cross_entropy

def forward_pass_with_label(batch):
    # Convert dict of lists to list of dicts suitable for data collator
    features = [dict(zip(batch, t)) for t in zip(*batch.values())]
    # Pad inputs and labels and put all tensors on device
    batch = data_collator(features)
    input_ids = batch["input_ids"].to(device)
    attention_mask = batch["attention_mask"].to(device)
    labels = batch["labels"].to(device)
    with torch.no_grad():
        # Pass data through model
        output = trainer.model(input_ids, attention_mask)
        # logit.size: [batch_size, sequence_length, classes]
        # Predict class with largest logit value on classes axis
        predicted_label = torch.argmax(output.logits, axis=-1).cpu().numpy()
    # Calculate loss per token after flattening batch dimension with view
    loss = cross_entropy(output.logits.view(-1, 7),
                         labels.view(-1), reduction="none")
    # Unflatten batch dimension and convert to numpy array
    loss = loss.view(len(input_ids), -1).cpu().numpy()

    return {"loss":loss, "predicted_label": predicted_label}

我们现在可以将此函数应用于整个验证集，map() 并将所有数据加载到 aDataFrame中以进行进一步分析：

valid_set = panx_de_encoded["validation"]
valid_set = valid_set.map(forward_pass_with_label, batched=True, batch_size=32)
df = valid_set.to_pandas()

标记和标签仍然使用它们的 ID 进行编码，所以让我们将标记和标签映射回字符串，以便更容易阅读结果。对于标签为 –100 的填充标记，我们分配一个特殊标签IGN，以便我们稍后过滤它们。我们还通过将它们截断为输入的长度来消除loss和predicted_label字段中的所有填充：

index2tag[-100] = "IGN"
df["input_tokens"] = df["input_ids"].apply(
    lambda x: xlmr_tokenizer.convert_ids_to_tokens(x))
df["predicted_label"] = df["predicted_label"].apply(
    lambda x: [index2tag[i] for i in x])
df["labels"] = df["labels"].apply(
    lambda x: [index2tag[i] for i in x])
df['loss'] = df.apply(
    lambda x: x['loss'][:len(x['input_ids'])], axis=1)
df['predicted_label'] = df.apply(
    lambda x: x['predicted_label'][:len(x['input_ids'])], axis=1)
df.head(1)

每列包含每个样本的标记、标签、预测标签等列表。让我们通过解包这些列表来单独查看令牌。该pan⁠das.Series.explode() 函数允许我们通过为原始行列表中的每个元素创建一行来在一行中完成此操作。由于一行中的所有列表都具有相同的长度，因此我们可以对所有列并行执行此操作。我们还删除了我们命名的填充标记IGN，因为它们的损失无论如何都是零。最后，我们将仍然是numpy.Array 对象的损失转换为标准浮点数：

df_tokens = df.apply(pd.Series.explode)
df_tokens = df_tokens.query("labels != 'IGN'")
df_tokens["loss"] = df_tokens["loss"].astype(float).round(2)
df_tokens.head(7)

有了这种形状的数据，我们现在可以按输入标记对其进行分组，并将每个标记的损失与计数、均值和总和进行汇总。最后，我们按损失的总和对聚合数据进行排序， 并查看哪些令牌在验证集中累积的损失最多：

(
    df_tokens.groupby("input_tokens")[["loss"]]
    .agg(["count", "mean", "sum"])
    .droplevel(level=0, axis=1)  # Get rid of multi-level columns
    .sort_values(by="sum", ascending=False)
    .reset_index()
    .round(2)
    .head(10)
    .T
)

我们可以在此列表中观察到几种模式：

• 空白标记的总损失最高，这并不奇怪，因为它也是列表中最常见的标记。但是，它的平均损失远低于列表中的其他代币。这意味着模型不会费力地对其进行分类。

• “in”、“von”、“der”和“und”等词出现的频率相对较高。它们经常与命名实体一起出现，有时是它们的一部分，这解释了为什么模型可能会将它们混合在一起。

• 单词开头的括号、斜杠和大写字母比较少见，但平均损失相对较高。我们将进一步调查它们。

我们还可以对标签 ID 进行分组并查看每个类别的损失：

(
    df_tokens.groupby("labels")[["loss"]]
    .agg(["count", "mean", "sum"])
    .droplevel(level=0, axis=1)
    .sort_values(by="mean", ascending=False)
    .reset_index()
    .round(2)
    .T
)

我们看到B⁠-⁠ORG平均损失最高，这意味着确定组织的开始对我们的模型构成挑战。

我们可以通过绘制标记分类的混淆矩阵来进一步分解这一点，我们看到一个组织的开始经常与随后的I-ORG标记混淆：

from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix

def plot_confusion_matrix(y_preds, y_true, labels):
    cm = confusion_matrix(y_true, y_preds, normalize="true")
    fig, ax = plt.subplots(figsize=(6, 6))
    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
    disp.plot(cmap="Blues", values_format=".2f", ax=ax, colorbar=False)
    plt.title("Normalized confusion matrix")
    plt.show()

plot_confusion_matrix(df_tokens["labels"], df_tokens["predicted_label"],
                      tags.names)

从图中可以看出，我们的模型最容易混淆B-ORG和I-ORG实体。否则，它非常擅长对剩余实体进行分类，这可以从混淆矩阵的近对角线性质中清楚地看出。

现在我们已经检查了令牌级别的错误，让我们继续看看具有高损失的序列。对于这个计算，我们将重新审视我们的“未爆炸” DataFrame，并通过对每个令牌的损失求和来计算总损失。为此，让我们首先编写一个函数来帮助我们显示带有标签和损失的标记序列：

def get_samples(df):
    for _, row in df.iterrows():
        labels, preds, tokens, losses = [], [], [], []
        for i, mask in enumerate(row["attention_mask"]):
            if i not in {0, len(row["attention_mask"])}:
                labels.append(row["labels"][i])
                preds.append(row["predicted_label"][i])
                tokens.append(row["input_tokens"][i])
                losses.append(f"{row['loss'][i]:.2f}")
        df_tmp = pd.DataFrame({"tokens": tokens, "labels": labels,
                               "preds": preds, "losses": losses}).T
        yield df_tmp

df["total_loss"] = df["loss"].apply(sum)
df_tmp = df.sort_values(by="total_loss", ascending=False).head(3)

for sample in get_samples(df_tmp):
    display(sample)

很明显，这些样本的标签有问题；比如联合国和中非共和国都被贴上了一个人的标签！同时，“8. Juli”在第一个例子中被标记为一个组织。事实证明，PAN-X 数据集的注释是通过自动化过程生成的。此类注释通常被称为“银标准”（与人工生成注释的“黄金标准”相反），并且在某些情况下自动化方法无法生成合理的标签也就不足为奇了。事实上，这种故障模式并不是自动方法所独有的。即使人类仔细注释数据，当注释者的注意力减弱或他们只是误解了句子时，也会发生错误。

我们之前注意到的另一件事是括号和斜线的损失相对较高。让我们看几个带左括号的序列示例：

df_tmp = df.loc[df["input_tokens"].apply(lambda x: u"\u2581(" in x)].head(2)
for sample in get_samples(df_tmp):
    display(sample)

一般来说，我们不会将括号及其内容作为命名实体的一部分包含在内，但这似乎是自动提取注释文档的方式。在其他示例中，括号包含地理规范。虽然这确实也是一个位置，但我们可能希望将其与注释中的原始位置断开。该数据集由不同语言的维基百科文章组成，文章标题通常在括号中包含某种解释。例如，在第一个示例中，括号中的文本表明 Hama 是一家“Unternehmen”或英文公司。这些是我们在推出模型时需要了解的重要细节，因为它们可能会对模型所属的整个管道的下游性能产生影响。

通过相对简单的分析，我们发现了我们的模型和数据集中的一些弱点。在实际用例中，我们将迭代这一步，清理数据集，重新训练模型，并分析新的错误，直到我们对性能感到满意。

在这里，我们分析了单一语言的错误，但我们也对跨语言的性能感兴趣。在下一节中，我们将进行一些实验，以了解 XLM-R 中的跨语言迁移效果如何。

跨语言转移

现在我们已经在德语上对 XLM-R 进行了微调，我们可以predict()通过 Trainer. 由于我们计划评估多种语言，让我们创建一个简单的函数来为我们执行此操作：

def get_f1_score(trainer, dataset):
    return trainer.predict(dataset).metrics["test_f1"]

我们可以使用此函数来检查测试集的性能并跟踪我们在 a 中的分数dict：

f1_scores = defaultdict(dict)
f1_scores["de"]["de"] = get_f1_score(trainer, panx_de_encoded["test"])
print(f"F1-score of [de] model on [de] dataset: {f1_scores['de']['de']:.3f}")

F1-score of [de] model on [de] dataset: 0.868

这些对于 NER 任务来说是相当不错的结果。我们的指标在 85% 的范围内，我们可以看到模型似乎在ORG实体上最挣扎，可能是因为这些在训练数据中最不常见，而且许多组织名称在 XLM-R 的词汇表中很少见。其他语言呢？为了热身，让我们看看我们的模型是如何在法国票价上对德国票价进行微调的：

text_fr = "Jeff Dean est informaticien chez Google en Californie"
tag_text(text_fr, tags, trainer.model, xlmr_tokenizer)

不错！尽管两种语言的名称和组织相同，但该模型确实成功地正确标记了“Kalifornien”的法语翻译。接下来，让我们通过编写一个对数据集进行编码并生成分类报告的简单函数来量化我们的德国模型在整个法国测试集上的表现：

def evaluate_lang_performance(lang, trainer):
    panx_ds = encode_panx_dataset(panx_ch[lang])
    return get_f1_score(trainer, panx_ds["test"])

f1_scores["de"]["fr"] = evaluate_lang_performance("fr", trainer)
print(f"F1-score of [de] model on [fr] dataset: {f1_scores['de']['fr']:.3f}")

F1-score of [de] model on [fr] dataset: 0.714

尽管我们看到微平均指标下降了大约 15 个点，但请记住，我们的模型没有看到一个带标签的法语示例！一般来说，性能下降的大小与语言之间的“距离”有关。尽管德语和法语被归为印欧语系，但它们在技术上属于不同的语系：分别是日耳曼语和罗曼语。

接下来，让我们来评估一下意大利语的表现。由于意大利语也是一种罗曼语，我们希望得到与法语相似的结果：

f1_scores["de"]["it"] = evaluate_lang_performance("it", trainer)
print(f"F1-score of [de] model on [it] dataset: {f1_scores['de']['it']:.3f}")

F1-score of [de] model on [it] dataset: 0.692

事实上，我们的期望得到了F 1分数的证实。最后，让我们来看看属于日耳曼语系的英语的表现：

f1_scores["de"]["en"] = evaluate_lang_performance("en", trainer)
print(f"F1-score of [de] model on [en] dataset: {f1_scores['de']['en']:.3f}")

F1-score of [de] model on [en] dataset: 0.589

令人惊讶的是，我们的模型在英语上的表现最差，尽管我们可能直觉地认为德语与英语比法语更相似。在对德语进行了微调并执行了到法语和英语的零样本迁移之后，接下来让我们看看什么时候直接在目标语言上进行微调是有意义的。

def train_on_subset(dataset, num_samples):
    train_ds = dataset["train"].shuffle(seed=42).select(range(num_samples))
    valid_ds = dataset["validation"]
    test_ds = dataset["test"]
    training_args.logging_steps = len(train_ds) // batch_size

    trainer = Trainer(model_init=model_init, args=training_args,
        data_collator=data_collator, compute_metrics=compute_metrics,
        train_dataset=train_ds, eval_dataset=valid_ds, tokenizer=xlmr_tokenizer)
    trainer.train()
    if training_args.push_to_hub:
        trainer.push_to_hub(commit_message="Training completed!")

    f1_score = get_f1_score(trainer, test_ds)
    return pd.DataFrame.from_dict(
        {"num_samples": [len(train_ds)], "f1_score": [f1_score]})

panx_fr_encoded = encode_panx_dataset(panx_ch["fr"])

training_args.push_to_hub = False
metrics_df = train_on_subset(panx_fr_encoded, 250)
metrics_df

for num_samples in [500, 1000, 2000, 4000]:
    metrics_df = metrics_df.append(
        train_on_subset(panx_fr_encoded, num_samples), ignore_index=True)

fig, ax = plt.subplots()
ax.axhline(f1_scores["de"]["fr"], ls="--", color="r")
metrics_df.set_index("num_samples").plot(ax=ax)
plt.legend(["Zero-shot from de", "Fine-tuned on fr"], loc="lower right")
plt.ylim((0, 1))
plt.xlabel("Number of Training Samples")
plt.ylabel("F1 Score")
plt.show()

from datasets import concatenate_datasets

def concatenate_splits(corpora):
    multi_corpus = DatasetDict()
    for split in corpora[0].keys():
        multi_corpus[split] = concatenate_datasets(
            [corpus[split] for corpus in corpora]).shuffle(seed=42)
    return multi_corpus

panx_de_fr_encoded = concatenate_splits([panx_de_encoded, panx_fr_encoded])

training_args.logging_steps = len(panx_de_fr_encoded["train"]) // batch_size
training_args.push_to_hub = True
training_args.output_dir = "xlm-roberta-base-finetuned-panx-de-fr"

trainer = Trainer(model_init=model_init, args=training_args,
    data_collator=data_collator, compute_metrics=compute_metrics,
    tokenizer=xlmr_tokenizer, train_dataset=panx_de_fr_encoded["train"],
    eval_dataset=panx_de_fr_encoded["validation"])

trainer.train()
trainer.push_to_hub(commit_message="Training completed!")

for lang in langs:
    f1 = evaluate_lang_performance(lang, trainer)
    print(f"F1-score of [de-fr] model on [{lang}] dataset: {f1:.3f}")

F1-score of [de-fr] model on [de] dataset: 0.866
F1-score of [de-fr] model on [fr] dataset: 0.868
F1-score of [de-fr] model on [it] dataset: 0.815
F1-score of [de-fr] model on [en] dataset: 0.677

corpora = [panx_de_encoded]

# Exclude German from iteration
for lang in langs[1:]:
    training_args.output_dir = f"xlm-roberta-base-finetuned-panx-{lang}"
    # Fine-tune on monolingual corpus
    ds_encoded = encode_panx_dataset(panx_ch[lang])
    metrics = train_on_subset(ds_encoded, ds_encoded["train"].num_rows)
    # Collect F1-scores in common dict
    f1_scores[lang][lang] = metrics["f1_score"][0]
    # Add monolingual corpus to list of corpora to concatenate
    corpora.append(ds_encoded)

corpora_encoded = concatenate_splits(corpora)

training_args.logging_steps = len(corpora_encoded["train"]) // batch_size
training_args.output_dir = "xlm-roberta-base-finetuned-panx-all"

trainer = Trainer(model_init=model_init, args=training_args,
    data_collator=data_collator, compute_metrics=compute_metrics,
    tokenizer=xlmr_tokenizer, train_dataset=corpora_encoded["train"],
    eval_dataset=corpora_encoded["validation"])

trainer.train()
trainer.push_to_hub(commit_message="Training completed!")

for idx, lang in enumerate(langs):
    f1_scores["all"][lang] = get_f1_score(trainer, corpora[idx]["test"])

scores_data = {"de": f1_scores["de"],
               "each": {lang: f1_scores[lang][lang] for lang in langs},
               "all": f1_scores["all"]}
f1_scores_df = pd.DataFrame(scores_data).T.round(4)
f1_scores_df.rename_axis(index="Fine-tune on", columns="Evaluated on",
                         inplace=True)
f1_scores_df

与模型小部件交互

在本章中，我们将很多经过微调的模型推送到了 Hub。尽管我们可以pipeline()在本地机器上使用该功能与它们进行交互，但 Hub 提供了非常适合这种工作流程的小部件。图 4-5显示了我们的 检查点的一个示例 transformersbook/xlm-roberta-base-finetuned-panx-all，正如您所见，它在识别德语文本的所有实体方面做得很好。

图 4-5。Hugging Face Hub 上的小部件示例

结论

在本章中，我们看到了如何使用在 100 种语言上预训练的单个转换器来处理多语言语料库上的 NLP 任务：XLM-R。虽然我们能够证明，当只有少量标记示例可用于微调时，从德语到法语的跨语言迁移是有竞争力的，但如果目标语言与目标语言显着不同，通常不会出现这种良好的性能。基本模型在预训练期间使用的 100 种语言上进行了微调，或者不是其中一种。最近的提议如 MAD-X 正是针对这些低资源场景而设计的，而且由于 MAD-X 构建在 Transformer 之上，您可以轻松地调整本章中的代码以使用它！6

到目前为止，我们已经研究了两个任务：序列分类和标记分类。这些都属于自然语言理解领域，其中文本被合成为预测。在下一章中，我们将首先了解文本生成，其中模型的输入和输出都是文本。