Transformers 文件
MarianMT
並獲得增強的文件體驗
開始使用
MarianMT
概述
一個用於翻譯模型的框架,使用與 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 模型的詞彙表大小。定義了在呼叫 MarianModel 或 TFMarianModel 時,可以透過 `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) — 全連線層內啟用函式的丟棄率。 - 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
透過追加 eos_token_id 從序列構建模型輸入。
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.Seq2SeqModelOutput 或 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()。
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
,使用者可以選擇只輸入形狀為(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_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.Tensor
,形狀為(sequence_length)
,可選) — 描繪輸入序列詞元在序列中位置的索引。與position_ids
相反,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(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.Seq2SeqLMOutput 或 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()。
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.Seq2SeqLMOutput 或 tuple(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
forward
< source >( 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()。
- 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.CausalLMOutputWithCrossAttentions 或 tuple(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
TFMarianModel
class transformers.TFMarianModel
< source >( 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 函式一樣傳遞輸入!
呼叫
< source >( 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()。
- 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()。
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.TFSeq2SeqModelOutput 或 tuple(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_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 之後,用於計算自注意力頭中的加權平均。
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.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()。
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.TFSeq2SeqLMOutput 或 tuple(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_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 之後,用於計算自注意力頭中的加權平均。
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 ?"
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.float32
、jax.numpy.float16
(在 GPU 上)和jax.numpy.bfloat16
(在 TPU 上)之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定,所有計算都將使用給定的 `dtype` 進行。
請注意,這僅指定計算的 dtype,不影響模型引數的 dtype。
基礎的 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.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
時),包含根據配置(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=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
時返回) —jnp.ndarray
的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為(batch_size, sequence_length, hidden_size)
。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.output_attentions=True
時返回) —jnp.ndarray
的元組(每層一個),形狀為(batch_size, num_heads, sequence_length, sequence_length)
。解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.output_attentions=True
時返回) —jnp.ndarray
的元組(每層一個),形狀為(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=True
或config.output_hidden_states=True
時返回) —jnp.ndarray
的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為(batch_size, sequence_length, hidden_size)
。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.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.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定,所有計算都將使用給定的
dtype
執行。請注意,這僅指定計算的 dtype,不影響模型引數的 dtype。
帶有語言建模頭的 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.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (形狀為
(batch_size, sequence_length)
的jnp.ndarray
) — 詞彙表中輸入序列標記的索引。如果提供了填充,預設會被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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()。
對於翻譯和摘要訓練,應提供
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.FlaxSeq2SeqLMOutput 或 tuple(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=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
時返回) —jnp.ndarray
的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為(batch_size, sequence_length, hidden_size)
。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.output_attentions=True
時返回) —jnp.ndarray
的元組(每層一個),形狀為(batch_size, num_heads, sequence_length, sequence_length)
。解碼器的注意力權重,在注意力 softmax 之後,用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.output_attentions=True
時返回) —jnp.ndarray
的元組(每層一個),形狀為(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=True
或config.output_hidden_states=True
時返回) —jnp.ndarray
的元組(一個用於嵌入層的輸出,一個用於每一層的輸出),形狀為(batch_size, sequence_length, hidden_size)
。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(jnp.ndarray)
, 可選,當傳遞output_attentions=True
或config.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.*