Transformers 文件

MarianMT

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

MarianMT

PyTorch TensorFlow Flax FlashAttention SDPA

概述

一個用於翻譯模型的框架,使用與 BART 相同的模型。翻譯結果應與每個模型卡中連結的測試集輸出相似,但不完全相同。此模型由 sshleifer 貢獻。

實現說明

  • 每個模型在磁碟上約佔 298 MB,有超過 1,000 個模型。

  • 支援的語言對列表可以在這裡找到。

  • 模型最初由 Jörg Tiedemann 使用 Marian C++ 庫進行訓練,該庫支援快速訓練和翻譯。

  • 所有模型都是 Transformer 編碼器-解碼器結構,每個元件有 6 層。每個模型的效能都記錄在模型卡中。

  • 不支援需要 BPE 預處理的 80 個 opus 模型。

  • 建模程式碼與 BartForConditionalGeneration 相同,但有一些細微修改:

    • 靜態(正弦)位置嵌入 (MarianConfig.static_position_embeddings=True)
    • 無 layernorm_embedding (MarianConfig.normalize_embedding=False)
    • 模型以 pad_token_id(其 token_embedding 為 0)作為字首開始生成(Bart 使用 <s/>),
  • 批次轉換模型的程式碼可以在 `convert_marian_to_pytorch.py` 中找到。

命名

  • 所有模型名稱均採用以下格式:Helsinki-NLP/opus-mt-{src}-{tgt}
  • 用於命名模型的語言程式碼不一致。兩位程式碼通常可以在這裡找到,三位程式碼則需要谷歌搜尋“language code {code}”。
  • 類似 `es_AR` 格式的程式碼通常是 `code_{region}`。這個例子代表阿根廷西班牙語。
  • 這些模型分兩個階段進行轉換。前 1000 個模型使用 ISO-639-2 程式碼來識別語言,第二批則結合使用 ISO-639-5 程式碼和 ISO-639-2 程式碼。

示例

  • 由於 Marian 模型比庫中許多其他翻譯模型小,因此它們對於微調實驗和整合測試非常有用。
  • 在 GPU 上微調

多語言模型

  • 所有模型名稱均採用以下格式:Helsinki-NLP/opus-mt-{src}-{tgt}
  • 如果一個模型可以輸出多種語言,您應該透過在 `src_text` 前新增所需輸出語言的程式碼來指定語言程式碼。
  • 你可以在模型的模型卡中看到其支援的語言程式碼,在“目標成分”下,例如 opus-mt-en-roa
  • 請注意,如果模型僅在源語言端是多語言的,例如 `Helsinki-NLP/opus-mt-roa-en`,則不需要語言程式碼。

來自 Tatoeba-Challenge 倉庫 的新多語言模型需要 3 個字元的語言程式碼。

>>> from transformers import MarianMTModel, MarianTokenizer

>>> src_text = [
...     ">>fra<< this is a sentence in english that we want to translate to french",
...     ">>por<< This should go to portuguese",
...     ">>esp<< And this to Spanish",
... ]

>>> model_name = "Helsinki-NLP/opus-mt-en-roa"
>>> tokenizer = MarianTokenizer.from_pretrained(model_name)
>>> print(tokenizer.supported_language_codes)
['>>zlm_Latn<<', '>>mfe<<', '>>hat<<', '>>pap<<', '>>ast<<', '>>cat<<', '>>ind<<', '>>glg<<', '>>wln<<', '>>spa<<', '>>fra<<', '>>ron<<', '>>por<<', '>>ita<<', '>>oci<<', '>>arg<<', '>>min<<']

>>> model = MarianMTModel.from_pretrained(model_name)
>>> translated = model.generate(**tokenizer(src_text, return_tensors="pt", padding=True))
>>> [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
["c'est une phrase en anglais que nous voulons traduire en français",
 'Isto deve ir para o português.',
 'Y esto al español']

以下是檢視 Hub 上所有可用預訓練模型的程式碼:

from huggingface_hub import list_models

model_list = list_models()
org = "Helsinki-NLP"
model_ids = [x.id for x in model_list if x.id.startswith(org)]
suffix = [x.split("/")[1] for x in model_ids]
old_style_multi_models = [f"{org}/{s}" for s in suffix if s != s.lower()]

舊式多語言模型

這些是從 OPUS-MT-Train 倉庫移植的舊式多語言模型:以及每個語言組的成員

['Helsinki-NLP/opus-mt-NORTH_EU-NORTH_EU',
 'Helsinki-NLP/opus-mt-ROMANCE-en',
 'Helsinki-NLP/opus-mt-SCANDINAVIA-SCANDINAVIA',
 'Helsinki-NLP/opus-mt-de-ZH',
 'Helsinki-NLP/opus-mt-en-CELTIC',
 'Helsinki-NLP/opus-mt-en-ROMANCE',
 'Helsinki-NLP/opus-mt-es-NORWAY',
 'Helsinki-NLP/opus-mt-fi-NORWAY',
 'Helsinki-NLP/opus-mt-fi-ZH',
 'Helsinki-NLP/opus-mt-fi_nb_no_nn_ru_sv_en-SAMI',
 'Helsinki-NLP/opus-mt-sv-NORWAY',
 'Helsinki-NLP/opus-mt-sv-ZH']
GROUP_MEMBERS = {
 'ZH': ['cmn', 'cn', 'yue', 'ze_zh', 'zh_cn', 'zh_CN', 'zh_HK', 'zh_tw', 'zh_TW', 'zh_yue', 'zhs', 'zht', 'zh'],
 'ROMANCE': ['fr', 'fr_BE', 'fr_CA', 'fr_FR', 'wa', 'frp', 'oc', 'ca', 'rm', 'lld', 'fur', 'lij', 'lmo', 'es', 'es_AR', 'es_CL', 'es_CO', 'es_CR', 'es_DO', 'es_EC', 'es_ES', 'es_GT', 'es_HN', 'es_MX', 'es_NI', 'es_PA', 'es_PE', 'es_PR', 'es_SV', 'es_UY', 'es_VE', 'pt', 'pt_br', 'pt_BR', 'pt_PT', 'gl', 'lad', 'an', 'mwl', 'it', 'it_IT', 'co', 'nap', 'scn', 'vec', 'sc', 'ro', 'la'],
 'NORTH_EU': ['de', 'nl', 'fy', 'af', 'da', 'fo', 'is', 'no', 'nb', 'nn', 'sv'],
 'SCANDINAVIA': ['da', 'fo', 'is', 'no', 'nb', 'nn', 'sv'],
 'SAMI': ['se', 'sma', 'smj', 'smn', 'sms'],
 'NORWAY': ['nb_NO', 'nb', 'nn_NO', 'nn', 'nog', 'no_nb', 'no'],
 'CELTIC': ['ga', 'cy', 'br', 'gd', 'kw', 'gv']
}

使用舊式雙字元語言程式碼將英語翻譯成多種羅曼語的示例:

>>> from transformers import MarianMTModel, MarianTokenizer

>>> src_text = [
...     ">>fr<< this is a sentence in english that we want to translate to french",
...     ">>pt<< This should go to portuguese",
...     ">>es<< And this to Spanish",
... ]

>>> model_name = "Helsinki-NLP/opus-mt-en-ROMANCE"
>>> tokenizer = MarianTokenizer.from_pretrained(model_name)

>>> model = MarianMTModel.from_pretrained(model_name)
>>> translated = model.generate(**tokenizer(src_text, return_tensors="pt", padding=True))
>>> tgt_text = [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
["c'est une phrase en anglais que nous voulons traduire en français",
 'Isto deve ir para o português.',
 'Y esto al español']

資源

MarianConfig

class transformers.MarianConfig

< >

( vocab_size = 58101 decoder_vocab_size = None 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 decoder_start_token_id = 58100 scale_embedding = False pad_token_id = 58100 eos_token_id = 0 forced_eos_token_id = 0 share_encoder_decoder_embeddings = True **kwargs )

引數

  • vocab_size (int, 可選, 預設為 58101) — Marian 模型的詞彙表大小。定義了在呼叫 MarianModelTFMarianModel 時,可以透過 `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 (strfunction, 可選, 預設為 "gelu") — 編碼器和池化器中的非線性啟用函式(函式或字串)。如果為字串,支援 "gelu", "relu", "silu""gelu_new"
  • dropout (float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化器中所有全連線層的丟棄機率。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力機率的丟棄率。
  • activation_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, 可選, 預設為 0) — 當達到 `max_length` 時,強制作為最後一個生成詞元的 ID。通常設定為 `eos_token_id`。

這是用於儲存 MarianModel 配置的配置類。它用於根據指定的引數例項化一個 Marian 模型,定義模型架構。使用預設值例項化配置將產生與 Marian Helsinki-NLP/opus-mt-en-de 架構相似的配置。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。有關更多資訊,請閱讀 PretrainedConfig 的文件。

示例

>>> from transformers import MarianModel, MarianConfig

>>> # Initializing a Marian Helsinki-NLP/opus-mt-en-de style configuration
>>> configuration = MarianConfig()

>>> # Initializing a model from the Helsinki-NLP/opus-mt-en-de style configuration
>>> model = MarianModel(configuration)

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

MarianTokenizer

class transformers.MarianTokenizer

< >

( source_spm target_spm vocab target_vocab_file = None source_lang = None target_lang = None unk_token = '<unk>' eos_token = '</s>' pad_token = '<pad>' model_max_length = 512 sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None separate_vocabs = False **kwargs )

引數

  • source_spm (str) — 包含源語言詞彙表的 SentencePiece 檔案(通常副檔名為 .spm)。
  • target_spm (str) — 包含目標語言詞彙表的 SentencePiece 檔案(通常副檔名為 .spm)。
  • source_lang (str, 可選) — 代表源語言的字串。
  • target_lang (str, 可選) — 代表目標語言的字串。
  • unk_token (str, 可選, 預設為 "<unk>") — 未知詞元(token)。詞彙表中不存在的詞元無法轉換為 ID,將被設定為此詞元。
  • eos_token (str, 可選, 預設為 "</s>") — 序列結束詞元。
  • pad_token (str, 可選, 預設為 "<pad>") — 用於填充的詞元,例如當批處理不同長度的序列時使用。
  • model_max_length (int, 可選, 預設為 512) — 模型接受的最大句子長度。
  • additional_special_tokens (list[str], 可選, 預設為 ["<eop>", "<eod>"]) — 分詞器使用的額外特殊詞元。
  • 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 的合併操作的丟棄機率。

構建一個 Marian 分詞器。基於 SentencePiece

此分詞器繼承自 PreTrainedTokenizer,其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。

示例

>>> from transformers import MarianForCausalLM, MarianTokenizer

>>> model = MarianForCausalLM.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> src_texts = ["I am a small frog.", "Tom asked his teacher for advice."]
>>> tgt_texts = ["Ich bin ein kleiner Frosch.", "Tom bat seinen Lehrer um Rat."]  # optional
>>> inputs = tokenizer(src_texts, text_target=tgt_texts, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)  # should work

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None )

透過追加 eos_token_id 從序列構建模型輸入。

Pytorch
隱藏 Pytorch 內容

MarianModel

class transformers.MarianModel

< >

( config: MarianConfig )

引數

  • config (MarianConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。

原始的 Marian 模型,輸出原始的隱藏狀態,頂部沒有任何特定的頭部。

此模型繼承自 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.Tensor] = 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.Union[tuple[torch.Tensor], transformers.modeling_outputs.BaseModelOutput, NoneType] = 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.Seq2SeqModelOutputtuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (torch.Tensor,形狀為 (batch_size, sequence_length)可選) — 避免對填充詞元索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示詞元未被遮蓋
    • 0 表示詞元被遮蓋

    什麼是注意力掩碼?

  • decoder_input_ids (torch.LongTensor,形狀為 (batch_size, target_sequence_length)可選) — 詞彙表中解碼器輸入序列詞元的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是解碼器輸入 ID?

    Marian 使用 pad_token_id 作為生成 decoder_input_ids 的起始詞元。如果使用 past_key_values,則可以選擇只輸入最後的 decoder_input_ids(參見 past_key_values)。

  • decoder_attention_mask (torch.LongTensor,形狀為 (batch_size, target_sequence_length)可選) — 預設行為:生成一個忽略 decoder_input_ids 中填充詞元的張量。預設情況下也會使用因果掩碼。
  • 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 (Union[tuple[torch.Tensor], ~modeling_outputs.BaseModelOutput, NoneType]) — 元組包含(last_hidden_state, 可選: hidden_states, 可選: attentionslast_hidden_state,形狀為 (batch_size, sequence_length, hidden_size)可選)是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可選) — 預計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在先前解碼階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • Cache 例項,請參閱我們的 kv 快取指南
    • 長度為 config.n_layerstuple(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 (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_idsdecoder_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.Tensor,形狀為 (sequence_length)可選) — 描繪輸入序列詞元在序列中位置的索引。與 position_ids 相反,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.Seq2SeqModelOutputtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.Seq2SeqModelOutput 或一個 torch.FloatTensor 的元組(如果傳遞了 return_dict=False 或當 config.return_dict=False),根據配置 (MarianConfig) 和輸入包含各種元素。

  • 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 時返回) — torch.FloatTensor 的元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    解碼器在每個層輸出的隱藏狀態,加上可選的初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器交叉注意力層的注意力權重,在注意力 softmax 之後,用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (torch.FloatTensor,形狀為 (batch_size, sequence_length, hidden_size)可選) — 模型編碼器最後一層輸出的隱藏狀態序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    編碼器在每個層輸出的隱藏狀態,加上可選的初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    編碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

MarianModel 的前向方法,重寫了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MarianModel

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = MarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_inputs = tokenizer(
...     "<pad> Studien haben gezeigt dass es hilfreich ist einen Hund zu besitzen",
...     return_tensors="pt",
...     add_special_tokens=False,
... )
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_inputs.input_ids)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 26, 512]

MarianMTModel

class transformers.MarianMTModel

< >

( config: MarianConfig )

引數

  • config (MarianConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法以載入模型權重。

帶有語言模型頭部的 Marian 模型。可用於摘要任務。

此模型繼承自 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.Tensor] = 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.Union[tuple[torch.Tensor], transformers.modeling_outputs.BaseModelOutput, NoneType] = 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.Seq2SeqLMOutputtuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (torch.Tensor,形狀為 (batch_size, sequence_length)可選) — 避免對填充詞元索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示詞元未被遮蓋
    • 0 表示詞元被遮蓋

    什麼是注意力掩碼?

  • decoder_input_ids (torch.LongTensor,形狀為 (batch_size, target_sequence_length)可選) — 詞彙表中解碼器輸入序列詞元的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是解碼器輸入 ID?

    Marian 使用 pad_token_id 作為生成 decoder_input_ids 的起始詞元。如果使用 past_key_values,則可以選擇只輸入最後的 decoder_input_ids(參見 past_key_values)。

  • decoder_attention_mask (torch.LongTensor,形狀為 (batch_size, target_sequence_length)可選) — 預設行為:生成一個忽略 decoder_input_ids 中填充詞元的張量。預設情況下也會使用因果掩碼。
  • 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 (Union[tuple[torch.Tensor], ~modeling_outputs.BaseModelOutput, NoneType]) — 由 (last_hidden_state, *可選*: hidden_states, *可選*: attentions) 組成的元組。last_hidden_state 的形狀為 (batch_size, sequence_length, hidden_size),*可選*) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。
  • 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`,使用者可以選擇只輸入最後的 `input_ids`(那些沒有為其提供過去鍵值狀態的 `input_ids`),其形狀為 `(batch_size, 1)`,而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), *可選*) — 可選地,你可以選擇直接傳遞一個嵌入表示,而不是 `input_ids`。如果你想比模型內部的嵌入查詢矩陣有更多控制權來將 `input_ids` 索引轉換為相關向量,這會非常有用。
  • decoder_inputs_embeds (torch.FloatTensor of shape (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 of shape (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.Tensor of shape (sequence_length), *可選*) — 描述輸入序列詞元在序列中位置的索引。與 `position_ids` 不同,該張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.Seq2SeqLMOutputtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.Seq2SeqLMOutput 或一個 `torch.FloatTensor` 的元組(如果傳遞 `return_dict=False` 或 `config.return_dict=False`),包含根據配置(MarianConfig)和輸入的不同元素。

  • 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 時返回) — torch.FloatTensor 的元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器交叉注意力層的注意力權重,在注意力 softmax 之後,用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (torch.FloatTensor,形狀為 (batch_size, sequence_length, hidden_size)可選) — 模型編碼器最後一層輸出的隱藏狀態序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組(一個用於嵌入層的輸出,如果模型有嵌入層,+ 一個用於每層輸出),形狀為 (batch_size, sequence_length, hidden_size)

    編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    編碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

MarianMTModel 的 forward 方法重寫了 `__call__` 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MarianMTModel

>>> src = "fr"  # source language
>>> trg = "en"  # target language

>>> model_name = f"Helsinki-NLP/opus-mt-{src}-{trg}"
>>> model = MarianMTModel.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

>>> sample_text = "où est l'arrêt de bus ?"
>>> batch = tokenizer([sample_text], return_tensors="pt")

>>> generated_ids = model.generate(**batch)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
"Where's the bus stop?"

MarianForCausalLM

class transformers.MarianForCausalLM

< >

( config )

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 or tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length), *可選*) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), *可選*) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示詞元未被掩碼
    • 0 表示詞元被掩碼

    什麼是注意力掩碼?

  • encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), *可選*) — 編碼器最後一層輸出的隱藏狀態序列。如果模型被配置為解碼器,則在交叉注意力中使用。
  • encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), *可選*) — 用於避免對編碼器輸入的填充詞元索引執行注意力的掩碼。如果模型被配置為解碼器,則在交叉注意力中使用此掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示詞元未被掩碼
    • 0 表示詞元被掩碼
  • head_mask (torch.Tensor of shape (num_heads,) or (num_layers, num_heads), *可選*) — 用於將自注意力模組的選定頭置零的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示頭未被掩碼
    • 0 表示頭被掩碼
  • cross_attn_head_mask (torch.Tensor of shape (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 例項,請參閱我們的 kv 快取指南
    • 一個長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元組,每個元組包含 2 個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳入 `past_key_values`,將返回舊版快取格式。

    如果使用 `past_key_values`,使用者可以選擇只輸入最後的 `input_ids`(那些沒有為其提供過去鍵值狀態的 `input_ids`),其形狀為 `(batch_size, 1)`,而不是形狀為 `(batch_size, sequence_length)` 的所有 `input_ids`。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), *可選*) — 可選地,你可以選擇直接傳遞一個嵌入表示,而不是 `input_ids`。如果你想比模型內部的嵌入查詢矩陣有更多控制權來將 `input_ids` 索引轉換為相關向量,這會非常有用。
  • labels (torch.LongTensor of shape (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 of shape (sequence_length), *可選*) — 描述輸入序列詞元在序列中位置的索引。與 `position_ids` 不同,該張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

一個 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一個 `torch.FloatTensor` 的元組(如果傳遞 `return_dict=False` 或 `config.return_dict=False`),包含根據配置(MarianConfig)和輸入的不同元素。

  • 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 時返回) — torch.FloatTensor 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 後的交叉注意力權重,用於計算交叉注意力頭中的加權平均。

  • past_key_values (Cache, *可選*, 當傳遞 `use_cache=True` 或 `config.use_cache=True` 時返回) — 它是一個 Cache 例項。有關更多詳細資訊,請參閱我們的 kv 快取指南

    包含預先計算的隱藏狀態(注意力塊中的鍵和值),可用於(參見 past_key_values 輸入)加速順序解碼。

MarianForCausalLM 的 forward 方法重寫了 `__call__` 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, MarianForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-fr-en")
>>> model = MarianForCausalLM.from_pretrained("Helsinki-NLP/opus-mt-fr-en", add_cross_attention=False)
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
True
TensorFlow
隱藏 TensorFlow 內容

TFMarianModel

class transformers.TFMarianModel

< >

( config: MarianConfig *inputs **kwargs )

引數

  • config (MarianConfig) — 模型配置類,包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

基礎的 MARIAN 模型,輸出原始的隱藏狀態,沒有任何特定的頭部。此模型繼承自 TFPreTrainedModel。請檢視超類文件,瞭解庫為所有模型實現的通用方法(如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

該模型也是一個 keras.Model 的子類。可以像使用常規的 TF 2.0 Keras 模型一樣使用它,並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數(如 PyTorch 模型),或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是,Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援,當使用 `model.fit()` 等方法時,一切應該都能“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤!然而,如果你想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式,例如在使用 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: tf.Tensor | None = 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: tf.Tensor | None = 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: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

引數

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (tf.Tensor of shape (batch_size, sequence_length), *可選*) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示詞元未被掩碼
    • 0 表示詞元被掩碼

    什麼是注意力掩碼?

  • decoder_input_ids (tf.Tensor of shape (batch_size, target_sequence_length), *可選*) — 詞彙表中解碼器輸入序列詞元的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是解碼器輸入 ID?

    Marian 使用 `pad_token_id` 作為生成 `decoder_input_ids` 的起始詞元。如果使用了 `past_key_values`,可以選擇只輸入最後的 `decoder_input_ids`(參見 `past_key_values`)。

  • decoder_attention_mask (tf.Tensor of shape (batch_size, target_sequence_length), *可選*) — 預設情況下會自動建立並忽略填充詞元。對於大多數用例,不建議設定此項。
  • decoder_position_ids (tf.Tensor of shape (batch_size, sequence_length), *可選*) — 位置嵌入中每個解碼器輸入序列詞元的位置索引。在 `[0, config.max_position_embeddings - 1]` 範圍內選擇。
  • head_mask (tf.Tensor of shape (encoder_layers, encoder_attention_heads), *可選*) — 用於將編碼器中注意力模組的選定頭置零的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示頭未被掩碼
    • 0 表示頭被掩碼
  • decoder_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), *可選*) — 用於將解碼器中注意力模組的選定頭置零的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示頭未被掩碼
    • 0 表示頭被掩碼
  • cross_attn_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), *可選*) — 用於將交叉注意力模組的選定頭置零的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示頭未被掩碼
    • 0 表示頭被掩碼
  • encoder_outputs (tf.FloatTensor, *可選*) — 編碼器最後一層輸出的隱藏狀態。用於解碼器的交叉注意力機制。形狀為 `(batch_size, sequence_length, hidden_size)` 的序列。
  • past_key_values (tuple[tuple[tf.Tensor]],長度為 config.n_layers) — 包含注意力模組預先計算的鍵和值隱藏狀態。可用於加速解碼。如果使用 past_key_values,使用者可以選擇只輸入最後一個 decoder_input_ids(形狀為 (batch_size, 1)),而不是所有形狀為 (batch_size, sequence_length)decoder_input_ids(那些沒有將其過去的鍵值狀態提供給該模型的ID)。
  • 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 mode)下使用,在圖模式(graph mode)下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。此引數只能在即時執行模式(eager mode)下使用,在圖模式(graph mode)下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在即時執行模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 False) — 是否在訓練模式下使用模型(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

transformers.modeling_tf_outputs.TFSeq2SeqModelOutputtuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一個 tf.Tensor 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(MarianConfig)和輸入,包含各種元素。

  • 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_layerstf.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 之後,用於計算自注意力頭中的加權平均。

TFMarianModel 的前向方法,重寫了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFMarianModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = TFMarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

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

>>> last_hidden_states = outputs.last_hidden_state

TFMarianMTModel

class transformers.TFMarianMTModel

< >

( config *inputs **kwargs )

引數

  • config (MarianConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重,只會載入配置。檢視 from_pretrained() 方法以載入模型權重。

帶有語言建模頭的 MARIAN 模型。可用於摘要。該模型繼承自 TFPreTrainedModel。請檢視超類文件,瞭解庫為其所有模型實現的通用方法(如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

該模型也是一個 keras.Model 的子類。可以像使用常規的 TF 2.0 Keras 模型一樣使用它,並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數(如 PyTorch 模型),或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是,Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援,當使用 `model.fit()` 等方法時,一切應該都能“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤!然而,如果你想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式,例如在使用 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: tf.Tensor | None = 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: TFBaseModelOutput | None = 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: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) transformers.modeling_tf_outputs.TFSeq2SeqLMOutputtuple(tf.Tensor)

引數

  • input_ids (tf.Tensor,形狀為 ({0})) — 詞彙表中輸入序列標記的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (tf.Tensor,形狀為 ({0})可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自 [0, 1]

    • 1 表示標記未被掩碼
    • 0 表示標記已被掩碼

    什麼是注意力掩碼?

  • decoder_input_ids (tf.Tensor,形狀為 (batch_size, target_sequence_length)可選) — 詞彙表中解碼器輸入序列標記的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是解碼器輸入 ID?

    Marian 使用 pad_token_id 作為生成 decoder_input_ids 的起始標記。如果使用 past_key_values,則可以選擇只輸入最後一個 decoder_input_ids(參見 past_key_values)。

  • decoder_attention_mask (tf.Tensor,形狀為 (batch_size, target_sequence_length)可選) — 預設情況下會建立並忽略填充標記。對於大多數用例,不建議設定此項。
  • decoder_position_ids (tf.Tensor,形狀為 (batch_size, sequence_length)可選) — 每個解碼器輸入序列標記在位置嵌入中的位置索引。選自範圍 [0, config.max_position_embeddings - 1]
  • head_mask (tf.Tensor,形狀為 (encoder_layers, encoder_attention_heads)可選) — 用於在編碼器中置零注意力模組的選定頭部的掩碼。掩碼值選自 [0, 1]

    • 1 表示頭部未被掩碼
    • 0 表示頭部已被掩碼
  • decoder_head_mask (tf.Tensor,形狀為 (decoder_layers, decoder_attention_heads)可選) — 用於在解碼器中置零注意力模組的選定頭部的掩碼。掩碼值選自 [0, 1]

    • 1 表示頭部未被掩碼
    • 0 表示頭部已被掩碼
  • cross_attn_head_mask (tf.Tensor,形狀為 (decoder_layers, decoder_attention_heads)可選) — 用於置零交叉注意力模組的選定頭部的掩碼。掩碼值選自 [0, 1]

    • 1 表示頭部未被掩碼
    • 0 表示頭部已被掩碼
  • encoder_outputs (tf.FloatTensor, 可選) — 編碼器最後一層輸出的隱藏狀態。用於解碼器的交叉注意力。形狀為 (batch_size, sequence_length, hidden_size),是一個序列。
  • past_key_values (tuple[tuple[tf.Tensor]],長度為 config.n_layers) — 包含注意力模組預先計算的鍵和值隱藏狀態。可用於加速解碼。如果使用 past_key_values,使用者可以選擇只輸入最後一個 decoder_input_ids(形狀為 (batch_size, 1)),而不是所有形狀為 (batch_size, sequence_length)decoder_input_ids(那些沒有將其過去的鍵值狀態提供給該模型的ID)。
  • 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 mode)下使用,在圖模式(graph mode)下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。此引數只能在即時執行模式(eager mode)下使用,在圖模式(graph mode)下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在即時執行模式下使用,在圖模式下該值將始終設定為 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.TFSeq2SeqLMOutputtuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一個 tf.Tensor 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(MarianConfig)和輸入,包含各種元素。

  • loss (形狀為 (n,)tf.Tensor, 可選, 其中 n 是非掩碼標籤的數量,當提供 labels 時返回) — 語言建模損失。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數(SoftMax 之前每個詞彙標記的分數)。

  • past_key_values (list[tf.Tensor], 可選, 當傳遞 use_cache=True 或當 config.use_cache=True 時返回) — 長度為 config.n_layerstf.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 之後,用於計算自注意力頭中的加權平均。

TFMarianMTModel 的前向方法,重寫了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

marian-nmt 的 transformer.h (c++) 的 TF 版本。專為 OPUS-NMT 翻譯檢查點設計。可用模型列在此處

示例

>>> from transformers import AutoTokenizer, TFMarianMTModel
>>> from typing import List

>>> src = "fr"  # source language
>>> trg = "en"  # target language
>>> sample_text = "où est l'arrêt de bus ?"
>>> model_name = f"Helsinki-NLP/opus-mt-{src}-{trg}"

>>> model = TFMarianMTModel.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
>>> batch = tokenizer([sample_text], return_tensors="tf")
>>> gen = model.generate(**batch)
>>> tokenizer.batch_decode(gen, skip_special_tokens=True)
"Where is the bus stop ?"
JAX
隱藏 JAX 內容

FlaxMarianModel

class transformers.FlaxMarianModel

< >

( config: MarianConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (MarianConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重,只會載入配置。檢視 from_pretrained() 方法以載入模型權重。
  • dtype (jax.numpy.dtype, 可選, 預設為 jax.numpy.float32) — 計算的資料型別。可以是 jax.numpy.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定,所有計算都將使用給定的 `dtype` 進行。

    請注意,這僅指定計算的 dtype,不影響模型引數的 dtype。

    如果你想更改模型引數的 dtype,請參閱 to_fp16()to_bf16()

基礎的 Marian 模型轉換器,輸出原始的隱藏狀態,頂部沒有任何特定的頭部。該模型繼承自 FlaxPreTrainedModel。請檢視超類文件,瞭解庫為其所有模型實現的通用方法(如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

該模型也是 Flax Linen flax.nn.Module 的子類。像常規 Flax 模組一樣使用它,並參考 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.FlaxSeq2SeqModelOutputtuple(torch.FloatTensor)

引數

  • input_ids (jnp.ndarray,形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果您提供填充,預設情況下將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • 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()

    什麼是解碼器輸入 ID?

    對於翻譯和摘要訓練,應提供 `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.FlaxSeq2SeqModelOutputtuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一個 torch.FloatTensor 的元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),包含根據配置(MarianConfig)和輸入而變化的不同元素。

  • 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=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstuple(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=Trueconfig.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器交叉注意力層的注意力權重,在注意力 softmax 之後,用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)jnp.ndarray可選) — 模型編碼器最後一層輸出的隱藏狀態序列。

  • encoder_hidden_states (tuple(jnp.ndarray), 可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    編碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

FlaxMarianPreTrainedModel 的前向方法,重寫了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxMarianModel

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = FlaxMarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxMarianMTModel

class transformers.FlaxMarianMTModel

< >

( config: MarianConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (MarianConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
  • dtype (jax.numpy.dtype, 可選,預設為 jax.numpy.float32) — 計算的資料型別。可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定,所有計算都將使用給定的 dtype 執行。

    請注意,這僅指定計算的 dtype,不影響模型引數的 dtype。

    如果你希望更改模型引數的 dtype,請參閱 to_fp16()to_bf16()

帶有語言建模頭的 MARIAN 模型。可用於翻譯。該模型繼承自 FlaxPreTrainedModel。請查閱超類文件,瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入的大小、修剪頭部等)。

該模型也是 Flax Linen flax.nn.Module 的子類。像常規 Flax 模組一樣使用它,並參考 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.FlaxSeq2SeqLMOutputtuple(torch.FloatTensor)

引數

  • input_ids (形狀為 (batch_size, sequence_length)jnp.ndarray) — 詞彙表中輸入序列標記的索引。如果提供了填充,預設會被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (形狀為 (batch_size, sequence_length)jnp.ndarray, 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選自 [0, 1]

    • 1 表示未被遮蔽的標記,
    • 0 表示被遮蔽的標記。

    什麼是注意力掩碼?

  • decoder_input_ids (形狀為 (batch_size, target_sequence_length)jnp.ndarray, 可選) — 詞彙表中解碼器輸入序列標記的索引。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是解碼器輸入 ID?

    對於翻譯和摘要訓練,應提供 decoder_input_ids。如果未提供 decoder_input_ids,模型將根據論文中的去噪預訓練方法,透過向右移動 input_ids 來建立此張量。

  • decoder_attention_mask (形狀為 (batch_size, target_sequence_length)jnp.ndarray, 可選) — 預設行為:生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也會使用因果掩碼。

    如果你想改變填充行為,應根據你的需要進行修改。有關預設策略的更多資訊,請參閱論文中的圖 1。

  • position_ids (形狀為 (batch_size, sequence_length)numpy.ndarray, 可選) — 位置嵌入中每個輸入序列標記的位置索引。選自 [0, config.max_position_embeddings - 1] 範圍。
  • decoder_position_ids (形狀為 (batch_size, sequence_length)numpy.ndarray, 可選) — 位置嵌入中每個解碼器輸入序列標記的位置索引。選自 [0, config.max_position_embeddings - 1] 範圍。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊,請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊,請參閱返回張量下的 hidden_states
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutputtuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 的元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),包含根據配置(MarianConfig)和輸入而變化的不同元素。

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size)jnp.ndarray) — 語言建模頭的預測分數(SoftMax 之前每個詞彙 token 的分數)。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可選,當傳遞 use_cache=Trueconfig.use_cache=True 時返回) — 長度為 config.n_layerstuple(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=Trueconfig.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    解碼器交叉注意力層的注意力權重,在注意力 softmax 之後,用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)jnp.ndarray可選) — 模型編碼器最後一層輸出的隱藏狀態序列。

  • encoder_hidden_states (tuple(jnp.ndarray), 可選,當傳遞 output_hidden_states=Trueconfig.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray), 可選,當傳遞 output_attentions=Trueconfig.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    編碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。

FlaxMarianPreTrainedModel 的前向方法,重寫了 __call__ 特殊方法。

儘管前向傳遞的配方需要在此函式內定義,但之後應呼叫 Module 例項而不是此函式,因為前者負責執行前後處理步驟,而後者會默默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxMarianMTModel

>>> model = FlaxMarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> text = "My friends are cool but they eat too many carbs."
>>> input_ids = tokenizer(text, max_length=64, return_tensors="jax").input_ids

>>> sequences = model.generate(input_ids, max_length=64, num_beams=2).sequences

>>> outputs = tokenizer.batch_decode(sequences, skip_special_tokens=True)
>>> # should give *Meine Freunde sind cool, aber sie essen zu viele Kohlenhydrate.*
< > 在 GitHub 上更新

© . This site is unofficial and not affiliated with Hugging Face, Inc.