Transformers 文件
飛馬座 (Pegasus)
並獲得增強的文件體驗
開始使用
飛馬座 (Pegasus)
Pegasus是一個編碼器-解碼器（序列到序列）的轉換器模型，經過無標籤文字的預訓練，以執行抽象摘要。Pegasus在兩個自監督目標函式上聯合訓練：掩蔽語言建模（MLM）和間隙句子生成（GSG）。整個句子被掩蔽，模型必須填補文件中的空白。即使在只有1000個示例的小資料集上，它也能以良好的效能進行微調。
您可以在Google組織下找到所有原始的Pegasus檢查點。
點選右側邊欄中的Pegasus模型，檢視更多關於如何將Pegasus應用於不同語言任務的示例。
以下示例演示瞭如何使用Pipeline、AutoModel和命令列來總結文字。
import torch
from transformers import pipeline
pipeline = pipeline(
task="summarization",
model="google/pegasus-xsum",
torch_dtype=torch.float16,
device=0
)
pipeline("""Plants are remarkable organisms that produce their own food using a method called photosynthesis.
This process involves converting sunlight, carbon dioxide, and water into glucose, which provides energy for growth.
Plants play a crucial role in sustaining life on Earth by generating oxygen and serving as the foundation of most ecosystems.""")量化透過以較低精度表示權重來減少大型模型的記憶體負擔。有關更多可用量化後端，請參閱量化概述。
以下示例使用 bitsandbytes 將權重僅量化為 int4。
import torch
from transformers import BitsAndBytesConfig, AutoModelForSeq2SeqLM, AutoTokenizer
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google/pegasus-xsum",
torch_dtype=torch.bfloat16,
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained(
"google/pegasus-xsum"
)
input_text = """Plants are remarkable organisms that produce their own food using a method called photosynthesis.
This process involves converting sunlight, carbon dioxide, and water into glucose, which provides energy for growth.
Plants play a crucial role in sustaining life on Earth by generating oxygen and serving as the foundation of most ecosystems."""
input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))注意事項
AdaFactor是微調Pegasus的推薦最佳化器。- 此Pegasus實現繼承自BartForConditionalGeneration，但它使用靜態/正弦位置嵌入。Pegasus還以
pad_token_id作為字首開始生成，並使用num_beams=8。
PegasusConfig
class transformers.PegasusConfig
< 來源 >( vocab_size = 50265 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 0 scale_embedding = False pad_token_id = 0 eos_token_id = 1 forced_eos_token_id = 1 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 50265) — PEGASUS模型的詞彙表大小。定義了呼叫PegasusModel或TFPegasusModel時可以透過inputs_ids表示的不同token的數量。 - d_model (
int, 可選, 預設為 1024) — 層和池化層的維度。 - encoder_layers (
int, 可選, 預設為 12) — 編碼器層的數量。 - decoder_layers (
int, 可選, 預設為 12) — 解碼器層的數量。 - encoder_attention_heads (
int, 可選, 預設為 16) — Transformer編碼器中每個注意力層的注意力頭數量。 - decoder_attention_heads (
int, 可選, 預設為 16) — Transformer解碼器中每個注意力層的注意力頭數量。 - decoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”（通常稱為前饋）層的維度。 - encoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”（通常稱為前饋）層的維度。 - activation_function (
str或function, 可選, 預設為"gelu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。如果是字串，支援"gelu"、"relu"、"silu"和"gelu_new"。 - dropout (
float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化器中所有全連線層的丟棄機率。 - attention_dropout (
float, 可選, 預設為 0.0) — 注意力機率的丟棄率。 - activation_dropout (
float, 可選, 預設為 0.0) — 全連線層內部啟用的丟棄率。 - max_position_embeddings (
int, 可選, 預設為 1024) — 此模型可能使用的最大序列長度。通常設定為一個較大的值以防萬一（例如，512、1024或2048）。 - init_std (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的truncated_normal_initializer的標準差。 - encoder_layerdrop (
float, 可選, 預設為 0.0) — 編碼器的LayerDrop機率。更多詳情請參見[LayerDrop論文](參見https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, 可選, 預設為 0.0) — 解碼器的LayerDrop機率。更多詳情請參見[LayerDrop論文](參見https://huggingface.co/papers/1909.11556)。 - scale_embedding (
bool, 可選, 預設為False) — 透過除以sqrt(d_model)來縮放嵌入。 - use_cache (
bool, 可選, 預設為True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。 - forced_eos_token_id (
int, 可選, 預設為 1) — 達到max_length時強制作為最後一個生成的token的ID。通常設定為eos_token_id。
這是用於儲存PegasusModel配置的配置類。它用於根據指定引數例項化PEGASUS模型，定義模型架構。使用預設值例項化配置將產生類似於PEGASUS google/pegasus-large架構的配置。
配置物件繼承自PretrainedConfig，可用於控制模型輸出。有關更多資訊，請參閱PretrainedConfig的文件。
示例
>>> from transformers import PegasusConfig, PegasusModel
>>> # Initializing a PEGASUS google/pegasus-large style configuration
>>> configuration = PegasusConfig()
>>> # Initializing a model (with random weights) from the google/pegasus-large style configuration
>>> model = PegasusModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configPegasusTokenizer
警告：add_tokens目前無法工作。
class transformers.PegasusTokenizer
< 來源 >( vocab_file pad_token = '<pad>' eos_token = '</s>' unk_token = '<unk>' mask_token = '<mask_2>' mask_token_sent = '<mask_1>' additional_special_tokens = None offset = 103 sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None **kwargs )
引數
- vocab_file (
str) — SentencePiece檔案（通常以.spm副檔名結尾），其中包含例項化分詞器所需的詞彙表。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的token，例如當批次處理不同長度的序列時。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束符。當使用特殊標記構建序列時，這不是用於序列結束的標記。所使用的標記是
sep_token。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為ID，而是設定為此標記。 - mask_token (
str, 可選, 預設為"<mask_2>") — 用於遮蔽單個標記值的標記。這是使用遮蔽語言建模 (MLM) 訓練此模型時使用的標記。這是 PEGASUS 編碼器在預訓練期間嘗試預測的標記。它對應於 PEGASUS: 用於抽象摘要的提取式句子生成預訓練 中的 [MASK2]。 - mask_token_sent (
str, 可選, 預設為"<mask_1>") — 用於遮蔽整個目標句子的標記。這是使用間隙句子生成 (GSG) 訓練此模型時使用的標記。這是 PEGASUS 解碼器在預訓練期間嘗試預測的句子。它對應於 PEGASUS: 用於抽象摘要的提取式句子生成預訓練 中的 [MASK1]。 - additional_special_tokens (
List[str], 可選) — 標記器使用的額外特殊標記。如果未提供額外的特殊標記，則使用 <mask_2> 和 <unk_2, …, unk_102> 作為額外的特殊標記，對應於 原始 PEGASUS 標記器，該標記器僅在預訓練時使用標記 2 - 104。 - sp_model_kwargs (
dict, 可選) — 將傳遞給SentencePieceProcessor.__init__()方法。 SentencePiece 的 Python 包裝器 可用於設定（其中包括）：-
enable_sampling: 啟用子詞正則化。 -
nbest_size: Unigram 取樣引數。對於 BPE-Dropout 無效。nbest_size = {0,1}: 不執行取樣。nbest_size > 1: 從 nbest_size 結果中取樣。nbest_size < 0: 假設 nbest_size 是無限的，並使用前向濾波和後向取樣演算法從所有假設（格）中取樣。
-
alpha: 用於 unigram 取樣的平滑引數，以及用於 BPE-dropout 的合併操作的 dropout 機率。
-
構建 PEGASUS 標記器。基於 SentencePiece。
此標記器繼承自 PreTrainedTokenizer，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< source >( token_ids_0 token_ids_1 = None ) → List[int]
透過連線和新增特殊標記，為序列分類任務從一個序列或一對序列構建模型輸入。PEGASUS 序列具有以下格式，其中 X 表示序列
- 單個序列：
X </s> - 序列對：
A B </s>（不推薦使用）
從不使用 BOS。序列對不是預期的用例，但它們將在沒有分隔符的情況下處理。
將標記序列（字串）轉換為單個字串。
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list] = None already_has_special_tokens: bool = False )
獲取一個列表，其中如果標記是 [eos] 或 [pad]，則條目為 [1]，否則為 0。
僅 EOS
PegasusTokenizerFast
class transformers.PegasusTokenizerFast
< source >( vocab_file = None tokenizer_file = None pad_token = '<pad>' eos_token = '</s>' unk_token = '<unk>' mask_token = '<mask_2>' mask_token_sent = '<mask_1>' additional_special_tokens = None offset = 103 **kwargs )
引數
- vocab_file (
str) — SentencePiece 檔案（通常具有 .spm 副檔名），其中包含例項化標記器所需的詞彙表。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的標記，例如在批處理不同長度的序列時。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束符。當使用特殊標記構建序列時，這不是用於序列結束的標記。所使用的標記是
sep_token。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，而是設定為此標記。 - mask_token (
str, 可選, 預設為"<mask_2>") — 用於遮蔽單個標記值的標記。這是使用遮蔽語言建模 (MLM) 訓練此模型時使用的標記。這是 PEGASUS 編碼器在預訓練期間嘗試預測的標記。它對應於 PEGASUS: 用於抽象摘要的提取式句子生成預訓練 中的 [MASK2]。 - mask_token_sent (
str, 可選, 預設為"<mask_1>") — 用於遮蔽整個目標句子的標記。這是使用間隙句子生成 (GSG) 訓練此模型時使用的標記。這是 PEGASUS 解碼器在預訓練期間嘗試預測的句子。它對應於 PEGASUS: 用於抽象摘要的提取式句子生成預訓練 中的 [MASK1]。 - additional_special_tokens (
List[str], 可選) — 標記器使用的額外特殊標記。如果未提供額外的特殊標記，則使用 <mask_2> 和 <unk_2, …, unk_102> 作為額外的特殊標記，對應於 原始 PEGASUS 標記器，該標記器僅在預訓練時使用標記 2 - 104。
構建一個“快速”PEGASUS 標記器（由 HuggingFace 的 tokenizers 庫支援）。基於 Unigram。
此標記器繼承自 PreTrainedTokenizerFast，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< source >( token_ids_0 token_ids_1 = None ) → List[int]
透過在末尾新增 EOS 構建序列的模型輸入。前端不新增 BOS 標記。
- 單個序列：
X </s> - 序列對：
A B </s>（不推薦使用）
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list] = None already_has_special_tokens: bool = False )
獲取一個列表，其中如果標記是 [eos] 或 [pad]，則條目為 [1]，否則為 0。
PegasusModel
class transformers.PegasusModel
< source >( config: PegasusConfig )
引數
- config (PegasusConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不載入與模型關聯的權重，僅載入配置。檢視 from_pretrained() 方法載入模型權重。
裸 Pegasus 模型輸出原始隱藏狀態，頂部沒有任何特定頭部。
此模型繼承自 PreTrainedModel。檢視超類文件以獲取庫為其所有模型實現的一般方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參閱 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[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.Tensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 詞彙表中輸入序列標記的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示未被遮蔽的標記，
- 0 表示被遮蔽的標記。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的torch.LongTensor, 可選) — 解碼器輸入序列標記在詞彙表中的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Pegasus 使用
pad_token_id作為decoder_input_ids生成的起始標記。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的），形狀為(batch_size, 1)，而不是所有input_ids的形狀(batch_size, sequence_length)。 - decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的torch.LongTensor, 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor, 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭部未被遮蔽，
- 0 表示頭部被遮蔽。
- decoder_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可選) — 用於使解碼器中注意力模組的選定頭部無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭部未被遮蔽，
- 0 表示頭部被遮蔽。
- cross_attn_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可選) — 用於使解碼器中交叉注意力模組的選定頭部無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭部未被遮蔽，
- 0 表示頭部被遮蔽。
- encoder_outputs (
tuple[torch.FloatTensor], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[torch.FloatTensor], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含兩個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也被稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，則將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後一個input_ids（那些沒有將其過去的鍵值狀態提供給此模型的），形狀為(batch_size, 1)，而不是所有input_ids的形狀(batch_size, sequence_length)。 - inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.Tensor, 可選) — （可選）您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為關聯向量有比模型內部嵌入查詢矩陣更多的控制，這會很有用。 - decoder_inputs_embeds (形狀為
(batch_size, target_sequence_length, hidden_size)的torch.Tensor, 可選) — （可選）您可以選擇直接傳遞嵌入表示，而不是傳遞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 (形狀為
(sequence_length)的torch.Tensor, 可選) — 表示輸入序列標記在序列中的位置的索引。與position_ids不同，此張量不受填充影響。它用於在正確位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (PegasusConfig) 和輸入的不同元素。
-
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 之後，用於計算自注意力頭中的加權平均。
PegasusModel forward 方法，覆蓋 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, PegasusModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> model = PegasusModel.from_pretrained("google/pegasus-large")
>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_inputs = tokenizer("Studies show that", return_tensors="pt")
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_inputs.input_ids)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 4, 1024]PegasusForConditionalGeneration
class transformers.PegasusForConditionalGeneration
< source >( config: PegasusConfig )
引數
- config (PegasusConfig) — 模型的配置類，包含模型的所有引數。用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
帶語言建模頭的 PEGASUS 模型。可用於摘要。
此模型繼承自 PreTrainedModel。檢視超類文件以獲取庫為其所有模型實現的一般方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參閱 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None labels: 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.Tensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免在填充 token 索引上執行注意力。掩碼值選擇範圍為[0, 1]：- 1 表示 token 未被掩碼，
- 0 表示 token 被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Pegasus 使用
pad_token_id作為decoder_input_ids生成的起始 token。如果使用past_key_values，可以選擇只輸入最後一個decoder_input_ids（那些沒有將過去鍵值狀態提供給此模型的 token）（請參閱past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充 token 的張量。預設情況下也會使用因果掩碼。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將自注意力模組的選定頭部置空。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- decoder_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 掩碼，用於將解碼器中注意力模組的選定頭部置空。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 掩碼，用於將解碼器中交叉注意力模組的選定頭部置空。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- encoder_outputs (
tuple[torch.FloatTensor]，可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)last_hidden_state形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
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，使用者可以選擇只輸入最後一個input_ids（那些沒有將過去鍵值狀態提供給此模型的 token），其形狀為(batch_size, 1)，而不是所有input_ids的形狀(batch_size, sequence_length)。 - 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的值。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[0, ..., config.vocab_size]或 -100 之間（請參閱input_ids文件字串）。索引設定為-100的 token 將被忽略（掩碼），損失只針對標籤在[0, ..., config.vocab_size]中的 token 計算。 - 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.Tensor，形狀為(sequence_length)，可選) — 描述輸入序列 token 在序列中位置的索引。與position_ids不同，此張量不受填充影響。它用於在正確位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置 (PegasusConfig) 和輸入的不同元素。
-
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 之後，用於計算自注意力頭中的加權平均。
PegasusForConditionalGeneration 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
摘要示例
>>> from transformers import AutoTokenizer, PegasusForConditionalGeneration
>>> model = PegasusForConditionalGeneration.from_pretrained("google/pegasus-xsum")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-xsum")
>>> ARTICLE_TO_SUMMARIZE = (
... "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer(ARTICLE_TO_SUMMARIZE, max_length=1024, return_tensors="pt")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"])
>>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"California's largest electricity provider has turned off power to hundreds of thousands of customers."PegasusForCausalLM
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[list[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 ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免在填充 token 索引上執行注意力。掩碼值選擇範圍為[0, 1]：- 1 表示 token 未被掩碼，
- 0 表示 token 被掩碼。
- encoder_hidden_states (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 編碼器最後一層輸出的隱藏狀態序列。如果模型被配置為解碼器，則用於交叉注意力。 - encoder_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免在編碼器輸入的填充 token 索引上執行注意力。如果模型被配置為解碼器，則此掩碼用於交叉注意力。掩碼值選擇範圍為[0, 1]：- 1 表示 token 未被掩碼，
- 0 表示 token 被掩碼。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將自注意力模組的選定頭部置空。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 掩碼，用於將交叉注意力模組的選定頭部置空。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部被掩碼。
- past_key_values (
list[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，使用者可以選擇只輸入最後一個input_ids（那些沒有將過去鍵值狀態提供給此模型的 token），其形狀為(batch_size, 1)，而不是所有input_ids的形狀(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對如何將input_ids索引轉換為相關向量比模型內部的嵌入查詢矩陣有更多的控制，這會很有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[0, ..., config.vocab_size]或 -100 之間（請參閱input_ids文件字串）。索引設定為-100的 token 將被忽略（掩碼），損失只針對標籤在[0, ..., config.vocab_size]中的 token 計算。 - 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)，可選) — 描述輸入序列 token 在序列中位置的索引。與position_ids不同，此張量不受填充影響。它用於在正確位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置 (PegasusConfig) 和輸入的不同元素。
-
loss (
torch.FloatTensor形狀為(1,)，可選，當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（如果模型有嵌入層，則其中一個用於嵌入層輸出，加上每個層的一個輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
Cache，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。
PegasusForCausalLM 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, PegasusForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> model = PegasusForCausalLM.from_pretrained("google/pegasus-large", add_cross_attention=False)
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
TrueTFPegasusModel
class transformers.TFPegasusModel
< source >( config: PegasusConfig *inputs **kwargs )
引數
- config (PegasusConfig) — 模型的配置類，包含模型的所有引數。用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
裸 PEGASAUS 模型，輸出原始隱藏狀態，不帶任何特定頭部。此模型繼承自 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 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[Union[tuple, TFBaseModelOutput]] = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_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: bool = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免在填充 token 索引上執行注意力。掩碼值選擇範圍為[0, 1]：- 1 表示 token 未被掩碼，
- 0 表示 token 被掩碼。
- decoder_input_ids (
tf.Tensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列 token 的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Pegasus 使用
pad_token_id作為decoder_input_ids生成的起始 token。如果使用past_key_values，可以選擇只輸入最後一個decoder_input_ids（那些沒有將過去鍵值狀態提供給此模型的 token）（請參閱past_key_values）。 - decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的tf.Tensor，可選) — 預設情況下會自動生成並忽略填充標記。在大多數使用場景下不建議手動設定此引數。 - decoder_position_ids (形狀為
(batch_size, sequence_length)的tf.Tensor，可選) — 解碼器輸入序列中每個標記在位置嵌入中的索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - head_mask (形狀為
(encoder_layers, encoder_attention_heads)的tf.Tensor，可選) — 用於使編碼器中注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- decoder_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的tf.Tensor，可選) — 用於使解碼器中注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- cross_attn_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的tf.Tensor，可選) — 用於使交叉注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- encoder_outputs (
tf.FloatTensor，可選) — 編碼器最後一層輸出的隱藏狀態。用於解碼器的交叉注意力。形狀為(batch_size, sequence_length, hidden_size)的序列。 - past_key_values (長度為
config.n_layers的tuple[tuple[tf.Tensor]]) — 包含注意力塊的預計算鍵值隱藏狀態。可用於加速解碼。如果使用past_key_values，使用者可以選擇僅輸入最後一個decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的）形狀為(batch_size, 1)，而不是所有decoder_input_ids形狀為(batch_size, sequence_length)。 - inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這很有用。 - use_cache (
bool，可選，預設為True) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。在訓練期間設定為False，在生成期間設定為True。output_attentions (bool，可選)：是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。此引數可在 eager 模式下使用，在 graph 模式下此值始終設定為True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
返回
transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
一個 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一個 tf.Tensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含取決於配置 (PegasusConfig) 和輸入的各種元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
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輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —tf.Tensor元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —tf.Tensor元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
TFPegasusModel 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFPegasusModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> model = TFPegasusModel.from_pretrained("google/pegasus-large")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFPegasusForConditionalGeneration
class transformers.TFPegasusForConditionalGeneration
< source >( config *inputs **kwargs )
引數
- config (PegasusConfig) — 帶有模型所有引數的模型配置類。用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言建模頭的 PEGASUS 模型。可用於摘要。此模型繼承自 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 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[TFBaseModelOutput] = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_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 labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
引數
- input_ids (形狀為
({0})的tf.Tensor) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- attention_mask (形狀為
({0})的tf.Tensor，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示未被掩蓋的標記，
- 0 表示被掩蓋的標記。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的tf.Tensor，可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
Pegasus 使用
pad_token_id作為decoder_input_ids生成的起始標記。如果使用past_key_values，可選地只需輸入最後一個decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的），形狀為(batch_size, 1)。 - decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的tf.Tensor，可選) — 預設情況下會自動生成並忽略填充標記。在大多數使用場景下不建議手動設定此引數。 - decoder_position_ids (形狀為
(batch_size, sequence_length)的tf.Tensor，可選) — 解碼器輸入序列中每個標記在位置嵌入中的索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - head_mask (形狀為
(encoder_layers, encoder_attention_heads)的tf.Tensor，可選) — 用於使編碼器中注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- decoder_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的tf.Tensor，可選) — 用於使解碼器中注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- cross_attn_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的tf.Tensor，可選) — 用於使交叉注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
- encoder_outputs (
tf.FloatTensor，可選) — 編碼器最後一層輸出的隱藏狀態。用於解碼器的交叉注意力。形狀為(batch_size, sequence_length, hidden_size)的序列。 - past_key_values (長度為
config.n_layers的tuple[tuple[tf.Tensor]]) — 包含注意力塊的預計算鍵值隱藏狀態。可用於加速解碼。如果使用past_key_values，使用者可以選擇僅輸入最後一個decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的）形狀為(batch_size, 1)，而不是所有decoder_input_ids形狀為(batch_size, sequence_length)。 - inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望對input_ids索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這很有用。 - use_cache (
bool，可選，預設為True) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。在訓練期間設定為False，在生成期間設定為True。output_attentions (bool，可選)：是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。此引數可在 eager 模式下使用，在 graph 模式下此值始終設定為True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。 - labels (形狀為
(batch_size, sequence_length)的tf.tensor，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[0, ..., config.vocab_size]範圍內或為 -100（參見input_ids文件字串）。索引設定為-100的標記將被忽略（掩碼），損失僅針對標籤在[0, ..., config.vocab_size]範圍內的標記計算。
返回
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
一個 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一個 tf.Tensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含取決於配置 (PegasusConfig) 和輸入的各種元素。
-
loss (形狀為
(n,)的tf.Tensor, 可選, 其中 n 是非掩碼標籤的數量，當提供labels時返回) — 語言建模損失。 -
logits (
tf.Tensorof 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輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —tf.Tensor元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —tf.Tensor元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
TFPegasusForConditionalGeneration 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
摘要示例
>>> from transformers import AutoTokenizer, TFPegasusForConditionalGeneration
>>> model = TFPegasusForConditionalGeneration.from_pretrained("google/pegasus-xsum")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-xsum")
>>> ARTICLE_TO_SUMMARIZE = (
... "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer(ARTICLE_TO_SUMMARIZE, max_length=1024, return_tensors="tf")
>>> # Generate Summary
>>> summary_ids = model.generate(input_ids)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))FlaxPegasusModel
class transformers.FlaxPegasusModel
< source >( config: PegasusConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (PegasusConfig) — 帶有模型所有引數的模型配置類。用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
- dtype (
jax.numpy.dtype，可選，預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的
dtype執行。請注意，這僅指定計算的資料型別，不影響模型引數的資料型別。
裸 Pegasus 模型 transformer 輸出原始隱藏狀態，頂部沒有任何特定頭部。此模型繼承自 FlaxPreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 Flax Linen flax.nn.Module 子類。將其用作常規 Flax 模組，並參閱 Flax 文件以瞭解所有與一般用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: 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.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的jnp.ndarray) — 詞彙表中輸入序列 token 的索引。如果提供填充，預設情況下將忽略它。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray, 可選) — 掩碼，用於避免對填充 token 索引執行注意力。掩碼值在[0, 1]中選擇：- 1 表示 未掩碼 的 token，
- 0 表示 已掩碼 的 token。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的jnp.ndarray, 可選) — 解碼器輸入序列 token 在詞彙表中的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的jnp.ndarray, 可選) — 預設行為：生成一個忽略decoder_input_ids中填充 token 的張量。預設情況下也將使用因果掩碼。如果想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]中選擇。 - decoder_position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個解碼器輸入序列 token 在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]中選擇。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），根據配置（PegasusConfig）和輸入包含各種元素。
-
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時返回) — 長度為config.n_layers的tuple(jnp.ndarray)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxPegasusPreTrainedModel forward 方法，覆蓋 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, FlaxPegasusModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> model = FlaxPegasusModel.from_pretrained("google/pegasus-large")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state編碼
< 來源 >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: 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 (形狀為
(batch_size, sequence_length)的jnp.ndarray) — 詞彙表中輸入序列 token 的索引。如果提供填充，預設情況下將忽略它。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray, 可選) — 掩碼，用於避免對填充 token 索引執行注意力。掩碼值在[0, 1]中選擇：- 1 表示 未掩碼 的 token，
- 0 表示 已掩碼 的 token。
- position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]中選擇。 - 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.pegasus.configuration_pegasus.PegasusConfig'>）和輸入包含各種元素。
-
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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
示例
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)解碼
< 來源 >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: 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 (形狀為
(batch_size, target_sequence_length)的jnp.ndarray) — 解碼器輸入序列 token 在詞彙表中的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元組由 (last_hidden_state, 可選:hidden_states, 可選:attentions) 組成，其中last_hidden_state形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - encoder_attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray, 可選) — 掩碼，用於避免對填充 token 索引執行注意力。掩碼值在[0, 1]中選擇：- 1 表示 未掩碼 的 token，
- 0 表示 已掩碼 的 token。
- decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的jnp.ndarray, 可選) — 預設行為：生成一個忽略decoder_input_ids中填充 token 的張量。預設情況下也將使用因果掩碼。如果想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- decoder_position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個解碼器輸入序列 token 在位置嵌入中的位置索引。在範圍[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.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），根據配置（<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>）和輸入包含各種元素。
-
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時返回) — 長度為config.n_layers的tuple(jnp.ndarray)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True和config.add_cross_attention=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
示例
>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, 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)
>>> last_decoder_hidden_states = outputs.last_hidden_stateFlaxPegasusForConditionalGeneration
class transformers.FlaxPegasusForConditionalGeneration
< 來源 >( config: PegasusConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (PegasusConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不載入與模型關聯的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
- dtype (
jax.numpy.dtype, 可選, 預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的
dtype執行。請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。
帶語言建模頭的 PEGASUS 模型。可用於摘要。此模型繼承自 FlaxPreTrainedModel。檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 Flax Linen flax.nn.Module 子類。將其用作常規 Flax 模組，並參閱 Flax 文件以瞭解所有與一般用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 來源 >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: 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 (形狀為
(batch_size, sequence_length)的jnp.ndarray) — 詞彙表中輸入序列 token 的索引。如果提供填充，預設情況下將忽略它。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray, 可選) — 掩碼，用於避免對填充 token 索引執行注意力。掩碼值在[0, 1]中選擇：- 1 表示 未掩碼 的 token，
- 0 表示 已掩碼 的 token。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的jnp.ndarray, 可選) — 解碼器輸入序列 token 在詞彙表中的索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。
- decoder_attention_mask (形狀為
(batch_size, target_sequence_length)的jnp.ndarray, 可選) — 預設行為：生成一個忽略decoder_input_ids中填充 token 的張量。預設情況下也將使用因果掩碼。如果想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]中選擇。 - decoder_position_ids (形狀為
(batch_size, sequence_length)的numpy.ndarray, 可選) — 每個解碼器輸入序列 token 在位置嵌入中的位置索引。在範圍[0, config.max_position_embeddings - 1]中選擇。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (PegasusConfig) 和輸入而定的各種元素。
-
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時返回) — 長度為config.n_layers的tuple(jnp.ndarray)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxPegasusPreTrainedModel forward 方法，覆蓋 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但此後應呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
摘要示例
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained('google/pegasus-large')
>>> tokenizer = AutoTokenizer.from_pretrained('google/pegasus-large')
>>> ARTICLE_TO_SUMMARIZE = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors='np')
>>> # Generate Summary
>>> summary_ids = model.generate(inputs['input_ids']).sequences
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))掩碼填充示例
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> input_ids = tokenizer([TXT], return_tensors="np")["input_ids"]
>>> logits = model(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = jax.nn.softmax(logits[0, masked_index], axis=0)
>>> values, predictions = jax.lax.top_k(probs)
>>> tokenizer.decode(predictions).split()編碼
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: 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)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參見 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray, 形狀為(batch_size, sequence_length), 可選) — 掩碼，以避免對填充標記索引執行注意力操作。掩碼值在[0, 1]中選擇：- 對於未被掩碼的標記為 1，
- 對於被掩碼的標記為 0。
- position_ids (
numpy.ndarray, 形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - 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.pegasus.configuration_pegasus.PegasusConfig'>）和輸入包含各種元素。
-
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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
示例
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)解碼
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: 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 deterministic: bool = True 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()。
- 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。
- decoder_position_ids (
numpy.ndarray, 形狀為(batch_size, sequence_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.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一個 torch.FloatTensor 元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>) 和輸入而定的各種元素。
-
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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個用於嵌入輸出，一個用於每層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 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輸入）加速順序解碼。
示例
>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, 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