Transformers 文件
GPT
並獲得增強的文件體驗
開始使用
GPT
GPT（生成式預訓練 Transformer）專注於有效學習文字表示並將其遷移到各種任務中。該模型訓練 Transformer 解碼器來預測下一個詞，然後在有標籤的資料上進行微調。
GPT 能夠生成高質量的文字，使其非常適合各種自然語言理解任務，如文字蘊含、問答、語義相似度和文件分類。
你可以在 OpenAI 社群組織下找到所有原始的 GPT 檢查點。
點選右側邊欄中的 GPT 模型，檢視更多如何將 GPT 應用於不同語言任務的示例。
下面的示例演示瞭如何使用 Pipeline、AutoModel 和命令列來生成文字。
import torch
from transformers import pipeline
generator = pipeline(task="text-generation", model="openai-community/gpt", torch_dtype=torch.float16, device=0)
output = generator("The future of AI is", max_length=50, do_sample=True)
print(output[0]["generated_text"])注意事項
- 由於 GPT 使用絕對位置嵌入，輸入應在右側進行填充。
OpenAIGPTConfig
class transformers.OpenAIGPTConfig
< 來源 >( vocab_size = 40478 n_positions = 512 n_embd = 768 n_layer = 12 n_head = 12 afn = 'gelu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 summary_type = 'cls_index' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 40478) — GPT-2 模型的詞彙表大小。定義了在呼叫 OpenAIGPTModel 或 TFOpenAIGPTModel 時，可以透過inputs_ids表示的不同詞元（token）的數量。 - n_positions (
int, 可選, 預設為 512) — 該模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需（例如，512、1024 或 2048）。 - n_embd (
int, 可選, 預設為 768) — 嵌入和隱藏狀態的維度。 - n_layer (
int, 可選, 預設為 12) — Transformer 編碼器中的隱藏層數。 - n_head (
int, 可選, 預設為 12) — Transformer 編碼器中每個注意力層的注意力頭數。 - afn (
str或Callable, 可選, 預設為"gelu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。如果是字串，支援"gelu"、"relu"、"silu"和"gelu_new"。 - resid_pdrop (
float, 可選, 預設為 0.1) — 嵌入、編碼器和池化器中所有全連線層的 dropout 機率。 - embd_pdrop (
int, 可選, 預設為 0.1) — 嵌入的 dropout 比率。 - attn_pdrop (
float, 可選, 預設為 0.1) — 注意力層的 dropout 比率。 - layer_norm_epsilon (
float, 可選, 預設為 1e-05) — 層歸一化層中使用的 epsilon 值。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - summary_type (
str, 可選, 預設為"cls_index") — 在進行序列摘要時使用的引數，用於模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。必須是以下選項之一：
"last"：取最後一個詞元的隱藏狀態（如 XLNet）。"first"：取第一個詞元的隱藏狀態（如 BERT）。"mean"：取所有詞元隱藏狀態的平均值。"cls_index"：提供一個分類詞元位置的張量（如 GPT/GPT-2）。"attn"：目前未實現，使用多頭注意力機制。
- summary_use_proj (
bool, 可選, 預設為True) — 在進行序列摘要時使用的引數，用於模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。是否在向量提取後新增一個投影層。
- summary_activation (
str, 可選) — 在進行序列摘要時使用的引數，用於模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。傳遞
"tanh"以對輸出應用 tanh 啟用函式，任何其他值將導致不應用啟用函式。 - summary_proj_to_labels (
bool, 可選, 預設為True) — 在進行序列摘要時使用的引數，用於模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。投影輸出是否應具有
config.num_labels或config.hidden_size個類別。 - summary_first_dropout (
float, 可選, 預設為 0.1) — 在進行序列摘要時使用的引數，用於模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。在投影和啟用之後使用的 dropout 比率。
這是用於儲存 OpenAIGPTModel 或 TFOpenAIGPTModel 配置的配置類。它用於根據指定的引數例項化一個 GPT 模型，定義模型架構。使用預設值例項化配置將產生與 OpenAI 的 GPT openai-community/openai-gpt 架構類似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
示例
>>> from transformers import OpenAIGPTConfig, OpenAIGPTModel
>>> # Initializing a GPT configuration
>>> configuration = OpenAIGPTConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = OpenAIGPTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOpenAIGPTModel
class transformers.OpenAIGPTModel
< 來源 >( config )
引數
- config (OpenAIGPTModel) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
裸 Openai 模型，輸出原始的隱藏狀態，沒有任何特定的頭在其之上。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 對於未被掩碼的詞元，值為 1，
- 對於被掩碼的詞元，值為 0。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在範圍[0, config.n_positions - 1]內選擇。 - 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.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutput 或一個 torch.FloatTensor 的元組 (如果傳遞了 return_dict=False 或當 config.return_dict=False 時)，根據配置 (OpenAIGPTConfig) 和輸入包含各種元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
OpenAIGPTModel 的 forward 方法重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
- forward
OpenAIGPTLMHeadModel
class transformers.OpenAIGPTLMHeadModel
< 原始碼 >( config )
引數
- config (OpenAIGPTLMHeadModel) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言模型頭的 OpenAI GPT 模型轉換器（線性層，權重與輸入嵌入繫結）。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在範圍[0, config.n_positions - 1]內選擇。 - 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索引轉換為關聯向量，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於語言模型的標籤。請注意，標籤在模型內部會被移位，即你可以設定labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中選擇。所有設定為-100的標籤都會被忽略（遮蔽），損失僅對[0, ..., config.vocab_size]中的標籤進行計算。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多細節請參見返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多細節請參見返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutput 或一個 torch.FloatTensor 的元組 (如果傳遞了 return_dict=False 或當 config.return_dict=False 時)，根據配置 (OpenAIGPTConfig) 和輸入包含各種元素。
-
loss (
torch.FloatTensor形狀為(1,)，可選，當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
OpenAIGPTLMHeadModel 的 forward 方法重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTLMHeadModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits- forward
OpenAIGPTDoubleHeadsModel
class transformers.OpenAIGPTDoubleHeadsModel
< 原始碼 >( config )
引數
- config (OpenAIGPTDoubleHeadsModel) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言模型頭和多項選擇分類頭的 OpenAI GPT 模型轉換器，例如用於 RocStories/SWAG 任務。這兩個頭是兩個線性層。語言模型頭的權重與輸入嵌入繫結，分類頭將輸入序列中指定分類標記索引的輸入作為輸入）。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None mc_token_ids: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.LongTensor] = None mc_labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。在範圍[0, config.n_positions - 1]內選擇。 - 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索引轉換為關聯向量，這會很有用。 - mc_token_ids (
torch.LongTensor，形狀為(batch_size, num_choices)，可選，預設為輸入的最後一個標記的索引) — 每個輸入序列中分類標記的索引。在範圍[0, input_ids.size(-1) - 1]內選擇。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於語言模型的標籤。請注意，標籤在模型內部會被移位，即你可以設定labels = input_ids。索引在[-1, 0, ..., config.vocab_size]中選擇。所有設定為-100的標籤都會被忽略（遮蔽），損失僅對[0, ..., config.vocab_size]中的標籤進行計算。 - mc_labels (
torch.LongTensor，形狀為(batch_size)，可選) — 用於計算多項選擇分類損失的標籤。索引應在[0, ..., num_choices]範圍內，其中 *num_choices* 是輸入張量第二維的大小。（參見上面的 *input_ids*） - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多細節請參見返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多細節請參見返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或一個 torch.FloatTensor 的元組 (如果傳遞了 return_dict=False 或當 config.return_dict=False 時)，根據配置 (OpenAIGPTConfig) 和輸入包含各種元素。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
mc_loss (
torch.FloatTensor，形狀為(1,)，可選，當提供mc_labels時返回) — 多項選擇分類損失。 -
logits (
torch.FloatTensor，形狀為(batch_size, num_choices, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 前每個詞彙標記的分數）。 -
mc_logits (
torch.FloatTensor，形狀為(batch_size, num_choices)) — 多項選擇分類頭的預測分數（SoftMax 前每個選項的分數）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
OpenAIGPTDoubleHeadsModel 的 forward 方法重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, OpenAIGPTDoubleHeadsModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTDoubleHeadsModel.from_pretrained("openai-community/openai-gpt")
>>> tokenizer.add_special_tokens(
... {"cls_token": "[CLS]"}
... ) # Add a [CLS] to the vocabulary (we should train it also!)
>>> model.resize_token_embeddings(len(tokenizer))
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> input_ids = torch.tensor([tokenizer.encode(s) for s in choices]).unsqueeze(0) # Batch size 1, 2 choices
>>> mc_token_ids = torch.tensor([input_ids.size(-1) - 1, input_ids.size(-1) - 1]).unsqueeze(0) # Batch size 1
>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.logits
>>> mc_logits = outputs.mc_logits- forward
OpenAIGPTForSequenceClassification
class transformers.OpenAIGPTForSequenceClassification
< 原始碼 >( config )
引數
- config (OpenAIGPTForSequenceClassification) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
原始的 OpenAI GPT 模型轉換器，頂部帶有一個序列分類頭（線性層）。OpenAIGPTForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（如 GPT-2）一樣。由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果在配置中定義了 pad_token_id，它會找到每行中不是填充標記的最後一個標記。如果未定義 pad_token_id，它會簡單地取批處理中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時無法猜測填充標記，它會做同樣的操作（取批處理中每行的最後一個值）。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一和第二部分的段標記索引。索引在[0, 1]中選擇：- 0 對應於*句子 A* 的標記，
- 1 對應於*句子 B* 的標記。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在範圍[0, config.n_positions - 1]內選擇。 - 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索引轉換為相關向量，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失）；如果config.num_labels > 1，則計算分類損失（交叉熵）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.SequenceClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（OpenAIGPTConfig）和輸入的不同，包含不同的元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
OpenAIGPTForSequenceClassification 的 forward 方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt")
>>> 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 = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", 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 = OpenAIGPTForSequenceClassification.from_pretrained(
... "openai-community/openai-gpt", 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).loss- forward
OpenAIGPTTokenizer
class transformers.OpenAIGPTTokenizer
< 來源 >( vocab_file merges_file unk_token = '<unk>' **kwargs )
構建一個 GPT 分詞器。基於位元組對編碼（Byte-Pair-Encoding），具有以下特點：
- 將所有輸入轉換為小寫，
- 如果已安裝，則使用
SpaCy分詞器和ftfy進行 BPE 前的分詞處理，否則回退到 BERT 的BasicTokenizer。
此分詞器繼承自 PreTrainedTokenizer，其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
將標記序列（字串）轉換為單個字串。
OpenAIGPTTokenizerFast
class transformers.OpenAIGPTTokenizerFast
< 來源 >( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<unk>' **kwargs )
構建一個“快速”的 GPT 分詞器（由 HuggingFace 的 *tokenizers* 庫支援）。基於位元組對編碼（Byte-Pair-Encoding），具有以下特點：
- 將所有輸入轉換為小寫
- 使用 BERT 的 BasicTokenizer 進行 BPE 前的分詞處理
此分詞器繼承自 PreTrainedTokenizerFast，其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
TFOpenAIGPTModel
class transformers.TFOpenAIGPTModel
< 來源 >( config *inputs **kwargs )
引數
- config (OpenAIGPTConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎的 OpenAI GPT 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 函式一樣傳遞輸入！
呼叫
< 來源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
Numpy 陣列或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- token_type_ids (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一和第二部分的段標記索引。索引在[0, 1]中選擇：- 0 對應於*句子 A* 的標記，
- 1 對應於*句子 B* 的標記。
- position_ids (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]內選擇。 - head_mask (
tf.Tensor或Numpy 陣列，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭已被遮蓋。
- inputs_embeds (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。此引數可在 eager 模式下使用，在 graph 模式下該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否以訓練模式使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
返回
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
一個 transformers.modeling_tf_outputs.TFBaseModelOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（OpenAIGPTConfig）和輸入的不同，包含不同的元素。
-
last_hidden_state (
tf.Tensorof shape(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(tf.FloatTensor)，可選，當傳遞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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFOpenAIGPTModel 的 forward 方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_state- 呼叫
TFOpenAIGPTLMHeadModel
class transformers.TFOpenAIGPTLMHeadModel
< 來源 >( config *inputs **kwargs )
引數
- config (OpenAIGPTConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言模型頭的 OpenAI GPT 模型轉換器（線性層，權重與輸入嵌入繫結）。
該模型繼承自 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 函式一樣傳遞輸入！
呼叫
< 來源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = 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: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
引數
- input_ids (
Numpy 陣列或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- token_type_ids (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一和第二部分的段標記索引。索引在[0, 1]中選擇：- 0 對應於*句子 A* 的標記，
- 1 對應於*句子 B* 的標記。
- position_ids (
tf.Tensor或Numpy 陣列，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]內選擇。 - head_mask (
tf.Tensor或Numpy array，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- inputs_embeds (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞嵌入表示。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為相關聯的向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。此引數可在 Eager 模式下使用，在圖模式下，該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組，在訓練和評估之間有不同的行為）。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於計算交叉熵分類損失的標籤。索引應在[0, ..., config.vocab_size - 1]範圍內。
返回
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
一個 transformers.modeling_tf_outputs.TFCausalLMOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (OpenAIGPTConfig) 和輸入的不同而變化的各種元素。
-
loss (形狀為
(n,)的tf.Tensor，可選，其中n是非掩碼標籤的數量，當提供了labels時返回) — 語言建模損失（用於下一標記預測）。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFOpenAIGPTLMHeadModel 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTLMHeadModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTLMHeadModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits- 呼叫
TFOpenAIGPTDoubleHeadsModel
class transformers.TFOpenAIGPTDoubleHeadsModel
< 來源 >( config *inputs **kwargs )
引數
- config (OpenAIGPTConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。
帶有語言模型頭和多項選擇分類頭的 OpenAI GPT 模型轉換器，例如用於 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 函式一樣傳遞輸入！
呼叫
< 來源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None mc_token_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
Numpy array或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- token_type_ids (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 分段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *A 句* 標記，
- 1 對應於 *B 句* 標記。
- position_ids (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - head_mask (
tf.Tensor或Numpy array，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- inputs_embeds (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞嵌入表示。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為相關聯的向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。此引數可在 Eager 模式下使用，在圖模式下，該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組，在訓練和評估之間有不同的行為）。 - mc_token_ids (
tf.Tensor或Numpy array，形狀為(batch_size, num_choices)，可選，預設為輸入的最後一個標記的索引) — 每個輸入序列中分類標記的索引。在[0, input_ids.size(-1) - 1]範圍內選擇。
返回
transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (OpenAIGPTConfig) 和輸入的不同而變化的各種元素。
-
logits (
tf.Tensor，形狀為(batch_size, num_choices, sequence_length, config.vocab_size)) — 語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
mc_logits (
tf.Tensor，形狀為(batch_size, num_choices)) — 多項選擇分類頭的預測分數（SoftMax 之前的每個選項的分數）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFOpenAIGPTDoubleHeadsModel 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFOpenAIGPTDoubleHeadsModel
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTDoubleHeadsModel.from_pretrained("openai-community/openai-gpt")
>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> tokenizer.add_special_tokens({"cls_token": "[CLS]"})
>>> model.resize_token_embeddings(len(tokenizer)) # Update the model embeddings with the new vocabulary size
>>> print(tokenizer.cls_token_id, len(tokenizer)) # The newly token the last token of the vocabulary
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoding = tokenizer(choices, return_tensors="tf")
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> inputs["mc_token_ids"] = tf.constant(
... [inputs["input_ids"].shape[-1] - 1, inputs["input_ids"].shape[-1] - 1]
... )[
... None, :
... ] # Batch size 1
>>> outputs = model(inputs)
>>> lm_prediction_scores, mc_prediction_scores = outputs[:2]- 呼叫
TFOpenAIGPTForSequenceClassification
class transformers.TFOpenAIGPTForSequenceClassification
< 來源 >( config *inputs **kwargs )
引數
- config (OpenAIGPTConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。
OpenAI GPT 模型 Transformer，頂部帶有一個序列分類頭（線性層）。
TFOpenAIGPTForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT-2）一樣。
由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果在配置中定義了 pad_token_id，它會找到每行中不是填充標記的最後一個標記。如果沒有定義 pad_token_id，它會簡單地取批處理中每行的最後一個值。由於當傳遞 inputs_embeds 而不是 input_ids 時它無法猜測填充標記，因此它會做同樣的操作（取批處理中每行的最後一個值）。
該模型繼承自 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 函式一樣傳遞輸入！
呼叫
< 來源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = 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: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
引數
- input_ids (
Numpy array或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- token_type_ids (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 分段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *A 句* 標記，
- 1 對應於 *B 句* 標記。
- position_ids (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - head_mask (
tf.Tensor或Numpy array，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- inputs_embeds (
tf.Tensor或Numpy array，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞嵌入表示。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為相關聯的向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數僅能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。此引數可在 Eager 模式下使用，在圖模式下，該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組，在訓練和評估之間有不同的行為）。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於計算交叉熵分類損失的標籤。索引應在[0, ..., config.vocab_size - 1]範圍內。
返回
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
一個 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (OpenAIGPTConfig) 和輸入的不同而變化的各種元素。
-
loss (
tf.Tensor，形狀為(batch_size, )，可選，當提供labels時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。 -
logits (
tf.Tensor，形狀為(batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFOpenAIGPTForSequenceClassification 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 Module 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt")
>>> 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 = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss- 呼叫