Transformers 文件
XLNet
並獲得增強的文件體驗
開始使用
XLNet
概述
XLNet 模型由 Zhilin Yang、Zihang Dai、Yiming Yang、Jaime Carbonell、Ruslan Salakhutdinov 和 Quoc V. Le 在 XLNet: Generalized Autoregressive Pretraining for Language Understanding 中提出。XLNet 是 Transformer-XL 模型的擴充套件，使用自迴歸方法進行預訓練，透過最大化輸入序列分解順序的所有排列的預期似然來學習雙向上下文。
論文摘要如下：
基於去噪自編碼的預訓練方法（如 BERT）具有建模雙向上下文的能力，因此其效能優於基於自迴歸語言建模的預訓練方法。然而，BERT 依賴於用掩碼破壞輸入，忽略了掩碼位置之間的依賴關係，並存在預訓練-微調不匹配的問題。鑑於這些優缺點，我們提出了 XLNet，一種廣義自迴歸預訓練方法，它 (1) 透過最大化分解順序的所有排列的預期似然來學習雙向上下文，並且 (2) 由於其自迴歸公式，克服了 BERT 的侷限性。此外，XLNet 將 Transformer-XL（最先進的自迴歸模型）的思想整合到預訓練中。經驗證明，在可比較的實驗設定下，XLNet 在 20 項任務中（包括問答、自然語言推理、情感分析和文件排序）的效能均優於 BERT，通常是大幅超越。
使用技巧
- 特定的注意力模式可以在訓練和測試時使用
perm_mask輸入進行控制。 - 由於在各種分解順序上訓練一個完全自迴歸模型存在困難，XLNet 僅使用部分輸出 token 作為目標進行預訓練，這些 token 是透過
target_mapping輸入選擇的。 - 要將 XLNet 用於順序解碼（即非完全雙向設定），請使用
perm_mask和target_mapping輸入來控制注意力範圍和輸出（請參閱 *examples/pytorch/text-generation/run_generation.py* 中的示例） - XLNet 是少數沒有序列長度限制的模型之一。
- XLNet 不是傳統的自迴歸模型，但它使用了一種基於此的訓練策略。它會對句子中的 token 進行排列，然後允許模型使用最後 n 個 token 來預測第 n+1 個 token。由於所有這些都是透過掩碼完成的，因此句子實際上是按正確順序輸入到模型中的，但 XLNet 不會掩蓋前 n 個 token 以預測 n+1，而是使用一個掩碼來隱藏給定排列 1, ..., 序列長度中前面的 token。
- XLNet 還使用與 Transformer-XL 相同的迴圈機制來建立長期依賴關係。
資源
XLNetConfig
class transformers.XLNetConfig
< 來源 >( vocab_size = 32000 d_model = 1024 n_layer = 24 n_head = 16 d_inner = 4096 ff_activation = 'gelu' untie_r = True attn_type = 'bi' initializer_range = 0.02 layer_norm_eps = 1e-12 dropout = 0.1 mem_len = 512 reuse_len = None use_mems_eval = True use_mems_train = False bi_data = False clamp_len = -1 same_length = False summary_type = 'last' summary_use_proj = True summary_activation = 'tanh' summary_last_dropout = 0.1 start_n_top = 5 end_n_top = 5 pad_token_id = 5 bos_token_id = 1 eos_token_id = 2 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 32000) — XLNet 模型的詞彙表大小。定義了呼叫 XLNetModel 或 TFXLNetModel 時傳遞的inputs_ids可以表示的不同 token 的數量。 - d_model (
int, 可選, 預設為 1024) — 編碼器層和池化器層的維度。 - n_layer (
int, 可選, 預設為 24) — Transformer 編碼器中的隱藏層數量。 - n_head (
int, 可選, 預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。 - d_inner (
int, 可選, 預設為 4096) — Transformer 編碼器中“中間”（通常稱為前饋）層的維度。 - ff_activation (
str或Callable, 可選, 預設為"gelu") — 非線性啟用函式（函式或字串）。如果是字串，支援"gelu"、"relu"、"silu"和"gelu_new"。 - untie_r (
bool, 可選, 預設為True) — 是否取消相對位置偏差的繫結。 - attn_type (
str, 可選, 預設為"bi") — 模型使用的注意力型別。XLNet 設定為"bi"，Transformer-XL 設定為"uni"。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態分佈初始化器的標準差。 - layer_norm_eps (
float, 可選, 預設為 1e-12) — 層歸一化層使用的 epsilon 值。 - dropout (
float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化器中所有全連線層的 dropout 機率。 - mem_len (
int或None, 可選) — 快取的 token 數量。在之前的正向傳播中已經預計算的鍵/值對不會重新計算。有關更多資訊，請參閱快速入門。 - reuse_len (
int, 可選) — 當前批次中要快取並在將來重用的 token 數量。 - bi_data (
bool, 可選, 預設為False) — 是否使用雙向輸入管道。通常在預訓練期間設定為True，在微調期間設定為False。 - clamp_len (
int, 可選, 預設為 -1) — 限制所有相對距離大於 clamp_len。將此屬性設定為 -1 表示不進行限制。 - same_length (
bool, 可選, 預設為False) — 是否對每個 token 使用相同的注意力長度。 - summary_type (
str, 可選, 預設為 “last”) — 序列摘要時使用的引數。在序列分類和多項選擇模型中使用。必須是以下選項之一：
"last"：取最後一個 token 的隱藏狀態（如 XLNet）。"first"：取第一個 token 的隱藏狀態（如 BERT）。"mean"：取所有 token 隱藏狀態的平均值。"cls_index"：提供分類 token 位置的張量（如 GPT/GPT-2）。"attn"：目前未實現，使用多頭注意力。
- summary_use_proj (
bool, 可選, 預設為True) — 序列摘要時使用的引數。在序列分類和多項選擇模型中使用。向量提取後是否新增投影。
- summary_activation (
str, 可選) — 序列摘要時使用的引數。在序列分類和多項選擇模型中使用。如果輸出需要 tanh 啟用，則傳遞
"tanh"，任何其他值將導致沒有啟用。 - summary_proj_to_labels (
boo, 可選, 預設為True) — 在序列分類和多項選擇模型中使用。投影輸出應具有
config.num_labels或config.hidden_size類。 - summary_last_dropout (
float, 可選, 預設為 0.1) — 在序列分類和多項選擇模型中使用。投影和啟用後使用的 dropout 比率。
- start_n_top (
int, 可選, 預設為 5) — 在 SQuAD 評估指令碼中使用。 - end_n_top (
int, 可選, 預設為 5) — 用於 SQuAD 評估指令碼中。 - use_mems_eval (
bool, 可選, 預設為True) — 模型在評估模式下是否使用迴圈記憶機制。 - use_mems_train (
bool, 可選, 預設為False) — 模型在訓練模式下是否使用迴圈記憶機制。對於預訓練，建議將
use_mems_train設定為True。對於微調，建議將use_mems_train設定為False，如 此處 所述。如果use_mems_train設定為True，則必須確保訓練批次已正確預處理，例如batch_1 = [[This line is], [This is the]]和batch_2 = [[ the first line], [ second line]]，並且所有批次的大小都相等。
這是一個配置類，用於儲存 XLNetModel 或 TFXLNetModel 的配置。它用於根據指定的引數例項化 XLNet 模型，定義模型架構。使用預設值例項化配置將產生類似於 xlnet/xlnet-large-cased 架構的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關這些方法的更多資訊，請參閱 PretrainedConfig 的文件。
示例
>>> from transformers import XLNetConfig, XLNetModel
>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXLNetTokenizer
類 transformers.XLNetTokenizer
< 來源 >( vocab_file do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None **kwargs )
引數
- vocab_file (
str) — SentencePiece 檔案（通常以 .spm 副檔名結尾），包含例項化分詞器所需的詞彙表。 - do_lower_case (
bool, 可選, 預設為False) — 分詞時是否將輸入轉換為小寫。 - remove_space (
bool, 可選, 預設為True) — 分詞時是否去除文字中的空格（刪除字串前後多餘的空格）。 - keep_accents (
bool, 可選, 預設為False) — 分詞時是否保留重音符號。 - bos_token (
str, 可選, 預設為"<s>") — 預訓練期間使用的序列開始符。可用作序列分類標記。使用特殊標記構建序列時，這不是序列開頭使用的標記。使用的標記是
cls_token。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束符。使用特殊標記構建序列時，這不是序列結尾使用的標記。使用的標記是
sep_token。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記不能轉換為 ID，而是設定為此標記。 - sep_token (
str, 可選, 預設為"<sep>") — 分隔符標記，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的標記，例如在對不同長度的序列進行批處理時。 - cls_token (
str, 可選, 預設為"<cls>") — 分類器標記，用於序列分類（對整個序列進行分類而非按標記分類）。它是使用特殊標記構建的序列的第一個標記。 - mask_token (
str, 可選, 預設為"<mask>") — 用於遮蓋值的標記。這是使用遮蓋語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - additional_special_tokens (
list[str], 可選, 預設為['<eop>', '<eod>']) — 分詞器使用的附加特殊標記。 - sp_model_kwargs (
dict, 可選) — 將傳遞給SentencePieceProcessor.__init__()方法。可用於設定 SentencePiece 的 Python 包裝器，其中包括：-
enable_sampling: 啟用子詞正則化。 -
nbest_size: Unigram 的取樣引數。對於 BPE-Dropout 無效。nbest_size = {0,1}: 不執行取樣。nbest_size > 1: 從 nbest_size 結果中取樣。nbest_size < 0: 假設 nbest_size 無限，並使用前向濾波和後向取樣演算法從所有假設（格）中取樣。
-
alpha: Unigram 取樣的平滑引數，以及 BPE-dropout 中合併操作的 dropout 機率。
-
- sp_model (
SentencePieceProcessor) — 用於所有轉換（字串、標記和 ID）的 SentencePiece 處理器。
構建 XLNet 分詞器。基於 SentencePiece。
此分詞器繼承自 PreTrainedTokenizer，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過拼接和新增特殊標記，從序列或序列對構建用於序列分類任務的模型輸入。XLNet 序列具有以下格式
- 單個序列：
X <sep> <cls> - 序列對：
A <sep> B <sep> <cls>
get_special_tokens_mask
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳遞的兩個序列建立用於序列對分類任務的掩碼。一個 XLNet
如果 token_ids_1 為 None，則此方法僅返回掩碼的第一部分（0s）。
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence | second sequence |如果 token_ids_1 為 None，則此方法僅返回掩碼的第一部分（0s）。
XLNetTokenizerFast
類 transformers.XLNetTokenizerFast
< 來源 >( vocab_file = None tokenizer_file = None do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] **kwargs )
引數
- vocab_file (
str) — SentencePiece 檔案（通常以 .spm 副檔名結尾），包含例項化分詞器所需的詞彙表。 - do_lower_case (
bool, 可選, 預設為True) — 分詞時是否將輸入轉換為小寫。 - remove_space (
bool, 可選, 預設為True) — 分詞時是否去除文字中的空格（刪除字串前後多餘的空格）。 - keep_accents (
bool, 可選, 預設為False) — 分詞時是否保留重音符號。 - bos_token (
str, 可選, 預設為"<s>") — 預訓練期間使用的序列開始符。可用作序列分類標記。使用特殊標記構建序列時，這不是序列開頭使用的標記。使用的標記是
cls_token。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束符。使用特殊標記構建序列時，這不是序列結尾使用的標記。使用的標記是
sep_token。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記不能轉換為 ID，而是設定為此標記。 - sep_token (
str, 可選, 預設為"<sep>") — 分隔符標記，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的標記，例如在對不同長度的序列進行批處理時。 - cls_token (
str, 可選, 預設為"<cls>") — 分類器標記，用於序列分類（對整個序列進行分類而非按標記分類）。它是使用特殊標記構建的序列的第一個標記。 - mask_token (
str, 可選, 預設為"<mask>") — 用於遮蓋值的標記。這是使用遮蓋語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - additional_special_tokens (
list[str], 可選, 預設為["<eop>", "<eod>"]) — 分詞器使用的附加特殊標記。 - sp_model (
SentencePieceProcessor) — 用於所有轉換（字串、標記和 ID）的 SentencePiece 處理器。
構建一個“快速”XLNet 分詞器（由 HuggingFace 的 tokenizers 庫支援）。基於 Unigram。
此分詞器繼承自 PreTrainedTokenizerFast，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過拼接和新增特殊標記，從序列或序列對構建用於序列分類任務的模型輸入。XLNet 序列具有以下格式
- 單個序列：
X <sep> <cls> - 序列對：
A <sep> B <sep> <cls>
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳遞的兩個序列建立用於序列對分類任務的掩碼。一個 XLNet
如果 token_ids_1 為 None，則此方法僅返回掩碼的第一部分（0s）。
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence | second sequence |如果 token_ids_1 為 None，則此方法僅返回掩碼的第一部分（0s）。
XLNet 特定輸出
類 transformers.models.xlnet.modeling_xlnet.XLNetModelOutput
< 來源 >( last_hidden_state: FloatTensor mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- last_hidden_state (形狀為
(batch_size, num_predict, hidden_size)的torch.FloatTensor) — 模型最後一層的隱藏狀態序列。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetModel 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape (1,), 可選, 當提供labels時返回) — 語言模型損失（用於下一個token預測）。 - logits (
torch.FloatTensorof shape(batch_size, num_predict, config.vocab_size)) — 語言模型頭的預測分數（SoftMax之前的每個詞彙token的分數）。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetLMHeadModel 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), 可選, 當提供label時返回) — 分類（如果config.num_labels==1則為迴歸）損失。 - logits (
torch.FloatTensorof shape(batch_size, config.num_labels)) — 分類（如果config.num_labels==1則為迴歸）分數（SoftMax之前）。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetForSequenceClassification 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape (1,), 可選, 當提供labels時返回) — 分類損失。 - logits (
torch.FloatTensorof shape(batch_size, num_choices)) — num_choices 是輸入張量的第二個維度。（請參見上面的 input_ids）。分類分數（SoftMax之前）。
- mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetForMultipleChoice 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 分類損失。 - logits (
torch.FloatTensorof shape(batch_size, sequence_length, config.num_labels)) — 分類分數（SoftMax之前）。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetForTokenClassificationOutput 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總跨度提取損失是開始和結束位置的交叉熵損失之和。 - start_logits (
torch.FloatTensorof shape(batch_size, sequence_length,)) — 跨度起始分數（SoftMax之前）。 - end_logits (
torch.FloatTensorof shape(batch_size, sequence_length,)) — 跨度結束分數（SoftMax之前）。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetForQuestionAnsweringSimple 的輸出型別。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_top_log_probs: typing.Optional[torch.FloatTensor] = None start_top_index: typing.Optional[torch.LongTensor] = None end_top_log_probs: typing.Optional[torch.FloatTensor] = None end_top_index: typing.Optional[torch.LongTensor] = None cls_logits: typing.Optional[torch.FloatTensor] = None mems: typing.Optional[list[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), 可選, 當同時提供start_positions和end_positions時返回) — 分類損失，為起始token、結束token（如果提供則包括impossible）分類損失之和。 - start_top_log_probs (
torch.FloatTensorof shape(batch_size, config.start_n_top), 可選, 當未提供start_positions或end_positions時返回) — 最優config.start_n_top個起始token可能性的對數機率（束搜尋）。 - start_top_index (
torch.LongTensorof shape(batch_size, config.start_n_top), 可選, 當未提供start_positions或end_positions時返回) — 最優config.start_n_top個起始token可能性的索引（束搜尋）。 - end_top_log_probs (
torch.FloatTensorof shape(batch_size, config.start_n_top * config.end_n_top), 可選, 當未提供start_positions或end_positions時返回) — 最優config.start_n_top * config.end_n_top個結束token可能性的對數機率（束搜尋）。 - end_top_index (
torch.LongTensorof shape(batch_size, config.start_n_top * config.end_n_top), 可選, 當未提供start_positions或end_positions時返回) — 最優config.start_n_top * config.end_n_top個結束token可能性的索引（束搜尋）。 - cls_logits (
torch.FloatTensorof shape(batch_size,), 可選, 當未提供start_positions或end_positions時返回) — 答案的is_impossible標籤的對數機率。 - mems (
list[torch.FloatTensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及可選的初始嵌入輸出。
- attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
XLNetForQuestionAnswering 的輸出型別。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput
< source >( last_hidden_state: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- last_hidden_state (
tf.Tensorof shape(batch_size, num_predict, hidden_size)) — 模型最後一層的隱藏狀態序列。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 - mems (
list[tf.Tensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) —tf.Tensor的元組（其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態，以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —tf.Tensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax後的注意力權重，用於計算自注意力頭中的加權平均。
TFXLNetModel 的輸出型別。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensorof shape (1,), 可選, 當提供labels時返回) — 語言模型損失（用於下一個token預測）。 - logits (
tf.Tensorof shape(batch_size, num_predict, config.vocab_size)) — 語言模型頭的預測分數（SoftMax之前的每個詞彙token的分數）。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 - mems (
list[tf.Tensor]of lengthconfig.n_layers) — 包含預先計算的隱藏狀態。可用於（參閱mems輸入）加速順序解碼。已提供給此模型的歷史令牌ID不應作為input_ids傳入，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), optional, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層的輸出+每個層的輸出各一個）。模型在每個層輸出的隱藏狀態以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), optional, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。在注意力softmax之後，用於計算自注意力頭中的加權平均值的注意力權重。
TFXLNetLMHeadModel的輸出型別。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (形狀為
(1,)的tf.Tensor, optional, 當提供label時返回) — 分類（如果config.num_labels==1則是迴歸）損失。 - logits (形狀為
(batch_size, config.num_labels)的tf.Tensor) — 分類（如果config.num_labels==1則是迴歸）得分（在SoftMax之前）。 - mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), optional, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層的輸出+每個層的輸出各一個）。模型在每個層輸出的隱藏狀態以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), optional, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。在注意力softmax之後，用於計算自注意力頭中的加權平均值的注意力權重。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (形狀為(1,)的
tf.Tensor, optional, 當提供labels時返回) — 分類損失。 - logits (形狀為
(batch_size, num_choices)的tf.Tensor) — num_choices是輸入張量的第二維。（參見上面的input_ids）。分類得分（在SoftMax之前）。
- mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), optional, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層的輸出+每個層的輸出各一個）。模型在每個層輸出的隱藏狀態以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), optional, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。在注意力softmax之後，用於計算自注意力頭中的加權平均值的注意力權重。
TFXLNetForMultipleChoice的輸出型別。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (形狀為
(1,)的tf.Tensor, optional, 當提供labels時返回) — 分類損失。 - logits (形狀為
(batch_size, sequence_length, config.num_labels)的tf.Tensor) — 分類得分（在SoftMax之前）。 - mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), optional, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層的輸出+每個層的輸出各一個）。模型在每個層輸出的隱藏狀態以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), optional, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。在注意力softmax之後，用於計算自注意力頭中的加權平均值的注意力權重。
TFXLNetForTokenClassificationOutput的輸出型別。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput
< source >( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[tf.Tensor] = None mems: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (形狀為
(1,)的tf.Tensor, optional, 當提供labels時返回) — 總範圍提取損失是起始和結束位置的交叉熵之和。 - start_logits (形狀為
(batch_size, sequence_length,)的tf.Tensor) — 起始範圍得分（在SoftMax之前）。 - end_logits (形狀為
(batch_size, sequence_length,)的tf.Tensor) — 結束範圍得分（在SoftMax之前）。 - mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 - hidden_states (
tuple(tf.Tensor), optional, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層的輸出+每個層的輸出各一個）。模型在每個層輸出的隱藏狀態以及初始嵌入輸出。
- attentions (
tuple(tf.Tensor), optional, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。在注意力softmax之後，用於計算自注意力頭中的加權平均值的注意力權重。
XLNetModel
class transformers.XLNetModel
< source >( config )
引數
- config (XLNetModel) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法來載入模型權重。
裸XLNet模型，輸出原始隱藏狀態，頂部沒有任何特定頭部。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。索引可以使用AutoTokenizer獲取。有關詳細資訊，請參見PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 掩碼，用於避免在填充令牌索引上執行注意力。掩碼值選擇在[0, 1]之間：- 1表示未被掩蓋的令牌，
- 0表示被掩蓋的令牌。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示每個輸入令牌的注意力模式，值為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則批處理k中的i關注j； - 如果
perm_mask[k, i, j] = 1，則批處理k中的i不關注j。
如果未設定，則每個令牌關注所有其他令牌（完全雙向注意力）。僅在預訓練期間（用於定義因子分解順序）或用於順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示要使用的輸出令牌。如果target_mapping[k, i, j] = 1，則批處理k中的第i個預測在第j個令牌上。僅在預訓練期間用於部分預測或用於順序解碼（生成）時使用。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 分段令牌索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]之間：- 0對應於句子A令牌，
- 1對應於句子B令牌。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor, 可選) — 掩碼，用於避免在填充令牌索引上執行注意力。attention_mask的負值，即真實令牌為0，填充為1，為了與原始程式碼庫相容而保留。掩碼值選擇在
[0, 1]之間：- 1表示被掩蓋的令牌，
- 0表示未被掩蓋的令牌。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor, 可選) — 掩碼，用於將自注意力模組的選定頭部置零。掩碼值選擇在[0, 1]之間：- 1表示頭部未被掩蓋，
- 0表示頭部被掩蓋。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.Tensor, 可選) — 可選地，您可以直接傳遞嵌入表示，而不是傳遞input_ids。如果您想對如何將input_ids索引轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - use_mems (
bool, 可選) — 是否使用記憶狀態來加速順序解碼。如果設定為True，模型將使用先前前向傳播中的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參見返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是純元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetModelOutput 或 tuple(torch.FloatTensor)
一個transformers.models.xlnet.modeling_xlnet.XLNetModelOutput或一個torch.FloatTensor元組（如果傳入return_dict=False或config.return_dict=False時），包含根據配置（XLNetConfig）和輸入的不同元素。
-
last_hidden_state (形狀為
(batch_size, num_predict, hidden_size)的torch.FloatTensor) — 模型最後一層的隱藏狀態序列。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetModel前向傳播方法，覆蓋了__call__特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
XLNetLMHeadModel
class transformers.XLNetLMHeadModel
< source >( config )
引數
- config (XLNetLMHeadModel) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法來載入模型權重。
XLNet模型，頂部帶有一個語言建模頭（與輸入嵌入繫結的線性層）。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput or tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇在[0, 1]中:- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將其過去值傳遞給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示每個輸入 token 的注意力模式，值選擇在[0, 1]中:- 如果
perm_mask[k, i, j] = 0，則批次 k 中 i 對 j 執行注意力操作； - 如果
perm_mask[k, i, j] = 1，則批次 k 中 i 不對 j 執行注意力操作。
如果未設定，每個 token 都將對所有其他 token 執行注意力操作（完全雙向注意力）。僅在預訓練期間（用於定義因子分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示要使用的輸出 token。如果target_mapping[k, i, j] = 1，則批次 k 中的第 i 個預測對應第 j 個 token。僅在預訓練期間（用於部分預測）或順序解碼（生成）時使用。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]中:- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫相容。掩碼值選擇在
[0, 1]中:- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor, 可選) — 掩碼，用於使自注意力模組的選定頭部無效。掩碼值選擇在[0, 1]中:- 1 表示頭部 未被掩蓋，
- 0 表示頭部 被掩蓋。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.Tensor, 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制權，則這會很有用。 - labels (形狀為
(batch_size, num_predict)的torch.LongTensor, 可選) — 掩碼語言建模的標籤。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。標籤應與應預測的掩碼輸入詞對應，並取決於
target_mapping。請注意，為了執行標準自迴歸語言建模，必須將一個token 新增到 input_ids（請參閱下面的prepare_inputs_for_generation函式和示例）索引選擇在
[-100, 0, ..., config.vocab_size]中。所有設定為-100的標籤都將被忽略，損失僅針對[0, ..., config.vocab_size]中的標籤計算。 - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用先前正向傳遞的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參見返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput 或 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (形狀為 (1,) 的
torch.FloatTensor, 可選, 當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, num_predict, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（每個詞彙 token 在 SoftMax 之前的分數）。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetLMHeadModel 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
... :, :, -1
... ] = 1.0 # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
... outputs.logits
... ) # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]XLNetForSequenceClassification
類 transformers.XLNetForSequenceClassification
< source >( config )
引數
- config (XLNetForSequenceClassification) — 具有模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，僅載入配置。檢視 from_pretrained() 方法以載入模型權重。
XLNet 模型，其頂部帶有一個序列分類/迴歸頭部（在池化輸出頂部的一個線性層），例如用於 GLUE 任務。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇在[0, 1]中:- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將其過去值傳遞給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示每個輸入 token 的注意力模式，值選擇在[0, 1]中:- 如果
perm_mask[k, i, j] = 0，則批次 k 中 i 對 j 執行注意力操作； - 如果
perm_mask[k, i, j] = 1，則批次 k 中 i 不對 j 執行注意力操作。
如果未設定，每個 token 都將對所有其他 token 執行注意力操作（完全雙向注意力）。僅在預訓練期間（用於定義因子分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示要使用的輸出 token。如果target_mapping[k, i, j] = 1，則批次 k 中的第 i 個預測對應第 j 個 token。僅在預訓練期間（用於部分預測）或順序解碼（生成）時使用。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]中:- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor, 可選) — 掩碼，用於避免對填充 token 索引執行注意力操作。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫相容。掩碼值選擇在
[0, 1]中:- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor, 可選) — 掩碼，用於使自注意力模組的選定頭部無效。掩碼值選擇在[0, 1]中:- 1 表示頭部 未被掩蓋，
- 0 表示頭部 被掩蓋。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.Tensor, 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制權，則這會很有用。 - labels (形狀為
(batch_size,)的torch.LongTensor, 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失）；如果config.num_labels > 1，則計算分類損失（交叉熵）。 - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用先前正向傳遞的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參見返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供label時返回) — 分類 (如果 config.num_labels==1 則為迴歸) 損失。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained(
... "xlnet/xlnet-large-cased", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossXLNetForMultipleChoice
類 transformers.XLNetForMultipleChoice
< source >( config )
引數
- config (XLNetForMultipleChoice) — 具有模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，僅載入配置。檢視 from_pretrained() 方法以載入模型權重。
Xlnet 模型，其頂部帶有一個多項選擇分類頭部（在池化輸出頂部的一個線性層和一個 softmax），例如用於 RocStories/SWAG 任務。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< source >( input_ids: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, num_choices, sequence_length)的torch.LongTensor) — 詞彙表中輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- token_type_ids (形狀為
(batch_size, num_choices, sequence_length)的torch.LongTensor, 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]中:- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
- input_mask (形狀為
batch_size, num_choices, sequence_length的torch.FloatTensor, 可選) — 掩碼，用於避免對填充 token 索引執行注意力操作。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫相容。掩碼值選擇在
[0, 1]中:- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇在[0, 1]中:- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將其過去值傳遞給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示每個輸入 token 的注意力模式，值選擇在[0, 1]中:- 如果
perm_mask[k, i, j] = 0，則批次 k 中 i 對 j 執行注意力操作； - 如果
perm_mask[k, i, j] = 1，則批次 k 中 i 不對 j 執行注意力操作。
如果未設定，每個 token 都將對所有其他 token 執行注意力操作（完全雙向注意力）。僅在預訓練期間（用於定義因子分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可選) — 掩碼，用於指示要使用的輸出 token。如果target_mapping[k, i, j] = 1，則批次 k 中的第 i 個預測對應第 j 個 token。僅在預訓練期間（用於部分預測）或順序解碼（生成）時使用。 - head_mask (
torch.Tensorof shape(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇在[0, 1]之間：- 1 表示頭 未被掩碼,
- 0 表示頭 被掩碼.
- inputs_embeds (
torch.FloatTensorof shape(batch_size, num_choices, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量進行比模型內部嵌入查詢矩陣更精細的控制，這會很有用。 - labels (
torch.LongTensorof shape(batch_size,), 可選) — 用於計算多項選擇分類損失的標籤。索引應在 `[0, ..., - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用先前正向傳播中的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或當 config.return_dict=False 時），其中包含根據配置 (XLNetConfig) 和輸入的不同元素。
-
loss (形狀為 (1,) 的
torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, num_choices)的torch.FloatTensor) — num_choices 是輸入張量的第二維大小。（請參閱上面的 input_ids）。分類分數（SoftMax 之前）。
-
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetForMultipleChoice 的 forward 方法，它重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, XLNetForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsXLNetForTokenClassification
類 transformers.XLNetForTokenClassification
< 來源 >( config )
引數
- config (XLNetForTokenClassification) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Xlnet transformer，頂部帶有令牌分類頭（隱藏狀態輸出頂部的一個線性層），例如用於命名實體識別 (NER) 任務。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 詞彙表中輸入序列令牌的索引。預設情況下會忽略填充。索引可以使用 AutoTokenizer 獲得。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 用於避免在填充令牌索引上執行注意力的掩碼。掩碼值選擇在[0, 1]之間：- 1 表示 未被掩碼 的令牌,
- 0 表示 被掩碼 的令牌.
- mems (
list[torch.FloatTensor]，長度為config.n_layers) — 包含預計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將其過去值傳遞給此模型的令牌 ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (
torch.FloatTensorof shape(batch_size, sequence_length, sequence_length), 可選) — 用於指示每個輸入令牌的注意力模式的掩碼，值選擇在[0, 1]之間：- 如果
perm_mask[k, i, j] = 0，則批處理 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批處理 k 中的 i 不注意 j。
如果未設定，則每個令牌注意所有其他令牌（完全雙向注意力）。僅在預訓練期間（定義分解順序）或順序解碼（生成）期間使用。
- 如果
- target_mapping (
torch.FloatTensorof shape(batch_size, num_predict, sequence_length), 可選) — 用於指示要使用的輸出令牌的掩碼。如果target_mapping[k, i, j] = 1，則批處理 k 中的第 i 個預測位於第 j 個令牌上。僅在預訓練期間用於部分預測或順序解碼（生成）。 - token_type_ids (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 段落令牌索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]之間：- 0 對應於 句子 A 令牌,
- 1 對應於 句子 B 令牌.
- input_mask (
torch.FloatTensorof shapebatch_size, sequence_length, 可選) — 用於避免在填充令牌索引上執行注意力的掩碼。與attention_mask相反，即真實令牌為 0，填充為 1，這與原始程式碼庫相容。掩碼值選擇在
[0, 1]之間：- 1 表示 被掩碼 的令牌,
- 0 表示 未被掩碼 的令牌.
您只能使用
input_mask和attention_mask中的一個。 - head_mask (
torch.Tensorof shape(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇在[0, 1]之間：- 1 表示頭 未被掩碼,
- 0 表示頭 被掩碼.
- inputs_embeds (
torch.Tensorof shape(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量進行比模型內部嵌入查詢矩陣更精細的控制，這會很有用。 - labels (
torch.LongTensorof shape(batch_size,), 可選) — 用於計算多項選擇分類損失的標籤。索引應在[0, ..., num_choices]之間，其中 num_choices 是輸入張量第二維度的大小。（參見上面的 input_ids） - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用先前正向傳播中的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或當 config.return_dict=False 時），其中包含根據配置 (XLNetConfig) 和輸入的不同元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分類分數（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetForTokenClassification 的 forward 方法，它重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, XLNetForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...XLNetForQuestionAnsweringSimple
類 transformers.XLNetForQuestionAnsweringSimple
< 來源 >( config )
引數
- config (XLNetForQuestionAnsweringSimple) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
XLNet 模型，頂部帶有一個用於 SQuAD 等抽取式問答任務的跨度分類頭（隱藏狀態輸出頂部的一個線性層，用於計算 span start logits 和 span end logits）。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 詞彙表中輸入序列令牌的索引。預設情況下會忽略填充。索引可以使用 AutoTokenizer 獲得。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 用於避免在填充令牌索引上執行注意力的掩碼。掩碼值選擇在[0, 1]之間：- 1 表示 未被掩碼 的令牌,
- 0 表示 被掩碼 的令牌.
- mems (
list[torch.FloatTensor]，長度為config.n_layers) — 包含預計算的隱藏狀態（參見下面的mems輸出）。可用於加速順序解碼。已將其過去值傳遞給此模型的令牌 ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (
torch.FloatTensorof shape(batch_size, sequence_length, sequence_length), 可選) — 用於指示每個輸入令牌的注意力模式的掩碼，值選擇在[0, 1]之間：- 如果
perm_mask[k, i, j] = 0，則批處理 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批處理 k 中的 i 不注意 j。
如果未設定，則每個令牌注意所有其他令牌（完全雙向注意力）。僅在預訓練期間（定義分解順序）或順序解碼（生成）期間使用。
- 如果
- target_mapping (
torch.FloatTensorof shape(batch_size, num_predict, sequence_length), 可選) — 用於指示要使用的輸出令牌的掩碼。如果target_mapping[k, i, j] = 1，則批處理 k 中的第 i 個預測位於第 j 個令牌上。僅在預訓練期間用於部分預測或順序解碼（生成）。 - token_type_ids (
torch.Tensorof shape(batch_size, sequence_length), 可選) — 段落令牌索引，用於指示輸入的第一個和第二個部分。索引選擇在[0, 1]之間：- 0 對應於 句子 A 令牌,
- 1 對應於 句子 B 令牌.
- input_mask (
torch.FloatTensorof shapebatch_size, sequence_length, 可選) — 用於避免在填充令牌索引上執行注意力的掩碼。與attention_mask相反，即真實令牌為 0，填充為 1，這與原始程式碼庫相容。掩碼值選擇在
[0, 1]之間：- 1 表示 被掩碼 的令牌,
- 0 表示 未被掩碼 的令牌.
您只能使用
input_mask和attention_mask中的一個。 - head_mask (
torch.Tensorof shape(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇在[0, 1]之間：- 1 表示頭 未被掩碼,
- 0 表示頭 被掩碼.
- inputs_embeds (
torch.Tensorof shape(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量進行比模型內部嵌入查詢矩陣更精細的控制，這會很有用。 - start_positions (
torch.Tensorof shape(batch_size,), 可選) — 用於計算令牌分類損失的標記跨度起始位置（索引）的標籤。位置將被限制在序列長度（sequence_length）內。序列外的位置不計入損失計算。 - end_positions (
torch.Tensorof shape(batch_size,), 可選) — 用於計算令牌分類損失的標記跨度結束位置（索引）的標籤。位置將被限制在序列長度（sequence_length）內。序列外的位置不計入損失計算。 - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用先前正向傳播中的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 物件，而非純元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensor形狀為(batch_size, sequence_length,)) — 跨度起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensor形狀為(batch_size, sequence_length,)) — 跨度結束分數（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetForQuestionAnsweringSimple 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...XLNetForQuestionAnswering
class transformers.XLNetForQuestionAnswering
< source >( config )
引數
- config (XLNetForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。要載入模型權重，請檢視 from_pretrained() 方法。
Xlnet transformer 帶有用於抽取式問答任務（如 SQuAD）的跨度分類頭（在隱藏狀態輸出之上有一個線性層，用於計算 `span start logits` 和 `span end logits`）。
此模型繼承自PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是PyTorch torch.nn.Module的子類。將其作為常規的PyTorch模組使用，並參考PyTorch文件瞭解所有與通用用法和行為相關的事項。
前向傳播
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None is_impossible: typing.Optional[torch.Tensor] = None cls_index: typing.Optional[torch.Tensor] = None p_mask: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參見 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未被遮蔽 的 token，
- 0 表示 被遮蔽 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預計算的隱藏狀態（請參見下面的mems輸出）。可用於加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (
torch.FloatTensor形狀為(batch_size, sequence_length, sequence_length), 可選) — 指示每個輸入 token 的注意力模式的掩碼，其值選擇範圍為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則批處理 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批處理 k 中的 i 不注意 j。
如果未設定，則每個 token 都會注意所有其他 token（完全雙向注意力）。僅在預訓練期間（用於定義因式分解順序）或用於順序解碼（生成）時使用。
- 如果
- target_mapping (
torch.FloatTensor形狀為(batch_size, num_predict, sequence_length), 可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則批處理 k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或用於順序解碼（生成）。 - token_type_ids (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為[0, 1]：- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
- input_mask (
torch.FloatTensor形狀為batch_size, sequence_length, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。是attention_mask的負值，即真實 token 為 0，填充 token 為 1，以與原始程式碼庫相容。掩碼值選擇範圍為
[0, 1]：- 1 表示 被遮蔽 的 token，
- 0 表示 未被遮蔽 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (
torch.Tensor形狀為(num_heads,)或(num_layers, num_heads), 可選) — 遮蔽自注意力模組選定頭的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭 未被遮蔽，
- 0 表示頭 被遮蔽。
- inputs_embeds (
torch.Tensor形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這將非常有用。 - start_positions (
torch.Tensor形狀為(batch_size,), 可選) — 用於計算 token 分類損失的標籤跨度起始位置（索引）。位置被限制為序列的長度（sequence_length）。序列之外的位置不計入損失計算。 - end_positions (
torch.Tensor形狀為(batch_size,), 可選) — 用於計算 token 分類損失的標籤跨度結束位置（索引）。位置被限制為序列的長度（sequence_length）。序列之外的位置不計入損失計算。 - is_impossible (
torch.LongTensor形狀為(batch_size,), 可選) — 標籤，表示問題是否有答案（SQuAD 2.0）。 - cls_index (
torch.LongTensor形狀為(batch_size,), 可選) — 用於計算答案合理性作為輸入的分類 token 的位置（索引）標籤。 - p_mask (
torch.FloatTensor形狀為(batch_size, sequence_length), 可選) — 可選的 token 掩碼，表示不能作為答案的 token（例如 [CLS]、[PAD] 等）。1.0 表示 token 應該被遮蔽。0.0 表示 token 未被遮蔽。 - use_mems (
bool, 可選) — 是否使用記憶體狀態來加速順序解碼。如果設定為True，模型將使用前向傳播中的隱藏狀態來計算注意力，這可以顯著提高順序解碼任務的效能。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參見返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 物件，而非純元組。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (
torch.FloatTensor形狀為(1,), 可選, 如果提供了start_positions和end_positions，則返回) — 作為起始 token 損失、結束 token 損失（如果提供is_impossible，則包含其損失）總和的分類損失。 -
start_top_log_probs (
torch.FloatTensor形狀為(batch_size, config.start_n_top), 可選, 如果未提供start_positions或end_positions，則返回) — 頂層 config.start_n_top 起始 token 可能性（束搜尋）的對數機率。 -
start_top_index (
torch.LongTensor形狀為(batch_size, config.start_n_top), 可選, 如果未提供start_positions或end_positions，則返回) — 頂層 config.start_n_top 起始 token 可能性（束搜尋）的索引。 -
end_top_log_probs (
torch.FloatTensor形狀為(batch_size, config.start_n_top * config.end_n_top), 可選, 如果未提供start_positions或end_positions，則返回) — 頂層config.start_n_top * config.end_n_top結束 token 可能性（束搜尋）的對數機率。 -
end_top_index (
torch.LongTensor形狀為(batch_size, config.start_n_top * config.end_n_top), 可選, 如果未提供start_positions或end_positions，則返回) — 頂層config.start_n_top * config.end_n_top結束 token 可能性（束搜尋）的索引。 -
cls_logits (
torch.FloatTensor形狀為(batch_size,), 可選, 如果未提供start_positions或end_positions，則返回) — 答案的is_impossible標籤的對數機率。 -
mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去的令牌ID提供給此模型的令牌ID不應作為input_ids傳遞，因為它們已被計算。 -
hidden_states (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層輸出一個）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor, ...], 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
XLNetForQuestionAnswering 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")
>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
... 0
... ) # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.lossTFXLNetModel
class transformers.TFXLNetModel
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。要載入模型權重，請檢視 from_pretrained() 方法。
裸 XLNet 模型 transformer，輸出原始隱藏狀態，頂部沒有任何特定頭部。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
torch.LongTensor形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參見 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor形狀為(batch_size, sequence_length), 可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未被遮蔽 的 token，
- 0 表示 被遮蔽 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預計算的隱藏狀態（請參見下面的mems輸出）。可用於加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (
torch.FloatTensor形狀為(batch_size, sequence_length, sequence_length), 可選) — 指示每個輸入 token 的注意力模式的掩碼，其值選擇範圍為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則批處理 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批處理 k 中的 i 不注意 j。
如果未設定，則每個 token 都會注意所有其他 token（完全雙向注意力）。僅在預訓練期間（用於定義因式分解順序）或用於順序解碼（生成）時使用。
- 如果
- target_mapping (
torch.FloatTensor形狀為(batch_size, num_predict, sequence_length), 可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則批處理 k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或用於順序解碼（生成）。 - token_type_ids (
torch.LongTensor形狀為(batch_size, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為[0, 1]：- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
- input_mask (
torch.FloatTensor形狀為batch_size, sequence_length, 可選) — 避免對填充 token 索引執行注意力操作的掩碼。是attention_mask的負值，即真實 token 為 0，填充 token 為 1，以與原始程式碼庫相容。掩碼值選擇範圍為
[0, 1]：- 1 表示 被遮蔽 的 token，
- 0 表示 未被遮蔽 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (
torch.FloatTensor形狀為(num_heads,)或(num_layers, num_heads), 可選) — 遮蔽自注意力模組選定頭的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭 未被遮蔽，
- 0 表示頭 被遮蔽。
- inputs_embeds (
torch.FloatTensor形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這將非常有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參見返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 物件，而非純元組。
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput 或一個 tf.Tensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
last_hidden_state (
tf.Tensor形狀為(batch_size, num_predict, hidden_size)) — 模型最後一層的隱藏狀態序列。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 -
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetModel 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFXLNetModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetModel.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFXLNetLMHeadModel
class transformers.TFXLNetLMHeadModel
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 包含模型所有引數的模型配置類。用配置檔案初始化模型不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
XLNet模型，頂部帶有一個語言建模頭（與輸入嵌入繫結的線性層）。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor) — 詞彙表中輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預計算的隱藏狀態（見下面的mems輸出）。可用於加速順序解碼。已將 past 傳入此模型的 token ID 不應作為input_ids傳入，因為它們已被計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可選) — 指示每個輸入 token 注意力模式的掩碼，值選擇範圍為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則 batch k 中的 i 注意到 j； - 如果
perm_mask[k, i, j] = 1，則 batch k 中的 i 不注意到 j。
如果未設定，每個 token 注意到所有其他 token（完全雙向注意力）。僅在預訓練期間（定義分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor，可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則 batch k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或順序解碼（生成）。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 指示輸入的第一部分和第二部分的段 token 索引。索引選擇範圍為[0, 1]：- 0 對應 句子 A 的 token，
- 1 對應 句子 B 的 token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫保持相容。掩碼值選擇範圍為
[0, 1]：- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部 未被掩蓋，
- 0 表示頭部 被掩蓋。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳入嵌入表示而不是input_ids。如果您希望對如何將input_ids索引轉換為關聯向量有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是純元組。 - labels (形狀為
(batch_size, sequence_length)的tf.Tensor，可選) — 用於計算交叉熵分類損失的標籤。索引應在[0, ..., config.vocab_size - 1]範圍內。
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (形狀為 (1,) 的
tf.Tensor，可選，當提供labels時返回) 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, num_predict, config.vocab_size)的tf.Tensor) — 語言建模頭的預測分數（SoftMax 之前的每個詞彙 token 的分數）。num_predict對應於target_mapping.shape[1]。如果target_mapping為None，則num_predict對應於sequence_length。 -
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetLMHeadModel 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> import tensorflow as tf
>>> import numpy as np
>>> from transformers import AutoTokenizer, TFXLNetLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = TFXLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=True))[
... None, :
... ] # We will predict the masked token
>>> perm_mask = np.zeros((1, input_ids.shape[1], input_ids.shape[1]))
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = np.zeros(
... (1, 1, input_ids.shape[1])
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(
... input_ids,
... perm_mask=tf.constant(perm_mask, dtype=tf.float32),
... target_mapping=tf.constant(target_mapping, dtype=tf.float32),
... )
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]TFXLNetForSequenceClassification
class transformers.TFXLNetForSequenceClassification
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 包含模型所有引數的模型配置類。用配置檔案初始化模型不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
XLNet 模型，其頂部帶有一個序列分類/迴歸頭部（在池化輸出頂部的一個線性層），例如用於 GLUE 任務。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或 tuple(tf.Tensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor) — 詞彙表中輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預計算的隱藏狀態（見下面的mems輸出）。可用於加速順序解碼。已將 past 傳入此模型的 token ID 不應作為input_ids傳入，因為它們已被計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可選) — 指示每個輸入 token 注意力模式的掩碼，值選擇範圍為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則 batch k 中的 i 注意到 j； - 如果
perm_mask[k, i, j] = 1，則 batch k 中的 i 不注意到 j。
如果未設定，每個 token 注意到所有其他 token（完全雙向注意力）。僅在預訓練期間（定義分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor，可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則 batch k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或順序解碼（生成）。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 指示輸入的第一部分和第二部分的段 token 索引。索引選擇範圍為[0, 1]：- 0 對應 句子 A 的 token，
- 1 對應 句子 B 的 token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫保持相容。掩碼值選擇範圍為
[0, 1]：- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部 未被掩蓋，
- 0 表示頭部 被掩蓋。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳入嵌入表示而不是input_ids。如果您希望對如何將input_ids索引轉換為關聯向量有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是純元組。 - labels (形狀為
(batch_size,)的tf.Tensor，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失），如果config.num_labels > 1，則計算分類損失（交叉熵）。
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而定的各種元素。
-
loss (形狀為
(1,)的tf.Tensor，可選，當提供label時返回) — 分類（或迴歸，如果 config.num_labels==1）損失。 -
logits (
tf.Tensor，形狀為(batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFXLNetForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFXLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).lossTFXLNetForMultipleChoice
class transformers.TFXLNetForMultipleChoice
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 包含模型所有引數的模型配置類。用配置檔案初始化模型不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
XLNET 模型，頂部帶有多項選擇分類頭（在池化輸出頂部和 softmax 上的線性層），例如用於 RocStories/SWAG 任務。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或 tuple(tf.Tensor)
引數
- input_ids (形狀為
(batch_size, num_choices, sequence_length)的torch.LongTensor) — 詞彙表中輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, num_choices, sequence_length)的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未被掩蓋 的 token，
- 0 表示 被掩蓋 的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預計算的隱藏狀態（見下面的mems輸出）。可用於加速順序解碼。已將 past 傳入此模型的 token ID 不應作為input_ids傳入，因為它們已被計算過。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可選) — 指示每個輸入 token 注意力模式的掩碼，值選擇範圍為[0, 1]：- 如果
perm_mask[k, i, j] = 0，則 batch k 中的 i 注意到 j； - 如果
perm_mask[k, i, j] = 1，則 batch k 中的 i 不注意到 j。
如果未設定，每個 token 注意到所有其他 token（完全雙向注意力）。僅在預訓練期間（定義分解順序）或順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor，可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則 batch k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或順序解碼（生成）。 - token_type_ids (形狀為
(batch_size, num_choices, sequence_length)的torch.LongTensor，可選) — 指示輸入的第一部分和第二部分的段 token 索引。索引選擇範圍為[0, 1]：- 0 對應 句子 A 的 token，
- 1 對應 句子 B 的 token。
- input_mask (形狀為
batch_size, num_choices, sequence_length的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力操作的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，這與原始程式碼庫保持相容。掩碼值選擇範圍為
[0, 1]：- 1 表示 被掩蓋 的 token，
- 0 表示 未被掩蓋 的 token。
您只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可選) — 用於使自注意力模組中的選定注意力頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示注意力頭未被遮蔽，
- 0 表示注意力頭已被遮蔽。
- inputs_embeds (形狀為
(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，你可以選擇直接傳入嵌入表示，而不是傳入input_ids。如果你想對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而非普通元組。 - labels (形狀為
(batch_size,)的tf.Tensor，可選) — 用於計算多項選擇分類損失的標籤。索引應在[0, ..., num_choices]範圍內，其中num_choices是輸入張量第二維的大小。（請參閱上面的input_ids）
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或一個 tf.Tensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而異的各種元素。
-
loss (形狀為 (1,) 的
tf.Tensor，可選，當提供labels時返回) — 分類損失。 -
logits (
tf.Tensor，形狀為(batch_size, num_choices)) — num_choices 是輸入張量的第二維。（參見上面的 input_ids）。分類分數（SoftMax 之前）。
-
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetForMultipleChoice 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFXLNetForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForMultipleChoice.from_pretrained("xlnet/xlnet-base-cased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logitsTFXLNetForTokenClassification
class transformers.TFXLNetForTokenClassification
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。請查閱 from_pretrained() 方法來載入模型權重。
XLNet 模型，其頂部帶有一個 token 分類頭（隱藏狀態輸出頂部的一個線性層），例如用於命名實體識別 (NER) 任務。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput or tuple(tf.Tensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor) — 詞表中輸入序列 token 的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示未被遮蔽的 token，
- 0 表示已被遮蔽的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（請參閱下面的mems輸出）。可用於加速順序解碼。已提供給該模型的 token ID 不應作為input_ids傳遞，因為它們已被計算。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可選) — 指示每個輸入 token 注意力模式的掩碼，值在[0, 1]中選擇：- 如果
perm_mask[k, i, j] = 0，則批次 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批次 k 中的 i 不注意 j。
如果未設定，每個 token 注意所有其他 token（完全雙向注意力）。僅在預訓練期間（定義分解順序）或用於順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor，可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則批次 k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或用於順序解碼（生成）時使用。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 片段 token 索引，用於指示輸入的第一個和第二個部分。索引在[0, 1]中選擇：- 0 對應於句子 A token，
- 1 對應於句子 B token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，以保持與原始程式碼庫的相容性。掩碼值在
[0, 1]中選擇：- 1 表示已被遮蔽的 token，
- 0 表示未被遮蔽的 token。
你只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可選) — 用於使自注意力模組中的選定注意力頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示注意力頭未被遮蔽，
- 0 表示注意力頭已被遮蔽。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，你可以選擇直接傳入嵌入表示，而不是傳入input_ids。如果你想對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而非普通元組。 - labels (形狀為
(batch_size, sequence_length)的tf.Tensor，可選) — 用於計算 token 分類損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput 或一個 tf.Tensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而異的各種元素。
-
loss (形狀為
(1,)的tf.Tensor，可選，當提供labels時返回) — 分類損失。 -
logits (
tf.Tensor，形狀為(batch_size, sequence_length, config.num_labels)) — 分類分數（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetForTokenClassification 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFXLNetForTokenClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForTokenClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )
>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]TFXLNetForQuestionAnsweringSimple
class transformers.TFXLNetForQuestionAnsweringSimple
< source >( config *inputs **kwargs )
引數
- config (XLNetConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化模型不會載入與模型相關的權重，只加載配置。請查閱 from_pretrained() 方法來載入模型權重。
XLNet 模型，頂部帶有一個用於 SQuAD 等抽取式問答任務的跨度分類頭（隱藏狀態輸出頂部的一個線性層，用於計算 span start logits 和 span end logits）。
此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視父類文件。
此模型也是 keras.Model 的子類。將其用作常規 TF 2.0 Keras 模型，並參考 TF 2.0 文件瞭解所有與一般使用和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是 Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，可以使用三種可能性來收集第一個位置引數中的所有輸入張量。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用 子類化 建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput or tuple(tf.Tensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor) — 詞表中輸入序列 token 的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示未被遮蔽的 token，
- 0 表示已被遮蔽的 token。
- mems (長度為
config.n_layers的list[torch.FloatTensor]) — 包含預先計算的隱藏狀態（請參閱下面的mems輸出）。可用於加速順序解碼。已提供給該模型的 token ID 不應作為input_ids傳遞，因為它們已被計算。必須將
use_mems設定為True才能使用mems。 - perm_mask (形狀為
(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可選) — 指示每個輸入 token 注意力模式的掩碼，值在[0, 1]中選擇：- 如果
perm_mask[k, i, j] = 0，則批次 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，則批次 k 中的 i 不注意 j。
如果未設定，每個 token 注意所有其他 token（完全雙向注意力）。僅在預訓練期間（定義分解順序）或用於順序解碼（生成）時使用。
- 如果
- target_mapping (形狀為
(batch_size, num_predict, sequence_length)的torch.FloatTensor，可選) — 指示要使用的輸出 token 的掩碼。如果target_mapping[k, i, j] = 1，則批次 k 中的第 i 個預測位於第 j 個 token 上。僅在預訓練期間用於部分預測或用於順序解碼（生成）時使用。 - token_type_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 片段 token 索引，用於指示輸入的第一個和第二個部分。索引在[0, 1]中選擇：- 0 對應於句子 A token，
- 1 對應於句子 B token。
- input_mask (形狀為
batch_size, sequence_length的torch.FloatTensor，可選) — 避免對填充 token 索引執行注意力的掩碼。與attention_mask相反，即真實 token 為 0，填充為 1，以保持與原始程式碼庫的相容性。掩碼值在
[0, 1]中選擇：- 1 表示已被遮蔽的 token，
- 0 表示未被遮蔽的 token。
你只能使用
input_mask和attention_mask中的一個。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可選) — 用於使自注意力模組中的選定注意力頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示注意力頭未被遮蔽，
- 0 表示注意力頭已被遮蔽。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，你可以選擇直接傳入嵌入表示，而不是傳入input_ids。如果你想對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而非普通元組。 - start_positions (形狀為
(batch_size,)的tf.Tensor，可選) — 用於計算 token 分類損失的標註跨度起始位置（索引）的標籤。位置被限制在序列長度（sequence_length）範圍內。超出序列的位置不計入損失計算。 - end_positions (形狀為
(batch_size,)的tf.Tensor，可選) — 用於計算 token 分類損失的標註跨度結束位置（索引）的標籤。位置被限制在序列長度（sequence_length）範圍內。超出序列的位置不計入損失計算。
返回
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput 或 tuple(tf.Tensor)
一個 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput 或一個 tf.Tensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（XLNetConfig）和輸入而異的各種元素。
-
loss (形狀為
(1,)的tf.Tensor，可選，當提供labels時返回) — 總跨度提取損失是起始和結束位置的交叉熵之和。 -
start_logits (形狀為
(batch_size, sequence_length,)的tf.Tensor) — 跨度起始得分（SoftMax 之前）。 -
end_logits (形狀為
(batch_size, sequence_length,)的tf.Tensor) — 跨度結束得分（SoftMax 之前）。 -
mems (長度為
config.n_layers的list[tf.Tensor]) — 包含預計算的隱藏狀態。可用於（參見mems輸入）加速順序解碼。已將過去資訊提供給此模型的 token ID 不應作為input_ids傳遞，因為它們已經計算過。 -
hidden_states (
tuple(tf.Tensor), 可選, 如果傳遞output_hidden_states=True或config.output_hidden_states=True，則返回) —tf.Tensor元組（一個用於嵌入輸出 + 一個用於每層輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選, 如果傳遞output_attentions=True或config.output_attentions=True，則返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFXLNetForQuestionAnsweringSimple 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但在此之後應該呼叫Module例項而不是它，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFXLNetForQuestionAnsweringSimple
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-base-cased")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)
>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]