Transformers 文档
分词器
并获得增强的文档体验
开始使用
分词器
分词器负责为模型准备输入。该库包含所有模型的分词器。大多数分词器都有两种风格：完整的 Python 实现和基于 Rust 库 🤗 Tokenizers 的“快速”实现。“快速”实现允许
- 显著加速，尤其是在进行批量分词时，以及
- 其他方法来映射原始字符串（字符和单词）和 token 空间（例如，获取包含给定字符的 token 的索引或与给定 token 相对应的字符跨度）。
基类 PreTrainedTokenizer 和 PreTrainedTokenizerFast 实现了用于在模型输入中编码字符串输入的常用方法（见下文）以及从本地文件或目录或从库提供的预训练分词器（从 HuggingFace 的 AWS S3 仓库下载）实例化/保存 Python 和“快速”分词器的方法。它们都依赖于包含常用方法的 PreTrainedTokenizerBase 和 SpecialTokensMixin。
PreTrainedTokenizer 和 PreTrainedTokenizerFast 因此实现了使用所有分词器的主要方法
- 分词（将字符串拆分为子词 token 字符串）、将 token 字符串转换为 ID 并反向转换，以及编码/解码（即，分词并转换为整数）。
- 以独立于底层结构（BPE、SentencePiece…）的方式向词汇表添加新 token。
- 管理特殊 token（如 mask、句首等）：添加它们，在分词器中将它们分配给属性以便于访问，并确保它们在分词期间不会被拆分。
BatchEncoding 保存 PreTrainedTokenizerBase 的编码方法（__call__、encode_plus 和 batch_encode_plus）的输出，并且派生自 Python 字典。当分词器是纯 Python 分词器时，此类行为类似于标准 Python 字典，并保存这些方法计算的各种模型输入（input_ids、attention_mask…）。当分词器是“快速”分词器（即，由 HuggingFace tokenizers 库支持）时，此类还提供了几个高级对齐方法，这些方法可用于映射原始字符串（字符和单词）和 token 空间（例如，获取包含给定字符的 token 的索引或与给定 token 相对应的字符跨度）。
多模态分词器
除此之外，每个分词器都可以是“多模态”分词器，这意味着分词器将保存所有相关的特殊 token 作为分词器属性的一部分，以便于访问。例如，如果分词器是从像 LLaVA 这样的视觉-语言模型加载的，您将能够访问 tokenizer.image_token_id 以获取用作占位符的特殊图像 token。
要为任何类型的分词器启用额外的特殊 token，您必须添加以下行并保存分词器。额外的特殊 token 不必与模态相关，可以是模型经常需要访问的任何内容。在下面的代码中，output_dir 中的分词器将可以直接访问另外三个特殊 token。
vision_tokenizer = AutoTokenizer.from_pretrained(
"llava-hf/llava-1.5-7b-hf",
extra_special_tokens={"image_token": "<image>", "boi_token": "<image_start>", "eoi_token": "<image_end>"}
)
print(vision_tokenizer.image_token, vision_tokenizer.image_token_id)
("<image>", 32000)PreTrainedTokenizer
class transformers.PreTrainedTokenizer
< 源代码 >( **kwargs )
参数
- model_max_length (
int, 可选) — Transformer 模型输入的最大长度（token 数量）。当使用 from_pretrained() 加载分词器时，这将设置为与模型关联的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, 可选) — 表示句子开头的特殊 token。将与self.bos_token和self.bos_token_id关联。 - eos_token (
str或tokenizers.AddedToken, 可选) — 表示句子结尾的特殊 token。将与self.eos_token和self.eos_token_id关联。 - unk_token (
str或tokenizers.AddedToken, 可选) — 表示词汇表外 token 的特殊 token。将与self.unk_token和self.unk_token_id关联。 - sep_token (
str或tokenizers.AddedToken, 可选) — 分隔同一输入中两个不同句子的特殊 token（例如，BERT 使用）。将与self.sep_token和self.sep_token_id关联。 - pad_token (
str或tokenizers.AddedToken, 可选) — 用于使 token 数组大小相同以进行批处理的特殊 token。然后将被注意力机制或损失计算忽略。将与self.pad_token和self.pad_token_id关联。 - cls_token (
str或tokenizers.AddedToken, 可选) — 表示输入类别的特殊 token（例如，BERT 使用）。将与self.cls_token和self.cls_token_id关联。 - mask_token (
str或tokenizers.AddedToken, 可选) — 表示 masked token 的特殊 token（由 masked-language modeling 预训练目标使用，例如 BERT）。将与self.mask_token和self.mask_token_id关联。 - additional_special_tokens (tuple 或 list of
str或tokenizers.AddedToken, 可选) — 附加特殊 token 的元组或列表。在此处添加它们以确保在使用skip_special_tokens设置为 True 的情况下解码时跳过它们。如果它们不是词汇表的一部分，则将它们添加到词汇表的末尾。 - clean_up_tokenization_spaces (
bool, 可选, 默认为True) — 模型是否应清理在 token 化过程中拆分输入文本时添加的空格。 - split_special_tokens (
bool, 可选, 默认为False) — 特殊 token 是否应在 token 化过程中拆分。传递将影响分词器的内部状态。默认行为是不拆分特殊 token。这意味着如果<s>是bos_token，则tokenizer.tokenize("<s>") = ['<s>]。否则，如果split_special_tokens=True，则tokenizer.tokenize("<s>")将给出['<','s', '>']。
所有慢速分词器的基类。
处理 token 化和特殊 token 的所有共享方法，以及下载/缓存/加载预训练分词器以及向词汇表添加 token 的方法。
此类还在所有分词器的基础上以统一的方式包含添加的 token，因此我们不必处理各种底层字典结构（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__
< source >( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.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] = 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]], 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 toTrue) — 是否在编码序列时添加特殊 token。 这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些 token 会自动添加到输入 id 中。 如果你想自动添加bos或eostoken，这将非常有用。 - padding (
bool,str或 PaddingStrategy, optional, defaults toFalse) — 激活并控制填充。接受以下值：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。'max_length'：填充到由参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, optional, defaults toFalse) — 激活并控制截断。接受以下值：True或'longest_first'：截断为由参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），这将逐个 token 地截断，从该对中最长的序列中删除一个 token。'only_first'：截断为由参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），这将仅截断该对中的第一个序列。'only_second'：截断为由参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），这将仅截断该对中的第二个序列。False或'do_not_truncate'（默认值）：不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
- max_length (
int, optional) — 控制由截断/填充参数之一使用的最大长度。如果未设置或设置为
None，如果截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。 如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度的功能。 - stride (
int, optional, defaults to 0) — 如果与max_length一起设置为一个数字，当return_overflowing_tokens=True时返回的溢出 token 序列将包含来自截断序列末尾的一些 token，以便在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool, optional, defaults toFalse) — 输入是否已预分词（例如，拆分为单词）。 如果设置为True，则分词器假定输入已拆分为单词（例如，通过在空格上拆分），它将对这些单词进行分词。 这对于 NER 或 token 分类非常有用。 - pad_to_multiple_of (
int, optional) — 如果设置，将序列填充到提供的值的倍数。 需要激活padding。 这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。 - padding_side (
str, optional) — 模型应在其上应用填充的侧面。 应从 [‘right’, ‘left’] 中选择。 默认值从同名的类属性中选取。 - return_tensors (
str或 TensorType, optional) — 如果设置，将返回 tensor 而不是 python 整数列表。 可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, optional) — 是否返回 token 类型 ID。 如果保留为默认值，将根据特定分词器的默认值返回 token 类型 ID，该默认值由return_outputs属性定义。 - return_attention_mask (
bool, optional) — 是否返回 attention mask。 如果保留为默认值，将根据特定分词器的默认值返回 attention mask，该默认值由return_outputs属性定义。 - return_overflowing_tokens (
bool, optional, defaults toFalse) — 是否返回溢出的 token 序列。 如果提供了一对输入 id 序列（或一批对）并且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool, optional, defaults toFalse) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, optional, defaults toFalse) — 是否为每个 token 返回(char_start, char_end)。这仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用，如果使用 Python 的分词器，此方法将引发
NotImplementedError。 - return_length (
bool, optional, defaults toFalse) — 是否返回编码输入的长度。 - verbose (
bool, optional, defaults toTrue) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
Returns
A BatchEncoding，包含以下字段
-
input_ids — 输入模型的 token id 列表。
-
token_type_ids — 输入模型的 token type id 列表 (当
return_token_type_ids=True或如果 “token_type_ids” 在self.model_input_names中时)。 -
attention_mask — 指定模型应关注哪些 token 的索引列表 (当
return_attention_mask=True或如果 “attention_mask” 在self.model_input_names中时)。 -
overflowing_tokens — 溢出的 token 序列列表 (当指定了
max_length且return_overflowing_tokens=True时)。 -
num_truncated_tokens — 截断的 token 数量 (当指定了
max_length且return_overflowing_tokens=True时)。 -
special_tokens_mask — 0 和 1 的列表，其中 1 指定添加的特殊 token，0 指定常规序列 token (当
add_special_tokens=True且return_special_tokens_mask=True时)。 -
length — 输入的长度 (当
return_length=True时)
用于为一个或多个序列或一对或多对序列进行 tokenization 和模型准备的主要方法。
add_tokens
< source >( new_tokens: typing.Union[str, tokenizers.AddedToken, typing.List[typing.Union[str, tokenizers.AddedToken]]] special_tokens: bool = False ) → int
参数
- new_tokens (
str,tokenizers.AddedToken或 str 或tokenizers.AddedToken列表) — 仅当新 token 不在词汇表中时才添加。tokenizers.AddedToken包装一个字符串 token，以便您可以个性化其行为：此 token 是否应仅与单个单词匹配，此 token 是否应去除左侧所有潜在的空格，此 token 是否应去除右侧所有潜在的空格等。 - special_tokens (
bool, optional, defaults toFalse) — 可用于指定 token 是否为特殊 token。这主要改变了归一化行为（例如，特殊 token 如 CLS 或 [MASK] 通常不会小写）。有关
tokenizers.AddedToken的详细信息，请参阅 HuggingFace tokenizers 库。
Returns
int
添加到词汇表的 token 数量。
将新 token 列表添加到 tokenizer 类。如果新 token 不在词汇表中，则会将它们添加到词汇表中，索引从当前词汇表的长度开始，并在应用 tokenization 算法之前隔离。因此，添加的 token 和来自 tokenization 算法词汇表的 token 不以相同的方式处理。
请注意，当向词汇表添加新 token 时，您应该确保同时调整模型的 token embedding 矩阵的大小，以便其 embedding 矩阵与 tokenizer 匹配。
为了做到这一点，请使用 resize_token_embeddings() 方法。
Examples
# 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
< source >( special_tokens_dict: typing.Dict[str, typing.Union[str, tokenizers.AddedToken]] replace_additional_special_tokens = True ) → int
参数
- special_tokens_dict (dictionary str to str 或
tokenizers.AddedToken) — 键应在预定义的特殊属性列表中：[bos_token,eos_token,unk_token,sep_token,pad_token,cls_token,mask_token,additional_special_tokens]。仅当 token 尚未在词汇表中时才添加（通过检查 tokenizer 是否为其分配了
unk_token的索引来测试）。 - replace_additional_special_tokens (
bool, optional,, defaults toTrue) — 如果为True，则现有的附加特殊 token 列表将被special_tokens_dict中提供的列表替换。否则，self._special_tokens_map["additional_special_tokens"]只是被扩展。在前一种情况下，token 不会从 tokenizer 的完整词汇表中删除 - 它们仅被标记为非特殊 token。请记住，这仅影响在解码期间跳过哪些 token，而不影响added_tokens_encoder和added_tokens_decoder。这意味着之前的additional_special_tokens仍然是添加的 token，并且不会被模型拆分。
Returns
int
添加到词汇表的 token 数量。
将特殊 token（eos、pad、cls 等）的字典添加到 encoder 并将它们链接到类属性。如果特殊 token 不在词汇表中，则会将它们添加到词汇表中（索引从当前词汇表的最后一个索引开始）。
当向词汇表添加新 token 时，您应该确保同时调整模型的 token embedding 矩阵的大小，以便其 embedding 矩阵与 tokenizer 匹配。
为了做到这一点，请使用 resize_token_embeddings() 方法。
使用 add_special_tokens 将确保您的特殊 token 可以通过多种方式使用
- 使用
skip_special_tokens = True解码时可以跳过特殊 token。 - 特殊 token 由 tokenizer 仔细处理（它们永远不会被拆分），类似于
AddedTokens。 - 您可以使用 tokenizer 类属性（如
tokenizer.cls_token）轻松引用特殊 token。这使得开发模型无关的训练和微调脚本变得容易。
如果可能，特殊 token 已经为提供的预训练模型注册（例如 BertTokenizer 的 cls_token 已经注册为 :obj'[CLS]'，而 XLM 的也注册为 '</s>'）。
Examples
# 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
< source >( conversation: typing.Union[typing.List[typing.Dict[str, str]], typing.List[typing.List[typing.Dict[str, str]]]] tools: typing.Optional[typing.List[typing.Union[typing.Dict, typing.Callable]]] = None documents: typing.Optional[typing.List[typing.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[typing.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[Dict], optional) — 模型可以访问的工具（可调用函数）列表。如果模板不支持函数调用，则此参数无效。每个工具都应作为 JSON Schema 传递，给出工具的名称、描述和参数类型。有关更多信息，请参阅我们的 聊天模板指南。 - documents (
List[Dict[str, str]], optional) — 表示文档的字典列表，如果模型正在执行 RAG（检索增强生成），则模型可以访问这些文档。如果模板不支持 RAG，则此参数无效。我们建议每个文档都应该是一个包含 “title” 和 “text” 键的字典。请参阅 聊天模板指南 的 RAG 部分，了解有关使用聊天模板传递文档的示例。 - chat_template (
str, optional) — 用于此转换的 Jinja 模板。通常没有必要为此参数传递任何内容，因为默认情况下将使用模型的模板。 - add_generation_prompt (bool, optional) — 如果设置此项，则会将带有指示助手消息开始的 token 的提示附加到格式化输出。当您想从模型生成响应时，这很有用。请注意，此参数将传递到聊天模板，因此模板中必须支持此参数才能生效。
- continue_final_message (bool, optional) — 如果设置此项，则将格式化聊天，以便聊天中的最后一条消息是开放式的，没有任何 EOS token。模型将继续此消息，而不是开始新消息。这允许您为其“预填充”模型响应的一部分。不能与
add_generation_prompt同时使用。 - tokenize (
bool, defaults toTrue) — 是否对输出进行 tokenization。如果为False，则输出将是一个字符串。 - padding (
bool,str或 PaddingStrategy, optional, defaults toFalse) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引）：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。'max_length'：填充到max_length参数指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool, defaults toFalse) — 是否在最大长度处截断序列。如果 tokenize 为False，则无效。 - max_length (
int, optional) — 用于填充或截断的最大长度（以 token 为单位）。如果 tokenize 为False，则无效。如果未指定，则 tokenizer 的max_length属性将用作默认值。 - return_tensors (
str或 TensorType, optional) — 如果设置，将返回特定框架的 tensors。如果 tokenize 为False，则无效。可接受的值为：'tf'：返回 TensorFlowtf.Tensor对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。'jax'：返回 JAXjnp.ndarray对象。
- return_dict (
bool, 默认为False) — 是否返回包含命名输出的字典。如果tokenize为False，则无效。 - tokenizer_kwargs (
Dict[str -- Any], 可选): 传递给 tokenizer 的额外 kwargs。 - return_assistant_tokens_mask (
bool, 默认为False) — 是否返回助手生成 token 的掩码。对于助手生成的 token，掩码将包含 1。对于用户和系统 token，掩码将包含 0。此功能仅适用于通过{% generation %}关键字支持它的聊天模板。 - **kwargs — 传递给模板渲染器的额外 kwargs。聊天模板可以访问这些 kwargs。
Returns
Union[List[int], Dict]
表示目前为止已分词的聊天的 token id 列表，包括控制 token。此输出已准备好传递给模型，可以直接传递，也可以通过诸如 generate() 之类的方法传递。如果设置了 return_dict，则将改为返回 tokenizer 输出的字典。
将带有 "role" 和 "content" 键的字典列表转换为 token id 列表。此方法旨在与聊天模型一起使用，并将读取 tokenizer 的 chat_template 属性以确定转换时要使用的格式和控制 token。
batch_decode
< source >( sequences: typing.Union[typing.List[int], typing.List[typing.List[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: 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) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。如果为None，将默认为self.clean_up_tokenization_spaces。 - kwargs (额外关键字参数, 可选) — 将传递给底层模型特定的解码方法。
Returns
List[str]
解码后的句子列表。
通过调用 decode 将 token id 列表转换为字符串列表。
decode
< source >( token_ids: typing.Union[int, typing.List[int], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → str
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 id 列表。可以使用__call__方法获得。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。如果为None，将默认为self.clean_up_tokenization_spaces。 - kwargs (额外关键字参数, 可选) — 将传递给底层模型特定的解码方法。
Returns
str
解码后的句子。
使用 tokenizer 和词汇表将 id 序列转换为字符串，可以选择移除特殊 token 并清理分词空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
encode
< source >( text: typing.Union[str, typing.List[str], typing.List[int]] text_pair: typing.Union[str, typing.List[str], typing.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] = 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 or 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) — 是否在编码序列时添加特殊 token。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些 token 会自动添加到输入 id 中。如果您想自动添加bos或eostoken，这将非常有用。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 激活并控制填充。接受以下值： - truncation (
bool,str或 TruncationStrategy, 可选, 默认为False) — 激活并控制截断。接受以下值： - max_length (
int, 可选) — 控制截断/填充参数之一使用的最大长度。 - stride (
int, 可选, 默认为 0) — 如果与max_length一起设置为数字，则当return_overflowing_tokens=True时返回的溢出 token 将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool, 可选, 默认为False) — 输入是否已预分词（例如，拆分为单词）。如果设置为True，tokenizer 假定输入已拆分为单词（例如，通过在空格上拆分），它将对其进行分词。这对于 NER 或 token 分类很有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充到提供的值的倍数。需要激活padding。这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。 - padding_side (
str, optional) — 模型应该在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。 - return_tensors (
stror TensorType, optional) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- **kwargs — 传递给
.tokenize()方法。
Returns
List[int], torch.Tensor, tf.Tensor or np.ndarray
文本的 token 化 id。
使用 tokenizer 和词汇表将字符串转换为 id 序列（整数）。
与执行 self.convert_tokens_to_ids(self.tokenize(text)) 相同。
push_to_hub
< source >( 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[int, str, NoneType] = '5GB' create_pr: bool = False safe_serialization: bool = True revision: str = None commit_description: str = None tags: typing.Optional[typing.List[str]] = None **deprecated_kwargs )
参数
- repo_id (
str) — 您想要将 tokenizer 推送到的仓库的名称。当推送到给定的组织时，它应该包含您的组织名称。 - use_temp_dir (
bool, optional) — 是否使用临时目录来存储在推送到 Hub 之前保存的文件。如果没有名为repo_id的目录，则默认为True，否则为False。 - commit_message (
str, optional) — 推送时提交的消息。将默认为"Upload tokenizer"。 - private (
bool, optional) — 是否使仓库私有。如果为None(默认值)，则仓库将是公开的，除非组织的默认设置为私有。如果仓库已存在，则此值将被忽略。 - token (
boolorstr, optional) — 用作远程文件的 HTTP Bearer 授权的令牌。如果为True，将使用运行huggingface-cli login时生成的令牌（存储在~/.huggingface中）。如果未指定repo_url，则默认为True。 - max_shard_size (
intorstr, optional, defaults to"5GB") — 仅适用于模型。分片之前的检查点的最大大小。然后检查点分片的大小将小于此大小。如果表示为字符串，则需要是数字后跟单位（如"5MB"）。我们默认设置为"5GB"，以便用户可以在免费层 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。 - create_pr (
bool, optional, defaults toFalse) — 是否创建包含上传文件的 PR 或直接提交。 - safe_serialization (
bool, optional, defaults toTrue) — 是否将模型权重转换为 safetensors 格式以实现更安全的序列化。 - revision (
str, optional) — 将上传的文件推送到的分支。 - commit_description (
str, optional) — 将要创建的提交的描述 - tags (
List[str], optional) — 要推送到 Hub 上的标签列表。
将 tokenizer 文件上传到 🤗 Model Hub。
Examples
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
< source >( ids: typing.Union[int, list[int]] skip_special_tokens: bool = False ) → str or List[str]
使用词汇表和添加的 token，将单个索引或索引序列转换为 token 或 token 序列。
convert_tokens_to_ids
< source >( tokens: typing.Union[str, list[str]] ) → int or List[int]
使用词汇表，将 token 字符串（或 token 序列）转换为单个整数 id（或 id 序列）。
以 token 到索引的字典形式返回词汇表中添加的 token。结果可能与快速调用不同，因为目前我们总是添加 token，即使它们已经在词汇表中。这是我们应该改变的事情。
num_special_tokens_to_add
< source >( pair: bool = False ) → int
返回使用特殊 token 编码序列时添加的 token 数量。
这会编码一个虚拟输入并检查添加的 token 数量，因此效率不高。不要将其放在您的训练循环中。
prepare_for_tokenization
< source >( text: str is_split_into_words: bool = False **kwargs ) → Tuple[str, Dict[str, Any]]
在分词之前执行任何必要的转换。
此方法应从 kwargs 中弹出参数，并返回剩余的 kwargs。我们在编码过程的最后测试 kwargs，以确保所有参数都已使用。
tokenize
< source >( text: str **kwargs ) → List[str]
使用 tokenizer 将字符串转换为 token 序列。
为基于单词的词汇表拆分为单词，或为基于子词的词汇表（BPE/SentencePieces/WordPieces）拆分为子词。处理添加的 token。
PreTrainedTokenizerFast
PreTrainedTokenizerFast 依赖于 tokenizers 库。从 🤗 tokenizers 库获得的 tokenizers 可以非常简单地加载到 🤗 transformers 中。请查看 使用来自 🤗 tokenizers 的 tokenizers 页面，以了解这是如何完成的。
class transformers.PreTrainedTokenizerFast
< source >( *args **kwargs )
参数
- model_max_length (
int, optional) — transformer 模型输入的最大长度（以 token 数计）。当使用 from_pretrained() 加载 tokenizer 时，这将设置为为关联模型存储在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或tokenizers.AddedToken, optional) — 表示句子开头的特殊 token。将与self.bos_token和self.bos_token_id关联。 - eos_token (
str或tokenizers.AddedToken, optional) — 表示句子结尾的特殊 token。将与self.eos_token和self.eos_token_id关联。 - unk_token (
str或tokenizers.AddedToken, optional) — 表示词汇表外 token 的特殊 token。将与self.unk_token和self.unk_token_id关联。 - sep_token (
str或tokenizers.AddedToken, optional) — 在同一输入中分隔两个不同句子的特殊 token（例如 BERT 使用）。将与self.sep_token和self.sep_token_id关联。 - pad_token (
str或tokenizers.AddedToken, optional) — 用于使 token 数组大小相同以便进行批处理的特殊 token。然后将被注意力机制或损失计算忽略。将与self.pad_token和self.pad_token_id关联。 - cls_token (
str或tokenizers.AddedToken, optional) — 表示输入类别的特殊 token（例如 BERT 使用）。将与self.cls_token和self.cls_token_id关联。 - mask_token (
str或tokenizers.AddedToken, optional) — 表示 masked token 的特殊 token（由 masked-language modeling 预训练目标使用，如 BERT）。将与self.mask_token和self.mask_token_id关联。 - additional_special_tokens (tuple 或 list of
str或tokenizers.AddedToken, optional) — 附加特殊 token 的元组或列表。在此处添加它们以确保在使用skip_special_tokens设置为 True 进行解码时跳过它们。如果它们不是词汇表的一部分，则将它们添加到词汇表的末尾。 - clean_up_tokenization_spaces (
bool, optional, defaults toTrue) — 模型是否应清理在分词过程中拆分输入文本时添加的空格。 - split_special_tokens (
bool, optional, defaults toFalse) — 特殊 token 是否应在分词过程中拆分。传递将影响 tokenizer 的内部状态。默认行为是不拆分特殊 token。这意味着如果<s>是bos_token，则tokenizer.tokenize("<s>") = ['<s>]。否则，如果split_special_tokens=True，则tokenizer.tokenize("<s>")将给出['<','s', '>']。 - tokenizer_object (
tokenizers.Tokenizer) — 来自 🤗 tokenizers 的tokenizers.Tokenizer对象，用于实例化。有关更多信息，请参阅 使用来自 🤗 tokenizers 的 tokenizers。 - tokenizer_file (
str) — 本地 JSON 文件的路径，该文件表示先前从 🤗 tokenizers 序列化的tokenizers.Tokenizer对象。
所有快速 tokenizer 的基类（包装 HuggingFace tokenizers 库）。
处理所有用于分词和特殊 token 的共享方法，以及用于下载/缓存/加载预训练分词器的方法，以及向词汇表添加 token 的方法。
此类还在所有分词器之上以统一的方式包含添加的 token，这样我们就不必处理各种底层字典结构（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__
< source >( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.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] = 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) — 是否在编码序列时添加特殊 token。 这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些 token 会自动添加到输入 ID 中。 如果您想自动添加bos或eostoken，这将非常有用。 - 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指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批序列对），这将逐个 token 截断，从较长序列中删除 token。'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时返回的溢出 token 序列将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool, 可选, 默认为False) — 输入是否已预先分词（例如，拆分为单词）。 如果设置为True，则分词器假定输入已拆分为单词（例如，通过在空格上拆分），它将对其进行分词。 这对于 NER 或 token 分类很有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充到提供的值的倍数。 需要激活padding。 这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。 - padding_side (
str, 可选) — 模型应在其上应用填充的一侧。 应从 [‘right’, ‘left’] 中选择。 默认值从同名类属性中选取。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensor 而不是 python 整数列表。 可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token 类型 ID。 如果保留为默认值，将根据特定分词器的默认值返回 token 类型 ID，由return_outputs属性定义。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。 如果保留为默认值，将根据特定分词器的默认值返回 attention mask，由return_outputs属性定义。 - return_overflowing_tokens (
bool, 可选, 默认为False) — 是否返回溢出的 token 序列。 如果提供了一对输入 ID 序列（或一批序列对），且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool, 可选, 默认为False) — 是否返回特殊 token mask 信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回每个 token 的(char_start, char_end)。这仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用，如果使用 Python 的分词器，此方法将引发
NotImplementedError。 - return_length (
bool, 可选, 默认为False) — 是否返回编码输入的长度。 - verbose (
bool, 可选, 默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
Returns
A BatchEncoding，包含以下字段
-
input_ids — 输入模型的 token id 列表。
-
token_type_ids — 输入模型的 token type id 列表 (当
return_token_type_ids=True或如果 “token_type_ids” 在self.model_input_names中时)。 -
attention_mask — 指定模型应关注哪些 token 的索引列表 (当
return_attention_mask=True或如果 “attention_mask” 在self.model_input_names中时)。 -
overflowing_tokens — 溢出的 token 序列列表 (当指定了
max_length且return_overflowing_tokens=True时)。 -
num_truncated_tokens — 截断的 token 数量 (当指定了
max_length且return_overflowing_tokens=True时)。 -
special_tokens_mask — 0 和 1 的列表，其中 1 指定添加的特殊 token，0 指定常规序列 token (当
add_special_tokens=True且return_special_tokens_mask=True时)。 -
length — 输入的长度 (当
return_length=True时)
用于为一个或多个序列或一对或多对序列进行 tokenization 和模型准备的主要方法。
add_tokens
< source >( new_tokens: typing.Union[str, tokenizers.AddedToken, typing.List[typing.Union[str, tokenizers.AddedToken]]] special_tokens: bool = False ) → int
参数
- new_tokens (
str,tokenizers.AddedToken或 str 或tokenizers.AddedToken列表) — 仅当 token 尚未在词汇表中时才添加 token。tokenizers.AddedToken包装一个字符串 token，让您可以个性化其行为：此 token 是否应仅与单个单词匹配，此 token 是否应去除左侧所有潜在的空格，此 token 是否应去除右侧所有潜在的空格等等。 - special_tokens (
bool, 可选, 默认为False) — 可用于指定 token 是否为特殊 token。这主要改变了归一化行为（例如，像 CLS 或 [MASK] 这样的特殊 token 通常不会被转换为小写）。有关
tokenizers.AddedToken的详细信息，请参阅 HuggingFace tokenizers 库。
Returns
int
添加到词汇表的 token 数量。
将新 token 列表添加到 tokenizer 类。如果新 token 不在词汇表中，则会将它们添加到词汇表中，索引从当前词汇表的长度开始，并在应用 tokenization 算法之前隔离。因此，添加的 token 和来自 tokenization 算法词汇表的 token 不以相同的方式处理。
请注意，当向词汇表添加新 token 时，您应该确保同时调整模型的 token embedding 矩阵的大小，以便其 embedding 矩阵与 tokenizer 匹配。
为了做到这一点，请使用 resize_token_embeddings() 方法。
Examples
# 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
< source >( special_tokens_dict: typing.Dict[str, typing.Union[str, tokenizers.AddedToken]] replace_additional_special_tokens = True ) → int
参数
- special_tokens_dict (字典 str 到 str 或
tokenizers.AddedToken) — 键应在预定义的特殊属性列表中：[bos_token,eos_token,unk_token,sep_token,pad_token,cls_token,mask_token,additional_special_tokens]。仅当 token 尚未在词汇表中时才添加（通过检查 tokenizer 是否为它们分配了
unk_token的索引来测试）。 - replace_additional_special_tokens (
bool, 可选, 默认为True) — 如果为True，则现有的附加特殊 token 列表将被special_tokens_dict中提供的列表替换。否则，self._special_tokens_map["additional_special_tokens"]仅被扩展。在前一种情况下，token 将不会从 tokenizer 的完整词汇表中删除 - 它们仅被标记为非特殊 token。请记住，这仅影响在解码期间跳过哪些 token，而不是added_tokens_encoder和added_tokens_decoder。这意味着之前的additional_special_tokens仍然是添加的 token，并且不会被模型拆分。
Returns
int
添加到词汇表的 token 数量。
将特殊 token（eos、pad、cls 等）的字典添加到 encoder 并将它们链接到类属性。如果特殊 token 不在词汇表中，则会将它们添加到词汇表中（索引从当前词汇表的最后一个索引开始）。
当向词汇表添加新 token 时，您应该确保同时调整模型的 token embedding 矩阵的大小，以便其 embedding 矩阵与 tokenizer 匹配。
为了做到这一点，请使用 resize_token_embeddings() 方法。
使用 add_special_tokens 将确保您的特殊 token 可以通过多种方式使用
- 使用
skip_special_tokens = True解码时可以跳过特殊 token。 - 特殊 token 由 tokenizer 仔细处理（它们永远不会被拆分），类似于
AddedTokens。 - 您可以使用 tokenizer 类属性（如
tokenizer.cls_token）轻松引用特殊 token。这使得开发模型无关的训练和微调脚本变得容易。
如果可能，特殊 token 已经为提供的预训练模型注册（例如 BertTokenizer 的 cls_token 已经注册为 :obj'[CLS]'，而 XLM 的也注册为 '</s>'）。
Examples
# 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
< source >( conversation: typing.Union[typing.List[typing.Dict[str, str]], typing.List[typing.List[typing.Dict[str, str]]]] tools: typing.Optional[typing.List[typing.Union[typing.Dict, typing.Callable]]] = None documents: typing.Optional[typing.List[typing.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[typing.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[Dict], 可选) — 工具（可调用函数）的列表，模型可以访问这些工具。如果模板不支持函数调用，则此参数无效。每个工具都应作为 JSON Schema 传递，其中包含工具的名称、描述和参数类型。 有关更多信息，请参阅我们的 聊天模板指南。 - documents (
List[Dict[str, str]], 可选) — 字典列表，表示当模型执行 RAG（检索增强生成）时可以访问的文档。如果模板不支持 RAG，则此参数无效。我们建议每个文档都应该是一个包含 “title” 和 “text” 键的字典。有关通过聊天模板传递文档的示例，请参阅 聊天模板指南 的 RAG 部分。 - chat_template (
str, 可选) — 用于此转换的 Jinja 模板。通常不需要向此参数传递任何内容，因为默认情况下将使用模型的模板。 - add_generation_prompt (bool, 可选) — 如果设置，则带有指示助手消息开始的 token 的提示将附加到格式化输出中。当您想从模型生成响应时，这非常有用。请注意，此参数将传递给聊天模板，因此模板中必须支持此参数才能生效。
- continue_final_message (bool, 可选) — 如果设置，则聊天将进行格式化，以便聊天中的最后一条消息是开放式的，没有任何 EOS token。模型将继续这条消息，而不是开始新消息。这允许您为其“预填充”模型响应的一部分。不能与
add_generation_prompt同时使用。 - tokenize (
bool, 默认为True) — 是否对输出进行 token 化。如果为False，则输出将为字符串。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引），选项包括：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。'max_length'：填充到由参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool, 默认为False) — 是否在最大长度处截断序列。如果 tokenize 为False，则无效。 - max_length (
int, 可选) — 用于填充或截断的最大长度（以 token 为单位）。如果 tokenize 为False，则无效。如果未指定，则 tokenizer 的max_length属性将用作默认值。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回特定框架的张量。如果 tokenize 为False，则无效。可接受的值为：'tf'：返回 TensorFlowtf.Tensor对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。'jax'：返回 JAXjnp.ndarray对象。
- return_dict (
bool, 默认为False) — 是否返回带有命名输出的字典。如果 tokenize 为False，则无效。 - tokenizer_kwargs (
Dict[str -- Any], 可选): 要传递给 tokenizer 的附加 kwargs。 - return_assistant_tokens_mask (
bool, 默认为False) — 是否返回助手生成的 token 的掩码。对于助手生成的 token，掩码将包含 1。对于用户和系统 token，掩码将包含 0。此功能仅适用于通过{% generation %}关键字支持它的聊天模板。 - **kwargs — 要传递给模板渲染器的附加 kwargs。聊天模板可以访问这些 kwargs。
Returns
Union[List[int], Dict]
表示目前为止已分词的聊天的 token id 列表，包括控制 token。此输出已准备好传递给模型，可以直接传递，也可以通过诸如 generate() 之类的方法传递。如果设置了 return_dict，则将改为返回 tokenizer 输出的字典。
将带有 "role" 和 "content" 键的字典列表转换为 token id 列表。此方法旨在与聊天模型一起使用，并将读取 tokenizer 的 chat_template 属性以确定转换时要使用的格式和控制 token。
batch_decode
< source >( sequences: typing.Union[typing.List[int], typing.List[typing.List[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]) — token 化输入 id 列表。可以使用__call__方法获取。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中删除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。
Returns
List[str]
解码后的句子列表。
通过调用 decode 将 token id 列表转换为字符串列表。
decode
< source >( token_ids: typing.Union[int, typing.List[int], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → str
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]) — token 化输入 id 列表。可以使用__call__方法获取。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中删除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。
Returns
str
解码后的句子。
使用 tokenizer 和词汇表将 id 序列转换为字符串，可以选择移除特殊 token 并清理分词空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
encode
< 源码 >( text: typing.Union[str, typing.List[str], typing.List[int]] text_pair: typing.Union[str, typing.List[str], typing.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] = 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 or 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) — 是否在编码序列时添加特殊 token。 这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些 token 会自动添加到输入 ID 中。 如果你想自动添加bos或eostoken，这将非常有用。 - 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指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），这将逐个 token 截断，从较长的序列中移除 token。'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时返回的溢出 token 将包含截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool, 可选, 默认为False) — 输入是否已预先分词（例如，拆分为单词）。 如果设置为True，则分词器假定输入已拆分为单词（例如，通过在空格上拆分），它将对其进行分词。 这对于 NER 或 token 分类很有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充为提供值的倍数。 需要激活padding。 这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。 - padding_side (
str, 可选) — 模型应在其上应用填充的一侧。 应在 [‘right’, ‘left’] 之间选择。 默认值从同名的类属性中选取。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensor 而不是 python 整数列表。 可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- **kwargs — 传递给
.tokenize()方法。
Returns
List[int], torch.Tensor, tf.Tensor or np.ndarray
文本的 token 化 id。
使用 tokenizer 和词汇表将字符串转换为 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[int, str, NoneType] = '5GB' create_pr: bool = False safe_serialization: bool = True revision: str = None commit_description: str = None tags: typing.Optional[typing.List[str]] = None **deprecated_kwargs )
参数
- repo_id (
str) — 您想要将分词器推送到仓库的名称。 当推送到给定的组织时，它应该包含您的组织名称。 - use_temp_dir (
bool, 可选) — 是否使用临时目录来存储在推送到 Hub 之前保存的文件。 如果没有像repo_id这样的目录，则默认为True，否则为False。 - commit_message (
str, 可选) — 推送时提交的消息。 默认为"Upload tokenizer"。 - private (
bool, 可选) — 是否使仓库私有。 如果为None(默认)，则仓库将是公共的，除非组织的默认设置为私有。 如果仓库已存在，则忽略此值。 - token (
bool或str, 可选) — 用作远程文件的 HTTP Bearer 授权的 token。 如果为True，将使用运行huggingface-cli login时生成的 token (存储在~/.huggingface中)。 如果未指定repo_url，则默认为True。 - max_shard_size (
int或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 的标签列表。
将 tokenizer 文件上传到 🤗 Model Hub。
Examples
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]
使用词汇表和添加的 token，将单个索引或索引序列转换为 token 或 token 序列。
convert_tokens_to_ids
< source >( tokens: typing.Union[str, collections.abc.Iterable[str]] ) → int 或 List[int]
使用词汇表将 token 字符串（或 token 序列）转换为单个整数 id（或 ids 的 Iterable）。
返回词汇表中添加的 tokens，以 token 到索引的字典形式返回。
num_special_tokens_to_add
< source >( pair: bool = False ) → int
返回使用特殊 token 编码序列时添加的 token 数量。
这会编码一个虚拟输入并检查添加的 token 数量，因此效率不高。不要将其放在您的训练循环中。
set_truncation_and_padding
< source >( 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
< source >( 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列表, 可选) — 要添加到您正在训练的分词器的新特殊 token 列表。 - special_tokens_map (
Dict[str, str], 可选) — 如果您想重命名此分词器使用的一些特殊 token，请在此参数中传递从旧特殊 token 名称到新特殊 token 名称的映射。 - kwargs (
Dict[str, Any], 可选) — 从 🤗 Tokenizers 库传递给训练器的其他关键字参数。
Returns
与原始分词器类型相同的新分词器，在 text_iterator 上训练。
使用与当前分词器相同的默认值（在特殊 token 或 tokenization pipeline 方面）在新语料库上训练分词器。
BatchEncoding
class transformers.BatchEncoding
< source >( data: typing.Optional[typing.Dict[str, typing.Any]] = None encoding: typing.Union[tokenizers.Encoding, typing.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], 可选) — 如果分词器是一个快速分词器，它可以输出额外的信息，例如从单词/字符空间到 token 空间的映射，则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
< source >( 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）。
Returns
int
token 的索引，如果字符索引指向仅为空格的 token，并且空格已使用 trim_offsets=True 修剪，则为 None。
获取批次序列的原始字符串中包含字符的编码输出中 token 的索引。
可以这样调用
- 如果批次大小为 1，则
self.char_to_token(char_index) - 如果批次大小大于或等于 1，则
self.char_to_token(batch_index, char_index)
当输入序列作为预分词序列（即单词由用户定义）提供时，此方法尤其适用。在这种情况下，它允许轻松地将编码的 token 与提供的分词单词关联起来。
char_to_word
< source >( batch_or_char_index: int char_index: typing.Optional[int] = None sequence_index: int = 0 ) → int or List[int]
获取原始字符串中与批次序列的原始字符串中的字符相对应的单词。
可以这样调用
- 如果批次大小为 1，则
self.char_to_word(char_index) - 如果批次大小大于 1，则
self.char_to_word(batch_index, char_index)
当输入序列作为预分词序列（即单词由用户定义）提供时，此方法尤其适用。在这种情况下，它允许轻松地将编码的 token 与提供的分词单词关联起来。
convert_to_tensors
< source >( tensor_type: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None prepend_batch_axis: bool = False )
参数
- tensor_type (
str或 TensorType, 可选) — 要使用的 tensor 类型。 如果为str，则应为枚举 TensorType 的值之一。 如果为None，则不进行任何修改。 - prepend_batch_axis (
int, 可选, 默认为False) — 是否在转换期间添加批次维度。
将内部内容转换为 tensor。
sequence_ids
< source >( batch_index: int = 0 ) → List[Optional[int]]
返回一个列表，该列表将 token 映射到其原始句子的 ID
None用于在序列周围或序列之间添加的特殊 token，0用于对应于第一个序列中单词的 token，1用于对应于第二个序列中单词的 token，当一对序列被联合编码时。
to
< source >( device: typing.Union[str, ForwardRef('torch.device')] non_blocking: bool = False ) → BatchEncoding
参数
Returns
修改后的同一实例。
通过调用 v.to(device, non_blocking=non_blocking) (仅限 PyTorch) 将所有值发送到设备。
token_to_chars
< source >( batch_or_token_index: int token_index: typing.Optional[int] = None ) → CharSpan
获取与批次序列中编码的 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
< source >( batch_or_token_index: int token_index: typing.Optional[int] = None ) → int
获取给定 token 所代表的序列的索引。在一般用例中，对于单个序列或一对序列中的第一个序列，此方法返回 0，对于一对序列中的第二个序列，此方法返回 1。
可以这样调用
- 如果批次大小为 1，则为
self.token_to_sequence(token_index) - 如果批次大小大于 1，则为
self.token_to_sequence(batch_index, token_index)
当输入序列以预分词序列（即，单词由用户定义）的形式提供时，此方法尤其适用。在这种情况下，它允许轻松地将编码后的 token 与提供的分词单词关联起来。
token_to_word
< source >( batch_or_token_index: int token_index: typing.Optional[int] = None ) → int
获取与批次序列中编码后的 token 相对应（即包含该 token）的单词的索引。
可以这样调用
- 如果批次大小为 1，则为
self.token_to_word(token_index) - 如果批次大小大于 1，则为
self.token_to_word(batch_index, token_index)
当输入序列以预分词序列（即，单词由用户定义）的形式提供时，此方法尤其适用。在这种情况下，它允许轻松地将编码后的 token 与提供的分词单词关联起来。
tokens
< source >( batch_index: int = 0 ) → List[str]
返回给定批次索引处的 token 列表（单词/子词拆分后和转换为整数索引之前的输入字符串的子部分）（仅适用于快速分词器的输出）。
word_ids
< source >( batch_index: int = 0 ) → List[Optional[int]]
返回一个列表，该列表将 token 映射到快速分词器的初始句子中的实际单词。
word_to_chars
< source >( batch_or_word_index: int word_index: typing.Optional[int] = None sequence_index: int = 0 ) → CharSpan or List[CharSpan]
参数
- batch_or_word_index (
int) — 批次中序列的索引。如果批次仅包含一个序列，则这可以是序列中单词的索引 - word_index (
int, optional) — 如果在 batch_or_token_index 中提供了批次索引，则这可以是序列中单词的索引。 - sequence_index (
int, optional, defaults to 0) — 如果批次中编码了一对序列，则可以使用此参数指定提供的单词索引属于该对中的哪个序列（0 或 1）。
Returns
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
< source >( batch_or_word_index: int word_index: typing.Optional[int] = None sequence_index: int = 0 ) → (TokenSpan, optional)
参数
- batch_or_word_index (
int) — 批次中序列的索引。如果批次仅包含一个序列，则这可以是序列中单词的索引。 - word_index (
int, optional) — 如果在 batch_or_token_index 中提供了批次索引，则这可以是序列中单词的索引。 - sequence_index (
int, optional, defaults to 0) — 如果批次中编码了一对序列，则可以使用此参数指定提供的单词索引属于该对中的哪个序列（0 或 1）。
Returns
(TokenSpan, optional)
编码序列中 token 的跨度。如果单词没有对应的 token，则返回 None。当 token 是用于格式化分词的特殊 token 时，尤其会发生这种情况。例如，当我们在分词的最开始添加一个类别 token 时。
获取与批次序列中单词对应的编码 token 跨度。
Token 跨度以 TokenSpan 的形式返回，包含：
- start — 第一个 token 的索引。
- end — 最后一个 token 之后的 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)
当输入序列作为预分词序列（即单词由用户定义）提供时，此方法尤其适用。在这种情况下，它允许轻松地将编码的 token 与提供的分词单词关联起来。
words
< source >( batch_index: int = 0 ) → List[Optional[int]]
返回一个列表，该列表将 token 映射到快速分词器的初始句子中的实际单词。