Transformers 文档
MBart 和 MBart-50
并获得增强的文档体验
开始使用
MBart 和 MBart-50
MBart 概述
MBart 模型在 用于神经机器翻译的多语言去噪预训练 一文中被提出，作者是 Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer。
根据摘要，MBART 是一个序列到序列的去噪自编码器，它使用 BART 目标函数，在多种语言的大规模单语语料库上进行了预训练。 mBART 是首批通过在多种语言中对完整文本进行去噪来预训练完整序列到序列模型的方法之一，而以前的方法仅侧重于编码器、解码器或重建部分文本。
此模型由 valhalla 贡献。作者的代码可以在 这里 找到
MBart 的训练
MBart 是一个多语言编码器-解码器（序列到序列）模型，主要用于翻译任务。 由于该模型是多语言的，因此它期望序列采用不同的格式。 特殊的语言 ID 令牌被添加到源文本和目标文本中。 源文本格式为 X [eos, src_lang_code]，其中 X 是源文本。 目标文本格式为 [tgt_lang_code] X [eos]。 从不使用 bos。
常规的 call() 将对作为第一个参数或使用 text 关键字传递的源文本格式进行编码，并对使用 text_label 关键字参数传递的目标文本格式进行编码。
- 监督式训练
>>> from transformers import MBartForConditionalGeneration, MBartTokenizer
>>> tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-en-ro", src_lang="en_XX", tgt_lang="ro_RO")
>>> example_english_phrase = "UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_romanian = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_romanian, return_tensors="pt")
>>> model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-en-ro")
>>> # forward pass
>>> model(**inputs)生成
在生成目标文本时，将
decoder_start_token_id设置为目标语言 ID。 以下示例展示了如何使用 facebook/mbart-large-en-ro 模型将英语翻译成罗马尼亚语。
>>> from transformers import MBartForConditionalGeneration, MBartTokenizer
>>> tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-en-ro", src_lang="en_XX")
>>> article = "UN Chief Says There Is No Military Solution in Syria"
>>> inputs = tokenizer(article, return_tensors="pt")
>>> translated_tokens = model.generate(**inputs, decoder_start_token_id=tokenizer.lang_code_to_id["ro_RO"])
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
"Şeful ONU declară că nu există o soluţie militară în Siria"MBart-50 概述
MBart-50 在 使用可扩展的多语言预训练和微调进行多语言翻译 论文中被介绍，作者是 Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan。 MBart-50 是通过扩展原始 mbart-large-cc25 检查点的嵌入层，为额外的 25 个语言令牌随机初始化向量，然后在 50 种语言上进行预训练而创建的。
根据摘要
可以通过多语言微调创建多语言翻译模型。 预训练模型不是在一个方向上进行微调，而是在多个方向上同时进行微调。 它表明，预训练模型可以扩展到包含其他语言，而不会损失性能。 多语言微调平均比最强的基线（从头开始的多语言或双语微调）提高了 1 个 BLEU，同时平均比从头开始的双语基线提高了 9.3 个 BLEU。
MBart-50 的训练
MBart-50 的文本格式与 mBART 略有不同。 对于 MBart-50，语言 ID 令牌用作源文本和目标文本的前缀，即文本格式为 [lang_code] X [eos]，其中 lang_code 是源文本的源语言 ID 和目标文本的目标语言 ID，其中 X 分别是源文本或目标文本。
MBart-50 有其自己的分词器 MBart50Tokenizer。
- 监督式训练
from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50")
tokenizer = MBart50TokenizerFast.from_pretrained("facebook/mbart-large-50", src_lang="en_XX", tgt_lang="ro_RO")
src_text = " UN Chief Says There Is No Military Solution in Syria"
tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
model(**model_inputs) # forward pass生成
要使用 mBART-50 多语言翻译模型进行生成，
eos_token_id用作decoder_start_token_id，并且强制将目标语言 ID 作为第一个生成的令牌。 要强制将目标语言 ID 作为第一个生成的令牌，请将 forced_bos_token_id 参数传递给 generate 方法。 以下示例展示了如何使用 facebook/mbart-50-large-many-to-many 检查点在印地语到法语和阿拉伯语到英语之间进行翻译。
from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
article_hi = "संयुक्त राष्ट्र के प्रमुख का कहना है कि सीरिया में कोई सैन्य समाधान नहीं है"
article_ar = "الأمين العام للأمم المتحدة يقول إنه لا يوجد حل عسكري في سوريا."
model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50-many-to-many-mmt")
tokenizer = MBart50TokenizerFast.from_pretrained("facebook/mbart-large-50-many-to-many-mmt")
# translate Hindi to French
tokenizer.src_lang = "hi_IN"
encoded_hi = tokenizer(article_hi, return_tensors="pt")
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.lang_code_to_id["fr_XX"])
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
# => "Le chef de l 'ONU affirme qu 'il n 'y a pas de solution militaire en Syria."
# translate Arabic to English
tokenizer.src_lang = "ar_AR"
encoded_ar = tokenizer(article_ar, return_tensors="pt")
generated_tokens = model.generate(**encoded_ar, forced_bos_token_id=tokenizer.lang_code_to_id["en_XX"])
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
# => "The Secretary-General of the United Nations says there is no military solution in Syria."文档资源
MBartConfig
class transformers.MBartConfig
< source >( vocab_size = 50265 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 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 classifier_dropout = 0.0 scale_embedding = False pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 forced_eos_token_id = 2 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 50265) — MBART 模型的词汇表大小。 定义了在调用 MBartModel 或 TFMBartModel 时传递的inputs_ids可以表示的不同令牌的数量。 - d_model (
int, 可选, 默认为 1024) — 层和池化器层的维度。 - encoder_layers (
int, 可选, 默认为 12) — 编码器层数。 - decoder_layers (
int, 可选, 默认为 12) — 解码器层数。 - encoder_attention_heads (
int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - decoder_attention_heads (
int, 可选, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。 - decoder_ffn_dim (
int, 可选, 默认为 4096) — 解码器中“中间”（通常称为前馈）层的维度。 - encoder_ffn_dim (
int, 可选, 默认为 4096) — 解码器中“中间”（通常称为前馈）层的维度。 - activation_function (
str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - dropout (
float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 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) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - 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, 可选, 默认为False) — 通过除以 sqrt(d_model) 来缩放嵌入。 - use_cache (
bool, optional, defaults toTrue) — Whether or not the model should return the last key/values attentions (not used by all models) - forced_eos_token_id (
int, optional, defaults to 2) — The id of the token to force as the last generated token whenmax_lengthis reached. Usually set toeos_token_id.
This is the configuration class to store the configuration of a MBartModel。它用于根据指定的参数实例化 MBART 模型，定义模型架构。使用默认值实例化配置将产生与 MBART facebook/mbart-large-cc25 架构类似的配置。
Configuration objects inherit from PretrainedConfig 并且可以用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import MBartConfig, MBartModel
>>> # Initializing a MBART facebook/mbart-large-cc25 style configuration
>>> configuration = MBartConfig()
>>> # Initializing a model (with random weights) from the facebook/mbart-large-cc25 style configuration
>>> model = MBartModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMBartTokenizer
class transformers.MBartTokenizer
< source >( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' tokenizer_file = None src_lang = None tgt_lang = None sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None additional_special_tokens = None **kwargs )
构建 MBART 分词器。
改编自 RobertaTokenizer 和 XLNetTokenizer。基于 SentencePiece。
对于源语言文档，分词方法是 示例 ( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → 参数 返回值
包含适当特殊 token 的 输入 ID 列表。 通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。MBART 序列具有以下格式，其中 从不使用 BOS。序列对不是预期的用例，但它们将被处理，不带分隔符。<tokens> <eos> <language code>，对于目标语言文档，分词方法是 `>>> from transformers import MBartTokenizer
>>> tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-en-ro", src_lang="en_XX", tgt_lang="ro_RO")
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_romanian = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_romanian, return_tensors="pt")build_inputs_with_special_tokens
< source > List[int]List[int]) — 将在其上添加特殊 token 的 ID 列表。 List[int], optional) — 序列对的可选的第二个 ID 列表。 List[int]X 代表序列input_ids (用于编码器) X [eos, src_lang_code]decoder_input_ids: (用于解码器) X [eos, tgt_lang_code]
MBartTokenizerFast
class transformers.MBartTokenizerFast
< source >( vocab_file = None tokenizer_file = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' src_lang = None tgt_lang = None additional_special_tokens = None **kwargs )
构建一个“快速” MBART 分词器（由 HuggingFace 的 tokenizers 库支持）。基于 BPE。
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
对于源语言文档，分词方法是 示例 ( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → 参数 返回值
包含适当特殊 token 的 输入 ID 列表。 通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。特殊 token 取决于调用的 set_lang。 MBART 序列具有以下格式，其中 从不使用 BOS。序列对不是预期的用例，但它们将被处理，不带分隔符。 ( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → 从传递的两个序列创建一个 mask，用于序列对分类任务。mBART 不使用 token 类型 ID，因此返回零列表。 将特殊 token 重置为源语言设置。无前缀和后缀=[eos, src_lang_code]。 将特殊 token 重置为目标语言设置。无前缀和后缀=[eos, tgt_lang_code]。<tokens> <eos> <language code>，对于目标语言文档，分词方法是 `>>> from transformers import MBartTokenizerFast
>>> tokenizer = MBartTokenizerFast.from_pretrained(
... "facebook/mbart-large-en-ro", src_lang="en_XX", tgt_lang="ro_RO"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_romanian = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_romanian, return_tensors="pt")build_inputs_with_special_tokens
< source > List[int]List[int]) — 将在其上添加特殊 token 的 ID 列表。 List[int], optional) — 序列对的可选的第二个 ID 列表。 List[int]X 代表序列input_ids (用于编码器) X [eos, src_lang_code]decoder_input_ids: (用于解码器) X [eos, tgt_lang_code]create_token_type_ids_from_sequences
< source > List[int]
MBart50Tokenizer
class transformers.MBart50Tokenizer
< source >( vocab_file src_lang = None tgt_lang = None eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - src_lang (
str, optional) — 代表源语言的字符串。 - tgt_lang (
str, optional) — 代表目标语言的字符串。 - eos_token (
str, optional, defaults to"</s>") — 序列结束符 token，默认为"</s>"。 - sep_token (
str, optional, defaults to"</s>") — 分隔符 token，用于从多个序列构建一个序列时，例如，用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - cls_token (
str, optional, defaults to"<s>") — 分类符 token，用于进行序列分类（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建序列时，它是序列的第一个 token，默认为"<s>"。 - unk_token (
str, optional, defaults to"<unk>") — 未知 token。词汇表中没有的 token 无法转换为 ID，而是设置为此 token，默认为"<unk>"。 - pad_token (
str, optional, defaults to"<pad>") — 填充 token，例如，当批量处理不同长度的序列时使用，默认为"<pad>"。 - mask_token (
str, optional, defaults to"<mask>") — 用于掩码值的 token。这是使用掩码语言建模训练此模型时使用的 token。这是模型将尝试预测的 token，默认为"<mask>"。 - sp_model_kwargs (
dict, optional) — 将传递给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 是无限的，并使用前向滤波和后向采样算法从所有假设（lattice）中采样。
-
alpha: unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
-
构建 MBart50 tokenizer。基于 SentencePiece。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
示例
>>> from transformers import MBart50Tokenizer
>>> tokenizer = MBart50Tokenizer.from_pretrained("facebook/mbart-large-50", src_lang="en_XX", tgt_lang="ro_RO")
>>> src_text = " UN Chief Says There Is No Military Solution in Syria"
>>> tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
>>> # model(**model_inputs) should workbuild_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
参数
- token_ids_0 (
List[int]) — 将向其添加特殊 token 的 ID 列表。 - token_ids_1 (
List[int], optional) — 序列对的可选的第二个 ID 列表。
返回值
List[int]
包含适当特殊 token 的 输入 ID 列表。
通过连接和添加特殊 token，从一个序列或一对序列构建模型输入，用于序列分类任务。MBART-50 序列具有以下格式，其中 X 表示序列
input_ids(对于编码器)[src_lang_code] X [eos]labels: (对于解码器)[tgt_lang_code] X [eos]
从不使用 BOS。序列对不是预期的用例，但它们将被处理，不带分隔符。
将一系列 token （字符串）转换为单个字符串。
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊 token 的 token 列表中检索序列 ID。当使用 tokenizer prepare_for_model 方法添加特殊 token 时，将调用此方法。
将特殊 token 重置为源语言设置。prefix=[src_lang_code] 和 suffix=[eos]。
将特殊 token 重置为目标语言设置。prefix=[tgt_lang_code] 和 suffix=[eos]。
MBart50TokenizerFast
class transformers.MBart50TokenizerFast
< source >( vocab_file = None src_lang = None tgt_lang = None tokenizer_file = None eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - src_lang (
str, optional) — 代表源语言的字符串。 - tgt_lang (
str, optional) — 代表目标语言的字符串。 - eos_token (
str, optional, defaults to"</s>") — 序列结束符 token，默认为"</s>"。 - sep_token (
str, optional, defaults to"</s>") — 分隔符 token，用于从多个序列构建一个序列时，例如，用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token，默认为"</s>"。 - cls_token (
str, optional, defaults to"<s>") — 分类符 token，用于进行序列分类（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建序列时，它是序列的第一个 token，默认为"<s>"。 - unk_token (
str, optional, defaults to"<unk>") — 未知 token。词汇表中没有的 token 无法转换为 ID，而是设置为此 token，默认为"<unk>"。 - pad_token (
str, optional, defaults to"<pad>") — 填充 token，例如，当批量处理不同长度的序列时使用，默认为"<pad>"。 - mask_token (
str, optional, defaults to"<mask>") — 用于遮蔽值的 token。 这是使用掩码语言建模训练此模型时使用的 token。 这是模型将尝试预测的 token。
为 mBART-50 构建 “fast” MBART tokenizer（由 HuggingFace 的 tokenizers 库支持）。 基于 BPE。
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
示例
>>> from transformers import MBart50TokenizerFast
>>> tokenizer = MBart50TokenizerFast.from_pretrained("facebook/mbart-large-50", src_lang="en_XX", tgt_lang="ro_RO")
>>> src_text = " UN Chief Says There Is No Military Solution in Syria"
>>> tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
>>> # model(**model_inputs) should workbuild_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
参数
- token_ids_0 (
List[int]) — 特殊 token 将被添加到的 ID 列表。 - token_ids_1 (
List[int], optional) — 序列对的可选第二个 ID 列表。
返回值
List[int]
包含适当特殊 token 的 输入 ID 列表。
通过连接和添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。特殊 token 取决于调用的 set_lang。
MBART-50 序列具有以下格式，其中 X 代表序列
input_ids(对于编码器)[src_lang_code] X [eos]labels: (对于解码器)[tgt_lang_code] X [eos]
从不使用 BOS。序列对不是预期的用例，但它们将被处理，不带分隔符。
将特殊 token 重置为源语言设置。prefix=[src_lang_code] 和 suffix=[eos]。
将特殊 token 重置为目标语言设置。 prefix=[src_lang_code] 和 suffix=[eos]。
MBartModel
class transformers.MBartModel
< source >( config: MBartConfig )
参数
- config (MBartConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 MBART 模型输出原始隐藏状态，顶部没有任何特定的 head。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), optional) — 掩码，以避免对 padding token 索引执行 attention。 在[0, 1]中选择的掩码值：- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length), optional) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID token 作为
decoder_input_ids生成的起始 token，该 token 根据源语言和目标语言而变化，例如 en_XX 为 25004，de_DE 为 25003。 如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过按照论文中的去噪预训练将input_ids向右移动来创建此张量。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 padding token。 默认情况下，也将使用因果掩码。 - head_mask (
torch.Tensor，形状为(encoder_layers, encoder_attention_heads), optional) — 掩码，用于使编码器中 attention 模块的选定 head 无效。 在[0, 1]中选择的掩码值：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), optional) — 掩码，用于使解码器中 attention 模块的选定 head 无效。 在[0, 1]中选择的掩码值：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), optional) — 掩码，用于使解码器中 cross-attention 模块的选定 head 无效。 在[0, 1]中选择的掩码值：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), optional) — 元组由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size), optional) 是编码器最后一层的输出处的隐藏状态序列。 在解码器的 cross-attention 中使用。 - 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)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些隐藏状态可以用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), optional) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - decoder_inputs_embeds (
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 而不是普通的元组。
返回值
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含取决于配置 (MBartConfig) 和输入的各种元素。
-
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)), 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, 当传递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 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出一个，加上每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
MBartModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, MBartModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = MBartModel.from_pretrained("facebook/mbart-large-cc25")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateMBartForConditionalGeneration
class transformers.MBartForConditionalGeneration
< source >( config: MBartConfig )
参数
- config (MBartConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 MBART 模型。在微调预训练模型后，可用于摘要。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, optional) — 掩码，用于避免在填充标记索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, optional) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID 标记作为
decoder_input_ids生成的起始标记，该标记因源语言和目标语言而异，例如，en_XX 为 25004，de_DE 为 25003。如果使用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, optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，也将使用因果掩码。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor, optional) — 掩码，用于使编码器中注意力模块的选定头无效。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, optional) — 掩码，用于使解码器中注意力模块的选定头无效。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, optional) — 掩码，用于使解码器中交叉注意力模块的选定头无效。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), optional) — 元组由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成，形状为(batch_size, sequence_length, hidden_size)的last_hidden_state, optional) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。 - 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输入）加速顺序解码。如果使用
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, optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - 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 而不是普通元组。 - 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 时），其中包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供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, 当传递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 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出一个，加上每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
MBartForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
翻译示例
>>> from transformers import AutoTokenizer, MBartForConditionalGeneration
>>> model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-en-ro")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-en-ro")
>>> example_english_phrase = "42 is the answer"
>>> inputs = tokenizer(example_english_phrase, return_tensors="pt")
>>> # Translate
>>> generated_ids = model.generate(**inputs, num_beams=4, max_length=5)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'42 este răspuns'掩码填充示例
>>> from transformers import AutoTokenizer, MBartForConditionalGeneration
>>> model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> # de_DE is the language symbol id <LID> for German
>>> TXT = "</s> Meine Freunde sind <mask> nett aber sie essen zu viel Kuchen. </s> de_DE"
>>> 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()
['nett', 'sehr', 'ganz', 'nicht', 'so']MBartForQuestionAnswering
class transformers.MBartForQuestionAnswering
< source >( config )
参数
- config (MBartConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
MBART 模型，顶部带有跨度分类头，用于执行抽取式问答任务，例如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Tensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.List[torch.FloatTensor]] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 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 表示已掩码的标记。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID 标记作为
decoder_input_ids生成的起始标记，该标记因源语言和目标语言而异，例如，en_XX 为 25004，de_DE 为 25003。如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过按照论文将input_ids向右移动以进行去噪预训练来创建此张量。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad 标记。默认情况下，也将使用因果掩码。 - 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 (
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 (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.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，则用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这将非常有用。 - 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, 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 而不是普通元组。 - start_positions (
torch.LongTensor，形状为(batch_size,)，optional) — 用于计算 token 分类损失的带标签跨度开始位置（索引）的标签。 位置被限制在序列的长度（sequence_length）内。 序列之外的位置不计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，optional) — 用于计算 token 分类损失的带标签跨度结束位置（索引）的标签。 位置被限制在序列的长度（sequence_length）内。 序列之外的位置不计入损失计算。
返回值
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False，或者当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵损失之和。 -
start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度开始得分（在 SoftMax 之前）。 -
end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束得分（在 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, 当传递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 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出一个，加上每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
MBartForQuestionAnswering forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, MBartForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = MBartForQuestionAnswering.from_pretrained("facebook/mbart-large-cc25")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.lossMBartForSequenceClassification
class transformers.MBartForSequenceClassification
< source >( config: MBartConfig **kwargs )
参数
- config (MBartConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 请查看 from_pretrained() 方法来加载模型权重。
MBart 模型，顶部带有序列分类/头（池化输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 默认情况下，如果您提供填充，则填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，optional) — 掩码，以避免对填充 token 索引执行注意力。 掩码值在[0, 1]中选择：- 1 表示 token 未被掩码，
- 0 表示 token 已被掩码。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，optional) — 词汇表中解码器输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID token 作为
decoder_input_ids生成的起始 token，该 token 因源语言和目标语言而异，例如 en_XX 为 25004，de_DE 为 25003。 如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过按照论文将input_ids向右移动来为去噪预训练创建此张量。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length)，optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充 token。 默认情况下，还将使用因果掩码。 - head_mask (
torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，optional) — 用于使编码器中注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头已被掩码。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 用于使解码器中注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头已被掩码。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 用于使解码器中交叉注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头已被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)，optional) — 元组由 (last_hidden_state，optional:hidden_states，optional:attentions) 组成，形状为(batch_size, sequence_length, hidden_size)的last_hidden_state，optional) 是编码器最后一层输出端的隐藏状态序列。 在解码器的交叉注意力中使用。 - 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输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的），形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - decoder_inputs_embeds (
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 时），其中包含取决于配置 (MBartConfig) 和输入的各种元素。
-
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)), 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, 当传递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 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出一个，加上每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
MBartForSequenceClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, MBartForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = MBartForSequenceClassification.from_pretrained("facebook/mbart-large-cc25")
>>> 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 = MBartForSequenceClassification.from_pretrained("facebook/mbart-large-cc25", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, MBartForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = MBartForSequenceClassification.from_pretrained("facebook/mbart-large-cc25", 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 = MBartForSequenceClassification.from_pretrained(
... "facebook/mbart-large-cc25", 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).lossMBartForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.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)，optional) — 掩码，以避免在填充标记索引上执行注意力机制。 掩码值在[0, 1]中选择：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- encoder_hidden_states (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 编码器最后一层的输出处的隐藏状态序列。 如果模型配置为解码器，则在交叉注意力机制中使用。 - encoder_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 掩码，以避免对编码器输入的填充标记索引执行注意力机制。 如果模型配置为解码器，则此掩码在交叉注意力机制中使用。 掩码值在[0, 1]中选择： - head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 掩码，用于使注意力模块的选定头无效。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 掩码，用于使交叉注意力模块的选定头无效。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- 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输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。 索引应在[0, ..., config.vocab_size]或 -100 中（请参阅input_ids文档字符串）。 索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。 - use_cache (
bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- 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 时），其中包含取决于配置 (MBartConfig) 和输入的各种元素。
-
loss (
torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 语言建模损失（用于预测下一个标记）。 -
logits (
torch.FloatTensor，形状为(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)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) —torch.FloatTensor元组的元组，长度为config.n_layers，每个元组包含自注意力层和交叉注意力层的缓存键、值状态（如果模型用于编码器-解码器设置中）。仅当config.is_decoder = True时相关。包含预先计算的隐藏状态（注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。
示例
>>> from transformers import AutoTokenizer, MBartForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = MBartForCausalLM.from_pretrained("facebook/mbart-large-cc25", 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
TrueTFMBartModel
class transformers.TFMBartModel
< source >( config: MBartConfig *inputs **kwargs )
参数
- config (MBartConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸MBART模型，输出原始隐藏状态，顶部没有任何特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解所有与常规用法和行为相关的内容。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 之类的方法时，事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个输入张量，与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩蔽，
- 0 表示标记被掩蔽。
- decoder_input_ids (
tf.Tensor，形状为(batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID 标记作为
decoder_input_ids生成的起始标记，该标记根据源语言和目标语言而变化，例如 en_XX 为 25004，de_DE 为 25003。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（参见past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过将input_ids向右移动来创建此张量，以进行遵循论文的去噪预训练。 - decoder_attention_mask (
tf.Tensor，形状为(batch_size, target_sequence_length), 可选) — 将默认创建并忽略填充标记。 不建议在大多数用例中设置此项。 - decoder_position_ids (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个解码器输入序列标记的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示头部未被掩蔽，
- 0 表示头部被掩蔽。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示头部未被掩蔽，
- 0 表示头部被掩蔽。
- cross_attn_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示头部未被掩蔽，
- 0 表示头部被掩蔽。
- encoder_outputs (
tf.FloatTensor, 可选) — 编码器最后一层输出的隐藏状态。 用于解码器的交叉注意力。 形状为(batch_size, sequence_length, hidden_size)的序列是 - past_key_values (
Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含注意力模块的预计算键和值隐藏状态。 可用于加速解码。 如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool, 可选, 默认为True) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 在训练期间设置为False，在生成期间设置为True - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
返回值
transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
List[tf.Tensor], 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器的预计算隐藏状态（注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
TFMBartModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFMBartModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = TFMBartModel.from_pretrained("facebook/mbart-large-cc25")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFMBartForConditionalGeneration
类 transformers.TFMBartForConditionalGeneration
< 源码 >( config *inputs **kwargs )
参数
- config (MBartConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
带有语言建模头的 MBART 模型。微调预训练模型后可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解所有与常规用法和行为相关的内容。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 之类的方法时，事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids的单个张量，没有其他内容：model(input_ids) - 长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个输入张量，与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< 源码 >( input_ids: TFModelInputType = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[TFBaseModelOutput] = None past_key_values: Tuple[Tuple[tf.Tensor]] = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor，形状为({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形状为({0})，可选) — 掩码，用于避免在填充标记索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示标记未被掩码，
- 0 表示标记被掩码。
- decoder_input_ids (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
MBart 使用特定的语言 ID 标记作为
decoder_input_ids生成的起始标记，该标记根据源语言和目标语言而变化，例如，en_XX 为 25004，de_DE 为 25003。 如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文中的方法。 - decoder_attention_mask (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 默认情况下将生成，并忽略填充标记。 不建议在大多数用例中设置此项。 - decoder_position_ids (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 解码器输入序列中每个标记在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- cross_attn_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使交叉注意力模块的选定头无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- encoder_outputs (
tf.FloatTensor，可选) — 编码器最后一层输出的隐藏状态。 在解码器的交叉注意力中使用。 形状为(batch_size, sequence_length, hidden_size)的序列是 - past_key_values (
Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含注意力块的预计算键和值隐藏状态。 可用于加速解码。 如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。 - use_cache (
bool，可选，默认为True) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 在训练期间设置为False，在生成期间设置为True - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回的张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回的张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。 索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。 索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
返回值
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
loss (
tf.Tensor，形状为(n,)，可选，当提供labels时返回，其中 n 是非掩码标签的数量) — 语言建模损失。 -
logits (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测得分（SoftMax 之前每个词汇表标记的得分）。 -
past_key_values (
List[tf.Tensor], 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器的预计算隐藏状态（注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
TFMBartForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
翻译示例
>>> from transformers import AutoTokenizer, TFMBartForConditionalGeneration
>>> model = TFMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-en-ro")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-en-ro")
>>> example_english_phrase = "42 is the answer"
>>> inputs = tokenizer(example_english_phrase, return_tensors="tf")
>>> # Translate
>>> generated_ids = model.generate(**inputs, num_beams=4, max_length=5)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'42 este răspuns'掩码填充示例
>>> from transformers import AutoTokenizer, TFMBartForConditionalGeneration
>>> import tensorflow as tf
>>> model = TFMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> # de_DE is the language symbol id <LID> for German
>>> TXT = "</s> Meine Freunde sind <mask> nett aber sie essen zu viel Kuchen. </s> de_DE"
>>> input_ids = tokenizer([TXT], add_special_tokens=False, return_tensors="tf")["input_ids"]
>>> logits = model(input_ids).logits
>>> masked_index = tf.where(input_ids[0] == tokenizer.mask_token_id)[0, 0]
>>> probs = tf.nn.softmax(logits[0, masked_index], axis=0)
>>> values, predictions = tf.math.top_k(probs, 5)
>>> tokenizer.decode(predictions).split()
['nett', 'sehr', 'ganz', 'nicht', 'so']FlaxMBartModel
class transformers.FlaxMBartModel
< source >( config: MBartConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (MBartConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
- dtype (
jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16(在 GPU 上) 和jax.numpy.bfloat16(在 TPU 上) 之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
裸MBart模型转换器输出原始隐藏状态，顶部没有任何特定的head。此模型继承自 FlaxPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝head等）。
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参阅 Flax 文档，了解与常规用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray, 形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray, 形状为(batch_size, sequence_length), 可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。
- decoder_input_ids (
jnp.ndarray, 形状为(batch_size, target_sequence_length), 可选) — 词汇表中 decoder 输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过将input_ids向右移动以进行去噪预训练（遵循论文）来创建此张量。 - decoder_attention_mask (
jnp.ndarray, 形状为(batch_size, target_sequence_length), 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad tokens。 默认情况下，也将使用因果 mask。如果您想更改 padding 行为，则应根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。
- position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - decoder_position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个 decoder 输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
返回值
transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个 torch.FloatTensor 的 tuple (如果传递 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
last_hidden_state (
jnp.ndarray, 形状为(batch_size, sequence_length, hidden_size)) — 模型 decoder 最后一层的输出处的 hidden-states 序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)的 tuple，每个 tuple 具有 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(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型 encoder 最后一层的输出处的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
FlaxMBartPreTrainedModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxMBartModel
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = FlaxMBartModel.from_pretrained("facebook/mbart-large-cc25")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateencode
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray, 形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray, 形状为(batch_size, sequence_length), 可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。
- position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)decode
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
参数
- decoder_input_ids (
jnp.ndarray，形状为(batch_size, target_sequence_length)) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应该提供
decoder_input_ids。 如果没有提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行遵循论文的去噪预训练。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元组由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size), optional) 是编码器最后一层输出处的隐藏状态序列。 用于解码器的交叉注意力。 - encoder_attention_mask (
jnp.ndarray，形状为(batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 未被屏蔽 的 token，
- 0 表示 被屏蔽 的 token。
- decoder_attention_mask (
jnp.ndarray，形状为(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中的 pad token 的张量。 默认情况下，也将使用因果掩码。如果要更改 padding 行为，则应根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1 。
- decoder_position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), optional) — 每个解码器输入序列 token 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - past_key_values (
Dict[str, np.ndarray], optional, 由init_cache返回或在传递先前的past_key_values时返回) — 预先计算的隐藏状态字典（attention 块中的键和值），可用于快速自回归解码。 预先计算的键和值隐藏状态的形状为 [batch_size, max_length]。 - output_attentions (
bool, optional) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量，并且如果config.is_encoder_decoder=True，则可选地具有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块中的键和值，以及可选地，如果
config.is_encoder_decoder=True，则在交叉注意力块中），这些隐藏状态可以用于（请参阅past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True和config.add_cross_attention=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> last_decoder_hidden_states = outputs.last_hidden_stateFlaxMBartForConditionalGeneration
class transformers.FlaxMBartForConditionalGeneration
< source >( config: MBartConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (MBartConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。 查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype, optional, 默认为jax.numpy.float32) — 计算的数据类型。 可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定，则所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，而不影响模型参数的 dtype。
带有语言建模头的 MMBart 模型。 可用于摘要。 此模型继承自 FlaxPreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参阅 Flax 文档，了解与常规用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray，形状为(batch_size, sequence_length)) — 输入序列 token 在词汇表中的索引。 默认情况下，如果您提供 padding，则 padding 将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形状为(batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 未被屏蔽 的 token，
- 0 表示 被屏蔽 的 token。
- decoder_input_ids (
jnp.ndarray，形状为(batch_size, target_sequence_length), optional) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应该提供
decoder_input_ids。 如果没有提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行遵循论文的去噪预训练。 - decoder_attention_mask (
jnp.ndarray，形状为(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中的 pad token 的张量。 默认情况下，也将使用因果掩码。如果要更改 padding 行为，则应根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1 。
- position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), optional) — 每个输入序列 token 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - decoder_position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 位置嵌入中每个解码器输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)
A transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (MBartConfig) 和输入的各种元素。
-
logits (
jnp.ndarrayof shape(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表 token 的分数）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)的 tuple，每个 tuple 具有 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(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型 encoder 最后一层的输出处的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
FlaxMBartPreTrainedModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
Summarization example
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration, MBartConfig
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> ARTICLE_TO_SUMMARIZE = "Meine Freunde sind cool, aber sie essen zu viel Kuchen."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="np")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"], num_beams=4, max_length=5).sequences
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))掩码填充示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> # de_DE is the language symbol id <LID> for German
>>> TXT = "</s> Meine Freunde sind <mask> nett aber sie essen zu viel Kuchen. </s> de_DE"
>>> input_ids = tokenizer([TXT], add_special_tokens=False, return_tensors="np")["input_ids"]
>>> logits = model(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero()[0].item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)
>>> tokenizer.decode(predictions).split()encode
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarrayof shape(batch_size, sequence_length)) — 输入序列 tokens 在词汇表中的索引。 如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarrayof shape(batch_size, sequence_length), optional) — 避免在填充 token 索引上执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示 未被掩蔽 的 tokens，
- 0 表示 被掩蔽 的 tokens。
- position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)decode
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
参数
- decoder_input_ids (
jnp.ndarrayof shape(batch_size, target_sequence_length)) — 解码器输入序列 tokens 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文中的方法。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元组由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成last_hidden_state的形状为(batch_size, sequence_length, hidden_size), optional) 是编码器最后一层的输出端的隐藏状态序列。 在解码器的交叉注意力中使用。 - encoder_attention_mask (
jnp.ndarrayof shape(batch_size, sequence_length), optional) — 避免在填充 token 索引上执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示 未被掩蔽 的 tokens，
- 0 表示 被掩蔽 的 tokens。
- decoder_attention_mask (
jnp.ndarrayof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充 token。 默认情况下，也将使用因果掩码。如果您想更改填充行为，则应根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。
- decoder_position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 位置嵌入中每个解码器输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - past_key_values (
Dict[str, np.ndarray], optional, 由init_cache返回，或在传递先前的past_key_values时返回）— 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。 预先计算的键和值隐藏状态的形状为[batch_size, max_length]。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
A transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入的各种元素。
-
logits (
jnp.ndarrayof shape(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表 token 的分数）。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。交叉注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或当config.use_cache=True时返回）— 长度为config.n_layers的jnp.ndarray元组的元组，每个元组都包含自注意力和交叉注意力层的缓存键、值状态（如果模型在编码器-解码器设置中使用）。 仅当config.is_decoder = True时相关。包含预先计算的隐藏状态（注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logitsFlaxMBartForSequenceClassification
class transformers.FlaxMBartForSequenceClassification
< source >( config: MBartConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (MBartConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype, optional, defaults tojax.numpy.float32) — 计算的数据类型。 可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定，则所有计算将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，而不影响模型参数的 dtype。
MBart 模型，顶部带有序列分类/头（池化输出顶部的线性层），例如用于 GLUE 任务。
This model inherits from FlaxPreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参阅 Flax 文档，了解与常规用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray, 形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供填充，则填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray, 形状为(batch_size, sequence_length), 可选) — 用于避免在填充 token 索引上执行注意力的掩码。 掩码值选自[0, 1]：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- decoder_input_ids (
jnp.ndarray, 形状为(batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以便按照论文进行去噪预训练。 - decoder_attention_mask (
jnp.ndarray, 形状为(batch_size, target_sequence_length), 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充 tokens。 默认情况下，也将使用因果掩码。如果您想更改填充行为，则应根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。
- position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - decoder_position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个解码器输入序列 token 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (MBartConfig) 和输入的各种元素。
-
logits (
jnp.ndarray, 形状为(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（SoftMax 之前）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)的 tuple，每个 tuple 具有 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(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型 encoder 最后一层的输出处的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
FlaxMBartPreTrainedModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = FlaxMBartForSequenceClassification.from_pretrained("facebook/mbart-large-cc25")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> logits = outputs.logitsencode
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray, 形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供填充，则填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray, 形状为(batch_size, sequence_length), 可选) — 用于避免在填充 token 索引上执行注意力的掩码。 掩码值选自[0, 1]：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
numpy.ndarray, 形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)decode
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
参数
- decoder_input_ids (
jnp.ndarray, 形状为(batch_size, target_sequence_length)) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以便按照论文进行去噪预训练。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层输出的隐藏状态序列。 用于解码器的交叉注意力。 - encoder_attention_mask (
jnp.ndarray, 形状为(batch_size, sequence_length), 可选) — 用于避免在填充 token 索引上执行注意力的掩码。 掩码值选自[0, 1]：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- decoder_attention_mask (
jnp.ndarrayof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad 标记。默认情况下，也将使用因果掩码。如果您想更改填充行为，则应根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- decoder_position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - past_key_values (
Dict[str, np.ndarray], optional, 由init_cache返回或在传递先前的past_key_values时返回) — 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量，并且如果config.is_encoder_decoder=True，则可选地具有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块中的键和值，以及可选地，如果
config.is_encoder_decoder=True，则在交叉注意力块中），这些隐藏状态可以用于（请参阅past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True和config.add_cross_attention=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> last_decoder_hidden_states = outputs.last_hidden_stateFlaxMBartForQuestionAnswering
class transformers.FlaxMBartForQuestionAnswering
< source >( config: MBartConfig input_shape: typing.Tuple[int] = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (MBartConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype, optional, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
MBart 模型，顶部带有跨度分类头，用于抽取式问答任务，例如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。
This model inherits from FlaxPreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)
此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参阅 Flax 文档，了解与常规用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarrayof shape(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarrayof shape(batch_size, sequence_length), optional) — 掩码，以避免对 padding 标记索引执行注意力机制。掩码值在[0, 1]中选择：- 1 代表未掩码的标记，
- 0 代表掩码的标记。
- decoder_input_ids (
jnp.ndarrayof shape(batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。如果未提供decoder_input_ids，则模型将通过将input_ids向右移动来创建此张量，以进行论文中所述的去噪预训练。 - decoder_attention_mask (
jnp.ndarrayof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad 标记。默认情况下，也将使用因果掩码。如果您想更改填充行为，则应根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - decoder_position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput 或 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (MBartConfig) 和输入。
-
start_logits (
jnp.ndarrayof shape(batch_size, sequence_length)) — Span-start 分数（在 SoftMax 之前）。 -
end_logits (
jnp.ndarrayof shape(batch_size, sequence_length)) — Span-end 分数（在 SoftMax 之前）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)的 tuple，每个 tuple 具有 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(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型 encoder 最后一层的输出处的 hidden-states 序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple (embeddings 的输出一个，每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头的加权平均值。
FlaxMBartPreTrainedModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForQuestionAnswering
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> model = FlaxMBartForQuestionAnswering.from_pretrained("facebook/mbart-large-cc25")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="jax")
>>> outputs = model(**inputs)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logitsencode
< source >( input_ids: Array attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
jnp.ndarray，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供填充，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免在填充 token 索引上执行 attention 的掩码。 掩码值选自[0, 1]：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)decode
< source >( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None past_key_values: dict = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
参数
- decoder_input_ids (
jnp.ndarray，形状为(batch_size, target_sequence_length)) — 解码器输入序列 tokens 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过将input_ids向右移动来创建此张量，以便按照论文进行去噪预训练。 - encoder_outputs (
tuple(tuple(jnp.ndarray)) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的 hidden-states 序列。在解码器的 cross-attention 中使用。 - encoder_attention_mask (
jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免在填充 token 索引上执行 attention 的掩码。 掩码值选自[0, 1]：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- decoder_attention_mask (
jnp.ndarray，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad tokens。 默认情况下，也将使用因果掩码。如果您想更改填充行为，则应根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。
- decoder_position_ids (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 每个解码器输入序列 tokens 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - past_key_values (
Dict[str, np.ndarray]，可选，由init_cache返回或在传递先前的past_key_values时返回) — 预先计算的 hidden-states 字典（attention 块中的键和值），可用于快速自回归解码。 预先计算的键和值 hidden-states 的形状为 *[batch_size, max_length]*。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量，并且如果config.is_encoder_decoder=True，则可选地具有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块中的键和值，以及可选地，如果
config.is_encoder_decoder=True，则在交叉注意力块中），这些隐藏状态可以用于（请参阅past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的元组（每个嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True和config.add_cross_attention=True或当config.output_attentions=True时返回) —jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头的加权平均值。
示例
>>> from transformers import AutoTokenizer, FlaxMBartForConditionalGeneration
>>> model = FlaxMBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)
>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id
>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> last_decoder_hidden_states = outputs.last_hidden_state