Kendi Yapay Zeka Modelini Eğitmek: Başlangıç Rehberi

Bir müşteri destek sistemi kurmak istiyorsunuz. Şirketinizin ürün kılavuzlarına, sözleşme şablonlarına ve binlerce geçmiş destek e-postasına ihtiyacınız var. OpenAI API'ye bu verileri gönderemezsiniz; veri gizliliği politikalarınız buna izin vermiyor. Üstelik genel amaçlı bir modelin sektörünüzün jargonuna ve kurumsal ses tonunuza uymasını da bekliyorsunuz. Bu ve benzeri senaryolarda kendi modelinizi eğitmek, en makul çözüme dönüşüyor.

Peki sıfırdan bir model mı geliştirmelisiniz, yoksa mevcut bir modeli kendi verinize göre mi uyarlamalısınız? Cevap neredeyse her zaman ikinci seçenek: fine-tuning. Sıfırdan eğitmek için Google veya Meta ölçeğinde veri ve hesaplama gücü gerekiyor. Fine-tuning ise halihazırda milyarlarca parametreyle önceden öğrenilmiş bir modeli, sizin küçük ve özelleştirilmiş veri setinizle ince ayarlamayı ifade ediyor.

Temel Kavramlar

İşin teknik boyutuna girmeden önce birkaç kavramı netleştirmek gerekiyor. Transformer mimarisi, bugün hemen tüm büyük dil modellerinin temelini oluşturuyor. 2017'de Google'ın "Attention Is All You Need" makalesiyle kamuoyuna sunulan bu mimari, dilin bağlamsal yapısını anlamak için "attention mekanizması"nı kullanıyor.

Attention mekanizmasını çok basit bir örnekle düşünebilirsiniz: "Banka kenarına oturdum" cümlesinde "banka" kelimesinin anlamını belirlemek için cümlenin geri kalanına bakmak gerekiyor. Attention mekanizması tam da bunu yapıyor; her token, diğer tokenlarla olan ilişkisine göre ağırlıklandırılıyor.

Parametreler ise bu ilişkileri kodlayan sayısal değerler. 7 milyar parametreli bir model, 7 milyar adet ayarlanabilir sayı içeriyor. Eğitim sürecinde bu sayılar, veri üzerinden yapılan hesaplamalar ve geri yayılım (backpropagation) algoritmasıyla güncelleniyor. Fine-tuning'de ise ya tüm parametreler ya da yalnızca belirli bir alt küme bu süreçten geçiyor.

Araçları Seçmek: PyTorch mu, TensorFlow mu?

2026 itibarıyla bu rekabet neredeyse sona erdi: PyTorch açık ara öne geçti. Araştırma camiasının ezici çoğunluğu PyTorch kullanıyor, Hugging Face ekosistemi PyTorch üzerine inşa edilmiş ve yeni model mimarileri önce PyTorch'ta hayata geçiyor. TensorFlow hâlâ Google altyapısında ve bazı production ortamlarında yaşıyor, ama yeni bir proje başlatıyorsanız PyTorch ile devam etmeniz mantıklı.

Hugging Face ise bu denklemin kritik parçası. Transformers kütüphanesi, yüzlerce önceden eğitilmiş modele standart bir API üzerinden erişim sağlıyor. Model hub'ında binlerce model, veri seti ve demo mevcut; çoğu tamamen ücretsiz. 2026'da Hugging Face'i atlamak, yapay zeka geliştirme dünyasında tekerleği yeniden icat etmek anlamına geliyor.

Veri Seti Hazırlama

Modelin kalitesi, doğrudan veri kalitesine bağlı. "Garbage in, garbage out" ilkesi yapay zeka için fazlasıyla geçerli. Veri hazırlama sürecinde dikkat edilmesi gerekenler:

• Temizleme: Yinelenen kayıtlar, boş değerler ve tutarsız formatlar temizlenmeli.
• Denge: Sınıf dengesizliği modelin belirli çıktılara yönelmesine yol açar.
• Tokenization: Metin, modelin anlayabileceği token birimlerine bölünmeli.

Basit bir veri temizleme ve tokenization örneği:

from datasets import Dataset
from transformers import AutoTokenizer

# Ham veri
data = {
    "text": [
        "Ürün iadesi için müşteri hizmetlerini arayın.",
        "Faturanızı e-posta ile talep edebilirsiniz.",
        # ... daha fazla örnek
    ],
    "label": [0, 1]
}

dataset = Dataset.from_dict(data)

# Tokenizer yükle
tokenizer = AutoTokenizer.from_pretrained("bert-base-turkish-cased")

def tokenize_fn(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        max_length=128,
        padding="max_length"
    )

tokenized = dataset.map(tokenize_fn, batched=True)
print(tokenized[0])

Türkçe metinler için bert-base-turkish-cased veya BERTurk gibi Türkçe önceden eğitilmiş modeller başlangıç noktanız olabilir. Genel İngilizce bir model Türkçe'ye uyarlanabilse de Türkçe tokenizer kullanmak çok daha verimli sonuçlar veriyor.

Fine-Tuning: En Pratik Yol

Tam fine-tuning, modelin tüm parametrelerini güncelliyor. Bu, büyük bir model için hem zaman hem de bellek açısından maliyetli. İşte burada LoRA (Low-Rank Adaptation) devreye giriyor.

LoRA, mevcut model ağırlıklarını dondurup yalnızca küçük, düşük ranklı matrisler ekliyor ve yalnızca bu matrisleri eğitiyor. Sonuç: orijinal modelin yüzde birinden daha azı kadar parametre eğitilmesine rağmen etkileyici adaptasyon performansı. PEFT (Parameter-Efficient Fine-Tuning) kütüphanesi bu teknikleri kolayca uygulamaya döküyor.

from transformers import AutoModelForCausalLM, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType

# Temel modeli yükle
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    load_in_8bit=True,  # bellek tasarrufu
    device_map="auto"
)

# LoRA konfigürasyonu
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,           # rank - düşük tutun
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
)

# PEFT modeli oluştur
peft_model = get_peft_model(model, lora_config)
peft_model.print_trainable_parameters()
# Eğitilebilir parametreler: ~4M / 8B (%0.05)

Trainer API ile eğitimi başlatmak:

training_args = TrainingArguments(
    output_dir="./my-finetuned-model",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=50,
    save_strategy="epoch",
)

trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_eval,
)

trainer.train()

GPU Seçimi ve Maliyet Optimizasyonu

Fine-tuning için GPU zorunlu değil ama pratikte CPU ile çalışmak son derece yavaş. Seçeneklere bakalım:

Kendi donanımınız: NVIDIA RTX 4090 (24GB VRAM), 7-13B parametreli modelleri LoRA ile eğitmek için yeterli. Tek seferlik maliyet 1.800-2.200 dolar civarında. Küçük modeller ve sık eğitim için uzun vadede ekonomik.

Cloud GPU: NVIDIA A100 (40/80GB) veya H100 (80GB) saatlik kiralanabilir. RunPod, Vast.ai ve Lambda Labs bu alanda rekabetçi fiyatlar sunuyor; A100 için saatlik yaklaşık 1,5-2,5 dolar. Google Colab Pro+, küçük deneyler için iyi bir başlangıç noktası ancak uzun eğitimler için yetersiz kalıyor.

Quantization: Modeli 8-bit veya 4-bit hassasiyete düşürmek (bitsandbytes kütüphanesiyle) bellek ihtiyacını dramatik biçimde azaltıyor. 8-bit Llama 3.1 8B, 16GB VRAM ile çalışabiliyor.

Model Deployment

Modelinizi eğittikten sonra onu bir servis olarak sunmanın birkaç yolu var:

Hugging Face Spaces: Eğittiğiniz modeli push edip ücretsiz bir demo arayüzüyle paylaşabilirsiniz. Gradio veya Streamlit entegrasyonu birkaç satır kod ile yapılıyor.

FastAPI ile basit bir inference servisi:

from fastapi import FastAPI
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = FastAPI()

# Model ve tokenizer yükle
tokenizer = AutoTokenizer.from_pretrained("./my-finetuned-model")
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "./my-finetuned-model")

@app.post("/generate")
async def generate(prompt: str, max_tokens: int = 256):
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_tokens,
            temperature=0.7,
            do_sample=True
        )
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return {"response": response}