Transformers 文档
分词器实用工具
并获得增强的文档体验
开始使用
分词器实用工具
本页列出了分词器使用的所有实用函数,主要是实现了 PreTrainedTokenizer 和 PreTrainedTokenizerFast 之间通用方法的 PreTrainedTokenizerBase 类以及混入类 SpecialTokensMixin。
这些大部分只有在您研究库中分词器代码时才有用。
PreTrainedTokenizerBase
class transformers.PreTrainedTokenizerBase
< 来源 >( **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
, 可选) — 表示被掩码 token 的特殊 token(例如 BERT 使用掩码语言建模预训练目标)。将与self.mask_token
和self.mask_token_id
关联。 - additional_special_tokens (
str
或tokenizers.AddedToken
的元组或列表, 可选) — 额外的特殊 token 的元组或列表。在此处添加它们以确保在解码时skip_special_tokens
设置为 True 时跳过它们。如果它们不是词汇表的一部分,它们将被添加到词汇表的末尾。 - clean_up_tokenization_spaces (
bool
, 可选, 默认为True
) — 模型是否应该清理在分词过程中分割输入文本时添加的空格。 - split_special_tokens (
bool
, 可选, 默认为False
) — 特殊 token 是否应该在分词过程中被分割。传递此参数将影响分词器的内部状态。默认行为是不分割特殊 token。这意味着如果<s>
是bos_token
,那么tokenizer.tokenize("<s>") = ['<s>']
。否则,如果split_special_tokens=True
,那么tokenizer.tokenize("<s>")
将给出['<','s', '>']
。
PreTrainedTokenizer 和 PreTrainedTokenizerFast 的基类。
处理这两个类之间共享的(主要是样板)方法。
类属性(由派生类覆盖)
- 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
) — 编码序列时是否添加特殊 token。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了哪些 token 会自动添加到输入 ID 中。如果您希望自动添加bos
或eos
token,此功能非常有用。 - 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 Cores 特别有用。 - padding_side (
str
, 可选) — 模型应该应用填充的侧面。应在 ['right', 'left'] 之间选择。默认值取自同名的类属性。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回张量而不是 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
, 可选) — 是否返回注意力掩码。如果保留默认值,将根据特定分词器的默认值返回注意力掩码,由return_outputs
属性定义。 - return_overflowing_tokens (
bool
, 可选, 默认为False
) — 是否返回溢出 token 序列。如果提供了一对输入 ID 序列(或一批对),并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出 token。 - return_special_tokens_mask (
bool
, 可选, 默认为False
) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool
, 可选, 默认为False
) — 是否返回每个 token 的(char_start, char_end)
。此功能仅适用于继承自 PreTrainedTokenizerFast 的快速分词器,如果使用 Python 的分词器,此方法将引发
NotImplementedError
。 - return_length (
bool
, 可选, 默认为False
) — 是否返回编码输入的长度。 - verbose (
bool
, 可选, 默认为True
) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()
方法
一个 BatchEncoding,包含以下字段:
-
input_ids — 要输入到模型中的标记 ID 列表。
-
token_type_ids — 要输入到模型中的标记类型 ID 列表(当
return_token_type_ids=True
或如果 *“token_type_ids”* 在self.model_input_names
中时)。 -
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
时)
将一个或多个序列或一对或多对序列标记化并准备用于模型的主要方法。
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'
: 返回 TensorFlowtf.Tensor
对象。'pt'
: 返回 PyTorchtorch.Tensor
对象。'np'
: 返回 NumPynp.ndarray
对象。'jax'
: 返回 JAXjnp.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]
到目前为止已分词聊天的标记 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 列表的列表转换为字符串列表。
batch_encode_plus
< 源 >( batch_text_or_text_pairs: typing.Union[list[str], list[tuple[str, str]], list[list[str]], list[tuple[list[str], list[str]]], list[list[int]], list[tuple[list[int], list[int]]]] 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 split_special_tokens: bool = False **kwargs ) → BatchEncoding
参数
- batch_text_or_text_pairs (
list[str]
,list[tuple[str, str]]
,list[list[str]]
,list[tuple[list[str], list[str]]]
,对于非快速分词器,还包括list[list[int]]
,list[tuple[list[int], list[int]]]
) — 要编码的序列批处理或序列对列表。这可以是字符串/字符串序列/整数序列列表,也可以是字符串/字符串序列/整数序列对列表(详见encode_plus
)。 - 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 Core 的使用特别有用。 - padding_side (
str
, 可选) — 模型应该应用填充的侧面。应在 ['right', 'left'] 之间选择。默认值从同名的类属性中选择。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:'tf'
: 返回 TensorFlowtf.constant
对象。'pt'
: 返回 PyTorchtorch.Tensor
对象。'np'
: 返回 Numpynp.ndarray
对象。
- return_token_type_ids (
bool
, 可选) — 是否返回标记类型 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,包含以下字段:
-
input_ids — 要输入到模型中的标记 ID 列表。
-
token_type_ids — 要输入到模型中的标记类型 ID 列表(当
return_token_type_ids=True
或如果 *“token_type_ids”* 在self.model_input_names
中时)。 -
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
时)
分词并为模型准备序列列表或序列对列表。
此方法已弃用,应改用 __call__
。
build_inputs_with_special_tokens
< 源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
通过连接和添加特殊标记,从序列或序列对构建用于序列分类任务的模型输入。
此实现不添加特殊标记,此方法应在子类中重写。
清理简单的英语分词伪影列表,例如标点符号前和缩写形式的空格。
convert_tokens_to_string
< 源 >( tokens: list ) → str
将一系列标记转换为单个字符串。最简单的方法是 " ".join(tokens)
,但我们通常希望同时删除子词分词伪影。
create_token_type_ids_from_sequences
< 源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
创建与传入序列对应的标记类型 ID。什么是标记类型 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'
:返回 TensorFlowtf.constant
对象。'pt'
:返回 PyTorchtorch.Tensor
对象。'np'
:返回 Numpynp.ndarray
对象。
- **kwargs — 传递给
.tokenize()
方法。
返回
list[int]
, torch.Tensor
, tf.Tensor
或 np.ndarray
文本的分词 ID。
使用分词器和词汇表将字符串转换为 ID 序列(整数)。
与执行 self.convert_tokens_to_ids(self.tokenize(text))
相同。
encode_plus
< 来源 >( 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 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[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'
:返回 TensorFlowtf.constant
对象。'pt'
:返回 PyTorchtorch.Tensor
对象。'np'
:返回 Numpynp.ndarray
对象。
- return_token_type_ids (
bool
, 可选) — 是否返回标记类型 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,包含以下字段:
-
input_ids — 要输入到模型中的标记 ID 列表。
-
token_type_ids — 要输入到模型中的标记类型 ID 列表(当
return_token_type_ids=True
或如果 *“token_type_ids”* 在self.model_input_names
中时)。 -
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
时)
对序列或序列对进行分词并为模型准备。
此方法已弃用,应改用 __call__
。
from_pretrained
< 来源 >( pretrained_model_name_or_path: typing.Union[str, os.PathLike] *init_inputs cache_dir: typing.Union[str, os.PathLike, NoneType] = None force_download: bool = False local_files_only: bool = False token: typing.Union[bool, str, NoneType] = None revision: str = 'main' trust_remote_code = False **kwargs )
参数
- pretrained_model_name_or_path (
str
或os.PathLike
) — 可以是:- 一个字符串,是托管在 huggingface.co 模型仓库中的预定义分词器的模型 ID。
- 一个包含分词器所需词汇文件的目录路径,例如使用 save_pretrained() 方法保存的目录,例如
./my_model_directory/
。 - (已弃用,不适用于所有派生类) 单个已保存词汇文件的路径或 URL(当且仅当分词器只需要一个词汇文件,如 Bert 或 XLNet 时),例如
./my_model_directory/vocab.txt
。
- cache_dir (
str
或os.PathLike
, 可选) — 如果不使用标准缓存,则下载的预定义分词器词汇文件应缓存到的目录路径。 - force_download (
bool
, 可选, 默认为False
) — 是否强制(重新)下载词汇文件并覆盖缓存版本(如果存在)。 - resume_download — 已弃用并忽略。现在所有下载默认都会在可能的情况下恢复。将在 Transformers v5 中移除。
- proxies (
dict[str, str]
, 可选) — 要按协议或端点使用的代理服务器字典,例如{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}
。代理用于每个请求。 - token (
str
或 bool, 可选) — 用于远程文件的 HTTP 授权令牌。如果为True
,将使用运行huggingface-cli login
时生成的令牌(存储在~/.huggingface
中)。 - local_files_only (
bool
, 可选, 默认为False
) — 是否仅依赖本地文件而不尝试下载任何文件。 - revision (
str
, 可选, 默认为"main"
) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们使用基于 Git 的系统在 huggingface.co 上存储模型和其他工件,因此revision
可以是 Git 允许的任何标识符。 - subfolder (
str
, 可选) — 如果相关文件位于 huggingface.co 上模型仓库的子文件夹中(例如,对于 facebook/rag-token-base),请在此处指定。 - inputs (附加位置参数,可选) — 将传递给分词器
__init__
方法。 - trust_remote_code (
bool
, 可选, 默认为False
) — 是否允许 Hub 上自定义模型在其自己的建模文件中定义。此选项仅应在您信任且已阅读其代码的仓库中设置为True
,因为它将在您的本地机器上执行 Hub 上存在的代码。 - kwargs (附加关键字参数,可选) — 将传递给分词器
__init__
方法。可用于设置特殊标记,如bos_token
、eos_token
、unk_token
、sep_token
、pad_token
、cls_token
、mask_token
、additional_special_tokens
。有关更多详细信息,请参阅__init__
中的参数。
从预定义分词器实例化 PreTrainedTokenizerBase(或派生类)。
当您想使用私有模型时,需要传递 token=True
。
示例
# We can't instantiate directly the base class *PreTrainedTokenizerBase* so let's show our examples on a derived class: BertTokenizer
# Download vocabulary from huggingface.co and cache.
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
# Download vocabulary from huggingface.co (user-uploaded) and cache.
tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased")
# If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/")
# If the tokenizer uses a single vocabulary file, you can point directly to this file
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/my_vocab.txt")
# You can link tokens to special vocabulary when instantiating
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased", unk_token="<unk>")
# You should be sure '<unk>' is in the vocabulary when doing that.
# Otherwise use tokenizer.add_special_tokens({'unk_token': '<unk>'}) instead)
assert tokenizer.unk_token == "<unk>"
get_chat_template
< 源 >( chat_template: typing.Optional[str] = None tools: typing.Optional[list[dict]] = None ) → str
参数
- chat_template (
str
, 可选) — 用于此转换的 Jinja 模板或模板名称。通常不需要向此参数传递任何内容,因为默认将使用模型的模板。 - tools (
list[Dict]
, 可选) — 模型可访问的工具(可调用函数)列表。如果模板不支持函数调用,此参数将无效。每个工具都应以 JSON Schema 形式传递,提供工具的名称、描述和参数类型。有关更多信息,请参阅我们的聊天模板指南。
返回
字符串
聊天模板字符串。
检索用于标记化聊天消息的聊天模板字符串。此模板由 apply_chat_template
方法在内部使用,也可在外部用于检索模型的聊天模板,以便更好地跟踪生成。
get_special_tokens_mask
< 源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → 一个范围在 [0, 1] 的整数列表
从未添加特殊令牌的令牌列表中检索序列 ID。使用分词器 prepare_for_model
或 encode_plus
方法添加特殊令牌时会调用此方法。
以从词元到索引的字典形式返回词汇表。
当 token
在词汇表中时,tokenizer.get_vocab()[token]
等同于 tokenizer.convert_tokens_to_ids(token)
。
pad
< 源 >( encoded_inputs: typing.Union[transformers.tokenization_utils_base.BatchEncoding, list[transformers.tokenization_utils_base.BatchEncoding], dict[str, list[int]], dict[str, list[list[int]]], list[dict[str, list[int]]]] padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True max_length: typing.Optional[int] = None pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_attention_mask: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None verbose: bool = True )
参数
- encoded_inputs (BatchEncoding, BatchEncoding 列表,
dict[str, list[int]]
,dict[str, list[list[int]]
或list[dict[str, list[int]]]
) — 经过分词的输入。可以表示单个输入(BatchEncoding 或dict[str, list[int]]
)或一批经过分词的输入(BatchEncoding 列表, dict[str, list[list[int]]] 或 list[dict[str, list[int]]]),因此您可以在预处理以及 PyTorch Dataloader 的 collate 函数中使用此方法。除了
list[int]
之外,您还可以使用张量(Numpy 数组、PyTorch 张量或 TensorFlow 张量),有关返回类型请参见上面的说明。 - padding (
bool
,str
或 PaddingStrategy, 可选, 默认为True
) — 在以下策略中选择一种填充返回序列的策略(根据模型的填充侧和填充索引):True
或'longest'
(默认):填充到批处理中最长的序列(如果只提供一个序列,则不填充)。'max_length'
:填充到由参数max_length
指定的最大长度,如果未提供该参数,则填充到模型可接受的最大输入长度。False
或'do_not_pad'
:不填充(即可以输出具有不同长度序列的批处理)。
- max_length (
int
, 可选) — 返回列表的最大长度以及可选的填充长度(见上文)。 - pad_to_multiple_of (
int
, 可选) — 如果设置,序列将填充到所提供值的倍数。这对于在计算能力
>= 7.5
(Volta) 的 NVIDIA 硬件上启用 Tensor Core 特别有用。 - padding_side (
str
, 可选) — 模型应在哪个方向应用填充。应在 ['right', 'left'] 中选择。默认值取自同名的类属性。 - return_attention_mask (
bool
, 可选) — 是否返回注意力掩码。如果保留默认值,将根据特定分词器的默认值(由return_outputs
属性定义)返回注意力掩码。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:'tf'
:返回 TensorFlowtf.constant
对象。'pt'
:返回 PyTorchtorch.Tensor
对象。'np'
:返回 Numpynp.ndarray
对象。
- verbose (
bool
, 可选, 默认为True
) — 是否打印更多信息和警告。
将单个编码输入或一批编码输入填充到预定义长度或批处理中的最大序列长度。
填充侧(左/右)填充令牌 ID 在分词器级别定义(通过 self.padding_side
、self.pad_token_id
和 self.pad_token_type_id
)。
请注意,对于快速分词器,使用 __call__
方法比使用方法对文本进行编码,然后调用 pad
方法以获取填充编码更快。
如果传入的 encoded_inputs
是 Numpy 数组、PyTorch 张量或 TensorFlow 张量的字典,除非您提供不同的张量类型(通过 return_tensors
),否则结果将使用相同的类型。但是,对于 PyTorch 张量,您将丢失张量的特定设备。
prepare_for_model
< 源 >( ids: list pair_ids: typing.Optional[list[int]] = 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 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 prepend_batch_axis: bool = False **kwargs ) → BatchEncoding
参数
- ids (
list[int]
) — 第一个序列的分词输入 ID。可以通过链接tokenize
和convert_tokens_to_ids
方法从字符串中获取。 - pair_ids (
list[int]
, 可选) — 第二个序列的分词输入 ID。可以通过链接tokenize
和convert_tokens_to_ids
方法从字符串中获取。 - 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 Core 特别有用。 - padding_side (
str
, 可选) — 模型应在哪个方向应用填充。应在 ['right', 'left'] 中选择。默认值取自同名的类属性。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:'tf'
:返回 TensorFlowtf.constant
对象。'pt'
:返回 PyTorchtorch.Tensor
对象。'np'
:返回 Numpynp.ndarray
对象。
- return_token_type_ids (
bool
, 可选) — 是否返回令牌类型 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,包含以下字段:
-
input_ids — 要输入到模型中的标记 ID 列表。
-
token_type_ids — 要输入到模型中的标记类型 ID 列表(当
return_token_type_ids=True
或如果 *“token_type_ids”* 在self.model_input_names
中时)。 -
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
时)
准备一个输入 ID 序列或一对输入 ID 序列,以便模型可以使用。它添加特殊令牌,如果溢出则截断序列,同时考虑特殊令牌并管理溢出令牌的移动窗口(具有用户定义的步长)。请注意,对于 pair_ids
不为 None
且 truncation_strategy = longest_first
或 True
的情况,无法返回溢出令牌。这种参数组合将引发错误。
prepare_seq2seq_batch
< 源 >( src_texts: list tgt_texts: typing.Optional[list[str]] = None max_length: typing.Optional[int] = None max_target_length: typing.Optional[int] = None padding: str = 'longest' return_tensors: typing.Optional[str] = None truncation: bool = True **kwargs ) → BatchEncoding
参数
- src_texts (
list[str]
) — 要概括的文档列表或源语言文本。 - tgt_texts (
list
, 可选) — 摘要列表或目标语言文本。 - max_length (
int
, 可选) — 控制编码器输入(要概括的文档或源语言文本)的最大长度。如果未设置或设置为None
,则如果截断/填充参数之一需要最大长度,此项将使用预定义的模型最大长度。如果模型没有特定的最大输入长度(如 XLNet),则最大长度的截断/填充将被停用。 - max_target_length (
int
, 可选) — 控制解码器输入(目标语言文本或摘要)的最大长度。如果未设置或设置为None
,将使用 `max_length` 值。 - padding (
bool
,str
或 PaddingStrategy, 可选, 默认为False
) — 激活并控制填充。接受以下值:True
或'longest'
: 填充到批次中最长的序列(如果只提供一个序列,则不填充)。'max_length'
: 填充到由参数max_length
指定的最大长度,如果未提供该参数,则填充到模型可接受的最大输入长度。False
或'do_not_pad'
(默认): 不填充(即可以输出不同长度序列的批次)。
- return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:'tf'
: 返回 TensorFlowtf.constant
对象。'pt'
: 返回 PyTorchtorch.Tensor
对象。'np'
: 返回 Numpynp.ndarray
对象。
- truncation (
bool
,str
或 TruncationStrategy, 可选, 默认为True
) — 激活并控制截断。接受以下值:True
或'longest_first'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将逐个截断令牌,从对中最长的序列中移除一个令牌。'only_first'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将只截断一对中的第一个序列。'only_second'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将只截断一对中的第二个序列。False
或'do_not_truncate'
(默认): 不截断(即可以输出序列长度大于模型最大可接受输入大小的批次)。
- **kwargs — 传递给
self.__call__
的额外关键字参数。
一个 BatchEncoding,包含以下字段:
- input_ids — 要输入到编码器的令牌 ID 列表。
- attention_mask — 指定模型应关注哪些令牌的索引列表。
- labels — tgt_texts 的令牌 ID 列表。
如果传递了 tgt_texts,则只会返回完整的键集 [input_ids, attention_mask, labels]
。否则,input_ids 和 attention_mask 将是唯一的键。
准备模型输入以进行翻译。为获得最佳性能,请一次翻译一个句子。
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[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
, 可选) — 是否使用临时目录来存储在推送到 Hub 之前保存的文件。如果没有名为repo_id
的目录,则默认为True
,否则为False
。 - commit_message (
str
, 可选) — 推送时要提交的消息。默认为"Upload tokenizer"
。 - private (
bool
, 可选) — 是否将存储库设为私有。如果为None
(默认),则存储库将是公开的,除非组织的默认设置为私有。如果存储库已存在,则此值将被忽略。 - token (
bool
或str
, 可选) — 用作远程文件 HTTP 承载授权的令牌。如果为True
,将使用运行huggingface-cli login
时生成的令牌(存储在~/.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 的标签列表。
将分词器文件上传到 🤗 模型中心。
示例
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")
register_for_auto_class
< source >( auto_class = 'AutoTokenizer' )
将此类别注册到一个给定的自动类中。这仅应用于自定义分词器,因为库中的分词器已与 AutoTokenizer
映射。
save_chat_templates
< source >( save_directory: typing.Union[str, os.PathLike] tokenizer_config: dict filename_prefix: typing.Optional[str] save_jinja_files: bool )
如果使用新格式,则将聊天模板写入保存目录,并从分词器配置中删除它们(如果存在)。如果使用旧格式,则不写入任何文件,而是将模板以正确格式写入分词器配置。
save_pretrained
< source >( save_directory: typing.Union[str, os.PathLike] legacy_format: typing.Optional[bool] = None filename_prefix: typing.Optional[str] = None push_to_hub: bool = False **kwargs ) → 一个 str
的元组
参数
- save_directory (
str
或os.PathLike
) — 分词器将保存到的目录路径。 - legacy_format (
bool
, 可选) — 仅适用于快速分词器。如果未设置(默认),将以统一的 JSON 格式以及旧格式(如果存在)保存分词器,即使用分词器特定的词汇表和单独的 added_tokens 文件。如果为
False
,将仅以统一的 JSON 格式保存分词器。此格式与“慢速”分词器(不由 tokenizers 库提供支持)不兼容,因此分词器将无法加载到相应的“慢速”分词器中。如果为
True
,将以旧格式保存分词器。如果“慢速”分词器不存在,则会引发值错误。 - filename_prefix (
str
, 可选) — 要添加到分词器保存文件名称的前缀。 - push_to_hub (
bool
, 可选, 默认为False
) — 保存模型后是否将其推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(默认为您命名空间中save_directory
的名称)。 - kwargs (
dict[str, Any]
, 可选) — 传递给 push_to_hub() 方法的额外关键字参数。
返回
一个 str
的元组
保存的文件。
保存完整的分词器状态。
此方法确保可以使用 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
类方法重新加载完整的分词器。
警告,None 这不会保存您在实例化后可能已应用于分词器的修改(例如,在创建后修改 tokenizer.do_lower_case
)。
save_vocabulary
< source >( save_directory: str filename_prefix: typing.Optional[str] = None ) → Tuple(str)
仅保存分词器的词汇表(词汇表 + 添加的令牌)。
此方法不会保存分词器的配置和特殊令牌映射。使用 _save_pretrained()
保存分词器的整个状态。
tokenize
< source >( text: str pair: typing.Optional[str] = None add_special_tokens: bool = False **kwargs ) → list[str]
参数
- text (
str
) — 要编码的序列。 - pair (
str
, 可选) — 与第一个序列一起编码的第二个序列。 - add_special_tokens (
bool
, 可选, 默认为False
) — 是否添加与相应模型关联的特殊令牌。 - kwargs (额外关键字参数,可选) — 将传递给底层模型特定编码方法。详见 call()
返回
list[str]
令牌列表。
将字符串转换为令牌序列,并将未知令牌替换为 unk_token
。
truncate_sequences
< source >( ids: list pair_ids: typing.Optional[list[int]] = None num_tokens_to_remove: int = 0 truncation_strategy: typing.Union[str, transformers.tokenization_utils_base.TruncationStrategy] = 'longest_first' stride: int = 0 ) → tuple[list[int], list[int], list[int]]
参数
- ids (
list[int]
) — 第一个序列的令牌化输入 ID。可以通过链接tokenize
和convert_tokens_to_ids
方法从字符串获取。 - pair_ids (
list[int]
, 可选) — 第二个序列的令牌化输入 ID。可以通过链接tokenize
和convert_tokens_to_ids
方法从字符串获取。 - num_tokens_to_remove (
int
, 可选, 默认为 0) — 使用截断策略要移除的令牌数量。 - truncation_strategy (
str
或 TruncationStrategy, 可选, 默认为'longest_first'
) — 截断要遵循的策略。可以是:'longest_first'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将逐个截断令牌,从对中最长的序列中移除一个令牌。'only_first'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将只截断一对中的第一个序列。'only_second'
: 截断到由参数max_length
指定的最大长度,如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供一对序列(或批次),这将只截断一对中的第二个序列。'do_not_truncate'
(默认): 不截断(即可以输出序列长度大于模型最大可接受输入大小的批次)。
- stride (
int
, 可选, 默认为 0) — 如果设置为正数,则返回的溢出令牌将包含主序列中的一些令牌。此参数的值定义了额外令牌的数量。
返回
tuple[list[int], list[int], list[int]]
截断后的 ids
、截断后的 pair_ids
和溢出令牌列表。注意:如果提供一对序列(或批次),longest_first 策略返回空的溢出令牌列表。
按照策略原地截断序列对。
SpecialTokensMixin
class transformers.SpecialTokensMixin
< source >( verbose = False **kwargs )
参数
- bos_token (
str
或tokenizers.AddedToken
, 可选) — 表示句子开头的特殊令牌。 - eos_token (
str
或tokenizers.AddedToken
, 可选) — 表示句子结尾的特殊令牌。 - unk_token (
str
或tokenizers.AddedToken
, 可选) — 表示词汇表外标记的特殊标记。 - sep_token (
str
或tokenizers.AddedToken
, 可选) — 在同一输入中分隔两个不同句子的特殊标记(例如 BERT 使用)。 - pad_token (
str
或tokenizers.AddedToken
, 可选) — 用于使标记数组大小相同以进行批处理的特殊标记。然后将被注意力机制或损失计算忽略。 - cls_token (
str
或tokenizers.AddedToken
, 可选) — 表示输入类别的特殊标记(例如 BERT 使用)。 - mask_token (
str
或tokenizers.AddedToken
, 可选) — 表示被掩码标记的特殊标记(例如被掩码语言建模预训练目标使用,如 BERT)。 - additional_special_tokens (
str
或tokenizers.AddedToken
的元组或列表, 可选) — 一个额外的标记元组或列表,将被标记为 `特殊`,这意味着如果 `skip_special_tokens` 设置为 `True`,它们在解码时将被跳过。
由 PreTrainedTokenizer 和 PreTrainedTokenizerFast 派生的混合类,用于处理与特殊标记相关的特定行为。特别是,此类拥有可用于以模型独立方式直接访问这些特殊标记的属性,并允许设置和更新特殊标记。
add_special_tokens
< source >( 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
添加到词汇表的标记数量。
向编码器添加特殊标记(eos、pad、cls 等)字典,并将其链接到类属性。如果特殊标记不在词汇表中,则将其添加到词汇表(索引从当前词汇表的最后一个索引开始)。
向词汇表添加新标记时,应确保同时调整模型的标记嵌入矩阵,使其嵌入矩阵与分词器匹配。
为此,请使用 resize_token_embeddings() 方法。
使用 add_special_tokens
将确保您的特殊标记可以多种方式使用
- 使用
skip_special_tokens = True
解码时可以跳过特殊标记。 - 特殊标记由分词器仔细处理(它们从不拆分),类似于
AddedTokens
。 - 您可以使用分词器类属性(例如
tokenizer.cls_token
)轻松引用特殊标记。这使得开发模型无关的训练和微调脚本变得容易。
在可能的情况下,预训练模型已注册特殊标记(例如 BertTokenizer 的 cls_token
已注册为 '[CLS]'
,XLM 的 cls_token
也注册为 '</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>"
add_tokens
< source >( 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.AddedToken
的详细信息,请参阅。
返回
int
添加到词汇表的标记数量。
向分词器类添加新标记列表。如果新标记不在词汇表中,它们将被添加到词汇表(索引从当前词汇表的长度开始),并在应用分词算法之前被隔离。因此,添加的标记和分词算法词汇表中的标记的处理方式不同。
请注意,向词汇表添加新标记时,应确保同时调整模型的标记嵌入矩阵,使其嵌入矩阵与分词器匹配。
为此,请使用 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))
sanitize_special_tokens
现已弃用,为向后兼容性保留,并将在 transformers v5 中移除。
枚举和命名元组
class transformers.tokenization_utils_base.TruncationStrategy
< source >( value names = None module = None qualname = None type = None start = 1 )
PreTrainedTokenizerBase.call() 中 truncation
参数的可能值。对 IDE 中的自动完成很有用。
class transformers.CharSpan
< source >( start: int end: int )
原始字符串中的字符跨度。
class transformers.TokenSpan
< source >( start: int end: int )
编码字符串(标记列表)中的标记跨度。