Traducción

La traducción convierte una secuencia de texto de un idioma a otro. Es una de varias tareas que se pueden formular como un problema de secuencia a secuencia, un marco de trabajo potente para generar una salida a partir de una entrada, como la traducción o la resumición. Los sistemas de traducción se utilizan comúnmente para traducir entre textos de diferentes idiomas, pero también pueden emplearse para el habla o alguna combinación intermedia, como texto a voz o voz a texto.

Esta guía le mostrará cómo:

1. Ajusta T5 en el subconjunto inglés-francés del conjunto de datos OPUS Books para traducir texto del inglés al francés.
2. Usa tu modelo afinado para la inferencia.

Para ver todas las arquitecturas y puntos de control compatibles con esta tarea, recomendamos consultar la página de la tarea.

Antes de comenzar, asegúrate de tener instaladas todas las bibliotecas necesarias:

pip install transformers datasets evaluate sacrebleu

Te animamos a iniciar sesión en tu cuenta de Hugging Face para que puedas subir y compartir tu modelo con la comunidad. Cuando se te solicite, introduce tu token para iniciar sesión:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Cargar el conjunto de datos OPUS Books

Comience cargando el subconjunto inglés-francés del conjunto de datos OPUS Books desde la biblioteca 🤗 Datasets:

>>> from datasets import load_dataset

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

Divida el conjunto de datos en un conjunto de entrenamiento y un conjunto de prueba con el método train_test_split:

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

A continuación, echa un vistazo a un ejemplo:

>>> 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: una traducción del texto al inglés y al francés.

Preprocesar

El siguiente paso es cargar un tokenizador de T5 para procesar los pares de idiomas inglés-francés:

>>> from transformers import AutoTokenizer

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

La función de preprocesamiento que desea crear debe:

1. Antepone un prompt a la entrada para que T5 sepa que se trata de una tarea de traducción. Algunos modelos capaces de realizar múltiples tareas de PLN requieren un prompt para tareas específicas.
2. Establezca el idioma de destino (francés) en el parámetro text_target para garantizar que el tokenizador procese correctamente el texto de destino. Si no establece text_target, el tokenizador procesará el texto de destino como inglés.
3. Trunca las secuencias para que no superen la longitud máxima establecida por el parámetro 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

Para aplicar la función de preprocesamiento a todo el conjunto de datos, utiliza el método map de 🤗 Datasets. Puedes acelerar la función map estableciendo batched=True para procesar varios elementos del conjunto de datos a la vez:

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

Ahora crea un lote de ejemplos usando DataCollatorForSeq2Seq. Es más eficiente rellenar dinámicamente las oraciones hasta la longitud más larga dentro de un lote durante la agrupación, en lugar de rellenar todo el conjunto de datos hasta la longitud máxima.

>>> from transformers import DataCollatorForSeq2Seq

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

Evaluar

Incluir una métrica durante el entrenamiento suele ser útil para evaluar el rendimiento de tu modelo. Puedes cargar rápidamente un método de evaluación con la biblioteca 🤗 Evaluate. Para esta tarea, carga la métrica SacreBLEU (consulta el quick tour de 🤗 Evaluate para saber más sobre cómo cargar y calcular una métrica):

>>> import evaluate

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

Luego, crea una función que pase tus predicciones y etiquetas a compute para calcular la puntuación 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

Tu función compute_metrics ya está lista y volverás a ella cuando configures el entrenamiento.

Entrenar

Si no está familiarizado con el ajuste fino de un modelo con Trainer, ¡eche un vistazo al tutorial básico aquí!

¡Ya estás listo para comenzar a entrenar tu modelo! Carga T5 con AutoModelForSeq2SeqLM:

>>> from transformers import AutoModelForSeq2SeqLM, Seq2SeqTrainingArguments, Seq2SeqTrainer

>>> model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint)

En este punto, solo quedan tres pasos:

1. Define los hiperparámetros de entrenamiento en Seq2SeqTrainingArguments. El único parámetro obligatorio es output_dir, que especifica dónde se guardará el modelo. Subirás este modelo al Hub configurando push_to_hub=True (debes iniciar sesión en Hugging Face para subir tu modelo). Al final de cada época, Trainer evaluará la métrica SacreBLEU y guardará el punto de control de entrenamiento.
2. Pasa los argumentos de entrenamiento a Seq2SeqTrainer junto con el modelo, el conjunto de datos, el tokenizador, el data collator y la función compute_metrics.
3. Llama a train() para ajustar tu modelo.

>>> 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()

Una vez completado el entrenamiento, comparte tu modelo en el Hub con el método push_to_hub() para que todo el mundo pueda usarlo:

>>> trainer.push_to_hub()

Para un ejemplo más detallado sobre cómo ajustar un modelo para la traducción, consulte el cuaderno de PyTorch correspondiente.

Inferencia

Genial, ahora que has afinado un modelo, ¡puedes usarlo para inferencia!

Ponga en marcha algo de texto que desee traducir a otro idioma. Para T5, debe prefijar su entrada según la tarea en la que esté trabajando. Para la traducción del inglés al francés, debe prefijar su entrada como se muestra a continuación:

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

Tokeniza el texto y devuelve los input_ids como tensores de PyTorch:

>>> from transformers import AutoTokenizer

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

Utilice el método generate() para crear la traducción. Para obtener más detalles sobre las diferentes estrategias de generación de texto y los parámetros para controlar la generación, consulte la API de 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)

Decodifica los ids de tokens generados de nuevo en texto:

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