PLBart
概述
PLBART 模型由 Wasi Uddin Ahmad、Saikat Chakraborty、Baishakhi Ray、Kai-Wei Chang 在 Unified Pre-training for Program Understanding and Generation 中提出。这是一个类似 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) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。 - attention_dropout (
float, 可选, 默认值为 0.1) — 注意力概率的丢弃率。 - activation_dropout (
float, 可选, 默认值为 0.0) — 全连接层内部激活的丢弃率。 - classifier_dropout (
float, 可选, 默认值为 0.0) — 分类器的丢弃率。 - max_position_embeddings (
int, 可选, 默认值为 1024) — 此模型可能使用的最大序列长度。通常将其设置为一个较大的值，以防万一（例如，512 或 1024 或 2048）。 - init_std (
float, 可选, 默认值为 0.02) — 初始化所有权重矩阵的截断正态分布初始化器的标准差。 - encoder_layerdrop (
float, 可选, 默认值为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - decoder_layerdrop (
float, 可选, 默认值为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - scale_embedding (
bool, 可选, 默认值为True) — 通过除以 sqrt(d_model) 来缩放嵌入。
这是用于存储 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.configPLBartTokenizer
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 clean_up_tokenization_spaces = True **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: 一元模型的采样参数。对于 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 结果中采样。nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（格）中采样。
alpha: 一元采样的平滑参数，以及 BPE-dropout 的合并操作的 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 ) → List[int]
通过串联和添加特殊标记，从序列或一对序列构建用于序列分类任务的模型输入。PLBART 序列具有以下格式，其中 X 表示序列
input_ids(用于编码器)X [eos, src_lang_code]decoder_input_ids: (用于解码器)X [eos, tgt_lang_code]
从不使用 BOS。序列对不是预期的用例，但它们将在没有分隔符的情况下进行处理。
PLBartModel
class transformers.PLBartModel
< source >( config: PLBartConfig )
参数
- config (PLBartConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型相关的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
PLBART 模型的裸模型，输出原始隐藏状态，顶部没有特定的头部。 此模型继承自 PreTrainedModel。 检查超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
< source >( 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 ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 默认情况下，如果您提供填充，填充将被忽略。索引可以使用 AutoTokenizer 或
PLBartMultiTokenizer获取，具体取决于检查点。 查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意的掩码。 在[0, 1]中选择的掩码值：- 1 表示未屏蔽的标记，
- 0 表示屏蔽的标记。
- decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列的词语在词表中的索引。索引可使用 AutoTokenizer 或
PLBartMultiTokenizer获取，具体取决于检查点。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。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 表示头部未被掩码，
- 0 表示头部被掩码。
- 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时返回):tuple(torch.FloatTensor)的元组，长度为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输入）加速顺序解码。如果使用
past_key_values，用户可以选择性地仅输入最后一个decoder_input_ids（其过去键值状态未提供给此模型）的形状为(batch_size, 1)，而不是所有decoder_input_ids的形状为(batch_size, sequence_length)。 - 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 而不是普通元组。
返回值
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形状为(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时返回) —tuple(torch.FloatTensor)的元组，长度为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_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出处的隐藏状态，加上可选的初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 Softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出处的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
The 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_statePLBartForConditionalGeneration
class transformers.PLBartForConditionalGeneration
< source >( config: PLBartConfig )
参数
- config (PLBartConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
带语言建模头的 PLBART 模型。可用于代码到文本、文本到代码和代码到代码。该模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
< source >( 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 ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。如果提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 或
PLBartMultiTokenizer（取决于检查点）获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 - attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 掩码，用于避免在填充标记索引上执行注意力。在[0, 1]中选择掩码值：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 解码器输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 或
PLBartMultiTokenizer（取决于检查点）获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。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 of shape
(batch_size, target_sequence_length), optional): 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将在默认情况下使用。 - head_mask (
torch.Tensor形状为(encoder_layers, encoder_attention_heads)，可选) — 用于将编码器中注意力模块的选定头部设为零的掩码。掩码值选择在[0, 1]中：- 1 表示头部未被掩码
- 0 表示头部被掩码
- decoder_head_mask (
torch.Tensor形状为(decoder_layers, decoder_attention_heads)，可选) — 用于将解码器中注意力模块的选定头部设为零的掩码。掩码值选择在[0, 1]中：- 1 表示头部未被掩码
- 0 表示头部被掩码
- cross_attn_head_mask ( — 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(那些没有向该模型提供过去键值状态的) 而不是所有形状为(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 (
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时返回) —tuple(torch.FloatTensor)的元组，长度为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_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 Softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
The 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
< source >( config: PLBartConfig **kwargs )
参数
- config (PLBartConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类/头部的 PLBart 模型（在池化输出之上有一个线性层）例如用于代码分类。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
< source >( 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 ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 或
PLBartMultiTokenizer获取，具体取决于检查点。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意的掩码。在[0, 1]中选择的掩码值：- 1 表示未屏蔽的标记，
- 0 表示屏蔽的标记。
- decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 或
PLBartMultiTokenizer获取，具体取决于检查点。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。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 表示未屏蔽的头部，
- 0 表示屏蔽的头部。
- 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)), optional, returned when
use_cache=Trueis passed or whenconfig.use_cache=True): 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（其过去键值状态未提供给此模型），而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds ( — obj:torch.FloatTensor 形状为
(batch_size, sequence_length, hidden_size), optional): 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量（而不是模型的内部嵌入查找矩阵）有更多控制权，这将很有用。 - decoder_inputs_embeds ( — obj:torch.FloatTensor 形状为
(batch_size, target_sequence_length, hidden_size), optional): 可选地，您可以选择直接传递嵌入表示，而不是传递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,), optional) — 用于计算序列分类/回归损失的标签。索引应在[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 (
torch.FloatTensor形状为(1,), optional, 返回时提供label) — 分类（或回归，如果config.num_labels==1）损失。 -
logits (
torch.FloatTensor形状为(batch_size, config.num_labels)) — 分类（或回归，如果config.num_labels==1）分数（在 SoftMax 之前）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，在传入use_cache=True或config.use_cache=True时返回) —tuple(torch.FloatTensor)的元组，长度为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_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 Softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 Softmax 之后，用于计算自注意力头中的加权平均值。
The PLBartForSequenceClassification forward method, overrides the __call__ special method.
尽管正向传递的配方需要在此函数内定义，但应该在之后调用 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).lossPLBartForCausalLM
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 ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果您提供填充，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意的掩码。掩码值在[0, 1]中选择：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- 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形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示未掩码的头部，
- 0 表示掩码的头部。
- cross_attn_head_mask (
torch.Tensor形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示未掩码的头部，
- 0 表示掩码的头部。
- past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传入use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。 当模型在序列到序列模型中用作解码器时，仅需要这两个额外张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - labels (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。 索引应在[0, ..., config.vocab_size]或 -100 中（参见input_ids文档字符串）。 索引设置为-100的标记被忽略（掩码），仅对标签在[0, ..., config.vocab_size]中的标记计算损失。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。- 1 表示 未掩码 的标记，
- 0 表示 掩码 的标记。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关详细信息，请参见返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关详细信息，请参见返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 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形状为(1,), 可选, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。 -
logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（在 SoftMax 之前每个词汇标记的分数）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入层的输出，如果模型具有嵌入层，加一个用于每一层的输出）形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力softmax之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。交叉注意力softmax之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传入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