Transformers

( **kwargs )

引數

model_max_length (int, 可選) — Transformer 模型輸入的最大長度（以詞元數量計）。當使用 from_pretrained() 載入 tokenizer 時，此值將設定為 max_model_input_sizes 中為相關模型儲存的值（見上文）。如果未提供值，將預設為 VERY_LARGE_INTEGER (int(1e30))。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 [‘right’, ‘left’] 之間選擇。預設值從同名的類屬性中選取。
truncation_side (str, 可選) — 模型應在其上應用截斷的一側。應在 [‘right’, ‘left’] 之間選擇。預設值從同名的類屬性中選取。
chat_template (str, 可選) — 用於格式化聊天訊息列表的 Jinja 模板字串。完整描述請參見 https://huggingface.co/docs/transformers/chat_templating。
model_input_names (list[string], 可選) — 模型前向傳播接受的輸入列表（如 "token_type_ids" 或 "attention_mask"）。預設值從同名的類屬性中選取。
bos_token (str 或 tokenizers.AddedToken, 可選) — 表示句子開頭的特殊詞元。將與 self.bos_token 和 self.bos_token_id 關聯。
eos_token (str 或 tokenizers.AddedToken, 可選) — 表示句子結尾的特殊詞元。將與 self.eos_token 和 self.eos_token_id 關聯。
unk_token (str 或 tokenizers.AddedToken, 可選) — 表示詞彙表外詞元的特殊詞元。將與 self.unk_token 和 self.unk_token_id 關聯。
sep_token (str 或 tokenizers.AddedToken, 可選) — 在同一輸入中分隔兩個不同句子的特殊詞元（例如 BERT 使用）。將與 self.sep_token 和 self.sep_token_id 關聯。
pad_token (str 或 tokenizers.AddedToken, 可選) — 用於使詞元陣列大小相同以便於批處理的特殊詞元。之後將被注意力機制或損失計算忽略。將與 self.pad_token 和 self.pad_token_id 關聯。
cls_token (str 或 tokenizers.AddedToken, 可選) — 表示輸入類別的特殊詞元（例如 BERT 使用）。將與 self.cls_token 和 self.cls_token_id 關聯。
mask_token (str 或 tokenizers.AddedToken, 可選) — 表示被掩碼詞元的特殊詞元（由掩碼語言模型預訓練目標使用，如 BERT）。將與 self.mask_token 和 self.mask_token_id 關聯。
additional_special_tokens (tuple 或 list of str 或 tokenizers.AddedToken, 可選) — 額外特殊詞元的元組或列表。在此處新增它們以確保當 skip_special_tokens 設定為 True 時解碼時跳過它們。如果它們不屬於詞彙表，它們將被新增到詞彙表的末尾。
clean_up_tokenization_spaces (bool, 可選, 預設為 True) — 模型是否應清除在分詞過程中拆分輸入文字時新增的空格。
split_special_tokens (bool, 可選, 預設為 False) — 特殊詞元在分詞過程中是否應被拆分。傳遞此引數將影響 tokenizer 的內部狀態。預設行為是不拆分特殊詞元。這意味著如果 <s> 是 bos_token，那麼 tokenizer.tokenize("<s>") = ['<s>']。否則，如果 split_special_tokens=True，那麼 tokenizer.tokenize("<s>") 將得到 ['<','s', '>']。

所有慢速 tokenizer 的基類。

繼承自 PreTrainedTokenizerBase。

處理所有共享的分詞和特殊詞元方法，以及下載/快取/載入預訓練 tokenizer 和向詞彙表新增詞元的方法。

這個類還在所有 tokenizer 的基礎上以統一的方式包含新增的詞元，因此我們不必處理各種底層詞典結構（BPE、sentencepiece...）的特定詞彙增強方法。

類屬性（由派生類覆蓋）

vocab_files_names (dict[str, str]) — 一個字典，其鍵是模型所需的每個詞彙檔案的 __init__ 關鍵字名稱，關聯值是用於儲存關聯檔案的檔名（字串）。
pretrained_vocab_files_map (dict[str, dict[str, str]]) — 一個字典的字典，高層鍵是模型所需的每個詞彙檔案的 __init__ 關鍵字名稱，低層鍵是預訓練模型的 short-cut-names，關聯值是關聯的預訓練詞彙檔案的 url。
model_input_names (list[str]) — 模型正向傳播中預期的輸入列表。
padding_side (str) — 模型應該應用填充的側面的預設值。應為 'right' 或 'left'。
truncation_side (str) — 模型應該應用截斷的側面的預設值。應為 'right' 或 'left'。

call

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

引數

text (str, list[str], list[list[str]], 可選) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_pair (str, list[str], list[list[str]], 可選) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_target (str, list[str], list[list[str]], 可選) — 作為目標文字編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_pair_target (str, list[str], list[list[str]], 可選) — 作為目標文字編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
add_special_tokens (bool, 可選, 預設為 True) — 在編碼序列時是否新增特殊詞元。這將使用底層的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函式，該函式定義了哪些詞元會自動新增到輸入 ID 中。如果您想自動新增 bos 或 eos 詞元，這很有用。
padding (bool, str 或 PaddingStrategy, 可選, 預設為 False) — 啟用和控制填充。接受以下值：
- True 或 'longest': 填充到批次中最長的序列（如果只提供單個序列，則不填充）。
- 'max_length': 填充到由 max_length 引數指定的最大長度，或者如果未提供該引數，則填充到模型的最大可接受輸入長度。
- False 或 'do_not_pad' (預設): 不填充（即，可以輸出具有不同長度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可選, 預設為 False) — 啟用和控制截斷。接受以下值：
- True 或 'longest_first': 截斷到由 max_length 引數指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。這將逐個詞元地截斷，如果提供了一對序列（或一批序列對），則從最長的序列中刪除一個詞元。
- 'only_first': 截斷到由 max_length 引數指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。如果提供了一對序列（或一批序列對），這隻會截斷第一個序列。
- 'only_second': 截斷到由 max_length 引數指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。如果提供了一對序列（或一批序列對），這隻會截斷第二個序列。
- False 或 'do_not_truncate' (預設): 不截斷（即，可以輸出序列長度大於模型最大允許輸入大小的批次）。
max_length (int, 可選) — 控制由截斷/填充引數之一使用的最大長度。

如果留空或設定為 None，並且截斷/填充引數之一需要最大長度，則將使用預定義的模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則截斷/填充到最大長度將被停用。
stride (int, 可選, 預設為 0) — 如果與 max_length 一起設定為一個數字，當 return_overflowing_tokens=True 時返回的溢位詞元將包含一些來自返回的截斷序列末尾的詞元，以便在截斷和溢位序列之間提供一些重疊。此引數的值定義了重疊詞元的數量。
is_split_into_words (bool, 可選, 預設為 False) — 輸入是否已預分詞（例如，拆分為單詞）。如果設定為 True，tokenizer 會假定輸入已拆分為單詞（例如，透過在空白處拆分），然後對其進行分詞。這對於 NER 或詞元分類很有用。
pad_to_multiple_of (int, 可選) — 如果設定，將序列填充到所提供值的倍數。需要啟用 padding。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上使用 Tensor Cores 特別有用。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 [‘right’, ‘left’] 之間選擇。預設值從同名的類屬性中選取。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：
- 'tf': 返回 TensorFlow tf.constant 物件。
- 'pt': 返回 PyTorch torch.Tensor 物件。
- 'np': 返回 Numpy np.ndarray 物件。
return_token_type_ids (bool, 可選) — 是否返回詞元型別 ID。如果留空，將根據特定 tokenizer 的預設設定返回詞元型別 ID，該設定由 return_outputs 屬性定義。

什麼是詞元型別 ID？
return_attention_mask (bool, 可選) — 是否返回注意力掩碼。如果留空，將根據特定 tokenizer 的預設設定返回注意力掩碼，該設定由 return_outputs 屬性定義。

什麼是注意力掩碼？
return_overflowing_tokens (bool, 可選, 預設為 False) — 是否返回溢位的詞元序列。如果提供了一對輸入 ID 序列（或一批序列對）且 truncation_strategy = longest_first 或 True，則會引發錯誤而不是返回溢位詞元。
return_special_tokens_mask (bool, 可選, 預設為 False) — 是否返回特殊詞元掩碼資訊。
return_offsets_mapping (bool, 可選, 預設為 False) — 是否為每個詞元返回 (char_start, char_end)。

這僅在繼承自 PreTrainedTokenizerFast 的快速 tokenizer 上可用，如果使用 Python 的 tokenizer，此方法將引發 NotImplementedError。
return_length (bool, 可選, 預設為 False) — 是否返回編碼輸入的長度。
verbose (bool, 可選, 預設為 True) — 是否列印更多資訊和警告。
**kwargs — 傳遞給 self.tokenize() 方法

BatchEncoding

一個 BatchEncoding，包含以下欄位：

input_ids — 要輸入到模型中的標記 ID 列表。

什麼是輸入 ID？
token_type_ids — 要輸入到模型中的標記型別 ID 列表（當 return_token_type_ids=True 或如果 *“token_type_ids”* 在 self.model_input_names 中時）。

什麼是標記型別 ID？
attention_mask — 指定模型應關注哪些標記的索引列表（當 return_attention_mask=True 或如果 *“attention_mask”* 在 self.model_input_names 中時）。

什麼是注意力掩碼？
overflowing_tokens — 溢位標記序列列表（當指定 max_length 且 return_overflowing_tokens=True 時）。
num_truncated_tokens — 截斷標記的數量（當指定 max_length 且 return_overflowing_tokens=True 時）。
special_tokens_mask — 0 和 1 的列表，其中 1 表示新增的特殊標記，0 表示常規序列標記（當 add_special_tokens=True 且 return_special_tokens_mask=True 時）。
length — 輸入的長度（當 return_length=True 時）

將一個或多個序列或一對或多對序列標記化並準備用於模型的主要方法。

add_tokens

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

引數

new_tokens (str, tokenizers.AddedToken 或 str 或 tokenizers.AddedToken 的序列) — 只有當詞元不在詞彙表中時才會被新增。tokenizers.AddedToken 包裝了一個字串詞元，讓您個性化其行為：該詞元是否應僅匹配單個單詞，是否應去除左側所有潛在的空白，是否應去除右側所有潛在的空白等。
special_tokens (bool, 可選, 預設為 False) — 可用於指定詞元是否為特殊詞元。這主要改變歸一化行為（像 CLS 或 [MASK] 這樣的特殊詞元通常不會轉換為小寫）。

有關 tokenizers.AddedToken 的詳細資訊，請參閱 HuggingFace tokenizers 庫。

int

新增到詞彙表中的詞元數量。

向 tokenizer 類新增一個新的詞元列表。如果新詞元不在詞彙表中，它們將被新增到詞彙表中，其索引從當前詞彙表的長度開始，並且在應用分詞演算法之前將被隔離。因此，新增的詞元和分詞演算法詞彙表中的詞元處理方式不同。

注意，向詞彙表新增新詞元時，您應確保也調整模型的詞元嵌入矩陣的大小，使其嵌入矩陣與 tokenizer 匹配。

為此，請使用 resize_token_embeddings() 方法。

示例

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

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

add_special_tokens

( special_tokens_dict: dict replace_additional_special_tokens = True ) → int

引數

special_tokens_dict (dictionary str to str, tokenizers.AddedToken, 或 Sequence[Union[str, AddedToken]]) — 鍵應位於預定義的特殊屬性列表中：[bos_token, eos_token, unk_token, sep_token, pad_token, cls_token, mask_token, additional_special_tokens]。

僅當標記尚未在詞彙表中時才會新增（透過檢查分詞器是否為它們分配了 unk_token 的索引來測試）。
replace_additional_special_tokens (bool, 可選，預設為 True) — 如果為 True，現有的附加特殊標記列表將被 special_tokens_dict 中提供的列表替換。否則，僅擴充套件 self._special_tokens_map["additional_special_tokens"]。在前一種情況下，這些標記不會從分詞器的完整詞彙表中移除 - 它們只是被標記為非特殊標記。請記住，這隻影響在解碼期間哪些標記被跳過，而不影響 added_tokens_encoder 和 added_tokens_decoder。這意味著之前的 additional_special_tokens 仍然是已新增的標記，並且不會被模型拆分。

int

新增到詞彙表中的詞元數量。

向編碼器新增一個特殊標記（eos、pad、cls 等）的字典，並將它們連結到類屬性。如果特殊標記不在詞彙表中，則將它們新增到詞彙表中（從當前詞彙表的最後一個索引開始索引）。

當向詞彙表新增新標記時，應確保同時調整模型的標記嵌入矩陣的大小，使其嵌入矩陣與分詞器匹配。

為此，請使用 resize_token_embeddings() 方法。

使用 add_special_tokens 將確保您的特殊標記可以透過多種方式使用

使用 skip_special_tokens = True 時，可以在解碼時跳過特殊標記。
特殊標記由分詞器仔細處理（它們永遠不會被拆分），類似於 AddedTokens。
您可以使用分詞器類屬性（如 tokenizer.cls_token）輕鬆引用特殊標記。這使得開發與模型無關的訓練和微調指令碼變得容易。

在可能的情況下，特殊標記已經為提供的預訓練模型註冊（例如 BertTokenizer 的 cls_token 已註冊為 '[CLS]'，XLM 的也已註冊為 '</s>'）。

示例

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

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

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

assert tokenizer.cls_token == "<CLS>"

apply_chat_template

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

引數

conversation (Union[list[dict[str, str]], list[list[dict[str, str]]]]) — 一個包含“role”和“content”鍵的字典列表，表示迄今為止的聊天曆史記錄。
tools (list[Union[Dict, Callable]], 可選) — 模型可訪問的工具（可呼叫函式）列表。如果模板不支援函式呼叫，此引數將無效。每個工具都應作為 JSON Schema 傳遞，給出工具的名稱、描述和引數型別。更多資訊請參閱我們的聊天模板指南。
documents (list[dict[str, str]], 可選) — 一個表示文件的字典列表，如果模型正在執行 RAG（檢索增強生成），這些文件將對模型可用。如果模板不支援 RAG，此引數將無效。我們建議每個文件都是一個包含“title”和“text”鍵的字典。有關透過聊天模板傳遞文件的示例，請參閱聊天模板指南的 RAG 部分。
chat_template (str, 可選) — 用於此轉換的 Jinja 模板。通常不需要向此引數傳遞任何內容，因為預設情況下將使用模型的模板。
add_generation_prompt (bool, 可選) — 如果設定此項，則會在格式化輸出的末尾附加一個帶有表示助手訊息開始的標記的提示。當您希望從模型生成響應時，這很有用。請注意，此引數將傳遞給聊天模板，因此模板必須支援此引數才能使其生效。
continue_final_message (bool, 可選) — 如果設定此項，聊天將被格式化，以便聊天中的最後一條訊息是開放式的，沒有任何 EOS 標記。模型將繼續此訊息，而不是開始一條新訊息。這允許您為其“預填充”模型響應的一部分。不能與 add_generation_prompt 同時使用。
tokenize (bool, 預設為 True) — 是否對輸出進行分詞。如果為 False，輸出將是一個字串。
padding (bool, str 或 PaddingStrategy, 可選，預設為 False) — 選擇一種策略來填充返回的序列（根據模型的填充側和填充索引）：
- True 或 'longest': 填充到批次中最長的序列（如果只提供單個序列，則不填充）。
- 'max_length': 填充到由 max_length 引數指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。
- False 或 'do_not_pad' (預設): 不填充（即，可以輸出具有不同長度序列的批次）。
truncation (bool, 預設為 False) — 是否在最大長度處截斷序列。如果 tokenize 為 False，則無效。
max_length (int, 可選) — 用於填充或截斷的最大長度（以標記計）。如果 tokenize 為 False，則無效。如果未指定，將使用分詞器的 max_length 屬性作為預設值。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回特定框架的張量。如果 tokenize 為 False，則無效。可接受的值為：
- 'tf': 返回 TensorFlow tf.Tensor 物件。
- 'pt': 返回 PyTorch torch.Tensor 物件。
- 'np': 返回 NumPy np.ndarray 物件。
- 'jax': 返回 JAX jnp.ndarray 物件。
return_dict (bool, 預設為 False) — 是否返回帶有命名輸出的字典。如果 tokenize 為 False，則無效。
tokenizer_kwargs (dict[str -- Any], 可選): 要傳遞給分詞器的附加關鍵字引數。
return_assistant_tokens_mask (bool, 預設為 False) — 是否返回助手生成標記的掩碼。對於助手生成的標記，掩碼將包含 1。對於使用者和系統標記，掩碼將包含 0。此功能僅適用於透過 {% generation %} 關鍵字支援它的聊天模板。
**kwargs — 要傳遞給模板渲染器的附加關鍵字引數。聊天模板將可以訪問。

Union[list[int], Dict]

一個表示迄今為止分詞後聊天的標記 ID 列表，包括控制標記。此輸出已準備好傳遞給模型，可以直接傳遞，也可以透過 generate() 等方法傳遞。如果設定了 return_dict，則將返回一個分詞器輸出的字典。

將包含 "role" 和 "content" 鍵的字典列表轉換為標記 ID 列表。此方法旨在與聊天模型一起使用，並將讀取分詞器的 chat_template 屬性以確定在轉換時使用的格式和控制標記。

batch_decode

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

引數

sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分詞後的輸入 ID 列表。可以使用 __call__ 方法獲得。
skip_special_tokens (bool, 可選，預設為 False) — 在解碼時是否移除特殊標記。
clean_up_tokenization_spaces (bool, 可選) — 是否清理分詞空格。如果為 None，將預設為 self.clean_up_tokenization_spaces。
kwargs (附加關鍵字引數, 可選) — 將傳遞給底層模型特定的解碼方法。

list[str]

解碼後的句子列表。

透過呼叫 decode 將標記 ID 列表的列表轉換為字串列表。

decode

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

引數

token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分詞後的輸入 ID 列表。可以使用 __call__ 方法獲得。
skip_special_tokens (bool, 可選，預設為 False) — 在解碼時是否移除特殊標記。
clean_up_tokenization_spaces (bool, 可選) — 是否清理分詞空格。如果為 None，將預設為 self.clean_up_tokenization_spaces。
kwargs (附加關鍵字引數, 可選) — 將傳遞給底層模型特定的解碼方法。

字串

解碼後的句子。

使用分詞器和詞彙表將 ID 序列轉換為字串，可以選擇移除特殊標記並清理分詞空間。

類似於執行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

編碼

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

引數

text (str, list[str] 或 list[int]) — 要編碼的第一個序列。這可以是一個字串，一個字串列表（使用 tokenize 方法分詞後的字串）或一個整數列表（使用 convert_tokens_to_ids 方法分詞後的字串 ID）。
text_pair (str, list[str] 或 list[int], 可選) — 可選的要編碼的第二個序列。這可以是一個字串，一個字串列表（使用 tokenize 方法分詞後的字串）或一個整數列表（使用 convert_tokens_to_ids 方法分詞後的字串 ID）。
add_special_tokens (bool, 可選，預設為 True) — 在編碼序列時是否新增特殊標記。這將使用底層的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函式，該函式定義了哪些標記會自動新增到輸入 ID 中。如果您想自動新增 bos 或 eos 標記，這很有用。
padding (bool, str 或 PaddingStrategy, 可選，預設為 False) — 啟用和控制填充。接受以下值：
- True 或 'longest': 填充到批次中最長的序列（如果只提供單個序列，則不填充）。
- 'max_length': 填充到由 max_length 引數指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。
- False 或 'do_not_pad' (預設): 不填充（即，可以輸出具有不同長度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可選，預設為 False) — 啟用和控制截斷。接受以下值：
- True 或 'longest_first': 截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。這將逐個標記地截斷，如果提供了一對序列（或一批對），則從該對中最長的序列中移除一個標記。
- 'only_first': 截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），則僅截斷第一個序列。
- 'only_second': 截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），則僅截斷第二個序列。
- False 或 'do_not_truncate' (預設): 不截斷（即，可以輸出序列長度大於模型最大允許輸入大小的批次）。
max_length (int, 可選) — 控制由截斷/填充引數之一使用的最大長度。

如果未設定或設定為 None，則如果截斷/填充引數之一需要最大長度，將使用預定義的模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則截斷/填充到最大長度的操作將被停用。
stride (int, 可選，預設為 0) — 如果與 max_length 一起設定為一個數字，當 return_overflowing_tokens=True 時返回的溢位標記將包含一些來自返回的截斷序列末尾的標記，以在截斷和溢位序列之間提供一些重疊。此引數的值定義了重疊標記的數量。
is_split_into_words (bool, 可選，預設為 False) — 輸入是否已經預分詞（例如，拆分為單詞）。如果設定為 True，分詞器將假定輸入已拆分為單詞（例如，透過在空白處拆分），它將對這些單詞進行分詞。這對於 NER 或標記分類很有用。
pad_to_multiple_of (int, 可選) — 如果設定，將序列填充到所提供值的倍數。需要啟用 padding。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上啟用 Tensor Cores 特別有用。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 [‘right’, ‘left’] 之間選擇。預設值從同名的類屬性中選取。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：
- 'tf': 返回 TensorFlow tf.constant 物件。
- 'pt': 返回 PyTorch torch.Tensor 物件。
- 'np': 返回 Numpy np.ndarray 物件。
**kwargs — 傳遞給 .tokenize() 方法。

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

文字的分詞後 ID。

使用分詞器和詞彙表將字串轉換為 ID（整數）序列。

與執行 self.convert_tokens_to_ids(self.tokenize(text)) 相同。

push_to_hub

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

引數

repo_id (str) — 您想將分詞器推送到的儲存庫的名稱。當推送到特定組織時，它應包含您的組織名稱。
use_temp_dir (bool, optional) — 是否使用臨時目錄來儲存推送到 Hub 之前儲存的檔案。如果沒有名為 repo_id 的目錄，則預設為 True，否則為 False。
commit_message (str, optional) — 推送時要提交的訊息。預設為 "Upload tokenizer"。
private (bool, optional) — 是否將儲存庫設為私有。如果為 None（預設值），除非組織的預設設定是私有，否則儲存庫將是公開的。如果儲存庫已存在，此值將被忽略。
token (bool or str, optional) — 用於遠端檔案的 HTTP 持有者授權的令牌。如果為 True，將使用執行 huggingface-cli login 時生成的令牌（儲存在 ~/.huggingface 中）。如果未指定 repo_url，則預設為 True。
max_shard_size (int or str, optional, defaults to "5GB") — 僅適用於模型。檢查點分片前的最大大小。每個檢查點分片的大小將小於此值。如果以字串形式表示，則需要是數字後跟單位（如 "5MB"）。我們預設設定為 "5GB"，以便使用者可以在免費的 Google Colab 例項上輕鬆載入模型，而不會出現任何 CPU 記憶體不足（OOM）的問題。
create_pr (bool, optional, defaults to False) — 是否為上傳的檔案建立一個拉取請求（PR）或直接提交。
safe_serialization (bool, optional, defaults to True) — 是否將模型權重轉換為 safetensors 格式以實現更安全的序列化。
revision (str, optional) — 要將上傳的檔案推送到的分支。
commit_description (str, optional) — 將要建立的提交的描述。
tags (list[str], optional) — 要推送到 Hub 的標籤列表。

將分詞器檔案上傳到 🤗 Model Hub。

示例

from transformers import AutoTokenizer

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

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

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

convert_ids_to_tokens

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

引數

ids (int or list[int]) — 要轉換為詞符的詞符 ID（或詞符 ID 列表）。
skip_special_tokens (bool, optional, defaults to False) — 是否在解碼時移除特殊詞符。

str or list[str]

解碼後的詞符。

使用詞彙表和新增的詞符，將單個索引或索引序列轉換為一個詞符或詞符序列。

convert_tokens_to_ids

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

引數

tokens (str or list[str]) — 要轉換為詞符 ID 的一個或多個詞符。

int or list[int]

詞符 ID 或詞符 ID 列表。

使用詞彙表，將一個詞符字串（或詞符序列）轉換為單個整數 ID（或 ID 序列）。

get_added_vocab

( ) → dict[str, int]

dict[str, int]

新增的詞符。

以詞符到索引的字典形式返回詞彙表中新增的詞符。結果可能與快速呼叫不同，因為目前即使詞符已在詞彙表中，我們仍會新增它們。這是我們應該改變的地方。

num_special_tokens_to_add

( pair: bool = False ) → int

引數

pair (bool, optional, defaults to False) — 是否在序列對的情況下或單個序列的情況下計算新增的詞符數量。

int

新增到序列中的特殊詞符數量。

在使用特殊詞符編碼序列時返回新增的詞符數量。

此方法會對一個虛擬輸入進行編碼並檢查新增的詞符數量，因此效率不高。請勿將其放入您的訓練迴圈中。

prepare_for_tokenization

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

引數

text (str) — 要準備的文字。
is_split_into_words (bool, optional, defaults to False) — 輸入是否已預分詞（例如，拆分為單詞）。如果設定為 True，分詞器會假定輸入已被拆分為單詞（例如，透過在空白處分割），然後它將對這些單詞進行分詞。這對於 NER 或詞符分類任務很有用。
kwargs (dict[str, Any], optional) — 用於分詞的關鍵字引數。

tuple[str, dict[str, Any]]

準備好的文字和未使用的 kwargs。

在分詞前執行任何必要的轉換。

此方法應從 kwargs 中彈出引數，並返回剩餘的 kwargs。我們在編碼過程結束時測試 kwargs，以確保所有引數都已使用。

tokenize

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

引數

text (str) — 要編碼的序列。
**kwargs (附加關鍵字引數) — 傳遞給特定於模型的 prepare_for_tokenization 預處理方法。

list[str]

令牌列表。

使用分詞器將字串轉換為詞符序列。

對於基於詞的詞彙表，拆分為單詞；對於基於子詞的詞彙表（BPE/SentencePieces/WordPieces），拆分為子詞。處理新增的詞符。

PreTrainedTokenizerFast

PreTrainedTokenizerFast 依賴於 tokenizers 庫。從 🤗 tokenizers 庫中獲得的分詞器可以非常簡單地載入到 🤗 transformers 中。請檢視使用 🤗 tokenizers 的分詞器頁面，瞭解如何操作。

class transformers.PreTrainedTokenizerFast

( *args **kwargs )

引數

model_max_length (int, optional) — Transformer 模型輸入的最大長度（以詞符數量計）。當使用 from_pretrained() 載入分詞器時，此值將設定為相關模型在 max_model_input_sizes 中儲存的值（見上文）。如果未提供值，則預設為 VERY_LARGE_INTEGER (int(1e30))。
padding_side (str, optional) — 模型應在其上應用填充的一側。應從 [‘right’, ‘left’] 中選擇。預設值從同名的類屬性中選取。
truncation_side (str, optional) — 模型應在其上應用截斷的一側。應從 [‘right’, ‘left’] 中選擇。預設值從同名的類屬性中選取。
chat_template (str, optional) — 一個 Jinja 模板字串，用於格式化聊天訊息列表。有關完整說明，請參閱 https://huggingface.co/docs/transformers/chat_templating。
model_input_names (list[string], optional) — 模型前向傳播接受的輸入列表（如 "token_type_ids" 或 "attention_mask"）。預設值從同名的類屬性中選取。
bos_token (str or tokenizers.AddedToken, optional) — 表示句子開頭的特殊詞符。將與 self.bos_token 和 self.bos_token_id 相關聯。
eos_token (str or tokenizers.AddedToken, optional) — 表示句子結尾的特殊詞符。將與 self.eos_token 和 self.eos_token_id 相關聯。
unk_token (str or tokenizers.AddedToken, optional) — 表示詞彙表外詞符的特殊詞符。將與 self.unk_token 和 self.unk_token_id 相關聯。
sep_token (str or tokenizers.AddedToken, optional) — 在同一輸入中分隔兩個不同句子的特殊詞符（例如，BERT 使用）。將與 self.sep_token 和 self.sep_token_id 相關聯。
pad_token (str or tokenizers.AddedToken, optional) — 用於使詞符陣列大小相同以便於批處理的特殊詞符。之後將被注意力機制或損失計算忽略。將與 self.pad_token 和 self.pad_token_id 相關聯。
cls_token (str or tokenizers.AddedToken, optional) — 表示輸入類別的特殊詞符（例如，BERT 使用）。將與 self.cls_token 和 self.cls_token_id 相關聯。
mask_token (str or tokenizers.AddedToken, optional) — 表示掩碼詞符的特殊詞符（用於掩碼語言建模預訓練目標，如 BERT）。將與 self.mask_token 和 self.mask_token_id 相關聯。
additional_special_tokens (tuple or list of str or tokenizers.AddedToken, optional) — 一個元組或列表，包含額外的特殊詞符。在此處新增它們，以確保在解碼時當 skip_special_tokens 設定為 True 時它們被跳過。如果它們不是詞彙表的一部分，它們將被新增到詞彙表的末尾。
clean_up_tokenization_spaces (bool, optional, defaults to True) — 模型是否應清理在分詞過程中分割輸入文字時新增的空格。
split_special_tokens (bool, optional, defaults to False) — 特殊詞符在分詞過程中是否應被分割。傳遞此引數將影響分詞器的內部狀態。預設行為是不分割特殊詞符。這意味著如果 <s> 是 bos_token，則 tokenizer.tokenize("<s>") = ['<s>']。否則，如果 split_special_tokens=True，則 tokenizer.tokenize("<s>") 將得到 ['<','s', '>']。
tokenizer_object (tokenizers.Tokenizer) — 從 🤗 tokenizers 例項化的 tokenizers.Tokenizer 物件。有關更多資訊，請參閱使用 🤗 tokenizers 的分詞器。
tokenizer_file (str) — 一個本地 JSON 檔案的路徑，代表先前從 🤗 tokenizers 序列化的 tokenizers.Tokenizer 物件。

所有快速分詞器的基類（包裝 HuggingFace tokenizers 庫）。

繼承自 PreTrainedTokenizerBase。

處理所有共享的分詞和特殊詞符方法，以及下載/快取/載入預訓練分詞器和向詞彙表新增詞符的方法。

這個類還以統一的方式在所有分詞器之上包含新增的詞符，因此我們不必處理各種底層詞典結構（BPE，sentencepiece…）的特定詞彙表增強方法。

類屬性（由派生類覆蓋）

vocab_files_names (dict[str, str]) — 一個字典，其鍵是模型所需的每個詞彙檔案的 __init__ 關鍵字名稱，關聯值是用於儲存關聯檔案的檔名（字串）。
pretrained_vocab_files_map (dict[str, dict[str, str]]) — 一個字典的字典，高層鍵是模型所需的每個詞彙檔案的 __init__ 關鍵字名稱，低層鍵是預訓練模型的 short-cut-names，關聯值是關聯的預訓練詞彙檔案的 url。
model_input_names (list[str]) — 模型正向傳播中預期的輸入列表。
padding_side (str) — 模型應該應用填充的側面的預設值。應為 'right' 或 'left'。
truncation_side (str) — 模型應該應用截斷的側面的預設值。應為 'right' 或 'left'。

call

引數

text (str, list[str], list[list[str]], optional) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_pair (str, list[str], list[list[str]], optional) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_target (str, list[str], list[list[str]], optional) — 要編碼為目標文字的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
text_pair_target (str, list[str], list[list[str]], optional) — 要編碼為目標文字的序列或序列批次。每個序列可以是一個字串或一個字串列表（預分詞的字串）。如果序列以字串列表（預分詞）的形式提供，您必須設定 is_split_into_words=True（以消除與序列批次的歧義）。
add_special_tokens (bool, optional, defaults to True) — 是否在編碼序列時新增特殊詞符。這將使用底層的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函式，該函式定義了哪些詞符會自動新增到輸入 ID 中。如果您想自動新增 bos 或 eos 詞符，這會很有用。
padding (bool, str or PaddingStrategy, optional, defaults to False) — 啟用和控制填充。接受以下值：
- True 或 'longest'：填充到批次中最長的序列（如果只提供單個序列則不填充）。
- 'max_length'：填充到由 max_length 引數指定的最大長度，或者如果未提供該引數，則填充到模型的最大可接受輸入長度。
- False 或 'do_not_pad'（預設）：不填充（即，可以輸出具有不同長度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可選, 預設為 False) — 啟用並控制截斷。接受以下值：
- True 或 'longest_first'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。這將逐個詞元進行截斷，如果提供了一對序列（或一批序列對），則從最長的序列中移除一個詞元。
- 'only_first'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批序列對），這隻會截斷第一個序列。
- 'only_second'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批序列對），這隻會截斷第二個序列。
- False 或 'do_not_truncate' (預設)：不進行截斷（即可以輸出序列長度大於模型最大可接受輸入大小的批次）。
max_length (int, 可選) — 控制截斷/填充引數使用的最大長度。

如果未設定或設定為 None，並且截斷/填充引數需要最大長度，則將使用預定義的模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則截斷/填充到最大長度的功能將被停用。
stride (int, 可選, 預設為 0) — 如果與 max_length 一起設定，並且當 return_overflowing_tokens=True 時，返回的溢位詞元將包含一些來自返回的被截斷序列末尾的詞元，以在截斷序列和溢位序列之間提供一些重疊。此引數的值定義了重疊詞元的數量。
is_split_into_words (bool, 可選, 預設為 False) — 輸入是否已經預分詞（例如，拆分為單詞）。如果設定為 True，分詞器將假定輸入已經被拆分為單詞（例如，透過空格分割），然後對其進行分詞。這對於 NER 或詞元分類任務很有用。
pad_to_multiple_of (int, 可選) — 如果設定，將把序列填充到所提供值的倍數。需要啟用 padding。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上啟用 Tensor Cores 特別有用。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 [‘right’, ‘left’] 之間選擇。預設值從同名的類屬性中選取。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值有：
- 'tf'：返回 TensorFlow tf.constant 物件。
- 'pt'：返回 PyTorch torch.Tensor 物件。
- 'np'：返回 Numpy np.ndarray 物件。
return_token_type_ids (bool, 可選) — 是否返回詞元型別 ID。如果保留預設值，將根據特定分詞器的預設設定返回詞元型別 ID，該設定由 return_outputs 屬性定義。

什麼是詞元型別 ID？
return_attention_mask (bool, 可選) — 是否返回注意力掩碼。如果保留預設值，將根據特定分詞器的預設設定返回注意力掩碼，該設定由 return_outputs 屬性定義。

什麼是注意力掩碼？
return_overflowing_tokens (bool, 可選, 預設為 False) — 是否返回溢位的詞元序列。如果提供了一對輸入 ID 序列（或一批序列對）並設定了 truncation_strategy = longest_first 或 True，則會引發錯誤，而不是返回溢位的詞元。
return_special_tokens_mask (bool, 可選, 預設為 False) — 是否返回特殊詞元掩碼資訊。
return_offsets_mapping (bool, 可選, 預設為 False) — 是否為每個詞元返回 (char_start, char_end)。

這僅在繼承自 PreTrainedTokenizerFast 的快速分詞器上可用，如果使用 Python 的分詞器，此方法將引發 NotImplementedError。
return_length (bool, 可選, 預設為 False) — 是否返回編碼輸入的長度。
verbose (bool, 可選, 預設為 True) — 是否列印更多資訊和警告。
**kwargs — 傳遞給 self.tokenize() 方法的引數

BatchEncoding

一個 BatchEncoding，包含以下欄位：

input_ids — 要輸入到模型中的標記 ID 列表。

什麼是輸入 ID？
token_type_ids — 要輸入到模型中的標記型別 ID 列表（當 return_token_type_ids=True 或如果 *“token_type_ids”* 在 self.model_input_names 中時）。

什麼是標記型別 ID？
attention_mask — 指定模型應關注哪些標記的索引列表（當 return_attention_mask=True 或如果 *“attention_mask”* 在 self.model_input_names 中時）。

什麼是注意力掩碼？
overflowing_tokens — 溢位標記序列列表（當指定 max_length 且 return_overflowing_tokens=True 時）。
num_truncated_tokens — 截斷標記的數量（當指定 max_length 且 return_overflowing_tokens=True 時）。
special_tokens_mask — 0 和 1 的列表，其中 1 表示新增的特殊標記，0 表示常規序列標記（當 add_special_tokens=True 且 return_special_tokens_mask=True 時）。
length — 輸入的長度（當 return_length=True 時）

將一個或多個序列或一對或多對序列標記化並準備用於模型的主要方法。

add_tokens

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

引數

new_tokens (str, tokenizers.AddedToken 或 str 或 tokenizers.AddedToken 的序列) — 僅當詞元不在詞彙表中時才會被新增。tokenizers.AddedToken 包裝了一個字串詞元，允許您自定義其行為：此詞元是否應僅匹配單個單詞、是否應剝離左側所有潛在的空白、是否應剝離右側所有潛在的空白等。
special_tokens (bool, 可選, 預設為 False) — 可用於指定該詞元是否為特殊詞元。這主要改變其歸一化行為（例如，像 CLS 或 [MASK] 這樣的特殊詞元通常不會被轉換為小寫）。

有關 HuggingFace tokenizers 庫中 tokenizers.AddedToken 的詳細資訊，請參閱相關文件。

int

新增到詞彙表中的詞元數量。

注意，向詞彙表新增新詞元時，您應確保也調整模型的詞元嵌入矩陣的大小，使其嵌入矩陣與 tokenizer 匹配。

為此，請使用 resize_token_embeddings() 方法。

示例

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

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

add_special_tokens

( special_tokens_dict: dict replace_additional_special_tokens = True ) → int

引數

special_tokens_dict (str 到 str 的字典, tokenizers.AddedToken, 或 Sequence[Union[str, AddedToken]]) — 鍵應在預定義的特殊屬性列表中：[bos_token, eos_token, unk_token, sep_token, pad_token, cls_token, mask_token, additional_special_tokens]。

僅當詞元不在詞彙表中時才會被新增（透過檢查分詞器是否為它們分配 unk_token 的索引來測試）。
replace_additional_special_tokens (bool, 可選,, 預設為 True) — 如果為 True，現有的額外特殊詞元列表將被 special_tokens_dict 中提供的列表替換。否則，self._special_tokens_map["additional_special_tokens"] 只是被擴充套件。在前一種情況下，這些詞元不會從分詞器的完整詞彙表中移除——它們只是被標記為非特殊詞元。請記住，這隻影響解碼過程中哪些詞元被跳過，而不影響 added_tokens_encoder 和 added_tokens_decoder。這意味著之前的 additional_special_tokens 仍然是已新增的詞元，並且不會被模型分割。

int

新增到詞彙表中的詞元數量。

當向詞彙表新增新標記時，應確保同時調整模型的標記嵌入矩陣的大小，使其嵌入矩陣與分詞器匹配。

為此，請使用 resize_token_embeddings() 方法。

使用 add_special_tokens 將確保您的特殊標記可以透過多種方式使用

使用 skip_special_tokens = True 時，可以在解碼時跳過特殊標記。
特殊標記由分詞器仔細處理（它們永遠不會被拆分），類似於 AddedTokens。
您可以使用分詞器類屬性（如 tokenizer.cls_token）輕鬆引用特殊標記。這使得開發與模型無關的訓練和微調指令碼變得容易。

在可能的情況下，特殊標記已經為提供的預訓練模型註冊（例如 BertTokenizer 的 cls_token 已註冊為 '[CLS]'，XLM 的也已註冊為 '</s>'）。

示例

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

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

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

assert tokenizer.cls_token == "<CLS>"

apply_chat_template

引數

conversation (Union[list[dict[str, str]], list[list[dict[str, str]]]]) — 一個由字典組成的列表，每個字典包含“role”和“content”鍵，代表到目前為止的聊天曆史記錄。
tools (list[Union[Dict, Callable]], 可選) — 一個工具列表（可呼叫函式），模型可以訪問這些工具。如果模板不支援函式呼叫，此引數將無效。每個工具都應以 JSON Schema 的形式傳遞，給出工具的名稱、描述和引數型別。更多資訊請參閱我們的聊天模板指南。
documents (list[dict[str, str]], 可選) — 一個代表文件的字典列表，如果模型正在執行 RAG（檢索增強生成），則可以訪問這些文件。如果模板不支援 RAG，此引數將無效。我們建議每個文件都應是一個包含“title”和“text”鍵的字典。有關透過聊天模板傳遞文件的示例，請參閱聊天模板指南的 RAG 部分。
chat_template (str, 可選) — 用於此轉換的 Jinja 模板。通常不需要向此引數傳遞任何內容，因為預設情況下將使用模型的模板。
add_generation_prompt (bool, 可選) — 如果設定，將在格式化輸出的末尾附加一個提示，該提示包含指示助手訊息開始的詞元。這在您希望模型生成響應時很有用。請注意，此引數將傳遞給聊天模板，因此模板必須支援此引數才能生效。
continue_final_message (bool, 可選) — 如果設定，聊天將被格式化，使得聊天中的最後一條訊息是開放式的，沒有任何 EOS 詞元。模型將繼續這條訊息而不是開始一條新的訊息。這允許您為模型“預填充”部分響應。不能與 add_generation_prompt 同時使用。
tokenize (bool, 預設為 True) — 是否對輸出進行分詞。如果為 False，輸出將是一個字串。
padding (bool, str 或 PaddingStrategy, 可選, 預設為 False) — 選擇一種策略來填充返回的序列（根據模型的填充側和填充索引）：
- True 或 'longest'：填充到批次中最長的序列（如果只提供單個序列則不填充）。
- 'max_length'：填充到由 max_length 引數指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。
- False 或 'do_not_pad' (預設)：不填充（即可以輸出一個包含不同長度序列的批次）。
truncation (bool, 預設為 False) — 是否在最大長度處截斷序列。如果 tokenize 為 False 則無效。
max_length (int, 可選) — 用於填充或截斷的最大長度（以詞元為單位）。如果 tokenize 為 False 則無效。如果未指定，將使用分詞器的 max_length 屬性作為預設值。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回特定框架的張量。如果 tokenize 為 False 則無效。可接受的值有：
- 'tf'：返回 TensorFlow tf.Tensor 物件。
- 'pt'：返回 PyTorch torch.Tensor 物件。
- 'np'：返回 NumPy np.ndarray 物件。
- 'jax'：返回 JAX jnp.ndarray 物件。
return_dict (bool, 預設為 False) — 是否返回一個帶有命名輸出的字典。如果 tokenize 為 False 則無效。
tokenizer_kwargs (dict[str -- Any], 可選): 傳遞給分詞器的額外 kwargs。
return_assistant_tokens_mask (bool, 預設為 False) — 是否返回助手生成詞元的掩碼。對於助手生成的詞元，掩碼將包含 1。對於使用者和系統詞元，掩碼將包含 0。此功能僅在透過 {% generation %} 關鍵字支援它的聊天模板中可用。
**kwargs — 傳遞給模板渲染器的額外 kwargs。聊天模板可以訪問。

Union[list[int], Dict]

batch_decode

引數

sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分詞後的輸入 ID 列表。可以使用 __call__ 方法獲得。
skip_special_tokens (bool, 可選, 預設為 False) — 是否在解碼時移除特殊詞元。
clean_up_tokenization_spaces (bool, 可選) — 是否清理分詞產生的空格。如果為 None，將預設為 self.clean_up_tokenization_spaces。
kwargs (額外的關鍵字引數, 可選) — 將傳遞給底層特定模型的解碼方法。

list[str]

解碼後的句子列表。

透過呼叫 decode 將標記 ID 列表的列表轉換為字串列表。

decode

引數

token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分詞後的輸入 ID 列表。可以使用 __call__ 方法獲得。
skip_special_tokens (bool, 可選, 預設為 False) — 是否在解碼時移除特殊詞元。
clean_up_tokenization_spaces (bool, 可選) — 是否清理分詞產生的空格。如果為 None，將預設為 self.clean_up_tokenization_spaces。
kwargs (額外的關鍵字引數, 可選) — 將傳遞給底層特定模型的解碼方法。

字串

解碼後的句子。

使用分詞器和詞彙表將 ID 序列轉換為字串，可以選擇移除特殊標記並清理分詞空間。

類似於執行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

編碼

引數

text (str, list[str] 或 list[int]) — 要編碼的第一個序列。這可以是一個字串、一個字串列表（使用 tokenize 方法分詞後的字串）或一個整數列表（使用 convert_tokens_to_ids 方法分詞後的字串 ID）。
text_pair (str, list[str] 或 list[int], 可選) — 要編碼的可選第二個序列。這可以是一個字串、一個字串列表（使用 tokenize 方法分詞後的字串）或一個整數列表（使用 convert_tokens_to_ids 方法分詞後的字串 ID）。
add_special_tokens (bool, 可選, 預設為 True) — 是否在編碼序列時新增特殊詞元。這將使用底層的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函式，該函式定義了哪些詞元會自動新增到輸入 ID 中。如果您想自動新增 bos 或 eos 詞元，這很有用。
padding (bool, str 或 PaddingStrategy, 可選, 預設為 False) — 啟用並控制填充。接受以下值：
- True 或 'longest'：填充到批次中最長的序列（如果只提供單個序列，則不進行填充）。
- 'max_length'：填充到由 max_length 引數指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。
- False 或 'do_not_pad' (預設)：不進行填充（即，可以輸出包含不同長度序列的批次）。
truncation (bool, str 或 TruncationStrategy, 可選, 預設為 False) — 啟用並控制截斷。接受以下值：
- True 或 'longest_first'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。這將逐個詞元進行截斷，如果提供了一對序列（或一批序列對），則從最長的序列中移除一個詞元。
- 'only_first'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批序列對），則僅截斷第一個序列。
- 'only_second'：截斷到由 max_length 引數指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批序列對），則僅截斷第二個序列。
- False 或 'do_not_truncate' (預設)：不進行截斷（即，可以輸出序列長度大於模型最大允許輸入大小的批次）。
max_length (int, 可選) — 控制截斷/填充引數使用的最大長度。

如果未設定或設定為 None，並且截斷/填充引數之一需要最大長度，則將使用預定義的模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則將停用截斷/填充到最大長度的功能。
stride (int, 可選, 預設為 0) — 如果與 max_length 一起設定，當 return_overflowing_tokens=True 時返回的溢位詞元將包含一些來自被截斷序列末尾的詞元，以便在被截斷和溢位的序列之間提供一些重疊。此引數的值定義了重疊詞元的數量。
is_split_into_words (bool, 可選, 預設為 False) — 輸入是否已經預分詞（例如，拆分為單詞）。如果設定為 True，分詞器會假定輸入已經被拆分為單詞（例如，透過空格分割），然後對其進行分詞。這對於 NER 或詞元分類任務很有用。
pad_to_multiple_of (int, 可選) — 如果設定，將序列填充到所提供值的倍數。需要啟用 padding。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上使用 Tensor Cores 特別有用。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 ['right', 'left'] 之間選擇。預設值從同名的類屬性中選取。
return_tensors (str 或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：
- 'tf'：返回 TensorFlow tf.constant 物件。
- 'pt'：返回 PyTorch torch.Tensor 物件。
- 'np'：返回 Numpy np.ndarray 物件。
**kwargs — 傳遞給 .tokenize() 方法。

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

文字的分詞後 ID。

使用分詞器和詞彙表將字串轉換為 ID（整數）序列。

與執行 self.convert_tokens_to_ids(self.tokenize(text)) 相同。

push_to_hub

引數

repo_id (str) — 您想要將分詞器推送到的倉庫名稱。當推送到特定組織時，它應包含您的組織名稱。
use_temp_dir (bool, 可選) — 是否使用臨時目錄來儲存在推送到 Hub 之前儲存的檔案。如果沒有名為 repo_id 的目錄，則預設為 True，否則為 False。
commit_message (str, 可選) — 推送時要提交的訊息。將預設為 "Upload tokenizer"。
private (bool, 可選) — 是否將倉庫設為私有。如果為 None (預設)，除非組織的預設設定為私有，否則倉庫將為公開。如果倉庫已存在，則此值將被忽略。
token (bool or str, 可選) — 用於遠端檔案 HTTP 持有者授權的令牌。如果為 True，將使用執行 huggingface-cli login 時生成的令牌（儲存在 ~/.huggingface 中）。如果未指定 repo_url，則預設為 True。
max_shard_size (int or str, 可選, 預設為 "5GB") — 僅適用於模型。在分片前檢查點的最大大小。檢查點分片的大小將小於此大小。如果表示為字串，需要是數字後跟一個單位（如 "5MB"）。我們預設為 "5GB"，以便使用者可以在免費的 Google Colab 例項上輕鬆載入模型，而不會出現任何 CPU OOM 問題。
create_pr (bool, 可選, 預設為 False) — 是為上傳的檔案建立一個 PR 還是直接提交。
safe_serialization (bool, 可選, 預設為 True) — 是否將模型權重轉換為 safetensors 格式以進行更安全的序列化。
revision (str, 可選) — 上傳檔案要推送到的分支。
commit_description (str, 可選) — 將要建立的提交的描述。
tags (list[str], 可選) — 要在 Hub 上推送的標籤列表。

將分詞器檔案上傳到 🤗 Model Hub。

示例

from transformers import AutoTokenizer

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

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

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

convert_ids_to_tokens

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

引數

ids (int or list[int]) — 要轉換為詞元的詞元 ID（或詞元 ID 列表）。
skip_special_tokens (bool, 可選, 預設為 False) — 是否在解碼時移除特殊詞元。

str or list[str]

解碼後的詞符。

使用詞彙表和新增的詞符，將單個索引或索引序列轉換為一個詞符或詞符序列。

convert_tokens_to_ids

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

引數

tokens (str 或 Iterable[str]) — 要轉換為詞元 ID 的一個或多個詞元。

int or list[int]

詞符 ID 或詞符 ID 列表。

使用詞彙表將一個詞元字串（或詞元序列）轉換為單個整數 ID（或 ID 的可迭代物件）。

get_added_vocab

( ) → dict[str, int]

dict[str, int]

新增的詞符。

以詞元到索引的字典形式返回詞彙表中已新增的詞元。

num_special_tokens_to_add

( pair: bool = False ) → int

引數

pair (bool, 可選, 預設為 False) — 已新增詞元的數量是應針對序列對還是單個序列進行計算。

int

新增到序列中的特殊詞符數量。

在使用特殊詞符編碼序列時返回新增的詞符數量。

此方法會對一個虛擬輸入進行編碼並檢查新增的詞符數量，因此效率不高。請勿將其放入您的訓練迴圈中。

set_truncation_and_padding

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

引數

padding_strategy (PaddingStrategy) — 將應用於輸入的填充型別。
truncation_strategy (TruncationStrategy) — 將應用於輸入的截斷型別。
max_length (int) — 序列的最大長度。
stride (int) — 處理溢位時使用的步幅。
pad_to_multiple_of (int, 可選) — 如果設定，將序列填充到所提供值的倍數。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上使用 Tensor Cores 特別有用。
padding_side (str, 可選) — 模型應在其上應用填充的一側。應在 ['right', 'left'] 之間選擇。預設值從同名的類屬性中選取。

為快速分詞器（由 HuggingFace tokenizers 庫提供）定義截斷和填充策略，並在之後恢復分詞器設定。

在託管部分之前，提供的分詞器沒有填充/截斷策略。如果您在之前為分詞器設定了填充/截斷策略，那麼在退出託管部分時，它將被重置為無填充/截斷。

train_new_from_iterator

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

引數

text_iterator (list[str] 的生成器) — 訓練語料庫。應為文字批次的生成器，例如，如果所有內容都在記憶體中，則為文字列表的列表。
vocab_size (int) — 您希望分詞器的詞彙表大小。
length (int, 可選) — 迭代器中序列的總數。這用於提供有意義的進度跟蹤。
new_special_tokens (str 列表或 AddedToken, 可選) — 要新增到您正在訓練的分詞器中的新特殊詞元列表。
special_tokens_map (dict[str, str], 可選) — 如果您想重新命名此分詞器使用的某些特殊詞元，請在此引數中傳遞一個從舊特殊詞元名稱到新特殊詞元名稱的對映。
kwargs (dict[str, Any], 可選) — 傳遞給 🤗 Tokenizers 庫中訓練器的其他關鍵字引數。

PreTrainedTokenizerFast

一個與原始分詞器型別相同的新分詞器，在 text_iterator 上訓練。

在新語料庫上訓練一個分詞器，其預設設定（在特殊詞元或分詞流程方面）與當前分詞器相同。

BatchEncoding

class transformers.BatchEncoding

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

引數

data (dict, 可選) — 由 __call__/encode_plus/batch_encode_plus 方法返回的列表/陣列/張量的字典（'input_ids'、'attention_mask' 等）。
encoding (tokenizers.Encoding 或 Sequence[tokenizers.Encoding], 可選) — 如果分詞器是快速分詞器，它會輸出額外的資訊，如從單詞/字元空間到詞元空間的對映，tokenizers.Encoding 例項或例項列表（用於批處理）持有這些資訊。
tensor_type (Union[None, str, TensorType], 可選) — 您可以在此處提供一個 tensor_type，以在初始化時將整數列表轉換為 PyTorch/TensorFlow/Numpy 張量。
prepend_batch_axis (bool, 可選, 預設為 False) — 在轉換為張量時是否新增批處理軸（請參閱上文的 tensor_type）。請注意，此引數僅在設定了 tensor_type 引數時才生效，否則無效。
n_sequences (Optional[int], 可選) — 你可以在此處指定一個 tensor_type，以便在初始化時將整數列表轉換為 PyTorch/TensorFlow/Numpy 張量。

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

這個類派生自 Python 字典，可以像字典一樣使用。此外，該類還提供了一些實用方法，用於從單詞/字元空間對映到詞元（token）空間。

char_to_token

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

引數

batch_or_char_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中單詞的索引。
char_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中單詞的索引。
sequence_index (int, 可選, 預設為 0) — 如果批處理中編碼了序列對，這可用於指定所提供的字元索引屬於該對中的哪個序列（0 或 1）。

int

詞元（token）的索引，如果字元索引指向一個僅包含空白字元的詞元且空白字元被 `trim_offsets=True` 裁剪，則返回 None。

獲取編碼輸出中包含原始字串中某個字元的詞元（token）的索引，該字元對應批處理中的一個序列。

可以這樣呼叫

如果批處理大小為 1，則為 `self.char_to_token(char_index)`
如果批處理大小大於或等於 1，則為 `self.char_to_token(batch_index, char_index)`

此方法特別適用於當輸入序列是預分詞序列（即單詞由使用者定義）的情況。在這種情況下，它可以輕鬆地將編碼後的詞元與提供的分詞後的單詞關聯起來。

char_to_word

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

引數

batch_or_char_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是原始字串中字元的索引。
char_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是原始字串中字元的索引。
sequence_index (int, 可選, 預設為 0) — 如果批處理中編碼了序列對，這可用於指定所提供的字元索引屬於該對中的哪個序列（0 或 1）。

int or list[int]

相關編碼詞元（token）的索引或索引列表。

獲取原始字串中與批處理序列中某個字元對應的單詞。

可以這樣呼叫

如果批處理大小為 1，則為 `self.char_to_word(char_index)`
如果批處理大小大於 1，則為 `self.char_to_word(batch_index, char_index)`

convert_to_tensors

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

引數

tensor_type (str 或 TensorType, 可選) — 要使用的張量型別。如果為 `str`，應為列舉 TensorType 的值之一。如果為 `None`，則不進行任何修改。
prepend_batch_axis (int, 可選, 預設為 False) — 在轉換過程中是否新增批處理維度。

將內部內容轉換為張量。

sequence_ids

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

引數

batch_index (int, 可選, 預設為 0) — 要在批處理中訪問的索引。

list[Optional[int]]

一個指示每個詞元（token）對應序列 ID 的列表。分詞器新增的特殊詞元對映為 `None`，其他詞元對映為其對應序列的索引。

返回一個將詞元對映到其原始句子 ID 的列表。

對於在序列周圍或之間新增的特殊詞元，返回 `None`
對於對應第一個序列中單詞的詞元，返回 `0`
當一對序列被聯合編碼時，對於對應第二個序列中單詞的詞元，返回 `1`

到

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

引數

device (str 或 torch.device) — 要放置張量的裝置。
non_blocking (bool) — 是否非同步執行復制。

BatchEncoding

修改後的同一例項。

透過呼叫 `v.to(device, non_blocking=non_blocking)` 將所有值傳送到裝置（僅限 PyTorch）。

token_to_chars

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

引數

batch_or_token_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中詞元（token）的索引。
token_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中詞元（token）或詞元列表的索引。

CharSpan

原始字串中的字元範圍，如果詞元（例如、）不對應原始字串中的任何字元，則為 None。

獲取批處理序列中與編碼詞元（token）相對應的字元範圍。

字元範圍以 CharSpan 的形式返回，包含

start — 與詞元（token）關聯的原始字串中第一個字元的索引。
end — 與詞元（token）關聯的原始字串中最後一個字元之後的字元索引。

可以這樣呼叫

如果批處理大小為 1，則為 `self.token_to_chars(token_index)`
如果批處理大小大於或等於 1，則為 `self.token_to_chars(batch_index, token_index)`

token_to_sequence

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

引數

batch_or_token_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中詞元（token）的索引。
token_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中詞元（token）的索引。

int

輸入序列中單詞的索引。

獲取由給定詞元（token）表示的序列的索引。在一般情況下，對於單個序列或序列對的第一個序列，此方法返回 `0`；對於序列對的第二個序列，返回 `1`。

可以這樣呼叫

如果批處理大小為 1，則為 `self.token_to_sequence(token_index)`
如果批處理大小大於 1，則為 `self.token_to_sequence(batch_index, token_index)`

此方法特別適用於當輸入序列是預分詞序列（即，單詞由使用者定義）的情況。在這種情況下，它可以輕鬆地將編碼後的詞元與提供的分詞後的單詞關聯起來。

token_to_word

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

引數

batch_or_token_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中詞元（token）的索引。
token_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中詞元（token）的索引。

int

輸入序列中單詞的索引。

獲取批處理序列中與編碼詞元（token）對應的單詞（即包含該詞元）的索引。

可以這樣呼叫

如果批處理大小為 1，則為 `self.token_to_word(token_index)`
如果批處理大小大於 1，則為 `self.token_to_word(batch_index, token_index)`

tokens

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

引數

batch_index (int, 可選, 預設為 0) — 要在批處理中訪問的索引。

list[str]

該索引處的詞元（token）列表。

返回給定批處理索引處的詞元（token）列表（輸入字串在經過詞/子詞切分後、轉換為整數索引前的子部分）（僅適用於快速分詞器的輸出）。

word_ids

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

引數

batch_index (int, 可選, 預設為 0) — 要在批處理中訪問的索引。

list[Optional[int]]

一個指示每個詞元（token）對應單詞的列表。分詞器新增的特殊詞元對映為 `None`，其他詞元對映為其對應單詞的索引（如果它們是該單詞的一部分，則多個詞元將對映到同一個單詞索引）。

對於快速分詞器，返回一個將詞元對映到其在初始句子中實際單詞的列表。

word_to_chars

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

引數

batch_or_word_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中單詞的索引。
word_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中單詞的索引。
sequence_index (int, 可選, 預設為 0) — 如果批處理中編碼了序列對，這可用於指定所提供的單詞索引屬於該對中的哪個序列（0 或 1）。

CharSpan 或 list[CharSpan]

字串中相關字元或字元集的範圍。CharSpan 是 NamedTuple，包含：

start: 原始字串中與詞元（token）關聯的第一個字元的索引
end: 原始字串中與詞元（token）關聯的最後一個字元之後的字元索引

獲取批處理序列中給定單詞在原始字串中對應的字元範圍。

字元範圍以 CharSpan NamedTuple 的形式返回，包含：

start: 原始字串中第一個字元的索引
end: 原始字串中最後一個字元之後的字元索引

可以這樣呼叫

如果批處理大小為 1，則為 `self.word_to_chars(word_index)`
如果批處理大小大於或等於 1，則為 `self.word_to_chars(batch_index, word_index)`

word_to_tokens

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

引數

batch_or_word_index (int) — 批處理中序列的索引。如果批處理僅包含一個序列，則這可以是序列中單詞的索引。
word_index (int, 可選) — 如果在 *batch_or_token_index* 中提供了批處理索引，則這可以是序列中單詞的索引。
sequence_index (int, 可選, 預設為 0) — 如果批處理中編碼了序列對，這可用於指定所提供的單詞索引屬於該對中的哪個序列（0 或 1）。

(TokenSpan, 可選)

編碼序列中的詞元（token）範圍。如果沒有詞元對應於該單詞，則返回 `None`。這種情況尤其可能發生在當詞元是用於格式化分詞的特殊詞元時。例如，當我們在分詞的最開始新增一個類別詞元時。

獲取批處理序列中與一個單詞相對應的編碼詞元（token）範圍。

詞元（token）範圍以 TokenSpan 的形式返回，包含

start — 第一個詞元（token）的索引。
end — 最後一個詞元（token）之後的詞元索引。

可以這樣呼叫

如果批處理大小為 1，則為 `self.word_to_tokens(word_index, sequence_index: int = 0)`
如果批處理大小大於或等於 1，則為 `self.word_to_tokens(batch_index, word_index, sequence_index: int = 0)`

words