LLM Quantization: INT4, INT8, GGUF ve Bellek Düşürme 2026

LLM quantization, büyük dil modellerinin ağırlıklarını FP16/BF16 yerine INT8, INT4 hatta INT2 gibi düşük bit derinliklerine indirgeyerek bellek tüketimini %50-87 oranında azaltan ve çıkarım hızını 2-4 katına çıkaran bir sıkıştırma tekniğidir. 2026 itibarıyla Llama 3.1 70B modelini FP16’da çalıştırmak yaklaşık 140 GB VRAM gerektirirken, GGUF Q4_K_M kuantizasyonu aynı modeli ~40 GB’a sığdırıyor; bu sayede tek bir RTX 4090 (24 GB) + 32 GB sistem RAM kombinasyonunda offload ile evde dahi servis edilebiliyor. Bu yazıda INT4, INT8, GGUF, AWQ, GPTQ ve SmoothQuant gibi tekniklerin nasıl çalıştığını, hangi senaryoda hangi formatın seçilmesi gerektiğini, doğruluk kaybı (perplexity drift) ile bellek kazanımı arasındaki dengeyi ve 2026 üretim ortamında dağıtım stratejilerini incelliyoruz.

Karar çerçevesi şu: bir 7B model production API’da düşük latency istiyorsanız AWQ INT4 + vLLM, edge/laptop’ta CPU çalıştıracaksanız GGUF Q4_K_M + llama.cpp, batch inference’ta maksimum throughput için FP8 + TensorRT-LLM seçilir. Hugging Face’in 2025 sonu indirme istatistiklerine göre toplam LLM indirmelerinin %63’ü kuantize edilmiş varyantlar üzerinden gerçekleşiyor; bu oran 2023’te yalnızca %18’di. Kuantizasyon artık opsiyon değil, üretim hattının zorunlu bir adımı.

Quantization Nedir, Neden Bu Kadar Önemli?

Bir LLM ağırlığı varsayılan olarak FP16 (16-bit floating point) ya da BF16 formatında saklanır. Her parametre 2 byte yer kaplar. 70 milyar parametreli bir model bu durumda 140 GB ham ağırlık dosyası demektir; KV-cache, aktivasyonlar ve workspace ile birlikte servis için 160-180 GB VRAM gerekir. Bu kapasiteyi karşılayan donanım (H100 80GB x2, A100 80GB x2) saat başı bulut maliyetinde $5-8 aralığındadır.

Quantization, bu ağırlıkları daha az bitle temsil ederek bellek ayak izini doğrudan düşürür. Tipik kazanımlar şöyledir:

• FP16 → INT8: %50 bellek azalması, ~1.5-2x throughput artışı, perplexity drift < %1.
• FP16 → INT4 (AWQ/GPTQ): %75 bellek azalması, ~2-3x throughput artışı, perplexity drift %1-3.
• FP16 → INT2 (1.58-bit BitNet): %87.5 bellek azalması, perplexity drift %5-10, hâlâ deneysel.
• FP16 → FP8 (E4M3/E5M2): %50 bellek, H100/RTX 4090 tensor core hızlandırma, perplexity drift < %0.5.

NVIDIA’nın TensorRT-LLM dokümantasyonunda yayınlanan benchmark’larda Llama 3 8B modelinde FP16 baseline’a karşı INT4 AWQ %2.7 perplexity artışına karşılık 2.3x token/saniye kazanımı sağlıyor. Bu, donanım maliyetinin yarıya inmesi ve aynı GPU’da daha fazla eşzamanlı kullanıcıya hizmet verilebilmesi anlamına geliyor.

Kavramsal olarak quantization, FP16 sayı uzayını (yaklaşık ±65504 dinamik aralık) çok daha dar bir tamsayı aralığına (INT8: -128 ile 127, INT4: -8 ile 7) sıkıştırır. Bu süreçte iki temel parametre belirlenir: scale (ölçek) ve zero-point (sıfır noktası). Her ağırlık grubu (genelde 64 veya 128’lik bloklar) için bu iki değer ayrıca saklanır; buna “group-wise quantization” denir ve doğruluk kaybını ciddi şekilde azaltır.

INT8 vs INT4 vs FP8: Hangi Hassasiyet, Hangi Senaryoda?

Bit derinliği seçimi, kullanım senaryosu ve donanıma göre değişir. Aşağıdaki tablo 2026 itibarıyla geçerli pratik tercih matrisidir.

Format	Bellek Azalması	Tipik Perplexity Drift	Donanım	Önerilen Kullanım
FP16 (baseline)	0%	0%	A100, H100, RTX 4090	Fine-tuning, araştırma
BF16	0%	~0%	A100, H100, TPU v5	Eğitim, geniş dinamik aralık
FP8 (E4M3)	~50%	<0.5%	H100, H200, RTX 5090	Production inference, batch
INT8 (SmoothQuant)	~50%	0.5-1.5%	A100, T4, L4, A10G	Server inference, eski Ampere GPU
INT4 (AWQ)	~75%	1.5-2.5%	RTX 4090, L40S, T4	Düşük VRAM, real-time chat
INT4 (GPTQ)	~75%	2-3%	RTX 3090/4090, A6000	Genel amaçlı INT4 deployment
GGUF Q4_K_M	~70%	2-4%	CPU, Apple Silicon, GPU	Edge, laptop, hybrid offload
INT2 / 1.58-bit	~85-87%	5-10%	Deneysel	Araştırma, IoT prototip

Pratik seçim kuralı:

• FP8 — Ne zaman seç: H100 veya RTX 5090 var, production’da SLA < 200ms p95, doğruluk en az %99.5 baseline olsun. Avantaj: en az perplexity kaybı. Dezavantaj: eski GPU’larda native destek yok.
• INT8 — Ne zaman seç: A100/L4/T4 GPU, batch inference, doğruluk kritik. Avantaj: tensor core destekli, geniş donanım uyumu. Dezavantaj: bellek tasarrufu sadece %50.
• INT4 AWQ — Ne zaman seç: real-time chatbot, 24 GB VRAM ile 13B/34B model servis etmek. Avantaj: activation-aware, en iyi INT4 doğruluğu. Dezavantaj: calibration dataset gerekiyor.
• GGUF Q4_K_M — Ne zaman seç: CPU veya Apple Silicon, ya da consumer GPU’da partial offload. Avantaj: llama.cpp ile her platformda çalışır. Dezavantaj: vLLM/TensorRT desteklemez, throughput düşüktür.

GGUF Formatı ve Q-Family Varyantları Detayı

GGUF (GPT-Generated Unified Format), Georgi Gerganov tarafından geliştirilen llama.cpp projesinin native model formatıdır ve 2023 sonunda eski GGML formatının yerini almıştır. Tek dosyada metadata + tokenizer + ağırlıkları barındırır; mmap ile diskten doğrudan yüklenebilir, bu da soğuk başlatma süresini saniyeler mertebesine indirir. GitHub üzerinde llama.cpp projesi 2026 başı itibarıyla 70.000+ yıldız almış durumda.

GGUF içinde quantization tipleri Q-prefix ile adlandırılır. K-variant (“K-quants”) süperblok yapısı kullanır: 256 ağırlık 16’lık alt bloklara bölünür, her alt blok kendi scale ve min’ine sahiptir, süperblok seviyesinde de ortak scale tutulur. Bu çift kademeli yapı klasik linear quantization’a göre belirgin avantaj sağlar.

GGUF Quant	Bit/ağırlık (efektif)	Llama 3 8B Boyut	Llama 3 70B Boyut	Tipik Perplexity (Wikitext)	Tavsiye
F16 (baseline)	16.0	~16 GB	~140 GB	6.14	Referans
Q8_0	8.5	~8.5 GB	~75 GB	6.15	Neredeyse kayıpsız
Q6_K	6.6	~6.6 GB	~58 GB	6.18	Yüksek kalite
Q5_K_M	5.7	~5.7 GB	~50 GB	6.22	Dengeli
Q4_K_M	4.85	~4.9 GB	~42 GB	6.34	En popüler tercih
Q4_K_S	4.58	~4.6 GB	~40 GB	6.41	Dar VRAM
Q3_K_M	3.91	~3.9 GB	~34 GB	6.62	Sınırda kalite
Q2_K	2.96	~3.0 GB	~26 GB	7.10+	Çok küçük cihaz
IQ4_XS	4.25	~4.3 GB	~37 GB	6.36	importance-matrix tabanlı
IQ2_XXS	2.06	~2.1 GB	~18 GB	8.20+	Aşırı sıkıştırma, son çare

2025 sonrası yaygınlaşan IQ (importance-aware quants) varyantları, ağırlıkların “ne kadar önemli olduğunu” ölçen bir importance matrix kullanır; aynı bit bütçesinde Q varyantlarına göre ~%0.05-0.15 perplexity avantajı sağlar. Bunun bedeli: hesaplama bir miktar daha yavaştır ve GPU’da Q-quants’lara göre daha az optimize edilmiştir. CPU çıkarımında IQ4_XS gözde tercihtir; H100 üzerinde Q4_K_M genelde daha hızlı kalır.

Pratik karar şu basit eşik üzerinden alınır:

1. VRAM > 1.2 × FP16 boyut → FP16 / BF16 kullan.
2. VRAM 0.6-1.2 × FP16 boyut → Q8_0 veya Q6_K.
3. VRAM 0.35-0.6 × FP16 → Q5_K_M veya Q4_K_M (sweet spot).
4. VRAM < 0.35 × FP16 → Q3_K veya Q2_K (kalite belirgin düşer).

AWQ, GPTQ ve SmoothQuant: Algoritma Karşılaştırması

GPU-native deployment için üç dominant algoritma vardır. Hepsi farklı varsayımlardan yola çıkar.

GPTQ (Frantar ve ark., 2022, ICLR 2023): Layer-by-layer ikinci dereceden Hessian yaklaşımı kullanarak quantization hatasını minimize eder. Bir kalibrasyon setinde (128-512 örnek) modelin çıkışlarını ölçer, her katmanı tek tek kuantize ederken sonraki ağırlıkları telafi edici şekilde ayarlar. arXiv 2210.17323 numaralı orijinal makale 2024 sonu itibarıyla 1500+ atıf almış durumda.

AWQ (Lin ve ark., 2023, MLSys 2024): Tüm ağırlıkların eşit derecede önemli olmadığı gözlemine dayanır. Aktivasyonların büyüklüğüne göre %0.1-1 oranındaki “salient” ağırlıkları belirler ve onları kuantizasyondan korur (per-channel scaling ile). GPTQ’ya kıyasla genelde 0.1-0.5 puan daha düşük perplexity ve %20-30 daha hızlı inference verir; ayrıca kalibrasyon dataset’i bağımlılığı daha düşüktür.

SmoothQuant (Xiao ve ark., 2022): INT8-spesifik bir tekniktir. LLM aktivasyonlarındaki “outlier” sorununu çözmek için scaling factor’ı aktivasyondan ağırlıklara taşır; hem aktivasyon hem ağırlık INT8’e indirilebilir hale gelir. NVIDIA TensorRT-LLM ve Intel Neural Compressor varsayılan olarak SmoothQuant kullanır.

Algoritma	Hedef Bit	Kalibrasyon Gerekli mi?	Aktivasyon Quant	Tipik Perplexity Drift (Llama 7B, Wikitext)	Runtime Desteği
GPTQ	3/4/8 bit	Evet (128-512 örnek)	Hayır (sadece ağırlık)	+0.21 (4-bit)	vLLM, ExLlamaV2, TGI, AutoGPTQ
AWQ	3/4 bit	Evet (küçük set)	Hayır	+0.15 (4-bit)	vLLM, TensorRT-LLM, llm-awq
SmoothQuant	8 bit	Evet	Evet (W8A8)	+0.05 (8-bit)	TensorRT-LLM, OpenVINO, INC
SqueezeLLM	3/4 bit	Evet	Hayır	+0.18 (4-bit)	Araştırma, sınırlı
QuIP#	2 bit	Evet (uzun)	Hayır	+0.8 (2-bit)	Deneysel
HQQ (Half-Quadratic)	2/3/4/8 bit	Hayır (data-free)	Hayır	+0.24 (4-bit)	Hugging Face Transformers
bitsandbytes NF4	4 bit	Hayır (QLoRA için)	Hayır	+0.30 (4-bit)	Transformers, PEFT

Pratik akış: Bir modeli ilk kez kuantize edecekseniz AWQ ile başlayın — kalibrasyon süresi ~10-30 dakika (A100 üzerinde 7B model), kalite/hız oranı en iyisi. QLoRA fine-tuning yapacaksanız bitsandbytes NF4 tek pratik seçenektir; H100 + production batch için SmoothQuant W8A8 ya da FP8 kullanın. Detay için LLM özelleştirme karşılaştırmamızı inceleyebilirsiniz.

Bellek Bütçesi Hesaplama: Donanıma Göre Maksimum Model

VRAM bütçesi yalnızca ağırlıklardan ibaret değildir. Production hesabında üç kalem vardır:

• Ağırlık (weights): parametre sayısı × bit/8.
• KV-cache: 2 × katman sayısı × head sayısı × head_dim × seq_len × batch × bit/8. Çoğu 70B modelde 8K context için 10-25 GB.
• Aktivasyon + workspace: Genelde 2-5 GB sabit overhead.

Bir 70B model + 4K context + batch 8 için yaklaşık formül: weights + 12 GB KV + 3 GB overhead. Aşağıdaki tablo, popüler donanımlarda hangi modelin hangi kuantizasyonla sığdığını gösterir.

GPU / Donanım	Kullanılabilir VRAM	FP16 Max Model	INT8 Max Model	INT4 Max Model	GGUF Q4_K_M Max
RTX 3060 12GB	~11 GB	3B	7B (kıt)	13B	13B + offload 34B
RTX 4090 24GB	~22 GB	7B	13B	34B	34B + offload 70B
RTX 5090 32GB	~30 GB	13B	34B	70B (kıt)	70B
L4 24GB	~22 GB	7B	13B	34B	34B
L40S 48GB	~45 GB	13B	34B	70B	70B (rahat)
A100 40GB	~38 GB	13B	34B	70B (kıt)	70B
A100 80GB	~75 GB	34B	70B	120B (Mixtral 8×22)	120B
H100 80GB	~75 GB	34B	70B	120B	120B
H200 141GB	~135 GB	70B	120B	405B (Llama 3.1)	405B
Mac Studio M2 Ultra 192GB unified	~150 GB	70B (yavaş)	120B	405B	405B

2026 başında Apple Silicon (M2/M3/M4 Max & Ultra) GGUF dünyasında ciddi bir oyuncu haline geldi. Unified memory mimarisi sayesinde 192 GB RAM’in çoğunluğu modele tahsis edilebiliyor; M2 Ultra üzerinde Llama 3.1 405B Q4_K_M ~9-12 token/sn üretiyor. Sunucu rakipleri (H100) için bu sayı 50-80 t/s, ancak donanım maliyeti 30-50x daha yüksek.

Performance Benchmark: Throughput, Latency ve Kalite

Aşağıdaki benchmark, A100 80GB üzerinde Llama 3 8B modelinin farklı kuantizasyonlarla vLLM 0.6.x sunulması sonucu elde edilen değerlerin yaklaşık sentezidir (NVIDIA ve vLLM blog yazılarındaki public sayılarla uyumlu, batch=16, in=512, out=128 token).

Quantization	Model Boyutu	Throughput (tok/s)	p50 Latency (ms)	p95 Latency (ms)	MMLU Skoru	Wikitext PPL
FP16	16.1 GB	~3850	520	730	67.8	6.14
BF16	16.1 GB	~3820	525	735	67.7	6.14
FP8 (E4M3)	8.2 GB	~6900	295	410	67.5	6.16
INT8 SmoothQuant	8.1 GB	~6400	315	440	67.1	6.21
INT4 AWQ	5.4 GB	~9100	225	320	66.4	6.29
INT4 GPTQ	5.4 GB	~8200	250	355	66.0	6.35
NF4 (bitsandbytes)	5.6 GB	~2300	820	1140	66.1	6.44

Dikkat çekici noktalar:

• NF4 yavaştır çünkü bitsandbytes dequantize-on-the-fly mantığıyla çalışır; üretim servisi için değil, QLoRA eğitimi için tasarlanmıştır.
• FP8 throughput’u INT4’ten düşük ama latency p95’i daha stabildir; SLA önceliği olan API’larda FP8 daha tahmin edilebilir.
• MMLU kaybı INT4’te %1.4 civarı; bu çoğu kurumsal use-case için kabul edilebilir, RAG hatlarında neredeyse fark edilmez çünkü retrieval kalitesi bu farkı genelde domine eder.

Ek bir gerçek: H100 üzerinde FP8 native tensor core desteği sayesinde aynı modelin throughput’u A100’e göre yaklaşık 2.4x’e çıkar. RTX 5090 üzerinde FP8 desteği daha yeni eklenmiş olsa da consumer fiyat/performansı en yüksek değer noktasıdır.

Production Deployment: vLLM, TensorRT-LLM, llama.cpp Stack Seçimi

Kuantize modelinizi nereden servis edeceğiniz, formattan en az kuantizasyon tipi kadar önemlidir. Yanlış runtime, %75 bellek tasarrufunuzu %20’lik bir throughput kaybıyla geri alabilir.

Runtime	Desteklenen Quant Formatları	Donanım	Tipik Throughput Kazancı (FP16’ya göre)	Sweet Spot
vLLM	AWQ, GPTQ, FP8, INT8 (Marlin kernel), BitsAndBytes	NVIDIA (A100+, RTX 30/40/50), AMD MI300 (sınırlı)	2-4x	Çok kullanıcılı API, OpenAI-uyumlu endpoint
TensorRT-LLM	FP8, INT8 SmoothQuant, INT4 AWQ, KV-cache INT8	NVIDIA H100/H200/L40S/RTX 4090+	3-5x	En düşük latency, NVIDIA-only production
llama.cpp	GGUF (tüm Q ve IQ varyantları)	CPU, Apple Silicon, NVIDIA, AMD, Vulkan, Metal	1.5-3x (CPU’ya göre)	Edge, laptop, mobil, hybrid offload
SGLang	AWQ, FP8, INT8, GGUF (kısmi)	NVIDIA (A100+), AMD MI300	2-4x	Yapılandırılmış üretim, JSON-mode, agentic
TGI (HF Text Gen)	AWQ, GPTQ, EETQ, FP8 (kısmi)	NVIDIA, AMD, Inferentia	1.8-3x	Hugging Face ekosistemi, sagemaker
ExLlamaV2	EXL2 (kendi formatı), GPTQ	NVIDIA consumer (RTX 30/40/50)	2-3x	Single-user uzun context, RP/local chat
Ollama	GGUF (llama.cpp tabanlı)	CPU, Apple Silicon, NVIDIA	~llama.cpp ile aynı	Yerel geliştirme, demo, hobi

Karar matrisi:

1. OpenAI-uyumlu çok kullanıcılı API (RTX 4090/L40S/A100): vLLM + AWQ INT4. PagedAttention ile KV-cache fragmentasyonu yok, continuous batching throughput’u maksimize eder.
2. H100 80GB, p95 latency < 200ms: TensorRT-LLM + FP8 (KV-cache INT8). Engine build 15-40 dk sürer ve her config değişiminde rebuild gerekir.
3. M2 Max MacBook’ta lokal 70B test: llama.cpp + GGUF Q4_K_M, Metal hızlandırma + mlock.
4. Agentic akış, JSON çıktı garanti: SGLang + AWQ. Constrained decoding native, çoklu adım cache reuse vLLM’den iyi.
5. QLoRA fine-tune: bitsandbytes NF4 + PEFT + Transformers. Production öncesi AWQ/GPTQ ile yeniden kuantize et.

2026 Trendleri: FP4, Microscaling ve KV-Cache Quantization

Quantization alanı 2024-2026 arasında üç önemli evrim geçirdi.

1. NVIDIA Blackwell ve FP4 native desteği: Mart 2024’te tanıtılan B100/B200 GPU’lar FP4 (4-bit floating point, E2M1) tensor core desteğiyle geldi. INT4’ten farklı olarak FP4 dinamik aralığı korur; Blackwell üzerinde FP4 inference, H100 FP8’e göre ~2.5x throughput sunuyor. Yazılım ekosistemi (TensorRT-LLM 0.13+, vLLM nightly) henüz olgunlaşıyor.

2. Microscaling formats (MX-format) — OCP standardı: Open Compute Project tarafından 2023 sonunda standartlaştırılan MXFP8, MXFP6, MXFP4 formatları, 32’lik bloklar halinde paylaşılan E8M0 scale faktörü kullanır. AMD MI350 ve gelecek nesil donanımların temel formatı; ARM ve Intel de destekliyor.

3. KV-cache quantization: Uzun context (32K+) servis ederken KV-cache boyutu ağırlıklardan büyük olabilir. Llama 3 70B + 32K context + batch 8’de KV-cache ~80 GB tutar. KV-cache’i INT8 ya da FP8’e indirgemek bellek baskısını ~%50 azaltır ve perplexity’ye etkisi çok düşüktür (<0.5 puan).

• Avantaj: Uzun context’te 2x daha fazla eşzamanlı kullanıcı.
• Dezavantaj: Bazı modellerde (özellikle GQA-yoğun mimariler) ek 0.3-1 puan MMLU kaybı.
• Ne zaman seç: Document chat, code completion, agentic workflows gibi 8K+ context senaryolarında neredeyse her zaman.

Hugging Face’in 2025 raporuna göre 2024’te en çok indirilen 100 LLM’in 78’i kuantize sürümler; bu rakam 2023’te 31’di. Konuya kurumsal bağlamda yaklaşıyorsanız kurumsal yapay zeka entegrasyonu ve RAG altyapı kurulumu rehberlerimiz tamamlayıcı yol haritası sunar.

Doğruluk Kaybını Azaltma: Calibration, GS, Outlier Handling

Kuantizasyon kaynaklı perplexity artışını minimize etmek için 2026 pratiğinde dört kaldıraç kullanılır:

1. Kalibrasyon dataset seçimi: Modelin kullanım dağılımına yakın olmalı. Genel domain için C4/RedPajama’dan 128-512 örnek yeterli. Ömer Önal olarak verdiğimiz danışmanlık projelerinde, kalibrasyon setini ürün dokümantasyonu + gerçek müşteri sorularından kurmak domain doğruluğunu 2-4 puan iyileştiriyor.
2. Group size (GS): Küçük GS = az hata, çok bellek. Pratik: GS=128 sweet spot; 4-bit’te GS=64 ek doğruluk verir ama %3-5 bellek maliyetiyle.
3. Outlier protection: AWQ salient-weight, SmoothQuant aktivasyon yumuşatma, GPTQ act-order. 2026’da yeni standart mixed-precision: outlier kanallar FP16’da, geri kalan INT4’te.
4. Quantization-aware fine-tuning (QAT): Model ağırlıkları kuantize halde birkaç epoch eğitilir. Pahalıdır (LoRA ile düşer) ama 2-3 bit sıkıştırmalarda perplexity drift’i yarıya indirir.

Kuantize bir modelin doğruluğunu test ederken Wikitext-2 perplexity sadece başlangıç ölçütüdür. Gerçek değerlendirme için MMLU, GSM8K, HumanEval ve domain-spesifik eval set’lerini birlikte koşturmak gerekir; LLM hallucination azaltma yazımızda bu ölçütleri detaylı ele aldık.

Sıkça Sorulan Sorular (SSS)

Sonuç

LLM quantization 2026’da artık opsiyonel bir optimizasyon değil, üretim hattının zorunlu bir bileşenidir. Doğru format seçimi — INT4 AWQ, INT8 SmoothQuant, FP8, GGUF Q4_K_M — donanımınıza, latency SLA’nıza ve doğruluk toleransınıza göre yapılır. Sunucu tarafında NVIDIA Hopper/Blackwell GPU’nuz varsa FP8 + TensorRT-LLM en yüksek verimlilik, A100/L40S/RTX 4090 sınıfında AWQ INT4 + vLLM en iyi maliyet/performans, edge/laptop için GGUF Q4_K_M + llama.cpp tek pratik yoldur.

Karar verirken üç ölçüt birlikte değerlendirilmeli: bellek bütçesi (donanımdaki gerçek VRAM, KV-cache ve overhead dahil), kalite eşiği (MMLU/domain eval ile ölçülen kabul edilebilir kayıp) ve operasyonel maliyet (token başına maliyet, p95 latency, eşzamanlı kullanıcı kapasitesi). Çoğu kurumsal senaryoda AWQ INT4 + vLLM + KV-cache INT8 üçlüsü, FP16 baseline’a kıyasla 3-4x daha düşük maliyetle %98-99 kalite sunar; bu, hızla yaygınlaşan “default production stack” haline gelmiş durumda.

LLM dağıtım mimarinizde kuantizasyon stratejisini netleştirmek için iletişime geçebilir ya da agentic AI iş akışları rehberimizden devam edebilirsiniz. Derin kaynaklar: AWQ makalesi (arXiv 2306.00978), GPTQ makalesi (arXiv 2210.17323), llama.cpp GitHub deposu, NVIDIA TensorRT-LLM dokümantasyonu, vLLM dokümantasyonu, Hugging Face Quantization Overview ve OCP Microscaling Formats spesifikasyonu.