快速分词器的特殊能力
在本节中，我们将更深入地了解 🤗 Transformers 中分词器的功能。到目前为止，我们只使用它们来分词输入或将 ID 解码回文本，但分词器——尤其是那些由 🤗 Tokenizers 库支持的分词器——可以做更多的事情。为了说明这些附加功能，我们将探索如何重现我们第一次在第 1 章中遇到的token-classification（我们称为ner）和question-answering管道的结果。
在接下来的讨论中，我们将经常区分“慢速”和“快速”分词器。“慢速”分词器是指在 🤗 Transformers 库内部用 Python 编写的分词器，而“快速”版本是由 🤗 Tokenizers 提供的分词器，它们是用 Rust 编写的。如果你还记得第 5 章中那个报告快速和慢速分词器分词药物评论数据集所需时间的表格，你应该就能理解我们为什么称它们为快速和慢速了。
| 快速分词器 | 慢速分词器 | |
|---|---|---|
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 对您是否有意义。
Token 分类管道内部
在第 1 章中，我们首次尝试应用 NER——其中任务是识别文本的哪些部分对应于人、地点或组织等实体——使用 🤗 Transformers 的pipeline()函数。然后，在第 2 章中，我们看到了管道如何将获取原始文本预测所需的三个阶段组合在一起：分词、将输入传递给模型以及后处理。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()函数的情况下获得这些结果！
从输入到预测
首先，我们需要对输入进行分词并将其传递给模型。这与第 2 章中完全相同；我们使用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是任何命名实体中都不存在的标记的标签（它代表“外部”），然后我们每种类型的实体（其他、人、组织和地点）都有两个标签。标签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 或 Byte-Pair-Encoding 分词器（将在本章后面讨论），我们将不得不编写另一套规则。
使用偏移量，所有这些自定义代码都消失了：我们只需要获取原始文本中以第一个标记开头并以最后一个标记结束的跨度。因此，对于标记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 库中分词器的最后一个功能：当我们将输入截断到给定长度时处理溢出标记。