Transformers 文档

NLLB-MOE

NLLB-MOE

概述

NLLB模型在《No Language Left Behind: Scaling Human-Centered Machine Translation》一文中由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种语言的障碍,并牢记伦理考虑?在“不让任何语言掉队”项目中,我们通过与原语者的探索性访谈,首先将低资源语言翻译支持的需求置于背景中。然后,我们创建了旨在缩小低资源语言和高资源语言之间性能差距的数据集和模型。更具体地说,我们开发了一个基于稀疏门控专家混合的条件计算模型,该模型使用针对低资源语言量身定制的新颖有效的数据挖掘技术获得的数据进行训练。我们提出了多种架构和训练改进措施,以在数千个任务训练中对抗过拟合。关键的是,我们使用人工翻译的基准Flores-200评估了超过40,000种不同翻译方向的性能,并将人工评估与覆盖Flores-200所有语言的新型毒性基准相结合,以评估翻译的安全性。我们的模型相对于之前的最新技术实现了44%的BLEU提升,为实现通用翻译系统奠定了重要基础。

该模型由Arthur Zucker贡献。 原始代码可以在这里找到。

使用提示

  • 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

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, optional, 默认为 1024) — 层和池化层的维度。
  • encoder_layers (int, optional, defaults to 12) — 编码器层数.
  • decoder_layers (int, optional, defaults to 12) — 解码器层数.
  • encoder_attention_heads (int, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
  • decoder_attention_heads (int, optional, defaults to 16) — Transformer解码器中每个注意力层的注意力头数量。
  • decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”(通常称为前馈)层的维度。
  • encoder_ffn_dim (int, optional, defaults to 4096) — 编码器中“中间”(通常称为前馈)层的维度。
  • activation_function (strfunction, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu""relu""silu""gelu_new"
  • dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的dropout概率。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的dropout比率.
  • activation_dropout (float, optional, defaults to 0.0) — 全连接层内部激活函数的丢弃比例。
  • classifier_dropout (float, optional, defaults to 0.0) — 分类器的丢弃比例。
  • max_position_embeddings (int, optional, 默认为 1024) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • init_std (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的LayerDrop概率。有关更多详细信息,请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • decoder_layerdrop (float, optional, 默认为 0.0) — 解码器的LayerDrop概率。有关更多详细信息,请参阅[LayerDrop论文](see https://arxiv.org/abs/1909.11556)。
  • second_expert_policy ( str, 可选, 默认为 "all") — 用于采样每个标记被采样到第二个专家的概率的策略。
  • normalize_router_prob_before_dropping (bool, optional, defaults to True) — 是否在基于专家容量(容量丢弃)应用掩码之前对路由器概率进行归一化。
  • batch_prioritized_routing (bool, 可选, 默认为 True) — 是否在容量丢弃之前根据路由概率对令牌进行排序。这意味着具有最高概率的令牌将比其他可能位于序列更后面的令牌先被路由。
  • moe_eval_capacity_token_fraction (float, optional, defaults to 1.0) — 验证期间作为容量的令牌比例,如果设置为负数,则使用与训练相同的比例。应在范围内:(0.0, 1.0]。
  • num_experts (int, 可选, 默认为 128) — 每个 NllbMoeSparseMlp 层的专家数量。
  • expert_capacity (int, optional, defaults to 64) — 每个专家可以存储的令牌数量。
  • encoder_sparse_step (int, optional, 默认为 4) — 编码器中稀疏层的频率。4 表示每 4 层中有一层是稀疏的。
  • decoder_sparse_step (int, optional, 默认为 4) — 解码器中稀疏层的频率。4 表示每 4 层中有一层是稀疏的。
  • router_dtype (str, 可选, 默认为 "float32") — 用于路由器的dtype。最好将dtype保持为"float32",如论文中的选择性精度讨论中所指定的那样。
  • router_ignore_padding_tokens (bool, 可选, 默认为 False) — 是否在路由时忽略填充标记。如果为 False,填充标记不会被路由到任何专家。
  • router_bias (bool, optional, defaults to False) — 路由器的分类器是否应该有一个偏置项。
  • moe_token_dropout (float, optional, defualt ot 0.2) — MoE专家输出掩码(EOM)的掩码率,这是通过在专家输出上应用Dropout2d来实现的。
  • output_router_logits (bool, 可选, 默认为 False) — 是否返回路由器logits。仅在训练时获取辅助损失时设置为True
  • use_cache (bool, optional, 默认为 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

transformers.NllbMoeTop2Router

< >

( config: NllbMoeConfig )

使用令牌的路由器选择前2位专家分配。

该路由器使用与fairseq仓库中的NLLB-MoE相同的机制。项目按router_probs排序,然后路由到它们选择的专家,直到达到专家的expert_capacity。不能保证每个标记都由专家处理,也不能保证每个专家至少接收一个标记。

路由器的组合权重也会被返回,以确保未更新的状态将被屏蔽。

route_tokens

< >

( router_logits: 张量 input_dtype: 数据类型 = torch.float32 padding_mask: 可选[torch.LongTensor] = 无 )

计算每个专家的dispatch_maskdispatch_weights。这些掩码会根据专家的容量进行调整。

前进

< >

( 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 概率为每个令牌选择的专家。 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-loss。

隐藏状态被重新塑造以简化路由器概率的计算(结合每个专家的权重)。

NllbMoeSparseMLP

transformers.NllbMoeSparseMLP

< >

( config: NllbMoeConfig ffn_dim: int expert_class: Module = )

NLLB-MoE稀疏MLP模块的实现。

前进

< >

( hidden_states: Tensor padding_mask: typing.Optional[torch.Tensor] = False ) hidden_states (torch.Tensor 形状为 (batch_size, sequence_length, hidden_dim))

参数

  • hidden_states (torch.Tensor of shape (batch_size, sequence_length, hidden_dim)) — 隐藏状态
  • padding_mask (torch.Tensor, optional, defaults to False) — 注意力掩码。可以是因果形式或非因果形式。

返回

隐藏状态(形状为(batch_size, sequence_length, hidden_dim)torch.Tensor

更新隐藏状态 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_probsrouter_mask的形状是(batch_size X sequence_length, num_expert),对应于router_probs的布尔版本。输入使用router_mask进行掩码。

2- 将隐藏状态分发到其关联的专家。路由器概率用于在更新掩码隐藏状态时加权每个专家的贡献。

NllbMoeModel

transformers.NllbMoeModel

< >

( config: NllbMoeConfig )

参数

  • config (NllbMoeConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化时不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的NllbMoe模型输出原始隐藏状态,没有任何特定的头部。 该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头部等)。

该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。

前进

< >

( 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.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.Seq2SeqMoEModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下,如果您提供了填充,它将被忽略。

返回

transformers.modeling_outputs.Seq2SeqMoEModelOutputtuple(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_layerstuple(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 的 forward 方法,重写了 __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_state

NllbMoeForConditionalGeneration

transformers.NllbMoeForConditionalGeneration

< >

( config: NllbMoeConfig )

参数

  • config (NllbMoeConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化时不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

带有语言建模头的NllbMoe模型。可用于摘要生成。 该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。

前进

< >

( 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.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.Seq2SeqMoEOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — Indices of decoder input sequence tokens in the vocabulary.

    可以使用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 of shape (batch_size, target_sequence_length), 可选) — 默认行为:生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也会使用因果掩码。
  • head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于在编码器中屏蔽注意力模块中选定的头。在 [0, 1] 中选择的掩码值:
    • 1 表示头 未被屏蔽,
    • 0 表示头 被屏蔽.
  • decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中取消选择注意力模块的特定头部的掩码。掩码值在 [0, 1] 中选择:
    • 1 表示头部 未被掩码,
    • 0 表示头部 被掩码.
  • cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中取消选择交叉注意力模块的特定头的掩码。掩码值在 [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)), optional, returned when use_cache=True is passed or when config.use_cache=True) — Tuple of tuple(torch.FloatTensor) of length config.n_layers, with each tuple having 2 tensors of shape (batch_size, num_heads, sequence_length, embed_size_per_head)) and 2 additional tensors of shape (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 of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您希望对如何将 input_ids 索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — Optionally, instead of passing decoder_input_ids you can choose to directly pass an embedded representation. If past_key_values is used, optionally only the last decoder_inputs_embeds have to be input (see past_key_values). This is useful if you want more control over how to convert decoder_input_ids indices into associated vectors than the model’s internal embedding lookup matrix.

    如果decoder_input_idsdecoder_inputs_embeds都未设置,decoder_inputs_embeds将取inputs_embeds的值。

  • use_cache (bool, 可选) — 如果设置为 Truepast_key_values 键值状态将被返回,并可用于加速解码(参见 past_key_values)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • output_router_logits (bool, 可选) — 是否返回所有路由器的logits。它们对于计算路由器损失非常有用,并且 在推理期间不应返回。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间(参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略 (掩码),损失仅针对标签在 [0, ..., config.vocab_size] 之间的标记计算。

返回

transformers.modeling_outputs.Seq2SeqMoEOutputtuple(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_layerstuple(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。

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))
< > Update on GitHub