Transformers 文件
LongT5
並獲得增強的文件體驗
開始使用
LongT5
概述
LongT5 模型由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在論文 LongT5: Efficient Text-To-Text Transformer for Long Sequences 中提出。它是一個在文字到文字去噪生成設定中預訓練的編碼器-解碼器 Transformer。LongT5 模型是 T5 模型的擴充套件，它支援使用兩種不同的高效注意力機制之一——（1）區域性注意力（Local attention），或（2）瞬時全域性注意力（Transient-Global attention）。
論文摘要如下：
最近的研究表明，（1）增加輸入長度或（2）增加模型大小都可以提高基於 Transformer 的神經模型的效能。在本文中，我們提出了一個名為 LongT5 的新模型，用它來探索同時擴充套件輸入長度和模型大小的效果。具體來說，我們將長輸入 Transformer（ETC）的注意力思想整合進來，並將摘要預訓練（PEGASUS）的預訓練策略應用於可擴充套件的 T5 架構中。其結果是一種我們稱之為 {\em 瞬時全域性} (TGlobal) 的新注意力機制，它模擬了 ETC 的區域性/全域性注意力機制，但不需要額外的側輸入。我們在幾個摘要任務上取得了最先進的結果，並在問答任務上優於原始的 T5 模型。
使用技巧
- LongT5ForConditionalGeneration 是 T5ForConditionalGeneration 的一個擴充套件，它將傳統的編碼器*自注意力*層替換為高效的*區域性*注意力或*瞬時全域性*（*tglobal*）注意力。
- 與 T5 模型不同，LongT5 不使用任務字首。此外，它使用了一種不同的預訓練目標，靈感來自於 PegasusForConditionalGeneration 的預訓練。
- LongT5 模型設計用於高效且出色地處理長距離*序列到序列*任務，其輸入序列長度超過了常用的 512 個 token。它能夠處理長度最多為 16,384 個 token 的輸入序列。
- 對於*區域性注意力*，稀疏的滑動視窗區域性注意力操作允許給定 token 只關注其左右各 `r` 個 token（預設 `r=127`）。*區域性注意力*不會給模型引入任何新引數。該機制的複雜度與輸入序列長度 `l` 呈線性關係：`O(l*r)`。
- 瞬時全域性注意力是*區域性注意力*的擴充套件。它進一步允許每個輸入 token 與層中的所有其他 token 進行互動。這是透過將輸入序列分割成固定長度 `k`（預設 `k=16`）的塊來實現的。然後，透過對塊中每個 token 的嵌入進行求和和歸一化，得到該塊的全域性 token。因此，注意力機制允許每個 token 既像區域性注意力一樣關注附近的 token，也像標準全域性注意力一樣關注每個全域性 token（“瞬時”表示全域性 token 是在每個注意力操作中動態構建的）。因此，*TGlobal* 注意力引入了一些新引數——全域性相對位置偏置和用於全域性 token 嵌入的層歸一化。該機制的複雜度為 `O(l(r + l/k))`。
- 下面是一個示例，展示瞭如何在 pubmed 資料集上評估一個微調過的 LongT5 模型。
>>> import evaluate
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> dataset = load_dataset("scientific_papers", "pubmed", split="validation")
>>> model = (
... LongT5ForConditionalGeneration.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
... .to("cuda")
... .half()
... )
>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
>>> def generate_answers(batch):
... inputs_dict = tokenizer(
... batch["article"], max_length=16384, padding="max_length", truncation=True, return_tensors="pt"
... )
... input_ids = inputs_dict.input_ids.to("cuda")
... attention_mask = inputs_dict.attention_mask.to("cuda")
... output_ids = model.generate(input_ids, attention_mask=attention_mask, max_length=512, num_beams=2)
... batch["predicted_abstract"] = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
... return batch
>>> result = dataset.map(generate_answer, batched=True, batch_size=2)
>>> rouge = evaluate.load("rouge")
>>> rouge.compute(predictions=result["predicted_abstract"], references=result["abstract"])資源
LongT5Config
class transformers.LongT5Config
< 原始碼 >( vocab_size = 32128 d_model = 512 d_kv = 64 d_ff = 2048 num_layers = 6 num_decoder_layers = None num_heads = 8 local_radius = 127 global_block_size = 16 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'relu' is_encoder_decoder = True encoder_attention_type = 'local' use_cache = True pad_token_id = 0 eos_token_id = 1 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 32128) — LongT5 模型的詞彙表大小。定義了在呼叫 LongT5Model 時，`inputs_ids` 可以表示的不同 token 的數量。 - d_model (
int, 可選, 預設為 512) — 編碼器層和池化層的大小。 - d_kv (
int, 可選, 預設為 64) — 每個注意力頭的鍵、查詢、值投影的大小。`d_kv` 必須等於 `d_model // num_heads`。 - d_ff (
int, 可選, 預設為 2048) — 每個 `LongT5Block` 中中間前饋層的大小。 - num_layers (
int, 可選, 預設為 6) — Transformer 編碼器中的隱藏層數量。 - num_decoder_layers (
int, 可選) — Transformer 解碼器中的隱藏層數量。如果未設定，將使用與 `num_layers` 相同的值。 - num_heads (
int, 可選, 預設為 8) — Transformer 編碼器中每個注意力層的注意力頭數量。 - local_radius (
int, 可選, 預設為 127) — 在區域性注意力機制中，每個 token 左右兩側進行區域性自注意力計算的 token 數量。 - global_block_size (
int, 可選, 預設為 16) — 用於將輸入序列劃分為塊以進行全域性 token 表示的塊長度。僅用於 `encoder_attention_type = "transient-global"`。 - relative_attention_num_buckets (
int, 可選, 預設為 32) — 每個注意力層使用的桶的數量。 - relative_attention_max_distance (
int, 可選, 預設為 128) — 用於桶分離的較長序列的最大距離。 - dropout_rate (
float, 可選, 預設為 0.1) — 所有 dropout 層的比率。 - layer_norm_eps (
float, 可選, 預設為 1e-6) — 層歸一化層使用的 epsilon 值。 - initializer_factor (
float, 可選, 預設為 1) — 用於初始化所有權重矩陣的因子（應保持為 1，內部用於初始化測試）。 - feed_forward_proj (
string, 可選, 預設為 `"relu"`) — 要使用的前饋層型別。應為 `"relu"` 或 `"gated-gelu"` 之一。LongT5v1.1 使用 `"gated-gelu"` 前饋投影。原始 LongT5 實現使用 `"gated-gelu"`。 - encoder_attention_type (
string, 可選, 預設為 `"local"`) — 要使用的編碼器注意力型別。應為 `"local"` 或 `"transient-global"` 之一，這些是 LongT5 實現支援的型別。 - use_cache (
bool, 可選, 預設為 `True`) — 模型是否應返回最後的鍵/值注意力（並非所有模型都使用）。
這是一個配置類，用於儲存 LongT5Model 或 FlaxLongT5Model 的配置。它根據指定的引數例項化一個 LongT5 模型，定義模型架構。使用預設值例項化配置將產生與 LongT5 google/long-t5-local-base 架構類似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。
LongT5Model
class transformers.LongT5Model
< source >( config: LongT5Config )
引數
- config (LongT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
無任何特定頭部的 LongT5 裸模型，輸出原始隱藏狀態。
該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = 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.Seq2SeqModelOutput or tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠在輸入的左側和右側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請參閱 LONGT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
LONGT5 使用
pad_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。要了解更多關於如何為預訓練準備
decoder_input_ids的資訊，請參閱 LONGT5 訓練。 - decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- decoder_head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使解碼器中自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使解碼器中交叉注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state（形狀為(batch_size, sequence_length, hidden_size)，可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.FloatTensor]]，可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
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（那些沒有為其提供過去鍵值狀態的 ID），而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這將非常有用。 - decoder_inputs_embeds (
torch.Tensor，形狀為(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞decoder_input_ids。如果使用past_key_values，可以選擇只輸入最後一個decoder_inputs_embeds（參見past_key_values）。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為相關向量，這將非常有用。如果
decoder_input_ids和decoder_inputs_embeds都未設定，decoder_inputs_embeds將取inputs_embeds的值。 - 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.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），根據配置 (LongT5Config) 和輸入包含不同的元素。
-
last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
EncoderDecoderCache，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出（如果模型有嵌入層），每個層一個輸出）。解碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出（如果模型有嵌入層），每個層一個輸出）。編碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
LongT5Model 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5Model.from_pretrained("google/long-t5-local-base")
>>> # Let's try a very long encoder input.
>>> input_ids = tokenizer(
... 100 * "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_stateLongT5ForConditionalGeneration
class transformers.LongT5ForConditionalGeneration
< source >( config: LongT5Config )
引數
- config (LongT5Config) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有一個 `language modeling` 頭的 LONGT5 模型。
該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_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 ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠在輸入的左側和右側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請參閱 LONGT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力操作的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
LONGT5 使用
pad_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。要了解更多關於如何為預訓練準備
decoder_input_ids的資訊，請參閱 LONGT5 訓練。 - decoder_attention_mask (
torch.BoolTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- decoder_head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使解碼器中自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使解碼器中交叉注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- encoder_outputs (
tuple[tuple[torch.Tensor]]，可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state（形狀為(batch_size, sequence_length, hidden_size)，可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.Tensor]]，可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
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（那些沒有為其提供過去鍵值狀態的 ID），而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這將非常有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞decoder_input_ids。如果使用past_key_values，可以選擇只輸入最後一個decoder_inputs_embeds（參見past_key_values）。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為相關向量，這將非常有用。如果
decoder_input_ids和decoder_inputs_embeds都未設定，decoder_inputs_embeds將取inputs_embeds的值。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[-100, 0, ..., config.vocab_size - 1]範圍內。所有設定為-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.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongT5Config）和輸入包含不同的元素。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
EncoderDecoderCache，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出（如果模型有嵌入層），每個層一個輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層的輸出（如果模型有嵌入層），每個層一個輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
LongT5ForConditionalGeneration 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
>>> model = LongT5ForConditionalGeneration.from_pretrained(
... "Stancld/longt5-tglobal-large-16384-pubmed-3k_steps"
... )
>>> # Let's try a very long input.
>>> inputs = tokenizer(100 * "studies have shown that owning a dog is good for you ", return_tensors="pt")
>>> input_ids = inputs.input_ids
>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
abstractthe aim of this article is to provide an overview of the literature on the role of dogLongT5EncoderModel
class transformers.LongT5EncoderModel
< source >( config: LongT5Config )
引數
- config (LongT5Config) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
無任何特定頭部的 LongT5 裸模型，輸出原始隱藏狀態。
該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = 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)) — 詞彙表中輸入序列詞元的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠對輸入的左右兩邊進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 LONGT5 訓練。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蓋，
- 0 表示詞元被遮蓋。
- 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 時），根據配置（LongT5Config）和輸入包含不同的元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LongT5EncoderModel 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5EncoderModel.from_pretrained("google/long-t5-local-base")
>>> input_ids = tokenizer(
... 100 * "Studies have been shown that owning a dog is good for you ", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_stateFlaxLongT5Model
class transformers.FlaxLongT5Model
< source >( config: LongT5Config input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: Array = None decoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠對輸入的左右兩邊進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 LONGT5 訓練。 - attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蓋，
- 0 表示詞元被遮蓋。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 解碼器輸入序列詞元在詞彙表中的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
LONGT5 使用
pad_token_id作為生成decoder_input_ids的起始詞元。如果使用past_key_values，可以選擇只輸入最後一個decoder_input_ids（請參閱past_key_values）。要了解如何為預訓練準備
decoder_input_ids，請參閱 LONGT5 訓練。 - decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。 - encoder_outputs (
tuple(tuple(jnp.ndarray), 可選) — 元組包含（last_hidden_state,可選: hidden_states,可選: attentions）。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple(tuple(jnp.ndarray))，長度為config.n_layers，每個元組包含 4 個形狀為(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的張量) — 包含預先計算的注意力塊的鍵和值隱藏狀態。可用於加速解碼。如果使用
past_key_values，使用者可以選擇只輸入最後一個decoder_input_ids（那些沒有為其提供過去鍵值狀態的詞元），其形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的decoder_input_ids。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongT5Config）和輸入包含不同的元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 在傳遞use_cache=True或config.use_cache=True時返回) —tuple(jnp.ndarray)的元組，長度為config.n_layers，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量和 2 個額外的形狀為(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的張量。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(jnp.ndarray), 可選, 在傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —jnp.ndarray的元組（一個是嵌入層的輸出 + 每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 在傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —jnp.ndarray的元組（一個是嵌入層的輸出 + 每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxLongT5PreTrainedModel 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5Model.from_pretrained("google/long-t5-local-base")
>>> input_ids = tokenizer(
... "Studies have been shown that owning a dog is good for you", return_tensors="np"
... ).input_ids
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="np").input_ids
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state編碼
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠對輸入的左右兩邊進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 LONGT5 訓練。 - attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蓋，
- 0 表示詞元被遮蓋。
- output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>）和輸入包含不同的元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)decode
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 解碼器輸入序列詞元在詞彙表中的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
對於訓練，應提供
decoder_input_ids。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元組包含（last_hidden_state, 可選:hidden_states, 可選:attentions）。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - encoder_attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蓋，
- 0 表示詞元被遮蓋。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，應根據你的需求進行修改。有關預設策略的更多資訊，請參閱論文中的圖 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.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>）和輸入包含不同的元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 在傳遞use_cache=True或config.use_cache=True時返回) —tuple(jnp.ndarray)的元組，長度為config.n_layers，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量，如果config.is_encoder_decoder=True，則還有 2 個額外的形狀為(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的張量。包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果
config.is_encoder_decoder=True，則還包含交叉注意力塊中的鍵和值），可用於（請參閱past_key_values輸入）加速序列解碼。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True且config.add_cross_attention=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> import jax.numpy as jnp
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logitsFlaxLongT5ForConditionalGeneration
class transformers.FlaxLongT5ForConditionalGeneration
< source >( config: LongT5Config input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: Array = None decoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。LongT5 是一個帶有相對位置嵌入的模型，因此你應該能夠對輸入的左右兩邊進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解如何為預訓練準備
input_ids，請參閱 LONGT5 訓練。 - attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蓋，
- 0 表示詞元被遮蓋。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 解碼器輸入序列詞元在詞彙表中的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
LONGT5 使用
pad_token_id作為生成decoder_input_ids的起始詞元。如果使用past_key_values，可以選擇只輸入最後一個decoder_input_ids（請參閱past_key_values）。要了解如何為預訓練準備
decoder_input_ids，請參閱 LONGT5 訓練。 - decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。 - encoder_outputs (
tuple(tuple(jnp.ndarray), 可選) — 元組包含 (last_hidden_state,可選: hidden_states,可選: attentions)。last_hidden_state的形狀為(batch_size, sequence_length, hidden_size)，是編碼器最後一層輸出的一系列隱藏狀態。用於解碼器的交叉注意力機制。 - past_key_values (
tuple(tuple(jnp.ndarray))，長度為config.n_layers，其中每個元組包含 4 個形狀為(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的張量) — 包含注意力塊的預計算鍵（key）和值（value）隱藏狀態。可用於加速解碼。如果使用
past_key_values，使用者可以選擇只輸入最後一個decoder_input_ids（即那些沒有為其提供過去鍵值狀態的decoder_input_ids），其形狀為(batch_size, 1)，而不是輸入所有形狀為(batch_size, sequence_length)的decoder_input_ids。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongT5Config）和輸入包含不同的元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 在傳遞use_cache=True或config.use_cache=True時返回) —tuple(jnp.ndarray)的元組，長度為config.n_layers，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量和 2 個額外的形狀為(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的張量。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(jnp.ndarray), 可選, 在傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —jnp.ndarray的元組（一個是嵌入層的輸出 + 每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 在傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —jnp.ndarray的元組（一個是嵌入層的輸出 + 每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxLongT5PreTrainedModel 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳播的邏輯需要在此函式內定義，但之後應該呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> ARTICLE_TO_SUMMARIZE = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], return_tensors="np")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"]).sequences
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=False))編碼
< 來源 >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。LongT5 是一個帶有相對位置嵌入的模型，因此您應該能夠在輸入的左側和右側進行填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids的資訊，請參閱 LONGT5 訓練。 - attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示未被遮蔽的詞元，
- 0 表示被遮蔽的詞元。
- output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>）和輸入包含不同的元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)decode
< 來源 >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 詞彙表中解碼器輸入序列詞元的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
對於訓練，應提供
decoder_input_ids。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。last_hidden_state的形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的一系列隱藏狀態。用於解碼器的交叉注意力機制。 - encoder_attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示未被遮蔽的詞元，
- 0 表示被遮蔽的詞元。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。如果您想更改填充行為，應根據您的需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 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.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.longt5.configuration_longt5.LongT5Config'>）和輸入，包含各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 在傳遞output_attentions=True或config.output_attentions=True時返回) —jnp.ndarray的元組（每一層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
tuple(tuple(jnp.ndarray)), 可選，在傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的jnp.ndarray元組的元組，其中每個元組包含自注意力和交叉注意力層的快取鍵、值狀態（如果模型在編碼器-解碼器設定中使用）。僅當config.is_decoder = True時相關。包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。
示例
>>> from transformers import AutoTokenizer, FlaxLongT5ForConditionalGeneration
>>> import jax.numpy as jnp
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = FlaxLongT5ForConditionalGeneration.from_pretrained("google/long-t5-local-base")
>>> text = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits