Kantizasyona Duyarlı Eğitim: Gemma 4'ün Yerel Çıkarımını İyileştirmeye Yönelik Bir Kılavuz

Kantizasyon Nedir?

Kantizasyon, model ağırlıklarının hassasiyetini düşüren bir model sıkıştırma tekniğidir. 

Büyük dil modelleri genellikle kaliteyi koruyan ancak önemli miktarda bellek gerektiren BF16 veya FP16 gibi yüksek hassasiyetli formatlarda depolanır. Kantizasyon, bu ağırlıkları 8 bit veya 4 bit gibi daha düşük bitli formatlara dönüştürür; böylece model daha az VRAM kullanır ve yerelde daha kolay çalışır. Hugging Face, 8 bit kantizasyonun bellek kullanımını kabaca yarıya indirebileceğini, 4 bit kantizasyonun ise bunu daha da azaltabileceğini belirtir.

Taviz şudur: Daha düşük hassasiyet bazen çıktı kalitesini düşürebilir, özellikle de model kantizasyona göre optimize edilmemişse. Basitçe söylemek gerekirse, BF16 ve FP16 genellikle en iyi kaliteyi sunar ancak daha fazla bellek kullanır; 8 bit modeller daha küçüktür ve genellikle güçlü kaliteyi korur; 4 bit modeller çok daha küçüktür ancak bir miktar doğruluk veya kararlılık kaybı yaşayabilir. 

Yerel çıkarım için bu ödün çoğu zaman değerdir; çünkü pahalı veri merkezi donanımı gerektirmek yerine daha büyük modellerin tüketici GPU’larında çalıştırılmasına olanak tanır.

Kantizasyona Duyarlı Eğitim Nedir?

Kantizasyona Duyarlı Eğitim (QAT), modelin düşük hassasiyetli davranış simülasyonu altında eğitildiği veya ince ayarlandığı bir eğitim tekniğini ifade eder. Bu, modelin kantizasyondan sonra daha kararlı kalmasına yardımcı olur ve düşük bit genişliklerinde yerel çıkarım performansını iyileştirebilir.

QAT’i Farklı Kılan Nedir?

Alışıldık yaklaşım olan eğitim sonrası kantizasyon, bir modeli eğitildikten sonra sıkıştırır. Bu basit ve pratiktir; ancak model, düşük hassasiyetli ağırlıklarla başa çıkacak şekilde eğitilmediği için bir miktar kalite kaybedebilir. 

Google AI Edge dokümantasyonuna göre eğitim sonrası kantizasyon, genellikle çok az doğruluk kaybıyla model boyutunu azaltabilen ve gecikmeyi iyileştirebilen bir dönüştürme adımıdır. Ancak nihai kalite yine de modele ve kantizasyon düzeyine bağlı olabilir. 

Kantizasyona Duyarlı Eğitim, yani QAT, farklı bir yaklaşım benir. Yalnızca eğitimden sonra kantize etmek yerine, QAT eğitim veya ince ayar sırasında düşük hassasiyetli davranışı simüle eder. Bu, modelin daha sonra daha küçük bir formata dönüştürüldüğünde nasıl kararlı kalacağını öğrenmesine yardımcı olur. Model sıkıştırıldığında kalite kaybını en aza indirir.

Bu nedenle Gemma 4 QAT, yerel yapay zekâ için kullanışlıdır. Kantizasyon düşünülerek tasarlanmıştır; böylece daha az bellek kullanırken orijinal model kalitesinin daha fazlasını koruyabilir. Modelleri tüketici GPU’larında çalıştıran kullanıcılar için bu, daha iyi düşük bit kararlılığı, daha düşük VRAM kullanımı ve daha pratik bir yerel çıkarım anlamına gelebilir.

Adım 1: Bağımlılıkları Yükleyin ve llama.cpp’yi Derleyin

Modelleri indirmeden önce yerel çalışma zamanını hazırlamamız gerekiyor. Bu eğitim, NVIDIA RTX 4090 GPU ve 24 GB VRAM’e sahip bir makinede test edilmiştir. Çıkarım çalışma zamanı olarak llama.cpp’yi, model formatı olarak GGUF’yi ve UD-Q4_K_XL kantize model dosyalarını kullanacağız.

Test edilen kurulum:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Çalışma zamanı: llama.cpp
• Model formatı: GGUF
• Kantizasyon: UD-Q4_K_XL

Aşağıdaki iki Unsloth GGUF modelini karşılaştıracağız:

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

Önce, GPU’nuzun kullanılabilir olduğunu kontrol edin.

nvidia-smi

Sonra, llama.cpp’yi derlemek için gereken sistem paketlerini yükleyin.

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

Resmî llama.cpp deposunu klonlayın.

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

Şimdi llama.cpp’yi CUDA desteği etkin olacak şekilde derleyin. Bu, model katmanlarının yalnızca CPU yerine GPU üzerinde çalışmasına olanak tanır.

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

Gerekli ikilileri derleyin.

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

Derleme tamamlandıktan sonra kullanacağımız ana ikili llama-server olacaktır. Bu, GGUF modelini yerelde çalıştırmamıza ve curl ile sorgulayabileceğimiz OpenAI uyumlu bir API uç noktası sunmamıza imkân verir. 

Adım 2: Gemma 4 12B QAT Olmayan ve QAT Modellerini İndirin 

Artık llama.cpp hazır olduğuna göre, her iki Gemma 4 12B model varyantını da Hugging Face’ten indirebiliriz. GGUF formatında normal talimatla ince ayarlı modeli ve QAT sürümünü indireceğiz.

Önce, daha hızlı indirme desteğiyle Hugging Face Hub CLI’yi yükleyin.

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

Yüksek performanslı Xet indirmelerini etkinleştirin.

export HF_XET_HIGH_PERFORMANCE=1

GGUF formatında normal Gemma 4 12B talimat modelini indirin.

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

Ardından, aynı kantizasyon formatını kullanarak QAT sürümünü indirin.

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*"

--include bayrakları, tüm depoyu çekmek yerine yalnızca bu eğitim için gereken dosyaları indirdiğimizden emin olur. Burada, UD-Q4_K_XL GGUF model dosyalarını ve model paketi tarafından kullanılan mmproj-BF16 dosyalarını indiriyoruz. 

İndirmeler bittikten sonra her iki model klasörünün de mevcut olduğunu doğrulayın.

ls models

Beklenen çıktı:

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

Bu noktada hem QAT olmayan hem de QAT modelleri yerelde kullanılabilir durumdadır ve bunları llama-server ile sunmaya başlayabiliriz.

Adım 3: QAT Olmayan Modeli llama-server ile Çalıştırın

Önce normal Gemma 4 12B talimat modelini çalıştıracağız. Böylece daha sonra aynı ayarlarla QAT sürümüyle karşılaştırabileceğimiz bir başlangıç seviyesi elde ederiz.

QAT olmayan modeli llama-server ile başlatın.

./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

Bu, http://localhost:8001 adresinde yerel bir OpenAI uyumlu sunucu başlatır.

Başka bir terminal açın ve yerel sunucuya bir istek gönderin.

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
}'

Bu komutta, OpenAI uyumlu API formatını izleyen yerel /v1/chat/completions uç noktasını kullanıyoruz. İstem, modelden kantizasyona duyarlı eğitimi açıklamasını istiyor ve max_tokens her iki model varyantının da aynı çıktı uzunluğunda test edilmesini sağlamak için 512 olarak ayarlanmıştır. 

RTX 4090 testimizde, QAT olmayan model şu zamanlama sonuçlarını üretti:

• İstem (prompt) belirteçleri: 40
• Tamamlama belirteçleri: 512
• İstem hızı: 510.22 belirteç/sn
• Üretim hızı: 94.65 belirteç/sn
• Toplam süre: 5.516 sn

GPU bellek kullanımı:

9247 MiB / 24564 MiB

Bu, normal Gemma 4 12B modeli için temel performansı verir. Bir sonraki adımda, aynı yapılandırmayla QAT sürümünü çalıştıracak ve sonuçları karşılaştıracağız.

Adım 4: QAT Modelini Çalıştırın ve Test Edin

Şimdi Gemma 4 12B’nin QAT sürümünü aynı llama-server ayarlarıyla çalıştıracağız. Her iki komut da aynı bağlantı noktasını kullandığı için, bunu başlatmadan önce önceki QAT olmayan sunucuyu durdurduğunuzdan emin olun.

QAT modelini başlatın.

./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

Bu, QAT modelini aynı yerel OpenAI uyumlu uç noktada, http://localhost:8001 üzerinde başlatır.

Şimdi aynı test istemini QAT modeline gönderin.

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
}'

RTX 4090 testimizde, QAT modeli aşağıdaki zamanlama sonuçlarını üretti:

1. İstem (prompt) belirteçleri: 40
2. Tamamlama belirteçleri: 512
3. İstem hızı: 593.93 belirteç/sn
4. Üretim hızı: 101.65 belirteç/sn
5. Toplam süre: 5.114 sn

GPU bellek kullanımı:

8627 MiB / 24564 MiB

Yerel sunucu URL’sini (http://localhost:8001) kopyalayıp tarayıcınıza da yapıştırabilirsiniz:

Bu, yerleşik llama.cpp web arayüzünü açar ve yerel modeli test etmek için size basit, ChatGPT benzeri bir arayüz sunar. Bunu kullanarak doğrudan tarayıcıda QAT modeliyle sohbet edebilir, istemlerle deney yapabilir ve modeli günlük yerel bir yapay zekâ asistanı olarak kullanabilirsiniz. 

QAT ve QAT Olmayan Sonuçları Karşılaştırın

Her iki modeli de aynı istem ve sunucu ayarlarıyla test ettikten sonra, bunların RTX 4090 üzerindeki performanslarını doğrudan karşılaştırabiliriz.

Bu çalıştırmada QAT modeli, normal QAT olmayan modelden hem daha hızlı hem de daha hafifti. 620 MiB daha az VRAM kullandı ve bellek kullanımını yaklaşık %6,7 oranında azalttı. Bu, yerel çıkarım için faydalıdır; çünkü büyük modelleri tüketici GPU’larında çalıştırırken tasarruf edilen her VRAM önemli fark yaratır.

QAT modeli ayrıca belirteçleri daha hızlı üretti; 94.65 belirteç/sn’den 101.65 belirteç/sn’ye yükseldi. Bu, üretim hızında yaklaşık %7,4 artış anlamına gelir ve duvar saati süresini 5,516 saniyeden 5,114 saniyeye düşürür.

Günlük kullanımda QAT modeli daha akıcı ve daha tepkisel hissettirdi. Bu testte yanıt kalitesi de daha istikrarlı görünüyordu; bu da QAT’in asıl faydasını açıklar: Modelin, düşük bit kantizasyonunu daha az kalite kaybıyla kaldırmasına yardımcı olurken, sıkıştırılmış bir modelin bellek ve hız avantajlarını korur.

Son Düşünceler

Google, yerel yapay zekâ topluluğu için harika işler yapıyor. Gemma 4 gibi modeller ve QAT gibi tekniklerle, güçlü yapay zekâ modellerini tamamen çevrimdışı ve hatta tüketici donanımı üzerinde yerelde çalıştırma hayali gerçeğe dönüşüyor. 

En heyecan verici olan şu ki bu yalnızca model boyutunu küçültmekle ilgili değil. QAT ile modeli sığdırmak için kaliteyi basitçe feda etmiyoruz. Düşük bit formatlarda daha iyi çalışacak şekilde tasarlanan modeller elde ediyoruz; böylece genel yerel yapay zekâ deneyimi iyileşiyor. Bu testte QAT modeli, QAT olmayan sürüme göre daha hızlı, daha hafif ve kullanımı daha akıcıydı.

Şimdi, hızı muhtemelen 2 kata kadar daha da artırabilecek modelin MTP sürümünü test etmeyi dört gözle bekliyorum. Bu, iş akışımın daha fazlasını yerel yapay zekâya taşımayı çok daha kolaylaştıracaktır. Modeli yerelde çalıştırabilir, OpenCode gibi araçlarla entegre edebilir ve proje dosyalarını doğrudan özel bir yerel asistanla düzenlemeye başlayabilirim.

Bu yeni yerel yapay zekâ dalgası, yapay zekâ sistemlerini kullanma biçimimize bakışımızı değiştiriyor. Bir zamanlar büyük bulut kurulumları gerektiren, özellikle metin, görsel ve video girdili çok modlu iş akışları, yavaş yavaş yerel makinelerde mümkün hale geliyor. Mahremiyet, hız ve kontrolü önemseyen geliştiriciler, araştırmacılar ve yapıcılar için bu çok heyecan verici bir yön.