AI 助理
备案控制台
开发者社区 人工智能 文章 正文

Transformers 4.37 中文文档（五十二）（2）

2024-07-11 22
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Transformers 4.37 中文文档（五十二）

Transformers 4.37 中文文档（五十二）（1）https://developer.aliyun.com/article/1565278


ProphetNetModel

class transformers.ProphetNetModel

<来源>

( config: ProphetNetConfig )

参数

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

裸 ProphetNet 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

原始 ProphetNet 代码可以在这里找到。检查点是从原始 Fairseq 检查点转换而来的。有关检查点转换的更多信息，请查看文件convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py。

这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为(batch_size, sequence_length)） — 词汇表中输入序列标记的索引。默认情况下会忽略填充。
    索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
    什么是输入 ID？
  • attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被掩盖的标记，为 1，
  • 对于被遮蔽的标记为 0。
  • 什么是注意力蒙版？
  • decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。
    可以使用 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（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果蒙版也将默认使用。
  • head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块中选择的头部失效的蒙版。蒙版值选择在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中注意力模块中选择的头部失效的蒙版。蒙版值选择在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块中选择的头部失效的蒙版。蒙版值选择在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
    如果使用了past_key_values，用户可以选择只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_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.ProphetNetSeq2SeqModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包括根据配置（ProphenetConfig）和输入而异的各种元素。

  • 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)。
    包含解码器的预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  • 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, decoder_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_attn_heads, decoder_sequence_length, decoder_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 之后，用于计算last_hidden_state中的加权平均值。
  • cross_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, encoder_sequence_length, decoder_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)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, encoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
    每个层的编码器的隐藏状态加上初始嵌入输出。
  • encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_attn_heads, encoder_sequence_length, encoder_sequence_length)的torch.FloatTensor元组（每个层一个）。
    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

ProphetNetModel 的前向方法，覆盖了__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

ProphetNet 编码器

class transformers.ProphetNetEncoder

<来源>

( config: ProphetNetConfig word_embeddings: Embedding = None )

参数

  • config（ProphetNetConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ProphetNetModel 的独立编码器部分。此模型继承自 PreTrainedModel。检查库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）的超类文档。

原始 ProphetNet 代码可以在这里找到。检查点是从原始 Fairseq 检查点转换而来的。有关检查点转换的更多信息，请查看文件convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

word_embeddings（形状为(config.vocab_size, config.hidden_size)的torch.nn.Embeddings，可选）：词嵌入参数。这可以用于使用预定义的词嵌入而不是随机初始化的词嵌入初始化 ProphetNetEncoder。

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。
    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
    什么是输入 ID？
  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：
  • 1 表示被 未掩码 的标记，
  • 0 表示被 掩码 的标记。
  • 注意力掩码是什么？
  • head_mask (torch.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选在 [0, 1]：
  • 1 表示头部是 未掩码，
  • 0 表示头部是 掩码。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，取决于配置 (ProphenetConfig) 和输入。

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。
    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。
    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

ProphetNetEncoder 的前向方法，覆盖了 __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

< source >

( config: ProphetNetConfig word_embeddings: Optional = None )

参数

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

ProphetNetModel 的独立解码器部分。此模型继承自 PreTrainedModel。检查库实现的所有模型的通用方法的超类文档（例如下载或保存，调整输入嵌入，修剪头等）。

原始 ProphetNet 代码可以在这里找到。检查点是从原始 Fairseq 检查点转换而来的。有关检查点转换的更多信息，请查看文件convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有事项。

word_embeddings (torch.nn.Embeddings of shape (config.vocab_size, config.hidden_size), 可选): 词嵌入参数。这可以用于使用预定义的词嵌入初始化 ProphetNetEncoder，而不是随机初始化的词嵌入。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。
    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
    什么是输入 ID？
  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 1 表示标记是not masked，
  • 0 表示标记是masked。
  • 什么是注意力掩码？
  • head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), 可选) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部是not masked，
  • 0 表示头部是masked。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
  • encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值选择在[0, 1]中：
  • cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部是not masked，
  • 0 表示头部是masked。
  • past_key_values (长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`的 4 个张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
    如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（即没有将过去的键值状态提供给该模型的那些）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  • use_cache (bool, 可选) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。

返回值

transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或者tuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput 或者一个torch.FloatTensor元组（如果传入return_dict=False或者config.return_dict=False）包含根据配置(ProphenetConfig)和输入不同的元素。

  • last_hidden_state (形状为(batch_size, decoder_sequence_length, hidden_size)的torch.FloatTensor`) — 模型解码器最后一层输出的主流隐藏状态序列。
    如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
  • last_hidden_state_ngram (形状为(batch_size, ngram * decoder_sequence_length, config.vocab_size)的torch.FloatTensor`) — 模型解码器最后一层输出的预测流隐藏状态序列。
  • past_key_values (List[torch.FloatTensor], 可选, 当传入use_cache=True或者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输入）。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, decoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每层输出）。
    解码器主流每层的隐藏状态加上初始嵌入输出。
  • ngram_hidden_states (tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, ngram * decoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每层输出）。
    解码器每层预测流的隐藏状态加上初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或者config.output_attentions=True时返回) — 形状为(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)的torch.FloatTensor元组（每层一个）。
    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • ngram_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length) 的 torch.FloatTensor 元组（每层一个）。
    解码器的预测流的注意力权重，在注意力 softmax 之后，用于计算加权平均值
  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_attn_heads, encoder_sequence_length, decoder_sequence_length) 的 torch.FloatTensor 元组（每层一个）。
    解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算加权平均值

ProphetNetDecoder 的前向方法，覆盖了 __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。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

原始的 ProphetNet 代码可以在这里找到。检查点是从原始的 Fairseq 检查点转换而来的。有关检查点转换的更多信息，请查看文件 convert_prophetnet_original_pytorch_checkpoint_to_pytorch.py。

此模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。
    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
    什么是输入 ID？
  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：
  • 对于被 masked 的标记为 1，
  • 对于被 masked 的标记为 0。
  • 什么是注意力掩码？
  • decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列标记在词汇表中的索引。
    可以使用 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（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。
  • head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于将解码器中注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于将交叉注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
  • encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
    如果使用了past_key_values，用户可以选择性地只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给该模型的）而不是形状为(batch_size, sequence_length)的所有decoder_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 而不是普通元组。
  • labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]范围内。所有设置为-100的标签将被忽略（遮蔽），损失仅计算在[0, ..., config.vocab_size]范围内的标签。

返回

transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput 或一个torch.FloatTensor的元组（如果传递了return_dict=False或config.return_dict=False），包括根据配置（ProphenetConfig）和输入而变化的各种元素。

  • 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, decoder_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_attn_heads, decoder_sequence_length, decoder_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_attn_heads, encoder_sequence_length, decoder_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=True或config.output_hidden_states=True时返回） — 形状为(batch_size, encoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。
    编码器在每一层的隐藏状态以及初始嵌入输出。
  • encoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_attn_heads, encoder_sequence_length, encoder_sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

ProphetNetForConditionalGeneration 的前向方法，覆盖了__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


Transformers 4.37 中文文档（五十二）（3）https://developer.aliyun.com/article/1565282

文章标签：
索引
算法框架/工具
PyTorch
布客飞龙
目录
相关文章
布客飞龙
|
2月前
|
存储 自然语言处理 测试技术
Transformers 4.37 中文文档（四十五）（4）
Transformers 4.37 中文文档（四十五）
布客飞龙
32 1
布客飞龙
|
2月前
|
机器学习/深度学习 存储 PyTorch
Transformers 4.37 中文文档（五十二）（3）
Transformers 4.37 中文文档（五十二）
布客飞龙
28 0
布客飞龙
|
2月前
|
PyTorch TensorFlow 算法框架/工具
Transformers 4.37 中文文档（四十五）（8）
Transformers 4.37 中文文档（四十五）
布客飞龙
25 2
布客飞龙
|
2月前
|
缓存 PyTorch 算法框架/工具
Transformers 4.37 中文文档（四十五）（2）
Transformers 4.37 中文文档（四十五）
布客飞龙
56 3
布客飞龙
|
2月前
|
自然语言处理 PyTorch 算法框架/工具
Transformers 4.37 中文文档（四十八）（2）
Transformers 4.37 中文文档（四十八）
布客飞龙
34 2
布客飞龙
|
2月前
|
存储 自然语言处理
Transformers 4.37 中文文档（四十八）（1）
Transformers 4.37 中文文档（四十八）
布客飞龙
35 2
布客飞龙
|
2月前
|
PyTorch TensorFlow 算法框架/工具
Transformers 4.37 中文文档（四十五）（9）
Transformers 4.37 中文文档（四十五）
布客飞龙
27 2
布客飞龙
|
2月前
|
PyTorch TensorFlow 算法框架/工具
Transformers 4.37 中文文档（五十三）（4）
Transformers 4.37 中文文档（五十三）
布客飞龙
16 1
布客飞龙
|
2月前
|
TensorFlow 算法框架/工具 索引
Transformers 4.37 中文文档（五十三）（5）
Transformers 4.37 中文文档（五十三）
布客飞龙
20 1
布客飞龙
|
2月前
|
PyTorch 算法框架/工具 索引
Transformers 4.37 中文文档（五十三）（3）
Transformers 4.37 中文文档（五十三）
布客飞龙
22 1