Tokenizers手册翻译（中文）

本文是一篇翻译文章，使用网络翻译工具进行翻译，全部内容为以下官网的英文文档。如有描述不清请参考英文文档。
如果对您有用，烦请点个免费的赞。
文档官网链接（国内官网镜像）

开始

Tokenizers

介绍

Tokenizers是一个快速而先进的分词器，针对研究和生产做出了优化。
🤗 Tokenizers 提供了当今最常用的 Tokenizer 的实现，专注于性能和多功能性。这些分词器也用于 🤗 Transformer 中。

主要特性

• 使用当今最常用的分词器训练新词汇表和分词。
• 由于 Rust 实现，速度非常快（包括训练和标记化）。在服务器的 CPU 上对 GB 文本进行标记所需的时间不到 20 秒。
• 易于使用，但也非常通用。
• 专为研究和生产而设计。
• 完全对齐跟踪。即使使用破坏性规范化，也始终可以获取原始句子中对应于任何标记的部分。
• 完成所有预处理：截断、填充、添加模型所需的特殊标记。

Quicktour

快速浏览

让我们快速了解🤗一下 Tokenizers 库的功能。该库提供了当今最常用的分词器的实现，它既易于使用又速度极快。

从头开始构建分词器

为了说明 Tokenizers 库的速度🤗有多快，让我们在几秒钟内在 wikitext-103（516M 文本）上训练一个新的分词器。首先，您需要下载此数据集并使用以下命令将其解压缩：

wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip
unzip wikitext-103-raw-v1.zip

训练分词器

在本教程中，我们将构建和训练字节对编码 （BPE） 分词器。有关不同类型分词器的更多信息，请查看 🤗Transformers 文档中的指南。在这里，训练 tokenizer 意味着它将通过以下方式学习合并规则：

• 从训练语料库中存在的所有字符作为标记开始。
• 确定最常见的令牌对并将其合并为一个令牌。
• 重复，直到词汇表（例如，标记的数量）达到我们想要的大小。

该库的主要 API 是 Tokenizer 类，以下是我们如何使用 BPE 模型进行实例化：

from tokenizers import Tokenizer
from tokenizers.models import BPE
tokenizer = Tokenizer(BPE(unk_token="[UNK]"))

要在 wikitext 文件上训练我们的分词器，我们需要实例化一个 [trainer]{.title-ref}，在本例中为 BpeTrainer

from tokenizers.trainers import BpeTrainer
trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])

我们可以设置训练参数，如 vocab_size 或 min_frequency（此处保留默认值 30,000 和 0），但最重要的部分是提供我们计划稍后使用special_tokens（它们在训练期间根本不使用），以便将它们插入到词汇表中。

编写特殊令牌列表的顺序很重要：此处 “[UNK]” 将获得 ID 0，“[CLS]” 将获得 ID 1，依此类推。

我们现在可以训练我们的分词器，但这并不是最佳选择。如果没有将我们的输入拆分为单词的预分词器，我们可能会得到与几个单词重叠的词元：例如，我们可以得到一个 “it is” 词元，因为这两个词经常彼此相邻出现。使用 pre-tokenizer 将确保没有 token 大于 pre-tokenizer 返回的单词。在这里，我们想要训练一个子词 BPE 分词器，我们将使用最简单的预分词器，通过在空格上进行拆分。

from tokenizers.pre_tokenizers import Whitespace
tokenizer.pre_tokenizer = Whitespace()

现在，我们只需使用我们想要使用的任何文件列表调用 Tokenizer.train 方法：

files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
tokenizer.train(files, trainer)

这应该只需要几秒钟就可以在完整的 wikitext 数据集上训练我们的分词器！要将 tokenizer 保存在一个包含其所有配置和词汇的文件中，只需使用$Tokenizer.save$ 方法：

tokenizer.save("data/tokenizer-wiki.json")

你可以使用$Tokenizer.from\_file\; classmethod$重新加载你的分词器从该文件中：

tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

使用 tokenizer

现在我们已经训练了一个分词器，我们可以通过 $Tokenizer.encode$方法在想要的任何文本上使用它：

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")

这会将tokenizer 的完整pipeline 应用于文本，并返回一个$Encoding$ 对象。要了解有关此pipeline 以及如何应用（或自定义）其部分的更多信息，请查看此页面。

然后，此 $Encoding$ 对象具有深度学习模型（或其他模型）所需的所有属性。$tokens$属性包含以标记形式对文本进行分割：

print(output.tokens)
# ["Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?"]

同样，$ids$ 属性将包含分词器词汇表中每个标记的索引：

print(output.ids)
# [27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35]

Tokenizers 库的一个重要功能🤗是它带有完整的对齐跟踪，这意味着您始终可以获取原始句子中与给定标记对应的部分。这些存储在 $Encoding$对象的 $offsets$属性中。例如，假设我们想要找回导致 “[UNK]” 标记出现的原因，即列表中索引 9 处的标记，我们只需请求索引处的偏移量：

print(output.offsets[9])
# (26, 27)

这些是与原句中的 😁相对应的索引：

sentence = "Hello, y'all! How are you 😁 ?"
sentence[26:27]
# "😁"

后处理

我们可能希望我们的分词器自动添加特殊标记，例如$“[CLS]”$ 或 $“[SEP]”$。为此，我们使用后处理器。$TemplateProcessing$ 是最常用的，您只需指定一个模板来处理单个句子和成对的句子，以及特殊标记及其 ID。
当我们构建分词器时，我们在特殊分词列表的第 1 位和第 2 位设置了 $“[CLS]”$和$“[SEP]”$，所以这应该是它们的 ID。要仔细检查，我们可以使用 $Tokenizer.token\_to\_id$方法：

tokenizer.token_to_id("[SEP]")
# 2

以下是我们如何设置后处理以提供传统的 BERT 输入：

from tokenizers.processors import TemplateProcessing
tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", tokenizer.token_to_id("[CLS]")),
        ("[SEP]", tokenizer.token_to_id("[SEP]")),
    ],
)

让我们更详细地回顾一下这段代码。首先，我们指定单个句子的模板：这些句子的格式应该是$"[CLS]\; \$A\; [SEP]"$ ，其中$\$A$ 代表我们的句子。

然后，我们指定句子对的模板，其格式应为$“[CLS]\; \$A\; [SEP]\; \$B\; [SEP]”$ ，其中$\$A$ 代表第一个句子，$\$B$ 代表第二个句子。模板中添加的 $：1$ 表示$type\; IDs$，它表示我们想要输入的每个部分：它默认为0（这就是为什么我们没有$A：0），这里我们将其设置为1，用于第二个句子的标记和最后一个 $“[SEP]”$ 标记。
最后，我们在 tokenizer 的词汇表中指定我们使用的特殊标记及其 ID。
为了检查它是否正常工作，让我们尝试对与之前相同的句子进行编码：

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?", "[SEP]"]

要检查一对句子的结果，我们只需将这两个句子传递给$Tokenizer.encode:$

output = tokenizer.encode("Hello, y'all!", "How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "[SEP]", "How", "are", "you", "[UNK]", "?", "[SEP]"]

检查type IDs

print(output.type_ids)
# [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]

如果您使用 $Tokenizer.save$保存 tokenizer，则后处理器将一起保存。

批量编码多个句子

要获得🤗 Tokenizers 库的全部速度，最好使用 $Tokenizer.encode\_batch$ 方法批量处理您的文本：

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])

然后，输出是一个$Encoding$ 对象列表，就像我们之前看到的一样。您可以一起处理任意数量的文本，只要它适合内存即可。
要处理一批句子对，请将两个列表传递给 $Tokenizer.encode\_batch$方法：句子列表 A 和句子列表 B：

output = tokenizer.encode_batch(
    [["Hello, y'all!", "How are you 😁 ?"], ["Hello to you too!", "I'm fine, thank you!"]]
)

在编码多个句子时，您可以使用$Tokenizer.enable\_padding$ 自动将输出填充到存在的最长句子，其中包含 $pad\_token$及其 ID（我们可以像以前一样使用 $Tokenizer.token\_to\_id$ 仔细检查填充令牌的 ID）：

tokenizer.enable_padding(pad_id=3, pad_token="[PAD]")

如果我们想将每个样本填充到该特定数字，我们可以设置填充的方向（默认为右侧）或给定的长度（这里我们将其取消设置为填充到最长文本的大小）。

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])
print(output[1].tokens)
# ["[CLS]", "How", "are", "you", "[UNK]", "?", "[SEP]", "[PAD]"]

在这种情况下，分词器生成的$attention\; mask$会考虑填充：

print(output[1].attention_mask)
# [1, 1, 1, 1, 1, 1, 1, 0]

预训练

使用预训练的分词器

只要存储库中有$tokenizer.json$文件可用，您就可以从 Hugging Face Hub 加载任何分词器。

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_pretrained("bert-base-uncased")

从旧词汇表中导入预训练的分词器

您也可以直接导入预训练的分词器，只要您有它的词汇表文件。例如，以下是如何导入经典的预训练 BERT 分词器：

from tokenizers import BertWordPieceTokenizer

tokenizer = BertWordPieceTokenizer("bert-base-uncased-vocab.txt", lowercase=True)

只要您下载了$bert-base-uncased-vocab.txt$

wget https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt

安装

Installation

🤗 Tokenizers 在 Python 3.5 上进行了测试。
您应该在虚拟环境中安装 🤗 Tokenizers。如果您不熟悉 Python 虚拟环境，请查看用户指南。使用您将要使用的 Python 版本创建虚拟环境并激活它。

使用pip安装

可以使用 pip 安装 🤗 Tokenizers，如下所示：

pip install tokenizers

使用源码安装

要使用此方法，您需要安装 Rust 语言。您可以按照官方指南了解更多信息。
如果您使用的是基于 unix 的作系统，则安装应该像运行一样简单：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

或者您可以使用以下命令轻松更新它：

rustup update

安装 rust 后，我们就可以开始检索 🤗Tokenizers 的源代码了：

git clone https://github.com/huggingface/tokenizers

然后我们进入 python bindings 文件夹：

cd tokenizers/bindings/python

此时，您应该已经激活了虚拟环境。为了编译 🤗 Tokenizers，您需要：

pip install -e .

The tokenization pipeline

调用 $Tokenizer.encode$ 或$Tokenizer.encode\_batch$ 时，输入文本将经过以下pipeline：

• $normalization$ 归一化
• $pre-tokenization$ 预分词
• $model$ 模型
• $post-processing$ 后处理

我们将详细了解每个步骤中发生的情况，以及您何时想要$decode\; <decoding>$某些token ids，以及 🤗Tokenizers 库如何允许您根据需要自定义每个步骤。如果您已经熟悉这些步骤，并希望通过查看一些代码来学习，请跳到$our\; BERT\; from\; scratch\; example\; <example>$

对于需要$Tokenizer$的示例，我们将使用我们在$quicktour$中训练的 Tokenizer，您可以使用它加载：

from tokenizers import Tokenizer
tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

Normalization 归一化

简而言之，归一化是你对原始字符串应用的一组作，以使其不那么随机或“更清晰”。常见作包括去除空格、删除重音字符或将所有文本小写。如果您熟悉Unicode normalization ，它也是大多数分词器中应用的非常常见的规范化作。

每个归一化操作在 🤗 Tokenizers 库中都由$Normalizer$ 表示，你可以通过一个$normalizers.Sequence$组合数个Normalizer。下面是一个应用 NFD Unicode normalization 并删除重音符号的规范化器示例：

from tokenizers import normalizers
from tokenizers.normalizers import NFD, StripAccents
normalizer = normalizers.Sequence([NFD(), StripAccents()])

您可以指定任意的字符串（string），手动测试normalizer

normalizer.normalize_str("Héllò hôw are ü?")
# "Hello how are u?"

在构建$Tokenizer$ 时，你可以定制它的normalizer通过修改相应的属性。

tokenizer.normalizer = normalizer

当然，如果你改变了 tokenizer 应用规范化的方式，你可能应该在之后从头开始重新训练它。

Pre-Tokenization 预分词

预分词是将文本拆分为较更小文本的操作，这些文本为训练结束时的词元提供上限。一个很好的理解方式是，预分词器会将你的文本拆分为 “words”，然后，你的最终词元将成为这些词的一部分。
对输入进行预分词的一种简单方法是对空格和标点符号进行拆分，这是由 $pre\_tokenizers.Whitespace$ 预分词完成的。

from tokenizers.pre_tokenizers import Whitespace
pre_tokenizer = Whitespace()
pre_tokenizer.pre_tokenize_str("Hello! How are you? I'm fine, thank you.")
# [("Hello", (0, 5)), ("!", (5, 6)), ("How", (7, 10)), ("are", (11, 14)), ("you", (15, 18)),
#  ("?", (18, 19)), ("I", (20, 21)), ("'", (21, 22)), ('m', (22, 23)), ("fine", (24, 28)),
#  (",", (28, 29)), ("thank", (30, 35)), ("you", (36, 39)), (".", (39, 40))]

输出是一个元组列表，每个元组包含一个单词及其在原始句子中的跨度（用于确定 $Encoding$的最终$offsets$）。请注意，在标点符号上拆分将拆分缩略，例如本例中的$“I’m”$ 。
您可以将任何 $PreTokenizer$组合在一起。例如，这是一个预分词器，它将按空格、标点符号和数字进行拆分，并在各个数字中分隔数字：

from tokenizers import pre_tokenizers
from tokenizers.pre_tokenizers import Digits
pre_tokenizer = pre_tokenizers.Sequence([Whitespace(), Digits(individual_digits=True)])
pre_tokenizer.pre_tokenize_str("Call 911!")
# [("Call", (0, 4)), ("9", (5, 6)), ("1", (6, 7)), ("1", (7, 8)), ("!", (8, 9))]

正如我们在$quicktour$中看到的，您只需更改相应的属性即可自定义一个$Tokenizer$的预分词器：

tokenizer.pre_tokenizer = pre_tokenizer

当然，如果你改变了预分词器（pre-tokenizer ）的方式，你可能应该在之后从头开始重新训练你的 tokenizer。

Model 模型

一旦输入文本被归一化和预分词，$Tokenizer$就会将模型应用于pre-tokens。这是pileline中需要在语料库上训练的部分（或者，如果您使用的是预训练的分词器，则已经过训练）。
该模型的作用是使用它学到的规则将您的 “单词” 拆分为标记(tokens)。它还负责将这些标记映射到它们在模型词汇表(vocabulary)中的相应 IDs 。
这个模型是在初始化$Tokenizer$ 时传递的，所以你已经知道如何自定义这部分了。目前，🤗 Tokenizers 库支持：

• $models.BPE$
• $models.Unigram$
• $models.WordLevel$
• $models.WordPiece$

有关每个模型及其行为的更多详细信息，您可以在此处查看

Post-Processing 后处理

后处理是分词化管道的最后一步，用于在$Encoding$ 返回之前，对 Encoding 执行任何其他转换，例如添加潜在的特殊tokens。
正如我们在快速浏览中所看到的，我们可以通过设置相应的属性来自定义 Tokenizer 的后处理器。例如，以下是我们如何进行后处理以使输入适合 BERT 模型：

from tokenizers.processors import TemplateProcessing
tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[("[CLS]", 1), ("[SEP]", 2)],
)

请注意，与 pre-tokenizer 或 normalizer 相反，在更改其后处理器后，您无需重新训练 tokenizer。

总述：从头开始的 BERT 分词器

让我们把所有这些部分放在一起，构建一个 BERT 分词器。首先，BERT 依赖于 WordPiece，因此我们用这个模型实例化一个新的$Tokenizer$ ：

from tokenizers import Tokenizer
from tokenizers.models import WordPiece
bert_tokenizer = Tokenizer(WordPiece(unk_token="[UNK]"))

然后我们知道 BERT 通过删除重音和小写来预处理文本。我们还使用 unicode normalizer：

from tokenizers import normalizers
from tokenizers.normalizers import NFD, Lowercase, StripAccents
bert_tokenizer.normalizer = normalizers.Sequence([NFD(), Lowercase(), StripAccents()])

预分词器只是在空格和标点符号上进行拆分：

from tokenizers.pre_tokenizers import Whitespace
bert_tokenizer.pre_tokenizer = Whitespace()

后处理使用我们在上一节中看到的模板：

from tokenizers.processors import TemplateProcessing
bert_tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", 1),
        ("[SEP]", 2),
    ],
)

我们可以使用这个分词器并在 wikitext 上对其进行训练，就像在$quicktour$中一样：

from tokenizers.trainers import WordPieceTrainer
trainer = WordPieceTrainer(vocab_size=30522, special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])
files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
bert_tokenizer.train(files, trainer)
bert_tokenizer.save("data/bert-wiki.json")

Decoding 解码

除了对输入文本进行编码之外，$Tokenizer$ 还有一个用于解码的 API，即将模型生成的 IDs 转换回文本。这是通过以下两个方法完成的$Tokenizer.decode$（用于一个预测文本）和 $Tokenizer.decode\_batch$（用于一批预测）。
解码器（$decoder$）首先将 IDs 转换回tokens（使用标记器的词汇表）并删除所有特殊标记，然后用空格连接这些标记：

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.ids)
# [1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2]
tokenizer.decode([1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2])
# "Hello , y ' all ! How are you ?"

如果您使用的模型添加了特殊字符来表示给定 “word” 的子标记（如 WordPiece 中的 $“\#\#”$），则需要自定义解码器以正确处理它们。如果我们以之前的bert_tokenizer为例，默认解码将给出：

output = bert_tokenizer.encode("Welcome to the 🤗 Tokenizers library.")
print(output.tokens)
# ["[CLS]", "welcome", "to", "the", "[UNK]", "tok", "##eni", "##zer", "##s", "library", ".", "[SEP]"]
bert_tokenizer.decode(output.ids)
# "welcome to the tok ##eni ##zer ##s library ."

但是通过将其更改为适当的解码器，我们可以得到：

from tokenizers import decoders
bert_tokenizer.decoder = decoders.WordPiece()
bert_tokenizer.decode(output.ids)
# "welcome to the tokenizers library."

Components 组件

在构建 Tokenizer 时，您可以将各种类型的组件附加到此 Tokenizer 以自定义其行为。此页面列出了提供的大多数组件。

Normalizers

$Normalizer$负责预处理输入字符串，以便将其规范化为与给定用例相关。一些常见的规范化示例是Unicode normalization 算法（NFD，NFKD，NFC & NFKC），小写等… $tokenizers$的特点是我们在规范化时跟踪对齐。这对于允许从生成的标记映射回输入文本至关重要。

$Normalizer$是可选的。

名字	描述	例子
NFD	NFD unicode normalization
NFKD	NFKD unicode normalization
NFC	NFC unicode normalization
NFKC	NFKC unicode normalization
Lowercase	将所有大写替换为小写	Input: HELLO ὈΔΥΣΣΕΎΣ Output: helloὀδυσσεύς`
Strip	删除输入的指定边（左、右或两者）上的所有空白字符	Input: “hi” Output: “hi”
StripAccents	删除 Unicode 中的所有重音符号（与 NFD 一起使用以保持一致性）	Input: é Ouput: e
Replace	替换自定义字符串或 regexp 并将其更改为给定内容	Replace(“a”, “e”) will behave like this: Input: “banana” Ouput: “benene”
BertNormalizer	提供原始 BERT 中使用的 Normalizer 的实现。可以设置的选项包括： * clean_text * handle_chinese_chars * strip_accents * lowercase
Sequence	组合多个将按提供的顺序运行的规范化器	Sequence([NFKC(), Lowercase()])

Pre-tokenizers

$PreTokenizer$ 负责根据一组规则拆分输入 。这种预处理可以确保底层 $Model$不会在多个 “split” 中构建 token。例如，如果您不想在token中包含空格，那么您可以使用一个$PreTokenizer$来拆分这些空格。

您可以使用一个$Sequence$ 轻松地将多个$PreTokenizer$组合在一起（见下文）。$PreTokenizer$也可以修改字符串，就像$Normalizer$ 一样。这对于允许一些需要在normalizing 之前进行拆分的复杂算法（例如 ByteLevel）是必要的

名字	描述	例子
ByteLevel	在空格处进行拆分，同时将所有字节重新映射到一组可见字符。这项技术是由 OpenAI 通过 GPT-2 引入的，并且或多或少具有一些不错的特性： 1.由于它映射字节，因此使用它的分词器只需要 256 个字符作为初始字母表（一个字节可以具有的值的数量），而不是 130,000 个 Unicode 字符。 2.前一点的结果是，绝对没有必要使用 this 来使用未知令牌，因为我们可以用 256 个令牌表示任何东西（Youhou！！ 🎉🎉 3.对于非 ASCII 字符，它变得完全不可读，但它仍然有效！	Input: “Hello my friend, how are you?” Ouput: “Hello”, “Ġmy”, Ġfriend", “,”, “Ġhow”, “Ġare”, “Ġyou”, “?”
Whitespace	在单词边界上拆分（使用以下正则表达式： \w+|[^\w\s]+	Input: “Hello there!” Output: “Hello”, “there”, “!”
Punctuation	将隔离所有标点符号	Input: “Hello?” Ouput: “Hello”, “?”
Metaspace	在空格处进行拆分并将其替换为特殊字符 “ ” （U 2581）	Input: “Hello there” Ouput: “Hello”, “▁there”
CharDelimiterSplit	对给定角色进行拆分	Example with x: Input: “Helloxthere” Ouput: “Hello”, “there”
Digits	从任何其他字符中拆分数字	Input: “Hello123there” Output: “Hello”, “123”, “there”
Split	多功能的 pre-tokenizer，根据提供的 pattern 和提供的行为进行拆分。如有必要，可以反转模式。 pattern 应该是自定义字符串或 regexp。 行为应为以下之一： 1.removed 2.isolated 3.merged_with_previous 4.merged_with_next 5.contiguous invert 应为布尔标志。	Example with pattern = , behavior = “isolated”, invert = False: Input: “Hello, how are you?” Output: “Hello,”, " ", “how”, " ", “are”, " ", “you?”
Sequence	允许您编写多个 PreTokenizer，这些 PreTokenizer 将按给定顺序运行	Sequence([Punctuation(), WhitespaceSplit()])

Models 模型

模型是用于实际分词的核心算法，因此，它们是 Tokenizer 的唯一强制性组件。

名字	描述
WordLevel	这是 “经典” 分词化算法。它让你可以简单地将单词映射到 ID，而不需要任何花哨的东西。这样做的好处是非常易于使用和理解，但它需要非常大的词汇量才能获得良好的覆盖。使用此模型需要使用 PreTokenizer。此模型不会直接做出选择，它只是将输入标记映射到 ID。
BPE	最流行的子词分词化算法之一。Byte-Pair-Encoding 的工作原理是从字符开始，同时将最常见的字符合并在一起，从而创建新的令牌。然后，它以迭代方式工作，从它在语料库中看到的最频繁的对中构建新的标记。BPE 能够通过使用多个子词标记来构建它从未见过的单词，因此需要更小的词汇表，拥有“unk”（未知）标记的机会较小。
WordPiece	这是一种与 BPE 非常相似的子词标记化算法，主要由 Google 在 BERT 等模型中使用。它使用一种贪婪算法，该算法首先尝试构建长单词，当词汇表中不存在整个单词时，它会拆分为多个标记。这与 BPE 不同，BPE 从角色开始，尽可能构建更大的代币。它使用著名的 ## 前缀来标识属于单词的标记（即不开始单词）。
Unigram	Unigram 也是一种子词标记化算法，其工作原理是尝试识别最佳的子词标记集，以最大限度地提高给定句子的概率。这与 BPE 的不同之处在于，BPE 不是基于一组按顺序应用的规则的确定性规则。相反，Unigram 将能够计算多种分词方式，同时选择最可能的一种。

Post-Processors 后处理器

在整个管道之后，我们有时希望在将标记化字符串馈送到模型之前插入一些特殊标记，例如 “[CLS] My horse is amazing [SEP]”。$PostProcessor$就是做这个事情的组件。

名字	描述	例子
TemplateProcessing	让您轻松地对后处理进行模板化，添加特殊标记，并为每个序列/特殊标记指定type_id。该模板提供了两个字符串，分别表示单个序列和一对序列，以及一组要使用的特殊标记。	示例，当指定具有以下值的模板时： single: “[CLS] $A [SEP]” pair: “[CLS] $A [SEP] $B [SEP]” special tokens:“[CLS]”“[SEP]” Input: (“I like this”, “but not this”) Output: “[CLS] I like this [SEP] but not this [SEP]”

Decoders 解码器

Decoder 知道如何从 Tokenizer 使用的 IDs 返回可读的文本。例如，某些 $Normalizer$和 $PreTokenizer$使用需要还原的特殊字符或标识符。

名字	描述
ByteLevel	还原 ByteLevel PreTokenizer。这个 PreTokenizer 在字节级别进行编码，使用一组可见的 Unicode 字符来表示每个字节，因此我们需要一个 Decoder 来恢复这个过程并再次获得可读的内容。
Metaspace	还原 Metaspace PreTokenizer。这个 PreTokenizer 使用一个特殊的 identifer ， 来识别空格，因此这个 Decoder 有助于解码这些空格。
WordPiece	还原 WordPiece 模型。此模型使用特殊标识符 ## 来继续子字，因此此 Decoder 有助于解码这些子字。

Training from memory 从内存中训练

在$Quicktour$中，我们了解了如何使用文本文件构建和训练分词器，但我们实际上可以使用任何 Python 迭代器。在本节中，我们将看到几种不同的训练 tokenizer 的方法。
对于下面列出的所有示例，我们将使用相同的 $Tokenizer$和$Trainer$ ，构建如下：

from tokenizers import Tokenizer, decoders, models, normalizers, pre_tokenizers, trainers
tokenizer = Tokenizer(models.Unigram())
tokenizer.normalizer = normalizers.NFKC()
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel()
tokenizer.decoder = decoders.ByteLevel()
trainer = trainers.UnigramTrainer(
    vocab_size=20000,
    initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
    special_tokens=["<PAD>", "<BOS>", "<EOS>"],
)

此分词器基于 Unigram模型。它负责使用 NFKC Unicode 规范化方法对输入进行规范化，并使用 ByteLevel 预分词器和相应的解码器。
有关此处使用的组件的更多信息，您可以在此处查看。

The most basic way 最基本的方法

你可能已经猜到了，训练我们的分词器的最简单方法是使用 $List${.interpreted-text role=“obj”}：

# First few lines of the "Zen of Python" https://www.python.org/dev/peps/pep-0020/
data = [
    "Beautiful is better than ugly."
    "Explicit is better than implicit."
    "Simple is better than complex."
    "Complex is better than complicated."
    "Flat is better than nested."
    "Sparse is better than dense."
    "Readability counts."
]
tokenizer.train_from_iterator(data, trainer=trainer)

很简单，对吧？你可以在这里使用任何用作迭代器的东西，无论是 $List${.interpreted-text role=“obj”}、$Tuple${.interpreted-text role=“obj”} 还是$np.Array$ {.interpreted-text role=“obj”}。只要提供字符串，任何东西都可以工作。

Using the 🤗 Datasets library 使用 🤗Datasets 库

访问现有众多数据集之一的一种绝妙方法是使用🤗 Datasets 库。有关更多信息，您应该在此处查看官方文档。
让我们从加载数据集开始：

import datasets
dataset = datasets.load_dataset("wikitext", "wikitext-103-raw-v1", split="train+test+validation")

下一步是在此数据集上构建迭代器。最简单的方法可能是使用 generator：

def batch_iterator(batch_size=1000):
    # Only keep the text column to avoid decoding the rest of the columns unnecessarily
    tok_dataset = dataset.select_columns("text")
    for batch in tok_dataset.iter(batch_size):
        yield batch["text"]

正如你在这里看到的，为了提高效率，我们实际上可以提供一批用于训练的示例，而不是一个一个地迭代它们。通过这样做，我们可以预期性能与直接从文件训练时获得的性能非常相似。
迭代器准备就绪后，我们只需要启动训练。为了改进进度条的外观，我们可以指定数据集的总长度：

tokenizer.train_from_iterator(batch_iterator(), trainer=trainer, length=len(dataset))

就是这样！

Using gzip files 使用压缩包

由于 Python 中的 gzip 文件可以用作迭代器，因此对此类文件进行训练非常简单：

import gzip
with gzip.open("data/my-file.0.gz", "rt") as f:
    tokenizer.train_from_iterator(f, trainer=trainer)

现在，如果我们想从多个 gzip 文件进行训练，那不会更难：

files = ["data/my-file.0.gz", "data/my-file.1.gz", "data/my-file.2.gz"]
def gzip_iterator():
    for path in files:
        with gzip.open(path, "rt") as f:
            for line in f:
                yield line
tokenizer.train_from_iterator(gzip_iterator(), trainer=trainer)

瞧！

API

Input Sequences 输入序列

这些类型代表了可以用作 Tokenizer 输入的所有不同类型的序列。总而言之，根据tokenizer的操作模式,任何序列都可以是字符串或者字符串列表：$raw\; text$ vs $pre-tokenized$

TextInputSequence

$tokenizers.TextInputSequence$
$str$表示一个输入序列

PreTokenizedInputSequence

$tokenizers.PreTokenizedInputSequence$
A pre-tokenized input sequence. 可以是以下之一:

• A List of str
• A Tuple of str

别名为$Union[List[str],\; Tuple[str]]$

InputSequence

$tokenizers.InputSequence$
表示用于编码的所有可能的输入序列类型。可以是：

• 当$is\_pretokenized=False$：TextInputSequence
• 当$is\_pretokenized=True$:PreTokenizedInputSequence

别名$Union[str,\; List[str],\; Tuple[str]]$

Encode Inputs 编码输入

这些类型代表了 Tokenizer 在使用 $encode\_batch()$ 时接受的所有不同类型的输入。

TextEncodeInput[[[ tokenizers.TextEncodeInput ]]]

$tokenizers.TextEncodeInput$
表示用于编码的文本输入。可以是：

• 单独序列：TextInputSequence （str）
• 成对序列：
  • A Tuple of TextInputSequence
  • a List of TextInputSequence of size 2

别名$Union[str,\; Tuple[str,\; str],\; List[str]]$

PreTokenizedEncodeInput[[[ tokenizers.PreTokenizedEncodeInput ]]]

$tokenizers.PreTokenizedEncodeInput$
表示用于编码的预标记化输入。可以是：

• 单独序列：PreTokenizedInputSequence （Union[List[str], Tuple[str]]）
• 成对序列：
  • A Tuple of PreTokenizedInputSequence
  • a List of PreTokenizedInputSequence of size 2

别名$Union[List[str],\; Tuple[str],\; Tuple[Union[List[str],\; Tuple[str]],\; Union[List[str],\; Tuple[str]]],\; List[Union[List[str],\; Tuple[str]]]]$

EncodeInput[[[ tokenizers.EncodeInput ]]]

$tokenizers.EncodeInput$
表示编码的所有可能输入类型。可以是：

• 当$is\_pretokenized=False$:TextEncodeInput
• 当$is\_pretokenized=True$:PreTokenizedEncodeInput
  别名$Union[str,\; Tuple[str,\; str],\; List[str],\; Tuple[str],\; Tuple[Union[List[str],\; Tuple[str]],\; Union[List[str],\; Tuple[str]]],\; List[Union[List[str],\; Tuple[str]]]]$

Tokenizer 分词器

Tokenizer

class tokenizers.Tokenizer
( model )
参数

• model (Model) —核心算法，$Tokenizer$应该使用它。.

$Tokenizer$作为pipeline工作。它处理一些原始文本作为输入，并输出一个Encodeing

@property decoder
Tokenizer使用的 可选的$Decoder$

@property model
供Tokenizer使用的 $Model$

@property normalizer
Tokenizer使用的 可选的$Normalizer$

@property padding
返回(dict, optional)
如果padding是开启的，dict有当前padding的参数
获得当前padding的参数
不能被设置，而是使用$enable\_padding()$

@property post_processor
Tokenizer使用的 可选的$PostProcessor$

@property pre_tokenizer
Tokenizer使用的 可选的$PreTokenizer$

@property truncation
返回(dict, optional)
如果truncation是开启的，dict有当前truncation的参数
获得当前truncation的参数
不能被设置，而是使用$enable\_truncation()$

function add_special_tokens
( tokens ) → int
参数：

• tokens （$str$ 或者AddedToken的$List$）
  我们要添加到词汇表的特殊tokens列表。每个token可以是字符串或 AddedToken 的实例，以便进行更多自定义。

返回值：

• int
  在词汇中创建的tokens数量。

描述：
将给定的特殊tokens添加到 Tokenizer。
如果这些 Tokens 已经是词汇表的一部分，它只会让 Tokenizer 知道它们。如果它们不存在，则 Tokenizer 会创建它们，并为它们提供一个新的 id。
这些特殊 token 永远不会被模型处理（即不会被拆分为多个 token），并且可以在解码时从输出中删除它们。

function add_tokens
( tokens ) → int
参数：

• tokens （$str$ 或者AddedToken的$List$）
  我们要添加到词汇表的tokens列表。每个token可以是字符串或 AddedToken 的实例，以便进行更多自定义。

返回值：

• int
  在词汇中创建的tokens数量。

描述：
将给定的tokens添加到词汇表中
仅当词汇表中尚不存在给定的tokens时，才会添加它们。然后，每个tokens都会获得一个新的属性id。

function decode
( ids，skip_special_tokens = True ) → str
参数：

• ids（$int$的$List或Tuple$）
  我们想要解码的 ids 列表
• skip_special_tokens（$bool$，默认为$True$）
  是否应从解码的字符串中删除特殊tokens

返回值：

• str
  解码后的字符串

描述：
将给定的 id 列表解码回字符串
这用于解码从语言模型返回的任何内容

function decode_batch
( sequences, skip_special_tokens = True ) → List[str]
参数：

• sequences（$List[int]$的$List$）
  我们要解码的序列批次
• skip_special_tokens（$bool$，默认为$True$）
  是否应从解码的字符串中删除特殊tokens

返回值：

• List[str]
  解码字符串的列表

描述：
将一批 ids 解码回其对应的字符串

function enable_padding
( direction = ‘right’, pad_id = 0, pad_type_id = 0, pad_token = ‘[PAD]’, length = Nonepad_to_multiple_of = None )
参数：

• direction（$str$, optional, 默认为right）
  填充的方向。可以是 right 或 left
• pad_to_multiple_of（$int$，optional）
  如果指定，则填充长度应始终对齐到给定值的下一个倍数。例如，如果我们要用 250 的长度填充，但 pad_to_multiple_of=8，那么我们将填充到 256。
• pad_id（$int$，默认为 0）
  填充时使用的 id
• pad_type_id（$int$，默认为 0）
  填充时使用的类型 id
• pad_token（$str$，默认为 [PAD]）
  填充时使用的 pad token
• length（$int$，optional）
  如果指定，则为要填充的长度。如果未指定，我们将使用批处理中最长序列的大小进行填充。

描述：
启用填充

function enable_truncation
( max_length, stride = 0, strategy = ‘longest_first’, direction = ‘right’ )
参数：

• max_length（$int$）
  要截断的最大长度
• stride（$int$, optional）
  要包含在溢出序列中的前一个第一个序列的长度
• strategy（$str$, optional, 默认longest_first）
  用于截断的策略。可以是$longest\_first,\; only\_first\; ,\; only\_second$
• direction（$str$, 默认右）
  截断方向

描述：
启用截断

function encode
( sequence, pair = None, is_pretokenized = False, add_special_tokens = True ) → Encoding
参数：

• sequence（$~tokenizers.InputSequence$）
  我们要编码的输入序列。根据$is\_pretokenized$ 参数，此序列可以是原始文本或pre-tokenized：
  • 如果$is\_pretokenized=False$：$TextInputSequence$
  • 如果$is\_pretokenized=True$：$PreTokenizedInputSequence()$
• pair （$~tokenizers.InputSequence,\; optional$）
  可选的输入序列。预期的格式与$sequence$ 的格式相同。
• is_pretokenized （$bool$,默认是False)
  输入是否是pre-tokenized
• add_special_tokens （$bool$,默认是True)
  是否添加特殊tokens

返回值：

• Encoding
  编码结果

描述：
对给定的序列和键值对（pair）进行编码。此方法可以处理原始文本序列以及已预先标记化的序列。

例子：
以下是接受的输入的一些示例：

encode("A single sequence")*
encode("A sequence", "And its pair")*
encode([ "A", "pre", "tokenized", "sequence" ], is_pretokenized=True)`
encode(
[ "A", "pre", "tokenized", "sequence" ], [ "And", "its", "pair" ],
is_pretokenized=True
)

function encode_batch
( input, is_pretokenized = False, add_special_tokens = True ) → A List of [`~tokenizers.Encoding“]
参数：

• input（List或者~tokenizers.EncodeInput的Tuple ）
  要编码的单个序列或对序列的列表。根据 is_pretokenized 参数，每个序列可以是原始文本或预标记化：
  • 如果$is\_pretokenized=False$：$TextInputSequence（）$
  • 如果$is\_pretokenized=True$：$PreTokenizedInputSequence()$
• is_pretokenized（$bool$，默认为False）
  输入是否是pre-tokenized
• add_special_tokens（$bool$，默认为True）
  是否添加特殊tokens

返回值：

• [~tokenizers.Encoding]的List
  编码的批次

描述：
对给定的输入批次进行编码。此方法接受原始文本序列以及已预先标记化的序列。我们使用 PySequence 的原因是它允许零成本（根据 PyO3）进行类型检查，因为我们不必转换而检查。

例子：
以下是接受的输入的一些示例：

encode_batch([
"A single sequence",
("A tuple with a sequence", "And its pair"),
[ "A", "pre", "tokenized", "sequence" ],
([ "A", "pre", "tokenized", "sequence" ], "And its pair")
])

function encode_batch_fast
( input, is_pretokenized = False, add_special_tokens = True ) → A List of [`~tokenizers.Encoding“]
参数：

• input（List或者~tokenizers.EncodeInput的Tuple ）
  要编码的单个序列或对序列的列表。根据 is_pretokenized 参数，每个序列可以是原始文本或预标记化：
  • 如果$is\_pretokenized=False$：$TextInputSequence（）$
  • 如果$is\_pretokenized=True$：$PreTokenizedInputSequence()$
• is_pretokenized（$bool$，默认为False）
  输入是否是pre-tokenized
• add_special_tokens（$bool$，默认为True）
  是否添加特殊tokens

返回值：

• [~tokenizers.Encoding]的List
  编码的批次

描述：
对给定的输入批次进行编码。这种方法比 encode_batch 更快，因为它不跟踪偏移量，它们将全部为零。

例子：
以下是接受的输入的一些示例：

encode_batch_fast([
"A single sequence",
("A tuple with a sequence", "And its pair"),
[ "A", "pre", "tokenized", "sequence" ],
([ "A", "pre", "tokenized", "sequence" ], "And its pair")
])

function from_buffer
( buffer ) → Tokenizer
参数：

• buffer（$bytes$）
  包含先前序列化的 Tokenizer 的缓冲区

返回值：

• Tokenizer
  新的Tokenizer

描述：
从给定的缓冲区实例化一个新的 Tokenizer。

function from_file
( path ) → Tokenizer
参数：

• path（$str$）
  表示先前序列化的 Tokenizer 的本地 JSON 文件的路径

返回值：

• Tokenizer
  新的Tokenizer

描述：
从给定路径处的文件实例化一个新的 Tokenizer。

function from_pretrained
( identifier, revision = ‘main’, token = None ) → Tokenizer
参数：

• identifier（$str$）
  Hugging Face Hub 上的模型的标识符，其中包含 tokenizer.json 文件
• revision（$str$，默认为main）
  分支或提交id
• token（$str$，optional，默认为None）
  用于访问 Hugging Face Hub 上的私有仓库的可选身份验证令牌

返回值：

• Tokenizer
  新的Tokenizer

描述：
从 Hugging Face Hub 上的现有文件实例化新的 Tokenizer。

function from_str
( json ) → Tokenizer
参数：

• json（$str$）
  一个有效的 JSON 字符串，表示以前序列化的 Tokenizer

返回值：

• Tokenizer
  新的Tokenizer

描述：
从给定的 JSON 字符串实例化新的 Tokenizer。

function get_added_tokens_decoder
( ) → Dict[int, AddedToken]

返回值：

• Dict[int, AddedToken]
  词汇表

描述：
获取基础词汇

function get_vocab
( with_added_tokens = True ) → Dict[str, int]

参数：

• with_added_tokens（$bool$，默认为True）
  是否包含添加的tokens

返回值：

• Dict[str, int]
  词汇表

描述：
获取基础词汇

function get_vocab_size
( with_added_tokens = True ) → int

参数：

• with_added_tokens（$bool$，默认为True）
  是否包含添加的tokens

返回值：

• int
  词汇表大小

描述：
获取基础词汇表的大小

function id_to_token
( id ) → Optional[str]

参数：

• id（$int$）
  要转换的 id

返回值：

• Optional[str]
  可选标记，如果不在词汇表，则为 None

描述：
将给定的 id 转换为其相应的token（如果存在）

function no_padding
( )

描述：
禁用padding

function no_truncation
( )

描述：
禁用truncation

function num_special_tokens_to_add
( is_pair )

描述：
返回单个或成对的句子的特殊tokens 的数量。. :param is_pair 布尔值表示如果输入是单个还是成对的返回值。

function post_process
( encoding, pair = None, add_special_tokens = True ) → Encoding
参数：

• encoding（$Encoding$）
  与主序列对应的 Encoding。
• pair（$Encoding,\; optional$）
  对应于对序列的可选 Encoding。
• add_special_tokens（$bool$）
  是否添加特殊tokens

返回值：

• Encoding
  最终的后处理编码

描述：
将所有后处理步骤应用于给定的编码。
各个步骤包括：

1. 根据设置的截断参数进行截断（由enable_truncation（）设置）
2. 应用 $PostProcessor$
3. 根据设置的填充参数进行填充（由 enable_padding（） 设置）

function save
( path, pretty = True )

参数：

• path（$str$）
  用于保存序列化 tokenizer 的文件的路径。
• pretty（$bool$，默认为True）
  JSON 文件是否应该采用 pretty 格式。

描述：
将 Tokenizer 保存到给定路径处的文件。

function to_str
( pretty = False ) → str

参数：

• pretty（$bool$，默认为False）
  JSON 文件是否应该采用 pretty 格式。

返回值：

• $str$
  表示序列化的 Tokenizer 的字符串

描述：
获取表示此 Tokenizer 的序列化字符串。

function token_to_id
( token ) → Optional[int]

参数：

• token（$str$，默认为False）
  要转换的token

返回值：

• $Optional[int]$
  可选 id，如果词汇表没有，则为 None。

描述：
将给定的token 转换为其相应的 id（如果存在）

function train
( files， trainer = None )
参数：

• files（$List[str]$）
  我们应该用于训练的文件的路径列表
• trainer（$~tokenizers.trainers.Trainer$）
  应该用于训练我们的模型的可选 trainer

描述：
使用给定的文件训练 Tokenizer。
逐行读取文件，同时保留所有空格，甚至是新行。如果要从内存中的数据存储进行训练，可以查看 $train\_from\_iterator（）$函数

function train_from_iterator
( iterator, trainer = None, length = None )
参数：

• iterator（$Iterator$）
  字符串或字符串列表上的任何迭代器
• trainer（$~tokenizers.trainers.Trainer$，可选项）
  应该用于训练我们的模型的可选 trainer
• length（$int$，可选项）
  迭代器中的序列总数。这用于提供有意义的进度跟踪

描述：
使用提供的迭代器训练 Tokenizer。
你可以提供任何 Python 迭代器

• 序列列表 List[str]
• 生成 str 或 List[str] 的生成器
• 字符串的 Numpy 数组
• 等等

Encoding

Encoding

class tokenizers.Encoding
( )
$Encoding$代表$Tokenizer$的输出。

@property attention_mask
返回值：

• $List[int]$

描述：注意力掩码

注意力掩码向 LM 指示哪些tokens应该被关注，哪些不应该被关注。这在批处理序列时尤其重要，因为我们需要应用填充。

@property ids
返回值：

• $List[int]$

描述：
ids列表

生成的ids
ids是语言模型的主要输入。它们是token索引，即 LM 理解的数字表示。

@property n_sequences
返回值：

• $int$

此 Encoding 中的序列数

描述：
表示的序列数

@property offsets
返回值：

• $Tuple[int,\; int]的List$

偏移量列表

描述：
与每个 Token 关联的偏移量
这些偏移量允许您对 input 字符串进行切片，从而检索导致生成相应 token 的原始部分。

@property overflowing
返回值：

• $溢出的Encoding的List$

描述：
使用截断时，Tokenizer 负责根据需要将输出拆分为任意数量的部分，以匹配指定的最大长度。此字段允许您检索所有后续片段。
当您使用成对的序列时，溢出的片段将包含足够的变化来涵盖所有可能的组合，同时遵守提供的最大长度。

@property sequence_ids
返回值：

• $Optional[int]的List$

可选序列索引的列表。

描述：
它们表示与每个标记关联的 input 序列的索引。如果标记与任何输入序列无关，例如使用特殊标记，则序列 id 可以是 None。

@property special_tokens_mask
返回值：

• $List[int]$

特殊标记掩码

特殊标记掩码指示哪些tokens 是特殊tokens ，哪些不是。

@property tokens
返回值：

• $List[str]$

tokens列表
描述：
生成的tokens是ids的字符串表示形式。

@property type_ids
返回值：

• $List[int]$

类型ids的列表

描述：
生成的类型ids
这些标记通常用于序列分类或问答等任务，它让 LM 知道哪个输入序列对应于每个tokens。

@property word_ids
返回值：

• $Optional[int]的List$

可选单词索引的列表。
描述：
生成的单词索引。
它们表示与每个token关联的单词的索引。当输入被预先标记化时，它们对应于给定输入标签的 id，否则它们对应于所使用的 PreTokenizer 定义的单词索引。

对于特殊标记等（从不属于输入的内容生成的任何标记），输出为 None

@property words
返回值：

• $Optional[int]的List$

可选的单词索引列表

描述：
生成的单词索引。

此功能已弃用，并将在未来版本中删除。请使用~tokenizers.Encoding.word_ids取而代之。

它们表示与每个标记关联的单词的索引。当输入被预先标记化时，它们对应于给定输入标签的 id，否则它们对应于所使用的 PreTokenizer 定义的单词索引。
对于特殊标记等（从不属于输入的内容生成的任何标记），输出为 None

function char_to_token
( char_pos, sequence_index = 0 ) → int
参数：

• char_pos（$int$）
  字符在输入字符串中的位置
• sequence_index（$int$，默认是0）
  包含目标字符的序列的索引

返回值：

• $int$

描述：
在编码序列中包含此字符的标记的索引
获取在输入序列中给定位置包含字符的token。

function char_to_word
( char_pos, sequence_index = 0 ) → int
参数：

• char_pos（$int$）
  字符在输入字符串中的位置
• sequence_index（$int$，默认是0）
  包含目标字符的序列的索引

返回值：

• $int$

描述：
在输入序列中包含此字符的单词的索引
获取在输入序列中给定位置包含字符的单词。

function merge
( encodings， growing_offsets = True ) → Encoding
参数：

• encodings（$Encoding的List$）
  应该合并在一起的编码列表
• growing_offsets（$bool$默认为True）
  合并时是否应累积偏移量

返回值：

• $Encoding$
  生成的 Encoding

描述：
将编码列表合并为一个最终的 Encoding

function pad
( length, direction = ‘right’. pad_id = 0. pad_type_id = 0, pad_token = ‘[PAD]’ )
参数：

• length（$int$）
  所需长度
• direction —（$str$，默认为 right）
  预期的填充方向。可以是 right 或 left
• pad_id（$int$, 默认为0）
  与填充token对应的 id
• pad_type_id（$int$, 默认为0）
  与填充token对应的类型 id
• pad_token（$str$, 默认为 [PAD]）
  使用的填充token

描述：
在给定长度处填充 Encoding

function set_sequence_id
( sequence_id )

描述：
设置给定的序列索引
为此 Encoding 中包含的整个 tokens 范围设置给定的序列索引。

function token_to_chars
( token_index ) → Tuple[int, int]
参数：

• token_index（$int$）
  编码序列中标记的索引。

返回值：Tuple[int, int]
token 偏移量（第一个，最后一个+1）

描述：
获取 token 在给定索引处的偏移量。
返回的偏移量与包含标记的输入序列相关。为了确定它属于哪个序列，您必须调用~tokenizers.Encoding.token_to_sequence()。

function token_to_sequence
( token_index ) → int
参数：

• token_index（$int$）
  编码序列中标记的索引。

返回值：int
给定 Token 的序列 id

描述：
获取由给定标记表示的序列的索引。

一般，这个方法对单个序列或成对序列的第一个序列返回0，成对序列的第二个序列返回1。

function token_to_word
( token_index ) → int
参数：

• token_index（$int$）
  编码序列中标记的索引。

返回值：int
相关 input 序列中单词的索引。

描述：
获取其中一个输入序列中包含标记的单词的索引。

返回的单词索引与包含标记的输入序列相关。为了确定它属于哪个 序列，您必须调用~tokenizers.Encoding.token_to_sequence()。

function truncate
( max_lengthstride = 0direction = ‘right’ )
参数：

• max_length（$int$）
  期望的长度
• stride（$int$， 默认为0）
  每个溢出部分要包含的先前内容的长度
• direction（$str$， 默认为right）
  截断方向

描述：
通过给定的长度，截断Encoding

如果此 Encoding 表示多个序列，则在截断时，此信息将丢失。它将被视为代表单个序列。

function word_to_chars
( word_index，sequence_index = 0 ) → Tuple[int, int]
参数：

• word_index（$int$）
  其中一个输入序列中单词的索引。
• sequence_index（$int$，默认为0）
  包含目标单词的序列的索引

返回值：

• Tuple[int, int]
  字符范围 （span） （first， last+1）

描述：
获取其中一个输入序列中给定索引处的单词偏移量。

function word_to_tokens
( word_index，sequence_index = 0 ) → Tuple[int, int]
参数：

• word_index（$int$）
  其中一个输入序列中单词的索引。
• sequence_index（$int$，默认为0）
  包含目标单词的序列的索引

返回值：

• Tuple[int, int]
  字符范围 （span） （first， last+1）

描述：
获取其中一个输入序列中给定索引处的单词偏移量。

Added Tokens

AddedToken 添加的Token

class tokenizers.AddedToken
( content, single_word = False, lstrip = False, rstrip = False, normalized = True, special = False )
$Encoding$代表$Tokenizer$的输出。

参数：

• content $str$
  token的内容

• single_word $bool$默认为False
  定义此标记是否应仅匹配单个单词。如果为 True，则此标记在单词内永远不会匹配。例如，如果此选项为 False，则token ‘ing’ 将与 tokenizing 匹配，但如果为 True，则不匹配。“inside of a word” 的概念由正则表达式中的单词边界模式定义（即，标记应以单词边界开头和结尾）。

• lstrip $bool$默认为False
  token是否应该跳过所有位于左边空格。如果为 True，则此令牌将贪婪地匹配其左侧的任何空格。例如，如果我们尝试将标记 [MASK] 与 lstrip=True 匹配，则在文本 “I saw a [MASK]” 中，我们将匹配 “ [MASK]”。（注意左边的空格）。

• rstrip $bool$默认为False
  token是否应该跳过所有位于右边空格。如果为 True，则此令牌将贪婪地匹配其右侧的任何空格。它的工作方式与 lstrip 类似，但在右侧。

• normalized $bool$默认为True与此同时
  方法：~tokenizers.Tokenizer.add_tokens和add_special_tokens()False
  
  此标记是否应与输入文本的规范化版本匹配。例如，添加token “yesterday”，并且负责将文本小写的规范化器，可以从输入中提取标记"I saw a lion Yesterday"。

• special $bool$默认为False并且方法~tokenizers.Tokenizer.add_tokens 和 False 的add_special_tokens()
  
  定义了在解码时是否应该跳过这个token。

描述：
表示可以添加到 Tokenizer 的token。它可以具有定义其行为方式的特殊选项。

@property content
描述：
获取这个AddedToken的内容

@property lstrip
描述：
获取lstrip选项的值

@property normalized
描述：
获取normalized选项的值

@property rstrip
描述：
获取rstrip选项的值

@property single_word
描述：
获取single_word选项的值

Models 模型

BPE

class tokenizers.models.BPE
( vocab = None, merges = None, cache_capacity = None, dropout = None, unk_token = None, continuing_subword_prefix = None, end_of_word_suffix = None, fuse_unk = None, byte_fallback = False, ignore_merges = False )

参数：

• vocab （$Dict[str,\; int]$，可选的）
  字符串键及其 ids 的字典，{“am”: 0,…}
• merges （$List[Tuple[str,\; str]]$，可选的）
  一对token的列表 (Tuple[str, str]) [(“a”, “b”),…]
• cache_capacity （$int$，可选的）
  BPE 高速缓存可以包含的字数。缓存允许通过保留多个单词的合并作结果来加快过程。
• dropout （$float$，可选的）
  一个介于 0 和 1 之间的浮点数，表示要使用的 BPE dropout。
• unk_token （$str$，可选的）
  模型要使用的未知 Token。
• continuing_subword_prefix （$str$，可选的）
  要附加到不表示单词开头的子单词单元的前缀。
• end_of_word_suffix （$str$，可选的）
  要附加到表示词尾的子词单元的后缀。
• fuse_unk （$bool$，可选的）
  是否将任何后续未知token融合为单个token
• byte_fallback （$bool$，可选的）
  是否使用 spm byte-fallback 技巧（默认为 False）
• ignore_merges （$bool$，可选的）
  是否在使用合并之前将标记与词汇匹配。

描述：
BPE（字节对编码）算法的实现

function from_file
( vocab, merge, **kwargs ) → BPE
参数：

• vocab（$str$）
  指向$vocab.json$文件的路径
• merges（$str$）
  指向$merges.txt$文件的路径

返回值：

• BPE
  从这些文件加载的 BPE 实例

描述：
从给定文件实例化 BPE 模型。

此方法大致相当于执行以下操作：

vocab, merges = BPE.read_file(vocab_filename, merges_filename)
bpe = BPE(vocab, merges)

如果您不需要保留$vocab,\; merges$周围的值，此方法比手动调用 read_file（） 来初始化 BPE 更优化

function read_file
( vocab, merges ) → A Tuple with the vocab and the merges
参数：

• vocab（$str$）
  指向$vocab.json$文件的路径
• merges（$str$）
  指向$merges.txt$文件的路径

返回值：

• vocab和merges组合的元组

加载到内存中的词汇表和 Merge

描述：
读 vocab.json 和 merges.txt文件

此方法提供了一种读取和解析这些文件内容的方法，并返回相关的数据结构。如果要从内存中实例化某些 BPE 模型，此方法会为您提供来自标准文件的预期输入。

Model

class tokenizers.models.Model
( )

描述：
所有模型的基类

该模型表示实际的分词化算法。这是一个部分将包含和管理所学的词汇。

不能直接构造此类。请使用其中一种具体模型。

function get_trainer
( ) → Trainer
参数：

• Trainer

用于训练此模型的 Trainer

描述：
获取相关的Trainer类

获得与这个模型相关的Trainer

function id_to_token
( id ) → str
参数：

• id（$int$）
  将转换成一个token的id

返回值：

• str
  与id相关的token

描述：
获取与id相关的token

function save
( folder, prefix ) → List[str]
参数：

• folder（$str$）
  用于保存各种文件的目标文件夹的路径

• prefix（$str$, optional）
  可选前缀，用于为每个文件名添加前缀

返回值：

• List[str]
  保存文件的列表

描述：
保存当前模型

将当前模型保存在指定文件夹中，使用给定的前缀为将要创建的各种文件命名。此文件夹中已经存在的同名文件将被覆盖。

function token_to_id
( tokens ) → int
参数：

• token（$str$）
  将要转换成id的token

返回值：

• int
  与token相关的id

描述：
获取token的id

function tokenize
( sequence ) → A List of Token
参数：

• sequence（$str$）
  要转换成Token的序列

返回值：

• Token的List
  生成的tokens

描述：
对序列进行标记化

Unigram

class tokenizers.models.Unigram
( vocab, unk_id, byte_fallback )

参数：

• vocab （$List[Tuple[str,\; float]]$, optional, optional ）
  词汇项目列表及其相对分数 [（“am”， -0.2442）,…]

描述：
Unigram 算法的实现

WordLevel

class tokenizers.models.WordLevel
( vocab, unk_token )
参数：

• vocab ($str$, optional)
  字符串键及其 ID 的字典 {“am”： 0,…}
• unk_token ($str$, optional)
  模型要使用的未知 Token。

描述：
WordLevel 算法的实现
最简单的 tokenizer 模型基于将 token 映射到它们对应的 id。
function from_file
( vocab, unk_token ) → WordLevel
参数：

• vocab（$str$）
  vocab.json文件的路径

返回值：

• WordLevel
  从 file 加载的 WordLevel 实例

描述：
从给定文件实例化 WordLevel 模型

此方法大致相当于执行以下操作：

vocab = WordLevel.read_file(vocab_filename)
wordlevel = WordLevel(vocab)

如果你不需要保留vocab，这种方法比手动调用 read_file（） 来初始化 WordLevel 更优化

function read_file
( vocab ) → Dict[str, int]
参数：

• vocab（$str$）
  vocab.json文件的路径

返回值：

• Dict[str, int]
  词汇表作为字典

描述：
读取一个vocab.json
此方法提供了一种读取和解析词汇文件内容的方法，并返回相关的数据结构。如果要从内存中实例化某些 WordLevel 模型，此方法会从标准文件中为你提供预期的输入。

WordPiece

class tokenizers.models.WordPiecel
( vocab, unk_token, max_input_chars_per_word )
参数：

• vocab ($Dict[str,\; int]$， optional)
  字符串键及其 ID 的字典，{“am”: 0,…}

• unk_token ($str$， optional)
  模型要使用的未知 Token。

• max_input_chars_per_word ($int$， optional)
  单个单词中要授权的最大字符数。

描述：
WordPiece 算法的实现

function from_file
( vocab，**kwargs ) → WordPiece
参数：

• vocab（$str$）
  vocab.json文件的路径

返回值：

• WordPiece
  从 file 加载的 WordPiece 实例

描述：
从给定文件实例化 WordPiece 模型

此方法大致相当于 如下操作：

vocab = WordPiece.read_file(vocab_filename)
wordpiece = WordPiece(vocab)

如果你不需要保存vocab值，这个方法比手动调用read_file()去初始化WordPiece更加高效。

function read_file
( vocab ) → Dict[str, int]
参数：

• vocab（$str$）
  vocab.json文件的路径

返回值：

• Dict[str, int]
  词典作为dict

描述：
读取一个vocab.txt文件

此方法提供了一种读取和分析 WordPiece 模型使用的标准 vocab.txt 文件内容的方法，并返回相关的数据结构。如果要从内存中实例化某些 WordPiece 模型，此方法会从标准文件中为您提供预期的输入。

还有部分未翻译。

\colorbox{#F9FAFB}{} ​
$\$$
\textasciitilde