Belajar Generative AI - Fine-Tuning & PEFT

#Pendahuluan

Hingga episode 11, semua aplikasi yang kalian bangun memakai model apa adanya — perilaku diatur lewat prompt, pengetahuan lewat RAG. Episode ini membuka jalur ketiga: mengubah model itu sendiri lewat fine-tuning. Kemampuan ini yang membedakan "memakai AI" dari "membangun solusi AI yang khas perusahaan".

Mengapa penting? Karena ada hal yang tidak bisa dicapai prompt maupun RAG: gaya output yang konsisten dan khas (nada perusahaan, format laporan), latensi & biaya rendah (model kecil yang sudah dilatih berperilaku seperti model besar), dan pengetahuan yang tertanam untuk akses offline. Namun fine-tuning juga termahal dan paling mudah disalahgunakan — jadi episode ini mengajarkan kapan tidak melakukannya.

#Kapan Fine-Tune, Kapan Prompt, Kapan RAG

Ini keputusan paling penting dan paling sering salah. Gunakan kerangka berikut:

Aturan emas: fine-tune adalah pilihan terakhir, bukan pertama. Mulai dengan prompt → tambah RAG → baru pikirkan fine-tune. Biaya fine-tune meliputi GPU, data, dan siklus evaluasi yang panjang — jika masalah bisa diselesaikan retrieval, jangan fine-tune.

#PEFT: LoRA & QLoRA

PEFT (Parameter-Efficient Fine-Tuning) mengubah hanya sebagian kecil parameter model. Dua teknik utamanya:

• LoRA (Low-Rank Adaptation): alih-alih mengupdate semua bobot, sisipkan matriks kecil (low-rank) yang dilatih sementara bobot asli dibekukan. Hasilnya hanya ~0.1-1% parameter yang berubah — muat di satu GPU.
• QLoRA: versi LoRA yang bekerja di atas model terkuantisasi (4-bit), sehingga model 7-13B bisa di-fine-tune di GPU konsumen (8-16GB).

Mengapa ini penting? Karena fine-tune penuh (full fine-tuning) model 70B butuh puluhan GPU; dengan LoRA/QLoRA, hasil yang sebanding bisa dicapai di satu GPU. Pada 2026, PEFT adalah cara default menyesuaikan model open-weight.

pip install transformers datasets peft bitsandbytes accelerate

#Siapkan Dataset: Format Instruction

Fine-tuning modern (SFT, supervised fine-tuning) memakai dataset berbentuk instruction-response. Kualitas dataset menentukan segalanya — dataset jelek malah merusak model.

[
  {"instruction": "Ringkas memo berikut",
   "input": "Rapat Q3: keputusan migrasi database ke Postgres, target selesai Desember...",
   "output": "Migrasi database ke Postgres ditargetkan selesai Desember."},
  {"instruction": "Tulis balasan email singkat",
   "input": "Pelanggan komplain pengiriman telat 3 hari",
   "output": "Mohon maaf atas keterlambatan. Kami kirim ulang hari ini dengan resi berikut."},
  {"instruction": "Klasifikasi tiket",
   "input": "Tidak bisa login setelah update",
   "output": "KATEGORI: account; URGENSI: high"}
]

Aturan dataset: minimal ratusan–ribuan contoh, format konsisten, dan sesuai dengan pola yang akan dihadapi di produksi — model hanya bisa meniru apa yang dilihatnya.

#Praktik: QLoRA Fine-Tune dengan Unsloth/TRL

Untuk produksi, tool seperti Unsloth dan TRL (Transformers Reinforcement Learning) memangkas kerumitan. Contoh dengan TRL + QLoRA:

from datasets import load_dataset
from peft import LoraConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTTrainer, DataCollatorForCompletionOnly
 
model_id = "Qwen/Qwen2.5-3B-Instruct"          # model open-weight kecil
tokenizer = AutoTokenizer.from_pretrained(model_id)
 
lora = LoraConfig(
    r=16,                    # rank matriks adaptor
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)
 
trainer = SFTTrainer(
    model=model_id,
    args=TrainingArguments(output_dir="ft-qwen", per_device_train_batch_size=1,
                           gradient_accumulation_steps=4, num_train_epochs=1),
    train_dataset=load_dataset("json", data_files="dataset.json")["train"],
    peft_config=lora,
    dataset_text_field="prompt",                # kolom dengan instruksi+output
)
trainer.train()

Catatan penting dari kode ini:

• r=16: rank LoRA — trade-off kapasitas vs ukuran file (16 cukup untuk banyak domain).
• Batch kecil + gradient accumulation: meniru batch besar dengan memori terbatas.
• 1 epoch cukup: fine-tuning overfit sangat cepat; lebih banyak epoch bukan lebih baik.

Setelah training, simpan adaptor (bukan model penuh) dan gabungkan saat inferensi:

from peft import PeftModel
 
trainer.model.save_pretrained("ft-qwen-adaptor")
# gabungkan ke model asal saat dipakai
base = AutoModelForCausalLM.from_pretrained(model_id)
model = PeftModel.from_pretrained(base, "ft-qwen-adaptor")

Adaptor LoRA biasanya hanya ratusan MB — beda jauh dengan full model puluhan GB. Inilah mengapa LoRA cocok disimpan, di-version, dan di-deploy dengan mudah.

#RLHF & DPO: Meluruskan Perilaku

SFT mengajarkan model meniru, tapi tidak memilih respons terbaik. RLHF (Reinforcement Learning from Human Feedback) dan turunannya DPO (Direct Preference Optimization) melatih model dengan preferensi: pasangan respons (dipilih vs ditolak) dari manusia/LLM judge.

• RLHF: membangun reward model dari preferensi, lalu optimasi dengan PPO — kompleks dan sensitif.
• DPO: menghindari reward model; langsung mengoptimasi kebijakan terhadap data preferensi — jauh lebih stabil dan murah.

[
  {
    "prompt": "Jelaskan cara reset password",
    "chosen": "Buka halaman akun, pilih 'Lupa kata sandi'...",
    "rejected": "Reset password itu rumit, mungkin harus beli paket premium."
  }
]

Kapan memakai DPO? Saat kalian punya data preferensi (feedback pengguna, evaluasi) dan ingin model cenderung memilih respons yang disukai. Framework seperti TRL mendukungnya dengan DPOTrainer — tetapi untuk sebagian besar aplikasi, SFT saja sudah cukup; DPO menambah kompleksitas.

#Common Pitfalls

• Fine-tune untuk menambahkan pengetahuan — itulah pekerjaan RAG; fine-tune tidak bisa diandalkan untuk fakta yang berubah.
• Dataset tidak mewakili produksi — model terlatih baik di data latih tapi gagal di pola nyata.
• Epoch terlalu banyak → catastrophic forgetting: model melupakan kemampuan umumnya.
• Tidak ada evaluasi sebelum/sesudah — tanpa golden set (episode 4), tidak tahu apakah fine-tune membantu atau merusak.

#Penutup

Inti yang harus dibawa pulang:

• Urutan keputusan: prompt → RAG → fine-tune — jangan lompat.
• LoRA/QLoRA = PEFT yang hemat GPU; adaptor kecil, model asli dibekukan.
• Dataset instruction-response yang representatif menentukan kualitas.
• RLHF/DPO untuk perilaku/preferensi; SFT cukup untuk kebanyakan kasus.

Di episode 13 selanjutnya kita akan membahas Self-Hosted LLM & Ollama/vLLM — menjalankan model open-weight di infrastruktur sendiri: Ollama untuk lokal, vLLM untuk produksi, quantization (GGUF/AWQ), kebutuhan GPU, dan integrasi ke aplikasi. Sampai jumpa di episode 13!