# Terjemahan

Terjemahan mengubah rangkaian teks dari satu bahasa ke bahasa lain. Ini adalah salah satu dari beberapa tugas yang dapat diformulasikan sebagai masalah sequence-to-sequence, sebuah kerangka kerja yang kuat untuk menghasilkan keluaran tertentu dari masukan, seperti terjemahan atau ringkasan. Sistem terjemahan umumnya digunakan untuk menerjemahkan teks antar bahasa yang berbeda, tetapi juga dapat digunakan untuk ucapan atau beberapa kombinasi di antaranya, seperti text-to-speech atau speech-to-text.

Panduan ini akan menunjukkan cara Anda untuk:

1. Lakukan finetune [T5](https://huggingface.co/google-t5/t5-small) pada subset Inggris-Prancis dari dataset [OPUS Books](https://huggingface.co/datasets/Helsinki-NLP/opus_books) untuk menerjemahkan teks Inggris ke Prancis.
2. Gunakan model yang telah Anda finetune untuk inferensi.

Untuk melihat semua arsitektur dan checkpoint yang kompatibel dengan tugas ini, kami menyarankan untuk memeriksa [halaman tugas](https://huggingface.co/tasks/translation).

Sebelum memulai, pastikan Anda telah menginstal semua pustaka yang diperlukan:

```bash
pip install transformers datasets evaluate sacrebleu
```

Kami menyarankan Anda untuk masuk ke akun Hugging Face Anda agar dapat mengunggah dan membagikan model Anda kepada komunitas. Saat diminta, masukkan token Anda untuk masuk:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Muat dataset OPUS Books

Mulai dengan memuat subset Inggris-Prancis dari dataset [OPUS Books](https://huggingface.co/datasets/Helsinki-NLP/opus_books) dari pustaka 🤗 Datasets:

```py
>>> from datasets import load_dataset

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

Bagi dataset menjadi set latih dan set uji dengan metode [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)
```

Lalu, lihatlah sebuah contoh:

```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`: terjemahan teks dalam bahasa Inggris dan Prancis.

## Pra-pemrosesan

Langkah selanjutnya adalah memuat tokenizer T5 untuk memproses pasangan bahasa Inggris-Prancis:

```py
>>> from transformers import AutoTokenizer

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

Fungsi pra-pemrosesan yang ingin Anda buat harus:

1. Tambahkan prompt di awal input agar T5 memahami bahwa ini adalah tugas terjemahan. Beberapa model yang mampu menangani berbagai tugas NLP memerlukan prompt untuk tugas tertentu.
2. Atur bahasa target (Prancis) pada parameter `text_target` untuk memastikan tokenizer memproses teks target dengan benar. Jika Anda tidak mengatur `text_target`, tokenizer akan memproses teks target sebagai bahasa Inggris.
3. Potong urutan agar tidak lebih panjang dari panjang maksimum yang ditetapkan oleh parameter `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
```

Untuk menerapkan fungsi pra-pemrosesan ke seluruh dataset, gunakan metode [map](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.map) dari 🤗 Datasets. Anda dapat mempercepat fungsi `map` dengan mengatur `batched=True` untuk memproses beberapa elemen dataset sekaligus:

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

Sekarang buat batch contoh menggunakan [DataCollatorForSeq2Seq](/docs/transformers/main/id/main_classes/data_collator#transformers.DataCollatorForSeq2Seq). Lebih efisien untuk *melakukan padding dinamis* kalimat hingga panjang terpanjang dalam batch saat kolasi, daripada melakukan padding seluruh dataset hingga panjang maksimum.

```py
>>> from transformers import DataCollatorForSeq2Seq

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

## Evaluasi

Menyertakan metrik selama pelatihan sering kali membantu untuk mengevaluasi kinerja model Anda. Anda dapat dengan cepat memuat metode evaluasi dengan pustaka 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index). Untuk tugas ini, muat metrik [SacreBLEU](https://huggingface.co/spaces/evaluate-metric/sacrebleu) (lihat [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

```py
>>> import evaluate

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke [compute](https://huggingface.co/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute) untuk menghitung skor 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
```

Fungsi `compute_metrics` Anda sudah siap digunakan, dan Anda akan kembali ke fungsi ini saat menyiapkan pelatihan.

## Latih

Jika Anda belum familiar dengan finetuning model menggunakan [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer), silakan lihat tutorial dasar [di sini](../training)!

Anda siap untuk mulai melatih model Anda sekarang! Muat T5 dengan [AutoModelForSeq2SeqLM](/docs/transformers/main/id/model_doc/auto#transformers.AutoModelForSeq2SeqLM):

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

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

Pada titik ini, hanya tersisa tiga langkah:

1. Definisikan hiperparameter pelatihan Anda di [Seq2SeqTrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.Seq2SeqTrainingArguments). Satu-satunya parameter yang wajib diisi adalah `output_dir` yang menentukan di mana model Anda akan disimpan. Anda akan mendorong model ini ke Hub dengan mengatur `push_to_hub=True` (Anda harus masuk ke Hugging Face untuk mengunggah model Anda). Di akhir setiap epoch, [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) akan mengevaluasi metrik SacreBLEU dan menyimpan checkpoint pelatihan.
2. Lewatkan argumen pelatihan ke [Seq2SeqTrainer](/docs/transformers/main/id/main_classes/trainer#transformers.Seq2SeqTrainer) bersama dengan model, dataset, tokenizer, data collator, dan fungsi `compute_metrics`.
3. Panggil [train()](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer.train) untuk melakukan finetuning pada model Anda.

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

Setelah pelatihan selesai, bagikan model Anda ke Hub dengan metode [push_to_hub()](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer.push_to_hub) agar semua orang dapat menggunakan model Anda:

```py
>>> trainer.push_to_hub()
```

Untuk contoh yang lebih mendalam tentang cara melakukan finetuning model untuk penerjemahan, lihat [notebook PyTorch](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/translation.ipynb) yang sesuai.

## Inferensi

Bagus, sekarang setelah Anda melakukan penyesuaian halus pada model, Anda dapat menggunakannya untuk inferensi!

Buatlah beberapa teks yang ingin Anda terjemahkan ke bahasa lain. Untuk T5, Anda perlu menambahkan awalan pada input Anda tergantung pada tugas yang sedang Anda kerjakan. Untuk terjemahan dari bahasa Inggris ke bahasa Prancis, Anda harus menambahkan awalan pada input Anda seperti yang ditunjukkan di bawah ini:

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

Tokenisasi teks dan kembalikan `input_ids` sebagai tensor PyTorch:

```py
>>> from transformers import AutoTokenizer

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

Gunakan metode [generate()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk membuat terjemahan. Untuk detail lebih lanjut tentang strategi generasi teks yang berbeda dan parameter untuk mengontrol generasi, lihat API [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)
```

Decode id token yang dihasilkan kembali menjadi teks:

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