# Pilihan ganda

Tugas pilihan ganda mirip dengan penjawab pertanyaan, kecuali beberapa jawaban kandidat disediakan bersama dengan konteks, dan model dilatih untuk memilih jawaban yang benar.

Panduan ini akan menunjukkan cara Anda untuk:

1. Lakukan finetune [BERT](https://huggingface.co/google-bert/bert-base-uncased) pada konfigurasi `regular` dari dataset [SWAG](https://huggingface.co/datasets/allenai/swag) untuk memilih jawaban terbaik berdasarkan beberapa opsi dan konteks tertentu.
2. Gunakan model yang telah Anda finetune untuk inferensi.

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

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

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 SWAG

Mulai dengan memuat konfigurasi `regular` dari dataset SWAG menggunakan pustaka 🤗 Datasets:

```py
>>> from datasets import load_dataset

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

Lalu, lihatlah sebuah contoh:

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

Meskipun terlihat ada banyak field di sini, sebenarnya cukup sederhana:

- `sent1` dan `sent2`: field-field ini menunjukkan bagaimana sebuah kalimat dimulai, dan jika Anda menggabungkan keduanya, Anda akan mendapatkan field `startphrase`.
- `ending`: mengusulkan kemungkinan akhir untuk bagaimana sebuah kalimat dapat diakhiri, tetapi hanya salah satunya yang benar.
- `label`: mengidentifikasi akhir kalimat yang benar.

## Pra-pemrosesan

Langkah selanjutnya adalah memuat tokenizer BERT untuk memproses awal kalimat dan empat kemungkinan akhirannya:

```py
>>> from transformers import AutoTokenizer

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

Fungsi pra-pemrosesan yang ingin Anda buat harus:

1. Buatkan empat salinan dari field `sent1` dan gabungkan masing-masing dengan `sent2` untuk merekonstruksi bagaimana sebuah kalimat dimulai.
2. Gabungkan `sent2` dengan masing-masing dari empat kemungkinan akhir kalimat.
3. Ratakan kedua daftar ini agar dapat ditokenisasi, lalu kembalikan ke bentuk semula agar setiap contoh memiliki field `input_ids`, `attention_mask`, dan `labels` yang bersesuaian.

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

Untuk menerapkan fungsi pra-pemrosesan ke seluruh dataset, gunakan metode [map](https://huggingface.co/docs/datasets/v5.2.0/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_swag = swag.map(preprocess_function, batched=True)
```

Untuk membuat batch contoh, lebih efisien untuk *melakukan padding secara dinamis* pada kalimat hingga panjang terpanjang dalam batch saat kolasi, daripada melakukan padding seluruh dataset hingga panjang maksimum. [DataCollatorForMultipleChoice](/docs/transformers/v5.23.0/id/main_classes/data_collator#transformers.DataCollatorForMultipleChoice) meratakan semua input model, menerapkan padding, dan kemudian meratakan kembali hasilnya.

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

## Evaluasi

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

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) untuk menghitung akurasi:

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

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/v5.23.0/id/main_classes/trainer#transformers.Trainer), silakan lihat tutorial dasar [di sini](../training)!

Anda siap untuk mulai melatih model Anda sekarang! Muat BERT dengan [AutoModelForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModelForMultipleChoice):

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

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

Pada titik ini, hanya tersisa tiga langkah:

1. Definisikan hiperparameter pelatihan Anda di [TrainingArguments](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.TrainingArguments). 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/v5.23.0/id/main_classes/trainer#transformers.Trainer) akan mengevaluasi akurasi dan menyimpan checkpoint pelatihan.
2. Lewatkan argumen pelatihan ke [Trainer](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) bersama dengan model, dataset, tokenizer, data collator, dan fungsi `compute_metrics`.
3. Panggil [train()](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer.train) untuk melakukan finetuning pada model Anda.

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

Setelah pelatihan selesai, bagikan model Anda ke Hub dengan metode [push_to_hub()](/docs/transformers/v5.23.0/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 pilihan ganda, lihat [notebook PyTorch](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb) yang sesuai.

## Inferensi

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

Buatlah beberapa teks dan dua jawaban kandidat:

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

Tokenisasi setiap pasangan prompt dan jawaban kandidat, lalu kembalikan tensor PyTorch. Anda juga harus membuat beberapa `labels`:

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

Lewatkan input dan label Anda ke model dan kembalikan `logits`:

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

Dapatkan kelas dengan probabilitas tertinggi:

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

