LLM Fine-tuning: Kendi Verilerinizle Dil Modeli Eğitme

Fine-tuning Nedir ve Neden İhtiyaç Duyarız?

Büyük dil modelleri (LLM'ler) genel amaçlı eğitilmiş olsalar da, spesifik bir alan veya görev için her zaman en iyi sonucu vermeyebilirler. Fine-tuning, önceden eğitilmiş bir modeli kendi verilerinizle yeniden eğiterek belirli bir göreve veya alana özelleştirme sürecidir. Bu işlem, modelin genel bilgisini korurken, sizin kullanım senaryonuza uygun çıktılar üretmesini sağlar.

Fine-tuning'e ihtiyaç duyabileceğiniz tipik senaryolar şunlardır:

• Alan-spesifik terminoloji: Tıp, hukuk veya mühendislik gibi alanlarda doğru terminoloji kullanımı
• Belirli bir çıktı formatı: JSON, tablo veya özel bir yapıda tutarlı yanıtlar
• Ton ve üslup kontrolü: Marka dilinize uygun yanıtlar üretme
• Düşük gecikmeli çıkarım: Uzun prompt'lar yerine modelin davranışını içselleştirmesi

Fine-tuning Yöntemleri

1. Full Fine-tuning

Modeldeki tüm ağırlıkların güncellenmesidir. En güçlü yöntem olmakla birlikte, büyük modeller için ciddi GPU belleği ve hesaplama kaynağı gerektirir. 7B parametreli bir model için bile en az 40-80 GB VRAM'e ihtiyaç duyabilirsiniz.

2. LoRA (Low-Rank Adaptation)

LoRA, modelin orijinal ağırlıklarını dondurup, küçük rank-decomposition matrisleri ekleyerek eğitim yapan verimli bir yöntemdir. Eğitilebilir parametre sayısını dramatik biçimde azaltır — genellikle toplam parametrelerin %1'inden daha azını eğitirsiniz. Bu da bellek kullanımını önemli ölçüde düşürür.

3. QLoRA (Quantized LoRA)

QLoRA, modeli 4-bit hassasiyette niceleyerek (quantize ederek) LoRA uygular. Bu sayede 70B parametreli bir modeli bile tek bir 24 GB GPU üzerinde fine-tune edebilirsiniz. Pratikte en çok tercih edilen yöntemlerden biridir.

Veri Hazırlama

Fine-tuning'in başarısını belirleyen en kritik faktör veri kalitesidir. Verilerinizi hazırlarken dikkat etmeniz gereken noktalar:

• Format tutarlılığı: Tüm örnekler aynı yapıda olmalıdır
• Kalite kontrolü: Hatalı veya çelişkili örnekler modeli olumsuz etkiler
• Çeşitlilik: Farklı senaryoları kapsayan örnekler genelleme yeteneğini artırır
• Yeterli miktar: Görevin karmaşıklığına bağlı olarak en az 100-1000 kaliteli örnek

Tipik bir eğitim verisi şu formatta hazırlanır:

{"messages": [
  {"role": "system", "content": "Sen bir müşteri destek asistanısın."},
  {"role": "user", "content": "Siparişim nerede?"},
  {"role": "assistant", "content": "Sipariş numaranızı paylaşır mısınız?"}
]}

Hugging Face ile Pratik Uygulama

Aşağıda, Hugging Face ekosistemini kullanarak bir modeli QLoRA ile fine-tune etmenin temel adımları yer almaktadır:

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

# 4-bit quantization ayarları
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="bfloat16",
    bnb_4bit_use_double_quant=True,
)

# Model ve tokenizer yükleme
model_name = "mistralai/Mistral-7B-v0.3"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# LoRA konfigürasyonu
lora_config = LoraConfig(
    r=16,                     # Rank değeri
    lora_alpha=32,            # Ölçekleme faktörü
    lora_dropout=0.05,        # Dropout oranı
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    task_type="CAUSAL_LM",
)

# Modeli eğitime hazırla
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# Veri setini yükle
dataset = load_dataset("json", data_files="train_data.jsonl", split="train")

# Eğitim ayarları ve başlatma
training_config = SFTConfig(
    output_dir="./fine_tuned_model",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    bf16=True,
    logging_steps=10,
    save_strategy="epoch",
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
    max_seq_length=2048,
)

trainer = SFTTrainer(
    model=model,
    args=training_config,
    train_dataset=dataset,
    processing_class=tokenizer,
)

trainer.train()

# Modeli kaydet
trainer.save_model("./fine_tuned_model")

Hiperparametre Ayarları

Fine-tuning sürecinde doğru hiperparametre seçimi kritik öneme sahiptir:

• Learning rate: Genellikle 1e-5 ile 5e-4 arasında. Çok yüksek değerler catastrophic forgetting'e (modelin önceki bilgilerini unutması) yol açar.
• Epoch sayısı: 1-5 epoch genellikle yeterlidir. Fazla epoch overfitting'e neden olur.
• LoRA rank (r): 8, 16 veya 32 yaygın değerlerdir. Daha yüksek rank daha fazla ifade gücü sağlar ancak bellek kullanımını artırır.
• Batch size: GPU belleğinize bağlı olarak ayarlayın, gradient_accumulation_steps ile efektif batch size'ı büyütebilirsiniz.
• Warmup: İlk adımlarda learning rate'i kademeli artırmak eğitim stabilitesini iyileştirir.

Değerlendirme ve İterasyon

Fine-tuning sonrası modeli değerlendirmek için şu yaklaşımları kullanabilirsiniz:

1. Eğitim/doğrulama kaybını izleme: Doğrulama kaybı artmaya başladığında overfitting sinyali alırsınız.
2. Manuel inceleme: Gerçek kullanım senaryolarında modelin çıktılarını test edin.
3. Otomatik metrikler: Görevinize uygun metrikleri (BLEU, ROUGE, F1, exact match vb.) kullanın.
4. A/B testi: Fine-tuned modeli base model ile karşılaştırın.

Yaygın Hatalar ve Çözümleri

• Catastrophic forgetting: Model genel yetkinliğini kaybediyorsa learning rate'i düşürün ve epoch sayısını azaltın.
• Overfitting: Doğrulama seti kullanın, dropout artırın veya veri çeşitliliğini artırın.
• Bellek yetersizliği: Batch size'ı düşürün, gradient checkpointing aktifleştirin veya QLoRA'ya geçin.
• Tutarsız çıktılar: Eğitim verisindeki format tutarsızlıklarını giderin ve system prompt'u standardize edin.

Fine-tuned Modeli Kullanma

Eğitim tamamlandıktan sonra LoRA adaptörünü base model ile birleştirip (merge) kullanabilir veya adaptör olarak ayrı yükleyebilirsiniz:

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

# Base model + LoRA adaptörü yükleme
base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.3")
model = PeftModel.from_pretrained(base_model, "./fine_tuned_model")

# Birleştirme (opsiyonel - deploy için önerilir)
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged_model")

# Çıkarım
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.3")
inputs = tokenizer("Müşteri şikayeti: Ürün hasarlı geldi.", return_tensors="pt")
outputs = merged_model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Sonuç

LLM fine-tuning, özellikle QLoRA gibi verimli yöntemlerle birlikte, artık sınırlı kaynaklarla bile uygulanabilir bir teknik haline gelmiştir. Başarının anahtarı kaliteli veri hazırlığı, doğru hiperparametre seçimi ve sistematik değerlendirmedir. Küçük ama kaliteli bir veri setiyle başlayıp iteratif olarak geliştirmek, büyük ama gürültülü bir veri setiyle tek seferde eğitmekten her zaman daha iyi sonuç verir. Fine-tuning sürecinizi bir deneysel döngü olarak ele alın: veri topla, eğit, değerlendir ve tekrarla.