Transformers documentation
M2M100
Ce modèle a été publié dans HF papers le 2020-10-21 et a été ajouté à Hugging Face Transformers le 2021-03-06.
M2M100
Aperçu
Le modèle M2M100 a été proposé dans Beyond English-Centric Multilingual Machine Translation par Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.
L'abstract de l'article est le suivant :
Les travaux existants en traduction ont démontré le potentiel de la traduction automatique massivement multilingue en entraînant un seul modèle capable de traduire entre n’importe quelle paire de langues. Cependant, une grande partie de ces travaux est centrée sur l’anglais, car ils n’entraînent le modèle que sur des données traduites depuis ou vers l’anglais. Bien que cela soit soutenu par de grandes sources de données d’entraînement, cela ne reflète pas les besoins de traduction à l’échelle mondiale. Dans ce travail, nous créons un véritable modèle de traduction multilingue Many-to-Many capable de traduire directement entre n’importe quelle paire de 100 langues. Nous construisons et mettons à disposition en open source un jeu de données d’entraînement qui couvre des milliers de directions de langues avec des données supervisées, créées par un minage à grande échelle. Ensuite, nous explorons comment augmenter efficacement la capacité du modèle grâce à une combinaison de mise à l’échelle dense et de paramètres creux spécifiques à chaque langue, afin de créer des modèles de haute qualité. Notre focus sur les modèles non centrés sur l’anglais apporte des gains de plus de 10 BLEU lors de la traduction directe entre des directions non anglaises, tout en restant compétitif par rapport aux meilleurs systèmes individuels du WMT. Nous mettons à disposition en open source nos scripts afin que d’autres puissent reproduire les données, l’évaluation et le modèle final M2M-100.
Ce modèle a été contribué par valhalla.
Conseils et exemples d'utilisation
M2M100 est un modèle encodeur-décodeur (seq-to-seq) multilingue destiné principalement aux tâches de traduction. Étant multilingue, le modèle s'attend à ce que les séquences soient au format suivant : un jeton d'identifiant de langue spécial est utilisé comme préfixe dans le texte source et le texte cible. Le format du texte source est [lang_code] X [eos], où lang_code est l'identifiant de la langue source pour le texte source et l'identifiant de la langue cible pour le texte cible, X représentant le texte source ou cible.
Le M2M100Tokenizer dépend de sentencepiece, assurez-vous donc de l’installer avant d’exécuter les
exemples. Pour installer sentencepiece, exécutez pip install sentencepiece.
Ensupervisé
from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", device_map="auto")
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="fr")
src_text = "Life is like a box of chocolates."
tgt_text = "La vie est comme une boîte de chocolat."
model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt").to(model.device)
loss = model(**model_inputs).loss # forward passGénération
M2M100 utilise le eos_token_id comme decoder_start_token_id pour la génération, l'identifiant de la langue cible étant forcé comme premier jeton généré. Pour forcer l'identifiant de la langue cible comme premier jeton généré, passez le paramètre forced_bos_token_id à la méthode generate. L'exemple suivant montre comment traduire du hindi vers le français et du chinois vers l'anglais en utilisant le point de contrôle facebook/m2m100_418M.
from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
hi_text = "जीवन एक चॉकलेट बॉक्स की तरह है।"
chinese_text = "生活就像一盒巧克力。"
model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", device_map="auto")
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")
# translate Hindi to French
tokenizer.src_lang = "hi"
encoded_hi = tokenizer(hi_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.get_lang_id("fr"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"La vie est comme une boîte de chocolat."
# translate Chinese to English
tokenizer.src_lang = "zh"
encoded_zh = tokenizer(chinese_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_zh, forced_bos_token_id=tokenizer.get_lang_id("en"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"Life is like a box of chocolate."Ressources
M2M100Config
classe transformers.M2M100Config
< 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 = Truepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - vocab_size (
int, facultatif, par défaut128112) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - max_position_embeddings (
int, facultatif, par défaut1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - encoder_layers (
int, facultatif, valeur par défaut12) — Nombre de couches cachées dans l’encodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - encoder_ffn_dim (
int, facultatif, par défaut4096) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur. - encoder_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer. - decoder_layers (
int, facultatif, valeur par défaut12) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - decoder_ffn_dim (
int, facultatif, valeur par défaut4096) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur. - decoder_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - encoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.05) — Probabilité de LayerDrop pour l'encodeur. Voir l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - decoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.05) — Probabilité de LayerDrop pour le décodeur. Voir l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - activation_function (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - d_model (
int, facultatif, par défaut1024) — Taille des couches encodeur et de la couche pooler. - dropout (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - activation_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée. - init_std (
float, facultatif, valeur par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - decoder_start_token_id (
int, facultatif, valeur par défaut2) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent debos, l’identifiant de ce jeton. - scale_embedding (
bool, facultatif, par défautTrue) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model). - pad_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un M2M100Model. Elle est utilisée pour instancier un modèle M2M 100 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/m2m100_418M
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> from transformers import M2M100Config, M2M100Model
>>> # Initializing a M2M100 facebook/m2m100_418M style configuration
>>> configuration = M2M100Config()
>>> # Initializing a model (with random weights) from the facebook/m2m100_418M style configuration
>>> model = M2M100Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configM2M100Tokenizer
classe transformers.M2M100Tokenizer
< source >( vocab_filespm_filesrc_lang = Nonetgt_lang = Nonebos_token = '<s>'eos_token = '</s>'sep_token = '</s>'pad_token = '<pad>'unk_token = '<unk>'language_codes = 'm2m100'sp_model_kwargs: dict[str, typing.Any] | None = Nonenum_madeup_words = 8**kwargs )
Paramètres
- vocab_file (
str) — Chemin vers le fichier de vocabulaire. - spm_file (
str) — Chemin vers le fichier SentencePiece (généralement avec l’extension .spm) qui contient le vocabulaire. - src_lang (
str, facultatif) — Une chaîne de caractères représentant la langue source. - tgt_lang (
str, facultatif) — Une chaîne de caractères représentant la langue cible. - eos_token (
str, facultatif, par défaut"</s>") — Le jeton de fin de séquence. - sep_token (
str, facultatif, par défaut"</s>") — Le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux. - unk_token (
str, facultatif, par défaut"<unk>") — Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton. - pad_token (
str, facultatif, par défaut"<pad>") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes. - language_codes (
str, facultatif, par défaut"m2m100") — Codes de langue à utiliser. Doit être"m2m100"ou"wmt21". - sp_model_kwargs (
dict, facultatif) — Sera transmis à la méthodeSentencePieceProcessor.__init__(). Le wrapper Python de SentencePiece peut être utilisé, entre autres, pour définir :-
enable_sampling: Active la régularisation des sous-mots. -
nbest_size: Paramètres d'échantillonnage pour les unigrammes. Invalide pour BPE-Dropout.nbest_size = {0,1}: Aucun échantillonnage n'est effectué.nbest_size > 1: échantillonne parmi les résultats de nbest_size.nbest_size < 0: suppose que nbest_size est infini et échantillonne à partir de toutes les hypothèses (lattice) en utilisant l'algorithme de filtrage avant et d'échantillonnage arrière.
-
alpha: Paramètre de lissage pour l'échantillonnage des unigrammes et probabilité de suppression pour les opérations de fusion dans le cas du BPE-dropout.
-
Construire un tokenizer M2M100. Basé sur SentencePiece.
Ce tokenizer hérite de PreTrainedTokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.
Exemples :
>>> from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="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")
>>> outputs = model(**model_inputs) # should workbuild_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
Paramètres
- token_ids_0 (
list[int]) — Liste des ID auxquels les jetons spéciaux seront ajoutés. - token_ids_1 (
list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.
Retourne
list[int]
Liste des identifiants d'entrée avec les jetons spéciaux appropriés.
Construire les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences en les concaténant et en ajoutant des jetons spéciaux. Une séquence MBART a le format suivant, où X représente la séquence :
input_ids(pour l'encodeur)X [eos, src_lang_code]decoder_input_ids: (pour le décodeur)X [eos, tgt_lang_code]
BOS n'est jamais utilisé. Les paires de séquences ne constituent pas le cas d'utilisation prévu, mais elles seront gérées sans séparateur.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → list[int]
Paramètres
- token_ids_0 (
list[int]) — Liste d'identifiants. - token_ids_1 (
list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences. - already_has_special_tokens (
bool, facultatif, par défautFalse) — Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.
Retourne
list[int]
Une liste d'entiers dans l'intervalle [0, 1] : 1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupère les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide de la méthode prepare_for_model du tokeniseur.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
Créez un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences.
Cette méthode construit dynamiquement les identifiants de type de jeton en fonction des attributs de configuration du tokeniseur :
token_type_ids_pattern: Motif à utiliser (« all_zeros » ou « bert_style »)token_type_ids_include_special_tokens: Indique s'il faut prendre en compte les jetons spéciaux dans le calcul de la longueur
Exemples :
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences
# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairsM2M100Model
classe transformers.M2M100Model
< source >( config: M2M100Config )
Paramètres
- config (M2M100Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle M2M 100 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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'> ) → Seq2SeqModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? M2M100 utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values).Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
M2M100 utilise
eos_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n’entrer que les derniersdecoder_input_ids(voirpast_key_values). - decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqModelOutput ou tuple(torch.Tensor)
Un Seq2SeqModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (M2M100Config) et des entrées.
La méthode forward du modèle M2M100Model redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
M2M100ForConditionalGeneration
classe transformers.M2M100ForConditionalGeneration
< source >( config: M2M100Config )
Paramètres
- config (M2M100Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle M2M100 avec une tête de modélisation de langage. Peut être utilisé pour la résumation.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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 = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? M2M100 utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values).Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
M2M100 utilise
eos_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n’entrer que les derniersdecoder_input_ids(voirpast_key_values). - decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqLMOutput ou tuple(torch.Tensor)
Un Seq2SeqLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (M2M100Config) et des entrées.
La méthode forward de M2M100ForConditionalGeneration surcharge la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage.logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple de traduction :
>>> from transformers import AutoTokenizer, M2M100ForConditionalGeneration
>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/m2m100_418M")
>>> 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("fr"))
>>> print(tokenizer.batch_decode(gen_tokens, skip_special_tokens=True))Utilisation de Flash Attention 2
Flash Attention 2 est une version plus rapide et optimisée du calcul des scores d'attention, qui s'appuie sur des noyaux cuda.
Installation
Vérifiez d'abord si votre matériel est compatible avec Flash Attention 2. La liste la plus récente du matériel compatible se trouve dans la documentation officielle.
Ensuite, installez la dernière version de Flash Attention 2 :
pip install -U flash-attn --no-build-isolation
Utilisation
Pour charger un modèle en utilisant Flash Attention 2, nous pouvons passer l'argument attn_implementation="flash_attention_2" à from_pretrained(). Vous pouvez utiliser la précision torch.float16 ou torch.bfloat16.
from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", attn_implementation="flash_attention_2", device_map="auto").eval()
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")
# translate Hindi to French
hi_text = "जीवन एक चॉकलेट बॉक्स की तरह है।"
tokenizer.src_lang = "hi"
encoded_hi = tokenizer(hi_text, return_tensors="pt").to(model.device)
generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.get_lang_id("fr"))
tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"La vie est comme une boîte de chocolat."Accélérations attendues
Ci-dessous se trouve un diagramme de l’accélération attendue qui compare le temps d’inférence pur entre l’implémentation native et Flash Attention 2.
Utilisation de l'attention à produit scalaire mis à l'échelle (SDPA)
PyTorch intègre un opérateur natif d'attention par produit scalaire mis à l'échelle (SDPA) au sein de torch.nn.functional. Cette fonction
englobe plusieurs implémentations qui peuvent être appliquées en fonction des entrées et du matériel utilisé. Consultez la documentation officielle ou la page GPU Inference pour plus d'informations.
SDPA est utilisé par défaut pour torch>=2.1.1 lorsqu’une implémentation est disponible, mais vous pouvez également définir attn_implementation="sdpa" dans from_pretrained() pour demander explicitement l’utilisation de SDPA.
from transformers import M2M100ForConditionalGeneration
model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M", attn_implementation="sdpa", device_map="auto")
...Pour obtenir les accélérations optimales, nous recommandons de charger le modèle en demi-précision (par exemple torch.float16 ou torch.bfloat16).