Belajar Deep Learning - Optimisasi Inference: Quantization & Pruning

#Pendahuluan

Sejauh ini kita berfokus membuat model akurat. Tapi akurasi bukan segalanya: di produksi, model dijalankan jutaan kali, pada perangkat dari data center sampai smartphone, dengan batasan biaya dan latency yang keras. Episode ini membahas sisi efisiensi — bagaimana menjalankan model seakurat mungkin dengan resource sekecil mungkin.

Keterampilan ini semakin penting seiring tren 2025-2026: model besar dijalankan di laptop dan mobile, inference menjadi mayoritas biaya AI enterprise, dan quantization menjadi pembeda antara model yang "bisa" vs yang "layak produksi". Ini juga jembatan menuju episode 20 tentang deployment.

#Quantization: Angka yang Lebih Kecil

#Prinsip Dasar

Model dilatih dalam FP32 (32-bit per bobot). Quantization menyimpan bobot dalam presisi lebih rendah — FP16, INT8, atau bahkan 4-bit — sehingga:

• Memori berkurang: FP16 = setengahnya FP32; INT8 = seperempatnya.
• Latency turun: operasi INT8 bisa diakselerasi hardware (tensor cores, NPU).
• Power hemat: penting untuk mobile/edge.

Trade-offnya adalah sedikit penurunan akurasi. Seni quantization adalah meminimalkan kerugian itu.

#Tingkatan Presisi

#Jenis Quantization

PTQ (Post-Training Quantization) — tanpa training ulang:

• Kalibrasi rentang bobot/aktivasi dari beberapa batch data.
• Cepat dan mudah, tapi loss akurasi bisa terasa untuk model kecil.

QAT (Quantization-Aware Training) — quantization disimulasikan selama training:

• Model belajar menoleransi error pembulatan.
• Hasil jauh lebih baik untuk INT8, tapi butuh training ulang.

Aturan praktis: model besar dan overparameterized toleran terhadap PTQ; model kecil dan tugas sensitif butuh QAT.

#Format LLM: GGUF, AWQ, GPTQ

Untuk LLM, format quantization sangat penting karena menentukan runtime yang bisa memakainya:

• GGUF: format 4-bit dari llama.cpp, jalan di CPU dan GPU dengan memori minimal. Standar untuk model lokal di laptop/mobile.
• GPTQ: 4-bit berbasis kuantisasi per-kolom, optimal untuk GPU dengan memori terbatas (inference cepat, satu GPU).
• AWQ (Activation-aware Weight Quantization): memilih saluran penting berdasarkan pola aktivasi; mempertahankan akurasi lebih baik daripada GPTQ pada beban yang sama.

huggingface-cli download Qwen/Qwen2.5-1.5B-Instruct-GGUF \
    --local-dir ./qwen-gguf --include "qwen2.5-1.5b-instruct-q4_k_m.gguf"

File GGUF bisa langsung dijalankan llama.cpp:

./llama-cli -m ./qwen-gguf/qwen2.5-1.5b-instruct-q4_k_m.gguf -p "Halo, siapa kamu?"

#Pruning: Membuang Bobot Tidak Penting

Pruning menghapus bobot yang hampir nol (tidak berkontribusi) dari jaringan. Setelah pruning, matriks menjadi sparse, dan dengan hardware/runtime yang mendukung, ukuran dan latency turun. Dua pendekatan:

• Unstructured pruning: hapus bobot individual di mana pun — sparse tapi tidak selalu mempercepat tanpa runtime khusus.
• Structured pruning: hapus seluruh saluran/head — benar-benar mengecilkan matriks dan mempercepat, tapi butuh fine-tuning agar akurat.

Pruning + quantization sering digabung dan dapat memangkas model hingga 90% tanpa kehilangan akurasi signifikan (dengan fine-tune).

#Distillation: Mengajarkan Model Kecil

Knowledge distillation melatih student kecil meniru teacher besar — bukan dari label, tapi dari distribusi output teacher (soft logits). Student belajar "keyakinan" teacher, bukan sekadar jawaban benar.

Hasilnya: model kecil dengan akurasi mengejutkan, jauh lebih baik daripada melatih model kecil dari nol. Ini cara industri membuat model edge (misal MobileNet versi distilled). Konsep yang sama dipakai mengompresi LLM besar menjadi model kecil yang menjalankan tugas tertentu.

#Praktik: ONNX Runtime dan TFLite

#ONNX Runtime

ONNX (Open Neural Network Exchange) adalah format pertukaran model lintas framework. ONNX Runtime mengoptimasi eksekusi di banyak hardware:

Export & run ONNX

import torch
import onnxruntime as ort
 
model.eval()
torch.onnx.export(model, dummy_input, "model.onnx",
                  input_names=["input"], output_names=["output"],
                  dynamic_axes={"input": {0: "batch"}})
 
session = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])
result = session.run(None, {"input": batch_numpy})

dynamic_axes mengizinkan variasi ukuran batch. ONNX Runtime bisa memakai TensorRT/CUDA provider di GPU — kombinasi quantization + provider sering memberi percepatan 2-5x.

#TFLite untuk Mobile

Untuk Android/iOS, TensorFlow Lite adalah jalur utama. Model dikonversi dengan quantization INT8 dan post-training optimization:

Konversi ke TFLite

import tensorflow as tf
 
converter = tf.lite.TFLiteConverter.from_saved_model("model_saved")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
 
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

TFLite mendukung GPU delegate dan NPU di perangkat — menjadikan model berjalan real-time di smartphone.

#Common Pitfalls

• Quantize setelah fine-tune, bukan sebelumnya: quantization merusak bobot halus; lakukan terakhir.
• Kalibrasi dengan data representatif: PTQ memakai data untuk menentukan rentang; data kalibrasi yang tidak mewakili distribusi nyata merusak akurasi.
• Menakar akurasi di dataset yang sama dengan kalibrasi: optimis palsu. Pakai eval set terpisah.
• Pruning tanpa fine-tune: model sparse langsung pakai sering ambruk akurasinya.
• Bandingkan ukuran, lupa latency: ukuran file tidak selalu sebanding dengan kecepatan — ukur latency dan throughput di hardware target.

#Penutup

Pada episode 19 ini, kalian telah menguasai optimisasi inference.

Inti yang harus dibawa pulang:

• Quantization FP16/INT8/4-bit memangkas memori dan latency dengan loss kecil.
• PTQ cepat tapi bisa kehilangan akurasi; QAT melatih dengan toleransi error pembulatan.
• GGUF untuk CPU/edge; GPTQ/AWQ untuk GPU terbatas; pilih dengan bijak.
• Pruning membuang bobot tak penting; distillation mengajar model kecil dari model besar.
• ONNX Runtime dan TFLite menghadirkan model ke produksi dan mobile.

Di episode 20 selanjutnya kita akan menyebarkan model: deployment & serving — TorchServe, vLLM untuk LLM, Triton Inference Server, Docker, plus monitoring drift, latency, dan throughput dengan OpenTelemetry. Sampai jumpa di episode 20!