Transformers 文档

ProphetNet

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

ProphetNet

PyTorch

概述

ProphetNet 模型由 Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang, Ming Zhou 于 2020 年 1 月 13 日在论文 ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training 中提出。

ProphetNet 是一个编码器-解码器模型,可以为“n-gram”语言建模预测 n 个未来的词元(token),而不仅仅是下一个词元。

论文摘要如下:

在本文中,我们提出了一种新的序列到序列预训练模型,名为 ProphetNet,它引入了一种新颖的自监督目标——未来 n-gram 预测,以及所提出的 n-stream 自注意力机制。与传统序列到序列模型中优化一步预测不同,ProphetNet 通过 n 步预测进行优化,即在每个时间步根据之前的上下文词元同时预测接下来的 n 个词元。未来 n-gram 预测明确鼓励模型为未来的词元进行规划,并防止对强局部相关性过拟合。我们分别使用基础规模数据集(16GB)和大规模数据集(160GB)对 ProphetNet 进行预训练。然后,我们在 CNN/DailyMail、Gigaword 和 SQuAD 1.1 基准上进行了摘要生成和问题生成任务的实验。实验结果表明,与使用相同规模预训练语料库的模型相比,ProphetNet 在所有这些数据集上都取得了新的最佳结果。

作者的代码可以在这里找到。

使用技巧

  • ProphetNet 是一个使用绝对位置嵌入的模型,因此通常建议在输入的右侧而不是左侧进行填充。
  • 该模型架构基于原始的 Transformer,但在解码器中用主自注意力机制以及自注意力和 n-stream(预测)自注意力机制取代了“标准”的自注意力机制。

资源

ProphetNetConfig

class transformers.ProphetNetConfig

< >

( activation_dropout: typing.Optional[float] = 0.1 activation_function: typing.Union[str, typing.Callable, NoneType] = 'gelu' vocab_size: typing.Optional[int] = 30522 hidden_size: typing.Optional[int] = 1024 encoder_ffn_dim: typing.Optional[int] = 4096 num_encoder_layers: typing.Optional[int] = 12 num_encoder_attention_heads: typing.Optional[int] = 16 decoder_ffn_dim: typing.Optional[int] = 4096 num_decoder_layers: typing.Optional[int] = 12 num_decoder_attention_heads: typing.Optional[int] = 16 attention_dropout: typing.Optional[float] = 0.1 dropout: typing.Optional[float] = 0.1 max_position_embeddings: typing.Optional[int] = 512 init_std: typing.Optional[float] = 0.02 is_encoder_decoder: typing.Optional[bool] = True add_cross_attention: typing.Optional[bool] = True decoder_start_token_id: typing.Optional[int] = 0 ngram: typing.Optional[int] = 2 num_buckets: typing.Optional[int] = 32 relative_max_distance: typing.Optional[int] = 128 disable_ngram_loss: typing.Optional[bool] = False eps: typing.Optional[float] = 0.0 use_cache: typing.Optional[bool] = True pad_token_id: typing.Optional[int] = 0 bos_token_id: typing.Optional[int] = 1 eos_token_id: typing.Optional[int] = 2 **kwargs )

参数

  • activation_dropout (float, 可选, 默认为 0.1) — 全连接层内激活函数的 dropout 比率。
  • activation_function (strfunction, 可选, 默认为 "gelu") — 编码器和池化层中的非线性激活函数(函数或字符串)。如果为字符串,支持 "gelu""relu""silu""gelu_new"
  • vocab_size (int, 可选, 默认为 30522) — ProphetNET 模型的词汇表大小。定义了调用 ProphetNetModel 时传入的 inputs_ids 可以表示的不同词元的数量。
  • hidden_size (int, 可选, 默认为 1024) — 层和池化层的维度。
  • encoder_ffn_dim (int, 可选, 默认为 4096) — 解码器中“中间”(通常称为前馈)层的维度。
  • num_encoder_layers (int, 可选, 默认为 12) — 编码器层数。
  • num_encoder_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数量。
  • decoder_ffn_dim (int, 可选, 默认为 4096) — 解码器中“中间”(通常称为前馈)层的维度。
  • num_decoder_layers (int, 可选, 默认为 12) — 解码器层数。
  • num_decoder_attention_heads (int, 可选, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数量。
  • attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
  • dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
  • max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如 512、1024 或 2048)。
  • init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • add_cross_attention (bool, 可选, 默认为 True) — 是否应向模型添加交叉注意力层。
  • is_encoder_decoder (bool, 可选, 默认为 True) — 这是否是一个编码器/解码器模型。
  • pad_token_id (int, 可选, 默认为 1) — 填充词元的 ID。
  • bos_token_id (int, 可选, 默认为 0) — 序列开始词元的 ID。
  • eos_token_id (int, 可选, 默认为 2) — 序列结束词元的 ID。
  • ngram (int, 可选, 默认为 2) — 要预测的未来词元数量。设置为 1 则与传统语言模型相同,只预测下一个词元。
  • num_buckets (int, 可选, 默认为 32) — 每个注意力层使用的桶数。用于相对位置计算。更多细节请参阅 [T5 论文](请参阅 https://huggingface.co/papers/1910.10683)。
  • relative_max_distance (int, 可选, 默认为 128) — 大于此值的相对距离将被放入最后一个相同的桶中。用于相对位置计算。更多细节请参阅 [T5 论文](请参阅 https://huggingface.co/papers/1910.10683)。
  • disable_ngram_loss (bool, 可选, 默认为 False) — 是否仅通过预测下一个词元进行训练。
  • eps (float, 可选, 默认为 0.0) — 控制损失计算中标签平滑的 epsilon 参数值。如果设置为 0,则不执行标签平滑。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。

这是用于存储 ProphetNetModel 配置的配置类。它根据指定的参数实例化 ProphetNet 模型,定义模型架构。使用默认值实例化配置将产生与 ProphetNet microsoft/prophetnet-large-uncased 架构相似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请阅读 PretrainedConfig 的文档。

ProphetNetTokenizer

class transformers.ProphetNetTokenizer

< >

( vocab_file: str do_lower_case: typing.Optional[bool] = True do_basic_tokenize: typing.Optional[bool] = True never_split: typing.Optional[collections.abc.Iterable] = None unk_token: typing.Optional[str] = '[UNK]' sep_token: typing.Optional[str] = '[SEP]' x_sep_token: typing.Optional[str] = '[X_SEP]' pad_token: typing.Optional[str] = '[PAD]' mask_token: typing.Optional[str] = '[MASK]' tokenize_chinese_chars: typing.Optional[bool] = True strip_accents: typing.Optional[bool] = None clean_up_tokenization_spaces: bool = True **kwargs )

参数

  • vocab_file (str) — 包含词汇表的文件。
  • do_lower_case (bool, optional, defaults to True) — 是否在分词时将输入转换为小写。
  • do_basic_tokenize (bool, optional, defaults to True) — 是否在 WordPiece 之前进行基本分词。
  • never_split (Iterable, optional) — 在分词过程中永远不会被分割的词元集合。仅在 `do_basic_tokenize=True` 时生效。
  • unk_token (str, optional, defaults to "[UNK]") — 未知词元。不在词汇表中的词元无法转换为 ID,将被设置为此词元。
  • sep_token (str, optional, defaults to "[SEP]") — 分隔符词元,用于从多个序列构建一个序列,例如用于序列分类的两个序列,或用于问答的文本和问题。它也用作使用特殊词元构建的序列的最后一个词元。
  • x_sep_token (str, optional, defaults to "[X_SEP]") — 特殊的第二个分隔符词元,可由 ProphetNetForConditionalGeneration 生成。它用于在摘要任务中分隔项目符号式的句子,例如
  • pad_token (str, optional, defaults to "[PAD]") — 用于填充的词元,例如在批处理不同长度的序列时使用。
  • mask_token (str, optional, defaults to "[MASK]") — 用于掩码值的词元。这是在使用掩码语言建模训练此模型时使用的词元。这是模型将尝试预测的词元。
  • tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。

    对于日语,此选项可能应被禁用(请参阅此问题)。

  • strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项,则将由 `lowercase` 的值确定(与原始 BERT 一样)。
  • clean_up_tokenization_spaces (bool, optional, defaults to True) — 是否在解码后清理空格,清理包括移除可能的多余空格等伪影。

构建一个 ProphetNetTokenizer。基于 WordPiece。

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

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) List[int]

参数

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

返回

List[int]

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

通过连接和添加特殊标记,从一个序列或一对序列构建用于序列分类任务的模型输入。BERT 序列的格式如下:

  • 单个序列:[CLS] X [SEP]
  • 序列对:[CLS] A [SEP] B [SEP]

convert_tokens_to_string

< >

( tokens: str )

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

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: typing.Optional[bool] = False ) List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。
  • token_ids_1 (List[int], optional) — 可选的第二个 ID 列表,用于序列对。
  • already_has_special_tokens (bool, optional, defaults to False) — 词元列表是否已经为模型格式化了特殊词元。

返回

List[int]

一个范围为 [0, 1] 的整数列表:1 表示特殊标记,0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。

ProphetNet 特定输出

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None logits_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失。
  • logits (torch.FloatTensor of shape (batch_size, decoder_sequence_length, config.vocab_size)) — 主流语言建模头的预测分数(SoftMax 前每个词汇词元的分数)。
  • logits_ngram (torch.FloatTensor of shape (batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 预测流语言建模头的预测分数(SoftMax 前每个词汇词元的分数)。
  • past_key_values (list[torch.FloatTensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 `config.n_layers` 的 `torch.FloatTensor` 列表,每个张量的形状为 `(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)`。

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

  • decoder_hidden_states (tuple[torch.FloatTensor], optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — `torch.FloatTensor` 的元组(如果模型有嵌入层,则一个用于嵌入层的输出,+ 每个层的输出一个),形状为 `(batch_size, sequence_length, hidden_size)`。

    解码器在每个层输出的隐藏状态以及初始嵌入输出。

  • decoder_ngram_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — `torch.FloatTensor` 的元组(一个用于嵌入层的输出 + 每个层的输出一个),形状为 `(batch_size, ngram * decoder_sequence_length, hidden_size)`。

    解码器预测流在每个层输出的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple[torch.FloatTensor], optional, returned when output_attentions=True is passed or when config.output_attentions=True) — `torch.FloatTensor` 的元组(每层一个),形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

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

  • decoder_ngram_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — `torch.FloatTensor` 的元组(每层一个),形状为 `(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)`。

    解码器预测流的注意力权重,经过注意力 softmax 后,用于在自注意力头中计算加权平均值。

  • cross_attentions (tuple[torch.FloatTensor], optional, returned when output_attentions=True is passed or when config.output_attentions=True) — `torch.FloatTensor` 的元组(每层一个),形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

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

  • encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, encoder_sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。
  • encoder_hidden_states (tuple[torch.FloatTensor], optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — `torch.FloatTensor` 的元组(如果模型有嵌入层,则一个用于嵌入层的输出,+ 每个层的输出一个),形状为 `(batch_size, sequence_length, hidden_size)`。

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

  • encoder_attentions (tuple[torch.FloatTensor], optional, returned when output_attentions=True is passed or when config.output_attentions=True) — `torch.FloatTensor` 的元组(每层一个),形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

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

序列到序列语言模型输出的基类。

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput

< >

( last_hidden_state: FloatTensor last_hidden_state_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None decoder_ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

  • last_hidden_state (torch.FloatTensor of shape (batch_size, decoder_sequence_length, hidden_size)) — 模型解码器最后一层输出的主流隐藏状态序列。

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

  • last_hidden_state_ngram (torch.FloatTensor of shape (batch_size,ngram * decoder_sequence_length, config.vocab_size), optional) — 模型解码器最后一层输出的预测流隐藏状态序列。
  • past_key_values (list[torch.FloatTensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 `config.n_layers` 的 `torch.FloatTensor` 列表,每个张量的形状为 `(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)`。

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

  • decoder_hidden_states (tuple[torch.FloatTensor], optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — `torch.FloatTensor` 的元组(如果模型有嵌入层,则一个用于嵌入层的输出,+ 每个层的输出一个),形状为 `(batch_size, sequence_length, hidden_size)`。

    解码器在每个层输出的隐藏状态以及初始嵌入输出。

  • decoder_ngram_hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出,另一个用于每层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

    解码器预测流在每层输出处的隐藏状态,以及初始的嵌入输出。

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

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

  • decoder_ngram_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

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

  • encoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, encoder_sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。
  • encoder_hidden_states (tuple[torch.FloatTensor], 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个用于嵌入层的输出,+ 每层一个输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

模型编码器输出的基类,也包含:可加速顺序解码的预计算隐藏状态。

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput

< >

( last_hidden_state: FloatTensor last_hidden_state_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states_ngram: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

  • last_hidden_state (torch.FloatTensor, 形状为 (batch_size, decoder_sequence_length, hidden_size)) — 模型解码器最后一层输出的主流隐藏状态序列。

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

  • last_hidden_state_ngram (torch.FloatTensor, 形状为 (batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 模型解码器最后一层输出的预测流隐藏状态序列。
  • past_key_values (list[torch.FloatTensor], 可选, 当传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

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

    模型在每层输出处的隐藏状态,以及可选的初始嵌入输出。

  • hidden_states_ngram (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出,另一个用于每层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

    解码器预测流在每层输出处的隐藏状态,以及初始的嵌入输出。

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

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

  • ngram_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

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

模型输出的基类,也可能包含过去的键/值(以加速顺序解码)。

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None logits_ngram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None hidden_states_ngram: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None ngram_attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供了 labels 时返回) — 语言建模损失。
  • logits (torch.FloatTensor, 形状为 (batch_size, decoder_sequence_length, config.vocab_size)) — 主流语言建模头的预测分数(在 SoftMax 之前每个词汇表标记的分数)。
  • logits_ngram (torch.FloatTensor, 形状为 (batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 预测流语言建模头的预测分数(在 SoftMax 之前每个词汇表标记的分数)。
  • past_key_values (list[torch.FloatTensor], 可选, 当传递 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

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

    模型在每层输出处的隐藏状态,以及可选的初始嵌入输出。

  • hidden_states_ngram (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入层的输出,另一个用于每层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

    解码器预测流在每层输出处的隐藏状态,以及初始的嵌入输出。

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

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

  • ngram_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

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

模型输出的基类,也可能包含过去的键/值(以加速顺序解码)。

ProphetNetModel

class transformers.ProphetNetModel

< >

( config: ProphetNetConfig )

参数

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

基础的 ProphetNet 模型,输出原始的隐藏状态,顶部没有任何特定的头。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( 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.BoolTensor] = 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[tuple] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = 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.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.Tensor, 形状为 (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?

    ProphetNet 使用 eos_token_id 作为生成 decoder_input_ids 的起始标记。如果使用 past_key_values,可以选择只输入最后的 decoder_input_ids(参见 past_key_values)。

  • decoder_attention_mask (torch.BoolTensor, 形状为 (batch_size, target_sequence_length), 可选) — 默认行为:生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。
  • head_mask (torch.Tensor, 形状为 (num_heads,)(num_layers, num_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, 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 的元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values,将返回旧版缓存格式。

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

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

    如果 decoder_input_idsdecoder_inputs_embeds 都未设置,则 decoder_inputs_embedsinputs_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.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutputtuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置(ProphetNetConfig)和输入决定的各种元素。

  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, decoder_sequence_length, hidden_size)) — 模型解码器最后一层输出的主流(main stream)隐藏状态序列。

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

  • last_hidden_state_ngram (torch.FloatTensor,形状为 (batch_size,ngram * decoder_sequence_length, config.vocab_size), 可选) — 模型解码器最后一层输出的预测流(predict stream)隐藏状态序列。

  • past_key_values (list[torch.FloatTensor], 可选,当传入 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

  • decoder_hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_ngram_hidden_states (tuple(torch.FloatTensor), 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

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

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

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

  • decoder_ngram_attentions (tuple(torch.FloatTensor), 可选,当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均。

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

  • encoder_hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

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

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

ProphetNetModel 的 forward 方法重写了 __call__ 特殊方法。

虽然前向传播的逻辑需要在这个函数中定义,但之后应该调用 `Module` 实例而不是这个函数,因为前者会处理前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, ProphetNetModel

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetModel.from_pretrained("microsoft/prophetnet-large-uncased")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)

>>> last_hidden_states = outputs.last_hidden_state  # main stream hidden states
>>> last_hidden_states_ngram = outputs.last_hidden_state_ngram  # predict hidden states

ProphetNetEncoder

class transformers.ProphetNetEncoder

< >

( config: ProphetNetConfig word_embeddings: Embedding = None )

参数

  • config (ProphetNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • word_embeddings (torch.nn.Embeddings,形状为 (config.vocab_size, config.hidden_size), 可选) — 词嵌入参数。这可用于使用预定义的词嵌入初始化 ProphetNetEncoder,而不是随机初始化的词嵌入。

ProphetNetModel 的独立编码器部分。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.BaseModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下,填充(Padding)将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是 input ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

  • head_mask (torch.Tensor,形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值选自 [0, 1]

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,你可以不传递 input_ids,而是直接传递一个嵌入表示。这在你想要对如何将 input_ids 索引转换为相关向量进行更多控制时很有用,而不是使用模型的内部嵌入查找矩阵。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的 `attentions`。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的 `hidden_states`。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 对象,而不是一个普通的元组。

返回

transformers.modeling_outputs.BaseModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置(ProphetNetConfig)和输入决定的各种元素。

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

  • hidden_states (tuple(torch.FloatTensor), 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

ProphetNetEncoder 的 forward 方法重写了 __call__ 特殊方法。

虽然前向传播的逻辑需要在这个函数中定义,但之后应该调用 `Module` 实例而不是这个函数,因为前者会处理前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, ProphetNetEncoder
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetEncoder.from_pretrained("patrickvonplaten/prophetnet-large-uncased-standalone")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ProphetNetDecoder

class transformers.ProphetNetDecoder

< >

( config: ProphetNetConfig word_embeddings: typing.Optional[torch.nn.modules.sparse.Embedding] = None )

参数

  • config (ProphetNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • word_embeddings (torch.nn.Embeddings,形状为 (config.vocab_size, config.hidden_size), 可选) — 词嵌入参数。这可用于使用预定义的词嵌入初始化 ProphetNetEncoder,而不是随机初始化的词嵌入。

ProphetNetModel 的独立解码器部分。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None 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.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下,填充(Padding)将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是 input ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值选自 [0, 1]

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

  • encoder_hidden_states (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器,则在交叉注意力中使用。
  • encoder_attention_mask (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 用于避免对编码器输入的填充词元索引执行注意力的掩码。如果模型被配置为解码器,则此掩码用于交叉注意力。掩码值选自 [0, 1]

    • 1 表示词元未被掩码
    • 0 表示词元被掩码
  • head_mask (torch.Tensor,形状为 (num_heads,)(num_layers, num_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.Tensor]], 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包括模型在解码的先前阶段返回的 `past_key_values`,当 `use_cache=True` 或 `config.use_cache=True` 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组,其中每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 `past_key_values`,将返回旧版缓存格式。

    如果使用 `past_key_values`,用户可以选择只输入最后一个 `input_ids`(那些没有为其提供过去键值状态的 `input_ids`),形状为 `(batch_size, 1)`,而不是所有形状为 `(batch_size, sequence_length)` 的 `input_ids`。

  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地,你可以不传递 input_ids,而是直接传递一个嵌入表示。这在你想要对如何将 input_ids 索引转换为相关向量进行更多控制时很有用,而不是使用模型的内部嵌入查找矩阵。
  • 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.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutputtuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置(ProphetNetConfig)和输入决定的各种元素。

  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, decoder_sequence_length, hidden_size)) — 模型解码器最后一层输出的主流(main stream)隐藏状态序列。

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

  • last_hidden_state_ngram (torch.FloatTensor,形状为 (batch_size, ngram * decoder_sequence_length, config.vocab_size)) — 模型解码器最后一层输出的预测流(predict stream)隐藏状态序列。

  • past_key_values (list[torch.FloatTensor], 可选,当传入 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

  • hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • hidden_states_ngram (tuple(torch.FloatTensor), 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

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

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

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

  • ngram_attentions (tuple(torch.FloatTensor), 可选,当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均。

ProphetNetDecoder 的 forward 方法重写了 __call__ 特殊方法。

虽然前向传播的逻辑需要在这个函数中定义,但之后应该调用 `Module` 实例而不是这个函数,因为前者会处理前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, ProphetNetDecoder
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetDecoder.from_pretrained("microsoft/prophetnet-large-uncased", add_cross_attention=False)
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ProphetNetForConditionalGeneration

class transformers.ProphetNetForConditionalGeneration

< >

( config: ProphetNetConfig )

参数

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

带有语言建模头的 ProphetNet 模型。可用于序列生成任务。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( 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.BoolTensor] = 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[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = 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.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.Tensor,形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下,填充(Padding)将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是 input 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()

    什么是解码器 input ID?

    ProphetNet 使用 `eos_token_id` 作为 `decoder_input_ids` 生成的起始词元。如果使用 `past_key_values`,可以选择只输入最后一个 `decoder_input_ids`(参见 `past_key_values`)。

  • decoder_attention_mask (torch.BoolTensor,形状为 (batch_size, target_sequence_length), 可选) — 默认行为:生成一个忽略 `decoder_input_ids` 中填充词元的张量。默认情况下也会使用因果掩码。
  • head_mask (torch.Tensor,形状为 (num_heads,)(num_layers, num_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 (torch.Tensor, 可选) — 元组包含(`last_hidden_state`, 可选: `hidden_states`, 可选: `attentions`)`last_hidden_state` 形状为 `(batch_size, sequence_length, hidden_size)`,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包含在解码的前一个阶段,当 `use_cache=True` 或 `config.use_cache=True` 时,模型返回的 `past_key_values`。

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组,每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量)。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 `past_key_values`,将返回旧版缓存格式。

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

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

    如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 都未设置,则 `decoder_inputs_embeds` 将取 `inputs_embeds` 的值。

  • labels (形状为 `(batch_size,)` 的 `torch.LongTensor`,可选) — 用于计算序列分类/回归损失的标签。索引应在 `[-100, 0, ..., config.vocab_size - 1]` 范围内。所有设置为 `-100` 的标签都将被忽略(屏蔽),损失仅对 `[0, ..., config.vocab_size]` 范围内的标签进行计算。
  • 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.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutputtuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或一个 `torch.FloatTensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),根据配置 (ProphetNetConfig) 和输入,包含各种元素。

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

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

  • logits_ngram (形状为 `(batch_size, ngram * decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 预测流语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (list[torch.FloatTensor], 可选,当传入 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

  • decoder_hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_ngram_hidden_states (tuple(torch.FloatTensor), 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

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

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

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

  • decoder_ngram_attentions (tuple(torch.FloatTensor), 可选,当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

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

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

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均。

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

  • encoder_hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

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

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

ProphetNetForConditionalGeneration 的 forward 方法,覆盖了 `__call__` 特殊方法。

虽然前向传播的逻辑需要在这个函数中定义,但之后应该调用 `Module` 实例而不是这个函数,因为前者会处理前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, ProphetNetForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetForConditionalGeneration.from_pretrained("microsoft/prophetnet-large-uncased")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)

>>> logits_next_token = outputs.logits  # logits to predict next token as usual
>>> logits_ngram_next_tokens = outputs.logits_ngram  # logits to predict 2nd, 3rd, ... next tokens

ProphetNetForCausalLM

class transformers.ProphetNetForCausalLM

< >

( config: ProphetNetConfig )

参数

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

ProphetNetModel 的独立解码器部分,顶部带有一个 lm 头。该模型可用于因果

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None 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.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

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

    • 1 表示标记未被屏蔽
    • 0 表示标记被屏蔽

    什么是注意力掩码?

  • encoder_hidden_states (形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`,可选) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器,则在交叉注意力中使用。
  • encoder_attention_mask (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 用于避免对编码器输入的填充标记索引执行注意力的掩码。如果模型被配置为解码器,则在交叉注意力中使用此掩码。掩码值在 `[0, 1]` 中选择:

    • 1 表示标记未被屏蔽
    • 0 表示标记被屏蔽
  • head_mask (形状为 `(num_heads,)` 或 `(num_layers, num_heads)` 的 `torch.Tensor`,可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 `[0, 1]` 中选择:

    • 1 表示头未被屏蔽
    • 0 表示头被屏蔽
  • cross_attn_head_mask (形状为 `(decoder_layers, decoder_attention_heads)` 的 `torch.Tensor`,可选) — 用于置零交叉注意力模块中选定头的掩码。掩码值在 `[0, 1]` 中选择:

    • 1 表示头未被屏蔽
    • 0 表示头被屏蔽
  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包含在解码的前一个阶段,当 `use_cache=True` 或 `config.use_cache=True` 时,模型返回的 `past_key_values`。

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组,每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量)。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 `past_key_values`,将返回旧版缓存格式。

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

  • inputs_embeds (形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`,可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 `input_ids`。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 `input_ids` 索引转换为关联向量,这会很有用。
  • labels (形状为 `(batch_size, sequence_length)` 的 `torch.LongTensor`,可选) — 用于计算从左到右语言建模损失(下一个词预测)的标签。索引应在 `[-100, 0, ..., config.vocab_size]` 范围内(参见 `input_ids` 文档字符串)。索引设置为 `-100` 的标记将被忽略(屏蔽),损失仅对标签在 `[0, ..., config.vocab_size]` 范围内的标记进行计算。
  • 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.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutputtuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput 或一个 `torch.FloatTensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),根据配置 (ProphetNetConfig) 和输入,包含各种元素。

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

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

  • logits_ngram (形状为 `(batch_size, ngram * decoder_sequence_length, config.vocab_size)` 的 `torch.FloatTensor`) — 预测流语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (list[torch.FloatTensor], 可选,当传入 use_cache=Trueconfig.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 列表,其中每个张量的形状为 (2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)

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

  • hidden_states (tuple[torch.FloatTensor], 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • hidden_states_ngram (tuple(torch.FloatTensor), 可选,当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(第一个是嵌入层的输出,之后是每一层的输出),形状为 (batch_size, ngram * decoder_sequence_length, hidden_size)

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

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

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

  • ngram_attentions (tuple(torch.FloatTensor), 可选,当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)

    解码器预测流的注意力权重,经过注意力 softmax 之后,用于计算加权平均值。

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

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均。

ProphetNetForCausalLM 的 forward 方法,覆盖了 `__call__` 特殊方法。

虽然前向传播的逻辑需要在这个函数中定义,但之后应该调用 `Module` 实例而不是这个函数,因为前者会处理前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, ProphetNetForCausalLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = ProphetNetForCausalLM.from_pretrained("microsoft/prophetnet-large-uncased")
>>> 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

>>> # Model can also be used with EncoderDecoder framework
>>> from transformers import BertTokenizer, EncoderDecoderModel, AutoTokenizer
>>> import torch

>>> tokenizer_enc = BertTokenizer.from_pretrained("google-bert/bert-large-uncased")
>>> tokenizer_dec = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google-bert/bert-large-uncased", "microsoft/prophetnet-large-uncased"
... )

>>> ARTICLE = (
...     "the us state department said wednesday it had received no "
...     "formal word from bolivia that it was expelling the us ambassador there "
...     "but said the charges made against him are `` baseless ."
... )
>>> input_ids = tokenizer_enc(ARTICLE, return_tensors="pt").input_ids
>>> labels = tokenizer_dec(
...     "us rejects charges against its ambassador in bolivia", return_tensors="pt"
... ).input_ids
>>> outputs = model(input_ids=input_ids, decoder_input_ids=labels[:, :-1], labels=labels[:, 1:])

>>> loss = outputs.loss
< > 在 GitHub 上更新