Belajar Deep Learning - Fine-Tuning LLM: PEFT & LoRA

#Pendahuluan

Di episode 15 kita fine-tune BERT kecil yang berjumlah ~67 juta parameter. Sekarang bayangkan model 7B atau 70B parameter: full fine-tuning berarti melatih ulang semua bobot — butuh GPU kelas data center, storage raksasa, dan waktu berhari-hari. Untuk mayoritas tim, itu tidak realistis.

Solusinya adalah PEFT (Parameter-Efficient Fine-Tuning): melatih sebagian kecil parameter sementara model utama dibekukan. Teknik paling populer di 2026 adalah LoRA, dan dengan kombinasi quantization (QLoRA), fine-tuning LLM bahkan bisa dilakukan di satu GPU consumer. Episode ini membuka akses ke keterampilan yang paling banyak dicari industri: menyesuaikan model bahasa besar dengan biaya masuk akal.

#Mengapa Full Fine-Tuning Mahal

Untuk model 7B parameter:

• Bobot FP32: 28 GB. AdamW menyimpan dua state momentum per parameter — total lebih dari 60 GB hanya untuk training.
• Gradien dan aktivasi menambah lebih banyak lagi.
• Satu checkpoint memakan puluhan GB; versi dengan beberapa checkpoint lebih boros lagi.

Hasilnya: full fine-tuning model 7B butuh 4-8 GPU A100 (80GB). QLoRA mencapai hasil sebanding dengan satu GPU 24GB.

#LoRA: Low-Rank Adaptation

#Ide Inti

LoRA berangkat dari observasi penting: saat fine-tuning, perubahan pada bobot cenderung berdimensi rendah — hanya sedikit arah yang benar-benar berubah. Alih-alih mengubah matriks bobot W (misal 4096x4096), LoRA menyisipkan dua matriks kecil A dan B yang hasil kalinya memperbarui bobot:

W_baru = W_asli + B * A

dengan B berdimensi (out, r) dan A berdimensi (r, in), dan rank r kecil (8-64). Karena r sangat kecil dibanding dimensi asli, jumlah parameter yang dilatih berkurang 99%+. Model asli dibekukan; hanya A dan B yang diperbarui.

#Keuntungan Praktis

• Hemat resource: hanya adapter (MB, bukan GB) yang di-training.
• Cepat: gradien dihitung untuk parameter kecil saja.
• Portabel: hasil fine-tuning adalah satu file adapter kecil yang bisa dibagikan dan digabung tanpa menyentuh model asli.
• Multi-task: satu model dasar, banyak adapter terpisah — ganti task cukup ganti file.

#QLoRA: LoRA + Quantization

QLoRA menambah satu langkah: model dasar di-quantize ke 4-bit agar muat di satu GPU, sementara adapter LoRA tetap dihitung dalam presisi penuh:

• Model 7B di 4-bit: ~4-5 GB (vs 28 GB FP32).
• Adapter LoRA dilatih dengan presisi penuh di atas representasi terkompresi.
• Dengan 4-bit + paged_optimizer, satu GPU 24GB cukup untuk fine-tune model 7B.

Loss kualitas hanya sedikit di atas full fine-tuning — trade-off yang sangat masuk akal untuk hampir semua tim.

#Praktik: Fine-Tune Model Open-Weight Kecil

Hugging Face PEFT + transformers membuat semuanya ringkas. Contoh: fine-tune Qwen2.5-0.5B atau Llama-3.2-1B untuk gaya percakapan:

Setup model 4-bit

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
 
quant = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="float16",
)
 
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct", quantization_config=quant)
model = prepare_model_for_kbit_training(model)
 
lora = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora)
model.print_trainable_parameters()

print_trainable_parameters() menunjukkan total parameter yang dilatih — biasanya di bawah 1%. Target modul (q_proj, dll.) adalah proyeksi attention dari episode 12: bobot inilah yang paling banyak berubah saat fine-tuning.

Training adapter

from transformers import Trainer, TrainingArguments
 
args = TrainingArguments(
    output_dir="./qwen-lora",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    num_train_epochs=3,
    logging_steps=50,
    bf16=True,
)
 
trainer = Trainer(model=model, args=args, train_dataset=ds, tokenizer=tokenizer)
trainer.train()

#Menguji dan Menggabungkan

Simpan & muat adapter

model.save_pretrained("./qwen-lora")
 
from peft import PeftModel
base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
model = PeftModel.from_pretrained(base, "./qwen-lora")

Adapter berukuran beberapa MB dan bisa disebar ke Hugging Face Hub. Untuk inference produksi, adapter sering di-merge ke model asli agar tidak ada overhead runtime.

#RLHF: Menyelaraskan Model

Setelah fine-tuning instruksi, langkah lanjutan adalah RLHF (Reinforcement Learning from Human Feedback): model dilatih meniru preferensi manusia. Tahapannya:

1. SFT: fine-tune pada data instruksi.
2. RM: latih reward model dari peringkat manusia terhadap jawaban.
3. RL: optimalkan model dengan PPO terhadap reward model.

Untuk tim kecil, DPO (Direct Preference Optimization) adalah alternatif yang jauh lebih sederhana — tidak butuh reward model terpisah, cukup data preferensi langsung. Episode 22 akan membahas RL dan reasoning model lebih dalam.

#Common Pitfalls

• Lupa prepare_model_for_kbit_training: tanpa ini, model 4-bit dan LoRA bekerja dengan presisi salah dan training tidak stabil.
• Batching terlalu besar: LLM memakan banyak memori; gunakan gradient accumulation (episode 13) daripada batch besar.
• Format prompt salah: selalu ikuti chat_template model.
• Salah memilih target_modules: model yang berbeda punya nama layer berbeda; untuk selain Qwen/LLaMA, cek model.named_parameters().
• Melatih terlalu lama: overfit pada fine-tuning LLM muncul sebagai repetisi templat. Pantau loss eval dan evaluasi kualitatif manual.

#Penutup

Pada episode 16 ini, kalian telah menguasai fine-tuning LLM yang efisien.

Inti yang harus dibawa pulang:

• Full fine-tuning 7B butuh resource data center; PEFT melatih sebagian kecil parameter.
• LoRA menyisipkan matriks rank-rendah; perubahan bobot diperkirakan berdimensi rendah.
• QLoRA (LoRA + 4-bit) memungkinkan fine-tune 7B di satu GPU 24GB.
• Adapter LoRA portabel dan bisa di-merge; multi-adapter untuk multi-task.
• RLHF/DPO menyelaraskan model dengan preferensi manusia; fine-tuning tidak menambah pengetahuan.

Di episode 17 selanjutnya kita akan membahas sisi gelapnya: AI security untuk model — OWASP GenAI LLM Top 10 2026, adversarial attacks, prompt injection, data poisoning, dan hardening dengan guardrails & red teaming. Sampai jumpa di episode 17!