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 pada konfigurasi regular dari dataset 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:

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:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Muat dataset SWAG

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

>>> from datasets import load_dataset

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

Lalu, lihatlah sebuah contoh:

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

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

>>> 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 dari 🤗 Datasets. Anda dapat mempercepat fungsi map dengan mengatur batched=True untuk memproses beberapa elemen dataset sekaligus:

>>> 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 collation, alih-alih melakukan padding seluruh dataset hingga panjang maksimum. DataCollatorForMultipleChoice meratakan semua input model, menerapkan padding, dan kemudian meratakan kembali hasilnya.

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

Evaluasi

Menambahkan metrik selama pelatihan sering kali membantu untuk mengevaluasi kinerja model Anda. Anda dapat dengan cepat memuat metode evaluasi dengan pustaka 🤗 Evaluate. Untuk tugas ini, muat metrik accuracy (lihat quick tour 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

>>> import evaluate

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke compute untuk menghitung akurasi:

>>> 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, silakan lihat tutorial dasar di sini!

Anda siap untuk mulai melatih model Anda sekarang! Muat BERT dengan AutoModelForMultipleChoice:

>>> 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. Satu-satunya parameter yang wajib diisi adalah output_dir yang menentukan lokasi penyimpanan model Anda. 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 akan mengevaluasi akurasi dan menyimpan checkpoint pelatihan.
2. Lewatkan argumen pelatihan ke Trainer bersama dengan model, dataset, tokenizer, data collator, dan fungsi compute_metrics.
3. Panggil train() untuk melakukan finetuning pada model Anda.

>>> 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() agar semua orang dapat menggunakan model Anda:

>>> trainer.push_to_hub()

Untuk contoh yang lebih mendalam tentang cara melakukan finetuning model untuk pilihan ganda, lihat notebook PyTorch yang sesuai.

Inferensi

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

Buatlah beberapa teks dan dua jawaban kandidat:

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

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

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

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