hf-doc-build/doc-dev / transformers /pr_48314 /en /model_doc /mbart.md

|

77.1 kB

mBART

mBART is a multilingual machine translation model that pretrains the entire translation model (encoder-decoder) unlike previous methods that only focused on parts of the model. The model is trained on a denoising objective which reconstructs the corrupted text. This allows mBART to handle the source language and the target text to translate to.

mBART-50 is pretrained on an additional 25 languages.

You can find all the original mBART checkpoints under the AI at Meta organization.

Click on the mBART models in the right sidebar for more examples of applying mBART to different language tasks.

The example below demonstrates how to translate text with Pipeline or the AutoModel class.

from transformers import pipeline

pipeline = pipeline(
    task="translation",
    model="facebook/mbart-large-50-many-to-many-mmt",
    src_lang="en_XX",
    tgt_lang="fr_XX",
    device=0,
)
print(pipeline("UN Chief Says There Is No Military Solution in Syria"))

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

article_en = "UN Chief Says There Is No Military Solution in Syria"

model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-50-many-to-many-mmt", attn_implementation="sdpa", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-50-many-to-many-mmt")

tokenizer.src_lang = "en_XX"
encoded_hi = tokenizer(article_en, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.lang_code_to_id["fr_XX"], cache_implementation="static")
print(tokenizer.batch_decode(generated_tokens, skip_special_tokens=True))

Notes

You can check the full list of language codes via tokenizer.lang_code_to_id.keys().
mBART requires a special language id token in the source and target text during training. The source text format is X [eos, src_lang_code] where X is the source text. The target text format is [tgt_lang_code] X [eos]. The bos token is never used. The ~PreTrainedTokenizerBase._call_ encodes the source text format passed as the first argument or with the text keyword. The target text format is passed with the text_label keyword.

Set the decoder_start_token_id to the target language id for mBART.

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-en-ro", attn_implementation="sdpa", device_map="auto")
tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-en-ro", src_lang="en_XX")

article = "UN Chief Says There Is No Military Solution in Syria"
inputs = tokenizer(article, return_tensors="pt").to(model.device)

translated_tokens = model.generate(**inputs, decoder_start_token_id=tokenizer.lang_code_to_id["ro_RO"])
tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]

mBART-50 has a different text format. The language id token is used as the prefix for the source and target text. The text format is [lang_code] X [eos] where lang_code is the source language id for the source text and target language id for the target text. X is the source or target text respectively.

Set the eos_token_id as the decoder_start_token_id for mBART-50. The target language id is used as the first generated token by passing forced_bos_token_id to generate().

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

model = AutoModelForSeq2SeqLM.from_pretrained("facebook/mbart-large-50-many-to-many-mmt", attn_implementation="sdpa", device_map="auto")
tokenizer = MBartTokenizer.from_pretrained("facebook/mbart-large-50-many-to-many-mmt")

article_ar = "الأمين العام للأمم المتحدة يقول إنه لا يوجد حل عسكري في سوريا."
tokenizer.src_lang = "ar_AR"

encoded_ar = tokenizer(article_ar, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_ar, forced_bos_token_id=tokenizer.lang_code_to_id["en_XX"])
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)

MBartConfig[[transformers.MBartConfig]]

transformers.MBartConfig[[transformers.MBartConfig]]

transformers.MBartConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None, is_encoder_decoder: bool = True, vocab_size: int = 50265, max_position_embeddings: int = 1024, encoder_layers: int = 12, encoder_ffn_dim: int = 4096, encoder_attention_heads: int = 16, decoder_layers: int = 12, decoder_ffn_dim: int = 4096, decoder_attention_heads: int = 16, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, classifier_dropout: float | int = 0.0, scale_embedding: bool = False, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, decoder_start_token_id: int | None = None, forced_eos_token_id: int | list[int] | None = 2, is_decoder: bool = False, tie_word_embeddings: bool = True)

Source

Parameters:

is_encoder_decoder (bool, optional, defaults to True) : Whether the model is used as an encoder/decoder or not.

vocab_size (int, optional, defaults to 50265) : Vocabulary size of the model. Defines the number of different tokens that can be represented by the input_ids.

max_position_embeddings (int, optional, defaults to 1024) : The maximum sequence length that this model might ever be used with.

encoder_layers (int, optional, defaults to 12) : Number of hidden layers in the Transformer encoder. Will use the same value as num_layers if not set.

encoder_ffn_dim (int, optional, defaults to 4096) : Dimensionality of the "intermediate" (often named feed-forward) layer in encoder.

encoder_attention_heads (int, optional, defaults to 16) : Number of attention heads for each attention layer in the Transformer encoder.

decoder_layers (int, optional, defaults to 12) : Number of hidden layers in the Transformer decoder. Will use the same value as num_layers if not set.

decoder_ffn_dim (int, optional, defaults to 4096) : Dimensionality of the "intermediate" (often named feed-forward) layer in decoder.

decoder_attention_heads (int, optional, defaults to 16) : Number of attention heads for each attention layer in the Transformer decoder.

encoder_layerdrop (Union[float, int], optional, defaults to 0.0) : The LayerDrop probability for the encoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more details.

decoder_layerdrop (Union[float, int], optional, defaults to 0.0) : The LayerDrop probability for the decoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more details.

use_cache (bool, optional, defaults to True) : Whether or not the model should return the last key/values attentions (not used by all models). Only relevant if config.is_decoder=True or when the model is a decoder-only generative model.

activation_function (str, optional, defaults to gelu) : The non-linear activation function (function or string) in the decoder. For example, "gelu", "relu", "silu", etc.

d_model (int, optional, defaults to 1024) : Size of the encoder layers and the pooler layer.

dropout (Union[float, int], optional, defaults to 0.1) : The ratio for all dropout layers.

attention_dropout (Union[float, int], optional, defaults to 0.0) : The dropout ratio for the attention probabilities.

activation_dropout (Union[float, int], optional, defaults to 0.0) : The dropout ratio for activations inside the fully connected layer.

init_std (float, optional, defaults to 0.02) : The standard deviation of the truncated_normal_initializer for initializing all weight matrices.

classifier_dropout (Union[float, int], optional, defaults to 0.0) : The dropout ratio for classifier.

scale_embedding (bool, optional, defaults to False) : Whether to scale embeddings by dividing by sqrt(d_model).

pad_token_id (int, optional, defaults to 1) : Token id used for padding in the vocabulary.

bos_token_id (int, optional, defaults to 0) : Token id used for beginning-of-stream in the vocabulary.

eos_token_id (Union[int, list[int]], optional, defaults to 2) : Token id used for end-of-stream in the vocabulary.

decoder_start_token_id (int, optional) : If an encoder-decoder model starts decoding with a different token than bos, the id of that token.

forced_eos_token_id (Union[int, list[int]], optional, defaults to 2) : The id of the token to force as the last generated token when max_length is reached. Usually set to eos_token_id.

is_decoder (bool, optional, defaults to False) : Whether the model is used as a decoder or not. If False, the model is used as an encoder.

tie_word_embeddings (bool, optional, defaults to True) : Whether to tie weight embeddings according to model's tied_weights_keys mapping.

This is the configuration class to store the configuration of a MBartModel. It is used to instantiate a Mbart model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the facebook/mbart-large-cc25

Configuration objects inherit from PreTrainedConfig and can be used to control the model outputs. Read the documentation from PreTrainedConfig for more information.

Example:

>>> from transformers import MBartConfig, MBartModel

>>> # Initializing a MBART facebook/mbart-large-cc25 style configuration
>>> configuration = MBartConfig()

>>> # Initializing a model (with random weights) from the facebook/mbart-large-cc25 style configuration
>>> model = MBartModel(configuration)

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

MBartTokenizer[[transformers.MBartTokenizer]]

transformers.MBartTokenizer[[transformers.MBartTokenizer]]

transformers.MBartTokenizer(vocab: str | dict | list | None = None, bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', src_lang = None, tgt_lang = None, additional_special_tokens = None, **kwargs)

Source

Construct an MBART tokenizer (backed by HuggingFace's tokenizers library). Based on Unigram.

This tokenizer inherits from TokenizersBackend which contains most of the main methods. Users should refer to this superclass for more information regarding those methods.

The tokenization method is <tokens> <eos> <language code> for source language documents, and for target language documents.

Examples:

>>> from transformers import MBartTokenizer

>>> tokenizer = MBartTokenizer.from_pretrained(
...     "facebook/mbart-large-en-ro", src_lang="en_XX", tgt_lang="ro_RO"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_romanian = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_romanian, return_tensors="pt")

set_src_lang_special_tokens[[transformers.MBartTokenizer.set_src_lang_special_tokens]]

set_src_lang_special_tokens(src_lang)

Source

Reset the special tokens to the source lang setting. No prefix and suffix=[eos, src_lang_code].

set_tgt_lang_special_tokens[[transformers.MBartTokenizer.set_tgt_lang_special_tokens]]

set_tgt_lang_special_tokens(lang: str)

Source

Reset the special tokens to the target language setting. No prefix and suffix=[eos, tgt_lang_code].

MBart50Tokenizer[[transformers.MBart50Tokenizer]]

transformers.MBart50Tokenizer[[transformers.MBart50Tokenizer]]

transformers.MBart50Tokenizer(vocab: str | dict | list | None = None, _spm_precompiled_charsmap: str | None = None, src_lang = None, tgt_lang = None, eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', **kwargs)

Source

Parameters:

vocab_file (str, optional) : Path to the vocabulary file.

src_lang (str, optional) : A string representing the source language.

tgt_lang (str, optional) : A string representing the target language.

eos_token (str, optional, defaults to "</s>") : The end of sequence token.

sep_token (str, optional, defaults to "</s>") : The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for sequence classification or for a text and a question for question answering. It is also used as the last token of a sequence built with special tokens.

cls_token (str, optional, defaults to "<s>") : The classifier token which is used when doing sequence classification (classification of the whole sequence instead of per-token classification). It is the first token of the sequence when built with special tokens.

unk_token (str, optional, defaults to "<unk>") : The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this token instead.

pad_token (str, optional, defaults to "<pad>") : The token used for padding, for example when batching sequences of different lengths.

mask_token (str, optional, defaults to "<mask>") : The token used for masking values. This is the token used when training this model with masked language modeling. This is the token which the model will try to predict.

Construct a MBart50 tokenizer (backed by HuggingFace's tokenizers library). Based on Unigram.

This tokenizer inherits from TokenizersBackend which contains most of the main methods. Users should refer to this superclass for more information regarding those methods.

Examples:

>>> from transformers import MBart50Tokenizer

>>> tokenizer = MBart50Tokenizer.from_pretrained("facebook/mbart-large-50", src_lang="en_XX", tgt_lang="ro_RO")
>>> src_text = " UN Chief Says There Is No Military Solution in Syria"
>>> tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
>>> # model(**model_inputs) should work

set_src_lang_special_tokens[[transformers.MBart50Tokenizer.set_src_lang_special_tokens]]

set_src_lang_special_tokens(src_lang: str)

Source

Reset the special tokens to the source lang setting. prefix=[src_lang_code] and suffix=[eos].

set_tgt_lang_special_tokens[[transformers.MBart50Tokenizer.set_tgt_lang_special_tokens]]

set_tgt_lang_special_tokens(tgt_lang: str)

Source

Reset the special tokens to the target language setting. prefix=[tgt_lang_code] and suffix=[eos].

MBartModel[[transformers.MBartModel]]

transformers.MBartModel[[transformers.MBartModel]]

transformers.MBartModel(config: MBartConfig)

Source

Parameters:

config (MBartConfig) : Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.

The bare Mbart Model outputting raw hidden-states without any specific head on top.

This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)

This model is also a PyTorch torch.nn.Module subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior.

forward[[transformers.MBartModel.forward]]

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, encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, return_dict: bool | None = None, **kwargs: Unpack)

Source

Parameters:

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) : Indices of input sequence tokens in the vocabulary. Padding will be ignored by default. Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details. What are input IDs?

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. What are attention masks?

decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) : Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details. What are decoder input IDs? MBart uses a specific language id token as the starting token for decoder_input_ids generation that varies according to source and target language, e.g. 25004 for en_XX, and 25003 for de_DE. If past_key_values is used, optionally only the last decoder_input_ids have to be input (see past_key_values). For translation and summarization training, decoder_input_ids should be provided. If no decoder_input_ids is provided, the model will create this tensor by shifting the input_ids to the right for denoising pre-training following the paper.

decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) : Default behavior: generate a tensor that ignores pad tokens in decoder_input_ids. Causal mask will also be used by default.

encoder_outputs (tuple[tuple[torch.FloatTensor]], optional) : Tuple consists of (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state of shape (batch_size, sequence_length, hidden_size), optional) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.

past_key_values (~cache_utils.Cache, optional) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the past_key_values returned by the model at a previous stage of decoding, when use_cache=True or config.use_cache=True. Only Cache instance is allowed as input, see our kv cache guide. If no past_key_values are passed, DynamicCache will be initialized by default. The model will output the same cache format that is fed as input. If past_key_values are used, the user is expected to input only unprocessed input_ids (those that don't have their past key value states given to this model) of shape (batch_size, unprocessed_length) instead of all input_ids of shape (batch_size, sequence_length).

inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) : Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model's internal embedding lookup matrix.

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. If decoder_input_ids and decoder_inputs_embeds are both unset, decoder_inputs_embeds takes the value of inputs_embeds.

use_cache (bool, optional) : If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).

return_dict (bool, optional) : Whether or not to return a ModelOutput instead of a plain tuple.

Returns: Seq2SeqModelOutput or tuple(torch.FloatTensor)

A Seq2SeqModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (MBartConfig) and inputs.

The MBartModel forward method, overrides the __call__ special method.

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the pre and post processing steps while the latter silently ignores them.

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) -- Sequence of hidden-states at the output of the last layer of the decoder of the model.

If past_key_values is used only the last hidden-state of the sequences of shape (batch_size, 1, hidden_size) is output.
past_key_values (EncoderDecoderCache, optional, returned when use_cache=True is passed or when config.use_cache=True) -- It is a EncoderDecoderCache instance. For more details, see our kv cache guide.

Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.
decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) -- Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size).

Hidden-states of the decoder at the output of each layer plus the optional initial embedding outputs.
decoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) -- Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads.
cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) -- Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads.
encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) -- Sequence of hidden-states at the output of the last layer of the encoder of the model.
encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) -- Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size).

Hidden-states of the encoder at the output of each layer plus the optional initial embedding outputs.
encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) -- Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads.

MBartForConditionalGeneration[[transformers.MBartForConditionalGeneration]]

transformers.MBartForConditionalGeneration[[transformers.MBartForConditionalGeneration]]

transformers.MBartForConditionalGeneration(config: MBartConfig)

Source

Parameters:

config (MBartConfig) : Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.

The MBART Model with a language modeling head. Can be used for summarization, after fine-tuning the pretrained models.

This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)

This model is also a PyTorch torch.nn.Module subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior.

forward[[transformers.MBartForConditionalGeneration.forward]]

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, encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, return_dict: bool | None = None, **kwargs: Unpack)