Sistem Question Answering (QA) merupakan salah satu aplikasi menarik dari Natural Language Processing (NLP) yang memungkinkan mesin menjawab pertanyaan dalam bahasa manusia berdasarkan konteks teks yang diberikan. Model canggih seperti BERT (Bidirectional Encoder Representations from Transformers) telah merevolusi kemampuan sistem QA berkat pemahamannya yang mendalam terhadap konteks bahasa. Untungnya, library seperti Hugging Face Transformers menyediakan perangkat yang sangat memudahkan pengembang untuk mengimplementasikan model-model ini. Tutorial ini akan memandu Anda langkah demi langkah dalam membangun sistem QA sederhana menggunakan BERT dan Hugging Face Transformers, lengkap dengan contoh kode implementasi BERT QA Python yang praktis.
Memahami Konsep Dasar: QA, BERT, dan Hugging Face
Sebelum masuk ke langkah teknis, mari kita pahami beberapa konsep kunci yang akan digunakan:
Question Answering (QA): Secara sederhana, sistem QA adalah program komputer yang dirancang untuk secara otomatis menjawab pertanyaan yang diajukan oleh manusia dalam bahasa alami. Berbeda dengan mesin pencari tradisional yang mengembalikan daftar dokumen relevan, sistem QA bertujuan memberikan jawaban yang singkat dan tepat, yang diekstrak atau disintesis dari satu atau beberapa sumber informasi (disebut konteks). Aplikasinya sangat luas, mulai dari chatbot layanan pelanggan, asisten virtual, hingga alat bantu analisis data teks.
BERT (Bidirectional Encoder Representations from Transformers): BERT adalah model pemrosesan bahasa alami yang dikembangkan oleh Google AI. Keunikan BERT terletak pada kemampuannya memahami konteks kata dalam sebuah kalimat dari kedua arah (kiri-ke-kanan dan kanan-ke-kiri). Kemampuan ini membuatnya sangat efektif dalam tugas-tugas NLP yang membutuhkan pemahaman kontekstual mendalam, termasuk Question Answering. Model ini telah dilatih pada korpus teks yang sangat besar, memungkinkannya menangkap nuansa bahasa yang kompleks.
Hugging Face Transformers: Ini adalah library Python open-source yang menjadi standar de-facto untuk bekerja dengan model Transformer seperti BERT. Library ini menyediakan akses mudah ke ribuan model pra-terlatih (termasuk varian BERT yang sudah di-fine-tune untuk tugas QA) melalui Hugging Face Hub. Selain itu, ia juga menyediakan API tingkat tinggi untuk tokenisasi, inferensi, dan bahkan pelatihan model. Dengan Hugging Face, implementasi sistem QA menggunakan BERT menjadi jauh lebih sederhana dan cepat.
Dengan memahami dasar-dasar ini, Anda siap untuk memulai proses pembangunan sistem QA Anda.
Langkah 1: Persiapan Lingkungan Pengembangan Python
Langkah pertama adalah memastikan lingkungan pengembangan Anda siap. Pastikan Anda memiliki Python terinstal (disarankan versi 3.7 atau lebih baru). Sangat direkomendasikan untuk menggunakan lingkungan virtual (seperti `venv` atau `conda`) untuk mengelola dependensi proyek agar tidak bentrok dengan instalasi Python global Anda.
Setelah lingkungan virtual aktif (jika Anda menggunakannya), buka terminal atau command prompt Anda dan instal library yang dibutuhkan menggunakan pip:
pip install transformers torch
Jika Anda lebih memilih menggunakan TensorFlow sebagai backend, gunakan perintah berikut:
pip install transformers tensorflow
Perintah ini akan mengunduh dan memasang library Hugging Face Transformers beserta dependensi utamanya (PyTorch atau TensorFlow), mempersiapkan Anda untuk langkah selanjutnya.
Langkah 2: Memuat Model BERT Pra-Terlatih dan Tokenizer QA
Setelah lingkungan siap, langkah berikutnya adalah memuat model BERT yang sudah dilatih khusus untuk tugas Question Answering beserta tokenizer yang sesuai. Hugging Face Hub menyediakan banyak pilihan model; untuk tutorial ini, kita akan menggunakan model populer yang telah di-fine-tune pada dataset SQuAD (Stanford Question Answering Dataset), yaitu `bert-large-uncased-whole-word-masking-finetuned-squad`.
Hugging Face memudahkan proses ini melalui class `AutoModelForQuestionAnswering` dan `AutoTokenizer`. Class ini secara otomatis akan memilih arsitektur model dan tokenizer yang benar berdasarkan nama model yang kita berikan. Proses ini mencakup langkah penting yaitu Load pre-trained BERT model.
Berikut adalah kode Python untuk memuat model dan tokenizer:
from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch # atau import tensorflow as tf jika menggunakan TensorFlow
# Nama model QA dari Hugging Face Hub
model_name = "bert-large-uncased-whole-word-masking-finetuned-squad"
print(f"Memuat tokenizer untuk model {model_name}...")
tokenizer = AutoTokenizer.from_pretrained(model_name)
print(f"Memuat model {model_name}...")
model = AutoModelForQuestionAnswering.from_pretrained(model_name)
print("Model dan Tokenizer berhasil dimuat.")
Kode ini akan mengunduh model dan tokenizer (jika belum ada di cache lokal Anda) dan memuatnya ke dalam memori, siap digunakan untuk memproses teks.
Langkah 3: Memproses Input Teks (Konteks dan Pertanyaan)
Model QA BERT memerlukan input spesifik: sebuah konteks (teks sumber informasi) dan sebuah pertanyaan yang jawabannya diharapkan ada di dalam konteks tersebut. Namun, model tidak bisa langsung memproses teks mentah. Di sinilah proses tokenisasi teks QA berperan penting.
Tokenizer yang telah kita muat akan melakukan beberapa langkah pra-pemrosesan:
- Memecah teks pertanyaan dan konteks menjadi unit-unit kecil yang disebut token (bisa berupa kata, sub-kata, atau karakter).
- Menambahkan token khusus yang dibutuhkan oleh arsitektur BERT, seperti `[CLS]` di awal dan `[SEP]` sebagai pemisah antara pertanyaan dan konteks, serta di akhir.
- Mengonversi setiap token menjadi ID numerik unik berdasarkan kosakata (vocabulary) model.
- Membuat `attention mask`, sebuah penanda biner (0 atau 1) untuk membedakan token asli dari token padding (jika ada).
- Membuat `token type IDs` (opsional tetapi berguna untuk QA) untuk membantu model membedakan mana bagian pertanyaan dan mana bagian konteks.
Mari kita terapkan ini pada contoh konteks dan pertanyaan menggunakan objek `tokenizer`:
# Contoh Konteks dan Pertanyaan
context = """
Hugging Face adalah perusahaan teknologi yang berbasis di New York City.
Perusahaan ini mengembangkan alat untuk membangun aplikasi menggunakan machine learning.
Salah satu produk utamanya adalah library Transformers yang menyediakan ribuan model pra-terlatih.
"""
question = "Apa produk utama Hugging Face?"
print("\nMelakukan tokenisasi untuk pertanyaan dan konteks...")
# Tokenisasi input
# return_tensors='pt' menghasilkan output PyTorch tensors. Gunakan 'tf' untuk TensorFlow.
inputs = tokenizer(question, context, return_tensors='pt')
# 'inputs' adalah dictionary berisi tensor:
# - input_ids: ID numerik dari token
# - attention_mask: Mask atensi
# - token_type_ids: ID tipe token (membedakan pertanyaan dan konteks)
print("Input Teks berhasil di-tokenisasi.")
# print(inputs) # Uncomment untuk melihat detail hasil tokenisasi
Tokenizer secara otomatis menggabungkan pertanyaan dan konteks sesuai format yang diharapkan model (`[CLS] question [SEP] context [SEP]`) dan menghasilkan tensor yang siap dimasukkan sebagai input ke model BERT.
Langkah 4: Menjalankan Inferensi Model untuk Prediksi Jawaban
Dengan input yang sudah diproses dalam format tensor, kita kini dapat memberikannya ke model BERT QA untuk melakukan inferensi. Proses ini merupakan inti dari prediksi jawaban BERT.
Model akan memproses `input_ids`, `attention_mask`, dan `token_type_ids`, lalu menghasilkan output berupa skor mentah (logits) untuk setiap token dalam input. Secara spesifik untuk tugas QA, model menghasilkan dua set logits:
- `start_logits`: Skor kemungkinan setiap token menjadi token *awal* dari jawaban.
- `end_logits`: Skor kemungkinan setiap token menjadi token *akhir* dari jawaban.
Berikut kode untuk menjalankan inferensi:
print("\nMenjalankan inferensi model...")
# Nonaktifkan perhitungan gradien untuk efisiensi saat inferensi
with torch.no_grad():
outputs = model(**inputs)
# Jika menggunakan TensorFlow: outputs = model(inputs)
# Ekstrak start dan end logits dari output model
start_logits = outputs.start_logits
end_logits = outputs.end_logits
print("Inferensi model selesai. Mendapatkan start dan end logits.")
# print("Start Logits Shape:", start_logits.shape) # Output: (batch_size, sequence_length)
# print("End Logits Shape:", end_logits.shape) # Output: (batch_size, sequence_length)
Variabel `start_logits` dan `end_logits` kini menyimpan skor yang akan kita gunakan untuk menentukan posisi jawaban dalam teks asli.
Langkah 5: Mengekstrak Teks Jawaban dari Output Model
Setelah mendapatkan `start_logits` dan `end_logits`, langkah terakhir adalah menginterpretasikannya untuk mengekstrak teks jawaban yang sebenarnya.
Strategi umumnya adalah menemukan indeks token dengan skor `start_logits` tertinggi dan indeks token dengan skor `end_logits` tertinggi. Kedua indeks ini (`start_index` dan `end_index`) akan menandai rentang token dalam `input_ids` yang paling mungkin merupakan jawaban.
Setelah mendapatkan `start_index` dan `end_index`, kita mengambil irisan (slice) dari `input_ids` asli yang berada dalam rentang `[start_index, end_index]`. Kemudian, kita gunakan metode `tokenizer.decode()` untuk mengonversi token ID tersebut kembali menjadi string teks yang dapat dibaca manusia.
Beberapa hal penting yang perlu dipertimbangkan saat ekstraksi:
- Pastikan `end_index` tidak lebih kecil dari `start_index`.
- Idealnya, jawaban harus berasal dari bagian konteks, bukan dari pertanyaan atau token spesial. Perlu validasi tambahan untuk memastikan ini.
- Terkadang model mungkin tidak menemukan jawaban yang relevan; perlu logika untuk menangani kasus ini (misalnya, dengan memeriksa skor logits atau memastikan rentang valid).
Berikut kode untuk mengekstrak teks jawaban:
print("\nMengekstrak jawaban dari logits...")
# Temukan indeks token dengan skor start dan end tertinggi
start_index = torch.argmax(start_logits, dim=1).item() # Argmax di sepanjang dimensi urutan token
end_index = torch.argmax(end_logits, dim=1).item()
# Validasi sederhana dan ekstraksi jawaban
answer = "Jawaban tidak dapat ditemukan atau indeks tidak valid."
if end_index >= start_index:
# Ambil semua token ID dari input asli antara start dan end index
input_ids = inputs['input_ids'][0] # Ambil dari batch pertama
answer_tokens = input_ids[start_index : end_index + 1]
# Konversi token ID kembali menjadi string, hilangkan token spesial
answer = tokenizer.decode(answer_tokens, skip_special_tokens=True)
# Membersihkan spasi ekstra yang mungkin muncul dari tokenisasi sub-kata BPE/WordPiece
answer = answer.replace(' ##', '').replace('##', '')
print(f"Indeks Awal Prediksi: {start_index}")
print(f"Indeks Akhir Prediksi: {end_index}")
print(f"\nJawaban Prediksi: {answer}")
Dengan kode ini, kita mendapatkan teks jawaban akhir yang diekstrak oleh model BERT QA.
Contoh Kode Lengkap Implementasi BERT QA Python
Untuk memudahkan, berikut adalah gabungan semua langkah-langkah QA BERT Hugging Face dalam satu skrip Python yang fungsional. Ini menyajikan contoh kode BERT QA yang dapat Anda jalankan langsung:
# Import library yang diperlukan
from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch # Gunakan 'import tensorflow as tf' jika memakai TensorFlow
def run_qa_bert(context, question):
"""Fungsi untuk menjalankan QA BERT pada konteks dan pertanyaan tertentu."""
# 1. Muat Model dan Tokenizer (diasumsikan sudah dimuat sebelumnya atau dimuat di sini)
# Untuk contoh ini, kita muat di luar fungsi agar tidak berulang
print("\n--- Memulai Proses QA --- Coba 2")
print(f"Konteks: {context[:100]}..." ) # Tampilkan sebagian konteks
print(f"Pertanyaan: {question}")
# 3. Proses Input (Tokenisasi)
print("\nTokenisasi input...")
# Tambahkan max_length dan truncation untuk menangani teks yang mungkin panjang
inputs = tokenizer(question, context, return_tensors='pt', max_length=512, truncation=True)
input_ids = inputs['input_ids'][0] # Simpan input_ids untuk decoding nanti
print("Tokenisasi selesai.")
# 4. Jalankan Inferensi Model
print("\nMenjalankan inferensi model...")
try:
with torch.no_grad(): # Mode inferensi (tanpa perhitungan gradien)
outputs = model(**inputs)
# Jika menggunakan TensorFlow: outputs = model(inputs)
start_logits = outputs.start_logits
end_logits = outputs.end_logits
print("Inferensi model selesai.")
except Exception as e:
print(f"Error saat inferensi model: {e}")
return "Error saat inferensi."
# 5. Ekstrak Jawaban
print("\nMengekstrak jawaban...")
start_index = torch.argmax(start_logits, dim=1).item()
end_index = torch.argmax(end_logits, dim=1).item()
# Validasi lebih baik: jawaban harus berada dalam konteks (setelah token [SEP] pertama)
# Temukan posisi token [SEP] pertama
sep_token_id = tokenizer.sep_token_id
sep_indices = (input_ids == sep_token_id).nonzero(as_tuple=True)[0]
answer = "Jawaban tidak dapat ditemukan atau indeks tidak valid."
if len(sep_indices) > 0:
sep_index = sep_indices[0].item() # Indeks [SEP] pertama (pemisah Q dan C)
# Pastikan start_index berada setelah [SEP] pertama dan end_index >= start_index
if start_index > sep_index and end_index >= start_index:
answer_tokens = input_ids[start_index : end_index + 1]
answer = tokenizer.decode(answer_tokens, skip_special_tokens=True)
# Membersihkan spasi ekstra
answer = answer.replace(' ##', '').replace('##', '')
elif start_index <= sep_index:
# Model mungkin salah prediksi jawaban di dalam pertanyaan
answer = "Prediksi jawaban berada di dalam pertanyaan, bukan konteks."
print(f"Indeks Awal Prediksi: {start_index}")
print(f"Indeks Akhir Prediksi: {end_index}")
print(f"Jawaban Prediksi: {answer}")
print("--- Proses QA Selesai --- Coba 2")
return answer
# --- Main Execution --- Coba 2
if __name__ == "__main__":
# 1. Muat Model dan Tokenizer (sekali saja)
model_name = "bert-large-uncased-whole-word-masking-finetuned-squad"
try:
print(f"Memuat tokenizer {model_name}...")
tokenizer = AutoTokenizer.from_pretrained(model_name)
print(f"Memuat model {model_name}...")
model = AutoModelForQuestionAnswering.from_pretrained(model_name)
print("Model dan Tokenizer berhasil dimuat.")
except Exception as e:
print(f"Error memuat model/tokenizer: {e}")
exit()
# 2. Siapkan Konteks dan Pertanyaan
context_1 = """
Artificial Intelligence (AI) adalah bidang ilmu komputer yang berfokus pada penciptaan mesin cerdas
yang bekerja dan bereaksi seperti manusia. Beberapa aktivitas komputer dengan kecerdasan buatan
dirancang untuk mencakup pengenalan ucapan, pembelajaran, perencanaan, dan pemecahan masalah.
Kirim.ai adalah contoh perusahaan yang memanfaatkan AI untuk solusi bisnis.
"""
question_1 = "Apa itu Artificial Intelligence?"
context_2 = """
Gunung Everest adalah gunung tertinggi di Bumi diukur dari permukaan laut,
terletak di sub-pegunungan Mahalangur Himal di Himalaya.
Ketinggian resminya adalah 8.848,86 meter (29.031,7 kaki).
"""
question_2 = "Di mana lokasi Gunung Everest?"
# Jalankan QA untuk contoh pertama
jawaban_1 = run_qa_bert(context_1, question_1)
# Jalankan QA untuk contoh kedua
jawaban_2 = run_qa_bert(context_2, question_2)
Jalankan skrip ini. Anda akan melihat bagaimana model BERT QA memproses input dan berhasil mengekstrak jawaban yang relevan dari konteks yang berbeda untuk setiap pertanyaan.
Kesimpulan dan Langkah Selanjutnya
Selamat! Anda telah mempelajari langkah-langkah fundamental untuk membangun sistem Question Answering menggunakan model BERT pra-terlatih melalui library Hugging Face Transformers. Kita telah membahas mulai dari persiapan lingkungan, memuat model dan tokenizer, memproses input teks (tokenisasi), menjalankan inferensi untuk mendapatkan prediksi, hingga mengekstrak teks jawaban akhir. Library Hugging Face terbukti sangat menyederhanakan proses yang sebelumnya kompleks ini.
Sistem QA yang dibangun dalam tutorial ini adalah titik awal yang solid. Terdapat banyak potensi pengembangan lebih lanjut untuk meningkatkan kemampuannya:
- Eksplorasi Model Lain: Coba gunakan model QA berbeda dari Hugging Face Hub. Mungkin ada model yang lebih ringan (seperti DistilBERT QA) atau model yang secara spesifik dilatih untuk bahasa atau domain tertentu, misalnya untuk kebutuhan NLP Indonesia.
- Fine-tuning Model: Untuk akurasi maksimal pada topik spesifik, Anda dapat melakukan proses Fine tuning BERT untuk QA menggunakan dataset khusus domain Anda.
- Penanganan Jawaban Tidak Tersedia: Implementasikan mekanisme yang lebih canggih untuk mendeteksi ketika jawaban tidak ada dalam konteks. Ini bisa melibatkan analisis skor logits atau menggunakan model yang dilatih pada dataset seperti SQuAD 2.0 yang menyertakan pertanyaan tak terjawab.
- Evaluasi Kinerja Model: Lakukan Evaluasi model Question Answering secara formal menggunakan metrik standar seperti F1 score dan Exact Match pada dataset benchmark (misalnya, bagian dari Dataset SQuAD QA) untuk mengukur performa model secara objektif.
- Integrasi ke Aplikasi: Integrasikan sistem QA ini ke dalam aplikasi yang lebih besar, seperti chatbot, sistem pencarian dokumen internal, atau alat analisis feedback pelanggan.
- Manfaatkan Pipeline Hugging Face: Untuk implementasi yang lebih cepat dan abstraksi tingkat tinggi pada kasus penggunaan standar, gunakan Pipeline QA Hugging Face (`pipeline('question-answering')`). Ini menyembunyikan banyak langkah pra-pemrosesan dan pasca-pemrosesan.
Butuh Solusi AI Lebih Lanjut untuk Bisnis Anda?
Membangun sistem QA ini adalah langkah awal yang menarik ke dunia AI praktis. Namun, jika bisnis Anda membutuhkan solusi kecerdasan buatan yang lebih kompleks, terintegrasi, atau disesuaikan—seperti pengembangan platform AI khusus, implementasi AI Agent untuk otomatisasi proses bisnis (misalnya SEO), atau pembuatan aplikasi cerdas lainnya—seringkali diperlukan keahlian dan sumber daya yang lebih mendalam. Platform SaaS dan layanan pengembangan khusus dari Kirim.ai dirancang untuk memberdayakan bisnis dengan solusi AI canggih. Tim ahli kami siap membantu Anda merancang, membangun, dan mengimplementasikan solusi AI yang tepat guna mendorong inovasi dan pertumbuhan bisnis Anda. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat menjadi mitra strategis Anda dalam memanfaatkan kekuatan transformatif AI.
Tanggapan (0 )