Düşük RAM ile Ollama: Quantized Model Rehberi

Eski bir dizüstü bilgisayarda ya da RAM’i kısıtlı bir sunucuda yerel LLM çalıştırmak istediğinde, ilk karşılaştığın duvar genellikle bellek sorunudur. Ollama bir modeli yüklerken yeterli RAM bulamazsa ya çöker ya da sistemi tamamen kasıp kavurur. Ama bu, yerel yapay zeka kullanımından vazgeçmek zorunda olduğun anlamına gelmiyor. Quantized modeller sayesinde 8GB hatta 4GB RAM’li sistemlerde bile oldukça kullanılabilir bir deneyim elde etmek mümkün. Bu yazıda quantization mantığını, hangi modelin hangi durumda tercih edilmesi gerektiğini ve düşük bellekli sistemlerde Ollama’yı nasıl verimli hale getireceğini ele alacağız.

Quantization Nedir, Neden İşe Yarar?

Bir dil modelini eğittiğinde, her parametre (ağırlık) genellikle 32-bit ya da 16-bit float değeri olarak saklanır. Milyarlarca parametreden oluşan bir modeli bu hassasiyetle depolamak ve işlemek, devasa bellek gerektirir. Mesela 7 milyar parametreli bir modeli FP32 formatında tutmak teorik olarak 28GB bellek ister.

Quantization bu ağırlıkları daha düşük bit sayısıyla temsil etme işlemidir. 4-bit quantization ile aynı model yaklaşık 4-5GB’a iner. Elbette bir miktar doğruluk kaybı yaşanır ama pratikte günlük kullanım için bu fark çoğu zaman fark edilmez düzeyde kalır.

GGUF formatı, Ollama’nın temel olarak kullandığı format ve quantization türleri şu şekilde sıralanır:

Q2_K: En agresif sıkıştırma, çok düşük bellek ama ciddi kalite kaybı
Q3_K_S / Q3_K_M / Q3_K_L: 3-bit quantization, küçük/orta/büyük varyantlar
Q4_K_S / Q4_K_M: 4-bit quantization, günlük kullanım için en iyi denge noktası
Q5_K_S / Q5_K_M: 5-bit, kalite ve boyut arasında iyi orta yol
Q6_K: 6-bit, FP16’ya yakın kalite, daha fazla RAM ister
Q8_0: 8-bit, neredeyse kayıpsız ama model boyutu büyüyor

Sysadmin perspektifinden bakılırsa: Q4_K_M çoğu senaryo için varsayılan tercih olmalı. Ne çok agresif ne de çok savurgan.

Sistem RAM’ini Doğru Ölçmek

Model seçmeden önce elimizdeki kaynakları net olarak görmek gerekiyor. Salt “8GB RAM var” demek yetmez, sistemin ne kadarını gerçekten Ollama’ya ayırabildiğini bilmek lazım.

# Anlık bellek kullanımı
free -h

# Daha detaylı bellek bilgisi
cat /proc/meminfo | grep -E "MemTotal|MemFree|MemAvailable|SwapTotal|SwapFree"

# Hangi prosesler ne kadar RAM yiyor
ps aux --sort=-%mem | head -20

Çıktıdan MemAvailable değerine dikkat et. Bu, sistemin gerçekten serbestçe kullanabileceği bellek miktarını gösteriyor. Eğer bu değer 5GB civarındaysa Q4_K_M formatında bir 7B model rahatça çalışır. 3GB ise 3B modellere ya da daha agresif quantization seçeneklerine bakman gerekiyor.

# Swap durumunu kontrol et
swapon --show

# Swap yoksa geçici olarak oluştur (8GB)
sudo fallocate -l 8G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Swap kesinlikle RAM’in yerini tutmaz ama kriz anlarında modelin tamamen çökmesini önleyebilir. SSD üzerindeysen swap performansı makul seviyelerde kalır.

Ollama’da Model İndirirken Quantization Seçimi

Ollama’nın Modelfile sistemi ve registry’si sayesinde hangi quantization versiyonunu indireceğini kolayca belirleyebilirsin.

# Mevcut tag'leri görmek için (llama3.2 örneği)
ollama show llama3.2

# Belirli bir quantization versiyonunu indirmek
ollama pull llama3.2:3b-instruct-q4_K_M

# 1B model, çok düşük RAM için
ollama pull llama3.2:1b-instruct-q4_K_M

# Mistral 7B Q4
ollama pull mistral:7b-instruct-q4_K_M

# Daha agresif, 4GB altı sistemler için
ollama pull mistral:7b-instruct-q2_K

Ollama Hub’da modele baktığında “Tags” bölümünde tüm quantization versiyonlarını görürsün. İsimlendirme her zaman tutarlı değil ama genel kural şu: isminde q4 geçiyorsa 4-bit quantization, q8 geçiyorsa 8-bit.

# Şu an sistemde yüklü modelleri ve boyutlarını gör
ollama list

# Modelin detaylı bilgisi
ollama show mistral:7b-instruct-q4_K_M

RAM’e Göre Model Seçim Rehberi

Teorik eşik değerlerini şöyle sıralayabiliriz:

4GB ve altı sistemler için:

1B-3B arası modeller en makul seçenek
llama3.2:1b-instruct-q4_K_M (yaklaşık 800MB)
llama3.2:3b-instruct-q4_K_M (yaklaşık 2GB)
phi3:3.8b-mini-instruct-q4_K_M (yaklaşık 2.2GB)
7B modellerden Q2_K kullanılabilir ama kalite ciddi düşer

6-8GB sistemler için:

7B modeller en ideal nokta
mistral:7b-instruct-q4_K_M (yaklaşık 4.1GB)
llama3.1:8b-instruct-q4_K_M (yaklaşık 4.7GB)
gemma2:9b-instruct-q4_K_M (yaklaşık 5.4GB)
Q5_K_M versiyonlarına da bakılabilir

12-16GB sistemler için:

13B modeller rahatça çalışır
llama3.1:8b-instruct-q8_0 (yüksek kalite)
codellama:13b-instruct-q4_K_M (yaklaşık 7.3GB)
llama2:13b-chat-q4_K_M

# Model indirmeden önce ne kadar yer kaplayacağını tahmin etmek için
# (parametre sayısı x bit sayısı / 8 = yaklaşık GB)
# 7B model, Q4 = 7,000,000,000 x 4 / 8 / 1,073,741,824 ≈ 3.5GB

# Disk kullanımını kontrol et
df -h ~/.ollama/

Ollama’yı Düşük RAM İçin Yapılandırmak

Sadece doğru modeli seçmek yetmez, Ollama’nın kendisini de kısıtlı kaynaklara göre ayarlamak gerekiyor.

# Ollama servis konfigürasyonu için environment variable'ları ayarla
sudo systemctl edit ollama

Açılan dosyaya şunları ekle:

[Service]
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"

Bu ayarların anlamı:

OLLAMA_NUM_PARALLEL=1: Aynı anda yalnızca bir istek işle, bellek baskısını azaltır
OLLAMA_MAX_LOADED_MODELS=1: Belleğe yalnızca bir model yükle
OLLAMA_FLASH_ATTENTION=1: Flash attention aktif edilerek bellek kullanımı optimize edilir
OLLAMA_KV_CACHE_TYPE=q8_0: KV cache’i de quantize ederek bellek tasarrufu sağlanır

# Değişiklikleri uygula
sudo systemctl daemon-reload
sudo systemctl restart ollama

# Durumu kontrol et
sudo systemctl status ollama

Context Window’u Kısaltmak

Çoğu zaman göz ardı edilen bir faktör: context window boyutu. Model çalışırken KV cache adı verilen bir yapı oluşturulur ve bu yapı context penceresi büyüdükçe ölçeklenir. Varsayılan 4096 ya da 8192 token bağlamı, RAM’in önemli bir bölümünü yer.

# Model çalıştırırken context boyutunu düşür
ollama run mistral:7b-instruct-q4_K_M --num-ctx 2048

Ya da Modelfile üzerinden kalıcı hale getir:

# Özel Modelfile oluştur
cat > ~/Modelfile.mistral-low-ram << 'EOF'
FROM mistral:7b-instruct-q4_K_M

PARAMETER num_ctx 2048
PARAMETER num_predict 512
PARAMETER num_thread 4

SYSTEM "Sen yardımcı bir asistansın. Kısa ve öz yanıtlar ver."
EOF

# Bu Modelfile'dan yeni model oluştur
ollama create mistral-lowram -f ~/Modelfile.mistral-low-ram

# Oluşturulan modeli çalıştır
ollama run mistral-lowram

num_ctx 2048: Bağlam penceresini 2048 token ile sınırla
num_predict 512: Maksimum çıktı token sayısını sınırla
num_thread 4: CPU thread sayısını sınırla, RAM değil ama CPU yükünü dengeler

Gerçek Dünya Senaryosu: Eski Bir Laptop’ta Geliştirme Ortamı

Diyelim ki 8GB RAM’li, Intel Core i5 7. nesil bir laptop var. Üzerinde Ubuntu 22.04 çalışıyor ve yerel bir kod yardımcısı istiyorsun.

# Önce mevcut RAM durumuna bak
free -h
# Çıktı: 8GB toplam, 5.2GB available (diğer servisler çalışıyor)

# Codellama'nın düşük boyutlu versiyonunu indir
ollama pull codellama:7b-code-q4_K_M

# Test et
ollama run codellama:7b-code-q4_K_M "Python'da bir liste comprehension örneği yaz"

Eğer sistem yine de zorlanıyorsa:

# Gereksiz servisleri geçici olarak durdur
sudo systemctl stop snapd
sudo systemctl stop cups
sudo systemctl stop bluetooth

# Tekrar dene
free -h

# Model çalışırken RAM kullanımını izle
watch -n 2 'free -h && echo "---" && ps aux --sort=-%mem | head -5'

CPU Thread Optimizasyonu

Düşük RAM’li sistemlerde genellikle CPU da sınırlıdır. Ollama’nın thread kullanımını doğru ayarlamak hem performansı hem de kararlılığı etkiler.

# Kaç CPU çekirdeğin var?
nproc

# Ollama'nın kullandığı thread sayısını görüntüle
curl http://localhost:11434/api/ps | python3 -m json.tool

# Thread sayısını ayarlamak için environment variable
sudo systemctl edit ollama

[Service]
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="GOMP_SPINCOUNT=0"

GOMP_SPINCOUNT=0 değeri, CPU’nun aktif bekleme yerine uyku moduna geçmesini sağlar. Düşük çekirdekli sistemlerde yararlı olabilir.

Model Performansını Ölçmek

Hangi modelin sisteminizde gerçekten makul hızda çalıştığını görmek için basit bir benchmark yapabilirsiniz.

# Token/saniye hızını ölçmek için basit test
time echo "Türkiye'nin başkenti hakkında 100 kelimelik bir yazı yaz." | ollama run mistral:7b-instruct-q4_K_M

# API üzerinden daha detaylı metrik almak
curl -s http://localhost:11434/api/generate -d '{
  "model": "mistral:7b-instruct-q4_K_M",
  "prompt": "Merhaba, nasılsın?",
  "stream": false
}' | python3 -c "
import json, sys
data = json.load(sys.stdin)
total_tokens = data.get('eval_count', 0)
total_time = data.get('eval_duration', 0) / 1e9
print(f'Token sayısı: {total_tokens}')
print(f'Süre: {total_time:.2f}s')
print(f'Hız: {total_tokens/total_time:.1f} token/s')
"

Kabul edilebilir performans eşikleri konusunda kişisel değerlendirmem şöyle: 4-5 token/saniye üzeri sohbet için kullanılabilir, 8-10 token/saniye gayet akıcı, 15+ token/saniye ise konforlu bir deneyim sağlıyor.

Modeli Bellekten Kaldırma

Ollama, kullandıktan sonra modeli bellekte tutmaya devam eder. Düşük RAM’li sistemlerde bu sorun yaratır. Bu davranışı kontrol edebilirsiniz.

# Model bellekte ne kadar süre kalacağını ayarla (saniye cinsinden)
# 0 = kullanım bittikten hemen sonra bellekten çıkar
OLLAMA_KEEP_ALIVE=0 ollama run mistral:7b-instruct-q4_K_M

# Ya da süre olarak belirt (5 dakika)
OLLAMA_KEEP_ALIVE=5m ollama run mistral:7b-instruct-q4_K_M

Servis genelinde bu değeri ayarlamak için:

sudo systemctl edit ollama

[Service]
Environment="OLLAMA_KEEP_ALIVE=0"

Bu ayar özellikle birden fazla farklı araç Ollama ile konuşuyorsa ve aralarında uzun aralar varsa çok işe yarar.

Küçük Ama Güçlü Model Tavsiyeleri

Deneyimlerime dayanarak düşük RAM’li sistemler için öne çıkan bazı modeller:

phi3:mini (3.8B): Microsoft’un küçük ama yetenekli modeli. Q4_K_M ile yaklaşık 2.3GB. Mantık soruları için güçlü.
gemma2:2b: Google’ın 2B parametreli modeli. Yalnızca 1.6GB ile çalışır. Şaşırtıcı derecede yetenekli.
llama3.2:1b: Gerçekten kısıtlı ortamlar için. 800MB. Basit görevlerde işe yarar.
qwen2.5:3b: Alibaba’nın modeli, özellikle kod ve çok dilli görevlerde 3B seviyesinin üzerinde performans gösteriyor.
deepseek-r1:1.5b: Reasoning odaklı, 1.1GB ile çalışır, düşük parametreye rağmen mantık yürütme görevlerinde oldukça başarılı.

# Hepsini sırayla test etmek için
for model in phi3:mini gemma2:2b llama3.2:1b qwen2.5:3b; do
    echo "=== $model test ediliyor ==="
    echo "2 + 2 kaçtır ve neden?" | timeout 60 ollama run $model 2>/dev/null
    echo ""
done

Sonuç

Düşük RAM’li sistemlerde Ollama kullanmak, doğru quantization seçimi ve birkaç konfigürasyon değişikliğiyle oldukça pratik bir hale geliyor. Özetlemek gerekirse:

Önce free -h ile gerçekten kullanılabilir belleği ölç. Sonra bu değere göre model boyutunu belirle. Genel kural: modelin RAM tüketimi, kullanılabilir belleğin %70-80’ini geçmemeli, sistemin nefes alacak yerine ihtiyacı var.

Q4_K_M formatı ezici çoğunluk senaryosunda en iyi kalite/boyut dengesini sunuyor. Daha da küçülmek gerekiyorsa Q3_K_M bir adım aşağısı, ciddi kayıp kabul edilirse Q2_K son çare.

OLLAMA_MAX_LOADED_MODELS=1, OLLAMA_KEEP_ALIVE=0 ve num_ctx kısıtlaması bu üçlüyü her zaman uygula. Bu basit adımlar sistemi öngörülemeyen çökmelerden korur.

Yerel LLM kullanımı bulut tabanlı servislere göre elbette daha fazla uğraş gerektiriyor ama veri gizliliği, internet bağımsızlığı ve uzun vadede maliyet avantajları düşünüldüğünde bu uğraş kesinlikle değiyor. Üstelik eski donanımı yeniden hayata döndürmek, bir sysadmin olarak ayrı bir tatmin kaynağı.

Düşük RAM ile Ollama Çalıştırma: Quantized Model Seçimi