Transformers

( **kwargs )

参数

model_max_length (int, 可选) — Transformer 模型输入的最大长度（以词元数量计）。当使用 from_pretrained() 加载 tokenizer 时，此值将设置为 max_model_input_sizes 中为相关模型存储的值（见上文）。如果未提供值，将默认为 VERY_LARGE_INTEGER (int(1e30))。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
truncation_side (str, 可选) — 模型应在其上应用截断的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
chat_template (str, 可选) — 用于格式化聊天消息列表的 Jinja 模板字符串。完整描述请参见 https://huggingface.co/docs/transformers/chat_templating。
model_input_names (list[string], 可选) — 模型前向传播接受的输入列表（如 "token_type_ids" 或 "attention_mask"）。默认值从同名的类属性中选取。
bos_token (str 或 tokenizers.AddedToken, 可选) — 表示句子开头的特殊词元。将与 self.bos_token 和 self.bos_token_id 关联。
eos_token (str 或 tokenizers.AddedToken, 可选) — 表示句子结尾的特殊词元。将与 self.eos_token 和 self.eos_token_id 关联。
unk_token (str 或 tokenizers.AddedToken, 可选) — 表示词汇表外词元的特殊词元。将与 self.unk_token 和 self.unk_token_id 关联。
sep_token (str 或 tokenizers.AddedToken, 可选) — 在同一输入中分隔两个不同句子的特殊词元（例如 BERT 使用）。将与 self.sep_token 和 self.sep_token_id 关联。
pad_token (str 或 tokenizers.AddedToken, 可选) — 用于使词元数组大小相同以便于批处理的特殊词元。之后将被注意力机制或损失计算忽略。将与 self.pad_token 和 self.pad_token_id 关联。
cls_token (str 或 tokenizers.AddedToken, 可选) — 表示输入类别的特殊词元（例如 BERT 使用）。将与 self.cls_token 和 self.cls_token_id 关联。
mask_token (str 或 tokenizers.AddedToken, 可选) — 表示被掩码词元的特殊词元（由掩码语言模型预训练目标使用，如 BERT）。将与 self.mask_token 和 self.mask_token_id 关联。
additional_special_tokens (tuple 或 list of str 或 tokenizers.AddedToken, 可选) — 额外特殊词元的元组或列表。在此处添加它们以确保当 skip_special_tokens 设置为 True 时解码时跳过它们。如果它们不属于词汇表，它们将被添加到词汇表的末尾。
clean_up_tokenization_spaces (bool, 可选, 默认为 True) — 模型是否应清除在分词过程中拆分输入文本时添加的空格。
split_special_tokens (bool, 可选, 默认为 False) — 特殊词元在分词过程中是否应被拆分。传递此参数将影响 tokenizer 的内部状态。默认行为是不拆分特殊词元。这意味着如果 <s> 是 bos_token，那么 tokenizer.tokenize("<s>") = ['<s>']。否则，如果 split_special_tokens=True，那么 tokenizer.tokenize("<s>") 将得到 ['<','s', '>']。

所有慢速 tokenizer 的基类。

继承自 PreTrainedTokenizerBase。

处理所有共享的分词和特殊词元方法，以及下载/缓存/加载预训练 tokenizer 和向词汇表添加词元的方法。

这个类还在所有 tokenizer 的基础上以统一的方式包含添加的词元，因此我们不必处理各种底层词典结构（BPE、sentencepiece...）的特定词汇增强方法。

类属性（由派生类覆盖）

vocab_files_names (dict[str, str]) — 一个字典，其键是模型所需的每个词汇文件的 __init__ 关键字名称，关联值是用于保存关联文件的文件名（字符串）。
pretrained_vocab_files_map (dict[str, dict[str, str]]) — 一个字典的字典，高层键是模型所需的每个词汇文件的 __init__ 关键字名称，低层键是预训练模型的 short-cut-names，关联值是关联的预训练词汇文件的 url。
model_input_names (list[str]) — 模型正向传播中预期的输入列表。
padding_side (str) — 模型应该应用填充的侧面的默认值。应为 'right' 或 'left'。
truncation_side (str) — 模型应该应用截断的侧面的默认值。应为 'right' 或 'left'。

call

( text: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair: typing.Union[str, list[str], list[list[str]], NoneType] = None text_target: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair_target: typing.Union[str, list[str], list[list[str]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy, NoneType] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → BatchEncoding

参数

text (str, list[str], list[list[str]], 可选) — 要编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_pair (str, list[str], list[list[str]], 可选) — 要编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_target (str, list[str], list[list[str]], 可选) — 作为目标文本编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_pair_target (str, list[str], list[list[str]], 可选) — 作为目标文本编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
add_special_tokens (bool, 可选, 默认为 True) — 在编码序列时是否添加特殊词元。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些词元会自动添加到输入 ID 中。如果您想自动添加 bos 或 eos 词元，这很有用。
padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值：
- True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
- 'max_length': 填充到由 max_length 参数指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。
- False 或 'do_not_pad' (默认): 不填充（即，可以输出具有不同长度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值：
- True 或 'longest_first': 截断到由 max_length 参数指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐个词元地截断，如果提供了一对序列（或一批序列对），则从最长的序列中删除一个词元。
- 'only_first': 截断到由 max_length 参数指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这只会截断第一个序列。
- 'only_second': 截断到由 max_length 参数指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这只会截断第二个序列。
- False 或 'do_not_truncate' (默认): 不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
max_length (int, 可选) — 控制由截断/填充参数之一使用的最大长度。

如果留空或设置为 None，并且截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则截断/填充到最大长度将被停用。
stride (int, 可选, 默认为 0) — 如果与 max_length 一起设置为一个数字，当 return_overflowing_tokens=True 时返回的溢出词元将包含一些来自返回的截断序列末尾的词元，以便在截断和溢出序列之间提供一些重叠。此参数的值定义了重叠词元的数量。
is_split_into_words (bool, 可选, 默认为 False) — 输入是否已预分词（例如，拆分为单词）。如果设置为 True，tokenizer 会假定输入已拆分为单词（例如，通过在空白处拆分），然后对其进行分词。这对于 NER 或词元分类很有用。
pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上使用 Tensor Cores 特别有用。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf': 返回 TensorFlow tf.constant 对象。
- 'pt': 返回 PyTorch torch.Tensor 对象。
- 'np': 返回 Numpy np.ndarray 对象。
return_token_type_ids (bool, 可选) — 是否返回词元类型 ID。如果留空，将根据特定 tokenizer 的默认设置返回词元类型 ID，该设置由 return_outputs 属性定义。

什么是词元类型 ID？
return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果留空，将根据特定 tokenizer 的默认设置返回注意力掩码，该设置由 return_outputs 属性定义。

什么是注意力掩码？
return_overflowing_tokens (bool, 可选, 默认为 False) — 是否返回溢出的词元序列。如果提供了一对输入 ID 序列（或一批序列对）且 truncation_strategy = longest_first 或 True，则会引发错误而不是返回溢出词元。
return_special_tokens_mask (bool, 可选, 默认为 False) — 是否返回特殊词元掩码信息。
return_offsets_mapping (bool, 可选, 默认为 False) — 是否为每个词元返回 (char_start, char_end)。

这仅在继承自 PreTrainedTokenizerFast 的快速 tokenizer 上可用，如果使用 Python 的 tokenizer，此方法将引发 NotImplementedError。
return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。
**kwargs — 传递给 self.tokenize() 方法

BatchEncoding

一个 BatchEncoding，包含以下字段：

input_ids — 要输入到模型中的标记 ID 列表。

什么是输入 ID？
token_type_ids — 要输入到模型中的标记类型 ID 列表（当 return_token_type_ids=True 或如果 *“token_type_ids”* 在 self.model_input_names 中时）。

什么是标记类型 ID？
attention_mask — 指定模型应关注哪些标记的索引列表（当 return_attention_mask=True 或如果 *“attention_mask”* 在 self.model_input_names 中时）。

什么是注意力掩码？
overflowing_tokens — 溢出标记序列列表（当指定 max_length 且 return_overflowing_tokens=True 时）。
num_truncated_tokens — 截断标记的数量（当指定 max_length 且 return_overflowing_tokens=True 时）。
special_tokens_mask — 0 和 1 的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当 add_special_tokens=True 且 return_special_tokens_mask=True 时）。
length — 输入的长度（当 return_length=True 时）

将一个或多个序列或一对或多对序列标记化并准备用于模型的主要方法。

add_tokens

( new_tokens: typing.Union[str, tokenizers.AddedToken, collections.abc.Sequence[typing.Union[str, tokenizers.AddedToken]]] special_tokens: bool = False ) → int

参数

new_tokens (str, tokenizers.AddedToken 或 str 或 tokenizers.AddedToken 的序列) — 只有当词元不在词汇表中时才会被添加。tokenizers.AddedToken 包装了一个字符串词元，让您个性化其行为：该词元是否应仅匹配单个单词，是否应去除左侧所有潜在的空白，是否应去除右侧所有潜在的空白等。
special_tokens (bool, 可选, 默认为 False) — 可用于指定词元是否为特殊词元。这主要改变归一化行为（像 CLS 或 [MASK] 这样的特殊词元通常不会转换为小写）。

有关 tokenizers.AddedToken 的详细信息，请参阅 HuggingFace tokenizers 库。

int

添加到词汇表中的词元数量。

向 tokenizer 类添加一个新的词元列表。如果新词元不在词汇表中，它们将被添加到词汇表中，其索引从当前词汇表的长度开始，并且在应用分词算法之前将被隔离。因此，添加的词元和分词算法词汇表中的词元处理方式不同。

注意，向词汇表添加新词元时，您应确保也调整模型的词元嵌入矩阵的大小，使其嵌入矩阵与 tokenizer 匹配。

为此，请使用 resize_token_embeddings() 方法。

示例

# Let's see how to increase the vocabulary of Bert model and tokenizer
tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased")
model = BertModel.from_pretrained("google-bert/bert-base-uncased")

num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"])
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

add_special_tokens

( special_tokens_dict: dict replace_additional_special_tokens = True ) → int

参数

special_tokens_dict (dictionary str to str, tokenizers.AddedToken, 或 Sequence[Union[str, AddedToken]]) — 键应位于预定义的特殊属性列表中：[bos_token, eos_token, unk_token, sep_token, pad_token, cls_token, mask_token, additional_special_tokens]。

仅当标记尚未在词汇表中时才会添加（通过检查分词器是否为它们分配了 unk_token 的索引来测试）。
replace_additional_special_tokens (bool, 可选，默认为 True) — 如果为 True，现有的附加特殊标记列表将被 special_tokens_dict 中提供的列表替换。否则，仅扩展 self._special_tokens_map["additional_special_tokens"]。在前一种情况下，这些标记不会从分词器的完整词汇表中移除 - 它们只是被标记为非特殊标记。请记住，这只影响在解码期间哪些标记被跳过，而不影响 added_tokens_encoder 和 added_tokens_decoder。这意味着之前的 additional_special_tokens 仍然是已添加的标记，并且不会被模型拆分。

int

添加到词汇表中的词元数量。

向编码器添加一个特殊标记（eos、pad、cls 等）的字典，并将它们链接到类属性。如果特殊标记不在词汇表中，则将它们添加到词汇表中（从当前词汇表的最后一个索引开始索引）。

当向词汇表添加新标记时，应确保同时调整模型的标记嵌入矩阵的大小，使其嵌入矩阵与分词器匹配。

为此，请使用 resize_token_embeddings() 方法。

使用 add_special_tokens 将确保您的特殊标记可以通过多种方式使用

使用 skip_special_tokens = True 时，可以在解码时跳过特殊标记。
特殊标记由分词器仔细处理（它们永远不会被拆分），类似于 AddedTokens。
您可以使用分词器类属性（如 tokenizer.cls_token）轻松引用特殊标记。这使得开发与模型无关的训练和微调脚本变得容易。

在可能的情况下，特殊标记已经为提供的预训练模型注册（例如 BertTokenizer 的 cls_token 已注册为 '[CLS]'，XLM 的也已注册为 '</s>'）。

示例

# Let's see how to add a new classification token to GPT-2
tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2Model.from_pretrained("openai-community/gpt2")

special_tokens_dict = {"cls_token": "<CLS>"}

num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

assert tokenizer.cls_token == "<CLS>"

apply_chat_template

( conversation: typing.Union[list[dict[str, str]], list[list[dict[str, str]]]] tools: typing.Optional[list[typing.Union[dict, typing.Callable]]] = None documents: typing.Optional[list[dict[str, str]]] = None chat_template: typing.Optional[str] = None add_generation_prompt: bool = False continue_final_message: bool = False tokenize: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: bool = False max_length: typing.Optional[int] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_dict: bool = False return_assistant_tokens_mask: bool = False tokenizer_kwargs: typing.Optional[dict[str, typing.Any]] = None **kwargs ) → Union[list[int], Dict]

参数

conversation (Union[list[dict[str, str]], list[list[dict[str, str]]]]) — 一个包含“role”和“content”键的字典列表，表示迄今为止的聊天历史记录。
tools (list[Union[Dict, Callable]], 可选) — 模型可访问的工具（可调用函数）列表。如果模板不支持函数调用，此参数将无效。每个工具都应作为 JSON Schema 传递，给出工具的名称、描述和参数类型。更多信息请参阅我们的聊天模板指南。
documents (list[dict[str, str]], 可选) — 一个表示文档的字典列表，如果模型正在执行 RAG（检索增强生成），这些文档将对模型可用。如果模板不支持 RAG，此参数将无效。我们建议每个文档都是一个包含“title”和“text”键的字典。有关通过聊天模板传递文档的示例，请参阅聊天模板指南的 RAG 部分。
chat_template (str, 可选) — 用于此转换的 Jinja 模板。通常不需要向此参数传递任何内容，因为默认情况下将使用模型的模板。
add_generation_prompt (bool, 可选) — 如果设置此项，则会在格式化输出的末尾附加一个带有表示助手消息开始的标记的提示。当您希望从模型生成响应时，这很有用。请注意，此参数将传递给聊天模板，因此模板必须支持此参数才能使其生效。
continue_final_message (bool, 可选) — 如果设置此项，聊天将被格式化，以便聊天中的最后一条消息是开放式的，没有任何 EOS 标记。模型将继续此消息，而不是开始一条新消息。这允许您为其“预填充”模型响应的一部分。不能与 add_generation_prompt 同时使用。
tokenize (bool, 默认为 True) — 是否对输出进行分词。如果为 False，输出将是一个字符串。
padding (bool, str 或 PaddingStrategy, 可选，默认为 False) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引）：
- True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
- 'max_length': 填充到由 max_length 参数指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
- False 或 'do_not_pad' (默认): 不填充（即，可以输出具有不同长度序列的批次）。
truncation (bool, 默认为 False) — 是否在最大长度处截断序列。如果 tokenize 为 False，则无效。
max_length (int, 可选) — 用于填充或截断的最大长度（以标记计）。如果 tokenize 为 False，则无效。如果未指定，将使用分词器的 max_length 属性作为默认值。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。如果 tokenize 为 False，则无效。可接受的值为：
- 'tf': 返回 TensorFlow tf.Tensor 对象。
- 'pt': 返回 PyTorch torch.Tensor 对象。
- 'np': 返回 NumPy np.ndarray 对象。
- 'jax': 返回 JAX jnp.ndarray 对象。
return_dict (bool, 默认为 False) — 是否返回带有命名输出的字典。如果 tokenize 为 False，则无效。
tokenizer_kwargs (dict[str -- Any], 可选): 要传递给分词器的附加关键字参数。
return_assistant_tokens_mask (bool, 默认为 False) — 是否返回助手生成标记的掩码。对于助手生成的标记，掩码将包含 1。对于用户和系统标记，掩码将包含 0。此功能仅适用于通过 {% generation %} 关键字支持它的聊天模板。
**kwargs — 要传递给模板渲染器的附加关键字参数。聊天模板将可以访问。

Union[list[int], Dict]

一个表示迄今为止分词后聊天的标记 ID 列表，包括控制标记。此输出已准备好传递给模型，可以直接传递，也可以通过 generate() 等方法传递。如果设置了 return_dict，则将返回一个分词器输出的字典。

将包含 "role" 和 "content" 键的字典列表转换为标记 ID 列表。此方法旨在与聊天模型一起使用，并将读取分词器的 chat_template 属性以确定在转换时使用的格式和控制标记。

batch_decode

( sequences: typing.Union[list[int], list[list[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None **kwargs ) → list[str]

参数

sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可以使用 __call__ 方法获得。
skip_special_tokens (bool, 可选，默认为 False) — 在解码时是否移除特殊标记。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词空格。如果为 None，将默认为 self.clean_up_tokenization_spaces。
kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。

list[str]

解码后的句子列表。

通过调用 decode 将标记 ID 列表的列表转换为字符串列表。

decode

( token_ids: typing.Union[int, list[int], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None **kwargs ) → str

参数

token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可以使用 __call__ 方法获得。
skip_special_tokens (bool, 可选，默认为 False) — 在解码时是否移除特殊标记。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词空格。如果为 None，将默认为 self.clean_up_tokenization_spaces。
kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。

字符串

解码后的句子。

使用分词器和词汇表将 ID 序列转换为字符串，可以选择移除特殊标记并清理分词空间。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

编码

( text: typing.Union[str, list[str], list[int]] text_pair: typing.Union[str, list[str], list[int], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy, NoneType] = None max_length: typing.Optional[int] = None stride: int = 0 padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs ) → list[int], torch.Tensor, tf.Tensor 或 np.ndarray

参数

text (str, list[str] 或 list[int]) — 要编码的第一个序列。这可以是一个字符串，一个字符串列表（使用 tokenize 方法分词后的字符串）或一个整数列表（使用 convert_tokens_to_ids 方法分词后的字符串 ID）。
text_pair (str, list[str] 或 list[int], 可选) — 可选的要编码的第二个序列。这可以是一个字符串，一个字符串列表（使用 tokenize 方法分词后的字符串）或一个整数列表（使用 convert_tokens_to_ids 方法分词后的字符串 ID）。
add_special_tokens (bool, 可选，默认为 True) — 在编码序列时是否添加特殊标记。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些标记会自动添加到输入 ID 中。如果您想自动添加 bos 或 eos 标记，这很有用。
padding (bool, str 或 PaddingStrategy, 可选，默认为 False) — 激活和控制填充。接受以下值：
- True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
- 'max_length': 填充到由 max_length 参数指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
- False 或 'do_not_pad' (默认): 不填充（即，可以输出具有不同长度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可选，默认为 False) — 激活和控制截断。接受以下值：
- True 或 'longest_first': 截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。这将逐个标记地截断，如果提供了一对序列（或一批对），则从该对中最长的序列中移除一个标记。
- 'only_first': 截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批对），则仅截断第一个序列。
- 'only_second': 截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批对），则仅截断第二个序列。
- False 或 'do_not_truncate' (默认): 不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
max_length (int, 可选) — 控制由截断/填充参数之一使用的最大长度。

如果未设置或设置为 None，则如果截断/填充参数之一需要最大长度，将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则截断/填充到最大长度的操作将被停用。
stride (int, 可选，默认为 0) — 如果与 max_length 一起设置为一个数字，当 return_overflowing_tokens=True 时返回的溢出标记将包含一些来自返回的截断序列末尾的标记，以在截断和溢出序列之间提供一些重叠。此参数的值定义了重叠标记的数量。
is_split_into_words (bool, 可选，默认为 False) — 输入是否已经预分词（例如，拆分为单词）。如果设置为 True，分词器将假定输入已拆分为单词（例如，通过在空白处拆分），它将对这些单词进行分词。这对于 NER 或标记分类很有用。
pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Cores 特别有用。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf': 返回 TensorFlow tf.constant 对象。
- 'pt': 返回 PyTorch torch.Tensor 对象。
- 'np': 返回 Numpy np.ndarray 对象。
**kwargs — 传递给 .tokenize() 方法。

list[int], torch.Tensor, tf.Tensor 或 np.ndarray

文本的分词后 ID。

使用分词器和词汇表将字符串转换为 ID（整数）序列。

与执行 self.convert_tokens_to_ids(self.tokenize(text)) 相同。

push_to_hub

( repo_id: str use_temp_dir: typing.Optional[bool] = None commit_message: typing.Optional[str] = None private: typing.Optional[bool] = None token: typing.Union[bool, str, NoneType] = None max_shard_size: typing.Union[str, int, NoneType] = '5GB' create_pr: bool = False safe_serialization: bool = True revision: typing.Optional[str] = None commit_description: typing.Optional[str] = None tags: typing.Optional[list[str]] = None **deprecated_kwargs )

参数

repo_id (str) — 您想将分词器推送到的存储库的名称。当推送到特定组织时，它应包含您的组织名称。
use_temp_dir (bool, optional) — 是否使用临时目录来存储推送到 Hub 之前保存的文件。如果没有名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, optional) — 推送时要提交的消息。默认为 "Upload tokenizer"。
private (bool, optional) — 是否将存储库设为私有。如果为 None（默认值），除非组织的默认设置是私有，否则存储库将是公开的。如果存储库已存在，此值将被忽略。
token (bool or str, optional) — 用于远程文件的 HTTP 持有者授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int or str, optional, defaults to "5GB") — 仅适用于模型。检查点分片前的最大大小。每个检查点分片的大小将小于此值。如果以字符串形式表示，则需要是数字后跟单位（如 "5MB"）。我们默认设置为 "5GB"，以便用户可以在免费的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU 内存不足（OOM）的问题。
create_pr (bool, optional, defaults to False) — 是否为上传的文件创建一个拉取请求（PR）或直接提交。
safe_serialization (bool, optional, defaults to True) — 是否将模型权重转换为 safetensors 格式以实现更安全的序列化。
revision (str, optional) — 要将上传的文件推送到的分支。
commit_description (str, optional) — 将要创建的提交的描述。
tags (list[str], optional) — 要推送到 Hub 的标签列表。

将分词器文件上传到 🤗 Model Hub。

示例

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")

# Push the tokenizer to your namespace with the name "my-finetuned-bert".
tokenizer.push_to_hub("my-finetuned-bert")

# Push the tokenizer to an organization with the name "my-finetuned-bert".
tokenizer.push_to_hub("huggingface/my-finetuned-bert")

convert_ids_to_tokens

( ids: typing.Union[int, list[int]] skip_special_tokens: bool = False ) → str or list[str]

参数

ids (int or list[int]) — 要转换为词符的词符 ID（或词符 ID 列表）。
skip_special_tokens (bool, optional, defaults to False) — 是否在解码时移除特殊词符。

str or list[str]

解码后的词符。

使用词汇表和添加的词符，将单个索引或索引序列转换为一个词符或词符序列。

convert_tokens_to_ids

( tokens: typing.Union[str, list[str]] ) → int or list[int]

参数

tokens (str or list[str]) — 要转换为词符 ID 的一个或多个词符。

int or list[int]

词符 ID 或词符 ID 列表。

使用词汇表，将一个词符字符串（或词符序列）转换为单个整数 ID（或 ID 序列）。

get_added_vocab

( ) → dict[str, int]

dict[str, int]

添加的词符。

以词符到索引的字典形式返回词汇表中添加的词符。结果可能与快速调用不同，因为目前即使词符已在词汇表中，我们仍会添加它们。这是我们应该改变的地方。

num_special_tokens_to_add

( pair: bool = False ) → int

参数

pair (bool, optional, defaults to False) — 是否在序列对的情况下或单个序列的情况下计算添加的词符数量。

int

添加到序列中的特殊词符数量。

在使用特殊词符编码序列时返回添加的词符数量。

此方法会对一个虚拟输入进行编码并检查添加的词符数量，因此效率不高。请勿将其放入您的训练循环中。

prepare_for_tokenization

( text: str is_split_into_words: bool = False **kwargs ) → tuple[str, dict[str, Any]]

参数

text (str) — 要准备的文本。
is_split_into_words (bool, optional, defaults to False) — 输入是否已预分词（例如，拆分为单词）。如果设置为 True，分词器会假定输入已被拆分为单词（例如，通过在空白处分割），然后它将对这些单词进行分词。这对于 NER 或词符分类任务很有用。
kwargs (dict[str, Any], optional) — 用于分词的关键字参数。

tuple[str, dict[str, Any]]

准备好的文本和未使用的 kwargs。

在分词前执行任何必要的转换。

此方法应从 kwargs 中弹出参数，并返回剩余的 kwargs。我们在编码过程结束时测试 kwargs，以确保所有参数都已使用。

tokenize

( text: str **kwargs ) → list[str]

参数

text (str) — 要编码的序列。
**kwargs (附加关键字参数) — 传递给特定于模型的 prepare_for_tokenization 预处理方法。

list[str]

令牌列表。

使用分词器将字符串转换为词符序列。

对于基于词的词汇表，拆分为单词；对于基于子词的词汇表（BPE/SentencePieces/WordPieces），拆分为子词。处理添加的词符。

PreTrainedTokenizerFast

PreTrainedTokenizerFast 依赖于 tokenizers 库。从 🤗 tokenizers 库中获得的分词器可以非常简单地加载到 🤗 transformers 中。请查看使用 🤗 tokenizers 的分词器页面，了解如何操作。

class transformers.PreTrainedTokenizerFast

( *args **kwargs )

参数

model_max_length (int, optional) — Transformer 模型输入的最大长度（以词符数量计）。当使用 from_pretrained() 加载分词器时，此值将设置为相关模型在 max_model_input_sizes 中存储的值（见上文）。如果未提供值，则默认为 VERY_LARGE_INTEGER (int(1e30))。
padding_side (str, optional) — 模型应在其上应用填充的一侧。应从 [‘right’, ‘left’] 中选择。默认值从同名的类属性中选取。
truncation_side (str, optional) — 模型应在其上应用截断的一侧。应从 [‘right’, ‘left’] 中选择。默认值从同名的类属性中选取。
chat_template (str, optional) — 一个 Jinja 模板字符串，用于格式化聊天消息列表。有关完整说明，请参阅 https://huggingface.co/docs/transformers/chat_templating。
model_input_names (list[string], optional) — 模型前向传播接受的输入列表（如 "token_type_ids" 或 "attention_mask"）。默认值从同名的类属性中选取。
bos_token (str or tokenizers.AddedToken, optional) — 表示句子开头的特殊词符。将与 self.bos_token 和 self.bos_token_id 相关联。
eos_token (str or tokenizers.AddedToken, optional) — 表示句子结尾的特殊词符。将与 self.eos_token 和 self.eos_token_id 相关联。
unk_token (str or tokenizers.AddedToken, optional) — 表示词汇表外词符的特殊词符。将与 self.unk_token 和 self.unk_token_id 相关联。
sep_token (str or tokenizers.AddedToken, optional) — 在同一输入中分隔两个不同句子的特殊词符（例如，BERT 使用）。将与 self.sep_token 和 self.sep_token_id 相关联。
pad_token (str or tokenizers.AddedToken, optional) — 用于使词符数组大小相同以便于批处理的特殊词符。之后将被注意力机制或损失计算忽略。将与 self.pad_token 和 self.pad_token_id 相关联。
cls_token (str or tokenizers.AddedToken, optional) — 表示输入类别的特殊词符（例如，BERT 使用）。将与 self.cls_token 和 self.cls_token_id 相关联。
mask_token (str or tokenizers.AddedToken, optional) — 表示掩码词符的特殊词符（用于掩码语言建模预训练目标，如 BERT）。将与 self.mask_token 和 self.mask_token_id 相关联。
additional_special_tokens (tuple or list of str or tokenizers.AddedToken, optional) — 一个元组或列表，包含额外的特殊词符。在此处添加它们，以确保在解码时当 skip_special_tokens 设置为 True 时它们被跳过。如果它们不是词汇表的一部分，它们将被添加到词汇表的末尾。
clean_up_tokenization_spaces (bool, optional, defaults to True) — 模型是否应清理在分词过程中分割输入文本时添加的空格。
split_special_tokens (bool, optional, defaults to False) — 特殊词符在分词过程中是否应被分割。传递此参数将影响分词器的内部状态。默认行为是不分割特殊词符。这意味着如果 <s> 是 bos_token，则 tokenizer.tokenize("<s>") = ['<s>']。否则，如果 split_special_tokens=True，则 tokenizer.tokenize("<s>") 将得到 ['<','s', '>']。
tokenizer_object (tokenizers.Tokenizer) — 从 🤗 tokenizers 实例化的 tokenizers.Tokenizer 对象。有关更多信息，请参阅使用 🤗 tokenizers 的分词器。
tokenizer_file (str) — 一个本地 JSON 文件的路径，代表先前从 🤗 tokenizers 序列化的 tokenizers.Tokenizer 对象。

所有快速分词器的基类（包装 HuggingFace tokenizers 库）。

继承自 PreTrainedTokenizerBase。

处理所有共享的分词和特殊词符方法，以及下载/缓存/加载预训练分词器和向词汇表添加词符的方法。

这个类还以统一的方式在所有分词器之上包含添加的词符，因此我们不必处理各种底层词典结构（BPE，sentencepiece…）的特定词汇表增强方法。

类属性（由派生类覆盖）

vocab_files_names (dict[str, str]) — 一个字典，其键是模型所需的每个词汇文件的 __init__ 关键字名称，关联值是用于保存关联文件的文件名（字符串）。
pretrained_vocab_files_map (dict[str, dict[str, str]]) — 一个字典的字典，高层键是模型所需的每个词汇文件的 __init__ 关键字名称，低层键是预训练模型的 short-cut-names，关联值是关联的预训练词汇文件的 url。
model_input_names (list[str]) — 模型正向传播中预期的输入列表。
padding_side (str) — 模型应该应用填充的侧面的默认值。应为 'right' 或 'left'。
truncation_side (str) — 模型应该应用截断的侧面的默认值。应为 'right' 或 'left'。

call

参数

text (str, list[str], list[list[str]], optional) — 要编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_pair (str, list[str], list[list[str]], optional) — 要编码的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_target (str, list[str], list[list[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
text_pair_target (str, list[str], list[list[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是一个字符串或一个字符串列表（预分词的字符串）。如果序列以字符串列表（预分词）的形式提供，您必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
add_special_tokens (bool, optional, defaults to True) — 是否在编码序列时添加特殊词符。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些词符会自动添加到输入 ID 中。如果您想自动添加 bos 或 eos 词符，这会很有用。
padding (bool, str or PaddingStrategy, optional, defaults to False) — 激活和控制填充。接受以下值：
- True 或 'longest'：填充到批次中最长的序列（如果只提供单个序列则不填充）。
- 'max_length'：填充到由 max_length 参数指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。
- False 或 'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活并控制截断。接受以下值：
- True 或 'longest_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。这将逐个词元进行截断，如果提供了一对序列（或一批序列对），则从最长的序列中移除一个词元。
- 'only_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这只会截断第一个序列。
- 'only_second'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这只会截断第二个序列。
- False 或 'do_not_truncate' (默认)：不进行截断（即可以输出序列长度大于模型最大可接受输入大小的批次）。
max_length (int, 可选) — 控制截断/填充参数使用的最大长度。

如果未设置或设置为 None，并且截断/填充参数需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则截断/填充到最大长度的功能将被停用。
stride (int, 可选, 默认为 0) — 如果与 max_length 一起设置，并且当 return_overflowing_tokens=True 时，返回的溢出词元将包含一些来自返回的被截断序列末尾的词元，以在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠词元的数量。
is_split_into_words (bool, 可选, 默认为 False) — 输入是否已经预分词（例如，拆分为单词）。如果设置为 True，分词器将假定输入已经被拆分为单词（例如，通过空格分割），然后对其进行分词。这对于 NER 或词元分类任务很有用。
pad_to_multiple_of (int, 可选) — 如果设置，将把序列填充到所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Cores 特别有用。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值有：
- 'tf'：返回 TensorFlow tf.constant 对象。
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 Numpy np.ndarray 对象。
return_token_type_ids (bool, 可选) — 是否返回词元类型 ID。如果保留默认值，将根据特定分词器的默认设置返回词元类型 ID，该设置由 return_outputs 属性定义。

什么是词元类型 ID？
return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保留默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由 return_outputs 属性定义。

什么是注意力掩码？
return_overflowing_tokens (bool, 可选, 默认为 False) — 是否返回溢出的词元序列。如果提供了一对输入 ID 序列（或一批序列对）并设置了 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出的词元。
return_special_tokens_mask (bool, 可选, 默认为 False) — 是否返回特殊词元掩码信息。
return_offsets_mapping (bool, 可选, 默认为 False) — 是否为每个词元返回 (char_start, char_end)。

这仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用，如果使用 Python 的分词器，此方法将引发 NotImplementedError。
return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。
**kwargs — 传递给 self.tokenize() 方法的参数

BatchEncoding

一个 BatchEncoding，包含以下字段：

input_ids — 要输入到模型中的标记 ID 列表。

什么是输入 ID？
token_type_ids — 要输入到模型中的标记类型 ID 列表（当 return_token_type_ids=True 或如果 *“token_type_ids”* 在 self.model_input_names 中时）。

什么是标记类型 ID？
attention_mask — 指定模型应关注哪些标记的索引列表（当 return_attention_mask=True 或如果 *“attention_mask”* 在 self.model_input_names 中时）。

什么是注意力掩码？
overflowing_tokens — 溢出标记序列列表（当指定 max_length 且 return_overflowing_tokens=True 时）。
num_truncated_tokens — 截断标记的数量（当指定 max_length 且 return_overflowing_tokens=True 时）。
special_tokens_mask — 0 和 1 的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当 add_special_tokens=True 且 return_special_tokens_mask=True 时）。
length — 输入的长度（当 return_length=True 时）

将一个或多个序列或一对或多对序列标记化并准备用于模型的主要方法。

add_tokens

( new_tokens: typing.Union[str, tokenizers.AddedToken, collections.abc.Sequence[typing.Union[str, tokenizers.AddedToken]]] special_tokens: bool = False ) → int

参数

new_tokens (str, tokenizers.AddedToken 或 str 或 tokenizers.AddedToken 的序列) — 仅当词元不在词汇表中时才会被添加。tokenizers.AddedToken 包装了一个字符串词元，允许您自定义其行为：此词元是否应仅匹配单个单词、是否应剥离左侧所有潜在的空白、是否应剥离右侧所有潜在的空白等。
special_tokens (bool, 可选, 默认为 False) — 可用于指定该词元是否为特殊词元。这主要改变其归一化行为（例如，像 CLS 或 [MASK] 这样的特殊词元通常不会被转换为小写）。

有关 HuggingFace tokenizers 库中 tokenizers.AddedToken 的详细信息，请参阅相关文档。

int

添加到词汇表中的词元数量。

注意，向词汇表添加新词元时，您应确保也调整模型的词元嵌入矩阵的大小，使其嵌入矩阵与 tokenizer 匹配。

为此，请使用 resize_token_embeddings() 方法。

示例

# Let's see how to increase the vocabulary of Bert model and tokenizer
tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased")
model = BertModel.from_pretrained("google-bert/bert-base-uncased")

num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"])
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

add_special_tokens

( special_tokens_dict: dict replace_additional_special_tokens = True ) → int

参数

special_tokens_dict (str 到 str 的字典, tokenizers.AddedToken, 或 Sequence[Union[str, AddedToken]]) — 键应在预定义的特殊属性列表中：[bos_token, eos_token, unk_token, sep_token, pad_token, cls_token, mask_token, additional_special_tokens]。

仅当词元不在词汇表中时才会被添加（通过检查分词器是否为它们分配 unk_token 的索引来测试）。
replace_additional_special_tokens (bool, 可选,, 默认为 True) — 如果为 True，现有的额外特殊词元列表将被 special_tokens_dict 中提供的列表替换。否则，self._special_tokens_map["additional_special_tokens"] 只是被扩展。在前一种情况下，这些词元不会从分词器的完整词汇表中移除——它们只是被标记为非特殊词元。请记住，这只影响解码过程中哪些词元被跳过，而不影响 added_tokens_encoder 和 added_tokens_decoder。这意味着之前的 additional_special_tokens 仍然是已添加的词元，并且不会被模型分割。

int

添加到词汇表中的词元数量。

当向词汇表添加新标记时，应确保同时调整模型的标记嵌入矩阵的大小，使其嵌入矩阵与分词器匹配。

为此，请使用 resize_token_embeddings() 方法。

使用 add_special_tokens 将确保您的特殊标记可以通过多种方式使用

使用 skip_special_tokens = True 时，可以在解码时跳过特殊标记。
特殊标记由分词器仔细处理（它们永远不会被拆分），类似于 AddedTokens。
您可以使用分词器类属性（如 tokenizer.cls_token）轻松引用特殊标记。这使得开发与模型无关的训练和微调脚本变得容易。

在可能的情况下，特殊标记已经为提供的预训练模型注册（例如 BertTokenizer 的 cls_token 已注册为 '[CLS]'，XLM 的也已注册为 '</s>'）。

示例

# Let's see how to add a new classification token to GPT-2
tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2Model.from_pretrained("openai-community/gpt2")

special_tokens_dict = {"cls_token": "<CLS>"}

num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

assert tokenizer.cls_token == "<CLS>"

apply_chat_template

参数

conversation (Union[list[dict[str, str]], list[list[dict[str, str]]]]) — 一个由字典组成的列表，每个字典包含“role”和“content”键，代表到目前为止的聊天历史记录。
tools (list[Union[Dict, Callable]], 可选) — 一个工具列表（可调用函数），模型可以访问这些工具。如果模板不支持函数调用，此参数将无效。每个工具都应以 JSON Schema 的形式传递，给出工具的名称、描述和参数类型。更多信息请参阅我们的聊天模板指南。
documents (list[dict[str, str]], 可选) — 一个代表文档的字典列表，如果模型正在执行 RAG（检索增强生成），则可以访问这些文档。如果模板不支持 RAG，此参数将无效。我们建议每个文档都应是一个包含“title”和“text”键的字典。有关通过聊天模板传递文档的示例，请参阅聊天模板指南的 RAG 部分。
chat_template (str, 可选) — 用于此转换的 Jinja 模板。通常不需要向此参数传递任何内容，因为默认情况下将使用模型的模板。
add_generation_prompt (bool, 可选) — 如果设置，将在格式化输出的末尾附加一个提示，该提示包含指示助手消息开始的词元。这在您希望模型生成响应时很有用。请注意，此参数将传递给聊天模板，因此模板必须支持此参数才能生效。
continue_final_message (bool, 可选) — 如果设置，聊天将被格式化，使得聊天中的最后一条消息是开放式的，没有任何 EOS 词元。模型将继续这条消息而不是开始一条新的消息。这允许您为模型“预填充”部分响应。不能与 add_generation_prompt 同时使用。
tokenize (bool, 默认为 True) — 是否对输出进行分词。如果为 False，输出将是一个字符串。
padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引）：
- True 或 'longest'：填充到批次中最长的序列（如果只提供单个序列则不填充）。
- 'max_length'：填充到由 max_length 参数指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
- False 或 'do_not_pad' (默认)：不填充（即可以输出一个包含不同长度序列的批次）。
truncation (bool, 默认为 False) — 是否在最大长度处截断序列。如果 tokenize 为 False 则无效。
max_length (int, 可选) — 用于填充或截断的最大长度（以词元为单位）。如果 tokenize 为 False 则无效。如果未指定，将使用分词器的 max_length 属性作为默认值。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。如果 tokenize 为 False 则无效。可接受的值有：
- 'tf'：返回 TensorFlow tf.Tensor 对象。
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 NumPy np.ndarray 对象。
- 'jax'：返回 JAX jnp.ndarray 对象。
return_dict (bool, 默认为 False) — 是否返回一个带有命名输出的字典。如果 tokenize 为 False 则无效。
tokenizer_kwargs (dict[str -- Any], 可选): 传递给分词器的额外 kwargs。
return_assistant_tokens_mask (bool, 默认为 False) — 是否返回助手生成词元的掩码。对于助手生成的词元，掩码将包含 1。对于用户和系统词元，掩码将包含 0。此功能仅在通过 {% generation %} 关键字支持它的聊天模板中可用。
**kwargs — 传递给模板渲染器的额外 kwargs。聊天模板可以访问。

Union[list[int], Dict]

batch_decode

参数

sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可以使用 __call__ 方法获得。
skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，将默认为 self.clean_up_tokenization_spaces。
kwargs (额外的关键字参数, 可选) — 将传递给底层特定模型的解码方法。

list[str]

解码后的句子列表。

通过调用 decode 将标记 ID 列表的列表转换为字符串列表。

decode

参数

token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可以使用 __call__ 方法获得。
skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，将默认为 self.clean_up_tokenization_spaces。
kwargs (额外的关键字参数, 可选) — 将传递给底层特定模型的解码方法。

字符串

解码后的句子。

使用分词器和词汇表将 ID 序列转换为字符串，可以选择移除特殊标记并清理分词空间。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

编码

参数

text (str, list[str] 或 list[int]) — 要编码的第一个序列。这可以是一个字符串、一个字符串列表（使用 tokenize 方法分词后的字符串）或一个整数列表（使用 convert_tokens_to_ids 方法分词后的字符串 ID）。
text_pair (str, list[str] 或 list[int], 可选) — 要编码的可选第二个序列。这可以是一个字符串、一个字符串列表（使用 tokenize 方法分词后的字符串）或一个整数列表（使用 convert_tokens_to_ids 方法分词后的字符串 ID）。
add_special_tokens (bool, 可选, 默认为 True) — 是否在编码序列时添加特殊词元。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些词元会自动添加到输入 ID 中。如果您想自动添加 bos 或 eos 词元，这很有用。
padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活并控制填充。接受以下值：
- True 或 'longest'：填充到批次中最长的序列（如果只提供单个序列，则不进行填充）。
- 'max_length'：填充到由 max_length 参数指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
- False 或 'do_not_pad' (默认)：不进行填充（即，可以输出包含不同长度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活并控制截断。接受以下值：
- True 或 'longest_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。这将逐个词元进行截断，如果提供了一对序列（或一批序列对），则从最长的序列中移除一个词元。
- 'only_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断第一个序列。
- 'only_second'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断第二个序列。
- False 或 'do_not_truncate' (默认)：不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
max_length (int, 可选) — 控制截断/填充参数使用的最大长度。

如果未设置或设置为 None，并且截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度的功能。
stride (int, 可选, 默认为 0) — 如果与 max_length 一起设置，当 return_overflowing_tokens=True 时返回的溢出词元将包含一些来自被截断序列末尾的词元，以便在被截断和溢出的序列之间提供一些重叠。此参数的值定义了重叠词元的数量。
is_split_into_words (bool, 可选, 默认为 False) — 输入是否已经预分词（例如，拆分为单词）。如果设置为 True，分词器会假定输入已经被拆分为单词（例如，通过空格分割），然后对其进行分词。这对于 NER 或词元分类任务很有用。
pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上使用 Tensor Cores 特别有用。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 ['right', 'left'] 之间选择。默认值从同名的类属性中选取。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf'：返回 TensorFlow tf.constant 对象。
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 Numpy np.ndarray 对象。
**kwargs — 传递给 .tokenize() 方法。

list[int], torch.Tensor, tf.Tensor 或 np.ndarray

文本的分词后 ID。

使用分词器和词汇表将字符串转换为 ID（整数）序列。

与执行 self.convert_tokens_to_ids(self.tokenize(text)) 相同。

push_to_hub

参数

repo_id (str) — 您想要将分词器推送到的仓库名称。当推送到特定组织时，它应包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录来存储在推送到 Hub 之前保存的文件。如果没有名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时要提交的消息。将默认为 "Upload tokenizer"。
private (bool, 可选) — 是否将仓库设为私有。如果为 None (默认)，除非组织的默认设置为私有，否则仓库将为公开。如果仓库已存在，则此值将被忽略。
token (bool or str, 可选) — 用于远程文件 HTTP 持有者授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int or str, 可选, 默认为 "5GB") — 仅适用于模型。在分片前检查点的最大大小。检查点分片的大小将小于此大小。如果表示为字符串，需要是数字后跟一个单位（如 "5MB"）。我们默认为 "5GB"，以便用户可以在免费的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。
create_pr (bool, 可选, 默认为 False) — 是为上传的文件创建一个 PR 还是直接提交。
safe_serialization (bool, 可选, 默认为 True) — 是否将模型权重转换为 safetensors 格式以进行更安全的序列化。
revision (str, 可选) — 上传文件要推送到的分支。
commit_description (str, 可选) — 将要创建的提交的描述。
tags (list[str], 可选) — 要在 Hub 上推送的标签列表。

将分词器文件上传到 🤗 Model Hub。

示例

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")

# Push the tokenizer to your namespace with the name "my-finetuned-bert".
tokenizer.push_to_hub("my-finetuned-bert")

# Push the tokenizer to an organization with the name "my-finetuned-bert".
tokenizer.push_to_hub("huggingface/my-finetuned-bert")

convert_ids_to_tokens

( ids: typing.Union[int, list[int]] skip_special_tokens: bool = False ) → str or list[str]

参数

ids (int or list[int]) — 要转换为词元的词元 ID（或词元 ID 列表）。
skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。

str or list[str]

解码后的词符。

使用词汇表和添加的词符，将单个索引或索引序列转换为一个词符或词符序列。

convert_tokens_to_ids

( tokens: typing.Union[str, collections.abc.Iterable[str]] ) → int 或 list[int]

参数

tokens (str 或 Iterable[str]) — 要转换为词元 ID 的一个或多个词元。

int or list[int]

词符 ID 或词符 ID 列表。

使用词汇表将一个词元字符串（或词元序列）转换为单个整数 ID（或 ID 的可迭代对象）。

get_added_vocab

( ) → dict[str, int]

dict[str, int]

添加的词符。

以词元到索引的字典形式返回词汇表中已添加的词元。

num_special_tokens_to_add

( pair: bool = False ) → int

参数

pair (bool, 可选, 默认为 False) — 已添加词元的数量是应针对序列对还是单个序列进行计算。

int

添加到序列中的特殊词符数量。

在使用特殊词符编码序列时返回添加的词符数量。

此方法会对一个虚拟输入进行编码并检查添加的词符数量，因此效率不高。请勿将其放入您的训练循环中。

set_truncation_and_padding

( padding_strategy: PaddingStrategy truncation_strategy: TruncationStrategy max_length: int stride: int pad_to_multiple_of: typing.Optional[int] padding_side: typing.Optional[str] )

参数

padding_strategy (PaddingStrategy) — 将应用于输入的填充类型。
truncation_strategy (TruncationStrategy) — 将应用于输入的截断类型。
max_length (int) — 序列的最大长度。
stride (int) — 处理溢出时使用的步幅。
pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到所提供值的倍数。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上使用 Tensor Cores 特别有用。
padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 ['right', 'left'] 之间选择。默认值从同名的类属性中选取。

为快速分词器（由 HuggingFace tokenizers 库提供）定义截断和填充策略，并在之后恢复分词器设置。

在托管部分之前，提供的分词器没有填充/截断策略。如果您在之前为分词器设置了填充/截断策略，那么在退出托管部分时，它将被重置为无填充/截断。

train_new_from_iterator

( text_iterator vocab_size length = None new_special_tokens = None special_tokens_map = None **kwargs ) → PreTrainedTokenizerFast

参数

text_iterator (list[str] 的生成器) — 训练语料库。应为文本批次的生成器，例如，如果所有内容都在内存中，则为文本列表的列表。
vocab_size (int) — 您希望分词器的词汇表大小。
length (int, 可选) — 迭代器中序列的总数。这用于提供有意义的进度跟踪。
new_special_tokens (str 列表或 AddedToken, 可选) — 要添加到您正在训练的分词器中的新特殊词元列表。
special_tokens_map (dict[str, str], 可选) — 如果您想重命名此分词器使用的某些特殊词元，请在此参数中传递一个从旧特殊词元名称到新特殊词元名称的映射。
kwargs (dict[str, Any], 可选) — 传递给 🤗 Tokenizers 库中训练器的其他关键字参数。

PreTrainedTokenizerFast

一个与原始分词器类型相同的新分词器，在 text_iterator 上训练。

在新语料库上训练一个分词器，其默认设置（在特殊词元或分词流程方面）与当前分词器相同。

BatchEncoding

class transformers.BatchEncoding

( data: typing.Optional[dict[str, typing.Any]] = None encoding: typing.Union[tokenizers.Encoding, collections.abc.Sequence[tokenizers.Encoding], NoneType] = None tensor_type: typing.Union[NoneType, str, transformers.utils.generic.TensorType] = None prepend_batch_axis: bool = False n_sequences: typing.Optional[int] = None )

参数

data (dict, 可选) — 由 __call__/encode_plus/batch_encode_plus 方法返回的列表/数组/张量的字典（'input_ids'、'attention_mask' 等）。
encoding (tokenizers.Encoding 或 Sequence[tokenizers.Encoding], 可选) — 如果分词器是快速分词器，它会输出额外的信息，如从单词/字符空间到词元空间的映射，tokenizers.Encoding 实例或实例列表（用于批处理）持有这些信息。
tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处提供一个 tensor_type，以在初始化时将整数列表转换为 PyTorch/TensorFlow/Numpy 张量。
prepend_batch_axis (bool, 可选, 默认为 False) — 在转换为张量时是否添加批处理轴（请参阅上文的 tensor_type）。请注意，此参数仅在设置了 tensor_type 参数时才生效，否则无效。
n_sequences (Optional[int], 可选) — 你可以在此处指定一个 tensor_type，以便在初始化时将整数列表转换为 PyTorch/TensorFlow/Numpy 张量。

包含 call()、encode_plus() 和 batch_encode_plus() 方法的输出（tokens、attention_masks 等）。

这个类派生自 Python 字典，可以像字典一样使用。此外，该类还提供了一些实用方法，用于从单词/字符空间映射到词元（token）空间。

char_to_token

( batch_or_char_index: int char_index: typing.Optional[int] = None sequence_index: int = 0 ) → int

参数

batch_or_char_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中单词的索引。
char_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中单词的索引。
sequence_index (int, 可选, 默认为 0) — 如果批处理中编码了序列对，这可用于指定所提供的字符索引属于该对中的哪个序列（0 或 1）。

int

词元（token）的索引，如果字符索引指向一个仅包含空白字符的词元且空白字符被 `trim_offsets=True` 裁剪，则返回 None。

获取编码输出中包含原始字符串中某个字符的词元（token）的索引，该字符对应批处理中的一个序列。

可以这样调用

如果批处理大小为 1，则为 `self.char_to_token(char_index)`
如果批处理大小大于或等于 1，则为 `self.char_to_token(batch_index, char_index)`

此方法特别适用于当输入序列是预分词序列（即单词由用户定义）的情况。在这种情况下，它可以轻松地将编码后的词元与提供的分词后的单词关联起来。

char_to_word

( batch_or_char_index: int char_index: typing.Optional[int] = None sequence_index: int = 0 ) → int 或 list[int]

参数

batch_or_char_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是原始字符串中字符的索引。
char_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是原始字符串中字符的索引。
sequence_index (int, 可选, 默认为 0) — 如果批处理中编码了序列对，这可用于指定所提供的字符索引属于该对中的哪个序列（0 或 1）。

int or list[int]

相关编码词元（token）的索引或索引列表。

获取原始字符串中与批处理序列中某个字符对应的单词。

可以这样调用

如果批处理大小为 1，则为 `self.char_to_word(char_index)`
如果批处理大小大于 1，则为 `self.char_to_word(batch_index, char_index)`

convert_to_tensors

( tensor_type: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None prepend_batch_axis: bool = False )

参数

tensor_type (str 或 TensorType, 可选) — 要使用的张量类型。如果为 `str`，应为枚举 TensorType 的值之一。如果为 `None`，则不进行任何修改。
prepend_batch_axis (int, 可选, 默认为 False) — 在转换过程中是否添加批处理维度。

将内部内容转换为张量。

sequence_ids

( batch_index: int = 0 ) → list[Optional[int]]

参数

batch_index (int, 可选, 默认为 0) — 要在批处理中访问的索引。

list[Optional[int]]

一个指示每个词元（token）对应序列 ID 的列表。分词器添加的特殊词元映射为 `None`，其他词元映射为其对应序列的索引。

返回一个将词元映射到其原始句子 ID 的列表。

对于在序列周围或之间添加的特殊词元，返回 `None`
对于对应第一个序列中单词的词元，返回 `0`
当一对序列被联合编码时，对于对应第二个序列中单词的词元，返回 `1`

到

( device: typing.Union[str, ForwardRef('torch.device')] non_blocking: bool = False ) → BatchEncoding

参数

device (str 或 torch.device) — 要放置张量的设备。
non_blocking (bool) — 是否异步执行复制。

BatchEncoding

修改后的同一实例。

通过调用 `v.to(device, non_blocking=non_blocking)` 将所有值发送到设备（仅限 PyTorch）。

token_to_chars

( batch_or_token_index: int token_index: typing.Optional[int] = None ) → CharSpan

参数

batch_or_token_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中词元（token）的索引。
token_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中词元（token）或词元列表的索引。

CharSpan

原始字符串中的字符范围，如果词元（例如、）不对应原始字符串中的任何字符，则为 None。

获取批处理序列中与编码词元（token）相对应的字符范围。

字符范围以 CharSpan 的形式返回，包含

start — 与词元（token）关联的原始字符串中第一个字符的索引。
end — 与词元（token）关联的原始字符串中最后一个字符之后的字符索引。

可以这样调用

如果批处理大小为 1，则为 `self.token_to_chars(token_index)`
如果批处理大小大于或等于 1，则为 `self.token_to_chars(batch_index, token_index)`

token_to_sequence

( batch_or_token_index: int token_index: typing.Optional[int] = None ) → int

参数

batch_or_token_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中词元（token）的索引。
token_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中词元（token）的索引。

int

输入序列中单词的索引。

获取由给定词元（token）表示的序列的索引。在一般情况下，对于单个序列或序列对的第一个序列，此方法返回 `0`；对于序列对的第二个序列，返回 `1`。

可以这样调用

如果批处理大小为 1，则为 `self.token_to_sequence(token_index)`
如果批处理大小大于 1，则为 `self.token_to_sequence(batch_index, token_index)`

此方法特别适用于当输入序列是预分词序列（即，单词由用户定义）的情况。在这种情况下，它可以轻松地将编码后的词元与提供的分词后的单词关联起来。

token_to_word

( batch_or_token_index: int token_index: typing.Optional[int] = None ) → int

参数

batch_or_token_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中词元（token）的索引。
token_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中词元（token）的索引。

int

输入序列中单词的索引。

获取批处理序列中与编码词元（token）对应的单词（即包含该词元）的索引。

可以这样调用

如果批处理大小为 1，则为 `self.token_to_word(token_index)`
如果批处理大小大于 1，则为 `self.token_to_word(batch_index, token_index)`

tokens

( batch_index: int = 0 ) → list[str]

参数

batch_index (int, 可选, 默认为 0) — 要在批处理中访问的索引。

list[str]

该索引处的词元（token）列表。

返回给定批处理索引处的词元（token）列表（输入字符串在经过词/子词切分后、转换为整数索引前的子部分）（仅适用于快速分词器的输出）。

word_ids

( batch_index: int = 0 ) → list[Optional[int]]

参数

batch_index (int, 可选, 默认为 0) — 要在批处理中访问的索引。

list[Optional[int]]

一个指示每个词元（token）对应单词的列表。分词器添加的特殊词元映射为 `None`，其他词元映射为其对应单词的索引（如果它们是该单词的一部分，则多个词元将映射到同一个单词索引）。

对于快速分词器，返回一个将词元映射到其在初始句子中实际单词的列表。

word_to_chars

( batch_or_word_index: int word_index: typing.Optional[int] = None sequence_index: int = 0 ) → CharSpan 或 list[CharSpan]

参数

batch_or_word_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中单词的索引。
word_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中单词的索引。
sequence_index (int, 可选, 默认为 0) — 如果批处理中编码了序列对，这可用于指定所提供的单词索引属于该对中的哪个序列（0 或 1）。

CharSpan 或 list[CharSpan]

字符串中相关字符或字符集的范围。CharSpan 是 NamedTuple，包含：

start: 原始字符串中与词元（token）关联的第一个字符的索引
end: 原始字符串中与词元（token）关联的最后一个字符之后的字符索引

获取批处理序列中给定单词在原始字符串中对应的字符范围。

字符范围以 CharSpan NamedTuple 的形式返回，包含：

start: 原始字符串中第一个字符的索引
end: 原始字符串中最后一个字符之后的字符索引

可以这样调用

如果批处理大小为 1，则为 `self.word_to_chars(word_index)`
如果批处理大小大于或等于 1，则为 `self.word_to_chars(batch_index, word_index)`

word_to_tokens

( batch_or_word_index: int word_index: typing.Optional[int] = None sequence_index: int = 0 ) → (TokenSpan, 可选)

参数

batch_or_word_index (int) — 批处理中序列的索引。如果批处理仅包含一个序列，则这可以是序列中单词的索引。
word_index (int, 可选) — 如果在 *batch_or_token_index* 中提供了批处理索引，则这可以是序列中单词的索引。
sequence_index (int, 可选, 默认为 0) — 如果批处理中编码了序列对，这可用于指定所提供的单词索引属于该对中的哪个序列（0 或 1）。

(TokenSpan, 可选)

编码序列中的词元（token）范围。如果没有词元对应于该单词，则返回 `None`。这种情况尤其可能发生在当词元是用于格式化分词的特殊词元时。例如，当我们在分词的最开始添加一个类别词元时。

获取批处理序列中与一个单词相对应的编码词元（token）范围。

词元（token）范围以 TokenSpan 的形式返回，包含

start — 第一个词元（token）的索引。
end — 最后一个词元（token）之后的词元索引。

可以这样调用

如果批处理大小为 1，则为 `self.word_to_tokens(word_index, sequence_index: int = 0)`
如果批处理大小大于或等于 1，则为 `self.word_to_tokens(batch_index, word_index, sequence_index: int = 0)`

words