Transformers 文档

Pegasus

Hugging Face's logo
加入 Hugging Face 社区

并获取增强型文档体验

开始使用

Pegasus

Models Spaces

概述

Pegasus 模型在 2019 年 12 月 18 日由 Jingqing Zhang、Yao Zhao、Mohammad Saleh 和 Peter J. Liu 在 PEGASUS: 用于抽象摘要的提取间隔句子预训练 中提出。

根据摘要,

  • Pegasus 的预训练任务与摘要有意相似:从输入文档中删除/屏蔽重要句子,并将其作为单个输出序列从剩余句子中生成,类似于提取式摘要。
  • Pegasus 在所有 12 个下游任务中都取得了最先进的摘要性能,这是通过 ROUGE 和人工评估得出的。

该模型由 sshleifer 贡献。作者的代码可以在 此处 找到。

使用技巧

  • 序列到序列模型,与 BART 具有相同的编码器-解码器模型架构。Pegasus 在两个自监督目标函数上联合预训练:掩蔽语言建模 (MLM) 和一种新的摘要特定预训练目标,称为间隔句子生成 (GSG)。

    • MLM:编码器输入标记被随机替换为掩蔽标记,并必须由编码器预测(如 BERT 中)。
    • GSG:整个编码器输入句子被替换为第二个掩蔽标记并馈送到解码器,但解码器具有因果掩蔽以隐藏未来的单词,就像常规的自回归 Transformer 解码器一样。
  • 不支持 FP16(欢迎提供帮助/想法!)。

  • 建议使用 adafactor 优化器对 pegasus 进行微调。

检查点

除了 pegasus-large 之外,所有 检查点 都针对摘要进行了微调,而其他检查点则针对其他任务进行了微调。

  • 每个检查点在磁盘上占 2.2 GB,参数为 568M。
  • 不支持 FP16(欢迎提供帮助/想法!)。
  • 使用默认参数在 v100 GPU 上对 xsum 进行 FP32 摘要大约需要 400 毫秒/样本。
  • 可以在 此问题 中找到完整的复制结果和正确预处理的数据。
  • 蒸馏检查点这篇论文 中有所描述。

实施说明

  • 所有模型都是 Transformer 编码器-解码器,每个组件包含 16 层。
  • 实现完全继承自 BartForConditionalGeneration
  • 一些关键配置差异
    • 静态的正弦位置嵌入
    • 模型以 pad_token_id(具有 0 个标记嵌入)作为前缀开始生成。
    • 使用更多光束 (num_beams=8)
  • 所有预训练的 pegasus 检查点除了三个属性外都相同:tokenizer.model_max_length(最大输入大小)、max_length(要生成的标记的最大数量)和 length_penalty
  • 用于转换在作者的 仓库 中训练的检查点的代码可以在 convert_pegasus_tf_to_pytorch.py 中找到。

使用示例

>>> from transformers import PegasusForConditionalGeneration, PegasusTokenizer
>>> import torch

>>> src_text = [
...     """ 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."""
... ]

... model_name = "google/pegasus-xsum"
... device = "cuda" if torch.cuda.is_available() else "cpu"
... tokenizer = PegasusTokenizer.from_pretrained(model_name)
... model = PegasusForConditionalGeneration.from_pretrained(model_name).to(device)
... batch = tokenizer(src_text, truncation=True, padding="longest", return_tensors="pt").to(device)
... translated = model.generate(**batch)
... tgt_text = tokenizer.batch_decode(translated, skip_special_tokens=True)
... assert (
...     tgt_text[0]
...     == "California's largest electricity provider has turned off power to hundreds of thousands of customers."
... )

资源

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 模型的词汇量大小。定义了在调用 PegasusModelTFPegasusModel 时,可以通过传递的 inputs_ids 表示的不同标记的数量。
  • d_model (int, 可选, 默认值 1024) — 层和池化层的维度。
  • encoder_layers (int, 可选, 默认值 12) — 编码器层的数量。
  • decoder_layers (int, 可选, 默认值 12) — 解码器层的数量。
  • encoder_attention_heads (int, 可选, 默认值 16) — Transformer 编码器中每个注意力层中的注意力头的数量。
  • decoder_attention_heads (int, 可选, 默认值 16) — Transformer 解码器中每个注意力层中的注意力头的数量。
  • encoder_ffn_dim (int, 可选, 默认为 4096) — 解码器中“中间”层(通常称为前馈层)的维度。
  • activation_function (strfunction, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""silu""gelu_new"
  • dropout (float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • activation_dropout (float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比率。
  • max_position_embeddings (int, 可选, 默认为 1024) — 此模型可能使用的最大序列长度。通常将其设置为一个较大的值,以防万一(例如,512 或 1024 或 2048)。
  • init_std (float, 可选, 默认为 0.02) — 初始化所有权重矩阵的截断正态初始化的标准差。
  • encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息,请参见 [LayerDrop 论文](见 https://arxiv.org/abs/1909.11556)。
  • decoder_layerdrop (float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息,请参见 [LayerDrop 论文](见 https://arxiv.org/abs/1909.11556)。
  • scale_embedding (bool, 可选, 默认为 False) — 通过除以 sqrt(d_model) 来缩放嵌入。
  • 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.config

PegasusTokenizer

警告:目前 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: Optional = None **kwargs )

参数

  • vocab_file (str) — SentencePiece 文件(通常具有 .spm 扩展名),其中包含实例化分词器所需的词汇表。
  • pad_token (str, 可选, 默认为 "<pad>") — 用于填充的 token,例如在对不同长度的序列进行批处理时。
  • eos_token (str, 可选, 默认为 "</s>") — 序列结束 token。

    在使用特殊 token 构建序列时,这不是用于序列结束的 token。使用的 token 是 sep_token

  • unk_token (str, 可选, 默认为 "<unk>") — 未知 token。不在词汇表中的 token 无法转换为 ID,而是设置为此 token。
  • mask_token (str, 可选, 默认为 "<mask_2>") — 用于掩盖单个 token 值的 token。这是在使用掩码语言建模 (MLM) 训练此模型时使用的 token。这是 PEGASUS 编码器在预训练期间将尝试预测的 token。它对应于 PEGASUS:用于抽象摘要的提取间隙句子的预训练 中的 [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
  • sp_model_kwargs (dict, optional) — 将传递给 SentencePieceProcessor.__init__() 方法。 SentencePiece 的 Python 包装器 可用于(除其他事项外)设置:

    • enable_sampling: 启用子词正则化。

    • nbest_size: 一元模型的采样参数。对于 BPE-Dropout 无效。

      • nbest_size = {0,1}: 不执行采样。
      • nbest_size > 1: 从 nbest_size 结果中采样。
      • nbest_size < 0: 假设 nbest_size 为无穷大,并使用前向过滤和后向采样算法从所有假设(格)中采样。
    • alpha: 一元模型采样的平滑参数,以及 BPE-Dropout 中合并操作的 dropout 概率。

构造 PEGASUS 分词器。基于 SentencePiece

此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None ) List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
  • token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 输入 ID 列表。

通过连接和添加特殊标记,从序列或一对序列为序列分类任务构建模型输入。PEGASUS 序列具有以下格式,其中 X 表示序列

  • 单个序列:X </s>
  • 一对序列:A B </s>(非预期用法)

从不使用 BOS。序列对不是预期的用例,但它们将被处理而没有分隔符。

convert_tokens_to_string

< >

( tokens )

将一系列标记(字符串)转换为单个字符串。

get_special_tokens_mask

< >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False )

获取列表,其中条目为 [1](如果标记为 [eos] 或 [pad])否则为 0。

num_special_tokens_to_add

< >

( pair = False )

仅 EOS

PegasusTokenizerFast

transformers.PegasusTokenizerFast

< >

( 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], optional) — 分词器使用的额外特殊标记。 如果没有提供额外的特殊标记, 将用作额外特殊标记,对应于 原始 PEGASUS 分词器,它仅使用标记 2 - 104 进行预训练。

构建一个“快速”PEGASUS 分词器(由 HuggingFace 的 tokenizers 库支持)。 基于 Unigram

该分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None ) List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表
  • token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

带有适当特殊标记的 输入 ID 列表。

通过在末尾添加 eos 从序列构建模型输入。 在前面没有添加 bos 标记。

  • 单个序列:X </s>
  • 一对序列:A B </s>(非预期用法)

get_special_tokens_mask

< >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False )

获取列表,其中条目为 [1](如果标记为 [eos] 或 [pad])否则为 0。

Pytorch
隐藏 Pytorch 内容

PegasusModel

class transformers.PegasusModel

< >

( config: PegasusConfig )

参数

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

PEGASUS 模型的裸模型,输出原始隐藏状态,没有任何特定的头部。 该模型继承自 PreTrainedModel。 检查超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、修剪头部等)。

该模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般使用和行为相关的所有事宜。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充,则默认情况下会忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 避免对填充标记索引执行注意的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示 未掩码 的标记,
    • 0 表示 已掩码 的标记。

    什么是注意力掩码?

  • decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列标记的索引。

    索引可以使用 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 形状为 (batch_size, target_sequence_length), 可选) — 默认行为:生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
  • head_mask (torch.Tensor 形状为 (encoder_layers, encoder_attention_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(tuple(torch.FloatTensor), optional) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 形状为 (batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层输出的隐藏状态序列。 用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当 use_cache=True 传递或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 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 输入) 加速顺序解码。

    如果使用 past_key_values,用户可以选择性地仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids (那些没有提供给该模型的过去键值状态),而不是所有形状为 (batch_size, sequence_length)decoder_input_ids

  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,除了传递 input_ids,还可以选择直接传递嵌入表示。 如果您想要更深入地控制如何将 input_ids 索引转换为关联向量,而不是模型的内部嵌入查找矩阵,这将很有用。
  • decoder_inputs_embeds (torch.FloatTensor 形状为 (batch_size, target_sequence_length, hidden_size), 可选) — 可选地,除了传递 decoder_input_ids,还可以选择直接传递嵌入表示。 如果使用 past_key_values,可以选择性地仅输入最后一个 decoder_inputs_embeds (参见 past_key_values)。 如果您想要更深入地控制如何将 decoder_input_ids 索引转换为关联向量,而不是模型的内部嵌入查找矩阵,这将很有用。

    如果 decoder_input_idsdecoder_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 而不是简单的元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutputtuple(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 (tuple(tuple(torch.FloatTensor)), 可选, 当 use_cache=True 传递或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 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(torch.FloatTensor), 可选, 当 output_hidden_states=True 传递或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组 (一个用于嵌入的输出,如果模型具有嵌入层,+ 一个用于每一层的输出) 形状为 (batch_size, sequence_length, hidden_size)

    解码器在每一层输出的隐藏状态,加上可选的初始嵌入输出。

  • decoder_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=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每个层一个)。

    解码器交叉注意力层的注意力权重,经过注意力 softmax 后,用于计算交叉注意力头部的加权平均值。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 模型编码器最后一层的输出处的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), 可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor 元组(一个用于嵌入层的输出,如果模型具有嵌入层,以及每个层的输出)。

    每个层的编码器输出处的隐藏状态,以及可选的初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), 可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每个层一个)。

    编码器的注意力权重,经过注意力 softmax 后,用于计算自注意力头部的加权平均值。

PegasusModel 的正向方法覆盖了 __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

< >

( config: PegasusConfig )

参数

  • config (PegasusConfig) — 模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。

具有语言建模头的 PEGASUS 模型。可用于摘要。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般使用和行为相关的所有事宜。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.Seq2SeqLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列标记的索引。如果您提供填充,默认情况下会忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请查看 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (形状为 (batch_size, sequence_length)torch.Tensor可选) — 掩码,以避免对填充标记索引执行注意力。掩码值选择 [0, 1] 中的值:

    • 1 表示 **未掩码** 的标记,
    • 0 表示 **掩码** 的标记。

    什么是注意力掩码?

  • decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列标记的索引。

    可以使用 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 形状为 (batch_size, target_sequence_length), 可选) — 默认行为:生成一个张量,该张量忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
  • head_mask (torch.Tensor 形状为 (encoder_layers, encoder_attention_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(tuple(torch.FloatTensor), 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 形状为 (batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选,当传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)) 元组,每个元组都有 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 输入)加快顺序解码速度。

    如果使用 past_key_values,则用户可以选择仅输入最后一个 decoder_input_ids(那些没有为此模型提供过去键值状态的 decoder_input_ids)形状为 (batch_size, 1),而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)

  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想对如何将 input_ids 索引转换为关联向量(而不是模型的内部嵌入查找矩阵)进行更多控制,这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor 形状为 (batch_size, target_sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 decoder_input_ids。 如果使用了 past_key_values,则可以选择仅输入最后一个 decoder_inputs_embeds(参见 past_key_values)。 如果你想对如何将 decoder_input_ids 索引转换为关联向量进行更多控制,而不是模型的内部嵌入查找矩阵,这将非常有用。

    如果 decoder_input_idsdecoder_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 而不是一个简单的元组。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。 索引应位于 [0, ..., config.vocab_size] 或 -100 中(参见 input_ids 文档字符串)。 索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签位于 [0, ..., config.vocab_size] 中的标记进行计算。

返回

transformers.modeling_outputs.Seq2SeqLMOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (PegasusConfig) 和输入而变化的各种元素。

  • loss (torch.FloatTensor 形状为 (1,), 可选, 当提供 labels 时返回) — 语言建模损失。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测得分(在 SoftMax 之前,每个词汇标记的得分)。

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当 use_cache=True 传递或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 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(torch.FloatTensor), 可选, 当 output_hidden_states=True 传递或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组 (一个用于嵌入的输出,如果模型具有嵌入层,+ 一个用于每一层的输出) 形状为 (batch_size, sequence_length, hidden_size)

    解码器在每层输出处的隐藏状态加上初始嵌入输出。

  • decoder_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=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每个层一个)。

    解码器交叉注意力层的注意力权重,经过注意力 softmax 后,用于计算交叉注意力头部的加权平均值。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 模型编码器最后一层的输出处的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), 可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor 元组(一个用于嵌入层的输出,如果模型具有嵌入层,以及每个层的输出)。

    编码器在每层输出处的隐藏状态加上初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), 可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每个层一个)。

    编码器的注意力权重,经过注意力 softmax 后,用于计算自注意力头部的加权平均值。

PegasusForConditionalGeneration 的正向方法,覆盖了 __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

class transformers.PegasusForCausalLM

< >

( config )

forward

< >

( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充,默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择掩码值:

    • 1 表示 **未掩码** 的标记,
    • 0 表示 **掩码** 的标记。

    什么是注意力掩码?

  • encoder_hidden_states (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器,则用于交叉注意力。
  • encoder_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 掩码以避免对编码器输入的填充标记索引执行注意力。如果模型配置为解码器,则此掩码用于交叉注意力。在 [0, 1] 中选择掩码值:
  • 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 表示 **掩码** 的头部。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选,在传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)),每个元组具有 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 输入)加速顺序解码。

    如果使用 past_key_values,用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids(那些没有提供给此模型的过去键值状态的)而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids

  • labels (torch.LongTensor 形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言模型损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100(参见 input_ids 文档字符串)。索引设置为 -100 的标记会被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 内的标记进行计算。
  • use_cache (bool可选) — 如果设置为 True,则返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。

    • 1 表示未掩码的标记,
    • 0 表示掩码的标记。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的 hidden_states
  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置(PegasusConfig)和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,在提供 labels 时返回) — 语言建模损失(用于下一个标记预测)。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测得分(在 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=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每个层一个)。

    交叉注意力 softmax 后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 元组的元组,每个元组包含自注意力和交叉注意力层的缓存键值状态,如果模型用于编码器-解码器设置。仅在 config.is_decoder = True 时相关。

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

示例

>>> 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
True
TensorFlow
隐藏 TensorFlow 内容

TFPegasusModel

class transformers.TFPegasusModel

< >

( config: PegasusConfig *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 函数一样传递输入!

调用

< >

( 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.TFSeq2SeqModelOutputtuple(tf.Tensor)

参数

  • input_ids (tf.Tensor 形状为 (batch_size, sequence_length)) — 输入序列词元的词汇索引。

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

    什么是输入 ID?

  • attention_mask (tf.Tensor 形状为 (batch_size, sequence_length), 可选) — 避免对填充词元索引执行注意的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示未掩码的词元,
    • 0 表示掩码的词元。

    什么是注意力掩码?

  • decoder_input_ids (tf.Tensor 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列词元的词汇索引。

    可以使用 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 (tf.Tensor 形状为 (batch_size, target_sequence_length), 可选) — 将默认创建,并忽略填充词元。不建议在大多数用例中设置此选项。
  • decoder_position_ids (tf.Tensor 形状为 (batch_size, sequence_length), 可选) — 解码器输入序列中每个token在位置嵌入中的索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • head_mask (tf.Tensor 形状为 (encoder_layers, encoder_attention_heads), 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值在 [0, 1] 范围内选择:

    • 1 表示该头没有被掩码
    • 0 表示该头被掩码
  • decoder_head_mask (tf.Tensor 形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在 [0, 1] 范围内选择:

    • 1 表示该头没有被掩码
    • 0 表示该头被掩码
  • cross_attn_head_mask (tf.Tensor 形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头无效的掩码。掩码值在 [0, 1] 范围内选择:

    • 1 表示该头没有被掩码
    • 0 表示该头被掩码
  • encoder_outputs (tf.FloatTensor, 可选) — 编码器最后一层输出处的隐藏状态。用于解码器的交叉注意力。形状为 (batch_size, sequence_length, hidden_size),是…的序列
  • past_key_values (长度为 config.n_layersTuple[Tuple[tf.Tensor]]) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用 past_key_values,用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids(那些没有提供其过去键值状态的)而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids
  • inputs_embeds (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可选择直接传递嵌入表示而不是传递 input_ids。如果您想要对如何将 input_ids 索引转换为关联向量进行更多控制,而不是模型的内部嵌入查找矩阵,这将很有用。
  • use_cache (bool, 可选,默认值为 True) — 如果设置为 True,将返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。在训练期间设置为 False,在生成期间设置为 True output_attentions (bool, 可选): 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量中的 attentions。此参数仅可在急切模式下使用,在图模式下,将使用配置中的值。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量中的 attentions。此参数仅可在急切模式下使用,在图模式下,将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的 hidden_states。此参数仅可在急切模式下使用,在图形模式下,将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图形模式下,该值将始终设置为 True。
  • training (bool, 可选,默认为 False) — 是否在训练模式下使用模型(某些模块,例如 dropout 模块,在训练和评估之间有不同的行为)。

返回

transformers.modeling_tf_outputs.TFSeq2SeqModelOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutputtf.Tensor 的元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (PegasusConfig) 和输入的各种元素。

  • last_hidden_state (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出处的隐藏状态序列。

    如果使用 past_key_values,则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (List[tf.Tensor], 可选,在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstf.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 (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。

  • 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 后,用于计算自注意力头部的加权平均值。

The TFPegasusModel forward method, overrides the __call__ special method.

虽然正向传递的配方需要在此函数中定义,但之后应该调用 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_state

TFPegasusForConditionalGeneration

class transformers.TFPegasusForConditionalGeneration

< >

( 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 函数一样传递输入!

调用

< >

( 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 or tuple(tf.Tensor)

参数

  • input_ids (tf.Tensor 形状为 ({0})) — 句子中每个词在词汇表中的索引。

    可以通过 AutoTokenizer 获取索引。 查看 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 获取更多详情。

    什么是 input IDs?

  • attention_mask (tf.Tensor 形状为 ({0}), 可选) — 掩码用于避免对填充词索引执行注意力操作。 掩码值选择范围在 [0, 1] 中:

    • 1 表示该词 **没有被掩码**
    • 0 表示该词 **被掩码**

    什么是 attention masks?

  • decoder_input_ids (tf.Tensor 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列中每个词在词汇表中的索引。

    可以通过 AutoTokenizer 获取索引。 查看 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 获取更多详情。

    什么是 decoder input IDs?

    Pegasus 使用 pad_token_id 作为 decoder_input_ids 生成时的起始词。 如果使用 past_key_values,可以选择只输入最后的 decoder_input_ids (查看 past_key_values)。

  • decoder_attention_mask (tf.Tensor 形状为 (batch_size, target_sequence_length), 可选) — 默认情况下会自动生成,并忽略填充词。 对于大多数用例,不建议设置此参数。
  • decoder_position_ids (tf.Tensor 形状为 (batch_size, sequence_length), 可选) — 解码器输入序列中每个词在位置嵌入中的位置索引。 选择范围在 [0, config.max_position_embeddings - 1] 中。
  • head_mask (tf.Tensor 形状为 (encoder_layers, encoder_attention_heads), 可选) — 掩码用于将编码器中注意力模块中选定的注意力头归零。 掩码值选择范围在 [0, 1] 中:

    • 1 表示该注意力头 **没有被掩码**
    • 0 表示该注意力头 **被掩码**
  • decoder_head_mask (tf.Tensor 形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示头 **未被掩盖**
    • 0 表示头 **被掩盖**
  • cross_attn_head_mask (tf.Tensor 形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头无效的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示头 **未被掩盖**
    • 0 表示头 **被掩盖**
  • encoder_outputs (tf.FloatTensor, 可选) — 编码器最后一层输出的隐藏状态。用于解码器的交叉注意力。形状为 (batch_size, sequence_length, hidden_size),是关于 ... 的一个序列。
  • past_key_values (Tuple[Tuple[tf.Tensor]] 长度为 config.n_layers) — 包含预先计算的注意力块的关键值隐藏状态。可用于加速解码。如果使用 past_key_values,用户可以选择仅输入最后 decoder_input_ids(那些没有提供过去关键值状态的 decoder_input_ids)形状为 (batch_size, 1),而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)
  • inputs_embeds (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,您无需传递 input_ids,而是选择直接传递嵌入式表示。如果您希望比模型的内部嵌入查找矩阵更能控制如何将 input_ids 索引转换为关联向量,这将很有用。
  • use_cache (bool, 可选,默认为 True) — 如果设置为 True,将返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。在训练期间设置为 False,在生成期间设置为 True output_attentions (bool, 可选): 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的 attentions。此参数仅可在急切模式下使用,在图形模式下,将使用配置中的值。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的 attentions。此参数仅可在急切模式下使用,在图形模式下,将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的 hidden_states。此参数仅可在急切模式下使用,在图形模式下,将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图形模式下,该值始终设置为 True。
  • labels (tf.tensor 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 中(参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记进行计算。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=Falseconfig.return_dict=False 时),包含根据配置 (PegasusConfig) 和输入而定的各种元素。

  • loss (tf.Tensor 形状为 (n,), 可选,在提供 labels 时返回) — 语言建模损失。

  • logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (List[tf.Tensor], 可选,在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstf.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 (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。

  • 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))
JAX
隐藏 JAX 内容

FlaxPegasusModel

class transformers.FlaxPegasusModel

< >

( 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.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    这可以用来启用混合精度训练或 GPU 或 TPU 上的半精度推理。如果指定,所有计算将使用给定的 dtype 执行。

    注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参见 to_fp16()to_bf16().

Pegasus 模型的裸 Transformer,输出原始隐藏状态,没有任何特定的头部。该模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。

该模型也是 Flax Linen flax.nn.Module 子类。将其用作常规的 Flax 模块,并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

最后,该模型支持 JAX 的内在功能,例如

__call__

< >

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充,默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (jnp.ndarray 形状为 (batch_size, sequence_length)可选) — 掩码,用于避免对填充标记索引执行注意力。掩码值选择在 [0, 1] 中:

    • 1 表示未屏蔽的标记,
    • 0 表示屏蔽的标记。

    什么是注意力掩码?

  • decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length)可选) — 词汇表中解码器输入序列标记的索引。

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

    什么是解码器输入 ID?

  • decoder_attention_mask (jnp.ndarray 形状为 (batch_size, target_sequence_length)可选) — 默认行为:生成一个张量,该张量忽略 decoder_input_ids 中的填充标记。默认情况下,因果掩码也将被使用。

    如果您想更改填充行为,您应该根据您的需要进行修改。有关默认策略的更多信息,请参阅 论文 中的图 1。

  • position_ids (numpy.ndarray 形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列标记的位置索引。选择在 [0, config.max_position_embeddings - 1] 范围内。
  • decoder_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.FlaxSeq2SeqModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (PegasusConfig) 和输入而不同的各种元素。

  • last_hidden_state (jnp.ndarray 形状为 (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出处的隐藏状态序列。

    如果使用 past_key_values,则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (tuple(tuple(jnp.ndarray))可选,在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(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 时返回) — jnp.ndarray 元组(一个用于嵌入的输出 + 一个用于每个层的输出),形状为 (batch_size, sequence_length, hidden_

    解码器在每层输出处的隐藏状态加上初始嵌入输出。

  • decoder_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器的注意力权重,在注意力 Softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器交叉注意力层的注意力权重,经过注意力 softmax 后,用于计算交叉注意力头部的加权平均值。

  • encoder_last_hidden_state (jnp.ndarray,形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    编码器在每层输出处的隐藏状态加上初始嵌入输出。

  • encoder_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    编码器的注意力权重,经过注意力 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

encode

< >

( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray,形状为 (batch_size, sequence_length)) — 词汇表中输入序列词元的索引。如果您提供填充,默认情况下将忽略填充。

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

    什么是输入 ID?

  • 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 or tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputtorch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),包括根据配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>) 和输入而变化的各种元素。

  • last_hidden_state (jnp.ndarray,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态加上初始嵌入输出。

  • attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 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)

decode

< >

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentionstuple(torch.FloatTensor)

参数

  • decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length)) — 解码器输入序列令牌在词汇表中的索引。

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

    什么是解码器输入 ID?

  • 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.FlaxBaseModelOutputWithPastAndCrossAttentions or 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 (jnp.ndarray,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

    如果使用 past_key_values,则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可选,在传递了 use_cache=True 或当 config.use_cache=True 时返回) — tuple(jnp.ndarray) 的元组,长度为 config.n_layers,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量,并且如果 config.is_encoder_decoder=True,还可以选择包含 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预先计算的隐藏状态(自注意力块中的键和值,以及如果 config.is_encoder_decoder=True 则在交叉注意力块中的键和值),这些状态可以用于(参见 past_key_values 输入)加快顺序解码速度。

  • hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态加上初始嵌入输出。

  • attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(jnp.ndarray), 可选,在传递了 output_attentions=Trueconfig.add_cross_attention=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器交叉注意力层的注意力权重,经过注意力 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_state

FlaxPegasusForConditionalGeneration

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.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    这可以用来启用混合精度训练或在 GPU 或 TPU 上进行半精度推理。如果指定,所有计算将使用给定的 dtype 执行。

    注意,这仅指定计算的 dtype,不会影响模型参数的 dtype。

    如果你希望更改模型参数的 dtype,请参见 to_fp16()to_bf16()

带有语言建模头的 PEGASUS 模型。可用于摘要。此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、修剪头等)。

该模型也是 Flax Linen flax.nn.Module 子类。将其用作常规的 Flax 模块,并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

最后,该模型支持 JAX 的内在功能,例如

__call__

< >

( input_ids: 数组 attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None position_ids: 可选 = None decoder_position_ids: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None train: bool = False params: 字典 = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray 形状为 (batch_size, sequence_length)) — 句子中每个词在词典中的索引。默认情况下,如果提供了填充,填充将被忽略。

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

    什么是输入 ID?

  • attention_mask (jnp.ndarray 形状为 (batch_size, sequence_length), 可选) — 掩码用于避免对填充词索引执行注意力。掩码值选择在 [0, 1] 内:

    • 1 表示 **未掩码** 的词
    • 0 表示 **掩码** 的词

    什么是注意力掩码?

  • decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入句子中每个词在词典中的索引。

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

    什么是解码器输入 ID?

  • decoder_attention_mask (jnp.ndarray 形状为 (batch_size, target_sequence_length), 可选) — 默认行为:生成一个张量,它忽略 decoder_input_ids 中的填充词。因果掩码默认情况下也会使用。

    如果您想更改填充行为,则应该根据您的需要修改它。有关默认策略的更多信息,请参阅 论文 中的图表 1。

  • position_ids (numpy.ndarray 形状为 (batch_size, sequence_length), 可选) — 输入句子中每个词在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 内。
  • decoder_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, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者 config.return_dict=False),包含根据配置 (PegasusConfig) 和输入而不同的各种元素。

  • logits (jnp.ndarray 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数 (SoftMax 之前的每个词汇表标记的分数)。

  • past_key_values (tuple(tuple(jnp.ndarray))可选,在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(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 时返回) — jnp.ndarray 元组(一个用于嵌入的输出 + 一个用于每个层的输出),形状为 (batch_size, sequence_length, hidden_

    解码器在每层输出处的隐藏状态加上初始嵌入输出。

  • decoder_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器的注意力权重,在注意力 Softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器交叉注意力层的注意力权重,经过注意力 softmax 后,用于计算交叉注意力头部的加权平均值。

  • encoder_last_hidden_state (jnp.ndarray,形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    编码器在每层输出处的隐藏状态加上初始嵌入输出。

  • encoder_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    编码器的注意力权重,经过注意力 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()

encode

< >

( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray 形状为 (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。如果您提供填充,默认情况下将忽略填充。

    索引可以使用 AutoTokenizer 获得。有关详细信息,请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (jnp.ndarray 形状为 (batch_size, sequence_length), optional) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值:

    • 1 表示未掩码的标记,
    • 0 表示已掩码的标记。

    什么是注意力掩码?

  • position_ids (numpy.ndarray 形状为 (batch_size, sequence_length), optional) — 输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量中的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量中的 hidden_states
  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputtorch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),包括根据配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>) 和输入而变化的各种元素。

  • last_hidden_state (jnp.ndarray,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态加上初始嵌入输出。

  • attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 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)

decode

< >

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None deterministic: bool = True params: dict = None dropout_rng: PRNGKey = None ) transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length)) — 解码器输入序列的标记在词汇表中的索引。

    索引可以通过 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是解码器输入 ID?

  • 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.FlaxCausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentionstorch.FloatTensor 的元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>) 和输入的各种元素。

  • logits (jnp.ndarray 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数 (SoftMax 之前的每个词汇表标记的分数)。

  • hidden_states (jnp.ndarray 的元组, 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态加上初始嵌入输出。

  • attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (jnp.ndarray 的元组, 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    交叉注意力 softmax 后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可选,当传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layersjnp.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
< > 在 GitHub 上更新