Belajar ML Engineer - Model Optimization

#Pendahuluan

Setelah di episode 22 sistem serving kalian berjalan di Kubernetes, muncul satu pertanyaan yang menentukan biaya dan latensi: bisakah model ini dibuat lebih ringan? Model yang lebih kecil berarti: muat di lebih banyak hardware, lebih cepat merespons, dan jauh lebih murah per prediksi. Di dunia produksi 2026, model optimization bukan opsional — ia adalah lembah antara "model bekerja" dan "model menguntungkan".

Episode ini membangun tiga teknik inti: kuantisasi (mengurangi presisi angka), distillation (melatih model kecil meniru model besar), dan pruning (membuang bagian yang tidak berguna). Ketiganya berbagi satu prinsip yang tidak bisa ditawar: jangan pernah mengoptimalkan tanpa mengukur dampaknya — dan itu menuntun kembali ke disiplin evaluasi episode 7 dan 24.

#Kuantisasi: INT8, FP8, dan Lainnya

Kuantisasi mengurangi presisi numerik bobot dan aktivasi. Model dilatih di FP32 (atau BF16); saat inference, bobot bisa dipetakan ke presisi lebih rendah:

Pendekatan kuantisasi:

• PTQ (Post-Training Quantization): kuantisasi setelah training, tanpa retraining. Cepat, tapi ada penurunan kualitas.
• QAT (Quantization-Aware Training): melatih model dengan simulasi kuantisasi di dalam training, sehingga model "belajar" mentoleransi presisi rendah. Kualitas jauh lebih baik, biaya training naik.

from torch.ao.quantization import quantize_dynamic
 
# Dynamic quantization — sederhana, cocok untuk model klasik
quantized_model = quantize_dynamic(model, dtype=torch.qint8)
torch.save(quantized_model.state_dict(), "model_int8.pt")

Untuk LLM, kuantisasi umumnya terjadi saat load model dengan AWQ/GPTQ (4-bit) atau fp8 (yang didukung vLLM langsung):

vllm serve Qwen/Qwen2.5-7B-Instruct --quantization fp8

#Mengukur Dampak Kuantisasi

Rutinitas yang wajib dilakukan: evaluasi sebelum vs sesudah kuantisasi pada eval set yang sama, ukur metrik kualitas dan latency/throughput/memori. Model 4-bit yang turun 2% accuracy tapi 4x lebih murah sering kali merupakan keputusan bisnis yang tepat; model yang turun 10% jelas tidak.

for name, model in [("fp32", fp32_model), ("int8", int8_model)]:
    acc = evaluate(model, eval_set)
    lat = measure_latency(model)
    print(f"{name}: accuracy={acc:.3f}, p95={lat:.1f}ms")

#Distillation: Model Kecil yang Meniru Model Besar

Knowledge distillation melatih model kecil (student) untuk meniru output model besar (teacher). Alih-alih hanya belajar dari label, student belajar dari probabilitas teacher — yang jauh lebih informatif (misal teacher tahu "anjing" sedikit mirip "serigala").

Teacher (besar, akurat) ── soft labels ──► Student (kecil, murah)
                                              ↑
                                          true labels

Untuk LLM (distilasi juga disebut model compression), contoh populer: keluarga DistilBERT (mengompres BERT ~40% dengan mempertahankan 97% performa) dan Phi series yang dilatih dari data sintetis guru. Varian modern:

• Distilasi klasik: teacher memberi probabilitas (logits/soft labels).
• Distilasi LLM: teacher (misal GPT-4-class) menghasilkan data pelatihan berkualitas tinggi (misal reasoning chains) untuk melatih student kecil.

import torch.nn.functional as F
 
def distillation_loss(student_logits, teacher_logits, labels, alpha=0.5, T=2.0):
    soft = F.kl_div(
        F.log_softmax(student_logits / T, dim=1),
        F.softmax(teacher_logits / T, dim=1),
        reduction="batchmean",
    ) * (T**2)
    hard = F.cross_entropy(student_logits, labels)
    return alpha * soft + (1 - alpha) * hard

Temperatur T mengontrol "kelembutan" distribusi teacher; alpha menimbang pengaruh soft vs hard loss.

#Pruning: Membuang Bobot yang Tidak Berguna

Pruning menghapus sebagian bobot (atau neuron/heads) yang berkontribusi paling sedikit, sehingga model lebih kecil dan lebih cepat. Dua pendekatan:

• Magnitude pruning: buang bobot dengan nilai absolut terkecil — bobot kecil dianggap kurang penting.
• Structured pruning: buang unit utuh (channel, attention head) — hasilnya benar-benar mempercepat komputasi (tidak seperti sparse yang sering tetap lambat tanpa hardware khusus).

import torch
 
threshold = torch.quantile(torch.abs(model.weight), q=0.3)
mask = torch.abs(model.weight) > threshold
model.weight.data *= mask

Perhatikan kelemahan: pruning satu kali sering terlalu agresif. Iterative pruning — prune sedikit, fine-tune, ulangi — jauh lebih stabil.

#Menggabungkan Teknik: Alur Optimasi

Optimasi yang realistis menggabungkan teknik berurutan:

Tiap langkah menurunkan kualitas sedikit — oleh karena itu evaluasi di tiap langkah adalah kunci. Kalian perlu tahu persis kapan penurunan kualitas melewati batas yang bisa diterima.

#Common Pitfalls

#Penutup

Pada episode 23 ini, kalian telah menguasai optimasi model:

• Kuantisasi INT8/FP8/INT4 — pengurangan presisi untuk speed & memori; PTQ murah, QAT berkualitas.
• Distillation — student kecil meniru teacher besar lewat soft labels.
• Pruning — membuang bobot/unit yang tidak berguna, iterative + fine-tune.
• Evaluasi di tiap langkah — optimasi tanpa pengukuran hanyalah tebakan berbiaya.

Di episode 24 selanjutnya kita akan membahas Advanced Evaluation & Eval-Driven Development — LLM-as-judge, benchmark, regression suites, dan pipeline evaluasi yang menjadi gerbang utama sebelum model naik ke produksi. Sampai jumpa di episode 24!