Açık Kaynak LLM Karşılaştırması: Hangi Model Ne Zaman Kullanılır

Yazar:komut.io ekibi
0 Yorum

Sunucuna bir LLM kurmak istiyorsun ama hangi modeli seçeceğini bilmiyorsun. Llama mı, Mistral mı, Phi mi? Her biri farklı bir şey vaat ediyor, her biri farklı kaynaklar istiyor. Bu yazıda sysadmin gözüyle açık kaynak LLM dünyasına bakacağız; hangi modeli ne zaman kullanman gerektiğini, Hugging Face üzerinden nasıl indirip çalıştıracağını ve gerçek dünya senaryolarında hangisinin daha mantıklı olduğunu konuşacağız.

Hugging Face ile Başlamak

Hugging Face, açık kaynak modeller için fiili standart depo haline geldi. huggingface_hub kütüphanesi ya da transformers paketi üzerinden modellerle çalışabilirsin. Önce ortamı hazırlayalım.

# Python sanal ortamı oluştur
python3 -m venv llm-env
source llm-env/bin/activate

# Temel paketleri kur
pip install transformers huggingface_hub torch accelerate bitsandbytes
pip install sentencepiece protobuf

Hugging Face CLI ile oturum açmak, özellikle gated model’lere (Llama gibi) erişim için şart:

# HF token ile giriş yap
huggingface-cli login

# Token'ı environment variable olarak set et
export HUGGING_FACE_HUB_TOKEN="hf_xxxxxxxxxxxx"

# Belirli bir modeli sadece config dosyalarıyla indir (önce boyut kontrolü)
huggingface-cli download meta-llama/Llama-3.2-3B-Instruct --include "config.json" "tokenizer*"

Model indirme işlemini script’e gömmek istiyorsan snapshot_download fonksiyonu hayat kurtarır:

python3 << 'EOF'
from huggingface_hub import snapshot_download
import os

# Modeli belirli bir dizine indir
model_path = snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3",
    local_dir="/opt/models/mistral-7b-instruct",
    local_dir_use_symlinks=False,
    ignore_patterns=["*.msgpack", "*.h5", "flax_model*"]
)
print(f"Model indirildi: {model_path}")
EOF

Temel Model Aileleri ve Karakterleri

Açık kaynak LLM dünyasını anlamak için birkaç ana aileyi tanımak gerekiyor.

Llama Ailesi (Meta)

Meta’nın Llama modelleri, açık kaynak ekosisteminin omurgasını oluşturuyor. Llama 3.1 ve 3.2 serileri şu an piyasadaki en dengeli modellerden biri.

Güçlü yönleri:

  • Geniş topluluk desteği ve fine-tuning ekosistemi
  • Çok dilli destek (özellikle 3.1+)
  • GGUF formatı ile çok farklı ortamlarda çalışabilme
  • Uzun context window (128K token, 3.1 serisi)

Zayıf yönleri:

  • Meta lisansı bazı ticari kullanımlarda kısıtlayıcı olabiliyor
  • Büyük modeller (70B+) için ciddi donanım gereksinimi
  • Gated repo, token gerektiriyor

Ne zaman kullan: Genel amaçlı metin üretimi, kod asistanı, RAG pipeline’ları, uzun döküman analizi.

Mistral Ailesi

Mistral AI, Avrupa çıkışlı bir şirket olarak hem açık hem ticari modeller üretiyor. Mistral 7B, parametre sayısına göre olağanüstü performans gösteriyor.

Güçlü yönleri:

  • 7B boyutunda çok güçlü reasoning
  • Apache 2.0 lisansı (bazı modeller), ticari kullanım özgür
  • Mixtral MoE mimarisi ile büyük model performansı, küçük model maliyeti
  • Hızlı inference

Zayıf yönleri:

  • Türkçe performansı Llama 3.1’e göre biraz daha zayıf
  • Mixtral 8x7B için hala ciddi RAM gerekiyor (48GB+)

Ne zaman kullan: API servisi kurarken, sınırlı GPU bütçesi varken, İngilizce ağırlıklı iş yüklerinde.

Microsoft Phi Serisi

Phi modelleri “küçük ama akıllı” konseptini test ediyor. Phi-3 ve Phi-3.5 serileri, 3.8B parametreyle çok üstünde modellere taş çıkarıyor.

Güçlü yönleri:

  • Çok düşük donanım gereksinimi (CPU’da bile çalışır)
  • Reasoning ve matematik performansı boyutuna göre çok yüksek
  • MIT lisansı, tamamen özgür kullanım
  • Edge deployment için ideal

Zayıf yönleri:

  • Uzun bağlam ve açık uçlu yaratıcı görevlerde zorlanır
  • Gerçek dünya bilgisi daha kısıtlı
  • Büyük organizasyonların beklediği fine-tuning ekosistemi yok

Ne zaman kullan: Raspberry Pi veya edge cihaz deployment, yetersiz GPU, classification/extraction gibi yapılandırılmış görevler.

Qwen Serisi (Alibaba)

Qwen 2.5 serisi, özellikle kod ve çok dilli destek konusunda son zamanlarda çok güçlendi.

Güçlü yönleri:

  • Mükemmel kod üretimi (Qwen2.5-Coder)
  • Güçlü çok dilli destek (Türkçe dahil)
  • 0.5B’dan 72B’a geniş model yelpazesi
  • Apache 2.0 lisansı

Zayıf yönleri:

  • Batı kökenli değerlendirme benchmark’larında bazen tutarsız sonuçlar
  • Küçük modellerde hallucination daha belirgin

Ne zaman kullan: Kod review asistanı, çok dilli projeler, Türkçe NLP görevleri.

Donanım Gereksinimlerini Anlamak

Model seçiminde belki de en kritik faktör donanımdır. Yanıltıcı benchmark’lara bakıp 70B model indirip sonra “neden çalışmıyor” diye saatler harcamak istemezsin.

Basit kural: 4-bit kuantizasyonla model parametresi başına yaklaşık 0.5GB VRAM hesapla. 7B model için ~3.5GB, 13B için ~7GB, 70B için ~35GB.

# GPU bilgilerini kontrol et
nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv

# Çalışan süreçlerin GPU kullanımını izle
watch -n 1 nvidia-smi

# Sisteme ne kadar RAM var
free -h && cat /proc/meminfo | grep HugePages

CPU inference da bir seçenek; özellikle llama.cpp ile. Ama production ortamda 7B modeli CPU’da çalıştırıyorsan, yanıt sürelerini kullanıcı beklentileriyle ölçmeyi unutma.

Hugging Face Transformers ile Model Çalıştırma

Basit bir inference pipeline kuralım. Bu örnek Mistral 7B için ama aynı yapı çoğu modelde çalışır:

# inference_test.py
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "mistralai/Mistral-7B-Instruct-v0.3"

# Tokenizer yükle
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Modeli 4-bit ile yükle (bitsandbytes gerekli)
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto",
    torch_dtype=torch.float16,
)

# Chat template kullan
messages = [
    {"role": "user", "content": "Linux'ta disk kullanımını analiz etmek için en iyi 5 komutu ver."}
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.7,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )

response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

Ollama ile Pratik Deployment

Production’da transformer pipeline yerine Ollama kullanmak çok daha pratik. Servis yönetimi, model switching, REST API hepsi hazır geliyor.

# Ollama kur
curl -fsSL https://ollama.ai/install.sh | sh

# Systemd service olarak başlat
systemctl enable ollama
systemctl start ollama

# Farklı modelleri çek ve karşılaştır
ollama pull llama3.2:3b
ollama pull mistral:7b
ollama pull phi3.5:3.8b
ollama pull qwen2.5:7b

# Model bilgilerini gör
ollama show llama3.2:3b --modelfile
ollama list

Hangi modelin senin iş yükün için daha hızlı olduğunu test etmek için basit bir bash script:

#!/bin/bash
# benchmark_models.sh

MODELS=("llama3.2:3b" "mistral:7b" "phi3.5:3.8b")
PROMPT="Explain TCP/IP handshake in 3 sentences."

echo "Model Benchmark Testi"
echo "===================="

for model in "${MODELS[@]}"; do
    echo -n "Model: $model | "
    
    START_TIME=$(date +%s%3N)
    
    RESPONSE=$(ollama run "$model" "$PROMPT" 2>/dev/null)
    
    END_TIME=$(date +%s%3N)
    ELAPSED=$((END_TIME - START_TIME))
    
    WORD_COUNT=$(echo "$RESPONSE" | wc -w)
    
    echo "Sure: ${ELAPSED}ms | Kelime: ${WORD_COUNT}"
done

Gerçek Dünya Senaryosu: Log Analiz Asistanı

Diyelim ki sunucu loglarını analiz edip anomali tespiti yapan bir araç istiyorsun. Bu iş için model seçimi önemli.

Bu senaryo için Phi-3.5 veya Mistral 7B iyi tercihler. Yapılandırılmış bir görev (log parsing), çok uzun bağlam gerektirmiyor ve hız önemli.

# log_analyzer.py
import subprocess
import requests
import json

def analyze_logs_with_llm(log_content: str, model: str = "phi3.5:3.8b") -> str:
    """
    Verilen log içeriğini LLM ile analiz eder
    Ollama REST API kullanır
    """
    
    system_prompt = """Sen bir Linux sistem yöneticisi asistanısın. 
    Verilen log dosyasını analiz et ve şunları belirt:
    1. Kritik hatalar
    2. Güvenlik uyarıları
    3. Performans sorunları
    4. Önerilen aksiyonlar
    Kısa ve net ol."""
    
    payload = {
        "model": model,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Bu logları analiz et:nn{log_content[:3000]}"}
        ],
        "stream": False,
        "options": {
            "temperature": 0.1,
            "num_predict": 500
        }
    }
    
    response = requests.post(
        "http://localhost:11434/api/chat",
        json=payload,
        timeout=120
    )
    
    if response.status_code == 200:
        return response.json()["message"]["content"]
    else:
        return f"Hata: {response.status_code}"

# Son 100 satır auth log'u al ve analiz et
result = subprocess.run(
    ["tail", "-n", "100", "/var/log/auth.log"],
    capture_output=True, text=True
)

if result.stdout:
    analysis = analyze_logs_with_llm(result.stdout)
    print("=== LLM Log Analizi ===")
    print(analysis)

Gerçek Dünya Senaryosu: Kod Review Bot

Geliştirme ekibine basit bir kod review asistanı kurmak istiyorsun. Bu senaryo için Qwen2.5-Coder veya Llama 3.1 8B güçlü tercihler.

#!/bin/bash
# code_review.sh
# Git diff alıp LLM ile review yaptırır

DIFF_CONTENT=$(git diff HEAD~1 HEAD -- "*.py" "*.sh" "*.go" 2>/dev/null | head -200)

if [ -z "$DIFF_CONTENT" ]; then
    echo "Review edilecek diff bulunamadi"
    exit 1
fi

PROMPT="Asagidaki kod degisikliklerini incele. Guvenlik aciklarini, performans sorunlarini ve best practice ihlallerini belirt. Turkce yanit ver.nn$DIFF_CONTENT"

echo "Kod review yapiliyor..."
ollama run qwen2.5-coder:7b "$PROMPT"

Quantization ve Format Seçimi

GGUF formatı ve llama.cpp ile çalışıyorsan kuantizasyon seçimi performansı doğrudan etkiler.

Q4_K_M: 7B model için ~4.1GB, iyi kalite/hız dengesi, çoğu kullanım için yeterli Q5_K_M: Biraz daha büyük ama belirgin kalite artışı, 7B için ~5GB Q8_0: Neredeyse tam hassasiyet, 7B için ~8GB, yavaş Q2_K: Çok küçük (7B için ~2.5GB) ama kalite düşüyor, acil durum seçeneği

# llama.cpp ile GGUF model indir ve çalıştır
wget https://huggingface.co/bartowski/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/Mistral-7B-Instruct-v0.3-Q4_K_M.gguf

# llama.cpp derle
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j$(nproc) LLAMA_CUBLAS=1  # GPU ile, CPU için sadece make

# Model çalıştır
./main -m Mistral-7B-Instruct-v0.3-Q4_K_M.gguf 
    -n 512 
    -p "[INST] Linux cron job syntax nasıl yazılır? [/INST]" 
    --gpu-layers 35 
    --threads 8 
    --ctx-size 4096

Model Seçim Rehberi: Senaryoya Göre

8GB veya daha az VRAM varsa:

  • Phi-3.5-mini (3.8B): Hız ve verimlilik öncelikliyse
  • Llama 3.2 3B: Genel amaçlı, Türkçe destek istiyorsan
  • Mistral 7B Q4: 8GB sınırını zorlayarak ama Mistral kalitesi istiyorsan

16-24GB VRAM varsa:

  • Mistral 7B veya Llama 3.1 8B: Çoğu production görevi için ideal
  • Qwen2.5 7B Coder: Kod ağırlıklı iş yükü
  • Llama 3.2 11B Vision: Görsel analiz gerekiyorsa

48GB+ VRAM veya multi-GPU varsa:

  • Llama 3.1 70B: Kaliteden ödün vermeden genel kullanım
  • Mixtral 8x7B: Hız/kalite dengesi arıyorsan
  • Qwen2.5 72B: Çok dilli ve kod ağırlıklı işler

Sadece CPU varsa:

  • Phi-3.5-mini Q4: En makul seçim
  • Llama 3.2 1B: Gerçekten kısıtlı ortamlar için

Monitoring ve Gözlemlenebilirlik

Production’da hangi modeli çalıştırdığından bağımsız olarak, kaynak kullanımını izlemelisin.

# GPU metriklerini her 5 saniyede logla
while true; do
    TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
    GPU_MEM=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits)
    GPU_UTIL=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits)
    echo "$TIMESTAMP | GPU Memory: ${GPU_MEM}MB | GPU Util: ${GPU_UTIL}%" >> /var/log/gpu_metrics.log
    sleep 5
done &

# Ollama servis durumunu kontrol et
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Yüklü modellerin bellek kullanımını gör
ollama ps

Sonuç

Açık kaynak LLM seçimi bir “en iyi model hangisi” sorusu değil, “benim ihtiyacım için en uygun model hangisi” sorusudur. Eğer sınırlı bir donanımda hızlı bir asistan istiyorsan Phi-3.5, genel production API servisi kuruyorsan Mistral 7B veya Llama 3.1 8B, kod odaklı çalışıyorsan Qwen2.5-Coder, dil kalitesi ön plandaysa ve donanımın varsa Llama 3.1 70B mantıklı tercihler.

Hugging Face ile model indirip Ollama ile servis haline getirmek düşündüğünden çok daha kolay. Asıl zorluk doğru modeli, doğru kuantizasyonla, doğru senaryoda kullanmak. Bunun için de en iyi yol küçük testlerle başlamak, benchmark scriptlerini çalıştırmak ve kendi kullanım senaryonun metriklerine bakmak.

Her model ailesini en az bir kez kurup kendi test prompt’larınla karşılaştırmanı şiddetle tavsiye ederim. Başkasının benchmark’ı sana ait iş yükü için hiçbir zaman kesin sonuç vermez.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir