Transformers 文档
Pegasus
并获得增强的文档体验
开始使用
Pegasus
概述
Pegasus 模型在 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中被提出,作者是 Jingqing Zhang、Yao Zhao、Mohammad Saleh 和 Peter J. Liu,于 2019 年 12 月 18 日发布。
根据摘要,
- Pegasus 的预训练任务有意地与摘要任务相似:重要的句子从输入文档中移除/掩盖,并从剩余的句子中作为一个输出序列生成,类似于抽取式摘要。
- Pegasus 在所有 12 个下游任务上实现了 SOTA 摘要性能,通过 ROUGE 和人工评估衡量。
此模型由 sshleifer 贡献。作者的代码可以在这里找到。
使用技巧
序列到序列模型,具有与 BART 相同的编码器-解码器模型架构。Pegasus 在两个自监督目标函数上联合预训练:掩码语言建模 (MLM) 和一种新颖的特定于摘要的预训练目标,称为 Gap Sentence Generation (GSG)。
- MLM:编码器输入标记被随机替换为掩码标记,并且必须由编码器预测(如 BERT 中一样)
- GSG:整个编码器输入句子被第二个掩码标记替换并馈送到解码器,但解码器具有因果掩码以隐藏未来的词,就像常规的自回归 Transformer 解码器一样。
不支持 FP16(欢迎对此提供帮助/想法!)。
建议为 pegasus 微调使用 adafactor 优化器。
检查点
除了 pegasus-large 之外,所有 检查点 都针对摘要进行了微调,其他检查点都是由此微调而来
- 每个检查点在磁盘上占用 2.2 GB,参数为 568M。
- 不支持 FP16(欢迎对此提供帮助/想法!)。
- 在 v100 GPU 上使用默认参数,以 fp32 总结 xsum 大约需要 400 毫秒/样本。
- 完整的复制结果和正确预处理的数据可以在此 Issue 中找到。
- Distilled checkpoints 在这篇 论文 中描述。
实现说明
- 所有模型都是 Transformer 编码器-解码器,每个组件中有 16 层。
- 该实现完全继承自 BartForConditionalGeneration
- 一些关键配置差异
- 静态正弦位置嵌入
- 模型开始生成时,使用 pad_token_id(其 token_embedding 为 0)作为前缀。
- 使用更多束搜索 (
num_beams=8
)
- 所有预训练的 pegasus 检查点都是相同的,除了三个属性:
tokenizer.model_max_length
(最大输入大小),max_length
(要生成的最大 token 数) 和length_penalty
。 - 将作者的 repo 中训练的检查点转换为 PyTorch 的代码可以在
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."
... )
资源
- 在 XSUM 数据集上微调 pegasus 的 脚本。数据下载说明请见 examples/pytorch/summarization/。
- 因果语言建模任务指南
- 翻译任务指南
- 摘要任务指南
PegasusConfig
class transformers.PegasusConfig
< source >( vocab_size = 50265 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 0 scale_embedding = False pad_token_id = 0 eos_token_id = 1 forced_eos_token_id = 1 **kwargs )
参数
- vocab_size (`int`, *可选的*, 默认为 50265) — PEGASUS 模型的词汇表大小。定义了在调用 PegasusModel 或 TFPegasusModel 时传递的
inputs_ids
可以表示的不同 token 的数量。 - d_model (`int`, *可选的*, 默认为 1024) — 层和池化层的维度。
- encoder_layers (`int`, *可选的*, 默认为 12) — 编码器层数。
- decoder_layers (`int`, *可选的*, 默认为 12) — 解码器层数。
- encoder_attention_heads (`int`, *可选的*, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
- decoder_attention_heads (`int`, *可选的*, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。
- decoder_ffn_dim (`int`, *可选的*, 默认为 4096) — 解码器中 “中间” 层(通常称为前馈层)的维度。
- encoder_ffn_dim (`int`, *可选的*, 默认为 4096) — 编码器中 “中间” 层(通常称为前馈层)的维度。
- activation_function (`str` 或 `function`, *可选的*, 默认为 `"gelu"`) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 `"gelu"`, `"relu"`, `"silu"` 和 `"gelu_new"`。
- dropout (`float`, *可选的*, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 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) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
- 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) 来缩放嵌入。
- use_cache (`bool`, *可选的*, 默认为 `True`) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
- forced_eos_token_id (`int`, *可选的*, 默认为 1) — 当达到 `max_length` 时,强制作为最后一个生成的 token 的 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_file pad_token = '<pad>' eos_token = '</s>' unk_token = '<unk>' mask_token = '<mask_2>' mask_token_sent = '<mask_1>' additional_special_tokens = None offset = 103 sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )
参数
- vocab_file (
str
) — SentencePiece 文件 (通常具有 .spm 扩展名),其中包含实例化 tokenizer 所需的词汇表。 - pad_token (
str
, optional, defaults to"<pad>"
) — 用于填充的 token,例如在对不同长度的序列进行批处理时。 - eos_token (
str
, optional, defaults to"</s>"
) — 序列结束 token。当使用特殊 token 构建序列时,这并非用于序列结束的 token。 所使用的 token 是
sep_token
。 - unk_token (
str
, optional, defaults to"<unk>"
) — 未知 token。词汇表中不存在的 token 无法转换为 ID,而是设置为此 token。 - mask_token (
str
, optional, defaults to"<mask_2>"
) — 用于掩盖单个 token 值的 token。这是使用掩码语言建模 (MLM) 训练此模型时使用的 token。这是 PEGASUS 编码器在预训练期间尝试预测的 token。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK2]。 - mask_token_sent (
str
, optional, defaults to"<mask_1>"
) — 用于掩盖整个目标句子的 token。这是使用 gap sentences generation (GSG) 训练此模型时使用的 token。这是 PEGASUS 解码器在预训练期间尝试预测的句子。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK1]。 - additional_special_tokens (
List[str]
, optional) — tokenizer 使用的其他特殊 token。如果未提供 additional_special_tokens,则使用 <mask_2> 和 <unk_2, …,="" unk_102=""> 作为附加的特殊 token,对应于仅将 token 2 - 104 用于预训练的 原始 PEGASUS tokenizer。 - sp_model_kwargs (
dict
, optional) — 将传递给SentencePieceProcessor.__init__()
方法。 SentencePiece 的 Python 封装器 可用于设置以下内容:-
enable_sampling
: 启用子词正则化。 -
nbest_size
: unigram 的采样参数。对 BPE-Dropout 无效。nbest_size = {0,1}
: 不执行采样。nbest_size > 1
: 从 nbest_size 结果中采样。nbest_size < 0
: 假设 nbest_size 是无限的,并使用前向过滤和后向采样算法从所有假设(格)中采样。
-
alpha
: unigram 采样的平滑参数,以及 BPE-dropout 的合并操作的 dropout 概率。
-
Construct a PEGASUS tokenizer. 基于 SentencePiece。
This tokenizer inherits from PreTrainedTokenizer which contains most of the main methods. Users should refer to this superclass for more information regarding those methods.
build_inputs_with_special_tokens
< source >( token_ids_0 token_ids_1 = None ) → List[int]
Build model inputs from a sequence or a pair of sequences for sequence classification tasks by concatenating and adding special tokens. A PEGASUS sequence has the following format, where X
represents the sequence
- single sequence:
X </s>
- pair of sequences:
A B </s>
(not intended use)
BOS is never used. Pairs of sequences are not the expected use case, but they will be handled without a separator.
Converts a sequence of tokens (string) in a single string.
get_special_tokens_mask
< source >( token_ids_0: typing.List token_ids_1: typing.Optional[typing.List] = None already_has_special_tokens: bool = False )
Get list where entries are [1] if a token is [eos] or [pad] else 0.
Just EOS
PegasusTokenizerFast
class transformers.PegasusTokenizerFast
< source >( vocab_file = None tokenizer_file = None pad_token = '<pad>' eos_token = '</s>' unk_token = '<unk>' mask_token = '<mask_2>' mask_token_sent = '<mask_1>' additional_special_tokens = None offset = 103 **kwargs )
参数
- vocab_file (
str
) — SentencePiece 文件 (通常具有 .spm 扩展名),其中包含实例化 tokenizer 所需的词汇表。 - pad_token (
str
, optional, defaults to"<pad>"
) — 用于填充的 token,例如在对不同长度的序列进行批处理时。 - eos_token (
str
, optional, defaults to"</s>"
) — 序列结束 token。当使用特殊 token 构建序列时,这并非用于序列结束的 token。 所使用的 token 是
sep_token
。 - unk_token (
str
, optional, defaults to"<unk>"
) — 未知 token。词汇表中不存在的 token 无法转换为 ID,而是设置为此 token。 - mask_token (
str
, optional, defaults to"<mask_2>"
) — 用于掩盖单个 token 值的 token。这是使用掩码语言建模 (MLM) 训练此模型时使用的 token。这是 PEGASUS 编码器在预训练期间尝试预测的 token。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK2]。 - mask_token_sent (
str
, optional, defaults to"<mask_1>"
) — 用于掩盖整个目标句子的 token。这是使用 gap sentences generation (GSG) 训练此模型时使用的 token。这是 PEGASUS 解码器在预训练期间尝试预测的句子。它对应于 PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization 中的 [MASK1]。 - additional_special_tokens (
List[str]
, optional) — 分词器使用的额外特殊 token。 如果没有提供 additional_special_tokens,则 <mask_2> 和 <unk_2, …, unk_102> 将用作额外的特殊 token,对应于original PEGASUS tokenizer,该分词器仅将 token 2 - 104 用于预训练
构建一个“快速” PEGASUS 分词器(由 HuggingFace 的 tokenizers 库支持)。 基于 Unigram。
此分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0 token_ids_1 = None ) → List[int]
通过在序列末尾添加 eos 来构建模型输入。 前面没有添加 bos token。
- single sequence:
X </s>
- pair of sequences:
A B </s>
(not intended use)
get_special_tokens_mask
< source >( token_ids_0: typing.List token_ids_1: typing.Optional[typing.List] = None already_has_special_tokens: bool = False )
Get list where entries are [1] if a token is [eos] or [pad] else 0.
PegasusModel
class transformers.PegasusModel
< source >( config: PegasusConfig )
参数
- config (
PegasusConfig
) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 PEGASUS 模型,输出原始隐藏状态,顶部没有任何特定的 head。 此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入 embedding 大小、剪枝 head 等)。
此模型也是 PyTorch torch.nn.Module
子类。 将其用作常规 PyTorch Module,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[typing.Tuple[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列 token 的索引。 默认情况下,如果您提供 padding,则会被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
,形状为(batch_size, sequence_length)
, 可选) — 用于避免对 padding token 索引执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 token 未被 mask,
- 0 表示 token 被 mask。
- decoder_input_ids (
torch.LongTensor
,形状为(batch_size, target_sequence_length)
, 可选) — 词汇表中 decoder 输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Pegasus 使用
pad_token_id
作为decoder_input_ids
生成的起始 token。 如果使用past_key_values
,则可以选择仅输入最后一个decoder_input_ids
(请参阅past_key_values
)。 - decoder_attention_mask (
torch.LongTensor
,形状为(batch_size, target_sequence_length)
, 可选) — 默认行为:生成一个 tensor,该 tensor 忽略decoder_input_ids
中的 pad token。 默认情况下,也将使用因果 mask。 - head_mask (
torch.Tensor
,形状为(encoder_layers, encoder_attention_heads)
, 可选) — 用于 nullify encoder 中 attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 head 未被 mask,
- 0 表示 head 被 mask。
- decoder_head_mask (
torch.Tensor
,形状为(decoder_layers, decoder_attention_heads)
, 可选) — 用于 nullify decoder 中 attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 head 未被 mask,
- 0 表示 head 被 mask。
- cross_attn_head_mask (
torch.Tensor
,形状为(decoder_layers, decoder_attention_heads)
, 可选) — 用于 nullify decoder 中 cross-attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 head 未被 mask,
- 0 表示 head 被 mask。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)
, 可选) — Tuple 由 (last_hidden_state
, 可选:hidden_states
, 可选:attentions
) 组成。last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
, 可选) 是 encoder 最后一层输出端的隐藏状态序列。 用于 decoder 的 cross-attention 中。 - past_key_values (
tuple(tuple(torch.FloatTensor))
, 可选, 当传递use_cache=True
或config.use_cache=True
时返回) —tuple(torch.FloatTensor)
的 tuple,长度为config.n_layers
,每个 tuple 包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的 tensor 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的附加 tensor。包含预先计算的隐藏状态(self-attention 块和 cross-attention 块中的 key 和 value),可以用于(请参阅
past_key_values
输入)加速顺序解码。如果使用
past_key_values
,则用户可以选择仅输入最后一个decoder_input_ids
(那些没有将其过去的 key value 状态提供给此模型的)形状为(batch_size, 1)
,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 - inputs_embeds (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
, 可选) — 可选地,您可以选择直接传递 embedding 表示,而不是传递input_ids
。 如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - decoder_inputs_embeds (
torch.FloatTensor
,形状为(batch_size, target_sequence_length, hidden_size)
, 可选) — 可选地,您可以选择直接传递 embedding 表示,而不是传递decoder_input_ids
。 如果使用past_key_values
,则可以选择仅输入最后一个decoder_inputs_embeds
(请参阅past_key_values
)。 如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将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 而不是纯元组。
Returns
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 torch.FloatTensor
元组 (如果传递 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (PegasusConfig) 和输入。
-
last_hidden_state (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层输出端的隐藏状态序列。如果使用
past_key_values
,则仅输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的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
输入)加速顺序解码。 -
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=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(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)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入输出之一,+ 每个层的输出之一),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
PegasusModel forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 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: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[typing.Tuple[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。 默认情况下,如果您提供填充,则会忽略填充。可以使用 AutoTokenizer 获取索引。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
- 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() 。
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
) 组成,形状为(batch_size, sequence_length, hidden_size)
的last_hidden_state
, 可选) 是编码器最后一层输出端的隐藏状态序列。 在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的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
(那些没有将其过去的键值状态提供给此模型的) ,形状为(batch_size, 1)
而不是所有形状为(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_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 而不是普通的元组。 - labels (
torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 用于计算掩码语言建模损失的标签。 索引应该在[0, ..., config.vocab_size]
或 -100 中(参见input_ids
文档字符串)。 索引设置为-100
的 token 将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
中的 token 计算。
Returns
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,)
,optional,当提供labels
时返回) — 语言建模损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测得分(SoftMax 之前的每个词汇表 token 的得分)。 -
past_key_values (
tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的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
输入)加速顺序解码。 -
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=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(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)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入输出之一,+ 每个层的输出之一),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
PegasusForConditionalGeneration
的 forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
摘要示例
>>> from transformers import AutoTokenizer, PegasusForConditionalGeneration
>>> model = PegasusForConditionalGeneration.from_pretrained("google/pegasus-xsum")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-xsum")
>>> ARTICLE_TO_SUMMARIZE = (
... "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer(ARTICLE_TO_SUMMARIZE, max_length=1024, return_tensors="pt")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"])
>>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"California's largest electricity provider has turned off power to hundreds of thousands of customers."
PegasusForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列 token 的索引。 默认情况下,如果您提供 padding,则会被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
,形状为(batch_size, sequence_length)
,optional) — 掩码,用于避免在 padding token 索引上执行 attention。 掩码值在[0, 1]
中选择:- 1 表示 token 未被掩码,
- 0 表示 token 已被掩码。
- encoder_hidden_states (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 编码器最后一层的输出端的隐藏状态序列。 如果模型配置为解码器,则在交叉注意力中使用。 - encoder_attention_mask (
torch.FloatTensor
,形状为(batch_size, sequence_length)
,optional) — 掩码,用于避免对编码器输入的 padding token 索引执行 attention。 如果模型配置为解码器,则此掩码在交叉注意力中使用。 掩码值在[0, 1]
中选择: - head_mask (
torch.Tensor
,形状为(decoder_layers, decoder_attention_heads)
,optional) — 掩码,用于使所选的 attention 模块的 head 失效。 掩码值在[0, 1]
中选择:- 1 表示 head 未被掩码,
- 0 表示 head 已被掩码。
- cross_attn_head_mask (
torch.Tensor
,形状为(decoder_layers, decoder_attention_heads)
,optional) — 掩码,用于使所选的交叉 attention 模块的 head 失效。 掩码值在[0, 1]
中选择:- 1 表示 head 未被掩码,
- 0 表示 head 已被掩码。
- past_key_values (
tuple(tuple(torch.FloatTensor))
,optional,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(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)
,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
)。- 1 表示 token 未被掩码,
- 0 表示 token 已被掩码。
- output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions
部分以了解更多详情。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states
部分以了解更多详情。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通的元组。
Returns
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (PegasusConfig) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 语言建模损失(用于下一个 token 预测)。 -
logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测得分(SoftMax 之前的每个词汇表 token 的得分)。 -
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)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。交叉注意力 softmax 之后的注意力权重,用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(torch.FloatTensor))
,optional,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的torch.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
TFPegasusModel
类 (class) transformers.TFPegasusModel
< 源代码 (source) >( 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 函数一样传递输入!
call
< 源代码 (source) >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的tf.Tensor
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)
的tf.Tensor
, 可选) — 掩码,用于避免对填充标记索引执行注意力机制。掩码值在[0, 1]
中选择:- 1 表示标记未被掩盖,
- 0 表示标记已被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)
的tf.Tensor
, 可选) — 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Pegasus 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可以选择仅输入最后一个decoder_input_ids
(请参阅past_key_values
)。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)
的tf.Tensor
, 可选) — 默认情况下将创建此掩码,并忽略填充标记。不建议在大多数用例中设置此参数。 - decoder_position_ids (形状为
(batch_size, sequence_length)
的tf.Tensor
, 可选) — 位置嵌入中每个解码器输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)
的tf.Tensor
, 可选) — 掩码,用于使编码器中注意力模块的选定头部无效。掩码值在[0, 1]
中选择:- 1 表示头部未被掩盖,
- 0 表示头部已被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)
的tf.Tensor
, 可选) — 掩码,用于使解码器中注意力模块的选定头部无效。掩码值在[0, 1]
中选择:- 1 表示头部未被掩盖,
- 0 表示头部已被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)
的tf.Tensor
, 可选) — 掩码,用于使交叉注意力模块的选定头部无效。掩码值在[0, 1]
中选择:- 1 表示头部未被掩盖,
- 0 表示头部已被掩盖。
- encoder_outputs (
tf.FloatTensor
, 可选) — 编码器最后一层输出的隐藏状态。在解码器的交叉注意力机制中使用。形状为(batch_size, sequence_length, hidden_size)
的序列 - past_key_values (长度为
config.n_layers
的Tuple[Tuple[tf.Tensor]]
) — 包含注意力模块的预计算的键和值隐藏状态。可用于加速解码。如果使用past_key_values
,则用户可以选择仅输入最后一个decoder_input_ids
(那些没有将其过去的键值状态提供给此模型的)的形状为(batch_size, 1)
,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)
的tf.Tensor
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - use_cache (
bool
, 可选, 默认为True
) — 如果设置为True
,则返回past_key_values
键值状态,并且可以用于加速解码(请参阅past_key_values
)。在训练期间设置为False
,在生成输出注意力 (bool
, 可选) 期间设置为True
:是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是纯元组。此参数可以在 eager 模式下使用,在 graph 模式下该值将始终设置为 True。 - training (
bool
, 可选, 默认为False
) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
Returns
transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个 tf.Tensor
的元组 (tuple)(如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (PegasusConfig) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的tf.Tensor
) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values
,则仅输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values (
List[tf.Tensor]
, 可选, 当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,其中每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器的预计算隐藏状态(注意力模块中的键和值),可以用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states (
tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —tf.Tensor
元组(每个嵌入输出 + 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的tf.Tensor
, 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —tf.Tensor
元组(每个嵌入输出 + 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
TFPegasusModel 的 forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 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
< source >( config *inputs **kwargs )
参数
- config (PegasusConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
带有语言建模头的 PEGASUS 模型。可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。
此模型也是 keras.Model 的子类。可将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档,了解与常规用法和行为相关的所有事项。
transformers
中的 TensorFlow 模型和层接受两种输入格式
- 将所有输入作为关键字参数(类似于 PyTorch 模型),或者
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit()
等方法时,事情应该“正常工作” - 只需以 model.fit()
支持的任何格式传递您的输入和标签!但是,如果您想在 Keras 方法(如 fit()
和 predict()
)之外使用第二种格式,例如在使用 Keras Functional
API 创建您自己的层或模型时,您可以使用以下三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids
的单个张量,没有其他内容:model(input_ids)
- 具有可变长度的列表,其中包含一个或多个输入张量,顺序与文档字符串中给出的顺序相同:
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
- 字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用 子类化 创建模型和层时,您无需担心这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[TFBaseModelOutput] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (形状为
({0})
的tf.Tensor
) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。
- attention_mask (形状为
({0})
的tf.Tensor
, 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示标记未被掩盖,
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)
的tf.Tensor
, 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。
Pegasus 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可以选择仅输入最后一个decoder_input_ids
(参见past_key_values
)。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)
的tf.Tensor
, 可选) — 默认情况下将创建,并忽略 pad 标记。不建议在大多数用例中设置此项。 - decoder_position_ids (形状为
(batch_size, sequence_length)
的tf.Tensor
, 可选) — 解码器输入序列中每个标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)
的tf.Tensor
, 可选) — 用于使编码器中注意力模块的选定注意力头无效的掩码。掩码值在[0, 1]
中选择:- 1 表示注意力头未被掩盖,
- 0 表示注意力头被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)
的tf.Tensor
, 可选) — 用于使解码器中注意力模块的选定注意力头无效的掩码。掩码值在[0, 1]
中选择:- 1 表示注意力头未被掩盖,
- 0 表示注意力头被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)
的tf.Tensor
, 可选) — 用于使交叉注意力模块的选定注意力头无效的掩码。掩码值在[0, 1]
中选择:- 1 表示注意力头未被掩盖,
- 0 表示注意力头被掩盖。
- encoder_outputs (
tf.FloatTensor
, 可选) — 编码器最后一层输出处的隐藏状态。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)
的序列是 - past_key_values (长度为
config.n_layers
的Tuple[Tuple[tf.Tensor]]
) — 包含注意力模块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values
,用户可以选择仅输入最后一个decoder_input_ids
(那些没有将其过去的键值状态提供给此模型的输入),其形状为(batch_size, 1)
,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)
的tf.Tensor
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - use_cache (
bool
, 可选, 默认为True
) — 如果设置为True
,则返回past_key_values
键值状态,并可用于加速解码(参见past_key_values
)。在训练期间设置为False
,在生成期间设置为True
output_attentions (bool
, 可选): 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回的张量下的attentions
。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值代替。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回的张量下的attentions
。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值代替。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回的张量下的hidden_states
。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值代替。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用,在 graph 模式下该值将始终设置为 True。 - training (
bool
, 可选, 默认为False
) — 是否在训练模式下使用模型(某些模块,如 dropout 模块,在训练和评估之间具有不同的行为)。 - labels (形状为
(batch_size, sequence_length)
的tf.tensor
, 可选) — 用于计算掩码语言建模损失的标签。索引应为[0, ..., config.vocab_size]
或 -100(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
中的标记计算。
Returns
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tf.Tensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时),包括各种元素,具体取决于配置 (PegasusConfig) 和输入。
-
loss (形状为
(n,)
的tf.Tensor
, 可选, 其中 n 是非掩码标签的数量,当提供labels
时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)
的tf.Tensor
) — 语言建模头的预测分数(SoftMax 之前每个词汇表标记的分数)。 -
past_key_values (
List[tf.Tensor]
, 可选, 当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,其中每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器的预计算隐藏状态(注意力模块中的键和值),可以用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states (
tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —tf.Tensor
元组(每个嵌入输出 + 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的tf.Tensor
, 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —tf.Tensor
元组(每个嵌入输出 + 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
TFPegasusForConditionalGeneration 的 forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
摘要示例
>>> from transformers import AutoTokenizer, TFPegasusForConditionalGeneration
>>> model = TFPegasusForConditionalGeneration.from_pretrained("google/pegasus-xsum")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-xsum")
>>> ARTICLE_TO_SUMMARIZE = (
... "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer(ARTICLE_TO_SUMMARIZE, max_length=1024, return_tensors="tf")
>>> # Generate Summary
>>> summary_ids = model.generate(input_ids)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))
FlaxPegasusModel
class transformers.FlaxPegasusModel
< source >( config: PegasusConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (PegasusConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认是jax.numpy.float32
) — 计算的数据类型。可以是jax.numpy.float32
,jax.numpy.float16
(在 GPUs 上) 和jax.numpy.bfloat16
(在 TPUs 上) 之一。这可以用于在 GPUs 或 TPUs 上启用混合精度训练或半精度推理。如果指定,所有计算将使用给定的
dtype
执行。请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。
裸 Pegasus 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的 head。此模型继承自 FlaxPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块,并参考 Flax 文档以了解所有与通用用法和行为相关的事项。
最后,此模型支持固有的 JAX 功能,例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列 token 的索引。如果您提供 padding,默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray
,形状为(batch_size, sequence_length)
, 可选) — Mask,用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]
中选择:- 1 表示 未被 mask 的 token,
- 0 表示 被 mask 的 token。
- decoder_input_ids (
jnp.ndarray
,形状为(batch_size, target_sequence_length)
, 可选) — 词汇表中 decoder 输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- decoder_attention_mask (
jnp.ndarray
,形状为(batch_size, target_sequence_length)
, 可选) — 默认行为:生成一个 tensor,忽略decoder_input_ids
中的 padding token。默认情况下,也将使用因果 mask。如果您想更改 padding 行为,则应根据您的需要进行修改。有关默认策略的更多信息,请参见 论文 中的图 1。
- position_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
, 可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - decoder_position_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
, 可选) — 位置嵌入中每个 decoder 输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - output_attentions (
bool
, 可选) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息,请参阅返回的 tensors 下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的 hidden states。有关更多详细信息,请参阅返回的 tensors 下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
Returns
transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个 torch.FloatTensor
的 tuple (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (PegasusConfig) 和输入。
-
last_hidden_state (
jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
) — 模型 decoder 的最后一层输出的 hidden-states 序列。如果使用
past_key_values
,则仅输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray))
, 可选, 当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(jnp.ndarray)
的 tuple,其中每个 tuple 具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的 tensors 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的附加 tensors。包含预先计算的隐藏状态(自注意力模块和交叉注意力模块中的键和值),这些状态可用于(请参阅
past_key_values
输入)加速顺序解码。 -
decoder_hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
的 tuple (embeddings 的输出一个,每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
, 可选) — 模型 encoder 的最后一层输出的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
的 tuple (embeddings 的输出一个,每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
FlaxPegasusPreTrainedModel
forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 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
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列 token 的索引。如果您提供 padding,默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray
,形状为(batch_size, sequence_length)
, 可选) — Mask,用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]
中选择:- 1 表示 未被 mask 的 token,
- 0 表示 被 mask 的 token。
- position_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
, 可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。详见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。详见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
Returns
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>
) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层的输出,包括 embeddings 层的输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上初始 embedding 输出。
-
attentions (
tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或当config.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
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
参数
- decoder_input_ids (形状为
(batch_size, target_sequence_length)
的jnp.ndarray
) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- encoder_outputs (
tuple(tuple(jnp.ndarray)
) — 元组包含 (last_hidden_state
, optional:hidden_states
, optional:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - encoder_attention_mask (形状为
(batch_size, sequence_length)
的jnp.ndarray
, optional) — 用于避免对 padding token 索引执行注意力的 mask。Mask 值在[0, 1]
中选择:- 1 代表 token 未被 mask,
- 0 代表 token 被 mask。
- decoder_attention_mask (形状为
(batch_size, target_sequence_length)
的jnp.ndarray
, optional) — 默认行为:生成一个忽略decoder_input_ids
中 pad token 的张量。默认情况下也会使用因果 mask。如果您想更改 padding 行为,您应该根据需要进行修改。有关默认策略的更多信息,请参见 论文中的图 1。
- decoder_position_ids (形状为
(batch_size, sequence_length)
的numpy.ndarray
, optional) — 每个解码器输入序列 token 在位置 embeddings 中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - past_key_values (
Dict[str, np.ndarray]
, optional, 由init_cache
返回或在传递先前的past_key_values
时返回) — 预计算的隐藏状态字典 (注意力模块中的 key 和 value),可用于快速自回归解码。预计算的 key 和 value 隐藏状态的形状为 [batch_size, max_length]。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。详见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。详见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
Returns
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>
) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层输出的隐藏状态序列。如果使用
past_key_values
,则仅输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray))
, optional, 当传递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)
的张量。包含预计算的隐藏状态 (自注意力模块中的 key 和 value,以及可选地,如果
config.is_encoder_decoder=True
,则包含交叉注意力模块中的 key 和 value),可以用于 (参见past_key_values
输入) 加速顺序解码。 -
hidden_states (
tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层的输出,包括 embeddings 层的输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上初始 embedding 输出。
-
attentions (
tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
且config.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
< source >( config: PegasusConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (PegasusConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype
, optional, 默认为jax.numpy.float32
) — 计算的数据类型。可以是jax.numpy.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,所有计算将使用给定的
dtype
执行。请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。
带有语言建模头的 PEGASUS 模型。可用于摘要生成。此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法 (例如下载或保存、调整输入 embeddings 大小、剪枝 head 等)。
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块,并参考 Flax 文档以了解所有与通用用法和行为相关的事项。
最后,此模型支持固有的 JAX 功能,例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的jnp.ndarray
) — 输入序列 token 在词汇表中的索引。如果您提供 padding,默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)
的jnp.ndarray
, optional) — 用于避免对 padding token 索引执行注意力的 mask。Mask 值在[0, 1]
中选择:- 1 代表 token 未被 mask,
- 0 代表 token 被 mask。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)
的jnp.ndarray
, optional) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- decoder_attention_mask (
jnp.ndarray
of shape(batch_size, target_sequence_length)
, optional) — 默认行为:生成一个张量,该张量忽略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 而不是普通元组。
Returns
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 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_layers
的tuple(jnp.ndarray)
的 tuple,其中每个 tuple 具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的 tensors 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的附加 tensors。包含预先计算的隐藏状态(自注意力模块和交叉注意力模块中的键和值),这些状态可用于(请参阅
past_key_values
输入)加速顺序解码。 -
decoder_hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
的 tuple (embeddings 的输出一个,每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
, 可选) — 模型 encoder 的最后一层输出的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
的 tuple (embeddings 的输出一个,每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出端的隐藏状态,加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
FlaxPegasusPreTrainedModel
forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数中定义,但应该在之后调用 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
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray
的形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。 默认情况下,如果您提供填充,则会忽略填充。可以使用 AutoTokenizer 获取索引。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray
的形状为(batch_size, sequence_length)
,可选) — 掩码,以避免对填充标记索引执行注意力机制。 在[0, 1]
中选择的掩码值:- 1 表示未掩码的标记,
- 0 表示已掩码的标记。
- position_ids (
numpy.ndarray
的形状为(batch_size, sequence_length)
,可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
Returns
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>
) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层的输出,包括 embeddings 层的输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上初始 embedding 输出。
-
attentions (
tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或当config.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
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None deterministic: bool = True params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
参数
- decoder_input_ids (
jnp.ndarray
的形状为(batch_size, target_sequence_length)
) — 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- encoder_outputs (
tuple(tuple(jnp.ndarray)
) — 元组由 (last_hidden_state
,可选:hidden_states
,可选:attentions
) 组成,last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选) 是编码器最后一层输出端的隐藏状态序列。 在解码器的交叉注意力机制中使用。 - encoder_attention_mask (
jnp.ndarray
的形状为(batch_size, sequence_length)
,可选) — 掩码,以避免对填充标记索引执行注意力机制。 在[0, 1]
中选择的掩码值:- 1 表示未掩码的标记,
- 0 表示已掩码的标记。
- decoder_attention_mask (
jnp.ndarray
的形状为(batch_size, target_sequence_length)
,可选) — 默认行为:生成一个张量,该张量忽略decoder_input_ids
中的填充标记。默认情况下,也会使用因果掩码。如果您想更改填充行为,则应根据您的需要进行修改。 有关默认策略的更多信息,请参见论文中的图 1。
- decoder_position_ids (
numpy.ndarray
的形状为(batch_size, sequence_length)
,可选) — 位置嵌入中每个解码器输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - past_key_values (
Dict[str, np.ndarray]
,可选,由init_cache
返回或在传递先前的past_key_values
时返回) — 预先计算的隐藏状态(注意力块中的键和值)字典,可用于快速自回归解码。 预先计算的键和值隐藏状态的形状为[batch_size, max_length]。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
Returns
transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 torch.FloatTensor
的元组 (如果传递了 return_dict=False
或者当 config.return_dict=False
时),其中包含取决于配置 (<class 'transformers.models.pegasus.configuration_pegasus.PegasusConfig'>
) 和输入的各种元素。
-
logits (
jnp.ndarray
的形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇表标记的分数)。 -
hidden_states (
tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层的输出,包括 embeddings 层的输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上初始 embedding 输出。
-
attentions (
tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
元组 (每个元素对应一个层),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) —jnp.ndarray
的 tuple (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。交叉注意力 softmax 之后的注意力权重,用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的jnp.ndarray
元组的元组,每个元组都包含自注意力机制和交叉注意力机制层的缓存键、值状态(如果模型用于编码器-解码器设置)。 仅在config.is_decoder = True
时相关。包含预先计算的隐藏状态(注意力模块中的键和值),这些状态可用于(参见
past_key_values
输入)加速顺序解码。
示例
>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxPegasusForConditionalGeneration
>>> model = FlaxPegasusForConditionalGeneration.from_pretrained("google/pegasus-large")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-large")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits