快速分词器的超能力

在本节中，我们将仔细研究 🤗 Transformers 中分词器的功能。到目前为止，我们只使用它们对输入进行分词或将 ID 解码回文本，但是分词器——尤其是那些由 🤗 Tokenizers 库支持的分词器——可以做更多的事情。为了说明这些附加功能，我们将探索如何重现我们在第一章中首次遇到的 token-classification（我们称之为 ner）和 question-answering 流水线的结果。

在下面的讨论中，我们将经常区分“慢速”分词器和“快速”分词器。慢速分词器是指在 🤗 Transformers 库内部用 Python 编写的分词器，而快速版本是由 🤗 Tokenizers 提供的，它们是用 Rust 编写的。如果你还记得第五章中报告快速和慢速分词器对药物评论数据集进行分词所需时间的表格，你就应该明白为什么我们称它们为快速和慢速分词器。

	快速分词器	慢速分词器
`batched=True`	10.8秒	4分41秒
`batched=False`	59.2秒	5分3秒

⚠️ 对单个句子进行分词时，你不会总是看到相同分词器的慢速版本和快速版本之间的速度差异。事实上，快速版本可能实际上更慢！只有同时并行地对大量文本进行分词时，你才能清楚地看到差异。

批处理编码

分词器的输出不是一个简单的 Python 字典；我们得到的是一个特殊的 BatchEncoding 对象。它是字典的子类（这就是为什么我们之前能够毫无问题地索引该结果），但它具有主要由快速分词器使用的附加方法。

除了并行化能力外，快速分词器的关键功能是它们始终跟踪最终标记来自的原始文本范围——我们称之为*偏移映射*的功能。这反过来又解锁了将每个单词映射到它生成的标记或将原始文本的每个字符映射到它所在的标记的功能，反之亦然。

让我们看一个例子

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
example = "My name is Sylvain and I work at Hugging Face in Brooklyn."
encoding = tokenizer(example)
print(type(encoding))

如前所述，我们在分词器的输出中得到一个 BatchEncoding 对象。

<class 'transformers.tokenization_utils_base.BatchEncoding'>

由于 AutoTokenizer 类默认选择一个快速分词器，我们可以使用此 BatchEncoding 对象提供的额外方法。我们有两种方法来检查我们的分词器是快速的还是慢速的。我们可以检查 tokenizer 的 is_fast 属性：

tokenizer.is_fast

True

或者检查我们 encoding 的相同属性：

encoding.is_fast

True

让我们看看快速分词器能让我们做什么。首先，我们可以直接访问标记，而无需将 ID 转换回标记：

encoding.tokens()

['[CLS]', 'My', 'name', 'is', 'S', '##yl', '##va', '##in', 'and', 'I', 'work', 'at', 'Hu', '##gging', 'Face', 'in',
 'Brooklyn', '.', '[SEP]']

在这种情况下，索引 5 处的标记是 ##yl，它是原始句子中“Sylvain”一词的一部分。我们还可以使用 word_ids() 方法获取每个标记来自的单词的索引：

encoding.word_ids()

[None, 0, 1, 2, 3, 3, 3, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11, 12, None]

我们可以看到分词器的特殊标记 [CLS] 和 [SEP] 被映射到 None，然后每个标记都被映射到它所源自的单词。这对于确定一个标记是否在一个单词的开头，或者两个标记是否在同一个单词中特别有用。我们可以依赖 ## 前缀来实现这一点，但它只适用于类 BERT 分词器；只要是快速分词器，这种方法就适用于任何类型的分词器。在下一章中，我们将看到如何利用此功能将我们为每个单词拥有的标签正确应用于命名实体识别（NER）和词性标注（POS）等任务中的标记。我们还可以使用它来在掩码语言建模中掩盖来自同一个单词的所有标记（一种称为*全词掩码*的技术）。

关于“单词”的定义很复杂。例如，“I'll”（“I will”的缩写）算一个单词还是两个单词？这实际上取决于分词器及其应用的预分词操作。有些分词器只在空格处进行分割，所以它们会将其视为一个单词。另一些分词器在空格之外还使用标点符号，所以会将其视为两个单词。

✏️ 试一试！ 使用 bert-base-cased 和 roberta-base 检查点创建一个分词器，然后用它们对“81s”进行分词。你观察到了什么？词 ID 是什么？

同样，有一个 sentence_ids() 方法可以用来将一个标记映射到它所属的句子（尽管在这种情况下，分词器返回的 token_type_ids 可以给我们相同的信息）。

最后，我们可以通过 word_to_chars() 或 token_to_chars() 以及 char_to_word() 或 char_to_token() 方法将任何单词或标记映射到原始文本中的字符，反之亦然。例如，word_ids() 方法告诉我们 ##yl 是索引 3 处单词的一部分，但它是句子中的哪个单词呢？我们可以这样找出：

start, end = encoding.word_to_chars(3)
example[start:end]

Sylvain

正如我们之前提到的，这一切都得益于快速分词器在*偏移量*列表中跟踪每个标记来自的文本范围。为了说明它们的用途，接下来我们将向你展示如何手动复制 token-classification 管道的结果。

✏️ 试一试！ 创建你自己的示例文本，看看你是否能理解哪些标记与词 ID 相关联，以及如何提取单个单词的字符跨度。为了获得额外加分，尝试使用两个句子作为输入，看看句子 ID 对你来说是否有意义。

分词分类流水线内部

在第一章中，我们首次尝试使用 🤗 Transformers 的 pipeline() 函数应用 NER — 任务是识别文本中与人、地点或组织等实体相对应的部分。然后，在第二章中，我们看到了流水线如何将获取原始文本预测所需的三个阶段组合在一起：分词、通过模型传递输入和后处理。token-classification 流水线中的前两个步骤与任何其他流水线相同，但后处理有点复杂 — 让我们看看它是如何进行的！

使用流水线获取基本结果

首先，让我们获取一个分词分类流水线，以便我们可以手动比较一些结果。默认使用的模型是 dbmdz/bert-large-cased-finetuned-conll03-english；它对句子执行 NER：

from transformers import pipeline

token_classifier = pipeline("token-classification")
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")

[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S', 'start': 11, 'end': 12},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl', 'start': 12, 'end': 14},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va', 'start': 14, 'end': 16},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in', 'start': 16, 'end': 18},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu', 'start': 33, 'end': 35},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging', 'start': 35, 'end': 40},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face', 'start': 41, 'end': 45},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

该模型正确地将“Sylvain”生成的每个标记识别为人，将“Hugging Face”生成的每个标记识别为组织，并将标记“Brooklyn”识别为地点。我们还可以要求流水线将对应于同一实体的标记分组在一起：

from transformers import pipeline

token_classifier = pipeline("token-classification", aggregation_strategy="simple")
token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.")

[{'entity_group': 'PER', 'score': 0.9981694, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.97960204, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.99321055, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

所选的 aggregation_strategy 将改变每个分组实体的计算分数。使用 "simple" 时，分数值就是给定实体中每个标记分数值的平均值：例如，“Sylvain”的分数值是我们在上一个示例中看到的标记 S、##yl、##va 和 ##in 分数值的平均值。其他可用的策略有：

"first"，其中每个实体的分数是该实体的第一个标记的分数（因此对于“Sylvain”将是 0.993828，即标记 S 的分数）
"max"，其中每个实体的分数是该实体中标记的最高分数（因此对于“Hugging Face”将是 0.98879766，即“Face”的分数）
"average"，其中每个实体的分数是组成该实体的单词分数的平均值（因此对于“Sylvain”与 "simple" 策略没有区别，但“Hugging Face”的分数将是 0.9819，即“Hugging”（0.975）和“Face”（0.98879）分数的平均值）

现在让我们看看如何在不使用 pipeline() 函数的情况下获得这些结果！

从输入到预测

首先，我们需要对输入进行分词并将其传递给模型。这与第二章中的操作完全相同；我们使用 AutoXxx 类实例化分词器和模型，然后将它们应用于我们的示例：

from transformers import AutoTokenizer, AutoModelForTokenClassification

model_checkpoint = "dbmdz/bert-large-cased-finetuned-conll03-english"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
model = AutoModelForTokenClassification.from_pretrained(model_checkpoint)

example = "My name is Sylvain and I work at Hugging Face in Brooklyn."
inputs = tokenizer(example, return_tensors="pt")
outputs = model(**inputs)

由于我们在这里使用 AutoModelForTokenClassification，我们为输入序列中的每个标记获得一组 logits：

print(inputs["input_ids"].shape)
print(outputs.logits.shape)

torch.Size([1, 19])
torch.Size([1, 19, 9])

我们有一个包含 1 个序列 19 个标记的批次，并且模型有 9 个不同的标签，因此模型的输出形状为 1 x 19 x 9。与文本分类流水线一样，我们使用 softmax 函数将这些 logits 转换为概率，并取 argmax 来获得预测（请注意，我们可以对 logits 取 argmax，因为 softmax 不会改变顺序）。

import torch

probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)[0].tolist()
predictions = outputs.logits.argmax(dim=-1)[0].tolist()
print(predictions)

[0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 6, 6, 6, 0, 8, 0, 0]

model.config.id2label 属性包含索引到标签的映射，我们可以使用它来理解预测：

model.config.id2label

{0: 'O',
 1: 'B-MISC',
 2: 'I-MISC',
 3: 'B-PER',
 4: 'I-PER',
 5: 'B-ORG',
 6: 'I-ORG',
 7: 'B-LOC',
 8: 'I-LOC'}

正如我们之前看到的，有 9 个标签：O 是不属于任何命名实体的标记的标签（它代表“outside”），然后我们为每种实体类型（杂项、人物、组织和地点）提供两个标签。标签 B-XXX 表示该标记是实体 XXX 的开头，标签 I-XXX 表示该标记在实体 XXX 内部。例如，在当前示例中，我们期望模型将标记 S 分类为 B-PER（人物实体的开头），并将标记 ##yl、##va 和 ##in 分类为 I-PER（人物实体内部）。

你可能会认为在这种情况下模型是错误的，因为它将 I-PER 标签赋予了所有这四个标记，但这并非完全正确。实际上，这些 B- 和 I- 标签有两种格式：*IOB1* 和 *IOB2*。IOB2 格式（下面用粉红色表示）是我们介绍的格式，而在 IOB1 格式（蓝色表示）中，以 B- 开头的标签仅用于分隔两个相邻的相同类型的实体。我们使用的模型是根据使用该格式的数据集进行微调的，这就是为什么它将 I-PER 标签分配给 S 标记。

有了这个映射，我们就可以（几乎完全）重现第一个流水线的结果了——我们只需获取未分类为 O 的每个标记的分数和标签：

results = []
tokens = inputs.tokens()

for idx, pred in enumerate(predictions):
    label = model.config.id2label[pred]
    if label != "O":
        results.append(
            {"entity": label, "score": probabilities[idx][pred], "word": tokens[idx]}
        )

print(results)

[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S'},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl'},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va'},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in'},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu'},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging'},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face'},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn'}]

这与我们之前得到的结果非常相似，但有一个例外：流水线还为我们提供了原始句子中每个实体的 start 和 end 信息。这就是我们的偏移映射发挥作用的地方。要获取偏移量，我们只需在将分词器应用于输入时设置 return_offsets_mapping=True：

inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
inputs_with_offsets["offset_mapping"]

[(0, 0), (0, 2), (3, 7), (8, 10), (11, 12), (12, 14), (14, 16), (16, 18), (19, 22), (23, 24), (25, 29), (30, 32),
 (33, 35), (35, 40), (41, 45), (46, 48), (49, 57), (57, 58), (0, 0)]

每个元组都是与每个标记对应的文本跨度，其中 (0, 0) 保留给特殊标记。我们之前看到索引 5 处的标记是 ##yl，它在这里的偏移量是 (12, 14)。如果我们在示例中获取相应的切片：

example[12:14]

我们获得了正确的文本跨度，没有 ##：

yl

使用此功能，我们现在可以完成之前的结果：

results = []
inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
tokens = inputs_with_offsets.tokens()
offsets = inputs_with_offsets["offset_mapping"]

for idx, pred in enumerate(predictions):
    label = model.config.id2label[pred]
    if label != "O":
        start, end = offsets[idx]
        results.append(
            {
                "entity": label,
                "score": probabilities[idx][pred],
                "word": tokens[idx],
                "start": start,
                "end": end,
            }
        )

print(results)

[{'entity': 'I-PER', 'score': 0.9993828, 'index': 4, 'word': 'S', 'start': 11, 'end': 12},
 {'entity': 'I-PER', 'score': 0.99815476, 'index': 5, 'word': '##yl', 'start': 12, 'end': 14},
 {'entity': 'I-PER', 'score': 0.99590725, 'index': 6, 'word': '##va', 'start': 14, 'end': 16},
 {'entity': 'I-PER', 'score': 0.9992327, 'index': 7, 'word': '##in', 'start': 16, 'end': 18},
 {'entity': 'I-ORG', 'score': 0.97389334, 'index': 12, 'word': 'Hu', 'start': 33, 'end': 35},
 {'entity': 'I-ORG', 'score': 0.976115, 'index': 13, 'word': '##gging', 'start': 35, 'end': 40},
 {'entity': 'I-ORG', 'score': 0.98879766, 'index': 14, 'word': 'Face', 'start': 41, 'end': 45},
 {'entity': 'I-LOC', 'score': 0.99321055, 'index': 16, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

这与我们从第一个流水线中得到的结果相同！

实体分组

使用偏移量来确定每个实体的起始和结束键很方便，但这些信息并非严格必要。然而，当我们想要将实体分组时，偏移量将为我们省去许多混乱的代码。例如，如果我们想要将标记 Hu、##gging 和 Face 分组，我们可以制定特殊规则，规定前两个应该在去除 ## 后连接在一起，而 Face 应该在添加空格后添加，因为它不以 ## 开头——但这只适用于这种特定类型的分词器。我们必须为 SentencePiece 或字节对编码分词器（本章后面讨论）编写另一套规则。

有了偏移量，所有这些自定义代码都消失了：我们只需获取原始文本中从第一个标记开始到最后一个标记结束的跨度。因此，在标记 Hu、##gging 和 Face 的情况下，我们应该从字符 33（Hu 的开头）开始，并在字符 45（Face 的结尾）之前结束：

example[33:45]

Hugging Face

为了编写对预测进行后处理同时对实体进行分组的代码，我们将连续且标记为 I-XXX 的实体分组在一起，除了第一个实体，它可以标记为 B-XXX 或 I-XXX（因此，当我们遇到 O、新类型的实体或 B-XXX 告诉我们相同类型的实体正在开始时，我们停止对实体进行分组）。

import numpy as np

results = []
inputs_with_offsets = tokenizer(example, return_offsets_mapping=True)
tokens = inputs_with_offsets.tokens()
offsets = inputs_with_offsets["offset_mapping"]

idx = 0
while idx < len(predictions):
    pred = predictions[idx]
    label = model.config.id2label[pred]
    if label != "O":
        # Remove the B- or I-
        label = label[2:]
        start, _ = offsets[idx]

        # Grab all the tokens labeled with I-label
        all_scores = []
        while (
            idx < len(predictions)
            and model.config.id2label[predictions[idx]] == f"I-{label}"
        ):
            all_scores.append(probabilities[idx][pred])
            _, end = offsets[idx]
            idx += 1

        # The score is the mean of all the scores of the tokens in that grouped entity
        score = np.mean(all_scores).item()
        word = example[start:end]
        results.append(
            {
                "entity_group": label,
                "score": score,
                "word": word,
                "start": start,
                "end": end,
            }
        )
    idx += 1

print(results)

我们得到了与我们的第二个流水线相同的结果！

[{'entity_group': 'PER', 'score': 0.9981694, 'word': 'Sylvain', 'start': 11, 'end': 18},
 {'entity_group': 'ORG', 'score': 0.97960204, 'word': 'Hugging Face', 'start': 33, 'end': 45},
 {'entity_group': 'LOC', 'score': 0.99321055, 'word': 'Brooklyn', 'start': 49, 'end': 57}]

偏移量非常有用，另一个例子是问答任务。深入研究该流水线（我们将在下一节中进行）还将使我们能够了解 🤗 Transformers 库中分词器的最后一个功能：当我们将输入截断到给定长度时处理溢出标记。