Traduction

La traduction convertit une séquence de texte d’une langue à une autre. C’est l’une des nombreuses tâches que l’on peut formuler comme un problème de séquence à séquence, un cadre puissant pour produire une sortie à partir d’une entrée, comme la traduction ou la résumation. Les systèmes de traduction sont couramment utilisés pour la traduction entre différents textes de langues, mais ils peuvent également être utilisés pour la parole ou pour une combinaison des deux, comme la synthèse vocale (text-to-speech) ou la reconnaissance vocale (speech-to-text).

Ce guide vous montre comment :

1. Effectuer le fine-tuning de T5 sur le sous-ensemble anglais-français du jeu de données OPUS Books pour traduire le texte anglais en français.
2. Utilisez votre modèle affiné pour l'inférence.

Pour consulter toutes les architectures et points de contrôle compatibles avec cette tâche, nous vous recommandons de consulter la page de la tâche.

Avant de commencer, assurez-vous d'avoir installé toutes les bibliothèques nécessaires :

pip install transformers datasets evaluate sacrebleu

Nous vous encourage à vous connecter à votre compte Hugging Face afin de pouvoir téléverser et partager votre modèle avec la communauté. Lorsque cela vous est demandé, saisissez votre jeton pour vous connecter :

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Charger le jeu de données OPUS Books

Commencez par charger le sous-ensemble anglais-français du jeu de données OPUS Books à partir de la bibliothèque 🤗 Datasets :

>>> from datasets import load_dataset

>>> books = load_dataset("Helsinki-NLP/opus_books", "en-fr")

Divisez le jeu de données en ensembles d’entraînement et de test à l’aide de la méthode train_test_split :

>>> books = books["train"].train_test_split(test_size=0.2)

Puis, jetez un œil à un exemple :

>>> books["train"][0]
{'id': '90560',
 'translation': {'en': 'But this lofty plateau measured only a few fathoms, and soon we reentered Our Element.',
  'fr': 'Mais ce plateau élevé ne mesurait que quelques toises, et bientôt nous fûmes rentrés dans notre élément.'}}

translation : une traduction en anglais et en français du texte.

Prétraitement

L'étape suivante consiste à charger un tokenizer T5 pour traiter les paires de langues anglais-français :

>>> from transformers import AutoTokenizer

>>> checkpoint = "google-t5/t5-small"
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)

La fonction de prétraitement que vous souhaitez créer doit :

1. Préfixez l'entrée par un prompt afin que T5 sache qu'il s'agit d'une tâche de traduction. Certains modèles capables de plusieurs tâches de NLP nécessitent un prompt pour des tâches spécifiques.
2. Définissez la langue cible (français) dans le paramètre text_target afin de garantir que le tokenizer traite correctement le texte cible. Si vous ne définissez pas text_target, le tokenizer traite le texte cible comme de l’anglais.
3. Tronquez les séquences pour qu’elles ne dépassent pas la longueur maximale définie par le paramètre max_length.

>>> source_lang = "en"
>>> target_lang = "fr"
>>> prefix = "translate English to French: "


>>> def preprocess_function(examples):
...     inputs = [prefix + example[source_lang] for example in examples["translation"]]
...     targets = [example[target_lang] for example in examples["translation"]]
...     model_inputs = tokenizer(inputs, text_target=targets, max_length=128, truncation=True)
...     return model_inputs

Pour appliquer la fonction de prétraitement à l’ensemble du jeu de données, utilisez la méthode map de 🤗 Datasets. Vous pouvez accélérer la fonction map en définissant batched=True afin de traiter plusieurs éléments du jeu de données à la fois :

>>> tokenized_books = books.map(preprocess_function, batched=True)

Créez maintenant un lot d’exemples à l’aide de DataCollatorForSeq2Seq. Il est plus efficace de rembourrer dynamiquement les phrases à la longueur maximale du lot lors de la collation, plutôt que de rembourrer l’ensemble du jeu de données à la longueur maximale.

>>> from transformers import DataCollatorForSeq2Seq

>>> data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=checkpoint)

Évaluer

L’inclusion d’une métrique pendant l’entraînement est souvent utile pour évaluer les performances de votre modèle. Vous pouvez charger rapidement une méthode d’évaluation avec la bibliothèque 🤗 Evaluate. Pour cette tâche, chargez la métrique SacreBLEU (consultez le quick tour de 🤗 Evaluate pour en savoir plus sur la façon de charger et de calculer une métrique) :

>>> import evaluate

>>> metric = evaluate.load("sacrebleu")

Créez ensuite une fonction qui transmet vos prédictions et vos étiquettes à compute afin de calculer le score SacreBLEU :

>>> import numpy as np


>>> def postprocess_text(preds, labels):
...     preds = [pred.strip() for pred in preds]
...     labels = [[label.strip()] for label in labels]

...     return preds, labels


>>> def compute_metrics(eval_preds):
...     preds, labels = eval_preds
...     if isinstance(preds, tuple):
...         preds = preds[0]
...     decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)

...     labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
...     decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

...     decoded_preds, decoded_labels = postprocess_text(decoded_preds, decoded_labels)

...     result = metric.compute(predictions=decoded_preds, references=decoded_labels)
...     result = {"bleu": result["score"]}

...     prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in preds]
...     result["gen_len"] = np.mean(prediction_lens)
...     result = {k: round(v, 4) for k, v in result.items()}
...     return result

Votre fonction compute_metrics est prête, et vous y reviendrez lors de la configuration de l’entraînement.

Entraînement

Si vous n’êtes pas familier avec l’ajustement fin d’un modèle à l’aide du Trainer, consultez le tutoriel de base ici !

Vous êtes prêt à commencer l’entraînement de votre modèle ! Chargez T5 avec AutoModelForSeq2SeqLM :

>>> from transformers import AutoModelForSeq2SeqLM, Seq2SeqTrainingArguments, Seq2SeqTrainer

>>> model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint)

À ce stade, il ne reste que trois étapes :

1. Définissez vos hyperparamètres d’entraînement dans Seq2SeqTrainingArguments. Le seul paramètre obligatoire est output_dir, qui spécifie l’endroit où enregistrer votre modèle. Vous pousserez ce modèle sur le Hub en définissant push_to_hub=True (vous devez être connecté à Hugging Face pour téléverser votre modèle). À la fin de chaque époque, le Trainer évaluera la métrique SacreBLEU et enregistrera le point de contrôle d’entraînement.
2. Transmettez les arguments d’entraînement à Seq2SeqTrainer en même temps que le modèle, le jeu de données, le tokenizer, le data collator et la fonction compute_metrics.
3. Appel de train() pour l’ajustement fin de votre modèle.

>>> training_args = Seq2SeqTrainingArguments(
...     output_dir="my_awesome_opus_books_model",
...     eval_strategy="epoch",
...     learning_rate=2e-5,
...     per_device_train_batch_size=16,
...     per_device_eval_batch_size=16,
...     weight_decay=0.01,
...     save_total_limit=3,
...     num_train_epochs=2,
...     predict_with_generate=True,
...     fp16=True, #change to bf16=True for XPU
...     push_to_hub=True,
... )

>>> trainer = Seq2SeqTrainer(
...     model=model,
...     args=training_args,
...     train_dataset=tokenized_books["train"],
...     eval_dataset=tokenized_books["test"],
...     processing_class=tokenizer,
...     data_collator=data_collator,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()

Une fois l’entraînement terminé, partagez votre modèle sur le Hub à l’aide de la méthode push_to_hub() afin que chacun puisse l’utiliser :

>>> trainer.push_to_hub()

Pour un exemple plus approfondi sur la façon d’affiner un modèle pour la traduction, consultez le notebook PyTorch correspondant.

Inférence

Parfait, maintenant que vous avez affiné un modèle, vous pouvez l'utiliser pour l'inférence !

Pensez à un texte que vous souhaitez traduire dans une autre langue. Pour T5, vous devez préfixer votre entrée en fonction de la tâche sur laquelle vous travaillez. Pour une traduction de l’anglais au français, vous devez préfixer votre entrée comme indiqué ci-dessous :

>>> text = "translate English to French: Legumes share resources with nitrogen-fixing bacteria."

Tokeniser le texte et retourner les input_ids sous forme de tenseurs PyTorch :

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("username/my_awesome_opus_books_model")
>>> inputs = tokenizer(text, return_tensors="pt").input_ids

Utilisez la méthode generate() pour créer la traduction. Pour plus de détails sur les différentes stratégies de génération de texte et les paramètres permettant de contrôler la génération, consultez l’API Text Generation.

>>> from transformers import AutoModelForSeq2SeqLM

>>> model = AutoModelForSeq2SeqLM.from_pretrained("username/my_awesome_opus_books_model")
>>> outputs = model.generate(inputs, max_new_tokens=40, do_sample=True, top_k=30, top_p=0.95)

Décoder les identifiants de jetons générés en texte :

>>> tokenizer.decode(outputs[0], skip_special_tokens=True)
'Les lignées partagent des ressources avec des bactéries enfixant l'azote.'