Transformers 文档

Pegasus

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

在模型、数据集和 Spaces 上进行协作

通过加速推理获得更快的示例

切换文档主题

开始使用

此模型发布于 2019-12-18，并于 2020-11-16 添加到 Hugging Face Transformers。

Pegasus

Pegasus 是一个编码器-解码器（序列到序列）Transformer 模型，在无标签文本上进行预训练，以执行抽象摘要。Pegasus 在两个自监督目标函数上联合训练：掩码语言模型 (MLM) 和句子补全生成 (GSG)。它会掩盖整个句子，模型需要填充文档中的空白。即使在只有 1000 个示例的小型数据集上，它也可以进行微调并获得良好的性能。

您可以在 Google 组织下找到所有原始 Pegasus 检查点。

点击侧边栏右侧的 Pegasus 模型，可获取更多关于如何将 Pegasus 应用于不同语言任务的示例。

下面的示例演示了如何使用 Pipeline、AutoModel 和命令行来总结文本。

流水线

自动模型

Transformers CLI

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。

以下示例使用 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",
    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(model.device)

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 is_decoder = False tie_word_embeddings = True **kwargs )

参数

vocab_size (int, optional, defaults to 50265) — PEGASUS 模型词汇量大小。定义通过调用 PegasusModel 传递的 inputs_ids 可以表示的不同 token 的数量。
d_model (int, optional, defaults to 1024) — 各层和池化层的维度。
encoder_layers (int, optional, defaults to 12) — 编码器层数。
decoder_layers (int, optional, defaults to 12) — 解码器层数。
encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。
decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
activation_function (str or function, optional, defaults to "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
activation_dropout (float, optional, defaults to 0.0) — 全连接层内部激活值的 dropout 比率。
max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常将其设置得大一些以防万一（例如，512、1024 或 2048）。
init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。
decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多详细信息请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。
scale_embedding (bool, optional, defaults to False) — 通过除以 sqrt(d_model) 来缩放嵌入。
use_cache (bool, optional, defaults to True) — 模型是否应返回最后一个 key/values 注意力（并非所有模型都使用）。
forced_eos_token_id (int, optional, defaults to 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.config

PegasusTokenizer

warning: add_tokens does not work at the moment.

class transformers.PegasusTokenizer

< source >

( vocab: str | list[tuple[str, float]] | None = 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, optional) — SentencePiece 文件（通常扩展名为 .spm），其中包含实例化分词器所需的词汇表。
pad_token (str, optional, defaults to "<pad>") — 用于填充的令牌，例如在批处理不同长度的序列时。
eos_token (str, optional, defaults to "</s>") — 序列结束令牌。

构建包含特殊令牌的序列时，用于序列结束的不是此令牌。实际使用的令牌是 sep_token。
unk_token (str, optional, defaults to "<unk>") — 未知令牌。无法转换为 ID 的令牌将被替换为此令牌。
mask_token (str, optional, defaults to "<mask_2>") — 用于掩码单个令牌值的令牌。这是使用掩码语言建模 (MLM) 训练此模型时使用的令牌。这是 PEGASUS 编码器在预训练期间将尝试预测的令牌。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK2]。
mask_token_sent (str, optional, defaults to "<mask_1>") — 用于掩码整个目标句子的令牌。这是在训练此模型进行间隙句子生成 (GSG) 时使用的令牌。这是 PEGASUS 解码器在预训练期间将尝试预测的句子。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK1]。
additional_special_tokens (List[str], optional) — 其他分词器使用的特殊令牌。如果未提供 additional_special_tokens，则使用和作为额外的特殊令牌，对应于原始 PEGASUS 分词器，该分词器仅使用令牌 2 - 104 进行预训练。
offset (int, optional, defaults to 103) — 额外特殊令牌的偏移量。
vocab (str or list[tuple[str, float]], optional) — 带有 (token, score) 元组的自定义词汇表。如果未提供，则初始化一个空白词汇表。

基于 HuggingFace 的 tokenizers 库构建 PEGASUS 分词器。基于 Unigram。

此分词器继承自 TokenizersBackend，其中包含大部分主要方法。用户应参考此父类了解有关这些方法的更多信息。

PegasusTokenizerFast

class transformers.PegasusTokenizer

< source >

参数

vocab_file (str, optional) — SentencePiece 文件（通常扩展名为 .spm），其中包含实例化分词器所需的词汇表。
pad_token (str, optional, defaults to "<pad>") — 用于填充的令牌，例如在批处理不同长度的序列时。
eos_token (str, optional, defaults to "</s>") — 序列结束令牌。

构建包含特殊令牌的序列时，用于序列结束的不是此令牌。实际使用的令牌是 sep_token。
unk_token (str, optional, defaults to "<unk>") — 未知令牌。无法转换为 ID 的令牌将被替换为此令牌。
mask_token (str, optional, defaults to "<mask_2>") — 用于掩码单个令牌值的令牌。这是使用掩码语言建模 (MLM) 训练此模型时使用的令牌。这是 PEGASUS 编码器在预训练期间将尝试预测的令牌。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK2]。
mask_token_sent (str, optional, defaults to "<mask_1>") — 用于掩码整个目标句子的令牌。这是在训练此模型进行间隙句子生成 (GSG) 时使用的令牌。这是 PEGASUS 解码器在预训练期间将尝试预测的句子。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK1]。
additional_special_tokens (List[str], optional) — 其他分词器使用的特殊令牌。如果未提供 additional_special_tokens，则使用和作为额外的特殊令牌，对应于原始 PEGASUS 分词器，该分词器仅使用令牌 2 - 104 进行预训练。
offset (int, optional, defaults to 103) — 额外特殊令牌的偏移量。
vocab (str or list[tuple[str, float]], optional) — 带有 (token, score) 元组的自定义词汇表。如果未提供，则初始化一个空白词汇表。

基于 HuggingFace 的 tokenizers 库构建 PEGASUS 分词器。基于 Unigram。

此分词器继承自 TokenizersBackend，其中包含大部分主要方法。用户应参考此父类了解有关这些方法的更多信息。

PegasusModel

class transformers.PegasusModel

< source >

( config: PegasusConfig )

参数

config (PegasusConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

输出原始隐藏状态的裸 Pegasus 模型，顶部没有任何特定头部。

此模型继承自 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.Tensor of shape (batch_size, sequence_length), optional) — 词汇表中输入序列令牌的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免对填充令牌索引执行注意力的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未掩码的令牌，
- 0 表示已掩码的令牌。
什么是注意力掩码？
decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列令牌在词汇表中的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是解码器输入 ID？

Pegasus 使用 pad_token_id 作为 decoder_input_ids 生成的起始令牌。如果使用 past_key_values，则可以选择只输入最后的 decoder_input_ids（请参阅 past_key_values）。
decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略 decoder_input_ids 中填充令牌的张量。默认情况下也会使用因果掩码。
encoder_outputs (tuple, optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state，形状为 (batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的输出隐藏状态序列。用于解码器的交叉注意力。
past_key_values (~cache_utils.Cache, optional) — 可用于加速序列解码的预计算隐藏状态（自注意力块和交叉注意力块中的键和值）。这通常由模型在解码的先前阶段返回的 past_key_values 组成，当 use_cache=True 或 config.use_cache=True 时。

只有 Cache 实例被允许作为输入，请参阅我们的 kv cache 指南。如果未传递 past_key_values，则默认初始化 DynamicCache。

模型将输出与输入相同的缓存格式。

如果使用 past_key_values，用户应仅输入未处理的 input_ids（即没有传递其过去键值状态给此模型的那些）形状为 (batch_size, unprocessed_length)，而不是所有 input_ids 形状为 (batch_size, sequence_length)。
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以通过直接传入嵌入表示来代替 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量进行比模型内部嵌入查找矩阵更精细地控制，这将非常有用。
decoder_inputs_embeds (torch.Tensor of 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) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回的张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回的张量下的hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 对象而不是一个普通的元组。
cache_position (torch.Tensor of shape (sequence_length), optional) — 索引，用于指示输入序列 token 在序列中的位置。与 position_ids 不同，此张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

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

一个 transformers.modeling_outputs.Seq2SeqModelOutput 对象或一个元组（如果传递了 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, 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 when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.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 之后，用于计算自注意力头中的加权平均。

transformers.PegasusModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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 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 of shape (batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下将忽略 padding。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

输入 ID 是什么？
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免对 padding token 索引执行 attention 的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
Attention 掩码是什么？
decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列 token 在词汇表中的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

解码器输入 ID 是什么？

Pegasus 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用了 past_key_values，则可以选择只输入最后一个 decoder_input_ids（参见 past_key_values）。
decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略 decoder_input_ids 中 pad token 的张量。默认还会使用因果掩码。
encoder_outputs (tuple, optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state，形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。在解码器的交叉 attention 中使用。
past_key_values (~cache_utils.Cache, optional) — 预计算的隐藏状态（自 attention 块和交叉 attention 块中的键和值），可用于加速顺序解码。这通常包括在 use_cache=True 或 config.use_cache=True 时，在前一个解码阶段由模型返回的 past_key_values。

只允许使用 Cache 实例，请参阅我们的 kv cache 指南。如果未传递 past_key_values，则默认初始化 DynamicCache。

模型将输出与输入相同的缓存格式。

如果使用 past_key_values，则用户应仅输入未处理的 input_ids（即没有其 past key value 状态已传递给此模型的那些），其形状为 (batch_size, unprocessed_length)，而不是所有 input_ids，其形状为 (batch_size, sequence_length)。
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，则此选项非常有用。
decoder_inputs_embeds (torch.Tensor of 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。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言模型损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 范围内（请参阅 input_ids 文档字符串）。索引设置为 -100 的 token 将被忽略（掩码），损失仅为标签在 [0, ..., config.vocab_size] 范围内的 token 计算。
use_cache (bool, optional) — 如果设置为 True，则会返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回的张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回的张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
cache_position (torch.Tensor of shape (sequence_length), optional) — Indices depicting the position of the input sequence tokens in the sequence. Contrarily to position_ids, this tensor is not affected by padding. It is used to update the cache in the correct position and to infer the complete sequence length.

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, 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 when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.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 之后，用于计算自注意力头中的加权平均。

PegasusForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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

class transformers.PegasusForCausalLM

< source >

( config )

forward

< source >

( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None encoder_hidden_states: torch.FloatTensor | None = None encoder_attention_mask: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | 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.LongTensor | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — Input sequence tokens的索引，在词汇表中。默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
- 1 for tokens that are not masked,
- 0 for tokens that are masked.
什么是注意力掩码？
encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder.
encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in [0, 1]:
- 1 for tokens that are not masked,
- 0 for tokens that are masked.
past_key_values (~cache_utils.Cache, optional) — Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the past_key_values returned by the model at a previous stage of decoding, when use_cache=True or config.use_cache=True.

Only Cache instance is allowed as input, see our kv cache guide. If no past_key_values are passed, DynamicCache will be initialized by default.

The model will output the same cache format that is fed as input.

If past_key_values are used, the user is expected to input only unprocessed input_ids (those that don’t have their past key value states given to this model) of shape (batch_size, unprocessed_length) instead of all input_ids of shape (batch_size, sequence_length).
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — Labels for computing the masked language modeling loss. Indices should either be in [0, ..., config.vocab_size] or -100 (see input_ids docstring). Tokens with indices set to -100 are ignored (masked), the loss is only computed for the tokens with labels in [0, ..., config.vocab_size].
use_cache (bool, optional) — If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).
output_attentions (bool, optional) — Whether or not to return the attentions tensors of all attention layers. See attentions under returned tensors for more detail.
output_hidden_states (bool, optional) — Whether or not to return the hidden states of all layers. See hidden_states under returned tensors for more detail.
return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.
cache_position (torch.LongTensor of shape (sequence_length), optional) — Indices depicting the position of the input sequence tokens in the sequence. Contrarily to position_ids, this tensor is not affected by padding. It is used to update the cache in the correct position and to infer the complete sequence length.
logits_to_keep (Union[int, torch.Tensor], optional, defaults to 0) — If an int, compute logits for the last logits_to_keep tokens. If 0, calculate logits for all input_ids (special case). Only last token logits are needed for generation, and calculating them only for that token can save memory, which becomes pretty significant for long sequences or large vocabulary size. If a torch.Tensor, must be 1D corresponding to the indices to keep in the sequence length dimension. This is useful when using packed tensor format (single dimension for batch and sequence length).

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

A 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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
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 when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。
past_key_values (Cache, optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

PegasusForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, PegasusForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> model = PegasusForCausalLM.from_pretrained("google/pegasus-large")
>>> 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
True

在 GitHub 上更新

←OPT PEGASUS-X→