NLLB-MOE
概述
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 发表的论文 不遗漏任何语言：扩展以人为中心的机器翻译 中提出。
论文摘要如下
受全球消除语言障碍目标的驱动，机器翻译已成为当今人工智能研究的重点领域。然而，此类工作主要集中在少数几种语言上，而大多数资源匮乏的语言却被忽视了。如何在确保安全、高质量结果的同时，突破 200 种语言的界限，并同时考虑伦理问题？在“No Language Left Behind”项目中，我们首先通过与母语人士的探索性访谈，阐明了对低资源语言翻译支持的需求。然后，我们创建了旨在缩小低资源语言和高资源语言之间性能差距的数据集和模型。更具体地说，我们开发了一种基于稀疏门控专家混合（Sparsely Gated Mixture of Experts）的条件计算模型，该模型使用针对低资源语言量身定制的新颖且有效的数据挖掘技术获得的数据进行训练。我们提出了多种架构和训练改进措施，以在对数千个任务进行训练时抵消过拟合。至关重要的是，我们使用人类翻译基准 Flores-200 评估了超过 40,000 个不同翻译方向的性能，并将人类评估与涵盖 Flores-200 中所有语言的新型毒性基准相结合，以评估翻译的安全性。我们的模型在 BLEU 分数方面相较于之前的最先进技术提高了 44%，为实现通用翻译系统奠定了重要的基础。
该模型由 Arthur Zucker 贡献。原始代码可以在这里找到 here。
使用技巧
- M2M100ForConditionalGeneration 是 NLLB 和 NLLB MoE 的基础模型。
- NLLB-MoE 与 NLLB 模型非常相似，但它的前馈层基于 SwitchTransformers 的实现。
- 分词器与 NLLB 模型相同。
与 SwitchTransformers 的实现差异
最大的区别在于标记路由的方式。NLLB-MoE 使用 top-2-gate，这意味着对于每个输入，仅根据门控网络中预测的最高概率选择前两个专家，而忽略其余专家。在 SwitchTransformers 中，仅计算前 1 个概率，这意味着标记被转发的概率较低。此外，如果标记未路由到任何专家，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) — 层和池化层（pooler layer）的维度。 - 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) — 初始化所有权重矩阵的截断正态初始化器的标准差。 - encoder_layerdrop (
float，可选，默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://arxiv.org/abs/1909.11556)。 - decoder_layerdrop (
float，可选，默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://arxiv.org/abs/1909.11556)。 - batch_prioritized_routing (
bool，可选，默认为True) — 是否在容量丢弃之前根据其路由器概率对标记进行排序。这意味着具有最高概率的标记将在其他可能在序列中更靠后的标记之前被路由。 - moe_eval_capacity_token_fraction (
float，可选，默认为 1.0) — 验证期间作为容量的标记分数，如果设置为负数，则使用与训练相同的容量。应在范围内：(0.0, 1.0]。 - num_experts (
int，可选，默认为 128) — 每个 NllbMoeSparseMlp 层的专家数量。 - expert_capacity (
int，可选，默认为 64) — 每个专家可以存储的标记数量。 - 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) — 在路由时是否忽略填充标记。如果False，则填充标记不会路由到任何专家。 - router_bias (
bool，可选，默认为False) — 路由器的分类器是否应该有偏差。 - 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.configNllbMoeTop2Router
使用令牌选择前 2 个专家分配的路由器。
此路由器使用与 fairseq 代码库中的 NLLB-MoE 相同的机制。项目按 router_probs 排序，然后路由到其选择的专家，直到专家的 expert_capacity 达到为止。**不能保证每个令牌都由专家处理**，或者每个专家至少接收一个令牌。
路由器组合权重也会返回，以确保未更新的状态将被屏蔽。
route_tokens
< 源代码 >( router_logits: Tensor input_dtype: dtype = torch.float32 padding_mask: Optional = None )
计算每个专家的dispatch_mask和dispatch_weights。掩码已适应专家容量。
forward
< 源代码 >( hidden_states: Tensor padding_mask: Optional = 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] 的索引张量，对应于使用路由器的前 1 个概率为每个令牌选择的专家。router_probabilities (torch.Tensor 形状为 (batch_size, sequence_length, nump_experts))：形状为 (batch_size, sequence_length, num_experts) 的张量，对应于每个令牌和专家的概率。用于将令牌路由到专家。router_logits (torch.Tensor 形状为 (batch_size, sequence_length))：形状为 (batch_size, sequence_length, num_experts) 的 logits 张量，对应于原始路由器 logits。这随后用于计算路由器 z 损失。
隐藏状态被重新整形以简化路由器概率的计算（每个专家的组合权重）。
NllbMoeSparseMLP
类 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: Optional = 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
类 transformers.NllbMoeModel
< 源代码 >( config: NllbMoeConfig )
参数
- config (NllbMoeConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
基本的 NllbMoe 模型，输出原始隐藏状态，没有任何特定的头部。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_router_logits: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.Seq2SeqMoEModelOutput 或 tuple(torch.FloatTensor)
参数
返回值
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 (
tuple(tuple(torch.FloatTensor))，可选，在传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递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，用于计算专家混合模型的辅助损失。
-
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 正向方法覆盖了 __call__ 特殊方法。
尽管正向传递的配方需要在此函数内定义，但此后应该调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则静默忽略它们。
NllbMoeModel 正向方法覆盖了 __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_stateNllbMoeForConditionalGeneration
类 transformers.NllbMoeForConditionalGeneration
< 源代码 >( config: NllbMoeConfig )
参数
- config (NllbMoeConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
具有语言建模头的 NllbMoe 模型。可用于摘要。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪 head 等）。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_router_logits: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.Seq2SeqMoEOutput 或 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()。
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形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。在[0, 1]中选择掩码值：- 1 表示头部**未被掩码**，
- 0 表示头部**被掩码**。
- decoder_head_mask (
torch.Tensor形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。在[0, 1]中选择掩码值：- 1 表示头部**未被掩码**，
- 0 表示头部**被掩码**。
- cross_attn_head_mask (
torch.Tensor形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中交叉注意力模块的选定头部无效的掩码。掩码值选自[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)，可选) — 元组包含 (last_hidden_state，可选:hidden_states，可选:attentions)last_hidden_state形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的一系列隐藏状态。用于解码器的交叉注意力。 - past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有为此模型提供过去键值状态的），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量（而不是模型的内部嵌入查找矩阵）有更多控制，这将很有用。 - decoder_inputs_embeds (
torch.FloatTensor形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您希望对如何将decoder_input_ids索引转换为关联向量（而不是模型的内部嵌入查找矩阵）有更多控制，这将很有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，则decoder_inputs_embeds将取inputs_embeds的值。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - output_router_logits (
bool，可选) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，在推理期间不应返回。 - labels (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 之间（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
返回值
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 (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，在传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递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，用于计算专家混合模型的辅助损失。
-
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。
The NllbMoeForConditionalGeneration 前向方法，覆盖了 __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))