Transformers documentation
NLLB-MOE
Este modelo foi publicado no HF papers em 2022-07-11 e contribuído para o Hugging Face Transformers em 2023-03-27.
NLLB-MOE
Visão geral
O modelo NLLB foi apresentado em No Language Left Behind: Scaling Human-Centered Machine Translation por 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 e Jeff Wang.
O resumo do artigo é o seguinte:
Impulsionada pelo objetivo de erradicar as barreiras linguísticas em escala global, a tradução automática se consolidou como um foco-chave da pesquisa em inteligência artificial hoje em dia. No entanto, esses esforços se concentraram em um pequeno subconjunto de idiomas, deixando para trás a grande maioria dos idiomas de baixo recurso. O que é necessário para quebrar a barreira dos 200 idiomas garantindo resultados seguros e de alta qualidade, tudo isso mantendo em mente as considerações éticas? Em No Language Left Behind, assumimos esse desafio primeiro contextualizando a necessidade de suporte à tradução de idiomas de baixo recurso por meio de entrevistas exploratórias com falantes nativos. Em seguida, criamos conjuntos de dados e modelos voltados para reduzir a lacuna de desempenho entre idiomas de baixo e alto recurso. Mais especificamente, desenvolvemos um modelo de computação condicional baseado em Sparsely Gated Mixture of Experts que é treinado com dados obtidos por meio de técnicas inovadoras e eficazes de mineração de dados adaptadas para idiomas de baixo recurso. Propomos melhorias arquitetônicas e de treinamento para contrabalançar o overfitting durante o treinamento em milhares de tarefas. Criticamente, avaliamos o desempenho de mais de 40.000 direções de tradução diferentes usando um benchmark traduzido por humanos, o Flores-200, e combinamos a avaliação humana com um novo benchmark de toxicidade que cobre todos os idiomas do Flores-200 para avaliar a segurança da tradução. Nosso modelo alcança uma melhoria de 44% em BLEU em relação ao estado da arte anterior, estabelecendo uma base importante para a realização de um sistema de tradução universal.
Este modelo foi contribuído por Arthur Zucker. O código original pode ser encontrado aqui.
Dicas de uso
- M2M100ForConditionalGeneration é o modelo base tanto para o NLLB quanto para o NLLB MoE
- O NLLB-MoE é muito semelhante ao modelo NLLB, mas sua camada feed forward é baseada na implementação do SwitchTransformers.
- O tokenizer é o mesmo dos modelos NLLB.
Diferenças de implementação em relação ao SwitchTransformers
A maior diferença está na forma como os tokens são roteados. O NLLB-MoE usa um top-2-gate, o que significa que, para cada entrada, apenas os dois especialistas com as maiores probabilidades previstas pela rede de roteamento são selecionados, e os demais especialistas são ignorados. No SwitchTransformers, apenas as probabilidades top-1 são calculadas, o que significa que os tokens têm menor probabilidade de serem encaminhados. Além disso, se um token não for roteado para nenhum especialista, o SwitchTransformers ainda adiciona seus estados ocultos não modificados (algo como uma conexão residual), enquanto eles são mascarados no mecanismo de roteamento top-2 do NLLB.
Gerando com NLLB-MoE
Os checkpoints disponíveis exigem cerca de 350GB de armazenamento. Certifique-se de usar accelerate caso não tenha RAM suficiente na sua máquina.
Ao gerar o texto de destino, defina o forced_bos_token_id para o id do idioma de destino. O exemplo a seguir mostra como traduzir do inglês para o francês usando o modelo facebook/nllb-200-distilled-600M.
Observe que estamos usando o código BCP-47 para o francês fra_Latn. Consulte aqui a lista de todos os BCP-47 no conjunto de dados Flores 200.
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-moe-54b")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-moe-54b", device_map="auto")
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").to(model.device)
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."Gerar a partir de qualquer outro idioma que não seja o inglês
O inglês (eng_Latn) é definido como o idioma padrão de origem para a tradução. Para especificar que você deseja traduzir a partir de um idioma diferente,
deve indicar o código BCP-47 no argumento de palavra-chave src_lang da inicialização do tokenizer.
Veja o exemplo abaixo para uma tradução do romeno para o alemão:
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", device_map="auto")
article = "Şeful ONU spune că nu există o soluţie militară în Siria"
inputs = tokenizer(article, return_tensors="pt").to(model.device)
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]Recursos
NllbMoeConfig
classe transformers.NllbMoeConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 128112max_position_embeddings: int = 1024encoder_layers: int = 12encoder_ffn_dim: int = 4096encoder_attention_heads: int = 16decoder_layers: int = 12decoder_ffn_dim: int = 4096decoder_attention_heads: int = 16encoder_layerdrop: float | int = 0.05decoder_layerdrop: float | int = 0.05use_cache: bool = Trueactivation_function: str = 'relu'd_model: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.0init_std: float = 0.02decoder_start_token_id: int | None = 2scale_embedding: bool = Truerouter_bias: bool = Falserouter_dtype: typing.Literal['float32', 'float16', 'bfloat16'] = 'float32'router_ignore_padding_tokens: bool = Falsenum_experts: int = 128expert_capacity: int = 64encoder_sparse_step: int = 4decoder_sparse_step: int = 4router_z_loss_coef: float = 0.001router_aux_loss_coef: float = 0.001second_expert_policy: str = 'all'normalize_router_prob_before_dropping: bool = Falsebatch_prioritized_routing: bool = Falsemoe_eval_capacity_token_fraction: float = 1.0moe_token_dropout: float | int = 0.2pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Trueoutput_router_logits: bool = False )
Parâmetros
- is_encoder_decoder (
bool, opcional, padrãoTrue) — Indica se o modelo é usado como encoder/decoder ou não. - vocab_size (
int, opcional, padrão128112) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - max_position_embeddings (
int, opcional, padrão1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - encoder_layers (
int, opcional, padrão12) — Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor denum_layersse não for definido. - encoder_ffn_dim (
int, opcional, padrão4096) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no encoder. - encoder_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no codificador do Transformer. - decoder_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. Se não for definido, usará o mesmo valor denum_layers. - decoder_ffn_dim (
int, opcional, padrão4096) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no decoder. - decoder_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - encoder_layerdrop (
Union[float, int], opcional, padrão0.05) — A probabilidade de LayerDrop para o encoder. Veja o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes. - decoder_layerdrop (
Union[float, int], opcional, padrão0.05) — A probabilidade de LayerDrop para o decoder. Veja o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes. - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - activation_function (
str, opcional, padrãorelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - d_model (
int, opcional, padrão1024) — Tamanho das camadas do codificador e da camada pooler. - dropout (
Union[float, int], opcional, padrão0.1) — A proporção para todas as camadas de dropout. - attention_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - activation_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - init_std (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - decoder_start_token_id (
int, opcional, padrão2) — Se um modelo encoder-decoder inicia a decodificação com um token diferente debos, o id desse token. - scale_embedding (
bool, opcional, padrãoTrue) — Se as embeddings devem ser escalonadas dividindo por sqrt(d_model). - router_bias (
bool, opcional, padrãoFalse) — Indica se o classificador do roteador deve ter um viés. - router_dtype (
str, opcional, padrão"float32") — Odtypeusado para os roteadores. É preferível manter odtypecomo"float32", conforme especificado na discussão sobre precisão seletiva em o paper. - router_ignore_padding_tokens (
bool, opcional, padrãoFalse) — Se deve ignorar tokens de preenchimento ao rotear. SeFalse, os tokens de preenchimento não são roteados para nenhum especialista. - num_experts (
int, opcional, padrão128) — Número de especialistas roteados nas camadas MoE. - expert_capacity (
int, opcional, padrão 64) — Número de tokens que podem ser armazenados em cada especialista. - encoder_sparse_step (
int, opcional, padrão 4) — Frequência das camadas esparsas no encoder. 4 significa que uma a cada 4 camadas será esparso. - decoder_sparse_step (
int, opcional, padrão 4) — Frequência das camadas esparsas no decoder. 4 significa que uma a cada 4 camadas será esparso. - router_z_loss_coef (
float, opcional, padrão0.001) — Coeficiente para a z-loss do roteador, que penaliza logits grandes do roteador para melhorar a estabilidade do treinamento. - router_aux_loss_coef (
float, opcional, padrão0.001) — Coeficiente da perda auxiliar de balanceamento de carga. Usado para penalizar o roteamento desigual de especialistas em modelos MoE. - second_expert_policy (
str, opcional, padrão"all") — A política utilizada para amostrar a probabilidade de um token ser direcionado a um segundo especialista. - normalize_router_prob_before_dropping (
bool, opcional, padrãoTrue) — Indica se as probabilidades do roteador devem ser normalizadas antes de aplicar uma máscara com base na capacidade dos especialistas (descarte por capacidade). - batch_prioritized_routing (
bool, opcional, padrãoTrue) — Define se os tokens devem ser ordenados pelas probabilidades do roteador antes do descarte de capacidade. Isso significa que os tokens com as probabilidades mais altas serão roteados antes de outros tokens que podem estar mais adiante na sequência. - moe_eval_capacity_token_fraction (
float, opcional, padrão 1.0) — Fração de tokens como capacidade durante a validação; se definido como negativo, usa o mesmo valor do treinamento. Deve estar no intervalo: (0.0, 1.0]. - moe_token_dropout (
float, opcional, padrão 0.2) — Taxa de mascaramento para o mascaramento de saída de especialistas MoE (EOM), implementado por meio de um Dropout2d nas saídas dos especialistas. - pad_token_id (
int, opcional, padrão1) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão0) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - tie_word_embeddings (
bool, opcional, padrãoTrue) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - output_router_logits (
bool, opcional, padrãoFalse) — Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permitirá que o modelo saída a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador.
Esta é a classe de configuração para armazenar a configuração de um modelo Nllb Moe. Ela é usada para instanciar um modelo Nllb Moe de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/nllb-moe-54b
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> 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
O roteador que usa tokens escolhe a atribuição dos 2 melhores especialistas.
Este roteador utiliza o mesmo mecanismo do NLLB-MoE do repositório fairseq. Os itens são ordenados por router_probs e, em seguida, roteados para o especialista de sua escolha até que o expert_capacity do especialista seja atingido. Não há garantia de que cada token seja processado por um especialista, nem de que cada especialista receba pelo menos um token.
Os pesos de combinação do roteador também são retornados para garantir que os estados que não são atualizados sejam mascarados.
route_tokens
< source >( router_logits: Tensorinput_dtype: dtype = torch.float32padding_mask: typing.Optional[torch.LongTensor] = None )
Calcula o dispatch_mask e os dispatch_weights para cada expert. As máscaras são adaptadas à capacidade do expert.
forward
< source >( hidden_states: Tensorpadding_mask: typing.Optional[torch.LongTensor] = None ) → top_1_mask (torch.Tensor of shape (batch_size, sequence_length))
Parâmetros
- hidden_states (
torch.Tensor) — (batch_size, sequence_length, hidden_dim) a partir do qual as probabilidades do roteador são calculadas.
Retorna
top_1_mask (torch.Tensor de forma (batch_size, sequence_length))
Tensor de índice de forma [batch_size, sequence_length] correspondente ao especialista selecionado para cada token,
usando as probabilidades top1 do roteador.
router_probabilities (torch.Tensor de forma (batch_size, sequence_length, nump_experts)):
Tensor de forma (batch_size, sequence_length, num_experts) correspondente às probabilidades para cada
token e especialista. Usado para rotear tokens para especialistas.
router_logits (torch.Tensor de forma (batch_size, sequence_length))):
Tensor de logits de forma (batch_size, sequence_length, num_experts) correspondente aos logits brutos do roteador.
Isso é usado posteriormente para calcular a perda z do roteador.
Os estados ocultos são redimensionados para simplificar o cálculo das probabilidades do roteador (combinando os pesos de cada especialista).
NllbMoeSparseMLP
Implementação do módulo de MLP esparsa do NLLB-MoE.
NllbMoeModel
classe transformers.NllbMoeModel
< source >( config: NllbMoeConfig )
Parâmetros
- config (NllbMoeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo Nllb Moe puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqMoEModelOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- decoder_input_ids (
torch.LongTensorde formato(batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- decoder_attention_mask (
torch.LongTensorde forma(batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro. - encoder_outputs (
tuple[tuple[torch.Tensor]], opcional) — A tupla consiste em (last_hidden_state, opcional:hidden_states, opcional:attentions)last_hidden_statede forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
Seq2SeqMoEModelOutput ou tuple(torch.Tensor)
Uma Seq2SeqMoEModelOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (None) e das entradas.
O método forward do NllbMoeModel substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do decodificador do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
EncoderDecoderCache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.decoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do decodificador na saída de cada camada, além das saídas opcionais do embedding inicial.
decoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
decoder_router_logits (
tuple(torch.Tensor), opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, sequence_length, num_experts).Logits do roteador do modelo decodificador, úteis para calcular a perda auxiliar em modelos Mixture of Experts.
cross_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
encoder_last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do codificador na saída de cada camada, além das saídas opcionais do embedding inicial.
encoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
encoder_router_logits (
tuple(torch.Tensor), opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.Tensor(um para cada camada) com a forma(batch_size, sequence_length, num_experts).Logits do roteador do modelo codificador, úteis para calcular a perda auxiliar e a z_loss para os módulos esparsos.
NllbMoeForConditionalGeneration
classe transformers.NllbMoeForConditionalGeneration
< source >( config: NllbMoeConfig )
Parâmetros
- config (NllbMoeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo NllbMoe com uma cabeça de modelagem de linguagem. Pode ser usado para sumarização.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_router_logits: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqMoEOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- decoder_input_ids (
torch.LongTensorde formato(batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador?Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- decoder_attention_mask (
torch.LongTensorde forma(batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro. - encoder_outputs (
tuple[tuple[torch.Tensor]], opcional) — A tupla consiste em (last_hidden_state, opcional:hidden_states, opcional:attentions)last_hidden_statede forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passardecoder_input_idsvocê pode escolher passar diretamente uma representação incorporada. Sepast_key_valuesfor usado, opcionalmente apenas o últimodecoder_inputs_embedsprecisa ser entrada (vejapast_key_values). Isso é útil se você quiser mais controle sobre como converterdecoder_input_idsíndices em vetores associados do que a matriz de busca de incorporação interna do modelo.Se
decoder_input_idsedecoder_inputs_embedsestiverem ambos não definidos,decoder_inputs_embedsassume o valor deinputs_embeds. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - output_router_logits (
bool, opcional) — Indica se os logits de todos os roteadores devem ser retornados. Eles são úteis para calcular a perda do roteador e não devem ser retornados durante a inferência.
Retorna
Seq2SeqMoEOutput ou tuple(torch.Tensor)
Um Seq2SeqMoEOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (NllbMoeConfig) e das entradas.
O método forward de NllbMoeForConditionalGeneration substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem.logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).past_key_values (
EncoderDecoderCache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.decoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
decoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
decoder_router_logits (
tuple(torch.Tensor), opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, sequence_length, num_experts).Logits do roteador do modelo decodificador, úteis para calcular a perda auxiliar em modelos Mixture of Experts.
cross_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
encoder_last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.encoder_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
encoder_attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
encoder_router_logits (
tuple(torch.Tensor), opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.add_router_probs=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, sequence_length, num_experts).Logits do roteador do modelo codificador, úteis para calcular a perda auxiliar e a z_loss para modelos Mixture of Experts.