Hugging Face 的 LOGO

Transformers 文件

NLLB-MOE

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

NLLB-MOE

PyTorch

概述

NLLB 模型由 Marta R. Costa-jussà、James Cross、Onur Çelebi、Maha Elbayad、Kenneth Heafield、Kevin Heffernan、Elahe Kalbassi、Janice Lam、Daniel Licht、Jean Maillard、Anna Sun、Skyler Wang、Guillaume Wenzek、Al Youngblood、Bapi Akula、Loic Barrault、Gabriel Mejia Gonzalez、Prangthip Hansanti、John Hoffman、Semarley Jarrett、Kaushik Ram Sadagopan、Dirk Rowe、Shannon Spruit、Chau Tran、Pierre Andrews、Necip Fazil Ayan、Shruti Bhosale、Sergey Edunov、Angela Fan、Cynthia Gao、Vedanuj Goswami、Francisco Guzmán、Philipp Koehn、Alexandre Mourachko、Christophe Ropers、Safiyyah Saleem、Holger Schwenk 和 Jeff Wang 在論文 No Language Left Behind: Scaling Human-Centered Machine Translation 中提出。

論文摘要如下：

在消除全球語言障礙的目標驅動下，機器翻譯已成為當今人工智慧研究的核心焦點。然而，這些努力集中於一小部分語言，而絕大多數低資源語言被忽略了。在確保安全、高質量結果的同時，要突破 200 種語言的障礙，併兼顧倫理考量，需要做些什麼？在 No Language Left Behind 專案中，我們透過與母語者進行探索性訪談，首先了解了低資源語言翻譯支援的需求背景，從而迎接了這一挑戰。然後，我們建立了資料集和模型，旨在縮小低資源語言與高資源語言之間的效能差距。具體來說，我們開發了一個基於稀疏門控混合專家（Sparsely Gated Mixture of Experts）的條件計算模型，並使用針對低資源語言量身定製的新穎有效的資料探勘技術獲取的資料進行訓練。我們提出了多項架構和訓練改進，以在訓練數千個任務時對抗過擬合。至關重要的是，我們使用人工翻譯的基準 Flores-200 評估了超過 40,000 個不同翻譯方向的效能，並將人工評估與涵蓋 Flores-200 中所有語言的新型毒性基準相結合，以評估翻譯的安全性。我們的模型相比之前的最先進技術，BLEU 分數提高了 44%，為實現通用翻譯系統奠定了重要基礎。

此模型由 Arthur Zucker 貢獻。原始程式碼可在此處找到。

使用技巧

  • M2M100ForConditionalGeneration 是 NLLB 和 NLLB MoE 的基礎模型。
  • NLLB-MoE 模型與 NLLB 模型非常相似，但其前饋層基於 SwitchTransformers 的實現。
  • 分詞器與 NLLB 模型相同。

與 SwitchTransformers 的實現差異

最大的區別在於 token 的路由方式。NLLB-MoE 使用 `top-2-gate`，這意味著對於每個輸入，僅根據門控網路預測的最高機率選擇前兩個專家，而忽略其餘的專家。在 `SwitchTransformers` 中，只計算 top-1 機率，這意味著 token 被轉發的機率更小。此外，如果一個 token 沒有被路由到任何專家，`SwitchTransformers` 仍然會加上其未經修改的隱藏狀態（類似殘差連線），而在 `NLLB` 的 top-2 路由機制中，它們會被掩碼掉。

使用 NLLB-MoE 進行生成

可用的檢查點需要大約 350GB 的儲存空間。如果你的機器沒有足夠的記憶體，請確保使用 `accelerate`。

在生成目標文字時，將 `forced_bos_token_id` 設定為目標語言的 ID。以下示例展示瞭如何使用 *facebook/nllb-200-distilled-600M* 模型將英語翻譯為法語。

請注意，我們使用的是法語的 BCP-47 程式碼 `fra_Latn`。有關 Flores 200 資料集中所有 BCP-47 程式碼的列表，請參閱此處。

>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-moe-54b")

>>> article = "Previously, Ring's CEO, Jamie Siminoff, remarked the company started when his doorbell wasn't audible from his shop in his garage."
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["fra_Latn"], max_length=50
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
"Auparavant, le PDG de Ring, Jamie Siminoff, a fait remarquer que la société avait commencé lorsque sa sonnette n'était pas audible depuis son magasin dans son garage."

從英語以外的任何其他語言生成

英語（`eng_Latn`）被設定為預設的翻譯源語言。要指定從不同語言翻譯，應在分詞器初始化的 `src_lang` 關鍵字引數中指定 BCP-47 程式碼。

以下是從羅馬尼亞語翻譯為德語的示例

>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b", src_lang="ron_Latn")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-moe-54b")

>>> article = "Şeful ONU spune că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(article, return_tensors="pt")

>>> translated_tokens = model.generate(
...     **inputs, forced_bos_token_id=tokenizer.lang_code_to_id["deu_Latn"], max_length=30
... )
>>> tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]

資源

NllbMoeConfig

class transformers.NllbMoeConfig

< >

( vocab_size = 128112 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.05 decoder_layerdrop = 0.05 use_cache = True is_encoder_decoder = True activation_function = 'relu' d_model = 1024 dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True router_bias = False router_dtype = 'float32' router_ignore_padding_tokens = False num_experts = 128 expert_capacity = 64 encoder_sparse_step = 4 decoder_sparse_step = 4 router_z_loss_coef = 0.001 router_aux_loss_coef = 0.001 second_expert_policy = 'all' normalize_router_prob_before_dropping = False batch_prioritized_routing = False moe_eval_capacity_token_fraction = 1.0 moe_token_dropout = 0.2 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 output_router_logits = False **kwargs )

引數

  • vocab_size (int，可選，預設為 50265) — NllbMoe 模型的詞彙表大小。定義了在呼叫 NllbMoeModel 時傳入的 `inputs_ids` 可以表示的不同標記的數量。
  • d_model (int，可選，預設為 1024) — 各層和池化層的維度。
  • encoder_layers (int，可選，預設為 12) — 編碼器層數。
  • decoder_layers (int，可選，預設為 12) — 解碼器層數。
  • encoder_attention_heads (int，可選，預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • decoder_attention_heads (int，可選，預設為 16) — Transformer 解碼器中每個注意力層的注意力頭數量。
  • decoder_ffn_dim (int，可選，預設為 4096) — 解碼器中“中間層”（通常稱為前饋層）的維度。
  • encoder_ffn_dim (int，可選，預設為 4096) — 編碼器中“中間層”（通常稱為前饋層）的維度。
  • activation_function (str 或 function，可選，預設為 "gelu") — 編碼器和池化層中的非線性啟用函式（函式或字串）。如果為字串，則支援 "gelu"、"relu"、"silu" 和 "gelu_new"。
  • dropout (float，可選，預設為 0.1) — 嵌入層、編碼器和池化層中所有全連線層的 dropout 機率。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力機率的 dropout 比率。
  • activation_dropout (float, 可選, 預設為 0.0) — 全連線層內部啟用函式的 dropout 比率。
  • classifier_dropout (float, 可選, 預設為 0.0) — 分類器的 dropout 比率。
  • max_position_embeddings (int, 可選, 預設為 1024) — 該模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需（例如，512、1024 或 2048）。
  • init_std (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
  • encoder_layerdrop (float, 可選, 預設為 0.0) — 編碼器的 LayerDrop 機率。更多詳情請參閱 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。
  • decoder_layerdrop (float, 可選, 預設為 0.0) — 解碼器的 LayerDrop 機率。更多詳情請參閱 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。
  • second_expert_policy ( str, 可選, 預設為 "all") — 用於為每個 token 取樣被分配到第二個專家的機率的策略。
  • normalize_router_prob_before_dropping (bool, 可選, 預設為 True) — 是否在根據專家容量應用掩碼（容量丟棄）之前對路由器機率進行歸一化。
  • batch_prioritized_routing (bool, 可選, 預設為 True) — 是否在容量丟棄前按路由器機率對 token 進行排序。這意味著機率最高的 token 將在序列中可能更靠後的其他 token 之前被路由。
  • moe_eval_capacity_token_fraction (float, 可選, 預設為 1.0) — 驗證期間作為容量的 token 比例，如果設定為負數，則使用與訓練時相同的設定。應在 (0.0, 1.0] 範圍內。
  • num_experts (int, 可選, 預設為 128) — 每個 NllbMoeSparseMlp 層的專家數量。
  • expert_capacity (int, 可選, 預設為 64) — 每個專家可以儲存的 token 數量。
  • encoder_sparse_step (int, 可選, 預設為 4) — 編碼器中稀疏層的頻率。4 表示每 4 層中有一層是稀疏層。
  • decoder_sparse_step (int, 可選, 預設為 4) — 解碼器中稀疏層的頻率。4 表示每 4 層中有一層是稀疏層。
  • router_dtype (str, 可選, 預設為 "float32") — 用於路由器的 dtype。最好將 dtype 保持為 "float32"，正如論文中關於 *選擇性精度* 的討論中所指定的。
  • router_ignore_padding_tokens (bool, 可選, 預設為 False) — 在路由時是否忽略填充 token。如果為 False，填充 token 將不會被路由到任何專家。
  • router_bias (bool, 可選, 預設為 False) — 路由器的分類器是否應有偏置。
  • moe_token_dropout (float, 可選, 預設為 0.2) — MoE 專家輸出掩碼（EOM）的掩位元速率，透過在專家輸出上應用 Dropout2d 實現。
  • output_router_logits (bool, 可選, 預設為 False) — 是否返回路由器 logits。僅在訓練時為了獲得輔助損失時設定為 True。
  • use_cache (bool, 可選, 預設為 True) — 模型是否應返回最後的鍵/值注意力（並非所有模型都使用）。

這是一個配置類，用於儲存 NllbMoeModel 的配置。它用於根據指定的引數例項化一個 NLLB-MoE 模型，定義模型架構。使用預設值例項化一個配置將產生與 NLLB-MoE facebook/nllb-moe-54b 架構類似的配置。

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

示例

>>> from transformers import NllbMoeModel, NllbMoeConfig

>>> # Initializing a NllbMoe facebook/nllb-moe-54b style configuration
>>> configuration = NllbMoeConfig()

>>> # Initializing a model from the facebook/nllb-moe-54b style configuration
>>> model = NllbMoeModel(configuration)

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

NllbMoeTop2Router

class transformers.NllbMoeTop2Router

< >

( config: NllbMoeConfig )

使用 token 選擇 top-2 專家分配的路由器。

該路由器使用與 fairseq 倉庫中 NLLB-MoE 相同的機制。專案按 router_probs 排序，然後路由到它們選擇的專家，直到達到專家的 expert_capacity。不保證每個 token 都被專家處理，也不保證每個專家至少收到一個 token。

路由器組合權重也會被返回，以確保未更新的狀態將被掩蓋。

route_tokens

< >

( router_logits: Tensor input_dtype: dtype = torch.float32 padding_mask: typing.Optional[torch.LongTensor] = None )

為每個專家計算 dispatch_mask 和 dispatch_weights。這些掩碼會適應專家的容量。

forward

< >

( hidden_states: Tensor padding_mask: typing.Optional[torch.LongTensor] = None ) → top_1_mask (torch.Tensor，形狀為 (batch_size, sequence_length))

引數

  • hidden_states (torch.Tensor) — (batch_size, sequence_length, hidden_dim) ，用於計算路由器機率。

返回

top_1_mask (torch.Tensor，形狀為 (batch_size, sequence_length))

形狀為 [batch_size, sequence_length] 的索引張量，對應於使用路由器 top1 機率為每個 token 選擇的專家。router_probabilities (torch.Tensor，形狀為 (batch_size, sequence_length, num_experts)): 形狀為 (batch_size, sequence_length, num_experts) 的張量，對應於每個 token 和專家的機率。用於將 token 路由到專家。router_logits (torch.Tensor，形狀為 (batch_size, sequence_length))): 形狀為 (batch_size, sequence_length, num_experts) 的 logits 張量，對應於原始路由器 logits。這將在稍後用於計算路由器 z-loss。

隱藏狀態被重塑以簡化路由器機率（每個專家的組合權重）的計算。

NllbMoeSparseMLP

class transformers.NllbMoeSparseMLP

< >

( config: NllbMoeConfig ffn_dim: int expert_class: Module = <class 'transformers.models.nllb_moe.modeling_nllb_moe.NllbMoeDenseActDense'> )

NLLB-MoE 稀疏 MLP 模組的實現。

forward

< >

( hidden_states: Tensor padding_mask: typing.Optional[torch.Tensor] = False ) → hidden_states (torch.Tensor，形狀為 (batch_size, sequence_length, hidden_dim))

引數

  • hidden_states (torch.Tensor，形狀為 (batch_size, sequence_length, hidden_dim)) — 隱藏狀態
  • padding_mask (torch.Tensor, 可選, 預設為 False) — 注意力掩碼。可以是因果形式，也可以不是。

返回

hidden_states (torch.Tensor，形狀為 (batch_size, sequence_length, hidden_dim))

更新後的隱藏狀態 router_logits (torch.Tensor，形狀為 (batch_size, sequence_length, num_experts)): 計算損失所需

這個前向傳播的目標是與等效的 NllbMoeDenseActDense (mlp) 層具有相同的運算元。這意味著所有的隱藏狀態最多被處理兩次（因為我們使用 top_2 門控機制）。這意味著我們將複雜度保持在 O(batch_size x sequence_length x hidden_dim)，而不是 O(num_experts x batch_size x sequence_length x hidden_dim)。

1- 從 `router` 獲取 `router_probs`。`router_mask` 的形狀是 `(batch_size X sequence_length, num_expert)`，對應於 `router_probs` 的布林版本。輸入使用 `router_mask` 進行掩碼。

2- 將 hidden_states 分派給其關聯的專家。路由器機率用於在更新掩碼後的隱藏狀態時對每個專家的貢獻進行加權。

NllbMoeModel

class transformers.NllbMoeModel

< >

( config: NllbMoeConfig )

引數

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

基礎的 Nllb Moe 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。

該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是一個 PyTorch torch.nn.Module 子類。像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_router_logits: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqMoEModelOutput 或 tuple(torch.FloatTensor)

引數

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

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

    什麼是 input IDs？

  • attention_mask (torch.Tensor，形狀為 (batch_size, sequence_length), 可選) — 用於避免在填充 token 索引上執行注意力的掩碼。掩碼值在 [0, 1] 中選擇：

    • 1 表示 token 未被掩碼,
    • 0 表示 token 被掩碼。

    什麼是注意力掩碼？

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

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

    什麼是解碼器輸入 IDs？

    NllbMoe 使用 eos_token_id 作為生成 decoder_input_ids 的起始 token。如果使用 past_key_values，可以選擇只輸入最後一個 decoder_input_ids（參見 past_key_values）。

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

    允許兩種格式：

    • 一個 Cache 例項，請參閱我們的 kv 快取指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組有兩個形狀為 (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，形狀為 (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。
  • output_router_logits (bool，可選) — 是否返回所有路由器的 logits。它們對於計算路由器損失很有用，在推理期間不應返回。
  • return_dict (bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_outputs.Seq2SeqMoEModelOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.Seq2SeqMoEModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（NllbMoeConfig）和輸入而變化的不同元素。

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

  • decoder_router_logits (tuple(torch.FloatTensor)，可選，當傳遞 output_router_logits=True 或 config.add_router_probs=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, sequence_length, num_experts)。

    解碼器模型的路由器 logits，用於計算混合專家模型（MoE）的輔助損失。

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

  • encoder_router_logits (tuple(torch.FloatTensor)，可選，當傳遞 output_router_logits=True 或 config.add_router_probs=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, sequence_length, num_experts)。

    編碼器模型的路由器 logits，用於計算稀疏模組的輔助損失和 z_loss。

NllbMoeModel 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默忽略它們。

示例

>>> from transformers import AutoTokenizer, NllbMoeModel

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/random-nllb-moe-2-experts")
>>> model = SwitchTransformersModel.from_pretrained("hf-internal-testing/random-nllb-moe-2-experts")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1

>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for NllbMoeModel
>>> decoder_input_ids = model._shift_right(decoder_input_ids)

>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state

NllbMoeForConditionalGeneration

class transformers.NllbMoeForConditionalGeneration

< >

( config: NllbMoeConfig )

引數

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

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

該模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭等）。

該模型也是一個 PyTorch torch.nn.Module 子類。像常規的 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_router_logits: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqMoEOutput 或 tuple(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？

    NllbMoe 使用 eos_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 (tuple[tuple[torch.FloatTensor]]，可選) — 元組包含 (last_hidden_state, 可選: hidden_states, 可選: attentions) last_hidden_state，形狀為 (batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。
  • past_key_values (tuple[tuple[torch.FloatTensor]]，可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在先前解碼階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 Cache 例項，請參閱我們的 kv 快取指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 的元組，每個元組有兩個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量。這也稱為舊版快取格式。

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

    如果使用 past_key_values，使用者可以選擇只輸入最後一個形狀為 (batch_size, 1) 的 input_ids（那些沒有將其過去鍵值狀態提供給此模型的詞元），而不是所有形狀為 (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 的值。

  • labels (torch.LongTensor，形狀為 (batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在 [0, ..., config.vocab_size] 或 -100 之間（參見 input_ids 文件字串）。索引設定為 -100 的詞元將被忽略（掩碼），損失僅對標籤在 [0, ..., config.vocab_size] 中的詞元計算。
  • use_cache (bool，可選) — 如果設定為 True，將返回 past_key_values 鍵值狀態，並可用於加速解碼（參見 past_key_values）。
  • output_attentions (bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
  • output_hidden_states (bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
  • output_router_logits (bool，可選) — 是否返回所有路由器的 logits。它們對於計算路由器損失很有用，在推理期間不應返回。
  • return_dict (bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_outputs.Seq2SeqMoEOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.Seq2SeqMoEOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（NllbMoeConfig）和輸入而變化的不同元素。

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

  • decoder_router_logits (tuple(torch.FloatTensor)，可選，當傳遞 output_router_logits=True 或 config.add_router_probs=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, sequence_length, num_experts)。

    解碼器模型的路由器 logits，用於計算混合專家模型（MoE）的輔助損失。

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

  • encoder_router_logits (tuple(torch.FloatTensor)，可選，當傳遞 output_router_logits=True 或 config.add_router_probs=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, sequence_length, num_experts)。

    編碼器模型的路由器 logits，用於計算混合專家模型（MoE）的輔助損失和 z_loss。

NllbMoeForConditionalGeneration 的 forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默忽略它們。

翻譯示例

>>> from transformers import AutoTokenizer, NllbMoeForConditionalGeneration

>>> model = NllbMoeForConditionalGeneration.from_pretrained("facebook/nllb-moe-54b")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b")

>>> text_to_translate = "Life is like a box of chocolates"
>>> model_inputs = tokenizer(text_to_translate, return_tensors="pt")

>>> # translate to French
>>> gen_tokens = model.generate(**model_inputs, forced_bos_token_id=tokenizer.get_lang_id("eng_Latn"))
>>> print(tokenizer.batch_decode(gen_tokens, skip_special_tokens=True))
< > 在 GitHub 上更新

←NLLB Nyströmformer→
© . This site is unofficial and not affiliated with Hugging Face, Inc.