Lo download model Llama, Mistral, atau Qwen. Di halaman Hugging Face ada puluhan file: .gguf, .awq, .gptq, .exl2, .safetensors. Lo bingung milih yang mana.
Gue juga dulu gitu.
Masalahnya: salah pilih format = buang resource. Format yang salah bikin GPU lo nganggur, CPU lo overload, atau model lo gak bisa jalan sama sekali.
Di artikel ini gue breakdown empat format utama - cara kerjanya, kenapa mereka ada, dan gimana milih sesuai hardware lo.
Kenapa Banyak Format?
Jawaban singkatnya: karena gak ada satu hardware yang cocok buat semua orang.
Ada yang punya GPU NVIDIA 24GB. Ada yang cuma pake laptop tanpa GPU. Ada yang jalanin inference di production dengan ribuan request per detik. Masing-masing butuh pendekatan berbeda - dan tiap format lahir dari kebutuhan yang beda itu.
Tapi inti masalahnya sama: model LLM itu gede. Model 13B parameter dalam FP16 aja butuh ~26GB - gak muat di kebanyakan GPU consumer. Makanya perlu quantization - proses mengecilkan ukuran model dengan mengurangi presisi angka.
Nah, cara mengecilkannya ini yang beda antar format. Dan perbedaan cara inilah yang bikin mereka punya karakteristik sendiri-sendiri.
1. GGUF - Si Serba Bisa (CPU+GPU Hybrid)
Cara Pakenya
GGUF adalah format paling populer buat jalanin LLM di perangkat lokal. Dipake sama Ollama, LM Studio, llama.cpp, KoboldCPP - semua tool yang lo pake buat chatting sama model di laptop sendiri.
# Pake Ollama - paling simpel
ollama run llama3.2:7b-q4_K_M
# Atau lewat llama.cpp langsung
./main -m model.q4_K_M.gguf -n 256 --temp 0.7
Kenapa Bisa Jalan di CPU?
Ini kunci bedanya GGUF dari format lain. GGUF pake llama.cpp engine yang ditulis dari awal dalam C++ dengan optimasi SIMD (AVX2, NEON, AMX) - jadi operasi matriks bisa jalan efisien di CPU tanpa GPU sama sekali.
Tapi kalo lo punya GPU, lo bisa offload sebagian layer ke GPU pake flag --ngl (number of GPU layers):
# 20 layer pertama diproses GPU, sisanya CPU
./main -m model.gguf -ngl 20
Makin banyak layer di GPU, makin cepet. Tapi kalo VRAM lo terbatas, lo bisa atur balance-nya.
Kenapa Banyak Varian (Q4_K_M, Q5_K_M, Q8_0…)?
GGUF pake block-wise quantization. Artinya: bobot model dipecah jadi blok-blok kecil, dan tiap blok dikompresi dengan skala offset sendiri. Ukuran blok beda-beda tergantung tipe quantization: Q4_0 pake 32 parameter per blok, sementara K-quants (Q4_K_M, Q5_K_M, dll) pake super-block 256 parameter yang dibagi lagi jadi sub-blok 16-32 - ini yang bikin K-quants lebih akurat.
- Q8_0 = 8-bit per parameter. Hampir gak ada loss akurasi. Ukuran ~13GB buat model 13B.
- Q4_K_M = 4-bit dengan优化的 mid-range. Ukuran ~8.5GB - cocok buat GPU 8-12GB.
- Q2_K = 2-bit. Kecil banget tapi akurasi turun. Buat yang RAM/VRAM-nya super terbatas.
Yang bikin GGUF flexible: lo bisa milih sendiri trade-off antara ukuran dan akurasi.
Kapan Pake GGUF
- Lo cuma punya CPU (laptop kantor, MacBook, server tanpa GPU)
- Lo punya GPU tapi VRAM terbatas (4-8GB)
- Lo pake Ollama/LM Studio buat daily driver
- Lo butuh format yang portabel - satu file, jalan di mana aja
2. AWQ - Activation-Aware Weight Quantization
Cara Pakenya
AWQ beda pendekatan. Ini format yang didesain khusus buat GPU, dan biasanya jalan lewat vLLM atau TGI (Text Generation Inference):
# Pake vLLM
python -m vllm.entrypoints.openai.api_server \
--model TheBloke/Llama-2-13B-AWQ \
--quantization awq
Atau kalo mau tes langsung:
from awq import AutoAWQForCausalLM
model = AutoAWQForCausalLM.from_quantized("model-awq")
Kenapa Lebih Akurat dari Quantization Biasa?
Ini yang bikin AWQ menarik. Gak semua bobot di model LLM itu pentingnya sama. Ada channel-channel tertentu - yang gue sebut salient channels - yang punya pengaruh lebih besar ke output model.
AWQ Deteksi channel-channel penting ini dengan ngelihat aktivasi (activation distribution): channel mana yang paling sering “aktif” dengan nilai besar. Channel-channel ini dijaga presisinya (tetep FP16), sementara channel lainnya dikuantisasi 4-bit.
Hasilnya: kompresi ~3.5x dari FP16, tapi akurasinya nyaris setara. Dalam benchmark, AWQ 4-bit hampir selalu outperform quantization 4-bit naif di metrik perplexity.
Kenapa Gak Bisa di CPU?
Karena AWQ pake kernel CUDA yang dioptimasi - operasi matriksnya jalan lewat TensorRT-LLM atau custom CUDA kernels. CPU gak punya akses ke ini. Kalo lo coba jalanin AWQ di CPU, bakal lemot banget karena fallback ke operasi float biasa.
Kapan Pake AWQ
- Lo punya GPU dengan VRAM 8GB+
- Lo butuh inference production (vLLM, TGI)
- Lo prioritasin akurasi setinggi mungkin di 4-bit
- Lo gak masalah sama dependency CUDA
3. GPTQ - Senior yang Masih Dipake
Cara Pakenya
GPTQ adalah salah satu metode quantization pertama yang populer buat LLM. Biasanya jalan lewat AutoGPTQ atau vLLM:
from auto_gptq import AutoGPTQForCausalLM
model = AutoGPTQForCausalLM.from_quantized(
"model-gptq",
use_triton=False
)
Kenapa Metodenya Berbeda?
Kalo AWQ pake aktivasi, GPTQ pake second-order information (Hessian matrix). Intinya: pas mau nge-quantize satu bobot, GPTQ ngitung gimana cara kompensasi error-nya dengan nyesuain bobot lain yang belum di-quantize.
Prosesnya sequential: GPTQ nge-quantize bobot satu per satu, dan tiap kali ngitung ulang sisa bobot buat “menambal” error yang baru dibuat. Ini mirip kayak Optimal Brain Quantizer (OBQ) - pendekatan yang butuh kalibrasi dataset (biasanya ~128 sample).
Hasilnya: akurasi yang sangat bagus di 4-bit, tapi proses quantization-nya lama (bisa berjam-jam buat model 30B+).
Kapan Pake GPTQ
- Lo udah punya infrastruktur vLLM/TGI yang support GPTQ
- Lo punya GPU mid-to-high end (12GB+)
- Trade-off: loading lebih lambat dari AWQ, tapi inference speed-nya setara
4. EXL2 - Si Kenceng Buat GPU Gaming
Cara Pakenya
EXL2 format spesifik buat ExLlamaV2 - inference engine yang ditulis khusus buat GPU consumer:
python exllamav2/test_inference.py \
-m model_exl2 \
-p "Kenapa format LLM banyak?"
Atau lewat UI kayak TabbyAPI atau SillyTavern.
Kenapa Paling Cepat?
ExLlamaV2 punya beberapa optimasi yang bikin inference-nya lebih kenceng dari vLLM di GPU consumer:
- Fused Attention - operasi attention digabung jadi satu kernel CUDA, ngurangin memory bandwidth
- Quantization Dinamis - EXL2 bisa pake bit rate yang beda buat tiap layer. Layer penting (attention) dapet bit lebih tinggi, layer lain dapet bit lebih rendah. Ini ngasih fleksibilitas yang gak ada di format lain
- Batched Inference via Flash Attention - support batching dengan kernel teroptimasi
Hasil benchmark: EXL2 4-bit bisa mencapai ~150% kecepatan FP16 di GPU yang sama - karena quantization ngurangin jumlah data yang dipindah, dan kernel-nya lebih efisien.
Tapi EXL2 cuma jalan di GPU CUDA. Gak ada fallback CPU. Kalo GPU lo gak cukup VRAM, model gak bisa jalan.
Kapan Pake EXL2
- Lo punya RTX 3090/4090 atau GPU gaming high-end
- Lo prioritasin kecepatan di atas segalanya
- Lo pake ExLlamaV2 / TabbyAPI / SillyTavern
- Lo mau tuning bit rate per layer
Tabel Perbandingan Cepat
| Format | Jalan di CPU? | Jalan di GPU? | Kecepatan (vs FP16) | Ukuran Model 13B | Engine Utama |
|---|---|---|---|---|---|
| GGUF | ✅ Ya (native) | ✅ Hybrid | ~70% | ~8,5 GB (Q4) | llama.cpp, Ollama |
| AWQ | ❌ | ✅ CUDA | ~110% | ~7,5 GB | vLLM, TGI |
| GPTQ | ❌ | ✅ CUDA | ~100% | ~7,8 GB | vLLM, AutoGPTQ |
| EXL2 | ❌ | ✅ CUDA | ~150% | ~5-12 GB* | ExLlamaV2 |
*EXL2 ukuran tergantung bit rate per layer - bisa diatur
Cara Milih - Dijamin Gak Salah
Kalo lo punya laptop biasa / Mac / server tanpa GPU:
→ GGUF Q4_K_M. Pake Ollama. Selesai.
Kalo lo punya GPU 8-12GB (RTX 3060/4060, laptop GPU):
→ GGUF Q4_K_M atau EXL2 4-bit. Coba dua-duanya, liat mana yang lebih cepet.
Kalo lo punya GPU 24GB (RTX 3090/4090):
→ EXL2 buat kecepatan maksimal. Atau AWQ kalo perlu production-grade inference.
Kalo lo production API (vLLM/TGI):
→ AWQ. Loading cepet, batch inference stabil, akurasi tinggi.
Kalo lo masih pake GGML:
→ Migrasi ke GGUF. GGML udah deprecated sejak 2023. Gak dapet update, gak support model baru.
Yang Penting Diingat
Format quantization itu alat, bukan tujuan. GGUF bukan “lebih baik” dari AWQ - mereka beda ranah. GGUF dirancang buat fleksibilitas hardware (CPU/GPU hybrid). AWQ/EXL2 dirancang buat performa GPU murni.
Pilih berdasarkan hardware yang lo punya sekarang, bukan yang lo rencanain punya tahun depan. Model yang jalan 10 token/detik di laptop lo lebih berguna daripada model yang gak bisa jalan sama sekali.
Terima kasih udah meluangkan waktu buat baca, semoga ada manfaat yang bisa diambil buat milih format model berikutnya. 🐾
Referensi:
- llama.cpp GitHub - GGUF spec & quantization types
- AWQ Paper (arxiv 2306.00978) - Activation-Aware Weight Quantization
- GPTQ Paper (arxiv 2210.17323) - Post-training quantization
- ExLlamaV2 GitHub - EXL2 format & benchmark
- AutoAWQ GitHub - implementasi AWQ