İleri · ~2 dk okuma #quantization #compression #inference

Quantization

Niceleme — Model Sıkıştırma

Modelin ağırlıklarını daha düşük hassasiyetle (FP16 → INT8 → INT4) saklama tekniği. Boyut + bellek + maliyet düşer, az miktarda doğruluk kaybı olur.

Tanım

Bir model eğitildiğinde ağırlıklar genelde FP32 (32-bit floating-point) olarak saklanır. Quantization, bu sayıları daha az bit ile temsil eder: FP16, INT8, INT4. Her ağırlık 32 bit yerine 4 bit alır = 8× daha az bellek.

Yöntem türleri: - PTQ (Post-Training Quantization): eğitim bittikten sonra ağırlıkları küçült. Hızlı ama biraz doğruluk kaybı. - QAT (Quantization-Aware Training): eğitim sırasında modelin düşük hassasiyete uyum sağlamasını öğret. Daha iyi doğruluk, daha pahalı eğitim. - GPTQ, AWQ, GGUF: pratikte kullanılan algoritmalar/formatlar.

Sonuç: 70B Llama bir tüketici GPU'sunda (24 GB VRAM) çalışabilir hale gelir. Ya da telefonda 7B model çalıştırabilirsin. Ortalama doğruluk kaybı INT8'de %1-2, INT4'te %3-5 — kabul edilebilir.

Benzetme

Bir resmi 24-bit renkten 8-bit'e düşürmek gibi. 16M renk yerine 256 renk. Resim hâlâ tanınır, sadece detaylarda hafif bir kayıp var. Quantization da öyle: ağırlıkların hassasiyeti azalır ama model "görüntüsü" çoğunlukla korunur.

Gerçek dünyadan örnek

Llama-3-70B'i kendi laptop'ında çalıştırmak istiyorsun. FP16'da 140 GB VRAM gerekir — imkansız. Çözüm:

1. llama.cpp ile model GGUF formatına çevir, Q4_K_M (4-bit) quantize et: dosya 140 GB → 40 GB. 2. M2 Max MacBook'ta 36 GB unified memory ile çalışır. 3. Inference hızı: ~12 token/saniye (insan okumaya yakın). 4. Doğruluk kaybı: %3-4, çoğu görev için fark edilmez.

2023'ten önce 70B model evde imkansızdı; bugün quantization sayesinde standart pratik. Hugging Face'de her popüler modelin GGUF/AWQ versiyonu hazır.

Format ailesi karşılaştırması (70B model için):

- FP32 — 280 GB, eğitim default'u, inference'ta gereksiz - FP16 / BF16 — 140 GB, inference baseline - FP8 — 70 GB, H100+ donanımı gerek, %1-2 doğruluk kaybı - INT8 — 70 GB, daha geniş donanım desteği - AWQ (4-bit) — 35 GB, vLLM/HF tercih, doğruluk korur - GPTQ (4-bit) — 35 GB, AWQ'ya alternatif - GGUF Q8_0 — 70 GB, llama.cpp standardı, neredeyse FP16 - GGUF Q5_K_M — 44 GB, çok iyi kalite, dengeli - GGUF Q4_K_M — 35 GB, ★ önerilen tatlı nokta - GGUF Q3_K_M — 26 GB, küçük ama kabul edilebilir - GGUF Q2_K / IQ2_XS — 18 GB, sadece deneme

Ekosistem ayrımı: vLLM + HF = AWQ, GPTQ, FP8. llama.cpp + Ollama + LM Studio = GGUF (Q-formatları). MLX = kendi 4bit/8bit varyantı. Format taşınmaz; aynı modelin doğru varyantını çek.

Bir adım daha derine

Kod örnekleri

                                            GGUF · llama.cpp ile quantize et
                                            bash
                                        
# 1. HF safetensors → GGUF FP16
python3 convert_hf_to_gguf.py \
  /path/to/Llama-3.1-8B-Instruct \
  --outfile model-f16.gguf

# 2. FP16 → Q4_K_M (en yaygın)
./build/bin/llama-quantize \
  model-f16.gguf model-Q4_K_M.gguf Q4_K_M

# Boyut farkı:
# f16 = 16.0 GB
# Q8_0 = 8.5 GB  (~%1 doğruluk kaybı)
# Q5_K_M = 5.7 GB (~%2)
# Q4_K_M = 4.6 GB  (~%3-4) ★
# Q3_K_M = 3.8 GB  (~%5-7)
# Q2_K  = 3.0 GB   (sadece test)

                                            AWQ · vLLM ile canlıya yükle
                                            python
                                        
# casperhansen/llama-3-70b-instruct-awq → 35 GB
# Tek A100 80GB'a sığar (FP16 olsaydı 2× A100 gerekirdi)

from vllm import LLM, SamplingParams

llm = LLM(
    model="casperhansen/llama-3-70b-instruct-awq",
    quantization="awq",
    tensor_parallel_size=1,
    max_model_len=8192,
    gpu_memory_utilization=0.90,
)

params = SamplingParams(temperature=0.3, max_tokens=512)
out = llm.generate(["Selam!"], params)
print(out[0].outputs[0].text)

                                            Bitsandbytes · 4-bit fly-tüne yükleme (HF Transformers)
                                            python
                                        
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4",        # NormalFloat-4
    bnb_4bit_use_double_quant=True,   # ek %0.4 tasarruf
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-70B-Instruct",
    quantization_config=bnb,
    device_map="auto",
)
# 70B FP16: 140 GB → NF4: ~35 GB
# QLoRA fine-tune için altyapı bu

Ne zaman kullan

Sınırlı VRAM/GPU bütçesiyle büyük model çalıştırmak
Edge deployment (telefon, embedded device, browser)
Inference maliyetini düşürmek (cloud GPU saati pahalı)
Aynı GPU'da daha fazla concurrent kullanıcı sığdırmak

Ne zaman kullanma

Hassas alanlarda (tıbbi tanı, finansal analiz) — küçük doğruluk kaybı maliyetli olabilir
Eğitim için — quantization inference içindir, training için değil
Model çok küçükse (~1-3B) — overhead, kazanca değmez
Edge case'lerde (uzun bağlam, multilingual) — quantize edilmiş modeller bazı görevlerde belirgin düşer

Sık yapılan hatalar

Doğruluk kaybını ölçmek zor

Genel benchmark'lar (MMLU, HumanEval) az düşüş gösterir ama senin spesifik kullanım senaryon farklı düşebilir. Mutlaka kendi eval setinde test et.

Tüm katmanları aynı quantize etmemek

Mixed precision: bazı katmanlar (attention output) FP16, diğerleri INT4. AWQ, GPTQ bunu otomatik yapar. Naive 'her şeyi INT4'le' kötü sonuç verir.

Format/araç uyumsuzluğu

GGUF (llama.cpp), GPTQ (Hugging Face), AWQ, EXL2 — farklı framework'ler farklı format kullanır. Üretim ortamına geçmeden önce hangi servis hangi formatı destekliyor kontrol et.