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

见返回张量下的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