Transformer dan Fine-Tuning Dasar
Pada sesi 6 mahasiswa sudah melihat bahwa representasi kata bisa dibuat lebih bermakna dengan embedding. Sesi 7 membawa mahasiswa ke tahap berikutnya, yaitu model transformer. Inilah keluarga model yang kemudian melahirkan BERT, GPT, dan banyak sistem NLP modern yang sekarang sering dipakai di industri dan riset.
Agar mudah dipahami, bayangkan begini. Pada pendekatan lama, model membaca kalimat seperti orang yang menatap satu kata demi satu kata tanpa benar-benar bisa menimbang semua hubungan sekaligus. Pada transformer, model mulai seperti pembaca yang bisa melirik ke banyak bagian kalimat pada saat yang sama untuk memahami siapa berhubungan dengan siapa, kata mana yang penting, dan konteks apa yang sedang dibicarakan.
Mengapa transformer menjadi langkah besar
Pada model klasik, kita banyak bergantung pada preprocessing dan fitur seperti BoW atau TF-IDF. Pendekatan itu tetap penting, tetapi ada keterbatasan. Model sulit menangkap urutan kata secara kaya, sulit memahami konteks panjang, dan sulit menangkap bahwa kata yang sama bisa bermakna berbeda tergantung kalimatnya.
Bayangkan ada mahasiswa membaca kalimat panjang sambil menutup hampir semua kata, lalu hanya menghitung kata yang muncul. Ia masih bisa menebak topik, tetapi belum tentu benar-benar paham. Transformer lebih mirip pembaca yang bisa melihat seluruh kalimat dan menimbang hubungan antarbagian. Karena itu pemahamannya biasanya lebih dalam.
Inilah alasan transformer banyak dipakai pada tugas klasifikasi, tanya jawab, ringkasan, terjemahan, hingga chatbot. Model ini tidak hanya menghitung kata, tetapi juga mencoba menangkap konteks dan hubungan antarkata secara lebih kaya.
Gagasan inti transformer secara sederhana
Kalimat dipecah menjadi token
Kalimat tidak langsung diproses sebagai blok utuh. Ia dipecah menjadi token agar model bisa membaca unit-unit kecil lebih teratur.
Setiap token diberi embedding
Token diubah menjadi vektor agar bisa dihitung secara matematis.
Attention menghitung fokus
Model menentukan token mana yang perlu lebih diperhatikan saat memahami token tertentu.
Representasi menjadi kontekstual
Kata yang sama bisa memiliki representasi berbeda tergantung kalimat tempat ia muncul.
Apa itu attention
Attention adalah cara model menentukan bagian mana dari kalimat yang perlu lebih diperhatikan saat memproses sebuah token. Kata “bank” pada kalimat “saya menabung di bank” tentu berbeda konteksnya dari “saya duduk di tepi bank sungai”. Dengan attention, model punya peluang lebih baik untuk membedakan konteks tersebut.
Intuisi sederhananya seperti ini. Saat dosen bertanya, “kata ini merujuk ke siapa?”, mahasiswa yang paham tidak hanya melihat satu kata, tetapi juga melihat kata-kata di sekitarnya. Attention bekerja dengan semangat yang mirip.
Istilah yang perlu dikenal
| Istilah | Makna sederhana | Catatan praktis |
|---|---|---|
| Token | Potongan teks yang dibaca model. | Bisa berupa kata, subword, atau simbol tertentu. |
| Tokenizer | Alat yang memecah teks menjadi token dan mengubahnya ke ID numerik. | Setiap model biasanya punya tokenizer sendiri. |
| Pretrained model | Model yang sudah belajar dari korpus besar sebelum dipakai ulang. | Membuat kita tidak perlu melatih dari nol. |
| Fine-tuning | Melatih ulang model pretrained pada tugas khusus yang kita inginkan. | Contohnya klasifikasi sentimen atau topik. |
| Max length | Batas panjang token yang dibaca model. | Kalimat terlalu panjang bisa dipotong. |
BERT, IndoBERT, dan model pretrained lain
BERT adalah salah satu model transformer paling terkenal untuk memahami teks. Ia banyak dipakai sebagai dasar untuk berbagai tugas NLP. Untuk konteks bahasa Indonesia, mahasiswa juga bisa memakai model seperti IndoBERT atau model multilingual yang mendukung bahasa Indonesia.
BERT
Cocok untuk memahami konsep model pretrained dan fine-tuning pada tugas klasifikasi.
IndoBERT
Lebih dekat dengan data bahasa Indonesia sehingga sering lebih relevan untuk tugas lokal.
Multilingual BERT
Praktis jika ingin mencoba banyak bahasa tanpa berganti keluarga model.
Praktikum 1: uji cepat model transformer dengan pipeline
Langkah awal yang paling ramah untuk mahasiswa adalah mencoba model pretrained dengan pipeline. Ini seperti mencoba mobil dalam mode otomatis terlebih dahulu sebelum membongkar mesinnya.
from transformers import pipeline
# contoh untuk klasifikasi sentimen bahasa Inggris
classifier = pipeline(
"sentiment-analysis",
model="distilbert-base-uncased-finetuned-sst-2-english"
)
contoh_teks = [
"This campus application is very helpful and easy to use.",
"The server is slow and login often fails."
]
hasil = classifier(contoh_teks)
for teks, pred in zip(contoh_teks, hasil):
print("Teks:", teks)
print("Prediksi:", pred)
print("-" * 50)Kode ini cocok untuk membuka wawasan bahwa model modern dapat langsung dipakai. Sesudah itu mahasiswa baru diajak ke proses fine-tuning agar paham bagaimana menyesuaikan model ke data sendiri.
Praktikum 2: menyiapkan dataset untuk fine-tuning
Pada tahap ini mahasiswa belajar bahwa fine-tuning tetap memerlukan dataset berlabel. Format sederhana yang umum dipakai adalah dua kolom, yaitu teks dan label.
import pandas as pd
from sklearn.model_selection import train_test_split
# contoh dataset kecil
data = {
"text": [
"Aplikasi kampus ini sangat membantu proses KRS",
"Server sering lambat saat jam sibuk",
"Menu akademik mudah dipahami mahasiswa baru",
"Login sering gagal dan membuat kesal",
"Fitur baru sangat bermanfaat untuk dosen",
"Tampilan aplikasi membingungkan dan lambat",
"Informasi jadwal kuliah mudah diakses",
"Sistem error saat unggah tugas"
],
"label": [1, 0, 1, 0, 1, 0, 1, 0]
}
df = pd.DataFrame(data)
train_df, test_df = train_test_split(
df,
test_size=0.25,
random_state=42,
stratify=df["label"]
)
print("Jumlah data train:", len(train_df))
print("Jumlah data test:", len(test_df))
print(train_df.head())Praktikum 3: tokenisasi dengan Hugging Face tokenizer
Tokenizer bertugas mengubah teks biasa menjadi ID token yang bisa dipahami model. Bagian ini penting karena mahasiswa sering mengira model langsung membaca string mentah begitu saja.
from transformers import AutoTokenizer
model_name = "indobenchmark/indobert-base-p1"
tokenizer = AutoTokenizer.from_pretrained(model_name)
contoh = "Aplikasi kampus ini sangat membantu mahasiswa."
encoding = tokenizer(
contoh,
padding="max_length",
truncation=True,
max_length=32
)
print("Token IDs:", encoding["input_ids"])
print("Attention mask:", encoding["attention_mask"])
print("Jumlah token:", len(encoding["input_ids"]))Attention mask digunakan untuk memberi tahu model bagian mana yang merupakan isi teks dan mana yang hanya padding.
Praktikum 4: ubah DataFrame menjadi Dataset Hugging Face
Supaya proses training lebih rapi, data biasanya diubah menjadi format Dataset. Ini membuat proses tokenisasi dan training lebih mudah dikelola.
from datasets import Dataset
train_dataset = Dataset.from_pandas(train_df.reset_index(drop=True))
test_dataset = Dataset.from_pandas(test_df.reset_index(drop=True))
def tokenize_batch(batch):
return tokenizer(
batch["text"],
padding="max_length",
truncation=True,
max_length=64
)
train_dataset = train_dataset.map(tokenize_batch, batched=True)
test_dataset = test_dataset.map(tokenize_batch, batched=True)
train_dataset = train_dataset.rename_column("label", "labels")
test_dataset = test_dataset.rename_column("label", "labels")
columns_to_return = ["input_ids", "attention_mask", "labels"]
train_dataset.set_format(type="torch", columns=columns_to_return)
test_dataset.set_format(type="torch", columns=columns_to_return)
print(train_dataset[0])Praktikum 5: fine-tuning model klasifikasi
Berikut contoh yang lebih lengkap menggunakan AutoModelForSequenceClassification dan Trainer. Walaupun terlihat lebih panjang daripada model klasik, alurnya tetap bisa dipahami langkah demi langkah.
import numpy as np
from transformers import AutoModelForSequenceClassification, TrainingArguments, Trainer
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
model = AutoModelForSequenceClassification.from_pretrained(
model_name,
num_labels=2
)
def compute_metrics(eval_pred):
logits, labels = eval_pred
preds = np.argmax(logits, axis=1)
precision, recall, f1, _ = precision_recall_fscore_support(
labels,
preds,
average="binary"
)
acc = accuracy_score(labels, preds)
return {
"accuracy": acc,
"precision": precision,
"recall": recall,
"f1": f1
}
training_args = TrainingArguments(
output_dir="./hasil_indobert",
eval_strategy="epoch",
save_strategy="epoch",
learning_rate=2e-5,
per_device_train_batch_size=8,
per_device_eval_batch_size=8,
num_train_epochs=3,
weight_decay=0.01,
logging_dir="./logs",
logging_steps=10,
load_best_model_at_end=True,
report_to="none"
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=test_dataset,
tokenizer=tokenizer,
compute_metrics=compute_metrics
)
trainer.train()
hasil_eval = trainer.evaluate()
print(hasil_eval)Mahasiswa tidak perlu takut pada panjang kode. Inti besarnya tetap sama seperti model klasik: siapkan data, ubah ke bentuk yang sesuai, latih model, lalu evaluasi.
Praktikum 6: prediksi pada teks baru
Setelah model selesai dilatih, mahasiswa perlu mencoba inferensi agar proses pembelajaran terasa utuh. Bagian ini sering membuat mahasiswa lebih yakin karena hasil model bisa langsung terlihat.
import torch
label_map = {0: "negatif", 1: "positif"}
teks_baru = [
"Aplikasi ini membantu saya melihat jadwal kuliah dengan cepat",
"Server sering error dan membuat login gagal"
]
inputs = tokenizer(
teks_baru,
padding=True,
truncation=True,
max_length=64,
return_tensors="pt"
)
model.eval()
with torch.no_grad():
outputs = model(**inputs)
pred_ids = torch.argmax(outputs.logits, dim=1).tolist()
for teks, pred_id in zip(teks_baru, pred_ids):
print("Teks:", teks)
print("Prediksi:", label_map[pred_id])
print("-" * 50)Praktikum 7: bandingkan model klasik dan transformer
Salah satu latihan yang sangat baik adalah membandingkan Logistic Regression berbasis TF-IDF dengan model transformer hasil fine-tuning. Tujuannya bukan mencari siapa yang selalu menang, tetapi agar mahasiswa belajar membaca konteks kekuatan masing-masing pendekatan.
# contoh kerangka perbandingan sederhana
hasil_ringkas = {
"Logistic Regression + TF-IDF": {
"accuracy": 0.84,
"f1": 0.83
},
"IndoBERT Fine-Tuning": {
"accuracy": 0.88,
"f1": 0.88
}
}
for nama_model, metrik in hasil_ringkas.items():
print(nama_model)
print("Accuracy:", metrik["accuracy"])
print("F1:", metrik["f1"])
print()Dari perbandingan seperti ini, mahasiswa dapat berdiskusi apakah peningkatan kinerja sebanding dengan kebutuhan komputasi yang lebih besar.
Studi kasus mini: analisis sentimen ulasan aplikasi kampus
Misalnya kampus ingin mengetahui apakah ulasan mahasiswa terhadap aplikasi akademik cenderung positif atau negatif. Pada sesi 4 mahasiswa bisa menyelesaikannya dengan TF-IDF dan model klasik. Pada sesi 7 mahasiswa mengulang tugas itu dengan model transformer. Dengan begitu mereka melihat sendiri apa perbedaan pendekatan lama dan pendekatan modern.
Tujuan kasus
Memprediksi sentimen ulasan mahasiswa terhadap aplikasi kampus.
Nilai pembelajaran
Mahasiswa memahami fine-tuning sebagai bentuk penyesuaian model pretrained ke domain lokal.
Luaran
Notebook klasifikasi sentimen berbasis transformer yang siap diuji pada teks baru.
Kesalahan umum mahasiswa pada sesi 7
Kesalahan pertama adalah mengira transformer selalu wajib tanpa melihat ukuran data dan biaya komputasi. Kesalahan kedua adalah memakai tokenizer yang tidak sesuai dengan model. Kesalahan ketiga adalah lupa bahwa label harus konsisten dan rapi. Kesalahan keempat adalah terlalu cepat puas pada satu hasil evaluasi tanpa membandingkan dengan baseline klasik. Kesalahan kelima adalah tidak memahami bahwa fine-tuning tetap memerlukan data berlabel yang baik.
Transformer memang kuat, tetapi bukan sulap. Data tetap penting, evaluasi tetap penting, dan baseline klasik tetap berguna sebagai pembanding yang jujur.
Diskusi Mahasiswa dengan Sistem LLM
Tanyakan materi yang masih terkait Pembelajaran Mesin untuk Teks dan AI Generatif.
Pembahasan dibatasi pada topik mata kuliah ini. Pertanyaan di luar tema akan ditolak secara otomatis.