Transformers 文档
NLLB-MOE
并获得增强的文档体验
开始使用
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 在论文 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.configNllbMoeTop2Router
使用 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()。
- 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()。
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_stateNllbMoeForConditionalGeneration
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()。
- 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，形状为(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))