# 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](https://huggingface.co/google-t5/t5-small) en el subconjunto inglés-francés del conjunto de datos [OPUS Books](https://huggingface.co/datasets/Helsinki-NLP/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](https://huggingface.co/tasks/translation).

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

```bash
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:

```py
>>> 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](https://huggingface.co/datasets/Helsinki-NLP/opus_books) desde la biblioteca 🤗 Datasets:

```py
>>> 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](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.train_test_split):

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

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

```py
>>> 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:

```py
>>> 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 objetivo (francés) en el parámetro `text_target` para garantizar que el tokenizador procese correctamente el texto objetivo. Si no establece `text_target`, el tokenizador procesa el texto objetivo como inglés.
3. Trunca las secuencias para que no superen la longitud máxima establecida por el parámetro `max_length`.

```py
>>> 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](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.map) de 🤗 Datasets. Puedes acelerar la función `map` estableciendo `batched=True` para procesar varios elementos del conjunto de datos a la vez:

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

Ahora crea un lote de ejemplos usando [DataCollatorForSeq2Seq](/docs/transformers/main/es/main_classes/data_collator#transformers.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.

```py
>>> 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](https://huggingface.co/docs/evaluate/index). Para esta tarea, carga la métrica [SacreBLEU](https://huggingface.co/spaces/evaluate-metric/sacrebleu) (consulta el [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) de 🤗 Evaluate para saber más sobre cómo cargar y calcular una métrica):

```py
>>> import evaluate

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

Luego, crea una función que pase tus predicciones y etiquetas a [compute](https://huggingface.co/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute) para calcular la puntuación SacreBLEU:

```py
>>> 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ás familiarizado con el ajuste fino de un modelo con [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer), ¡echa un vistazo al tutorial básico [aquí](../training)!

¡Ya está listo para comenzar a entrenar su modelo! Cargue T5 con [AutoModelForSeq2SeqLM](/docs/transformers/main/es/model_doc/auto#transformers.AutoModelForSeq2SeqLM):

```py
>>> from transformers import AutoModelForSeq2SeqLM, Seq2SeqTrainingArguments, Seq2SeqTrainer

>>> model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint)
```

En este punto, solo quedan tres pasos:

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

```py
>>> 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()](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer.push_to_hub) para que todo el mundo pueda usarlo:

```py
>>> 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](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/translation.ipynb) correspondiente.

## Inferencia

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

Pensar en algún texto que desees traducir a otro idioma. Para T5, debes añadir un prefijo a tu entrada según la tarea en la que estés trabajando. Para la traducción del inglés al francés, debes añadir el prefijo a tu entrada como se muestra a continuación:

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

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

```py
>>> 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()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.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](../main_classes/text_generation).

```py
>>> 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:

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