Hugging Face 的 LOGO

Transformers 文件

GPT-J

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

GPT-J

PyTorch TensorFlow Flax FlashAttention

概述

GPT-J 模型由 Ben Wang 和 Aran Komatsuzaki 在 kingoflolz/mesh-transformer-jax 程式碼庫中釋出。它是一個類似 GPT-2 的因果語言模型，在 the Pile 資料集上訓練。

此模型由 Stella Biderman 貢獻。

使用技巧

  • 要以 float32 格式載入 GPT-J，至少需要模型大小 2 倍的 RAM：1 倍用於初始權重，另外 1 倍用於載入檢查點。因此，對於 GPT-J，僅載入模型就需要至少 48GB 的 RAM。為了減少 RAM 使用量，有幾個選項。torch_dtype 引數可用於僅在 CUDA 裝置上以半精度初始化模型。還有一個 fp16 分支，它儲存了 fp16 權重，可用於進一步最小化 RAM 使用量。
>>> from transformers import GPTJForCausalLM
>>> import torch

>>> device = "cuda"
>>> model = GPTJForCausalLM.from_pretrained(
...     "EleutherAI/gpt-j-6B",
...     revision="float16",
...     torch_dtype=torch.float16,
... ).to(device)

  • 該模型應能放入 16GB GPU 進行推理。對於訓練/微調，則需要更多的 GPU RAM。例如，Adam 最佳化器會建立模型的四個副本：模型、梯度、梯度的平均值和平方平均值。因此，即使使用混合精度（因為梯度更新是 fp32），也至少需要模型大小 4 倍的 GPU 記憶體。這還不包括啟用和資料批次，它們會再次需要一些額外的 GPU RAM。因此，應該探索諸如 DeepSpeed 之類的解決方案來訓練/微調模型。另一個選擇是使用原始程式碼庫在 TPU 上訓練/微調模型，然後將模型轉換為 Transformers 格式進行推理。相關說明可以在這裡找到。

  • 雖然嵌入矩陣的大小為 50400，但 GPT-2 分詞器只使用了 50257 個條目。為了提高 TPU 的效率，添加了這些額外的詞元。為了避免嵌入矩陣大小和詞彙表大小之間的不匹配，GPT-J 的分詞器包含了 143 個額外的詞元 <|extratoken_1|>... <|extratoken_143|>，因此分詞器的 vocab_size 也變成了 50400。

使用示例

generate() 方法可用於使用 GPT-J 模型生成文字。

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-j-6B")
>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")

>>> prompt = (
...     "In a shocking finding, scientists discovered a herd of unicorns living in a remote, "
...     "previously unexplored valley, in the Andes Mountains. Even more surprising to the "
...     "researchers was the fact that the unicorns spoke perfect English."
... )

>>> input_ids = tokenizer(prompt, return_tensors="pt").input_ids

>>> gen_tokens = model.generate(
...     input_ids,
...     do_sample=True,
...     temperature=0.9,
...     max_length=100,
... )
>>> gen_text = tokenizer.batch_decode(gen_tokens)[0]

……或以 float16 精度

>>> from transformers import GPTJForCausalLM, AutoTokenizer
>>> import torch

>>> device = "cuda"
>>> model = GPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B", torch_dtype=torch.float16).to(device)
>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")

>>> prompt = (
...     "In a shocking finding, scientists discovered a herd of unicorns living in a remote, "
...     "previously unexplored valley, in the Andes Mountains. Even more surprising to the "
...     "researchers was the fact that the unicorns spoke perfect English."
... )

>>> input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(device)

>>> gen_tokens = model.generate(
...     input_ids,
...     do_sample=True,
...     temperature=0.9,
...     max_length=100,
... )
>>> gen_text = tokenizer.batch_decode(gen_tokens)[0]

資源

一系列官方 Hugging Face 和社群（以 🌎 標誌）資源，幫助您開始使用 GPT-J。如果您有興趣提交資源以包含在此處，請隨時提出拉取請求，我們將對其進行稽核！該資源最好能展示一些新東西，而不是重複現有資源。

文字生成

文件資源

GPTJConfig

class transformers.GPTJConfig

< >

( vocab_size = 50400 n_positions = 2048 n_embd = 4096 n_layer = 28 n_head = 16 rotary_dim = 64 n_inner = None activation_function = 'gelu_new' resid_pdrop = 0.0 embd_pdrop = 0.0 attn_pdrop = 0.0 layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True bos_token_id = 50256 eos_token_id = 50256 tie_word_embeddings = False **kwargs )

引數

  • vocab_size (int，可選，預設為 50400) — GPT-J 模型的詞彙表大小。定義了在呼叫 GPTJModel 時傳遞的 inputs_ids 可以表示的不同詞元的數量。
  • n_positions (int，可選，預設為 2048) — 該模型可能使用的最大序列長度。通常設定為一個較大的值以備不時之需（例如，512、1024 或 2048）。
  • n_embd (int，可選，預設為 4096) — 嵌入和隱藏狀態的維度。
  • n_layer (int，可選，預設為 28) — Transformer 編碼器中的隱藏層數量。
  • n_head (int，可選，預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • rotary_dim (int，可選，預設為 64) — 應用旋轉位置嵌入的嵌入維度數量。
  • n_inner (int，可選，預設為 None) — 內部前饋層的維度。None 將其設定為 n_embd 的 4 倍。
  • activation_function (str，可選，預設為 "gelu_new") — 啟用函式，可選列表為 ["relu", "silu", "gelu", "tanh", "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-5) — 在層歸一化層中使用的 epsilon 值。
  • initializer_range (float，可選，預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
  • use_cache (bool，可選，預設為 True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。

這是用於儲存 GPTJModel 配置的配置類。它用於根據指定的引數例項化一個 GPT-J 模型，定義模型架構。使用預設值例項化配置將產生與 GPT-J EleutherAI/gpt-j-6B 架構類似的配置。配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。

示例

>>> from transformers import GPTJModel, GPTJConfig

>>> # Initializing a GPT-J 6B configuration
>>> configuration = GPTJConfig()

>>> # Initializing a model from the configuration
>>> model = GPTJModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
Pytorch
隱藏 Pytorch 內容

GPTJModel

class transformers.GPTJModel

< >

( config )

引數

  • config (GPTJModel) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

裸 Gptj 模型，輸出原始隱藏狀態，頂部沒有任何特定的頭。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, tuple[tuple[torch.Tensor]], NoneType] = 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 use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length)，可選) — 詞彙表中輸入序列詞元的索引。預設情況下將忽略填充。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • past_key_values (Union[~cache_utils.Cache, tuple[tuple[torch.Tensor]], NoneType]) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當 use_cache=True 或 config.use_cache=True 時，由模型返回的 past_key_values。

    允許兩種格式：

    • Cache 例項，請參閱我們的 kv cache 指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳遞 past_key_values，將返回舊版快取格式。

    如果使用 past_key_values，使用者可以選擇只輸入形狀為 (batch_size, 1) 的最後一個 input_ids（即那些沒有為其提供過去鍵值狀態的 `input_ids`），而不是形狀為 (batch_size, sequence_length) 的所有 `input_ids`。

  • 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 句子* 標記。

    什麼是標記型別 ID？

  • position_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (torch.FloatTensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自 [0, 1]：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_dim), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果你想比模型內部的嵌入查詢矩陣有更多控制權來將 *input_ids* 索引轉換為關聯向量，這會很有用。
  • use_cache (bool, 可選) — 如果設定為 True，將返回 past_key_values 鍵值狀態，並可用於加速解碼（參見 past_key_values）。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參見返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
  • cache_position (torch.LongTensor，形狀為 (sequence_length), 可選) — 描述輸入序列標記在序列中位置的索引。與 position_ids 相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithPast 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），根據配置（GPTJConfig）和輸入包含各種元素。

  • last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

    如果使用了 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (Cache, 可選, 當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值，如果 `config.is_encoder_decoder=True`，則還包括交叉注意力塊中的鍵和值），可用於（參見 `past_key_values` 輸入）加速序列解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

GPTJModel 的前向方法，重寫了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

GPTJForCausalLM

class transformers.GPTJForCausalLM

< >

( config )

引數

  • config (GPTJForCausalLM) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

帶有語言建模頭的 GPT-J Transformer 模型。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, tuple[tuple[torch.Tensor]], NoneType] = 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 use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • past_key_values (Union[~cache_utils.Cache, tuple[tuple[torch.Tensor]], NoneType]) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當 use_cache=True 或 config.use_cache=True 時，由模型返回的 past_key_values。

    允許兩種格式：

    • Cache 例項，請參閱我們的 kv cache 指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳遞 past_key_values，將返回舊版快取格式。

    如果使用 past_key_values，使用者可以選擇只輸入形狀為 (batch_size, 1) 的最後一個 input_ids（即那些沒有為其提供過去鍵值狀態的 `input_ids`），而不是形狀為 (batch_size, sequence_length) 的所有 `input_ids`。

  • 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 句子* 標記。

    什麼是標記型別 ID？

  • position_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (torch.FloatTensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自 [0, 1]：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_dim), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果你想比模型內部的嵌入查詢矩陣有更多控制權來將 *input_ids* 索引轉換為關聯向量，這會很有用。
  • labels (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 語言建模的標籤。請注意，標籤在模型內部已移位，即你可以設定 labels = input_ids。索引選自 [-100, 0, ..., config.vocab_size]。所有設定為 -100 的標籤都會被忽略（遮蔽），損失僅對 [0, ..., config.vocab_size] 中的標籤進行計算。
  • use_cache (bool, 可選) — 如果設定為 True，將返回 past_key_values 鍵值狀態，並可用於加速解碼（參見 past_key_values）。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參見返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
  • cache_position (torch.LongTensor，形狀為 (sequence_length), 可選) — 描述輸入序列標記在序列中位置的索引。與 position_ids 相反，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），根據配置（GPTJConfig）和輸入包含各種元素。

  • loss (torch.FloatTensor 形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失（用於下一個 token 預測）。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。

  • past_key_values (Cache, 可選, 當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

GPTJForCausalLM 的前向方法，重寫了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

GPTJForSequenceClassification

class transformers.GPTJForSequenceClassification

< >

( config )

引數

  • config (GPTJForSequenceClassification) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

帶有序列分類頭（線性層）的 GPT-J Transformer 模型。

GPTJForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT、GPT-2、GPT-Neo）一樣。

由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果在配置中定義了 `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 past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = 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 use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • past_key_values (tuple[tuple[torch.Tensor]], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當 use_cache=True 或 config.use_cache=True 時，由模型返回的 past_key_values。

    允許兩種格式：

    • Cache 例項，請參閱我們的 kv cache 指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳遞 past_key_values，將返回舊版快取格式。

    如果使用 past_key_values，使用者可以選擇只輸入形狀為 (batch_size, 1) 的最後一個 input_ids（即那些沒有為其提供過去鍵值狀態的 `input_ids`），而不是形狀為 (batch_size, sequence_length) 的所有 `input_ids`。

  • 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 句子* 標記。

    什麼是標記型別 ID？

  • position_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選自範圍 [0, config.n_positions - 1]。

    什麼是位置 ID？

  • head_mask (torch.FloatTensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自 [0, 1]：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_dim), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞 input_ids。如果你想比模型內部的嵌入查詢矩陣有更多控制權來將 *input_ids* 索引轉換為關聯向量，這會很有用。
  • labels (torch.LongTensor，形狀為 (batch_size,), 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。如果 config.num_labels == 1，則計算迴歸損失（均方損失），如果 config.num_labels > 1，則計算分類損失（交叉熵）。
  • use_cache (bool, 可選) — 如果設定為 True，將返回 past_key_values 鍵值狀態，並可用於加速解碼（參見 past_key_values）。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參見返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.SequenceClassifierOutputWithPast 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置（GPTJConfig）和輸入而變化的不同元素。

  • loss (形狀為 (1,) 的 torch.FloatTensor，可選，當提供 labels 時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。

  • logits (形狀為 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。

  • past_key_values (Cache, 可選, 當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

GPTJForSequenceClassification 的 forward 方法會覆蓋 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

單標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, GPTJForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = GPTJForSequenceClassification.from_pretrained("EleutherAI/gpt-j-6B")

>>> 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 = GPTJForSequenceClassification.from_pretrained("EleutherAI/gpt-j-6B", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

多標籤分類示例

>>> import torch
>>> from transformers import AutoTokenizer, GPTJForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = GPTJForSequenceClassification.from_pretrained("EleutherAI/gpt-j-6B", 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 = GPTJForSequenceClassification.from_pretrained(
...     "EleutherAI/gpt-j-6B", 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

GPTJForQuestionAnswering

class transformers.GPTJForQuestionAnswering

< >

( config )

引數

  • config (GPTJForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。檢視 from_pretrained() 方法以載入模型權重。

Gptj transformer 模型，頂部帶有一個用於抽取式問答任務（如 SQuAD）的片段分類頭（在隱藏狀態輸出之上有一個線性層，用於計算 `span start logits` 和 `span end logits`）。

此模型繼承自 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 start_positions: typing.Optional[torch.LongTensor] = None end_positions: 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.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • 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* 的標記。

    什麼是標記型別 ID？

  • position_ids (torch.LongTensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 範圍內選擇。

    什麼是位置 ID？

  • head_mask (torch.FloatTensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值在 `[0, 1]` 中選擇：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_dim), 可選) — 可選地，你可以選擇直接傳遞嵌入表示而不是傳遞 input_ids。如果你想比模型內部嵌入查詢矩陣更好地控制如何將 *input_ids* 索引轉換為關聯向量，這會很有用。
  • start_positions (torch.LongTensor，形狀為 (batch_size,), 可選) — 標記的片段開始位置（索引）的標籤，用於計算標記分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置不計入損失計算。
  • end_positions (torch.LongTensor，形狀為 (batch_size,), 可選) — 標記的片段結束位置（索引）的標籤，用於計算標記分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置不計入損失計算。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一個 `torch.FloatTensor` 的元組（如果傳入 `return_dict=False` 或當 `config.return_dict=False` 時），包含根據配置（GPTJConfig）和輸入而變化的不同元素。

  • loss (torch.FloatTensor of shape (1,), 可選, 當提供 labels 時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 範圍結束分數（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 後的注意力權重，用於計算自注意力頭中的加權平均值。

GPTJForQuestionAnswering 的 forward 方法會覆蓋 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, GPTJForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = GPTJForQuestionAnswering.from_pretrained("EleutherAI/gpt-j-6B")

>>> 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)
...
TensorFlow
隱藏 TensorFlow 內容

TFGPTJModel

class transformers.TFGPTJModel

< >

( config *inputs **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。檢視 from_pretrained() 方法以載入模型權重。

基礎的 GPT-J Transformer 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。

該模型繼承自 TFPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是一個 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與一般用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數（如 PyTorch 模型），或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是，Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援，當使用像 `model.fit()` 這樣的方法時，一切應該“自然而然”地工作——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤！但是，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 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 past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = 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 use_cache: Optional[bool] = 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.TFBaseModelOutputWithPast or tuple(tf.Tensor)

引數

  • input_ids (Numpy 陣列 或 tf.Tensor，形狀為 (batch_size, input_ids_length)) — 如果 `past` 為 `None`，`input_ids_length` = `sequence_length`；否則 `input_ids_length` = `past[0].shape[-2]` (輸入過去鍵值狀態的 `sequence_length`)。詞彙表中輸入序列標記的索引。

    如果使用了 `past`，則只有那些尚未計算其 `past` 的輸入 ID 才應作為 `input_ids` 傳遞。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • past_key_values (長度為 config.n_layers 的 list[tf.Tensor]) — 包含由模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（參見下面的 `past` 輸出）。可用於加速序列解碼。已經給出其過去值的標記 ID 不應作為輸入 ID 傳遞，因為它們已經被計算過了。
  • attention_mask (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力操作的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示標記未被遮蔽，
    • 0 表示標記已被遮蔽。

    什麼是注意力掩碼？

  • token_type_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, input_ids_length), 可選) — 用於指示輸入的第一部分和第二部分的段標記索引。索引在 [0, 1] 中選擇：

    • 0 對應於 *句子 A* 的標記，
    • 1 對應於 *句子 B* 的標記。

    什麼是標記型別 ID？

  • position_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, input_ids_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.max_position_embeddings - 1]` 範圍內選擇。

    什麼是位置 ID？

  • head_mask (Numpy 陣列 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值在 `[0, 1]` 中選擇：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (tf.Tensor，形狀為 (batch_size, input_ids_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 模組在訓練和評估之間有不同的行為）。
  • use_cache (bool, 可選, 預設為 True) — 如果設定為 True，則返回 `past_key_values` 鍵值狀態，可用於加速解碼（參見 `past`）。在訓練期間設定為 `False`，在生成期間設定為 `True`。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPast 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFBaseModelOutputWithPast 或一個 `tf.Tensor` 的元組（如果傳入 `return_dict=False` 或當 `config.return_dict=False` 時），包含根據配置（GPTJConfig）和輸入而變化的不同元素。

  • last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

    如果使用了 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (list[tf.Tensor], 可選, 在傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 長度為 `config.n_layers` 的 `tf.Tensor` 列表，其中每個張量的形狀為 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFGPTJModel 的 forward 方法會覆蓋 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFGPTJModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = TFGPTJModel.from_pretrained("EleutherAI/gpt-j-6B")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFGPTJForCausalLM

class transformers.TFGPTJForCausalLM

< >

( config *inputs **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。檢視 from_pretrained() 方法以載入模型權重。

帶有語言建模頭的 GPT-J Transformer 模型。

該模型繼承自 TFPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是一個 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與一般用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數（如 PyTorch 模型），或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是，Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援，當使用像 `model.fit()` 這樣的方法時，一切應該“自然而然”地工作——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤！但是，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 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 past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = 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 labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = 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.TFCausalLMOutputWithPast or tuple(tf.Tensor)

引數

  • input_ids (Numpy 陣列 或 tf.Tensor，形狀為 (batch_size, input_ids_length)) — 如果 `past` 為 `None`，`input_ids_length` = `sequence_length`；否則 `input_ids_length` = `past[0].shape[-2]` (輸入過去鍵值狀態的 `sequence_length`)。詞彙表中輸入序列標記的索引。

    如果使用了 `past`，則只有那些尚未計算其 `past` 的輸入 ID 才應作為 `input_ids` 傳遞。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • past_key_values (長度為 config.n_layers 的 list[tf.Tensor]) — 包含由模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（參見下面的 `past` 輸出）。可用於加速序列解碼。已經給出其過去值的標記 ID 不應作為輸入 ID 傳遞，因為它們已經被計算過了。
  • attention_mask (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力操作的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示標記未被遮蔽，
    • 0 表示標記已被遮蔽。

    什麼是注意力掩碼？

  • token_type_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, input_ids_length), 可選) — 用於指示輸入的第一部分和第二部分的段標記索引。索引在 [0, 1] 中選擇：

    • 0 對應於 *句子 A* 的標記，
    • 1 對應於 *句子 B* 的標記。

    什麼是標記型別 ID？

  • position_ids (tf.Tensor 或 Numpy 陣列，形狀為 (batch_size, input_ids_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.max_position_embeddings - 1]` 範圍內選擇。

    什麼是位置 ID？

  • head_mask (Numpy 陣列 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值在 `[0, 1]` 中選擇：

    • 1 表示頭未被遮蔽，
    • 0 表示頭已被遮蔽。
  • inputs_embeds (tf.Tensor，形狀為 (batch_size, input_ids_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, optional, 預設為 False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。
  • labels (np.ndarray 或 tf.Tensor，形狀為 (batch_size, input_ids_length), optional) — 用於語言建模的標籤。請注意，標籤在模型內部會被 移動，例如，你可以設定 labels = input_ids。索引的選擇範圍是 [-100, 0, ..., config.vocab_size]。所有設定為 -100 的標籤都會被忽略（被遮蓋），損失僅對 [0, ..., config.vocab_size] 範圍內的標籤進行計算。

返回

transformers.modeling_tf_outputs.TFCausalLMOutputWithPast 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFCausalLMOutputWithPast 或一個 `tf.Tensor` 元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），包含的各種元素取決於配置（GPTJConfig）和輸入。

  • loss (形狀為(n,)的tf.Tensor，可選，其中n是非掩碼標籤的數量，當提供了labels時返回) — 語言建模損失（用於下一標記預測）。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。

  • past_key_values (list[tf.Tensor], 可選, 在傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 長度為 `config.n_layers` 的 `tf.Tensor` 列表，其中每個張量的形狀為 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFGPTJForCausalLM 的前向方法會覆蓋 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFGPTJForCausalLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFGPTJForSequenceClassification

class transformers.TFGPTJForSequenceClassification

< >

( config *inputs **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。

帶有序列分類頭（線性層）的 GPT-J Transformer 模型。

GPTJForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT、GPT-2、GPT-Neo）一樣。

由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果在配置中定義了 `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()` 支援的任何格式傳遞你的輸入和標籤！但是，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 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 past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = 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 labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = 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.TFSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)

引數

  • input_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, input_ids_length)) — 如果 past 為 None，則 input_ids_length = sequence_length，否則為 past[0].shape[-2]（輸入過去鍵值狀態的 sequence_length）。詞彙表中輸入序列詞元的索引。

    如果使用了 `past`，則只有那些尚未計算其過去狀態的輸入 ID 才應作為 `input_ids` 傳遞。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • past_key_values (list[tf.Tensor]，長度為 config.n_layers) — 包含由模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（見下面的 `past` 輸出）。可用於加速序列解碼。已經給出其過去狀態的詞元 ID 不應作為輸入 ID 傳遞，因為它們已經被計算過了。
  • attention_mask (tf.Tensor 或 Numpy array，形狀為 (batch_size, sequence_length), optional) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值選自 [0, 1]：

    • 1 表示詞元未被遮蓋，
    • 0 表示詞元被遮蓋。

    什麼是注意力掩碼？

  • token_type_ids (tf.Tensor 或 Numpy array，形狀為 (batch_size, input_ids_length), optional) — 分段詞元索引，用於指示輸入的第一部分和第二部分。索引選自 [0, 1]：

    • 0 對應一個 *句子 A* 的詞元，
    • 1 對應一個 *句子 B* 的詞元。

    什麼是詞元型別 ID？

  • position_ids (tf.Tensor 或 Numpy array，形狀為 (batch_size, input_ids_length), optional) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]。

    什麼是位置 ID？

  • head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), optional) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自 [0, 1]：

    • 1 表示頭未被遮蓋，
    • 0 表示頭被遮蓋。
  • inputs_embeds (tf.Tensor，形狀為 (batch_size, input_ids_length, hidden_size), optional) — 可選地，你可以不傳遞 `input_ids`，而是直接傳遞一個嵌入表示。如果你想比模型內部的嵌入查詢矩陣更能控制如何將 `input_ids` 索引轉換為相關向量，這將非常有用。
  • output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。此引數僅在即時模式下可用，在圖模式下將使用配置中的值。
  • output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。此引數僅在即時模式下可用，在圖模式下將使用配置中的值。
  • return_dict (bool, optional) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數在即時模式下可用，在圖模式下該值將始終設定為 True。
  • training (bool, optional, 預設為 False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。
  • labels (np.ndarray 或 tf.Tensor，形狀為 (batch_size,), optional) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。如果 config.num_labels == 1，則計算迴歸損失（均方損失）；如果 config.num_labels > 1，則計算分類損失（交叉熵）。

返回

transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast 或一個 `tf.Tensor` 元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），包含的各種元素取決於配置（GPTJConfig）和輸入。

  • loss (tf.Tensor，形狀為 (batch_size, )，可選，當提供 labels 時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。

  • logits (tf.Tensor，形狀為 (batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。

  • past_key_values (list[tf.Tensor], 可選, 在傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 長度為 `config.n_layers` 的 `tf.Tensor` 列表，其中每個張量的形狀為 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFGPTJForSequenceClassification 的前向方法會覆蓋 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFGPTJForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = TFGPTJForSequenceClassification.from_pretrained("EleutherAI/gpt-j-6B")

>>> 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 = TFGPTJForSequenceClassification.from_pretrained("EleutherAI/gpt-j-6B", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFGPTJForQuestionAnswering

class transformers.TFGPTJForQuestionAnswering

< >

( config *inputs **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。

GPT-J 模型轉換器，頂部帶有一個跨度分類頭，用於處理像 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()` 支援的任何格式傳遞你的輸入和標籤！但是，如果你想在 Keras 方法（如 `fit()` 和 `predict()`）之外使用第二種格式，例如在使用 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 past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = 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 start_positions: np.ndarray | tf.Tensor | None = None end_positions: 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.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

引數

  • input_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, input_ids_length)) — 如果 past 為 None，則 input_ids_length = sequence_length，否則為 past[0].shape[-2]（輸入過去鍵值狀態的 sequence_length）。詞彙表中輸入序列詞元的索引。

    如果使用了 `past`，則只有那些尚未計算其過去狀態的輸入 ID 才應作為 `input_ids` 傳遞。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什麼是輸入 ID？

  • past_key_values (list[tf.Tensor]，長度為 config.n_layers) — 包含由模型計算的預計算隱藏狀態（注意力塊中的鍵和值）（見下面的 `past` 輸出）。可用於加速序列解碼。已經給出其過去狀態的詞元 ID 不應作為輸入 ID 傳遞，因為它們已經被計算過了。
  • attention_mask (tf.Tensor 或 Numpy array，形狀為 (batch_size, sequence_length), optional) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值選自 [0, 1]：

    • 1 表示詞元未被遮蓋，
    • 0 表示詞元被遮蓋。

    什麼是注意力掩碼？

  • token_type_ids (tf.Tensor 或 Numpy array，形狀為 (batch_size, input_ids_length), optional) — 分段詞元索引，用於指示輸入的第一部分和第二部分。索引選自 [0, 1]：

    • 0 對應一個 *句子 A* 的詞元，
    • 1 對應一個 *句子 B* 的詞元。

    什麼是詞元型別 ID？

  • position_ids (tf.Tensor 或 Numpy array，形狀為 (batch_size, input_ids_length), optional) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]。

    什麼是位置 ID？

  • head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), optional) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自 [0, 1]：

    • 1 表示頭未被遮蓋，
    • 0 表示頭被遮蓋。
  • inputs_embeds (tf.Tensor，形狀為 (batch_size, input_ids_length, hidden_size), optional) — 可選地，你可以不傳遞 `input_ids`，而是直接傳遞一個嵌入表示。如果你想比模型內部的嵌入查詢矩陣更能控制如何將 `input_ids` 索引轉換為相關向量，這將非常有用。
  • output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。此引數僅在即時模式下可用，在圖模式下將使用配置中的值。
  • output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。此引數僅在即時模式下可用，在圖模式下將使用配置中的值。
  • return_dict (bool, optional) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數在即時模式下可用，在圖模式下該值將始終設定為 True。
  • training (bool, optional, 預設為 False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。
  • start_positions (np.ndarray 或 tf.Tensor，形狀為 (batch_size,), optional) — 用於計算詞元分類損失的標記跨度開始位置（索引）的標籤。位置會被限制在序列長度（`sequence_length`）內。序列之外的位置在計算損失時不予考慮。
  • end_positions (np.ndarray 或 tf.Tensor，形狀為 (batch_size,), optional) — 用於計算詞元分類損失的標記跨度結束位置（索引）的標籤。位置會被限制在序列長度（`sequence_length`）內。序列之外的位置在計算損失時不予考慮。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一個 `tf.Tensor` 元組（如果傳遞了 `return_dict=False` 或 `config.return_dict=False`），包含的各種元素取決於配置（GPTJConfig）和輸入。

  • loss (tf.Tensor，形狀為 (batch_size, ), optional, 當提供了 start_positions 和 end_positions 時返回) — 總跨度抽取損失是開始和結束位置的交叉熵之和。

  • start_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度起始分數（SoftMax 之前）。

  • end_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度結束分數（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 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFGPTJForQuestionAnswering 的前向方法會覆蓋 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFGPTJForQuestionAnswering
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> model = TFGPTJForQuestionAnswering.from_pretrained("EleutherAI/gpt-j-6B")

>>> 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]
>>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)
JAX
隱藏 JAX 內容

FlaxGPTJModel

class transformers.FlaxGPTJModel

< >

( config: GPTJConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
  • dtype (jax.numpy.dtype, optional, 預設為 jax.numpy.float32) — 計算的資料型別。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的 `dtype` 執行。

    請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。

    如果你希望更改模型引數的 dtype，請參閱 to_fp16() 和 to_bf16()。

基礎的 GPTJ 模型轉換器，輸出原始的隱藏狀態，頂部沒有任何特定的頭。

此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。

此模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax 模組一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。

最後，此模型支援固有的 JAX 功能，例如

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (numpy.ndarray，形狀為 (batch_size, input_ids_length)) — `input_ids_length` = `sequence_length`。詞彙表中輸入序列詞元的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是輸入 ID？

  • attention_mask (numpy.ndarray，形狀為 (batch_size, sequence_length), optional) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值選自 [0, 1]：

    • 1 表示詞元未被遮蓋，
    • 0 表示詞元被遮蓋。

    什麼是注意力掩碼？

  • position_ids (numpy.ndarray，形狀為 (batch_size, input_ids_length), optional) — 每個輸入序列詞元在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]。
  • past_key_values (dict[str, np.ndarray], optional, 由 init_cache 返回或在傳遞先前的 past_key_values 時返回) — 包含預計算隱藏狀態（注意力塊中的鍵和值）的字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 *[batch_size, max_length]*。
  • output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。
  • output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 物件而不是一個普通的元組。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (GPTJConfig) 和輸入而定的各種元素。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於詞嵌入的輸出，另一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

FlaxGPTJPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxGPTJModel

>>> tokenizer = AutoTokenizer.from_pretrained("gptj")
>>> model = FlaxGPTJModel.from_pretrained("gptj")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FlaxGPTJForCausalLM

class transformers.FlaxGPTJForCausalLM

< >

( config: GPTJConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (GPTJConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
  • dtype (jax.numpy.dtype, 可選, 預設為 jax.numpy.float32) — 計算的資料型別。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的 dtype 執行。

    請注意，這僅指定計算的資料型別，不影響模型引數的資料型別。

    如果你希望更改模型引數的資料型別，請參閱 to_fp16() 和 to_bf16()。

GPTJ Transformer 模型，頂部帶有一個語言建模頭。

此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解該庫為其所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。

此模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax 模組一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。

最後，此模型支援固有的 JAX 功能，例如

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (numpy.ndarray, 形狀為 (batch_size, input_ids_length)) — input_ids_length = sequence_length。輸入序列中詞元在詞彙表中的索引。

    索引可以使用 AutoTokenizer 獲取。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是 input IDs？

  • attention_mask (numpy.ndarray, 形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力機制的掩碼。掩碼值選自 [0, 1]：

    • 1 表示詞元未被掩碼，
    • 0 表示詞元被掩碼。

    什麼是 attention masks？

  • position_ids (numpy.ndarray, 形狀為 (batch_size, input_ids_length), 可選) — 每個輸入序列詞元在位置嵌入中的位置索引。選自範圍 [0, config.max_position_embeddings - 1]。
  • past_key_values (dict[str, np.ndarray], 可選, 由 init_cache 返回或在傳遞先前的 past_key_values 時返回) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）的字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 hidden_states。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 物件而不是一個普通的元組。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (GPTJConfig) 和輸入而定的各種元素。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於詞嵌入的輸出，另一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

FlaxGPTJPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式中定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理執行前後處理步驟，而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxGPTJForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("gptj")
>>> model = FlaxGPTJForCausalLM.from_pretrained("gptj")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]
< > 在 GitHub 上更新

←GPT NeoX Japanese GPT2→
© . This site is unofficial and not affiliated with Hugging Face, Inc.