Transformers--4-37-中文文档-二十六-

Transformers 4.37 中文文档（二十六）

原文：huggingface.co/docs/transformers

PEGASUS-X

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/pegasus_x

概述

PEGASUS-X 模型由 Jason Phang、Yao Zhao 和 Peter J. Liu 在 Investigating Efficiently Extending Transformers for Long Input Summarization 中提出。

PEGASUS-X（PEGASUS eXtended）通过额外的长输入预训练和在编码器中使用交错的块局部注意力与全局标记，扩展了 PEGASUS 模型，用于长输入摘要。

该论文的摘要如下：

尽管大型预训练 Transformer 模型已被证明在处理自然语言任务方面非常有能力，但处理长序列输入仍然是一个重大挑战。其中一个任务是长输入摘要，其中输入长于大多数预训练模型的最大输入上下文。通过一系列广泛的实验，我们研究了哪些模型架构变化和预训练范式可以最有效地使预训练的 Transformer 适应长输入摘要。我们发现，具有全局编码器标记的交错块局部 Transformer 取得了性能和效率的良好平衡，并且在长序列上进行额外的预训练阶段可以有意义地提高下游摘要性能。基于我们的发现，我们介绍了 PEGASUS-X，这是 PEGASUS 模型的扩展，具有额外的长输入预训练，以处理长达 16K 个标记的输入。PEGASUS-X 在长输入摘要任务上取得了强大的性能，与更大的模型相当，同时增加了少量额外参数，并且不需要模型并行训练。

该模型由 zphang) 贡献。原始代码可在 此处 找到。

文档资源

• 翻译任务指南

• 摘要任务指南

PEGASUS-X 使用与 PEGASUS 相同的分词器。

PegasusXConfig

class transformers.PegasusXConfig

< source >

( vocab_size = 96103 max_position_embeddings = 16384 encoder_layers = 16 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 16 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 = True pad_token_id = 0 eos_token_id = 1 forced_eos_token_id = 1 num_global_tokens = 32 block_size = 512 stagger_local_blocks = True **kwargs )

参数

• vocab_size (int, optional, defaults to 96103) — PEGASUS-X 模型的词汇大小。定义了在调用 PegasusXModel 时可以表示的不同标记数量。

• d_model (int, optional, defaults to 1024) — 层和池化器层的维度。

• encoder_layers (int, optional, defaults to 16) — 编码器层数。

• decoder_layers (int, optional, defaults to 16) — 解码器层数。

• encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。

• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。

• activation_dropout（float，可选，默认为 0.0）— 全连接层内激活的丢弃比率。

• max_position_embeddings（int，可选，默认为 16384）— 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

• init_std（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop（float，可选，默认为 0.0）— 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• decoder_layerdrop（float，可选，默认为 0.0）— 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• use_cache（bool，可选，默认为True）— 模型是否应返回最后的键/值注意力（并非所有模型都使用）

• forced_eos_token_id（int，可选，默认为 1）— 当达到max_length时，强制作为最后生成的标记的标记 id。通常设置为eos_token_id。

• num_global_tokens（int，可选，默认为 128）— 用于编码器的全局标记数

• block_size（int，可选，默认为 512）— 编码器局部注意力的块大小。序列长度应该是块大小的精确倍数。如果stagger_local_block为 True，则block_size必须是 2 的倍数。

• stagger_local_block（bool，可选，默认为True）— 是否将每个其他局部注意力错开半个块

这是用于存储 PegasusXModel 配置的配置类。它用于根据指定的参数实例化一个 PEGASUS-X 模型，定义模型架构。使用默认值实例化配置将产生类似于 PEGASUS-X google/pegasus-x-large架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import PegasusXConfig, PegasusXModel

>>> # Initializing a PEGASUS google/pegasus-x-large style configuration
>>> configuration = PegasusXConfig()

>>> # Initializing a model (with random weights) from the google/pegasus-x-large style configuration
>>> model = PegasusXModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

PegasusXModel

class transformers.PegasusXModel

<来源>

( config: PegasusXConfig )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None 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.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

  Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.

  What are input IDs?

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation.

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

  • 1 for tokens that are not masked,

  • 0 for tokens that are masked.

  What are attention masks?

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — Indices of decoder input sequence tokens in the vocabulary.

  Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.

  What are decoder input IDs?

  PEGASUS-X uses the pad_token_id as the starting token for decoder_input_ids generation. If past_key_values is used, optionally only the last decoder_input_ids have to be input (see past_key_values).

• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — Default behavior: generate a tensor that ignores pad tokens in decoder_input_ids. Causal mask will also be used by default.

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — Tuple consists of (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state of shape (batch_size, sequence_length, hidden_size), optional) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — Tuple of tuple(torch.FloatTensor) of length config.n_layers, with each tuple having 2 tensors of shape (batch_size, num_heads, sequence_length, embed_size_per_head)) and 2 additional tensors of shape (batch_size, num_heads, encoder_sequence_length, embed_size_per_head).

  Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.

  If past_key_values are used, the user can optionally input only the last decoder_input_ids (those that don’t have their past key value states given to this model) of shape (batch_size, 1) instead of all decoder_input_ids of shape (batch_size, sequence_length).

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.

• 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, 可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（PegasusXConfig）和输入的不同元素。

• 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)的张量。

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

• decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每一层的输出）。

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

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

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

• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层的输出一个）。

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

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

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

PegasusXModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, PegasusModel

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

PegasusXForConditionalGeneration

class transformers.PegasusXForConditionalGeneration

<来源>

( config: PegasusXConfig )

参数

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

PEGASUS-X 用于条件生成（例如总结）。该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None 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.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选择直接传递嵌入表示，而不是传递input_ids。

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

  • 对于“未被掩码”的标记为 1，

  • 对于被“掩码”的标记为 0。

  什么是注意力掩码？

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

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

  什么是解码器输入 ID？

  PEGASUS-X 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，可以选择仅输入最后一个decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 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，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将其过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选择直接传递嵌入表示，而不是传递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 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（PegasusXConfig）和输入的各种元素。

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

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

• past_key_values (tuple(tuple(torch.FloatTensor))，optional，当传递 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)，optional，当 output_hidden_states=True 被传递或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的一个 + 每一层的输出的一个），形状为 (batch_size, 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 之后，用于计算自注意力头中的加权平均值。

• 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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 模型编码器最后一层的隐藏状态序列。

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

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

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

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

PegasusXForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

摘要示例：

>>> from transformers import AutoTokenizer, PegasusXForConditionalGeneration

>>> model = PegasusXForConditionalGeneration.from_pretrained("google/pegasus-x-base")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-x-large")

>>> 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."

Persimmon

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/persimmon

概述

Persimmon 模型是由ADEPT创建的，作者是 Erich Elsen，Augustus Odena，Maxwell Nye，Sağnak Taşırlar，Tri Dao，Curtis Hawthorne，Deepak Moparthi，Arushi Somani。

作者介绍了 Persimmon-8B，这是一个基于经典 transformers 架构的解码器模型，具有查询和键规范化。Persimmon-8B 是一个完全允许许可的模型，拥有约 80 亿个参数，发布在 Apache 许可下。Persimmon-8B 的一些关键属性是长上下文大小（16K）、性能和多模态扩展的能力。

作者展示了他们对模型评估的方法，重点放在实际文本生成上，反映了用户与语言模型的交互方式。该工作还包括了一项比较分析，将 Persimmon-8B 与其他知名模型（MPT 7B Instruct 和 Llama 2 Base 7B 1-Shot）在各种评估任务中进行对比。结果表明，即使训练数据有限，Persimmon-8B 的性能也很有竞争力。

在模型细节方面，该工作概述了 Persimmon-8B 的架构和训练方法，提供了关于其设计选择、序列长度和数据集组成的见解。作者提供了一个快速推理代码，通过操作融合和 CUDA 图利用来优于传统实现，同时保持代码的一致性。他们表达了他们对社区如何利用这一贡献推动创新的期待，并暗示将作为一系列持续发展的一部分发布更多即将推出的版本。

这个模型是由ArthurZ贡献的。原始代码可以在这里找到。

使用提示

Persimmon模型使用bfloat16进行训练，但原始推理使用float16。上传到 hub 的检查点使用torch_dtype = 'float16'，AutoModel API 将使用它将检查点从torch.float32转换为torch.float16。

在线权重的dtype大多数情况下并不重要，除非您在使用torch_dtype="auto"初始化模型时使用model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")。原因是模型将首先被下载（使用在线检查点的dtype），然后将被转换为torch的默认dtype（变为torch.float32）。用户应该指定他们想要的torch_dtype，如果他们不这样做，它将是torch.float32。

不建议在float16中微调模型，已知会产生nan，因此模型应该在bfloat16中进行微调。

提示：

• 要转换模型，您需要克隆原始存储库，使用git clone https://github.com/persimmon-ai-labs/adept-inference，然后获取检查点：

git clone https://github.com/persimmon-ai-labs/adept-inference
wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_base_model_release.tar
tar -xvf 8b_base_model_release.tar
python src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py  --input_dir /path/to/downloaded/persimmon/weights/ --output_dir /output/path \
    --pt_model_path /path/to/8b_chat_model_release/iter_0001251/mp_rank_00/model_optim_rng.pt
    --ada_lib_path /path/to/adept-inference

对于聊天模型：

wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
tar -xvf 8b_base_model_release.tar

之后，模型可以通过以下方式加载：

from transformers import PersimmonForCausalLM, PersimmonTokenizer

model = PersimmonForCausalLM.from_pretrained("/output/path")
tokenizer = PersimmonTokenizer.from_pretrained("/output/path")

• Perismmon 使用基于sentencepiece的分词器，具有一个Unigram模型。它支持 bytefallback，仅在快速分词器的tokenizers==0.14.0中可用。LlamaTokenizer被用作它是一个围绕 sentencepiece 的标准包装器。chat模板将在后续 PR 中使用模板函数进行更新！

• 作者建议为聊天模式使用以下提示格式：f"human: {prompt}\n\nadept:"

PersimmonConfig

class transformers.PersimmonConfig

<来源>

( vocab_size = 262144 hidden_size = 4096 intermediate_size = 16384 num_hidden_layers = 36 num_attention_heads = 64 hidden_act = 'relu2' max_position_embeddings = 16384 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 25000.0 rope_scaling = None qk_layernorm = True hidden_dropout = 0.0 attention_dropout = 0.0 partial_rotary_factor = 0.5 pad_token_id = None bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 262144）—Persimmon 模型的词汇量。定义了在调用 PersimmonModel 时可以表示的不同标记的数量。

• hidden_size (int, optional, defaults to 4096) — 隐藏表示的维度。

• intermediate_size (int, optional, defaults to 16384) — MLP 表示的维度。

• num_hidden_layers (int, optional, defaults to 36) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, optional, defaults to 64) — Transformer 编码器中每个注意力层的注意力头数。

• hidden_act (str or function, optional, defaults to "relu2") — 解码器中的非线性激活函数（函数或字符串）。

• max_position_embeddings (int, optional, defaults to 16384) — 该模型可能使用的最大序列长度。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-5) — rms 归一化层使用的 epsilon。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在config.is_decoder=True时相关。

• tie_word_embeddings(bool, optional, defaults to False) — 是否绑定权重嵌入

• rope_theta (float, optional, defaults to 25000.0) — RoPE 嵌入的基本周期。

• rope_scaling (Dict, optional) — 包含 RoPE 嵌入缩放配置的字典。当前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。期望的格式是{"type": 策略名称, "factor": 缩放因子}。使用此标志时，不要将max_position_embeddings更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参阅以下主题：www.reddit.com/r/LocalPersimmon/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。

• qk_layernorm (bool, optional, default to True) — 在投影隐藏状态后是否对查询和键进行归一化

• hidden_dropout (float, optional, default to 0.0) — 在将 MLP 应用于隐藏状态后的 dropout 比率。

• attention_dropout (float, optional, default to 0.0) — 计算注意力分数后的 dropout 比率。

• partial_rotary_factor (float, optional, default to 0.5) — 查询和键中将具有旋转嵌入的百分比。

  示例 —

这是用于存储 PersimmonModel 配置的配置类。根据指定的参数实例化 Persimmon 模型，定义模型架构。使用默认值实例化配置将产生类似于adept/persimmon-8b-base的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import PersimmonModel, PersimmonConfig

>>> # Initializing a Persimmon persimmon-7b style configuration
>>> configuration = PersimmonConfig()

PersimmonModel

class transformers.PersimmonModel

< source >

( config: PersimmonConfig )

参数

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

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

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个PersimmonDecoderLayer

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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 )

参数

• 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 表示未被“掩盖”的标记，

  • 0 表示被“掩盖”的标记。

  什么是注意力掩码？

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

  如果使用past_key_values，可选择仅输入最后的decoder_input_ids（参见past_key_values）。

  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

  • 1 表示头部未被“掩盖”。

  • 0 表示头部被“掩盖”。

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。

  什么是位置 ID？

• past_key_values (Cache 或 tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为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（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递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 而不是普通元组。

PersimmonModel 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

PersimmonForCausalLM

class transformers.PersimmonForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 对于“未掩码”的标记为 1，

  • 对于“掩码”的标记为 0。

  什么是注意力掩码？

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

  如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（参见past_key_values）。

  如果您想要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）— 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为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.FloatTensor，形状为(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 而不是普通元组。

  参数 — 标签（torch.LongTensor，形状为(batch_size, sequence_length)，可选）：用于计算掩盖语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（PersimmonConfig）和输入的各种元素。

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

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

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

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

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

PersimmonForCausalLM 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, PersimmonForCausalLM

>>> model = PersimmonForCausalLM.from_pretrained("adept/persimmon-8b-base")
>>> tokenizer = AutoTokenizer.from_pretrained("adept/persimmon-8b-base")

>>> prompt = "human: Hey, what should I eat for dinner?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'human: Hey, what should I eat for dinner?\n\ncat: 🐱\n\nhuman: 😐\n\n'

PersimmonForSequenceClassification

class transformers.PersimmonForSequenceClassification

< source >

( config )

参数

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

带有顶部序列分类头（线性层）的 Persimmon 变换器。

PersimmonForSequenceClassification 使用最后一个标记来进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则在每一行中找到不是填充标记的最后一个标记。如果未定义pad_token_id，则简单地取每一行批次中的最后一个值。由于在传递inputs_embeds而不是input_ids时无法猜测填充标记，因此它执行相同操作（取每一行批次中的最后一个值）。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

< source >

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• 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), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  如果使用past_key_values，可选地只需输入最后的decoder_input_ids（参见past_key_values）。

  如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。

  什么是位置 ID？

• past_key_values (Cache or tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为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（即那些没有将其过去键值状态提供给此模型的输入）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• 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,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

PersimmonForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

Phi

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/phi

概述

Phi-1 模型是由 Suriya Gunasekar、Yi Zhang、Jyoti Aneja、Caio César Teodoro Mendes、Allie Del Giorno、Sivakanth Gopi、Mojan Javaheripi、Piero Kauffmann、Gustavo de Rosa、Olli Saarikivi、Adil Salim、Shital Shah、Harkirat Singh Behl、Xin Wang、Sébastien Bubeck、Ronen Eldan、Adam Tauman Kalai、Yin Tat Lee 和 Yuanzhi Li 在Textbooks Are All You Need中提出的。

Phi-1.5 模型是由 Yuanzhi Li、Sébastien Bubeck、Ronen Eldan、Allie Del Giorno、Suriya Gunasekar 和 Yin Tat Lee 在Textbooks Are All You Need II: phi-1.5 technical report中提出的。

摘要

在 Phi-1 和 Phi-1.5 论文中，作者展示了数据质量对训练相对于模型大小的重要性。他们选择了高质量的“教科书”数据以及合成生成的数据，用于训练其具有 13 亿参数的小型 Transformer 模型 Phi-1。尽管规模较小，phi-1 在 HumanEval 上的 pass@1 准确率为 50.6%，在 MBPP 上为 55.5%。他们对 Phi-1.5 采用相同策略，并创建了另一个具有 13 亿参数的模型，其在自然语言任务上的性能与大 5 倍的模型相当，并超过了大多数非前沿 LLMs。Phi-1.5 表现出许多更大 LLMs 的特征，比如能够“逐步思考”或进行一些基本的上下文学习。通过这两个实验，作者成功地展示了在训练机器学习模型时训练数据质量的巨大影响。

Phi-1 论文的摘要如下：

我们介绍 phi-1，一个用于代码的新型大型语言模型，比竞争模型规模明显更小：phi-1 是一个基于 Transformer 的模型，具有 13 亿参数，在 8 个 A100 上训练了 4 天，使用了来自网络的“教科书质量”数据（60 亿标记）和使用 GPT-3.5（10 亿标记）合成生成的教科书和练习。尽管规模较小，phi-1 在 HumanEval 上的 pass@1 准确率为 50.6%，在 MBPP 上为 55.5%。与 phi-1-base 相比，我们在编码练习数据集上微调之前的模型，以及 phi-1-small，一个具有 350M 参数的较小模型，使用与 phi-1 相同的流程训练，仍然在 HumanEval 上达到 45%。

Phi-1.5 论文的摘要如下：

我们继续研究基于较小 Transformer 的语言模型的能力，这是由 TinyStories 发起的——一个可以生成连贯英语的 1 千万参数模型，以及关于 phi-1 的后续工作，这是一个 13 亿参数模型，其 Python 编码性能接近最先进水平。后者提出使用现有的大型语言模型（LLMs）生成“教科书质量”数据，以增强学习过程，相比传统网络数据。我们遵循“Textbooks Are All You Need”的方法，这次专注于自然语言中的常识推理，并创建一个新的 13 亿参数模型，命名为 phi-1.5，其在自然语言任务上的性能与大 5 倍的模型相当，并且在更复杂的推理任务（如小学数学和基本编码）上超过了大多数非前沿 LLMs。总的来说，phi-1.5 表现出许多更大 LLMs 的特征，包括好的——比如能够“逐步思考”或进行一些基本的上下文学习——以及坏的，包括幻觉和产生有毒和偏见的可能性——令人鼓舞的是，由于缺乏网络数据，我们在这方面看到了改善。我们开源 phi-1.5，以促进对这些紧迫主题的进一步研究。

该模型由Susnato Dhar贡献。

Phi-1、Phi-1.5 和 Phi-2 的原始代码可以在这里，这里和这里找到。

使用提示

• 这个模型与Llama非常相似，主要区别在于PhiDecoderLayer，其中他们在并行配置中使用了PhiAttention和PhiMLP层。

• 用于该模型的分词器与 CodeGenTokenizer 相同。

如何使用 Phi-2

Phi-2 已经集成在transformers的开发版本（4.37.0.dev）中。在通过pip发布官方版本之前，请确保您正在执行以下操作之一：

• 加载模型时，请确保将trust_remote_code=True作为from_pretrained()函数的参数传递。

• 将本地的transformers更新到开发版本：pip uninstall -y transformers && pip install git+https://github.com/huggingface/transformers。上述命令是从源代码克隆和安装的替代方法。

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("phi-2")
>>> tokenizer = AutoTokenizer.from_pretrained("phi-2")

>>> inputs = tokenizer('Can you help me write a formal email to a potential business partner proposing a joint venture?', return_tensors="pt", return_attention_mask=False)

>>> outputs = model.generate(**inputs, max_length=30)
>>> text = tokenizer.batch_decode(outputs)[0]
>>> print(text)
'Can you help me write a formal email to a potential business partner proposing a joint venture?\nInput: Company A: ABC Inc.\nCompany B: XYZ Ltd.\nJoint Venture: A new online platform for e-commerce'

示例：

>>> from transformers import PhiForCausalLM, AutoTokenizer

>>> # define the model and tokenizer.
>>> model = PhiForCausalLM.from_pretrained("microsoft/phi-1_5")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1_5")

>>> # feel free to change the prompt to your liking.
>>> prompt = "If I were an AI that had just achieved"

>>> # apply the tokenizer.
>>> tokens = tokenizer(prompt, return_tensors="pt")

>>> # use the model to generate new tokens.
>>> generated_output = model.generate(**tokens, use_cache=True, max_new_tokens=10)

>>> tokenizer.batch_decode(generated_output)[0]
'If I were an AI that had just achieved a breakthrough in machine learning, I would be thrilled'

结合 Phi 和 Flash Attention 2

首先，请确保安装最新版本的 Flash Attention 2 以包含滑动窗口注意力功能。

pip install -U flash-attn --no-build-isolation

还要确保您拥有与 Flash-Attention 2 兼容的硬件。在 flash-attn 存储库的官方文档中了解更多信息。还要确保以半精度（例如torch.float16）加载您的模型。

要加载和运行使用 Flash Attention 2 的模型，请参考下面的代码片段：

>>> import torch
>>> from transformers import PhiForCausalLM, AutoTokenizer

>>> # define the model and tokenizer and push the model and tokens to the GPU.
>>> model = PhiForCausalLM.from_pretrained("microsoft/phi-1_5", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to("cuda")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1_5")

>>> # feel free to change the prompt to your liking.
>>> prompt = "If I were an AI that had just achieved"

>>> # apply the tokenizer.
>>> tokens = tokenizer(prompt, return_tensors="pt").to("cuda")

>>> # use the model to generate new tokens.
>>> generated_output = model.generate(**tokens, use_cache=True, max_new_tokens=10)

>>> tokenizer.batch_decode(generated_output)[0]
'If I were an AI that had just achieved a breakthrough in machine learning, I would be thrilled'

预期加速

下面是一个预期的加速图表，比较了在使用序列长度为 2048 时，transformers 中使用microsoft/phi-1检查点的原生实现和模型的 Flash Attention 2 版本之间的纯推理时间。

PhiConfig

class transformers.PhiConfig

<来源>

( vocab_size = 51200 hidden_size = 2048 intermediate_size = 8192 num_hidden_layers = 24 num_attention_heads = 32 num_key_value_heads = None resid_pdrop = 0.0 embd_pdrop = 0.0 attention_dropout = 0.0 hidden_act = 'gelu_new' max_position_embeddings = 2048 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None partial_rotary_factor = 0.5 qk_layernorm = False bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size (int，可选，默认为 51200）— Phi 模型的词汇量。定义了在调用 PhiModel 时可以表示的不同令牌的数量。

• hidden_size (int，可选，默认为 2048）— 隐藏表示的维度。

• intermediate_size (int，可选，默认为 8192）— MLP 表示的维度。

• num_hidden_layers (int，可选，默认为 24）— Transformer 解码器中的隐藏层数。

• num_attention_heads (int，可选，默认为 32）— Transformer 解码器中每个注意力层的注意力头数。

• num_key_value_heads (int，可选）— 这是应该用于实现分组查询注意力的 key_value 头的数量。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（MHA），如果num_key_value_heads=1，模型将使用多查询注意力（MQA），否则使用 GQA。在将多头检查点转换为 GQA 检查点时，应通过对该组中所有原始头进行均值池化来构建每个组键和值头。有关更多详细信息，请查看此论文。如果未指定，将默认为num_attention_heads。

• resid_pdrop (float，可选，默认为 0.0）— mlp 输出的 dropout 概率。

• embd_pdrop (int，可选，默认为 0.0）— 嵌入的 dropout 比率。

• attention_dropout (float，可选，默认为 0.0）— 计算注意力分数后的 dropout 比率。

• hidden_act (str或function，可选，默认为"gelu_new") — 解码器中的非线性激活函数（函数或字符串）。

• max_position_embeddings (int, optional, defaults to 2048) — 此模型可能使用的最大序列长度。Phi-1 和 Phi-1.5 支持最多 2048 个标记。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-05) — rms 归一化层使用的 epsilon。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后一个键/值注意力（不是所有模型都使用）。仅在 config.is_decoder=True 时相关。是否绑定权重嵌入。

• tie_word_embeddings (bool, optional, defaults to False) — 是否绑定权重嵌入

• rope_theta (float, optional, defaults to 10000.0) — RoPE 嵌入的基本周期。

• rope_scaling (Dict, optional) — 包含 RoPE 嵌入的缩放配置的字典。目前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为 {"type": 策略名称, "factor": 缩放因子}。在使用此标志时，不要将 max_position_embeddings 更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参阅以下主题：www.reddit.com/r/LocalPersimmon/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。

• partial_rotary_factor (float, optional, defaults to 0.5) — 查询和键中将具有旋转嵌入的百分比。

• qk_layernorm (bool, optional, defaults to False) — 是否在投影隐藏状态后对查询和键进行归一化。

• bos_token_id (int, optional, defaults to 1) — 表示序列开始的标记 id。

• eos_token_id (int, optional, defaults to 2) — 表示序列结束的标记 id。

这是用于存储 PhiModel 配置的配置类。它用于根据指定的参数实例化 Phi 模型，定义模型架构。使用默认值实例化配置将产生类似于 Phi microsoft/phi-1的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import PhiModel, PhiConfig

>>> # Initializing a Phi-1 style configuration
>>> configuration = PhiConfig.from_pretrained("microsoft/phi-1")

>>> # Initializing a model from the configuration
>>> model = PhiModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

PytorchHide Pytorch content

PhiModel

class transformers.PhiModel

< source >

( config: PhiConfig )

参数

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

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

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个PhiDecoderLayer

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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 )

参数

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

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

  什么是输入 ID？

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

  • 1 表示未被“屏蔽”的标记，

  • 0 表示被“屏蔽”的标记。

  什么是注意力掩码？

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

  如果使用了past_key_values，可以选择仅输入最后一个input_ids（参见past_key_values）。

  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部是“未屏蔽的”，

  • 0 表示头部被“屏蔽”。

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  两种格式都允许：

  • 一个 Cache 实例；

  • 长度为config.n_layers的元组tuple(torch.FloatTensor)，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

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

  如果使用了past_key_values，用户可以选择仅输入最后一个形状为(batch_size, 1)的input_ids（这些input_ids没有将它们的过去键值状态提供给此模型）而不是所有形状为(batch_size, sequence_length)的input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• 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 而不是普通元组。

PhiModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

PhiForCausalLM

class transformers.PhiForCausalLM

< source >

( config )

forward

< source >

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast 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), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间:

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  如果使用 past_key_values，可以选择仅输入最后的 input_ids（参见 past_key_values）。

  如果要更改填充行为，应阅读 modeling_opt._prepare_decoder_attention_mask 并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图表 1。

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）— 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统缓存格式。

  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后input_ids（这些input_ids没有给定其过去键值状态的模型）而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。

  参数 — 标签（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（请参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时），包括根据配置（PhiConfig）和输入的不同元素。

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

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

• 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)的张量。

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

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

PhiForCausalLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, PhiForCausalLM

>>> model = PhiForCausalLM.from_pretrained("microsoft/phi-1")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1")

>>> prompt = "This is an example script ."
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'This is an example script .\n\n\n\nfrom typing import List\n\ndef find_most_common_letter(words: List[str'

生成

<来源>

( inputs: Optional = None generation_config: Optional = None logits_processor: Optional = None stopping_criteria: Optional = None prefix_allowed_tokens_fn: Optional = None synced_gpus: Optional = None assistant_model: Optional = None streamer: Optional = None negative_prompt_ids: Optional = None negative_prompt_attention_mask: Optional = None **kwargs ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor

参数

• inputs (torch.Tensor，根据模态性而变化的形状，可选) — 用作生成提示或作为编码器的模型输入的序列。如果为None，则该方法将使用bos_token_id和批量大小为 1 进行初始化。对于仅解码器模型，inputs应为input_ids格式。对于编码器-解码器模型，inputs可以表示input_ids、input_values、input_features或pixel_values中的任何一个。

• generation_config (~generation.GenerationConfig, 可选) — 用作生成调用的基本参数化的生成配置。与generation_config属性匹配的**kwargs传递给generate将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1）从generation_config.json模型文件中，如果存在；2）从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。

• logits_processor (LogitsProcessorList, 可选) — 自定义 logits 处理器，补充了从参数和生成配置构建的默认 logits 处理器。如果传递了一个已经使用参数或生成配置创建的 logit 处理器，将会抛出错误。此功能适用于高级用户。

• stopping_criteria (StoppingCriteriaList, 可选) — 自定义停止标准，补充了从参数和生成配置构建的默认停止标准。如果传递了一个已经使用参数或生成配置创建的停止标准，将会抛出错误。如果您的停止标准依赖于scores输入，请确保在调用generate时传递return_dict_in_generate=True, output_scores=True。此功能适用于高级用户。

• prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]], 可选) — 如果提供，此函数将在每一步将束搜索限制为仅允许的标记。如果未提供，则不应用约束。此函数接受 2 个参数：批次 IDbatch_id和input_ids。它必须返回一个列表，其中包含下一代步骤的允许标记，条件是批次 IDbatch_id和先前生成的标记inputs_ids。此参数对于受前缀约束的生成很有用，如自回归实体检索中所述。

• synced_gpus (bool, optional) — 是否继续运行 while 循环直到 max_length。除非被覆盖，否则在 DeepSpeed ZeRO Stage 3 多 GPU 环境下，此标志将设置为True，以避免一个 GPU 在其他 GPU 之前生成完成时挂起。否则，它将设置为False。

• assistant_model (PreTrainedModel, optional) — 一个助理模型，可用于加速生成。助理模型必须具有完全相同的分词器。当使用助理模型预测候选标记比使用您调用 generate 的模型运行生成要快得多时，加速就会实现。因此，助理模型应该要小得多。

• streamer (BaseStreamer, optional) — 将用于流式传输生成的序列的 Streamer 对象。生成的标记通过streamer.put(token_ids)传递，Streamer 负责任何进一步的处理。

• negative_prompt_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 一些处理器（如 CFG）需要的负向提示。批量大小必须与输入批量大小匹配。这是一个实验性功能，可能在未来版本中会有破坏性的 API 更改。

• negative_prompt_attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于negative_prompt_ids的 Attention_mask。

• kwargs (Dict[str, Any], optional) — generate_config的特定参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。如果模型是编码器-解码器模型，则编码器特定的 kwargs 不应该有前缀，解码器特定的 kwargs 应该以decoder_为前缀。

返回

ModelOutput 或torch.LongTensor

一个 ModelOutput（如果return_dict_in_generate=True或者config.return_dict_in_generate=True）或者一个torch.FloatTensor。

如果模型不是编码器-解码器模型（model.config.is_encoder_decoder=False），可能的 ModelOutput 类型为：

• GenerateDecoderOnlyOutput，

• GenerateBeamDecoderOnlyOutput

如果模型是编码器-解码器模型（model.config.is_encoder_decoder=True），可能的 ModelOutput 类型为：

• GenerateEncoderDecoderOutput，

• GenerateBeamEncoderDecoderOutput

为具有语言建模头的模型生成标记 id 序列。

大多数控制生成的参数都在generation_config中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate()来覆盖任何generation_config，例如.generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

PhiForSequenceClassification

class transformers.PhiForSequenceClassification

< source >

( config )

参数

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

PhiModel 在顶部具有序列分类头（线性层）。

PhiForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则会找到每行中不是填充标记的最后一个标记。如果未定义pad_token_id，则会简单地取批处理中每行的最后一个值。当传递inputs_embeds而不是input_ids时，无法猜测填充标记，因此会执行相同操作（取批处理中每行的最后一个值）。

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

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

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

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

  什么是输入 ID？

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

  • 1 表示标记未被遮蔽，

  • 0 表示被遮蔽的标记。

  什么是注意力掩码？

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

  如果使用past_key_values，则可选择仅输入最后的input_ids（参见past_key_values）。

  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values (Cache或tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统的缓存格式。

  模型将输出与输入相同的缓存格式。如果未传递past_key_values，则将返回传统的缓存格式。

  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个input_ids（这些input_ids不具有其过去的键值状态给予此模型）而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• 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,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

PhiForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

PhiForTokenClassification

class transformers.PhiForTokenClassification

< source >

( config: PhiConfig )

参数

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

在顶部带有标记分类头的 PhiModel（隐藏状态输出顶部的线性层），例如用于命名实体识别（NER）任务。

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **deprecated_arguments ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 对于未被掩码的标记，标记为 1，

  • 对于被掩码的标记，标记为 0。

  什么是注意力掩码？

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

  如果使用past_key_values，则可以选择仅输入最后的input_ids（参见past_key_values）。

  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）— 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。这也被称为传统的缓存格式。

  该模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。

  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后的input_ids（这些没有将其过去的键值状态提供给该模型）而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds (torch.FloatTensor，形状为(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 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或者当config.return_dict=False时）包含根据配置(PhiConfig)和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选, 当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

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

PhiForTokenClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, PhiForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1")
>>> model = PhiForTokenClassification.from_pretrained("microsoft/phi-1")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

PhoBERT

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/phobert

概述

PhoBERT 模型由 Dat Quoc Nguyen 和 Anh Tuan Nguyen 在PhoBERT: Pre-trained language models for Vietnamese中提出。

论文摘要如下：

我们提出了两个版本的 PhoBERT，PhoBERT-base 和 PhoBERT-large，这是为越南语预训练的第一个公共大规模单语言模型。实验结果表明，PhoBERT 始终优于最近的最佳预训练多语言模型 XLM-R（Conneau 等，2020），并改进了多个越南特定的 NLP 任务的最新技术，包括词性标注、依存句法分析、命名实体识别和自然语言推理。

此模型由dqnguyen贡献。原始代码可在此处找到。

用法示例

>>> import torch
>>> from transformers import AutoModel, AutoTokenizer

>>> phobert = AutoModel.from_pretrained("vinai/phobert-base")
>>> tokenizer = AutoTokenizer.from_pretrained("vinai/phobert-base")

>>> # INPUT TEXT MUST BE ALREADY WORD-SEGMENTED!
>>> line = "Tôi là sinh_viên trường đại_học Công_nghệ ."

>>> input_ids = torch.tensor([tokenizer.encode(line)])

>>> with torch.no_grad():
...     features = phobert(input_ids)  # Models outputs are now tuples

>>> # With TensorFlow 2.0+:
>>> # from transformers import TFAutoModel
>>> # phobert = TFAutoModel.from_pretrained("vinai/phobert-base")

PhoBERT 实现与 BERT 相同，除了分词。有关配置类及其参数的信息，请参考 EART 文档。下面记录了 PhoBERT 特定的标记器。

PhobertTokenizer

class transformers.PhobertTokenizer

< source >

( vocab_file merges_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• bos_token (st, optional, defaults to "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

  在构建使用特殊标记的序列时，这不是用于序列开头的标记。使用的标记是cls_token。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。

  在构建使用特殊标记的序列时，这不是用于序列结束的标记。使用的标记是sep_token。

• sep_token (str, optional, defaults to "</s>") — 分隔符标记，用于从多个序列构建序列，例如，用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, defaults to "<s>") — 用于进行序列分类时使用的分类器标记（对整个序列进行分类而不是对每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。在训练此模型时使用的标记为掩码语言建模。这是模型将尝试预测的标记。

构建一个 PhoBERT 标记器。基于字节对编码。

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

add_from_file

< source >

( f )

从文本文件加载现有字典并将其符号添加到此实例。

build_inputs_with_special_tokens

< source >

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

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

• 单个序列：<s> X </s>

• 序列对：<s> A </s></s> B </s>

convert_tokens_to_string

<来源>

( tokens )

将一系列标记（字符串）转换为单个字符串。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

零的列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。PhoBERT 不使用标记类型 ID，因此返回一个零列表。

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

• already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经使用特殊标记格式化。

返回

List[int]

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

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

PLBart

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/plbart

概述

PLBART 模型是由 Wasi Uddin Ahmad、Saikat Chakraborty、Baishakhi Ray、Kai-Wei Chang 在统一的程序理解和生成预训练中提出的。这是一个类似 BART 的模型，可用于执行代码摘要、代码生成和代码翻译任务。预训练模型plbart-base是通过 Java、Python 和英语上的多语言去噪任务进行训练的。

根据摘要

代码摘要和生成使编程语言（PL）和自然语言（NL）之间的转换变得更加强大，而代码翻译则可实现从一种 PL 到另一种 PL 的遗留代码迁移。本文介绍了 PLBART，这是一个序列到序列模型，能够执行广泛的程序和语言理解和生成任务。PLBART 在大量的 Java 和 Python 函数以及相关的 NL 文本上进行了预训练，通过去噪自编码。在英语语言的代码摘要、代码生成以及七种编程语言的代码翻译实验中，PLBART 表现出优于或与最先进模型相媲美的性能。此外，在区分性任务上的实验，如程序修复、克隆检测和易受攻击代码检测，展示了 PLBART 在程序理解方面的有效性。此外，分析显示 PLBART 学习了对程序语法、风格（例如标识符命名约定）、逻辑流程（例如 if 块在 else 块内等同于 else if 块）等对程序语义至关重要的内容，因此即使有限的注释也能表现出色。

此模型由gchhablani贡献。作者的代码可以在这里找到。

使用示例

PLBart 是一个多语言编码器-解码器（序列到序列）模型，主要用于代码到文本、文本到代码、代码到代码任务。由于该模型是多语言的，因此它期望序列以不同的格式提供。在源文本和目标文本中都添加了特殊的语言 id 标记。源文本格式为X [eos, src_lang_code]，其中X是源文本。目标文本格式为[tgt_lang_code] X [eos]。bos从未被使用。

然而，在一些情况下，对于微调，当只使用一种语言时，不提供语言标记。请参考论文以了解更多信息。

在需要语言代码的情况下，常规的call()将对源文本格式进行编码，当您将文本作为第一个参数传递或使用关键字参数text时，将对目标文本格式进行编码，如果使用text_target关键字参数传递目标文本格式。

监督训练

>>> from transformers import PLBartForConditionalGeneration, PLBartTokenizer

>>> tokenizer = PLBartTokenizer.from_pretrained("uclanlp/plbart-base", src_lang="en_XX", tgt_lang="python")
>>> example_python_phrase = "def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])"
>>> expected_translation_english = "Returns the maximum value of a b c."
>>> inputs = tokenizer(example_python_phrase, text_target=expected_translation_english, return_tensors="pt")
>>> model(**inputs)

生成

在生成目标文本时，将decoder_start_token_id设置为目标语言的 id。以下示例展示了如何使用uclanlp/plbart-python-en_XX模型将 Python 翻译成英语。

>>> from transformers import PLBartForConditionalGeneration, PLBartTokenizer

>>> tokenizer = PLBartTokenizer.from_pretrained("uclanlp/plbart-python-en_XX", src_lang="python", tgt_lang="en_XX")
>>> example_python_phrase = "def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])"
>>> inputs = tokenizer(example_python_phrase, return_tensors="pt")
>>> model = PLBartForConditionalGeneration.from_pretrained("uclanlp/plbart-python-en_XX")
>>> translated_tokens = model.generate(**inputs, decoder_start_token_id=tokenizer.lang_code_to_id["en_XX"])
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
"Returns the maximum value of a b c."

资源

• 文本分类任务指南

• 因果语言建模任务指南

• 翻译任务指南

• 摘要任务指南

PLBartConfig

class transformers.PLBartConfig

<来源>

( vocab_size = 50005 max_position_embeddings = 1024 encoder_layers = 6 encoder_ffn_dim = 3072 encoder_attention_heads = 12 decoder_layers = 6 decoder_ffn_dim = 3072 decoder_attention_heads = 12 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 768 dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 init_std = 0.02 classifier_dropout = 0.0 scale_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 forced_eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 50005）— PLBART 模型的词汇表大小。定义了在调用 PLBartModel 时可以由inputs_ids表示的不同标记数量。

• d_model (int, 可选, 默认为 768) — 层和池化层的维度。

• encoder_layers (int, 可选, 默认为 6) — 编码器层数。

• decoder_layers (int, 可选, 默认为 6) — 解码器层数。

• encoder_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, 可选, 默认为 12) — Transformer 解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, 可选, 默认为 3072) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, 可选, 默认为 3072) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。

• activation_dropout (float, 可选, 默认为 0.0) — 全连接层内激活的 dropout 比率。

• classifier_dropout (float, 可选, 默认为 0.0) — 分类器的 dropout 比率。

• max_position_embeddings (int, 可选, 默认为 1024) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。

• init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。

• decoder_layerdrop (float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。

• scale_embedding (bool, 可选, 默认为True) — 通过 sqrt(d_model)缩放嵌入。

• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• forced_eos_token_id (int, 可选, 默认为 2) — 当达到max_length时，强制作为最后生成的标记的标记 ID。通常设置为eos_token_id。

这是用于存储 PLBartModel 配置的配置类。它用于根据指定的参数实例化一个 PLBART 模型，定义模型架构。使用默认值实例化配置将产生类似于 PLBART uclanlp/plbart-base架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import PLBartConfig, PLBartModel

>>> # Initializing a PLBART uclanlp/plbart-base style configuration
>>> configuration = PLBartConfig()

>>> # Initializing a model (with random weights) from the uclanlp/plbart-base style configuration
>>> model = PLBartModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

PLBartTokenizer

class transformers.PLBartTokenizer

<来源>

( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' language_codes = 'base' tokenizer_file = None src_lang = None tgt_lang = None sp_model_kwargs: Optional = None additional_special_tokens = None **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• src_lang (str, 可选) — 表示源语言的字符串。

• tgt_lang (str, 可选) — 表示目标语言的字符串。

• bos_token（str，可选，默认为"<s>"）— 序列开始标记。

• eos_token（str，可选，默认为"</s>"）— 序列结束标记。

• sep_token（str，可选，默认为"</s>"）— 用于从多个序列构建序列时使用的分隔符标记，例如，用于序列分类的两个序列或用于问答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token（str，可选，默认为"<s>"）— cls 标记，用作所有任务的第一个标记。

• unk_token（str，可选，默认为"<unk>"）— 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• pad_token（str，可选，默认为"<pad>"）— 用于填充的标记，例如，当批处理不同长度的序列时。

• mask_token（str，可选，默认为"<mask>"）— 用于屏蔽值的标记。这是在使用屏蔽任务训练此模型时使用的标记。仅在"base"分词器类型中使用。对于"multi"分词器，下游任务永远不会进行屏蔽。

• language_codes（str，可选，默认为"base"）— 要使用的语言代码。应为"base"或"multi"之一。

• sp_model_kwargs（dict，可选）— 将传递给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 合并操作的丢弃概率。

构建一个 PLBART 分词器。

改编自 RobertaTokenizer 和 XLNetTokenizer。基于SentencePiece。

分词方法为源语言文档的<tokens> <eos> <language code>，以及<language code>

` 用于目标语言文档。

示例：

>>> from transformers import PLBartTokenizer

>>> tokenizer = PLBartTokenizer.from_pretrained("uclanlp/plbart-python-en_XX", src_lang="python", tgt_lang="en_XX")
>>> example_python_phrase = "def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])"
>>> expected_translation_english = "Returns the maximum value of a b c."
>>> inputs = tokenizer(example_python_phrase, text_target=expected_translation_english, return_tensors="pt")

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。PLBART 序列具有以下格式，其中X表示序列：

• input_ids（用于编码器）X [eos, src_lang_code]

• decoder_input_ids：（用于解码器）X [eos, tgt_lang_code]

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

PLBartModel

class transformers.PLBartModel

<来源>

( config: PLBartConfig )

参数

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

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

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

forward

<来源>

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

参数

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力。蒙版值在[0, 1]中选择：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力蒙版？

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  PLBart 使用特定的语言 ID 标记作为decoder_input_ids生成的起始标记，根据源语言和目标语言而变化，例如en_XX为 50003，java为 50001。如果使用past_key_values，可选择仅输入最后的decoder_input_ids（参见past_key_values）。

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，用于去噪预训练，遵循论文。

• decoder_attention_mask（- 形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）：默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果蒙版也将默认使用。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于在编码器中使选定的注意力模块头部无效的蒙版。蒙版值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• decoder_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选） — 用于使解码器中注意模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• cross_attn_head_mask（— obj：torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）：用于使解码器中交叉注意模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选） — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意。

• past_key_values（— obj：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，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的输入）。

• inputs_embeds（— obj：torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）：可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是模型内部的嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（— obj：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，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（PLBartConfig）和输入的各种元素。

• last_hidden_state (torch.FloatTensor of shape (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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

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

• decoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

• cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

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

• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

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

• encoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

PLBartModel 的前向方法，覆盖__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, PLBartModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uclanlp/plbart-base")
>>> model = PLBartModel.from_pretrained("uclanlp/plbart-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

PLBartForConditionalGeneration

class transformers.PLBartForConditionalGeneration

<来源>

( config: PLBartConfig )

参数

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

PLBART 模型带有语言建模头。可用于代码到文本、文本到代码和代码到代码。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

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

参数

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示未屏蔽的标记，

  • 0 表示已屏蔽的标记。

  什么是注意力掩码？

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  PLBart 使用特定的语言 ID 标记作为decoder_input_ids生成的起始标记，根据源语言和目标语言而变化，例如en_XX为 50003，java为 50001。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（参见past_key_values）。

  对于翻译和摘要训练，应提供decoder_input_ids。如果没有提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以用于去噪预训练，遵循论文。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的 torch.LongTensor，可选）：默认行为：生成一个张量，忽略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（元组（元组(torch.FloatTensor)，*可选*）— 元组包括（last_hidden_state，*可选*：hidden_states，*可选*：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)`，可选*）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（元组（元组（torch.FloatTensor）），可选，当传递use_cache=True或config.use_cache=True时返回）：长度为config.n_layers的元组，每个元组有 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_input_ids（这些未将其过去的键值状态提供给此模型的输入）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的 torch.FloatTensor，可选）：可选地，可以直接传递嵌入表示，而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的 torch.FloatTensor，可选）：可选地，可以直接传递嵌入表示，而不是传递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，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有[0, ..., config.vocab_size]标签的标记。

返回

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（PLBartConfig）和输入。

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

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

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

• decoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的交叉注意力层的注意权重，在注意力 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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

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

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

PLBartForConditionalGeneration 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

掩码填充示例：

>>> from transformers import AutoTokenizer, PLBartForConditionalGeneration

>>> model = PLBartForConditionalGeneration.from_pretrained("uclanlp/plbart-base")
>>> tokenizer = AutoTokenizer.from_pretrained("uclanlp/plbart-base")

>>> # en_XX is the language symbol id <LID> for English
>>> TXT = "<s> Is 0 the <mask> Fibonacci number ? </s> en_XX"
>>> input_ids = tokenizer([TXT], add_special_tokens=False, return_tensors="pt").input_ids

>>> logits = model(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)

>>> tokenizer.decode(predictions).split()
['first', 'same', 'highest', 'result', 'number']

PLBartForSequenceClassification

class transformers.PLBartForSequenceClassification

<来源>

( config: PLBartConfig **kwargs )

参数

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

PLBart 模型在顶部具有序列分类/头（在汇总输出的顶部有一个线性层），例如用于代码分类。

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

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

forward

<来源>

( input_ids: LongTensor = 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 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.modeling_outputs.Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer来获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未被masked的标记，值为 1。

  • 对于被masked的标记，值为 0。

  注意力掩码是什么？

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

  可以使用 AutoTokenizer 或PLBartMultiTokenizer获取索引，具体取决于检查点。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  PLBart 使用特定的语言 id 标记作为decoder_input_ids生成的起始标记，根据源语言和目标语言而变化，例如对于en_XX为 50003，对于java为 50001。如果使用past_key_values，可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。

• decoder_attention_mask（- obj：torch.LongTensor，形状为(batch_size, target_sequence_length)，可选）：默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

• head_mask（torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选）- 用于使编码器中注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• decoder_head_mask（torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）- 用于使解码器中注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• cross_attn_head_mask（- obj：torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选）：用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组由(last_hidden_state，可选：hidden_states，可选：attentions) 组成，last_hidden_state形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（- obj：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，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（即没有将其过去键值状态提供给此模型的那些）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds（- obj：torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）：可选地，可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（— obj: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，可选）— 如果设置为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，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

一个 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一个torch.FloatTensor的元组（如果传递了return_dict=False或config.return_dict=False时）包含不同的元素，取决于配置（PLBartConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供label时返回）— 分类（如果 config.num_labels==1 则为回归）损失。

• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• 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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

• decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每一层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每一层的输出）。

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

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

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

PLBartForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

单标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, PLBartForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uclanlp/plbart-base")
>>> model = PLBartForSequenceClassification.from_pretrained("uclanlp/plbart-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = PLBartForSequenceClassification.from_pretrained("uclanlp/plbart-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, PLBartForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uclanlp/plbart-base")
>>> model = PLBartForSequenceClassification.from_pretrained("uclanlp/plbart-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = PLBartForSequenceClassification.from_pretrained(
...     "uclanlp/plbart-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

PLBartForCausalLM

class transformers.PLBartForCausalLM

<来源>

( config )

forward

<来源>

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

参数

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

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

  什么是输入 ID？

• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • not masked的标记为 1。

  • masked的标记为 0。

  什么是注意力掩码？

• encoder_hidden_states（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在[0, 1]之间：

• head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于将注意力模块的选定头部置零的掩码。掩码值在[0, 1]范围内：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于将交叉注意力模块的选定头部置零的掩码。掩码值在[0, 1]范围内：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when 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。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档）。索引设置为-100的标记将被忽略（masked），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包含根据配置（PLBartConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失（用于下一个标记的预测）。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

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

• cross_attentions (tuple(torch.FloatTensor), optional, 当传递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, PLBartForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("uclanlp/plbart-base")
>>> model = PLBartForCausalLM.from_pretrained("uclanlp/plbart-base", 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

ProphetNet

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/prophetnet

概述

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 是一个编码器-解码器模型，可以预测“ngram”语言建模的 n 个未来标记，而不仅仅是下一个标记。

论文摘要如下：

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

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

使用提示

• ProphetNet 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

• 该模型架构基于原始 Transformer，但是在解码器中用一个主自注意力机制和一个自注意力机制和 n 流（预测）自注意力机制替换了“标准”自注意力机制。

资源

• 因果语言建模任务指南

• 翻译任务指南

• 摘要任务指南

ProphetNetConfig

class transformers.ProphetNetConfig

<来源>

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

参数

• activation_dropout（float，可选，默认为 0.1）— 全连接层内激活的丢失比率。

• activation_function（str或function，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• vocab_size（int，可选，默认为 30522）— ProphetNET 模型的词汇大小。定义了在调用 ProphetNetModel 时可以表示的不同标记的数量。

• 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) — 解码器中intermediate（通常称为前馈）层的维度。

• num_decoder_layers (int, 可选, 默认为 12) — 解码器层数。

• num_decoder_attention_heads (int, 可选, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。

• attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的丢失比率。

• dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

• max_position_embeddings (int, 可选, 默认为 512) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。

• init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• 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 论文)。

• relative_max_distance (int, 可选, 默认为 128) — 大于此数字的相对距离将放入最后一个相同的桶中。这是用于相对位置计算的。更多细节请参阅 T5 论文)。

• disable_ngram_loss (bool, 可选, 默认为False) — 是否训练仅预测下一个第一个标记。

• eps (float, 可选, 默认为 0.0) — 控制损失计算中标签平滑的epsilon参数值。如果设置为 0，则不执行标签平滑。

• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

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

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

ProphetNetTokenizer

class transformers.ProphetNetTokenizer

<来源>

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

参数

• vocab_file (str) — 包含词汇表的文件。

• do_lower_case (bool, 可选, 默认为True) — 在标记化时是否将输入转换为小写。

• do_basic_tokenize (bool, 可选, 默认为True) — 在 WordPiece 之前是否进行基本标记化。

• never_split（Iterable，可选）— 在标记化期间永远不会拆分的标记集合。仅在do_basic_tokenize=True时才有效果

• unk_token（str，可选，默认为"[UNK]"）— 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• sep_token（str，可选，默认为"[SEP]"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作由特殊标记构建的序列的最后一个标记。

• x_sep_token（str，可选，默认为"[X_SEP]"）— 特殊的第二个分隔符标记，可以由 ProphetNetForConditionalGeneration 生成。用于在摘要中分隔类似项目符号的句子，例如。

• pad_token（str，可选，默认为"[PAD]"）— 用于填充的标记，例如在批处理不同长度的序列时。

• mask_token（str，可选，默认为"[MASK]"）— 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• tokenize_chinese_chars（bool，可选，默认为True）— 是否对中文字符进行标记化。

  这可能应该在日语中停用（请参阅此问题）。

• strip_accents（bool，可选）— 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 相同）。

构建一个 ProphetNetTokenizer。基于 WordPiece。

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

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

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

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

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

convert_tokens_to_string

<来源>

( tokens: str )

将一系列标记（字符串）转换为单个字符串。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 ProphetNet

序列对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1是None，这个方法只返回掩码的第一部分（0s）。

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: Optional = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的第二个 ID 列表。

• already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

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

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

ProphetNet 特定输出

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqLMOutput

< source >

( loss: Optional = None logits: FloatTensor = None logits_ngram: Optional = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_ngram_hidden_states: Optional = None decoder_attentions: Optional = None decoder_ngram_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，在提供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=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输入）。

• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, decoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

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

• decoder_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元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

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

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

• decoder_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 之后，用于计算加权平均值

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

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

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

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetSeq2SeqModelOutput

< source >

( last_hidden_state: FloatTensor last_hidden_state_ngram: Optional = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_ngram_hidden_states: Optional = None decoder_attentions: Optional = None decoder_ngram_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• 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输入）。

• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, decoder_sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

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

• decoder_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元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

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

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

• decoder_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 之后，用于计算加权平均值。

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

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

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderModelOutput

<来源>

( last_hidden_state: FloatTensor last_hidden_state_ngram: Optional = None past_key_values: Optional = None hidden_states: Optional = None hidden_states_ngram: Optional = None attentions: Optional = None ngram_attentions: Optional = None cross_attentions: Optional = 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=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_attn_heads, decoder_sequence_length, embed_size_per_head)。

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

• 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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（每层一个，包括嵌入层和每一层的输出），形状为(batch_size, ngram * decoder_sequence_length, hidden_size)。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。

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

• ngram_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_attn_heads, decoder_sequence_length, decoder_sequence_length)。

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

• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_attn_heads, encoder_sequence_length, decoder_sequence_length)。

  解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算加权平均值

模型输出的基类，可能还包含过去的键/值（用于加速顺序解码）。

class transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput

<来源>

( loss: Optional = None logits: FloatTensor = None logits_ngram: Optional = None past_key_values: Optional = None hidden_states: Optional = None hidden_states_ngram: Optional = None attentions: Optional = None ngram_attentions: Optional = None cross_attentions: Optional = None )

参数

• loss (torch.FloatTensor，形状为(1,)，optional, 当提供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], optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（每层一个，包括嵌入层和每一层的输出），形状为(batch_size, decoder_sequence_length, hidden_size)。

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

• ngram_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（每层一个，包括嵌入层和每一层的输出），形状为(batch_size, ngram * decoder_sequence_length, hidden_size)。

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

• 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 之后，用于计算加权平均值

模型输出的基类，可能还包含过去的键/值（以加速顺序解码）。

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

ProphetNetForCausalLM

class transformers.ProphetNetForCausalLM

<来源>

( config: ProphetNetConfig )

参数

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

ProphetNetModel 的独立解码器部分，顶部带有 lm 头。该模型可用于因果语言建模。该模型继承自 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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.prophetnet.modeling_prophetnet.ProphetNetDecoderLMOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 对于未屏蔽的标记，

  • 对于被屏蔽的标记为 0。

  什么是注意力掩码？

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中：

  • 对于未屏蔽的标记为 1，

  • 0 表示头部被屏蔽。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。选择的掩码值在[0, 1]中：

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中：

  • 对于未屏蔽的标记为 1，

  • 对于被屏蔽的标记为 0。

• 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）。

  • 对于未屏蔽的标记为 1，

  • 对于被屏蔽的标记为 0。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算从左到右的语言建模损失（下一个单词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]中（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（屏蔽），损失仅计算具有标签 n [0, ..., config.vocab_size]的标记

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供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], optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, decoder_sequence_length, hidden_size)的torch.FloatTensor元组。

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

• ngram_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, ngram * decoder_sequence_length, hidden_size)的torch.FloatTensor元组。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递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), optional, 当传递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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_attn_heads, encoder_sequence_length, decoder_sequence_length)的torch.FloatTensor元组。

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

ProphetNetForCausalLM 的前向方法，覆盖了__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("bert-large-uncased")
>>> tokenizer_dec = AutoTokenizer.from_pretrained("microsoft/prophetnet-large-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "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

QDQBERT

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/qdqbert

概述

QDQBERT 模型可以在 Hao Wu、Patrick Judd、Xiaojie Zhang、Mikhail Isaev 和 Paulius Micikevicius 的整数量化用于深度学习推断：原理和实证评估中找到。

论文摘要如下：

量化技术可以减小深度神经网络的大小，并通过利用高吞吐量整数指令来提高推断延迟和吞吐量。在本文中，我们回顾了量化参数的数学方面，并评估了在不同应用领域的广泛神经网络模型上的选择。我们专注于适合由具有高吞吐量整数数学流水线的处理器加速的量化技术。我们还提出了一种 8 位量化的工作流程，能够在所有研究的网络上保持精度在浮点基线的 1%内，包括更难量化的模型，如 MobileNets 和 BERT-large。

此模型由shangz贡献。

使用提示

• QDQBERT 模型向 BERT 模型添加了伪量化操作（QuantizeLinear/DequantizeLinear ops 对）：(i) 线性层输入和权重，(ii) matmul 输入，(iii) 残差添加输入。

• QDQBERT 需要Pytorch 量化工具包的依赖。要安装pip install pytorch-quantization --extra-index-url https://pypi.ngc.nvidia.com

• QDQBERT 模型可以从 HuggingFace BERT 模型的任何检查点（例如bert-base-uncased）加载，并执行量化感知训练/后训练量化。

• 可以在 transformers/examples/research_projects/quantization-qdqbert/找到使用 QDQBERT 模型执行量化感知训练和后训练量化的完整示例，用于 SQUAD 任务。

设置默认量化器

QDQBERT 模型通过Pytorch 量化工具包中的TensorQuantizer向 BERT 添加了伪量化操作（QuantizeLinear/DequantizeLinear ops 对）。TensorQuantizer是用于量化张量的模块，QuantDescriptor定义了张量应该如何量化。有关更多详细信息，请参阅Pytorch 量化工具包用户指南。

在创建 QDQBERT 模型之前，必须设置默认的QuantDescriptor，定义默认的张量量化器。

示例：

>>> import pytorch_quantization.nn as quant_nn
>>> from pytorch_quantization.tensor_quant import QuantDescriptor

>>> # The default tensor quantizer is set to use Max calibration method
>>> input_desc = QuantDescriptor(num_bits=8, calib_method="max")
>>> # The default tensor quantizer is set to be per-channel quantization for weights
>>> weight_desc = QuantDescriptor(num_bits=8, axis=((0,)))
>>> quant_nn.QuantLinear.set_default_quant_desc_input(input_desc)
>>> quant_nn.QuantLinear.set_default_quant_desc_weight(weight_desc)

校准

校准是将数据样本传递给量化器并决定张量的最佳缩放因子的术语。设置张量量化器后，可以使用以下示例来校准模型：

>>> # Find the TensorQuantizer and enable calibration
>>> for name, module in model.named_modules():
...     if name.endswith("_input_quantizer"):
...         module.enable_calib()
...         module.disable_quant()  # Use full precision data to calibrate

>>> # Feeding data samples
>>> model(x)
>>> # ...

>>> # Finalize calibration
>>> for name, module in model.named_modules():
...     if name.endswith("_input_quantizer"):
...         module.load_calib_amax()
...         module.enable_quant()

>>> # If running on GPU, it needs to call .cuda() again because new tensors will be created by calibration process
>>> model.cuda()

>>> # Keep running the quantized model
>>> # ...

导出到 ONNX

导出到 ONNX 的目标是通过TensorRT部署推断。伪量化将被分解为一对 QuantizeLinear/DequantizeLinear ONNX 操作。将 TensorQuantizer 的静态成员设置为使用 Pytorch 自己的伪量化函数后，伪量化模型可以导出到 ONNX，按照torch.onnx中的说明操作。示例：

>>> from pytorch_quantization.nn import TensorQuantizer

>>> TensorQuantizer.use_fb_fake_quant = True

>>> # Load the calibrated model
>>> ...
>>> # ONNX export
>>> torch.onnx.export(...)

资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

• 因果语言建模任务指南

• 掩码语言建模任务指南

• 多项选择任务指南

QDQBertConfig

class transformers.QDQBertConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 use_cache = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — QDQBERT 模型的词汇表大小。定义在调用 QDQBertModel 时可以表示的不同标记数量。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512、1024 或 2048）。

• type_vocab_size (int, optional, defaults to 2) — 在调用 QDQBertModel 时传递的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• is_decoder (bool, optional, defaults to False) — 模型是否用作解码器。如果为 False，则模型用作编码器。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。

这是用于存储 QDQBertModel 配置的配置类。它用于根据指定的参数实例化一个 QDQBERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 BERT bert-base-uncased 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import QDQBertModel, QDQBertConfig

>>> # Initializing a QDQBERT bert-base-uncased style configuration
>>> configuration = QDQBertConfig()

>>> # Initializing a model from the bert-base-uncased style configuration
>>> model = QDQBertModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

QDQBertModel

class transformers.QDQBertModel

< source >

( config add_pooling_layer: bool = True )

参数

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

裸 QDQBERT 模型变压器输出原始隐藏状态，没有特定的头部。

该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

该模型可以作为编码器（仅具有自注意力）以及解码器行为，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need中描述的架构。

为了作为解码器行为，模型需要使用配置中的is_decoder参数初始化为True。要在 Seq2Seq 模型中使用，模型需要使用is_decoder参数和add_cross_attention设置为True进行初始化；然后期望将encoder_hidden_states作为输入传递给前向传递。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 对于未被“掩码”的标记，为 1，

  • 对于被“掩码”的标记，为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

  • 0 对应于句子 A标记。

  • 1 对应于句子 B标记。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被“掩码”。

  • 0 表示头部被“掩码”。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 编码器输入的填充标记索引遮罩，用于避免在填充标记上执行注意力操作。如果模型配置为解码器，则在交叉注意力中使用此遮罩。遮罩值选定为 [0, 1]：

  • not masked 的标记为 1，

  • masked 的标记为 0。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组包含形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的 4 个张量 — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

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

• use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（QDQBertConfig）和输入。

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

• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重是在预训练期间从下一个句子预测（分类）目标中训练的。

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

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

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True，还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中，如果config.is_encoder_decoder=True，还可以选择使用past_key_values输入来加速顺序解码。

QDQBertModel 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertModel.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

QDQBertLMHeadModel

class transformers.QDQBertLMHeadModel

<来源>

( config )

参数

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

带有顶部language modeling头部的 QDQBERT 模型，用于 CLM 微调。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 内：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在 [0, 1] 内：

  • 1 表示头部 未被掩码，

  • 0 表示头部 被掩码。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则此掩码将用于交叉注意力。选择的掩码值在 [0, 1] 内：

  • 1 代表 未被掩码 的标记，

  • 0 代表 被掩码 的标记。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在 [-100, 0, ..., config.vocab_size] 内（参见 input_ids 文档）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签 n [0, ..., config.vocab_size] 的标记。

• past_key_values (tuple(tuple(torch.FloatTensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

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

• use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。

返回

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

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

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

QDQBertLMHeadModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertLMHeadModel, QDQBertConfig
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> config = QDQBertConfig.from_pretrained("bert-base-cased")
>>> config.is_decoder = True
>>> model = QDQBertLMHeadModel.from_pretrained("bert-base-cased", config=config)

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.logits

QDQBertForMaskedLM

class transformers.QDQBertForMaskedLM

< source >

( config )

参数

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

带有顶部语言建模头的 QDQBERT 模型。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

  • 1 表示未被掩码的标记。

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记

返回

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

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（QDQBertConfig）和输入的不同元素。

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

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

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

QDQBertForMaskedLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForMaskedLM.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

QDQBertForSequenceClassification

class transformers.QDQBertForSequenceClassification

< source >

( config )

参数

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

Bert 模型变压器，顶部带有序列分类/回归头（池化输出之上的线性层），例如用于 GLUE 任务。

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

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

forward

< source >

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

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间。

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选在 [0, 1] 之间：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选在范围 [0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这是很有用的，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量中的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量中的 hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1]。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• 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 元组（每层一个）。

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

QDQBertForSequenceClassification 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, QDQBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForSequenceClassification.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = QDQBertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, QDQBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForSequenceClassification.from_pretrained("bert-base-uncased", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = QDQBertForSequenceClassification.from_pretrained(
...     "bert-base-uncased", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

QDQBertForNextSentencePrediction

class transformers.QDQBertForNextSentencePrediction

<来源>

( config )

参数

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

Bert 模型，顶部带有“下一句预测（分类）”头。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.NextSentencePredictorOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor） — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

  什么是输入 ID？

• attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选） — 避免在填充标记索引上执行注意力的蒙版。蒙版值选在 [0, 1] 中：

  • 1 代表“未蒙版”的标记，

  • 0 代表“蒙版”的标记。

  什么是注意力蒙版？

• token_type_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选） — 段标记索引，指示输入的第一部分和第二部分。索引选在 [0, 1] 中：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是 token type IDs?

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是 position IDs?

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool，optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算下一个序列预测（分类）损失的标签。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]中：

  • 0 表示序列 B 是序列 A 的延续，

  • 1 表示序列 B 是一个随机序列。

返回

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

一个 transformers.modeling_outputs.NextSentencePredictorOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（QDQBertConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供next_sentence_label时返回) — 下一个序列预测（分类）损失。

• logits (torch.FloatTensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头部的预测分数（SoftMax 之前的 True/False 连续性分数）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个层的输出）。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

QDQBertForNextSentencePrediction 的前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertForNextSentencePrediction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForNextSentencePrediction.from_pretrained("bert-base-uncased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")

>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1]  # next sentence was random

QDQBertForMultipleChoice

class transformers.QDQBertForMultipleChoice

<来源>

( config )

参数

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

在顶部具有多选分类头的 Bert 模型（顶部是一个线性层和一个 softmax，例如用于 RocStories/SWAG 任务的模型）。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

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

参数

• input_ids（torch.LongTensor，形状为(batch_size, num_choices, sequence_length)）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（torch.FloatTensor，形状为(batch_size, num_choices, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记。

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds（torch.FloatTensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量的第二维度的大小。（参见上面的input_ids）

返回

transformers.modeling_outputs.MultipleChoiceModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（QDQBertConfig）和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, num_choices)) — num_choices是输入张量的第二维度。（参见上面的input_ids）。

  分类得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

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

QDQBertForMultipleChoice 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForMultipleChoice.from_pretrained("bert-base-uncased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

QDQBertForTokenClassification

class transformers.QDQBertForTokenClassification

<来源>

( config )

参数

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

QDQBERT 模型在顶部带有一个标记分类头（隐藏状态输出的顶部线性层），例如用于命名实体识别（NER）任务。

这个模型继承自 PreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

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

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。

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

  什么是输入 ID？

• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被遮罩的令牌，

  • 0 表示被遮罩的令牌。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被遮罩，

  • 0 表示头部被遮罩。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算令牌分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（QDQBertConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — SoftMax 之前的分类分数。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

QDQBertForTokenClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForTokenClassification.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

QDQBertForQuestionAnswering

class transformers.QDQBertForQuestionAnswering

<来源>

( config )

参数

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

带有用于提取问答任务（如 SQuAD）的跨度分类头部的 QDQBERT 模型（在隐藏状态输出之上的线性层，用于计算跨度起始 logits和跨度结束 logits）。

该模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

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

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

  • 1 表示未被 掩码 的标记，

  • 0 表示被 掩码 的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1]：

  • 0 对应于一个 句子 A 的标记，

  • 1 对应于一个 句子 B 的标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在 [0, 1]：

  • 1 表示头部是 未被掩码，

  • 0 表示头部是 被掩码。

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

• start_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记范围开始位置的位置（索引）的标签。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。

• end_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记范围结束位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。

返回

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（QDQBertConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 总跨度抽取损失是起始位置和结束位置的交叉熵之和。

• start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度起始得分（SoftMax 之前）。

• end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层的输出的一个）。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。

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

QDQBertForQuestionAnswering 的前向方法重写了 __call__ 特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用 Module 实例，而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, QDQBertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = QDQBertForQuestionAnswering.from_pretrained("bert-base-uncased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

Qwen2

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/qwen2

概述

Qwen2 是 Qwen 团队推出的大型语言模型新系列。之前，我们发布了 Qwen 系列，包括 Qwen-72B、Qwen-1.8B、Qwen-VL、Qwen-Audio 等。

模型详情

Qwen2 是一个包含不同模型大小的解码器语言模型的系列。对于每个大小，我们发布基础语言模型和对齐的聊天模型。它基于 Transformer 架构，具有 SwiGLU 激活、注意力 QKV 偏置、组查询注意力、滑动窗口注意力和全注意力混合等。此外，我们还有一个适应多种自然语言和代码的改进的分词器。

使用提示

Qwen2-7B-beta和Qwen2-7B-Chat-beta可以在Huggingface Hub上找到

接下来，我们演示如何使用Qwen2-7B-Chat-beta进行推断。请注意，我们已经使用 ChatML 格式进行对话，在此演示中，我们展示了如何利用apply_chat_template来实现这一目的。

>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> device = "cuda" # the device to load the model onto

>>> model = AutoModelForCausalLM.from_pretrained("Qwen2/Qwen2-7B-Chat-beta", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen2/Qwen2-7B-Chat-beta")

>>> prompt = "Give me a short introduction to large language model."

>>> messages = [{"role": "user", "content": prompt}]

>>> text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

>>> model_inputs = tokenizer([text], return_tensors="pt").to(device)

>>> generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512, do_sample=True)

>>> generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)]

>>> response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

Qwen2Config

class transformers.Qwen2Config

<来源>

( vocab_size = 151936 hidden_size = 4096 intermediate_size = 22016 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 32 hidden_act = 'silu' max_position_embeddings = 32768 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True tie_word_embeddings = False rope_theta = 10000.0 use_sliding_window = False sliding_window = 4096 max_window_layers = 28 attention_dropout = 0.0 **kwargs )

参数

• vocab_size（int，可选，默认为 151936）— Qwen2 模型的词汇量。定义了在调用 Qwen2Model 时可以表示的不同标记的数量。

• hidden_size（int，可选，默认为 4096）— 隐藏表示的维度。

• intermediate_size（int，可选，默认为 22016）— MLP 表示的维度。

• num_hidden_layers（int，可选，默认为 32）— Transformer 编码器中的隐藏层数量。

• num_attention_heads（int，可选，默认为 32）— Transformer 编码器中每个注意力层的注意力头数。

• num_key_value_heads（int，可选，默认为 32）— 这是应该用于实现 Grouped Query Attention 的 key_value 头的数量。如果num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention（MHA），如果num_key_value_heads=1，模型将使用 Multi Query Attention（MQA），否则将使用 GQA。将多头检查点转换为 GQA 检查点时，应通过均值池化构建每个组键和值头，以包含该组中所有原始头的平均值。有关更多详细信息，请查看此论文。如果未指定，将默认为32。

• hidden_act（str或function，可选，默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。

• max_position_embeddings（int，可选，默认为 32768）— 该模型可能会使用的最大序列长度。

• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

• rms_norm_eps（float，可选，默认为 1e-06）— rms 归一化层使用的 epsilon。

• use_cache（bool，可选，默认为True）— 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

• tie_word_embeddings（bool，可选，默认为False）— 模型的输入和输出词嵌入是否应该绑定。

• rope_theta（float，可选，默认为 10000.0）— RoPE 嵌入的基本周期。

• use_sliding_window（bool，可选，默认为False）— 是否使用滑动窗口注意力。

• sliding_window（int，可选，默认为 4096）— 滑动窗口注意力（SWA）窗口大小。如果未指定，将默认为4096。

• max_window_layers (int, 可选, 默认为 28) — 使用 SWA（滑动窗口注意力）的层数。底层使用 SWA，而顶层使用完全注意力。

• attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的丢弃比率。

这是配置类，用于存储 Qwen2Model 的配置。它用于根据指定的参数实例化一个 Qwen2 模型，定义模型架构。使用默认值实例化配置将产生类似于 Qwen2-7B-beta Qwen/Qwen2-7B-beta的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import Qwen2Model, Qwen2Config

>>> # Initializing a Qwen2 style configuration
>>> configuration = Qwen2Config()

>>> # Initializing a model from the Qwen2-7B style configuration
>>> model = Qwen2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Qwen2Tokenizer

class transformers.Qwen2Tokenizer

<来源>

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = None eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' clean_up_tokenization_spaces = False split_special_tokens = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• errors (str, 可选, 默认为"replace") — 解码字节为 UTF-8 时要遵循的范例。查看bytes.decode以获取更多信息。

• unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。

• bos_token（str，可选）--序列标记的开头。不适用于此标记器。

• eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。

• pad_token（str，optional，默认为"<|endoftext|>"）--用于填充的令牌，例如，在批处理不同长度的序列时。

• clean_up_tokenization_spaces (bool, 可选, 默认为False) — 模型是否应清除在分词过程中拆分输入文本时添加的空格。对于这个分词器不适用，因为分词不会添加空格。

• split_special_token（bool，optional，默认为False）--在标记化过程中是否应拆分特殊标记。默认行为是不拆分特殊标记。这意味着，如果<|endoftext|>是eos_token，则tokenizer.tokenize("<|endoftext|>") = ['<|endoftext|>']。否则，如果split_special_tokens=True，则tokenizer.tokenize("<|endoftext|>")将被赋予[''<'', ''|'', ''endo'', ''ft'', ''ext'', ''|'', ''>'']。这一论点目前只支持“慢速”标记化器。

构建一个 Qwen2 分词器。基于字节级字节对编码。

与 GPT2Tokenizer 相同，这个分词器已经训练过，将空格视为标记的一部分，因此一个单词会

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import Qwen2Tokenizer

>>> tokenizer = Qwen2Tokenizer.from_pretrained("Qwen/Qwen-tokenizer")
>>> tokenizer("Hello world")["input_ids"]
[9707, 1879]

>>> tokenizer(" Hello world")["input_ids"]
[21927, 1879]

这是预期的。

您不应该使用 GPT2Tokenizer，因为其具有不同的 pretokenization 规则。

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

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

Qwen2TokenizerFast

class transformers.Qwen2TokenizerFast

<来源>

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = None eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

参数

• vocab_file (str, 可选) — 词汇文件的路径。

• merges_file (str, 可选) — 合并文件的路径。

• tokenizer_file (str, 可选) — 包含加载分词器所需的所有内容的tokenizers文件的路径（通常具有.json 扩展名）。

• unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。不适用于此标记器。

• bos_token（str，可选）--序列标记的开头。不适用于此标记器。

• eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。

• pad_token（str，optional，默认为"<|endoftext|>"）--用于填充的令牌，例如，在批处理不同长度的序列时。

构建一个“快速”Qwen2 分词器（由 HuggingFace 的tokenizers库支持）。基于字节级字节对编码。

与 GPT2Tokenizer 相同，这个分词器已经训练过，将空格视为标记的一部分，因此一个单词会

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import Qwen2TokenizerFast

>>> tokenizer = Qwen2TokenizerFast.from_pretrained("Qwen/Qwen-tokenizer")
>>> tokenizer("Hello world")["input_ids"]
[9707, 1879]

>>> tokenizer(" Hello world")["input_ids"]
[21927, 1879]

这是预期的。

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

Qwen2Model

class transformers.Qwen2Model

<来源>

( config: Qwen2Config )

参数

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

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

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个Qwen2DecoderLayer。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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 )

参数

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

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

  什么是输入 ID？

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

  • 1 表示未被“掩盖”的标记，

  • 0 表示被“掩盖”的标记。

  什么是注意力掩码？

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

  如果使用past_key_values，可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

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

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）—预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为config.n_layers的元组的元组（torch.FloatTensor），每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统缓存格式。

  如果使用past_key_values，用户可以选择仅输入最后的input_ids（即不将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递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 而不是普通元组。

Qwen2Model 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

Qwen2ForCausalLM

class transformers.Qwen2ForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未被掩码的标记为 1，

  • 对于被掩码的标记为 0。

  什么是注意力掩码？

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

  如果使用past_key_values，可选择仅输入最后的decoder_input_ids（参见past_key_values）。

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。

  什么是位置 ID？

• past_key_values (Cache或tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 长度为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（那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• 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 of shape (batch_size, sequence_length), optional): 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失（用于下一个标记预测）。

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

• 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)的张量。

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

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

Qwen2ForCausalLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, Qwen2ForCausalLM

>>> model = Qwen2ForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
>>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

Qwen2ForSequenceClassification

class transformers.Qwen2ForSequenceClassification

<来源>

( config )

参数

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

Qwen2 模型变压器，顶部带有序列分类头（线性层）。

Qwen2ForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则会找到每行中不是填充标记的最后一个标记。如果未定义pad_token_id，则会简单地取每行批次中的最后一个值。由于在传递inputs_embeds而不是input_ids时无法猜测填充标记，因此会执行相同操作（取每行批次中的最后一个值）。

此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• 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 表示掩码的标记。

  什么是注意力掩码？

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

  如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（请参见past_key_values）。

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

  • 1 表示头部是未掩码，

  • 0 表示头部是掩码。

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）- 输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

  什么是位置 ID？

• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。

  允许两种格式：

  • 一个 Cache 实例；

  • 元组tuple(torch.FloatTensor)的长度为config.n_layers，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统的缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。

  如果使用了past_key_values，用户可以选择仅输入最后的input_ids（即那些没有将它们的过去键值状态提供给该模型的输入）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型内部的嵌入查找矩阵，这将非常有用。

• use_cache（bool，可选）- 如果设置为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 of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

Qwen2ForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。