Transformers 文件
mBART
並獲得增強的文件體驗
開始使用
mBART
mBART 是一種多語言機器翻譯模型，它預訓練整個翻譯模型（編碼器-解碼器），這與以往只關注模型部分的方法不同。該模型基於一個去噪目標進行訓練，該目標是重建被破壞的文字。這使得 mBART 能夠處理源語言和要翻譯的目標文字。
mBART-50 在另外25種語言上進行了預訓練。
你可以在 AI at Meta 組織下找到所有原始的 mBART 檢查點。
點選右側邊欄中的 mBART 模型，檢視更多將 mBART 應用於不同語言任務的示例。
[!NOTE] 當使用除“eager”之外的所有注意力實現時，`head_mask` 引數會被忽略。如果你有 `head_mask` 並希望它生效，請使用 `XXXModel.from_pretrained(model_id, attn_implementation="eager")` 載入模型。
以下示例演示瞭如何使用 Pipeline 或 AutoModel 類來翻譯文字。
import torch
from transformers import pipeline
pipeline = pipeline(
task="translation",
model="facebook/mbart-large-50-many-to-many-mmt",
device=0,
torch_dtype=torch.float16,
src_lang="en_XX",
tgt_lang="fr_XX",
)
print(pipeline("UN Chief Says There Is No Military Solution in Syria"))注意
你可以透過 `tokenizer.lang_code_to_id.keys()` 檢視完整的語言程式碼列表。
mBART 在訓練期間要求在源文字和目標文字中加入特殊的語言 ID 標記。源文字格式為 `X [eos, src_lang_code]`，其中 `X` 是源文字。目標文字格式為 `[tgt_lang_code] X [eos]`。`bos` 標記從未使用。`~PreTrainedTokenizerBase._call_` 會編碼作為第一個引數或使用 `text` 關鍵字傳遞的源文字格式。目標文字格式透過 `text_label` 關鍵字傳遞。
對於 mBART，將 `decoder_start_token_id` 設定為目標語言 ID。
import torch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-en-ro", torch_dtype=torch.bfloat16, attn_implementation="sdpa", device_map="auto") 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]mBART-50 有不同的文字格式。語言 ID 標記用作源文字和目標文字的字首。文字格式為 `[lang_code] X [eos]`，其中 `lang_code` 分別是源文字的源語言 ID 和目標文字的目標語言 ID。`X` 分別是源文字或目標文字。
對於 mBART-50，將 `eos_token_id` 設定為 `decoder_start_token_id`。透過向 generate() 傳遞 `forced_bos_token_id`，將目標語言 ID 用作第一個生成的標記。
import torch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-50-many-to-many-mmt", torch_dtype=torch.bfloat16, attn_implementation="sdpa", device_map="auto") tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-50-many-to-many-mmt") article_ar = "الأمين العام للأمم المتحدة يقول إنه لا يوجد حل عسكري في سوريا." 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)
MBartConfig
class transformers.MBartConfig
< 來源 >( 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) — 嵌入層、編碼器和池化層中所有全連線層的丟棄機率。 - attention_dropout (
float, 可選, 預設為 0.0) — 注意力機率的丟棄率。 - activation_dropout (
float, 可選, 預設為 0.0) — 全連線層內啟用函式的丟棄率。 - classifier_dropout (
float, 可選, 預設為 0.0) — 分類器的丟棄率。 - max_position_embeddings (
int, 可選, 預設為 1024) — 該模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需（例如，512、1024 或 2048）。 - init_std (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - encoder_layerdrop (
float, 可選, 預設為 0.0) — 編碼器的 LayerDrop 機率。詳情請參閱 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, 可選, 預設為 0.0) — 解碼器的 LayerDrop 機率。詳情請參閱 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。 - scale_embedding (
bool, 可選, 預設為False) — 透過除以 sqrt(d_model) 來縮放嵌入。 - use_cache (
bool, 可選, 預設為True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。 - forced_eos_token_id (
int, 可選, 預設為 2) — 當達到 `max_length` 時，強制作為最後一個生成標記的 ID。通常設定為 `eos_token_id`。
這是用於儲存 MBartModel 配置的配置類。它用於根據指定的引數例項化 MBART 模型，定義模型架構。使用預設值例項化配置將產生與 MBART facebook/mbart-large-cc25 架構相似的配置。
配置物件繼承自 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
< 來源 >( 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[dict[str, typing.Any]] = None additional_special_tokens = None **kwargs )
構建一個 MBART 分詞器。
改編自 RobertaTokenizer 和 XLNetTokenizer。基於 SentencePiece。
源語言文件的分詞方法是 <tokens> <eos> <language code>，目標語言文件的分詞方法是 `<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
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從一個序列或一對序列為序列分類任務構建模型輸入。MBART 序列具有以下格式，其中 `X` 代表序列
input_ids（用於編碼器）X [eos, src_lang_code]decoder_input_ids：（用於解碼器）X [eos, tgt_lang_code]
從不使用 BOS。序列對不是預期的用例，但它們將在沒有分隔符的情況下處理。
MBartTokenizerFast
class transformers.MBartTokenizerFast
< 原始碼 >( 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，其中包含了大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
源語言文件的分詞方法是 <tokens> <eos> <language code>，目標語言文件的分詞方法是 `<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
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記來構建序列或序列對的模型輸入，用於序列分類任務。特殊標記取決於呼叫 set_lang。
一個 MBART 序列具有以下格式，其中 `X` 代表序列
input_ids（用於編碼器）X [eos, src_lang_code]decoder_input_ids：（用於解碼器）X [eos, tgt_lang_code]
從不使用 BOS。序列對不是預期的用例，但它們將在沒有分隔符的情況下處理。
create_token_type_ids_from_sequences
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳入的兩個序列建立一個掩碼，用於序列對分類任務。mBART 不使用標記型別 ID，因此返回一個全零列表。
將特殊標記重置為源語言設定。無字首，字尾為=[eos, src_lang_code]。
將特殊標記重置為目標語言設定。無字首，字尾為=[eos, tgt_lang_code]。
MBart50Tokenizer
class transformers.MBart50Tokenizer
< 原始碼 >( 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[dict[str, typing.Any]] = None **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - src_lang (
str, 可選) — 表示源語言的字串。 - tgt_lang (
str, 可選) — 表示目標語言的字串。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束標記。 - sep_token (
str, 可選, 預設為"</s>") — 分隔符標記，用於從多個序列構建一個序列，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作帶有特殊標記構建的序列的最後一個標記。 - cls_token (
str, 可選, 預設為"<s>") — 分類器標記，用於序列分類（對整個序列進行分類，而不是逐個標記分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，將被設定為此標記。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的標記，例如當批處理不同長度的序列時。 - mask_token (
str, 可選, 預設為"<mask>") — 用於掩碼值的標記。這是使用掩碼語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - sp_model_kwargs (
dict, 可選) — 將傳遞給 `SentencePieceProcessor.__init__()` 方法。可使用 SentencePiece 的 Python 包裝器 來設定以下內容：-
enable_sampling：啟用子詞正則化。 -
nbest_size：Unigram 的取樣引數。對於 BPE-Dropout 無效。nbest_size = {0,1}：不執行取樣。nbest_size > 1：從 nbest_size 個結果中取樣。nbest_size < 0：假設 nbest_size 是無限的，並使用前向過濾和後向取樣演算法從所有假設（格）中取樣。
-
alpha：Unigram 取樣的平滑引數，以及 BPE-dropout 的合併操作的丟棄機率。
-
構建一個 MBart50 分詞器。基於 SentencePiece。
該分詞器繼承自 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
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從一個序列或一對序列為序列分類任務構建模型輸入。MBART-50 序列具有以下格式，其中 `X` 代表序列
input_ids(用於編碼器)[src_lang_code] X [eos]labels: (用於解碼器)[tgt_lang_code] X [eos]
從不使用 BOS。序列對不是預期的用例，但它們將在沒有分隔符的情況下處理。
將標記序列（字串）轉換為單個字串。
get_special_tokens_mask
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。
將特殊標記重置為源語言設定。字首=[src_lang_code] 和字尾=[eos]。
將特殊標記重置為目標語言設定。字首=[tgt_lang_code] 和字尾=[eos]。
MBart50TokenizerFast
class transformers.MBart50TokenizerFast
< 原始碼 >( 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, 可選) — 表示源語言的字串。 - tgt_lang (
str, 可選) — 表示目標語言的字串。 - eos_token (
str, 可選, 預設為"</s>") — 序列結束標記。 - sep_token (
str, 可選, 預設為"</s>") — 分隔符標記，用於從多個序列構建一個序列，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作帶有特殊標記構建的序列的最後一個標記。 - cls_token (
str, 可選, 預設為"<s>") — 分類器標記，用於序列分類（對整個序列進行分類，而不是逐個標記分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, 可選, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，將被設定為此標記。 - pad_token (
str, 可選, 預設為"<pad>") — 用於填充的標記，例如當批處理不同長度的序列時。 - mask_token (
str, 可選, 預設為"<mask>") — 用於掩碼值的標記。這是使用掩碼語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。
為 mBART-50 構建一個“快速”的 MBART 分詞器（由 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
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記來構建序列或序列對的模型輸入，用於序列分類任務。特殊標記取決於呼叫 set_lang。
一個 MBART-50 序列具有以下格式，其中 `X` 代表序列
input_ids(用於編碼器)[src_lang_code] X [eos]labels: (用於解碼器)[tgt_lang_code] X [eos]
從不使用 BOS。序列對不是預期的用例，但它們將在沒有分隔符的情況下處理。
將特殊標記重置為源語言設定。字首=[src_lang_code] 和字尾=[eos]。
將特殊標記重置為目標語言設定。字首=[src_lang_code] 和字尾=[eos]。
MBartModel
class transformers.MBartModel
< 原始碼 >( config: MBartConfig )
引數
- config (MBartConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸 Mbart 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.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[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[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 cache_position: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的torch.LongTensor，可選) — 解碼器輸入序列標記在詞彙表中的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
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，可選) — 預設行為：生成一個忽略 `decoder_input_ids` 中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- decoder_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor，可選) — 用於使解碼器中注意力模組選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- cross_attn_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor，可選) — 用於使解碼器中交叉注意力模組選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的 `last_hidden_state` 可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.FloatTensor]], 可選) — 預先計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括模型在解碼的前一階段返回的 `past_key_values`，當 `use_cache=True` 或 `config.use_cache=True` 時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 一個長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，其中每個元組有 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳入 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入形狀為 `(batch_size, 1)` 的最後 `input_ids`（那些沒有為其提供過去鍵值狀態的 ID），而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是 `input_ids`。如果您想比模型的內部嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為相關向量，這將非常有用。 - decoder_inputs_embeds (形狀為
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是 `decoder_input_ids`。如果使用 `past_key_values`，可以選擇只輸入最後的 `decoder_inputs_embeds`（參見 `past_key_values`）。如果您想比模型的內部嵌入查詢矩陣更好地控制如何將 `decoder_input_ids` 索引轉換為相關向量，這將非常有用。如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 均未設定，`decoder_inputs_embeds` 將取 `inputs_embeds` 的值。
- use_cache (
bool, 可選) — 如果設定為 `True`，將返回 `past_key_values` 鍵值狀態，可用於加速解碼（參見 `past_key_values`）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。 - cache_position (形狀為 `(sequence_length)` 的 `torch.Tensor`，可選) — 描繪輸入序列標記在序列中位置的索引。與 `position_ids` 不同，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
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 (
EncoderDecoderCache，可選，當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每個層輸出的隱藏狀態，加上可選的初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MBartModel 的前向方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者負責執行前處理和後處理步驟，而後者會默默地忽略它們。
MBartForConditionalGeneration
class transformers.MBartForConditionalGeneration
< 來源 >( config: MBartConfig )
引數
- config (MBartConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
帶語言模型頭的 MBART 模型。在對預訓練模型進行微調後，可用於摘要任務。
該模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.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[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[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 cache_position: typing.Optional[torch.Tensor] = 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，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (形狀為
(batch_size, target_sequence_length)的torch.LongTensor，可選) — 解碼器輸入序列標記在詞彙表中的索引。可以使用 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，可選) — 預設行為：生成一個忽略 `decoder_input_ids` 中填充標記的張量。預設情況下也會使用因果掩碼。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的torch.Tensor，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- decoder_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor，可選) — 用於使解碼器中注意力模組選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- cross_attn_head_mask (形狀為
(decoder_layers, decoder_attention_heads)的torch.Tensor，可選) — 用於使解碼器中交叉注意力模組選定的頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的 `last_hidden_state` 可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
tuple[tuple[torch.FloatTensor]], 可選) — 預先計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括模型在解碼的前一階段返回的 `past_key_values`，當 `use_cache=True` 或 `config.use_cache=True` 時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 一個長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組，其中每個元組有 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳入 `past_key_values`，將返回舊版快取格式。
如果使用 `past_key_values`，使用者可以選擇只輸入形狀為 `(batch_size, 1)` 的最後 `input_ids`（那些沒有為其提供過去鍵值狀態的 ID），而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。
- inputs_embeds (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是 `input_ids`。如果您想比模型的內部嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為相關向量，這將非常有用。 - decoder_inputs_embeds (形狀為
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示而不是 `decoder_input_ids`。如果使用 `past_key_values`，可以選擇只輸入最後的 `decoder_inputs_embeds`（參見 `past_key_values`）。如果您想比模型的內部嵌入查詢矩陣更好地控制如何將 `decoder_input_ids` 索引轉換為相關向量，這將非常有用。如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 均未設定，`decoder_inputs_embeds` 將取 `inputs_embeds` 的值。
- labels (形狀為
(batch_size, sequence_length)的torch.LongTensor，可選) — 用於計算掩碼語言模型損失的標籤。索引應在 `[0, ..., config.vocab_size]` 或 -100 之間（參見 `input_ids` 文件字串）。索引設定為 `-100` 的標記將被忽略（掩碼），損失僅對標籤在 `[0, ..., config.vocab_size]` 中的標記計算。 - use_cache (
bool, 可選) — 如果設定為 `True`，將返回 `past_key_values` 鍵值狀態，可用於加速解碼（參見 `past_key_values`）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。 - cache_position (形狀為 `(sequence_length)` 的 `torch.Tensor`，可選) — 描繪輸入序列標記在序列中位置的索引。與 `position_ids` 不同，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
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 (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
EncoderDecoderCache，可選，當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MBartForConditionalGeneration 的前向方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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
< 來源 >( config )
引數
- config (MBartForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Mbart transformer，頂部帶有一個用於抽取式問答任務（如 SQuAD）的片段分類頭（一個位於隱藏狀態輸出之上的線性層，用於計算 `span start logits` 和 `span end logits`）。
該模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.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[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 cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)的torch.Tensor，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 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()。
Bart 使用
eos_token_id作為生成decoder_input_ids的起始標記。如果使用了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中填充標記的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，應閱讀
modeling_bart._prepare_decoder_attention_mask並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_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 (
list[torch.FloatTensor]，可選) — 由 (last_hidden_state, 可選:hidden_states, 可選:attentions) 組成的元組。last_hidden_state(形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - start_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算標記分類損失的標註片段起始位置（索引）的標籤。位置被限制在序列長度 (sequence_length) 內。序列外的位置在計算損失時不予考慮。 - end_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算標記分類損失的標註片段結束位置（索引）的標籤。位置被限制在序列長度 (sequence_length) 內。序列外的位置在計算損失時不予考慮。 - 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，可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - cache_position (
torch.LongTensor，形狀為(sequence_length)，可選) — 描述輸入序列標記在序列中位置的索引。與position_ids不同，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含各種元素，具體取決於配置 (MBartConfig) 和輸入。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍結束分數（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache，可選，當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MBartForQuestionAnswering 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...MBartForSequenceClassification
class transformers.MBartForSequenceClassification
< 來源 >( config: MBartConfig **kwargs )
引數
- config (MBartConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。
MBart 模型，其上帶有一個序列分類/頭部（在池化輸出之上有一個線性層），例如用於 GLUE 任務。
該模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.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[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 cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 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()。
Bart 使用
eos_token_id作為生成decoder_input_ids的起始標記。如果使用了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中填充標記的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，應閱讀
modeling_bart._prepare_decoder_attention_mask並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_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 (
list[torch.FloatTensor]，可選) — 由 (last_hidden_state, 可選:hidden_states, 可選:attentions) 組成的元組。last_hidden_state(形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - 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的值。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels > 1，則計算分類損失（交叉熵）。 - use_cache (
bool，可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - cache_position (
torch.LongTensor，形狀為(sequence_length)，可選) — 描述輸入序列標記在序列中位置的索引。與position_ids不同，此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含各種元素，具體取決於配置 (MBartConfig) 和輸入。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供label時返回) — 分類 (如果 config.num_labels==1 則為迴歸) 損失。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache，可選，當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — 形狀為 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元組（一個用於嵌入的輸出，如果模型有嵌入層，+ 一個用於每層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
MBartForSequenceClassification 的 forward 方法覆蓋了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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()
>>> model.config.id2label[predicted_class_id]
...
>>> # 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
>>> round(loss.item(), 2)
...多標籤分類示例
>>> 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
< 來源 >( input_ids: typing.Optional[torch.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[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 cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 輸入序列標記在詞彙表中的索引。預設情況下將忽略填充。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力機制的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- encoder_hidden_states (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 編碼器最後一層輸出的隱藏狀態序列。如果模型配置為解碼器，則在交叉注意力機制中使用。 - encoder_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在編碼器輸入的填充標記索引上執行注意力機制的掩碼。如果模型配置為解碼器，則此掩碼用於交叉注意力機制。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭已被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 用於使交叉注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭已被掩碼。
- past_key_values (
list[torch.FloatTensor]，可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常由模型在解碼的先前階段返回的past_key_values組成，當use_cache=True或config.use_cache=True時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 鍵值快取指南；
- 一個長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞
past_key_values，將返回舊版快取格式。如果使用了
past_key_values，使用者可以選擇只輸入最後一個input_ids（那些沒有為其提供過去鍵值狀態的標記），形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入表示。這在你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為相關向量時非常有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言模型損失的標籤。索引應在[0, ..., config.vocab_size]或 -100 之間（參見input_ids文件字串）。索引設定為-100的標記將被忽略（掩碼），損失僅對標籤在[0, ..., config.vocab_size]之間的標記計算。 - use_cache (
bool，可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參見返回張量下的 `attentions`。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參見返回張量下的 `hidden_states`。 - return_dict (
bool, 可選) — 是返回一個 ModelOutput 而不是一個普通的元組。 - cache_position (
torch.LongTensor，形狀為(sequence_length)，可選) — 描述輸入序列詞元在序列中位置的索引。與 `position_ids` 不同，該張量不受填充的影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
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,)，可選，當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
hidden_states (
tuple(torch.FloatTensor), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，另外每個層都有一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — 形狀為 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元組（每層一個）。注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
Cache, 可選, 當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 這是一個 Cache 例項。更多詳情，請參閱我們的 kv cache 指南。包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。
MBartForCausalLM 的 forward 方法重寫了 `__call__` 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者負責執行前處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> 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
< 原始碼 >( 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 函式一樣傳遞輸入！
呼叫
< 原始碼 >( 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`（即那些沒有為其提供過去鍵值狀態的 `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 (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
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 (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
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 的 forward 方法重寫了 `__call__` 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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
class 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 函式一樣傳遞輸入！
呼叫
< 原始碼 >( 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: Optional[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`（即那些沒有為其提供過去鍵值狀態的 `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 模式下使用，在圖模式下，該值將始終設定為 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 (形狀為
(n,)的tf.Tensor, 可選, 其中 n 是非掩碼標籤的數量，當提供labels時返回) — 語言建模損失。 -
logits (
tf.Tensorof shape(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 (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
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__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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
< 來源 >( config: MBartConfig input_shape: tuple = (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 Transformer 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。該模型繼承自 FlaxPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供，填充將被預設忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用 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中填充標記的張量。預設情況下也會使用因果掩碼。如果要更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 位置嵌入中每個輸入序列標記的位置索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 位置嵌入中每個解碼器輸入序列標記的位置索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（MBartConfig）和輸入包含不同的元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
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)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxMBartPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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_state編碼
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供，填充將被預設忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 位置嵌入中每個輸入序列標記的位置索引。選擇範圍為[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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 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
< 來源 >( 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: typing.Optional[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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 詞彙表中解碼器輸入序列標記的索引。可以使用 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), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。如果要更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 位置嵌入中每個解碼器輸入序列標記的位置索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - past_key_values (
dict[str, np.ndarray], 可選, 由init_cache返回或在傳遞先前的past_key_values時返回) — 預計算的隱藏狀態字典（注意力塊中的鍵和值），可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。如果使用了
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)元組，每個元組包含 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), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True且config.add_cross_attention=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 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
< 來源 >( config: MBartConfig input_shape: tuple = (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。
帶語言建模頭的 MMBart 模型。可用於摘要任務。該模型繼承自 FlaxPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果您提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。索引可以使用 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中填充標記的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，你應該根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個解碼器輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（MBartConfig）和輸入而變化的不同元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 當use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tuple(jnp.ndarray)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxMBartPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者負責執行前處理和後處理步驟，而後者會默默地忽略它們。
摘要示例
>>> 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()編碼
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果您提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 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
< 來源 >( 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: typing.Optional[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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 詞彙表中解碼器輸入序列標記的索引。索引可以使用 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), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，你應該根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個解碼器輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - past_key_values (
dict[str, np.ndarray], 可選，由init_cache返回或在傳遞先前的past_key_values時返回) — 包含預計算的隱藏狀態（注意力塊中的鍵和值）的字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（<class 'transformers.models.mbart.configuration_mbart.MBartConfig'>）和輸入而變化的不同元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
tuple(tuple(jnp.ndarray)), 可選，當傳遞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
< 來源 >( config: MBartConfig input_shape: tuple = (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 模型，其上帶有一個序列分類/頭部（在池化輸出之上有一個線性層），例如用於 GLUE 任務。
此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果您提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。索引可以使用 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中填充標記的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，你應該根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個解碼器輸入序列標記在位置嵌入中的位置索引。在[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 (形狀為
(batch_size, config.num_labels)的jnp.ndarray) — 分類（如果 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)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxMBartPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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.logits編碼
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果您提供填充，預設情況下將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蓋，
- 0 表示標記已被遮蓋。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 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
< 來源 >( 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: typing.Optional[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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 詞彙表中解碼器輸入序列標記的索引。索引可以使用 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)。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state(*可選*) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - encoder_attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), *可選*) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), *可選*) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。如果你想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), *可選*) — 解碼器每個輸入序列標記在位置嵌入中的位置索引。選值範圍為[0, config.max_position_embeddings - 1]。 - past_key_values (
dict[str, np.ndarray], *可選*，由init_cache返回或在傳遞先前的past_key_values時返回) — 預計算的隱藏狀態字典（注意力塊中的鍵和值），可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 *[batch_size, max_length]*。 - output_attentions (
bool, *可選*) — 是否返回所有注意力層的注意力張量。更多詳情請參閱返回張量下的attentions。 - output_hidden_states (
bool, *可選*) — 是否返回所有層的隱藏狀態。更多詳情請參閱返回張量下的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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。如果使用了
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)元組，每個元組包含 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), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True且config.add_cross_attention=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 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
< 來源 >( config: MBartConfig input_shape: tuple = (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執行。請注意，這僅指定計算的資料型別，不影響模型引數的資料型別。
MBart 模型，其頂部帶有一個片段分類頭，用於像 SQuAD 這樣的抽取式問答任務（在隱藏狀態輸出之上有一個線性層，用於計算 `span start logits` 和 `span end logits`）。
此模型繼承自 FlaxPreTrainedModel。請查閱超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與常規用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), *可選*) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length), *可選*) — 詞彙表中解碼器輸入序列標記的索引。可以使用 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中填充標記的張量。預設情況下也會使用因果掩碼。如果你想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), *可選*) — 每個輸入序列標記在位置嵌入中的位置索引。選值範圍為[0, config.max_position_embeddings - 1]。 - decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), *可選*) — 解碼器每個輸入序列標記在位置嵌入中的位置索引。選值範圍為[0, config.max_position_embeddings - 1]。 - output_attentions (
bool, *可選*) — 是否返回所有注意力層的注意力張量。更多詳情請參閱返回張量下的attentions。 - output_hidden_states (
bool, *可選*) — 是否返回所有層的隱藏狀態。更多詳情請參閱返回張量下的hidden_states。 - return_dict (
bool, *可選*) — 是否返回 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.ndarray，形狀為(batch_size, sequence_length)) — 跨度開始得分（SoftMax 之前）。 -
end_logits (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 跨度結束得分（SoftMax 之前）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可選, 當use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tuple(jnp.ndarray)元組，每個元組包含 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時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
FlaxMBartPreTrainedModel 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳遞的配方需要在此函式內定義，但之後應呼叫 `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_logits編碼
< 來源 >( 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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
jnp.ndarray，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), *可選*) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), *可選*) — 每個輸入序列標記在位置嵌入中的位置索引。選值範圍為[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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(jnp.ndarray), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 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
< 來源 >( 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: typing.Optional[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: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)
引數
- decoder_input_ids (
jnp.ndarray，形狀為(batch_size, target_sequence_length)) — 詞彙表中解碼器輸入序列標記的索引。可以使用 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)。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state(*可選*) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - encoder_attention_mask (
jnp.ndarray，形狀為(batch_size, sequence_length), *可選*) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- decoder_attention_mask (
jnp.ndarray，形狀為(batch_size, target_sequence_length), *可選*) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。如果你想更改填充行為，應根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖1。
- decoder_position_ids (
numpy.ndarray，形狀為(batch_size, sequence_length), *可選*) — 解碼器每個輸入序列標記在位置嵌入中的位置索引。選值範圍為[0, config.max_position_embeddings - 1]。 - past_key_values (
dict[str, np.ndarray], *可選*，由init_cache返回或在傳遞先前的past_key_values時返回) — 預計算的隱藏狀態字典（注意力塊中的鍵和值），可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 *[batch_size, max_length]*。 - output_attentions (
bool, *可選*) — 是否返回所有注意力層的注意力張量。更多詳情請參閱返回張量下的attentions。 - output_hidden_states (
bool, *可選*) — 是否返回所有層的隱藏狀態。更多詳情請參閱返回張量下的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 (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。如果使用了
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)元組，每個元組包含 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), 可選, 當output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的jnp.ndarray元組（一個是嵌入層的輸出，一個是每一層的輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可選, 當output_attentions=True且config.add_cross_attention=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 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