# Çoktan seçmeli

Çoktan seçmeli bir görev, soru yanıtlamaya benzer; ancak bağlamın yanı sıra birkaç aday cevap da sağlanır ve model, doğru cevabı seçecek şekilde eğitilir.

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

1. [BERT](https://huggingface.co/google-bert/bert-base-uncased) modelini, birden fazla seçenek ve bazı bağlam verildiğinde en iyi cevabı seçmek üzere [SWAG](https://huggingface.co/datasets/allenai/swag) veri setinin `regular` yapılandırması üzerinde ince ayarlayın.
2. İnce ayarlanmış modelinizi çıkarım için kullanın.

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

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

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

## SWAG veri setini yükle

SWAG veri setinin `regular` yapılandırmasını 🤗 Datasets kütüphanesinden yükleyerek başlayın:

```py
>>> from datasets import load_dataset

>>> swag = load_dataset("allenai/swag", "regular")
```

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

```py
>>> swag["train"][0]
{'ending0': 'passes by walking down the street playing their instruments.',
 'ending1': 'has heard approaching them.',
 'ending2': "arrives and they're outside dancing and asleep.",
 'ending3': 'turns the lead singer watches the performance.',
 'fold-ind': '3416',
 'gold-source': 'gold',
 'label': 0,
 'sent1': 'Members of the procession walk down the street holding small horn brass instruments.',
 'sent2': 'A drum line',
 'startphrase': 'Members of the procession walk down the street holding small horn brass instruments. A drum line',
 'video-id': 'anetv_jkn6uvmqwh4'}
```

Burada birçok alan var gibi görünse de aslında oldukça basittir:

- `sent1` ve `sent2`: bu alanlar bir cümlenin nasıl başladığını gösterir ve ikisini bir araya getirdiğinizde `startphrase` alanını elde edersiniz.
- `ending`: bir cümlenin nasıl bitebileceğine dair olası bir son önerir, ancak bunlardan yalnızca biri doğrudur.
- `label`: doğru cümle sonunu belirler.

## Ön işleme

Bir sonraki adım, cümle başlangıçlarını ve dört olası sonu işlemek için bir BERT tokenizer'ı yüklemektir:

```py
>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
```

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

1. `sent1` alanının dört kopyasını oluşturun ve her birini `sent2` ile birleştirerek bir cümlenin nasıl başladığını yeniden oluşturun.
2. `sent2` öğesini, dört olası cümle sonundan her biriyle birleştirin.
3. Bu iki listeyi, onları tokenize edebilmek için düzleştirin ve ardından her örneğin karşılık gelen `input_ids`, `attention_mask` ve `labels` alanına sahip olması için yeniden düzleştirilmiş hâle getirin.

```py
>>> ending_names = ["ending0", "ending1", "ending2", "ending3"]

>>> def preprocess_function(examples):
...     first_sentences = [[context] * 4 for context in examples["sent1"]]
...     question_headers = examples["sent2"]
...     second_sentences = [
...         [f"{header} {examples[end][i]}" for end in ending_names] for i, header in enumerate(question_headers)
...     ]

...     first_sentences = sum(first_sentences, [])
...     second_sentences = sum(second_sentences, [])

...     tokenized_examples = tokenizer(first_sentences, second_sentences, truncation=True)
...     return {k: [v[i : i + 4] for i in range(0, len(v), 4)] for k, v in tokenized_examples.items()}
```

Ö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_swag = swag.map(preprocess_function, batched=True)
```

Örneklerin bir partisini oluşturmak için, tüm veri setini maksimum uzunluğa doldurmak yerine, birleştirme sırasında cümleleri *dinamik olarak* parti içindeki en uzun uzunluğa doldurmak daha verimlidir. [DataCollatorForMultipleChoice](/docs/transformers/main/tr/main_classes/data_collator#transformers.DataCollatorForMultipleChoice), tüm model girdilerini düzleştirir, dolguyu uygular ve ardından sonuçları yeniden biçimlendirir.

```py
>>> from transformers import DataCollatorForMultipleChoice
>>> collator = DataCollatorForMultipleChoice(tokenizer=tokenizer)
```

## 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 [accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) 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

>>> accuracy = evaluate.load("accuracy")
```

Ardından, tahminlerinizi ve etiketlerinizi [compute](https://huggingface.co/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute) işlevine geçirerek doğruluğu hesaplayan bir işlev oluşturun:

```py
>>> import numpy as np

>>> def compute_metrics(eval_pred):
...     predictions, labels = eval_pred
...     predictions = np.argmax(predictions, axis=1)
...     return accuracy.compute(predictions=predictions, references=labels)
```

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

Artık modelinizi eğitmeye hazırsınız! BERT'i [AutoModelForMultipleChoice](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModelForMultipleChoice) ile yükleyin:

```py
>>> from transformers import AutoModelForMultipleChoice, TrainingArguments, Trainer

>>> model = AutoModelForMultipleChoice.from_pretrained("google-bert/bert-base-uncased")
```

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

1. Eğitim hiperparametrelerinizi [TrainingArguments](/docs/transformers/main/tr/main_classes/trainer#transformers.TrainingArguments) 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), doğruluğu 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 [Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer)'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 = TrainingArguments(
...     output_dir="my_awesome_swag_model",
...     eval_strategy="epoch",
...     save_strategy="epoch",
...     load_best_model_at_end=True,
...     learning_rate=5e-5,
...     per_device_train_batch_size=16,
...     per_device_eval_batch_size=16,
...     num_train_epochs=3,
...     weight_decay=0.01,
...     push_to_hub=True,
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=tokenized_swag["train"],
...     eval_dataset=tokenized_swag["validation"],
...     processing_class=tokenizer,
...     data_collator=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()
```

Bir modeli çoktan seçmeli görevler için ince ayar yapmanın daha ayrıntılı bir örneği için ilgili [PyTorch defterine](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb) göz atın.

## Çıkarım

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

Bazı metin ve iki aday cevap üretin:

```py
>>> prompt = "France has a bread law, Le Décret Pain, with strict rules on what is allowed in a traditional baguette."
>>> candidate1 = "The law does not apply to croissants and brioche."
>>> candidate2 = "The law applies to baguettes."
```

Her istem ve aday cevap çiftini tokenlaştırmak ve PyTorch tensörlerini döndürmek için. Ayrıca bazı `labels` oluşturmalısınız:

```py
>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("username/my_awesome_swag_model")
>>> inputs = tokenizer([[prompt, candidate1], [prompt, candidate2]], return_tensors="pt", padding=True)
>>> labels = torch.tensor(0).unsqueeze(0)
```

Girdilerinizi ve etiketlerinizi modele iletin ve `logits` değerlerini döndürün:

```py
>>> from transformers import AutoModelForMultipleChoice

>>> model = AutoModelForMultipleChoice.from_pretrained("username/my_awesome_swag_model")
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in inputs.items()}, labels=labels)
>>> logits = outputs.logits
```

En yüksek olasılığa sahip sınıfı alın:

```py
>>> predicted_class = logits.argmax().item()
>>> predicted_class
0
```