Transformers 文档
PEGASUS-X
并获得增强的文档体验
开始使用
该模型于 2022 年 8 月 8 日在 HF papers 上发表，并于 2022 年 9 月 2 日贡献给 Hugging Face Transformers。
PEGASUS-X
PEGASUS-X 是一款用于长文本摘要的编码器-解码器（序列到序列）Transformer 模型。它在 Pegasus 模型的基础上扩展了交错块局部注意力（staggered block-local attention）、全局编码器 Token，并增加了针对长文本序列的预训练，使其能够处理最多 16,000 个 Token 的输入。PEGASUS-X 在使用更少参数的情况下，达到了比其大得多的模型的性能水平。
你可以在 Google 组织下找到所有原始的 PEGASUS-X 检查点。
该模型由 zphang 贡献。
点击右侧边栏中的 PEGASUS-X 模型，可以查看更多关于如何将 PEGASUS-X 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 以及从命令行进行文本摘要。
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(
"google/pegasus-x-large"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google/pegasus-x-large",
device_map="auto",
)
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))量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
以下示例使用 bitsandbytes 将权重仅量化为 int4。
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google/pegasus-x-large",
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
< 源码 >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None is_encoder_decoder: bool = True vocab_size: int = 96103 max_position_embeddings: int = 16384 encoder_layers: int = 16 encoder_ffn_dim: int = 4096 encoder_attention_heads: int = 16 decoder_layers: int = 16 decoder_ffn_dim: int = 4096 decoder_attention_heads: int = 16 encoder_layerdrop: float | int = 0.0 decoder_layerdrop: float | int = 0.0 use_cache: bool = True activation_function: str = 'gelu' d_model: int = 1024 dropout: float | int = 0.1 attention_dropout: float | int = 0.0 activation_dropout: float | int = 0.0 init_std: float = 0.02 decoder_start_token_id: int | None = 0 scale_embedding: bool = True pad_token_id: int | None = 0 eos_token_id: int | list[int] | None = 1 forced_eos_token_id: int | list[int] | None = 1 num_global_tokens: int = 32 block_size: int = 512 stagger_local_blocks: bool = True tie_word_embeddings: bool = True )
参数
- is_encoder_decoder (
bool, optional, 默认值为True) — 模型是否用作编码器/解码器。 - vocab_size (
int, optional, 默认值为96103) — 模型词汇表大小。定义了input_ids可以表示的不同 Token 的数量。 - max_position_embeddings (
int, optional, 默认值为16384) — 此模型可能用到的最大序列长度。 - encoder_layers (
int, optional, 默认值为16) — Transformer 编码器中的隐藏层数。如果未设置，将使用与num_layers相同的值。 - encoder_ffn_dim (
int, optional, 默认值为4096) — 编码器中“中间”层（通常称为前馈层）的维度。 - encoder_attention_heads (
int, optional, 默认值为16) — Transformer 编码器中每个注意力层的注意力头数。 - decoder_layers (
int, optional, 默认值为16) — Transformer 解码器中的隐藏层数。如果未设置，将使用与num_layers相同的值。 - decoder_ffn_dim (
int, optional, 默认值为4096) — 解码器中“中间”层（通常称为前馈层）的维度。 - decoder_attention_heads (
int, optional, 默认值为16) — Transformer 解码器中每个注意力层的注意力头数。 - encoder_layerdrop (
Union[float, int], optional, 默认值为0.0) — 编码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
Union[float, int], optional, 默认值为0.0) — 解码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, optional, 默认值为True) — 模型是否应该返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True或模型为仅解码器的生成模型时相关。 - activation_function (
str, optional, 默认值为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - d_model (
int, optional, 默认值为1024) — 编码器层和池化层的尺寸。 - dropout (
Union[float, int], optional, 默认值为0.1) — 所有 Dropout 层的比率。 - attention_dropout (
Union[float, int], optional, 默认值为0.0) — 注意力概率的 Dropout 比率。 - activation_dropout (
Union[float, int], optional, 默认值为0.0) — 全连接层内部激活值的 Dropout 比率。 - init_std (
float, optional, 默认值为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - decoder_start_token_id (
int, optional, defaults to0) — 如果编码器-解码器模型使用与bos不同的 token 开始解码，则为该 token 的 ID。 - scale_embedding (
bool, optional, defaults toTrue) — 是否通过除以 sqrt(d_model) 来缩放嵌入。 - pad_token_id (
int, optional, defaults to0) — 词汇表中用于填充（padding）的 token ID。 - eos_token_id (
Union[int, list[int]], optional, defaults to1) — 词汇表中用于流结束（end-of-stream）的 token ID。 - forced_eos_token_id (
Union[int, list[int]], optional, defaults to1) — 当达到max_length时强制作为最后一个生成的 token 的 ID。通常设置为eos_token_id。 - num_global_tokens (
int, optional, defaults to 128) — 用于编码器的全局 token 数量。 - block_size (
int, optional, defaults to 512) — 编码器局部注意力（local attention）的块大小。序列长度应为块大小的整数倍。如果 stagger_local_block 为 True，则 block_size 必须是 2 的倍数。 - stagger_local_blocks (
bool, optional, defaults toTrue) — 是否通过半个块来交错（stagger）每隔一个局部注意力。 - tie_word_embeddings (
bool, optional, defaults toTrue) — 是否根据模型的tied_weights_keys映射来绑定权重嵌入。
这是用于存储 PegasusXModel 配置的配置类。它根据指定的参数实例化 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
< 源代码 >( config: PegasusXConfig )
参数
- config (PegasusXConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
纯 Pegasus X 模型，输出原始隐藏状态，顶部没有任何特定头部。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源代码 >( 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 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列 token 的索引。默认情况下，填充（padding）将被忽略。索引可以使用 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 的张量。因果掩码（causal mask）也将默认使用。 - encoder_outputs (
tuple[torch.FloatTensor]，可选) — 元组包含 (last_hidden_state, 可选:hidden_states, 可选:attentions)。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力（cross-attention）中。 - past_key_values (
~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的前一个阶段返回的past_key_values组成，当use_cache=True或config.use_cache=True时。仅允许使用 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果没有传入
past_key_values，将默认初始化 DynamicCache。模型将输出与输入相同格式的缓存。
如果使用了
past_key_values，用户应仅输入形状为(batch_size, unprocessed_length)的未处理input_ids（那些其过去键值状态未提供给此模型的输入），而不是所有形状为(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）。
返回
Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
Seq2SeqModelOutput 或 torch.FloatTensor 的元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），根据配置（PegasusXConfig）和输入，包含各种元素。
PegasusXModel 前向传递方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
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), 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 之后，用于计算自注意力头中的加权平均。
示例
>>> 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
< 源代码 >( config: PegasusXConfig )
参数
- config (PegasusXConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
用于条件生成（例如摘要）的 PEGASUS-X 模型。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( 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 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.Tensor，可选) — 词表中输入序列 token 的索引。默认情况下将忽略填充（padding）。索引可以通过 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示未遮蔽的 token，
- 0 表示被遮蔽的 token。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 词表中解码器输入序列 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 (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 默认行为：生成一个忽略decoder_input_ids中填充 token 的张量。默认情况下也会使用因果掩码（causal mask）。 - encoder_outputs (
tuple[torch.FloatTensor]，可选) — 元组包含 (last_hidden_state，可选:hidden_states，可选:attentions)。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力机制中。 - past_key_values (
~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常由模型在解码的前一个阶段返回，当use_cache=True或config.use_cache=True时。仅允许 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果不传入
past_key_values，默认将初始化 DynamicCache。模型将输出与作为输入传入的格式相同的缓存。
如果使用
past_key_values，用户应仅输入未经处理的input_ids（那些尚未将其键值状态传给此模型的输入），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的所有input_ids。 - 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的值。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]之间或为 -100（参阅input_ids文档字符串）。索引设置为-100的 token 将被忽略（遮蔽），损失仅针对标签在[0, ..., config.vocab_size]中的 token 计算。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参阅past_key_values）。
返回
Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（PegasusXConfig）和输入包含各种元素。
PegasusXForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
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), 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 之后，用于计算自注意力头中的加权平均。