Quantization Aware Training: Panduan untuk Meningkatkan Inferensi Lokal Gemma 4

Apa Itu Kuantisasi?

Kuantisasi adalah teknik kompresi model yang mengurangi presisi bobot model. 

Model bahasa besar biasanya disimpan dalam format presisi tinggi seperti BF16 atau FP16, yang menjaga kualitas namun membutuhkan memori signifikan. Kuantisasi mengonversi bobot tersebut ke format bit lebih rendah, seperti 8-bit atau 4-bit, sehingga model menggunakan lebih sedikit VRAM dan lebih mudah dijalankan secara lokal. Hugging Face mencatat bahwa kuantisasi 8-bit dapat kira-kira memangkas penggunaan memori hingga setengahnya, sementara kuantisasi 4-bit dapat menguranginya lebih jauh.

Konsekuensinya, presisi yang lebih rendah kadang dapat menurunkan kualitas keluaran, terutama jika model tidak dioptimalkan untuk kuantisasi. Sederhananya, BF16 dan FP16 biasanya memberi kualitas terbaik namun memakai lebih banyak memori; model 8-bit lebih kecil sambil umumnya menjaga kualitas kuat, dan model 4-bit jauh lebih kecil tetapi mungkin kehilangan sebagian akurasi atau stabilitas. 

Untuk inferensi lokal, trade-off ini sering sepadan karena memungkinkan model yang lebih besar berjalan di GPU konsumen alih-alih membutuhkan perangkat keras pusat data yang mahal.

Apa Itu Quantization Aware Training?

Quantization-Aware Training (QAT) adalah teknik pelatihan di mana model dilatih atau di-fine-tune sambil mensimulasikan perilaku presisi rendah. Ini membantu model tetap lebih stabil setelah dikuantisasi dan dapat meningkatkan kinerja inferensi lokal pada lebar bit rendah.

Apa yang Membedakan QAT?

Pendekatan yang umum, yaitu kuantisasi pascapelatihan (post-training), mengompresi model setelah selesai dilatih. Ini sederhana dan praktis, tetapi model mungkin kehilangan sebagian kualitas karena tidak dilatih untuk menangani bobot berpresisi rendah. 

Menurut dokumentasi Google AI Edge, kuantisasi pascapelatihan adalah langkah konversi yang dapat mengurangi ukuran model dan meningkatkan latensi, biasanya dengan sedikit kehilangan akurasi. Namun, kualitas akhir tetap dapat bergantung pada model dan tingkat kuantisasinya. 

Quantization-Aware Training, atau QAT, mengambil pendekatan berbeda. Alih-alih hanya mengkuantisasi setelah pelatihan, QAT mensimulasikan perilaku presisi rendah selama pelatihan atau fine-tuning. Ini membantu model belajar untuk tetap stabil saat nanti dikonversi ke format yang lebih kecil. QAT meminimalkan kehilangan kualitas ketika model dikompresi.

Itulah mengapa Gemma 4 QAT berguna untuk AI lokal. Model ini dibangun dengan mempertimbangkan kuantisasi, sehingga dapat mempertahankan lebih banyak kualitas asli model sambil menggunakan lebih sedikit memori. Bagi pengguna yang menjalankan model di GPU konsumen, ini dapat berarti stabilitas low-bit yang lebih baik, penggunaan VRAM yang lebih rendah, dan inferensi lokal yang lebih praktis.

Langkah 1: Instal Dependensi dan Build llama.cpp

Sebelum mengunduh model, kita perlu menyiapkan runtime lokal terlebih dahulu. Tutorial ini diuji pada mesin dengan GPU NVIDIA RTX 4090 dan 24 GB VRAM. Kita akan menggunakan llama.cpp sebagai runtime inferensi, GGUF sebagai format model, dan berkas model terkuantisasi UD-Q4_K_XL.

Konfigurasi yang diuji:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Format model: GGUF
• Kuantisasi: UD-Q4_K_XL

Kita akan membandingkan dua model Unsloth GGUF berikut:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Pertama, periksa apakah GPU Anda tersedia.

nvidia-smi

Selanjutnya, instal paket sistem yang diperlukan untuk membangun llama.cpp.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Klon repositori resmi llama.cpp.

git clone https://github.com/ggml-org/llama.cpp

Sekarang build llama.cpp dengan dukungan CUDA diaktifkan. Ini memungkinkan lapisan model berjalan di GPU alih-alih hanya di CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Kompilasi biner yang diperlukan.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

Setelah build selesai, biner utama yang akan kita gunakan adalah llama-server. Ini memungkinkan kita menjalankan model GGUF secara lokal dan mengekspos endpoint API yang kompatibel dengan OpenAI yang dapat kita kueri dengan curl. 

Langkah 2: Unduh Model Gemma 4 12B Non-QAT dan QAT 

Sekarang llama.cpp sudah siap, kita dapat mengunduh kedua varian model Gemma 4 12B dari Hugging Face. Kita akan mengunduh model instruction-tuned reguler dan versi QAT dalam format GGUF.

Pertama, instal Hugging Face Hub CLI dengan dukungan unduhan lebih cepat.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Aktifkan unduhan Xet berkinerja tinggi.

export HF_XET_HIGH_PERFORMANCE=1

Unduh model instruction Gemma 4 12B reguler dalam format GGUF.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Selanjutnya, unduh versi QAT menggunakan format kuantisasi yang sama.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Flag --include memastikan kita hanya mengunduh berkas yang diperlukan untuk tutorial ini, alih-alih menarik seluruh repositori. Di sini, kita mengunduh berkas model GGUF UD-Q4_K_XL dan berkas mmproj-BF16 yang digunakan oleh paket model. 

Setelah unduhan selesai, konfirmasikan bahwa kedua folder model ada.

ls models

Keluaran yang diharapkan:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

Pada titik ini, baik model non-QAT maupun QAT sudah tersedia secara lokal, dan kita dapat mulai menyajikannya dengan llama-server.

Langkah 3: Jalankan Model Non-QAT dengan llama-server

Kita akan mulai dengan menjalankan model instruction Gemma 4 12B reguler. Ini memberi kita baseline sehingga nanti dapat dibandingkan dengan versi QAT menggunakan pengaturan yang sama.

Mulai model non-QAT dengan llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Ini akan memulai server lokal yang kompatibel dengan OpenAI di http://localhost:8001.

Buka terminal lain dan kirim permintaan ke server lokal.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

Dalam perintah ini, kita menggunakan endpoint lokal /v1/chat/completions yang mengikuti format API kompatibel OpenAI. Prompt meminta model menjelaskan quantization-aware training, dan max_tokens disetel ke 512 untuk memastikan kedua varian model diuji dengan panjang keluaran yang sama. 

Dalam pengujian RTX 4090 kami, model non-QAT menghasilkan hasil waktu berikut:

• Token prompt: 40
• Token completion: 512
• Kecepatan prompt: 510,22 token/detik
• Kecepatan generasi: 94,65 token/detik
• Total waktu: 5,516 detik

Penggunaan memori GPU adalah:

9247 MiB / 24564 MiB

Ini memberi kita performa baseline untuk model Gemma 4 12B reguler. Pada langkah berikutnya, kita akan menjalankan versi QAT dengan konfigurasi yang sama dan membandingkan hasilnya.

Langkah 4: Jalankan dan Uji Model QAT

Sekarang kita akan menjalankan versi QAT dari Gemma 4 12B menggunakan pengaturan llama-server yang sama. Pastikan menghentikan server non-QAT sebelumnya sebelum memulai yang ini, karena kedua perintah menggunakan port yang sama.

Mulai model QAT.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Ini menjalankan model QAT pada endpoint lokal yang kompatibel dengan OpenAI yang sama, http://localhost:8001.

Sekarang kirim prompt uji yang sama ke model QAT.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

Dalam pengujian RTX 4090 kami, model QAT menghasilkan hasil waktu berikut:

1. Token prompt: 40
2. Token completion: 512
3. Kecepatan prompt: 593,93 token/detik
4. Kecepatan generasi: 101,65 token/detik
5. Total waktu: 5,114 detik

Penggunaan memori GPU adalah:

8627 MiB / 24564 MiB

Anda juga dapat menyalin URL server lokal (http://localhost:8001) dan menempelkannya ke browser:

Ini membuka antarmuka web bawaan llama.cpp, yang memberi Anda antarmuka mirip ChatGPT sederhana untuk menguji model lokal. Anda dapat menggunakannya untuk mengobrol langsung dengan model QAT di browser, bereksperimen dengan prompt, dan menggunakan model sebagai asisten AI lokal harian. 

Bandingkan Hasil QAT vs Non-QAT

Setelah menguji kedua model dengan prompt dan pengaturan server yang sama, kita dapat langsung membandingkan performanya pada RTX 4090.

Dalam pengujian ini, model QAT lebih cepat dan lebih ringan daripada model non-QAT reguler. Model QAT menggunakan 620 MiB VRAM lebih sedikit, mengurangi penggunaan memori sekitar 6,7%. Ini berguna untuk inferensi lokal karena setiap penghematan VRAM membantu saat menjalankan model besar di GPU konsumen.

Model QAT juga menghasilkan token lebih cepat, meningkat dari 94,65 token/detik menjadi 101,65 token/detik. Itu sekitar kenaikan 7,4% dalam kecepatan generasi, memangkas waktu dari 5,516 detik menjadi 5,114 detik.

Dalam penggunaan sehari-hari, model QAT terasa lebih mulus dan responsif. Kualitas respons juga tampak lebih stabil dalam pengujian ini, yang merupakan alasan utama QAT berguna: QAT membantu model menangani kuantisasi low-bit dengan kehilangan kualitas yang lebih kecil sambil tetap mempertahankan manfaat memori dan kecepatan dari model terkompresi.

Pemikiran Akhir

Google melakukan pekerjaan luar biasa bagi komunitas AI lokal. Dengan model seperti Gemma 4 dan teknik seperti QAT, impian menjalankan model AI yang kuat secara lokal, sepenuhnya offline, bahkan di perangkat keras konsumen, menjadi kenyataan. 

Bagian paling menarik adalah ini bukan sekadar soal mengecilkan ukuran model. Dengan QAT, kita tidak sekadar berkompromi pada kualitas agar model muat. Kita mendapatkan model yang dirancang untuk berjalan lebih baik dalam format low-bit, meningkatkan pengalaman AI lokal secara keseluruhan. Dalam pengujian ini, model QAT lebih cepat, lebih ringan, dan lebih mulus digunakan daripada versi non-QAT.

Saya kini menantikan untuk menguji versi MTP dari model ini, yang bisa meningkatkan kecepatan lebih jauh, mungkin hingga 2x. Itu akan membuat jauh lebih mudah untuk memindahkan lebih banyak alur kerja saya ke AI lokal. Saya bisa menjalankan model secara lokal, menghubungkannya dengan alat seperti OpenCode, dan mulai mengedit berkas proyek langsung dengan asisten lokal privat.

Gelombang baru AI lokal ini mengubah cara kita memikirkan penggunaan sistem AI. Tugas yang dulu membutuhkan penyiapan cloud besar, terutama alur kerja multimodal dengan masukan teks, gambar, dan video, perlahan menjadi mungkin di mesin lokal. Bagi pengembang, peneliti, dan pembuat yang peduli pada privasi, kecepatan, dan kendali, ini adalah arah yang sangat menarik.