分词器

Python

Rust

Node

分词器

class tokenizers.Tokenizer

( model )

参数

model (Model) — 此 Tokenizer 应使用的核心算法。

Tokenizer 作为一个流程工作。它处理一些原始文本作为输入，并输出一个 Encoding。

property decoder

分词器中使用的*可选* Decoder

property model

分词器使用的 Model

property normalizer

分词器中使用的*可选* Normalizer

property padding

（dict，*可选*）

如果启用了填充，则为包含当前填充参数的字典

获取当前填充参数

无法设置，请改用 enable_padding()

property post_processor

分词器中使用的*可选* PostProcessor

property pre_tokenizer

分词器中使用的*可选* PreTokenizer

property truncation

（dict，*可选*）

如果启用了截断，则为包含当前截断参数的字典

获取当前设置的截断参数

无法设置，请改用 enable_truncation()

add_special_tokens

( tokens ) → int

参数

tokens (一个 AddedToken 或 str 的 List) — 我们想要添加到词汇表中的特殊词元列表。每个词元可以是一个字符串，也可以是一个 AddedToken 的实例以进行更多自定义。

int

在词汇表中创建的词元数量

将给定的特殊词元添加到分词器中。

如果这些词元已经是词汇表的一部分，它只是让分词器知道它们。如果它们不存在，分词器会创建它们，并给它们一个新的 ID。

这些特殊词元永远不会被模型处理（即不会被分割成多个词元），并且可以在解码时从输出中移除。

add_tokens

( tokens ) → int

参数

tokens (一个 AddedToken 或 str 的 List) — 我们想要添加到词汇表中的词元列表。每个词元可以是一个字符串，也可以是一个 AddedToken 的实例以进行更多自定义。

int

在词汇表中创建的词元数量

将给定的词元添加到词汇表中

只有当给定的词元在词汇表中尚不存在时，它们才会被添加。然后每个词元都会获得一个新分配的 ID。

decode

( ids skip_special_tokens = True ) → str

参数

ids (List/Tuple of int) — 我们想要解码的 ID 列表
skip_special_tokens (bool, 默认为 True) — 是否应从解码后的字符串中移除特殊词元

字符串

解码后的字符串

将给定的 ID 列表解码回字符串

这用于解码任何从语言模型返回的内容

decode_batch

( sequences skip_special_tokens = True ) → List[str]

参数

sequences (List of List[int]) — 我们想要解码的序列批次
skip_special_tokens (bool, 默认为 True) — 是否应从解码后的字符串中移除特殊词元

List[str]

解码后的字符串列表

将一批 ID 解码回其对应的字符串

enable_padding

( direction = 'right' pad_id = 0 pad_type_id = 0 pad_token = '[PAD]' length = None pad_to_multiple_of = None )

参数

direction (str, *可选*，默认为 right) — 填充的方向。可以是 right 或 left
pad_to_multiple_of (int, *可选*) — 如果指定，填充长度应始终对齐到给定值的下一个倍数。例如，如果我们要填充长度为 250，但 pad_to_multiple_of=8，那么我们将填充到 256。
pad_id (int, 默认为 0) — 填充时使用的 ID
pad_type_id (int, 默认为 0) — 填充时使用的类型 ID
pad_token (str, 默认为 [PAD]) — 填充时使用的填充词元
length (int, *可选*) — 如果指定，则为填充到的长度。如果未指定，则使用批次中最长序列的长度进行填充。

启用填充

enable_truncation

( max_length stride = 0 strategy = 'longest_first' direction = 'right' )

参数

max_length (int) — 截断的最大长度
stride (int, *可选*) — 在溢出序列中包含的前一个第一个序列的长度
strategy (str, *可选*，默认为 longest_first) — 用于截断的策略。可以是 longest_first、only_first 或 only_second 之一。
direction (str, 默认为 right) — 截断方向

启用截断

编码

( sequence pair = None is_pretokenized = False add_special_tokens = True ) → Encoding

参数

sequence (~tokenizers.InputSequence) — 我们想要编码的主要输入序列。根据 is_pretokenized 参数，此序列可以是原始文本或预分词的：
- 如果 is_pretokenized=False: TextInputSequence
- 如果 is_pretokenized=True: PreTokenizedInputSequence()
pair (~tokenizers.InputSequence, *可选*) — 一个可选的输入序列。预期格式与 sequence 相同。
is_pretokenized (bool, 默认为 False) — 输入是否已经预分词
add_special_tokens (bool, 默认为 True) — 是否添加特殊词元

编码

编码结果

对给定的序列和配对进行编码。此方法可以处理原始文本序列以及已经预分词的序列。

示例

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

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
)

encode_batch

( input is_pretokenized = False add_special_tokens = True ) → [`~tokenizers.Encoding`] 的 List

参数

input (一个 List/`Tuple of ~tokenizers.EncodeInput) — 要编码的单个序列或配对序列的列表。根据 is_pretokenized 参数，每个序列可以是原始文本或预分词的：
- 如果 is_pretokenized=False: TextEncodeInput()
- 如果 is_pretokenized=True: PreTokenizedEncodeInput()
is_pretokenized (bool, 默认为 False) — 输入是否已经预分词
add_special_tokens (bool, 默认为 True) — 是否添加特殊词元

一个 [`~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")
])

encode_batch_fast

( input is_pretokenized = False add_special_tokens = True ) → [`~tokenizers.Encoding`] 的 List

参数

input (一个 List/`Tuple of ~tokenizers.EncodeInput) — 要编码的单个序列或配对序列的列表。根据 is_pretokenized 参数，每个序列可以是原始文本或预分词的：
- 如果 is_pretokenized=False: TextEncodeInput()
- 如果 is_pretokenized=True: PreTokenizedEncodeInput()
is_pretokenized (bool, 默认为 False) — 输入是否已经预分词
add_special_tokens (bool, 默认为 True) — 是否添加特殊词元

一个 [`~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")
])

from_buffer

( buffer ) → Tokenizer

参数

buffer (bytes) — 一个包含先前序列化的 Tokenizer 的缓冲区

分词器

新的分词器

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

from_file

( path ) → Tokenizer

参数

path (str) — 一个本地 JSON 文件的路径，该文件代表先前序列化的 Tokenizer

分词器

新的分词器

从给定路径的文件中实例化一个新的 Tokenizer。

from_pretrained

( identifier revision = 'main' token = None ) → Tokenizer

参数

identifier (str) — Hugging Face Hub 上模型的标识符，其中包含一个 tokenizer.json 文件
revision (str, 默认为 *main*) — 分支或提交 ID
token (str, *可选*，默认为 *None*) — 一个可选的身份验证令牌，用于访问 Hugging Face Hub 上的私有仓库

分词器

新的分词器

从 Hugging Face Hub 上的现有文件实例化一个新的 Tokenizer。

from_str

( json ) → Tokenizer

参数

json (str) — 一个有效的 JSON 字符串，代表先前序列化的 Tokenizer

分词器

新的分词器

从给定的 JSON 字符串实例化一个新的 Tokenizer。

get_added_tokens_decoder

( ) → Dict[int, AddedToken]

Dict[int, AddedToken]

词汇表

获取底层的词汇表

get_vocab

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

参数

with_added_tokens (bool, 默认为 True) — 是否包含添加的词元

Dict[str, int]

词汇表

获取底层的词汇表

get_vocab_size

( with_added_tokens = True ) → int

参数

with_added_tokens (bool, 默认为 True) — 是否包含添加的词元

int

词汇表的大小

获取底层词汇表的大小

id_to_token

( id ) → Optional[str]

参数

id (int) — 要转换的 ID

Optional[str]

一个可选的词元，如果超出词汇表范围则为 None

如果存在，将给定的 ID 转换为其对应的词元

no_padding

( )

禁用填充

no_truncation

( )

禁用截断

num_special_tokens_to_add

( is_pair )

返回将为单句/句对添加的特殊词元数量。:param is_pair: 布尔值，指示输入是单个句子还是一个句对 :return

post_process

( encoding pair = None add_special_tokens = True ) → Encoding

参数

encoding (Encoding) — 对应于主序列的 Encoding。
pair (Encoding, *可选*) — 一个可选的 Encoding，对应于配对序列。
add_special_tokens (bool) — 是否添加特殊词元

编码

最终经过后处理的编码

将所有后处理步骤应用于给定的编码。

各个步骤是

根据设置的截断参数进行截断（通过 enable_truncation() 提供）
应用 PostProcessor
根据设置的填充参数进行填充（通过 enable_padding() 提供）

save

( path pretty = True )

参数

path (str) — 用于保存序列化分词器的文件路径。
pretty (bool, 默认为 True) — 是否将 JSON 文件进行美化格式化。

将 Tokenizer 保存到给定路径的文件中。

to_str

( pretty = False ) → str

参数

pretty (bool, 默认为 False) — 是否将 JSON 字符串进行美化格式化。

字符串

一个表示序列化分词器的字符串

获取一个表示此 Tokenizer 的序列化字符串。

token_to_id

( token ) → Optional[int]

参数

token (str) — 要转换的词符

Optional[int]

一个可选的 id，如果词符不在词汇表中则为 None

如果给定的词符存在，则将其转换为对应的 id

train

( files trainer = None )

参数

files (List[str]) — 用于训练的文件路径列表
trainer (~tokenizers.trainers.Trainer, optional) — 一个可选的训练器，用于训练我们的模型

使用给定的文件训练分词器。

逐行读取文件，同时保留所有空白字符，甚至是换行符。如果你想从内存中存储的数据进行训练，可以查看 train_from_iterator()

train_from_iterator

( iterator trainer = None length = None )

参数

iterator (Iterator) — 任何可迭代字符串或字符串列表的迭代器
trainer (~tokenizers.trainers.Trainer, optional) — 一个可选的训练器，用于训练我们的模型
length (int, optional) — 迭代器中序列的总数。这用于提供有意义的进度跟踪

使用提供的迭代器训练分词器。

您可以提供任何 Python 迭代器

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

< > 在 GitHub 上更新