# Çeviri

Çeviri, bir metin dizisini bir dilden diğerine dönüştürür. Çeviri, çeviri veya özetleme gibi bir girdiden bir çıktı döndüren güçlü bir çerçeve olan diziden-diziye (sequence-to-sequence) bir problem olarak formüle edebileceğiniz görevlerden biridir. Çeviri sistemleri genellikle farklı dillerdeki metinler arasında çeviri için kullanılır, ancak ses veya metinden sese, sestan metne gibi aradaki bazı kombinasyonlar için de kullanılabilir.

Bu kılavuz size şunları gösterecektir:

1. İngilizce metinleri Fransızca'ya çevirmek için [OPUS Books](https://huggingface.co/datasets/Helsinki-NLP/opus_books) veri setinin İngilizce-Fransızca alt kümesinde [T5](https://huggingface.co/google-t5/t5-small) modelini ince ayarlayın.
2. İnce ayarlanmış modelinizi çıkarım için kullanın.

Bu görevle uyumlu tüm mimarileri ve denetim noktalarını görmek için [görev sayfasını](https://huggingface.co/tasks/translation) kontrol etmenizi öneririz.

Başlamadan önce, gerekli tüm kütüphanelerin yüklendiğinden emin olun:

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

Modelinizi yükleyip toplulukla paylaşabilmeniz için Hugging Face hesabınıza giriş yapmanızı öneririz. İstendiğinde giriş yapmak için token'ınızı girin:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## OPUS Books veri setini yükle

🤗 Datasets kütüphanesinden [OPUS Books](https://huggingface.co/datasets/Helsinki-NLP/opus_books) veri setinin İngilizce-Fransızca alt kümesini yükleyerek başlayın:

```py
>>> from datasets import load_dataset

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

Veri setini [train_test_split](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.train_test_split) yöntemiyle eğitim ve test kümesine ayırın:

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

Sonra bir örneğe göz atın:

```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`: metnin İngilizce ve Fransızca çevirisi.

## Ön işleme

Bir sonraki adım, İngilizce-Fransızca dil çiftlerini işlemek için bir T5 tokenizer yüklemektir:

```py
>>> from transformers import AutoTokenizer

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

Oluşturmak istediğiniz ön işleme fonksiyonu şunları yapmalıdır:

1. Girdinin başına bir istem ekleyin ki T5 bunun bir çeviri görevi olduğunu anlasın. Birden fazla NLP görevi için yetenekli bazı modeller, belirli görevler için istem gerektirir.
2. Hedef dilin (Fransızca) `text_target` parametresinde ayarlandığından emin olun; bu, tokenizer'ın hedef metni doğru şekilde işlemesini sağlar. `text_target` parametresini ayarlamazsanız, tokenizer hedef metni İngilizce olarak işler.
3. Dizileri, `max_length` parametresiyle belirlenen maksimum uzunluktan daha uzun olmamak üzere kırpın.

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

Ön işleme fonksiyonunu tüm veri setine uygulamak için 🤗 Datasets [map](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.map) yöntemini kullanın. `map` fonksiyonunu, veri setinin birden çok öğesini aynı anda işlemek için `batched=True` ayarlayarak hızlandırabilirsiniz:

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

Şimdi [DataCollatorForSeq2Seq](/docs/transformers/main/tr/main_classes/data_collator#transformers.DataCollatorForSeq2Seq) kullanarak örneklerden oluşan bir batch oluşturun. Toplama sırasında cümleleri batch içindeki en uzun uzunluğa *dinamik olarak doldurmak*, tüm veri setini maksimum uzunluğa doldurmaktan daha verimlidir.

```py
>>> from transformers import DataCollatorForSeq2Seq

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

## Değerlendir

Eğitim sırasında bir metrik kullanmak, modelinizin performansını değerlendirmek için genellikle faydalıdır. 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) kütüphanesiyle bir değerlendirme yöntemini hızla yükleyebilirsiniz. Bu görev için [SacreBLEU](https://huggingface.co/spaces/evaluate-metric/sacrebleu) metrikini yükleyin (bir metriğin nasıl yükleneceğini ve hesaplanacağını öğrenmek için 🤗 Evaluate [hızlı turuna](https://huggingface.co/docs/evaluate/a_quick_tour) bakın):

```py
>>> import evaluate

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

Ardından, tahminlerinizi ve etiketlerinizi [compute](https://huggingface.co/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute) işlevine ileterek SacreBLEU puanını hesaplayan bir işlev oluşturun:

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

`compute_metrics` fonksiyonunuz artık hazır ve eğitiminizi yapılandırırken ona geri döneceksiniz.

## Eğit

[Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer) ile bir modelin ince ayarını yapma konusunda deneyiminiz yoksa, temel öğreticiyi [burada](../training) inceleyebilirsiniz!

Modelinizi eğitmeye başlamak için hazırsınız! T5'i [AutoModelForSeq2SeqLM](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModelForSeq2SeqLM) ile yükleyin:

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

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

Bu noktada yalnızca üç adım kaldı:

1. Eğitim hiperparametrelerinizi [Seq2SeqTrainingArguments](/docs/transformers/main/tr/main_classes/trainer#transformers.Seq2SeqTrainingArguments) içinde tanımlayın. Tek zorunlu parametre, modelinizi nereye kaydedeceğinizi belirleyen `output_dir`'dir. Modelinizi Hub'a `push_to_hub=True` ayarlayarak yükleyeceksiniz (modelinizi yüklemek için Hugging Face'e giriş yapmış olmanız gerekir). Her epoch'un sonunda [Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer), SacreBLEU metrikini değerlendirir ve eğitim checkpoint'ini kaydeder.
2. Eğitim argümanlarını, model, veri seti, tokenizer, veri toplayıcı ve `compute_metrics` fonksiyonuyla birlikte [Seq2SeqTrainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Seq2SeqTrainer)'a iletin.
3. Modelinizi ince ayar yapmak için [train()](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer.train) çağrın.

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

Eğitim tamamlandıktan sonra, modelinizi herkesin kullanabilmesi için [push_to_hub()](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer.push_to_hub) yöntemiyle Hub'a paylaşın:

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

Çeviri için bir modelin nasıl ince ayar yapılacağına dair daha ayrıntılı bir örnek için ilgili [PyTorch defterine](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/translation.ipynb) göz atın.

## Çıkarım

Harika, bir model ayarladıktan sonra artık çıkarım için kullanabilirsiniz!

Çevirmek istediğiniz başka bir dile çevrilecek bazı metinler oluşturun. T5 için, üzerinde çalıştığınız göreve göre girdinizi bir önekle (prefix) ile başlamanız gerekir. İngilizceden Fransızca'ya çeviri için, girdinizi aşağıda gösterildiği gibi öneklemelisiniz:

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

Metni tokenleştirin ve `input_ids` değerlerini PyTorch tensörleri olarak döndürün:

```py
>>> from transformers import AutoTokenizer

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

Çeviriyi oluşturmak için [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) yöntemini kullanın. Farklı metin üretim stratejileri ve üretimi kontrol etmeye yönelik parametreler hakkında daha fazla ayrıntı için [Text Generation](../main_classes/text_generation) API'sine göz atın.

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

Oluşturulan token kimliklerini metne geri dönüştürün:

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