Transformers 文档
PEGASUS-X
并获得增强的文档体验
开始使用
此模型于 2022-08-08 发布，并于 2022-09-02 添加到 Hugging Face Transformers。
PEGASUS-X
PEGASUS-X 是一个用于长文本摘要的编码器-解码器（序列到序列）Transformer 模型。它通过交错的块内注意力（staggered block-local attention）、全局编码器标记（global encoder tokens）以及对长文本序列进行的额外预训练，扩展了 Pegasus 模型，使其能够处理长达 16,000 个 token 的输入。PEGASUS-X 在使用更少参数的情况下，实现了与更大模型相当的性能。
您可以在 Google 组织下找到所有原始 PEGASUS-X 检查点。
此模型由 zphang 贡献。
点击右侧边栏中的 PEGASUS-X 模型，可了解更多关于如何将 PEGASUS-X 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 和命令行来总结文本。
import torch
from transformers import pipeline
pipeline = pipeline(
task="summarization",
model="google/pegasus-x-large",
dtype=torch.bfloat16,
device=0
)
pipeline("""Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle.""")量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
以下示例使用 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-x-large",
dtype=torch.bfloat16,
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained(
"google/pegasus-x-large"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))注意事项
- PEGASUS-X 还使用了 PegasusTokenizer。
PegasusXConfig
class transformers.PegasusXConfig
< source >( vocab_size = 96103 max_position_embeddings = 16384 encoder_layers = 16 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 16 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 = True pad_token_id = 0 eos_token_id = 1 forced_eos_token_id = 1 num_global_tokens = 32 block_size = 512 stagger_local_blocks = True tie_word_embeddings = True **kwargs )
参数
- vocab_size (
int, optional, 默认为 96103) — PEGASUS-X 模型的词汇表大小。定义调用 PegasusXModel 时传入的inputs_ids所能表示的不同 token 的数量。 - d_model (
int, optional, 默认为 1024) — 层的维度和池化层。 - encoder_layers (
int, optional, 默认为 16) — 编码器层数。 - decoder_layers (
int, optional, 默认为 16) — 解码器层数。 - encoder_attention_heads (
int, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - decoder_attention_heads (
int, optional, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。 - decoder_ffn_dim (
int, optional, 默认为 4096) — 解码器中“中间”（通常称为前馈）层的维度。 - encoder_ffn_dim (
int, optional, 默认为 4096) — 解码器中“中间”（通常称为前馈）层的维度。 - activation_function (
strorfunction, optional, 默认为"gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。 - dropout (
float, optional, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - attention_dropout (
float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。 - activation_dropout (
float, optional, 默认为 0.0) — 全连接层内激活值的 dropout 比率。 - max_position_embeddings (
int, optional, 默认为 16384) — 该模型可能使用的最大序列长度。通常将其设置为一个较大的值以防万一（例如，512、1024 或 2048）。 - init_std (
float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - encoder_layerdrop (
float, optional, 默认为 0.0) — 编码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, optional, 默认为 0.0) — 解码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。 - forced_eos_token_id (
int, optional, 默认为 1) — 当达到max_length时强制作为最后一个生成 token 的 id。通常设置为eos_token_id。 - num_global_tokens (
int, optional, 默认为 128) — 编码器使用的全局 token 数量。 - block_size (
int, optional, 默认为 512) — 编码器本地注意力的块大小。序列长度应为块大小的整数倍。如果 stagger_local_block 为 True，则 block_size 必须是 2 的倍数。 - stagger_local_block (
bool, optional, 默认为True) — 是否将每两个本地注意力交错半个块。
这是用于存储 PegasusXModel 配置的类。它用于根据指定的参数实例化 PEGASUS-X 模型，定义模型架构。使用默认值实例化配置将产生与 PEGASUS-X google/pegasus-x-large 架构相似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PreTrainedConfig 的文档。
示例
>>> from transformers import PegasusXConfig, PegasusXModel
>>> # Initializing a PEGASUS google/pegasus-x-large style configuration
>>> configuration = PegasusXConfig()
>>> # Initializing a model (with random weights) from the google/pegasus-x-large style configuration
>>> model = PegasusXModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configPegasusXModel
class transformers.PegasusXModel
< source >( config: PegasusXConfig )
参数
- config (PegasusXConfig) — 模型配置类，包含模型的全部参数。使用配置文件初始化不会加载模型权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
The bare Pegasus X Model outputting raw hidden-states without any specific head on top.
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.Tensor | None = None decoder_attention_mask: torch.Tensor | None = None encoder_outputs: tuple[torch.FloatTensor] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.Tensor | None = None decoder_inputs_embeds: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.Tensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充 token 索引上执行 attention 的掩码。掩码值选择在[0, 1]:- 1 表示未掩码的 token，
- 0 表示已掩码的 token。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 解码器输入序列 token 在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
PEGASUS-X 使用
pad_token_id作为decoder_input_ids生成的起始 token。如果使用了past_key_values，则可以选择只输入最后的decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中 padding token 的张量。默认也会使用因果掩码。 - encoder_outputs (
tuple, optional) — 元组由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层的输出隐藏状态序列。在解码器的交叉 attention 中使用。 - past_key_values (
~cache_utils.Cache, optional) — 预计算的隐藏状态（自 attention 块和交叉 attention 块中的 key 和 value），可用于加速顺序解码。这通常包括在解码的上一阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。只允许输入 Cache 实例，请参阅我们的 kv cache 指南。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与输入相同的 cache 格式。
如果使用了
past_key_values，用户应只输入未处理的input_ids（即其 past key value 状态未传递给此模型的那些），形状为(batch_size, unprocessed_length)，而不是全部input_ids，形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.Tensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量的控制程度超过模型的内部嵌入查找矩阵，则此选项非常有用。 - decoder_inputs_embeds (
torch.Tensorof shape(batch_size, target_sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递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, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - output_attentions (
bool, optional) — 是否返回所有 attention 层的 attention 张量。有关详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。 - cache_position (
torch.Tensorof shape(sequence_length), optional) — 指示输入序列 token 在序列中位置的索引。与position_ids不同，此张量不受 padding 的影响。它用于在正确位置更新 cache 并推断完整序列长度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.Seq2SeqModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (PegasusXConfig) and inputs.
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
The PegasusXModel forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, PegasusModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-x-large")
>>> model = PegasusModel.from_pretrained("google/pegasus-x-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]PegasusXForConditionalGeneration
class transformers.PegasusXForConditionalGeneration
< source >( config: PegasusXConfig )
参数
- config (PegasusXConfig) — 模型配置类，包含模型的全部参数。使用配置文件初始化不会加载模型权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
The PEGASUS-X for conditional generation (e.g. summarization).
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.Tensor | None = None decoder_attention_mask: torch.Tensor | None = None encoder_outputs: tuple[torch.FloatTensor] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.Tensor | None = None decoder_inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.Tensor | None = None **kwargs ) → 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-X 使用
pad_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可选地只需要输入最后一个decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略decoder_input_ids中的 pad token 的张量。因果掩码也将被默认使用。 - encoder_outputs (
tuple, 可选) — 元组包含（last_hidden_state, 可选:hidden_states, 可选:attentions）last_hidden_state，形状为(batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层的输出隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的past_key_values组成，当use_cache=True或config.use_cache=True时。只允许将 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果未传入
past_key_values，则默认初始化DynamicCache。模型将输出与输入相同的缓存格式。
如果使用
past_key_values，用户需要仅输入未处理的input_ids（即尚未将其过去键值状态提供给此模型的input_ids），形状为(batch_size, unprocessed_length)，而不是所有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 时），根据配置（PegasusXConfig）和输入包含各种元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
PegasusXForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。