LoRA + Unsloth ile Türkçe LLM Fine-Tuning: Adım Adım Rehber

Büyük dil modellerini sıfırdan eğitmek, çoğu ekip için ne zaman ne de para açısından gerçekçi değil. GPT-4 ölçeğinde bir modeli baştan eğitmek binlerce A100-GPU-saati ve milyonlarca dolar gerektiriyor; üstelik bu büyüklükte veri derleme ve altyapı yönetimi ayrı bir uzmanlık istiyor. Fine-tuning ise tamamen farklı bir yaklaşım sunuyor: önceden eğitilmiş, güçlü bir modeli kendi görevinize uyarlamak için yalnızca küçük bir adaptör katmanı eğitmeniz yeterli. Modelin genel dilsel bilgisini ve çıkarım kapasitesini olduğu gibi devralırsınız; yalnızca spesifik davranış ya da alan bilgisini şekillendirirsiniz.

LoRA (Low-Rank Adaptation) bu adaptasyon sürecinin bugüne kadar bulunan en verimli yollarından biri. Ağırlık matrislerini güncellemek yerine onların üzerine küçük, düşük kerteli faktörler ekliyor; eğitilebilir parametre sayısını base modelin binde biri düzeyine düşürüyor. Unsloth ise bu süreci bir adım öteye taşıyor: HuggingFace Transformers’ın standart eğitim döngüsüne kıyasla yaklaşık 2× hız ve %50 bellek tasarrufu sağlayan, açık kaynak bir optimizasyon kütüphanesi.

Bu rehberde şunları öğreneceksiniz: LoRA’nın matematiksel temellerini ve hangi hiperparametrelerin ne zaman kullanılacağını; QLoRA ile sınırlı GPU bütçesiyle 70B modele bile yaklaşmayı; Türkçe özelinde veri setini doğru formatlama ve yaygın tokenizer sorunlarını çözmeyi; Unsloth ile uçtan uca eğitim döngüsünü çalıştırmayı; modeli GGUF formatına dönüştürmeyi ve Ollama ya da HuggingFace Hub üzerinden dağıtmayı. Hedef kitle: Python ve PyTorch bilen, LLM kavramlarına aşina olan orta seviye ML mühendisleri.

LoRA Nedir ve Nasıl Çalışır?

Bir transformer modelinin dikkat (attention) katmanı büyük ağırlık matrisleri barındırır. Llama 3 8B’nin her attention katmanındaki q_proj matrisi yaklaşık 4096 × 4096 boyutundadır; bu tek matris ~16 milyon parametre demektir. Tüm modeli ele aldığınızda full fine-tuning, bu milyarlarca parametrenin gradyan güncellemesi anlamına gelir. Eğitim sırasında her parametre için gradyan ve optimizer durumu (Adam’ın momentum + varyans tensörleri) bellekte tutulmak zorundadır; bu da gerçek model boyutunun 3–4 katı VRAM kullanımına yol açar.

LoRA, farklı bir gözlemden yola çıkar: dil uyarlamasının gerektirdiği “bilgi değişikliği” aslında çok düşük bir iç boyutta (low-rank intrinsic dimension) öğrenilebilir. Başka bir deyişle, bir modeli hukuki dile veya tıbbi terminolojiye uyarlamak için tüm matrisin öğrenmesi gerekmiyor; matrisin düşük kerteli bir projeksiyon alt uzayında çalışmak yeterli.

Bunu pratiğe dökmek için: W matrisini doğrudan güncellemek yerine onu “dondurur” ve üzerine iki ince matris — B (d × r) ve A (r × k) — ekleriz. Güncelleme şu formülle tanımlanır:

W' = W₀ + ΔW = W₀ + B × A

Burada r (rank) d ve k’den çok küçük seçilir; tipik olarak 8–64 arası. Eğitim sırasında yalnızca B ve A parametreleri gradyan alır; W₀ sabit kalır ve depolama gereksinimi yoktur. Eğitim bittikten sonra ΔW = B × A hesaplanarak W₀’a eklenir; bu sayede çıkarım sırasında sıfır ek hesaplama yükü oluşur, model tam hızda çalışır.

B matrisi başlangıçta sıfırlarla, A matrisi ise rastgele başlatılır. Bu, eğitim başında ΔW = 0 olmasını ve modelin base halinden sapmadan başlamasını sağlar; eğitim sırasında bu başlangıç noktasından kademeli adaptasyon gerçekleşir.

Temel Hiperparametreler

r (rank): Adaptörün kapasitesini ve eğitilebilir parametre sayısını doğrudan belirler. Düşük r hızlı eğitim ve az bellek anlamına gelir; ancak çok düşük r karmaşık görevlerde yetersiz kalabilir. Genel instruction tuning için r=16 sağlam bir başlangıç noktasıdır.

lora_alpha: Adaptör güncellemelerinin etki katsayısını belirler. Öğrenme oranına benzer bir etki yapar; çok düşük alpha adaptörü neredeyse devre dışı bırakırken çok yüksek alpha eğitimi instable hale getirebilir. Yaygın pratik kural lora_alpha = 2 × r’dir.

lora_dropout: Aşırı öğrenmeye karşı her eğitim adımında adaptör aktivasyonlarının bir kısmını rastgele sıfırlar. Küçük veri setleri için 0.05–0.1 arası önerilir; büyük ve temiz veri setlerinde 0.0 da iyi çalışır.

Hedef modüller: LoRA’nın hangi matrisler üzerinde çalışacağını belirler. Standart başlangıç q_proj ve v_proj (sorgu ve değer projeksiyonları); yani dikkat mekanizmasının kalbidir. Daha kapsamlı adaptasyon için k_proj, o_proj ve MLP katmanlarındaki gate_proj, up_proj, down_proj da eklenebilir. Bu ekleme eğitilebilir parametre sayısını 3–4× artırır ve genellikle daha iyi sonuç verir; maliyeti ise küçük bir VRAM artışıdır.

LoRA’nın dikkat katmanlarını tercih etmesi tesadüf değil: görev uyarlamasına en duyarlı parametreler burada yoğunlaşmakta, MLP katmanları ise daha çok olgusal bilgiyi depolamaktadır. Tüm ağı eğitmek yerine bu seçici yaklaşım hem tasarruf hem odak sağlıyor.

QLoRA — 4-bit Quantization ile Bellek Tasarrufu

LoRA parametre güncelleme miktarını dramatik biçimde azaltır, ama base model yine de float16 ya da bfloat16 formatında yüklenir. Llama 3 70B için bu ~140 GB VRAM anlamına gelir; erişilebilir tek bir GPU’ya sığmaz. QLoRA, 2023 yılında Dettmers ve ekibi tarafından geliştirilen ve bu engeli iki aşamada aşan bir yöntemdir.

Aşama 1 — NF4 (Normal Float 4-bit) Quantization: Base model standart INT4 yerine NF4 formatında sıkıştırılır. NF4, değerlerin normal (Gauss) dağılımına göre ayrıştırıldığı özel bir 4-bit formattır; sinir ağı ağırlıklarının dağılımı genellikle normale yakın olduğundan standart INT4’a göre çok daha az bilgi kaybı yaşanır. Pratik sonuç: modelin kalitesi büyük ölçüde korunur, bellek yarıya iner.

Aşama 2 — Double Quantization: Quantization işlemi sırasında her blok için bir ölçek sabiti (scaling constant) hesaplanır; bu sabitler de bellekte yer kaplar. QLoRA bu sabitleri de ikinci bir quantization’a tabi tutar. Parametre başına ~0.37 bit ek tasarruf küçük görünse de büyük modellerde yüzlerce megabayta karşılık gelir.

LoRA adaptörleri bu frozen, 4-bit quantize edilmiş base model üzerinde bfloat16 hassasiyetiyle eğitilir. Gradyanlar tam hassasiyette hesaplanır, yalnızca base model ağırlıkları 4-bit tutulur. Bu hibrit yaklaşım sayesinde base modelin bilgisi korunurken adaptörler yüksek hassasiyetle öğrenir.

QLoRA ne zaman LoRA nedir? — LoRA terimi teknik olarak herhangi bir hassasiyette kullanılabilir; QLoRA ise özellikle 4-bit quantize base model üzerinde uygulanan LoRA’yı ifade eder. Pratikte bugün “fine-tuning” denildiğinde çoğunlukla QLoRA kastedilmektedir.

Paged Optimizer: Uzun süreli eğitimlerde Adam optimizer’ın momentum ve varyans tensörleri GPU belleğini büyük miktarda tüketir. Paged optimizer bu durumu çözmek için tensörleri ihtiyaç duyulmadığında CPU RAM’ine taşır; gerektiğinde yeniden GPU’ya alır. Bu mekanizma OOM (out of memory) hatalarını büyük ölçüde önler ve özellikle uzun sequence’larla eğitimde fark yaratır.

Model Boyutuna Göre VRAM Karşılaştırması

Bu tablodan çıkan pratik sonuç: RTX 3090 (24 GB) sahibi biri 7B modeli, A100 80GB sahibi ise 34B modeli QLoRA ile rahatça fine-tune edebilir. Birkaç yıl önce erişilmesi için bir veri merkezi gereken işlemler bugün tek kartlı bir iş istasyonunda yapılabilir hale geldi.

Unsloth Kurulumu ve Ortam Hazırlığı

Unsloth, HuggingFace Transformers’ın standart eğitim altyapısını tamamen değiştirmez; onun üstüne oturur ve kritik kısımları yeniden yazar. Hız avantajının iki ana kaynağı vardır: Flash Attention 2 ve özel Triton kernel’ları. Standart torch.autograd ile hesaplanan backpropagation adımları, Unsloth’un elle yazılmış kernel’larıyla çalıştırıldığında bellek bant genişliği kullanımı iyileşir, gereksiz tensor kopyalamaları azalır; net sonuç 2× hız artışı ve ~%50 bellek tasarrufudur.

# CUDA 12.1 + PyTorch 2.3.0 (Ampere ve daha yeni GPU'lar için önerilen)
pip install "unsloth[cu121-ampere-torch230]"

# Eski GPU'lar (CUDA 11.8, Turing/Pascal mimarisi)
pip install "unsloth[cu118-old-torch220]"

# Conda ortamı tercih edenler için
conda install -c conda-forge unsloth

Google Colab ve Kaggle: Ücretsiz T4 GPU ile Unsloth çalışır; T4 Turing mimarisi olduğundan Flash Attention 2 desteği sınırlıdır ama QLoRA ile 7B model sığar ve eğitim yapılabilir. Colab Pro+ üzerindeki A100, tam hız elde etmek için idealdir. Kaggle’ın ücretsiz P100 GPU’su ise daha eski bir mimari olduğundan fallback modda çalışır.

Flash Attention 2 uyumluluk notu: Ampere (RTX 3090, A6000, A100) ve sonraki mimariler tam desteklenir. Eski GPU’larda Unsloth otomatik olarak fallback moda geçer; hata vermez, yalnızca hız avantajı azalır. Kurulum sırasında bunu açıkça belirtmeniz gerekmez, Unsloth GPU mimarisini otomatik algılar.

from unsloth import FastLanguageModel
import torch

# Model yükleme — QLoRA için load_in_4bit=True
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3-8B-Instruct",
    max_seq_length=2048,
    dtype=None,          # Ampere'de bfloat16, eski GPU'larda float16 otomatik seçilir
    load_in_4bit=True,   # QLoRA aktif
)

Unsloth’un FastLanguageModel.from_pretrained API’si standart AutoModelForCausalLM.from_pretrained ile neredeyse özdeştir. Mevcut bir training script’ini Unsloth’a taşımak büyük ölçüde tek satır değişikliği demektir.

Veri Seti Hazırlama — Türkçe LLM için İpuçları

Fine-tuning sonucunu en çok belirleyen faktör, kullandığınız modelden değil veri kalitesinden kaynaklanır. Bu, Türkçe için özellikle önemli bir noktadır çünkü açık kaynak Türkçe instruction veri setleri henüz İngilizceye kıyasla daha sınırlıdır.

Instruction Tuning Formatları

Alpaca formatı — Tek turlu komut-yanıt görevleri için en yaygın seçim, çoğu kütüphane tarafından doğrudan desteklenir:

{
  "instruction": "Aşağıdaki metni özetle.",
  "input": "Yapay zeka, 2024 yılında hızla büyümeye devam etti...",
  "output": "Metin, yapay zekanın 2024'teki büyüme sürecini aktarmaktadır."
}

ChatML formatı — Çok turlu diyalog görevleri için HuggingFace ve Qwen ekosisteminde standart haline gelmiştir:

<|im_start|>system
Sen Türkçe konuşan, yardımcı bir yapay zeka asistanısın.<|im_end|>
<|im_start|>user
LoRA nedir?<|im_end|>
<|im_start|>assistant
LoRA (Low-Rank Adaptation), büyük dil modellerini verimli şekilde ince ayarlamak
için kullanılan bir tekniktir.<|im_end|>

Hangi format seçilirse seçilsin tutarlılık kritik öneme sahiptir. Karışık formatlı veri setleri modeli karıştırır ve daha fazla veriye rağmen daha kötü sonuç verebilir.

Türkçe Veri Kaynakları

Kaliteli Türkçe instruction verisi bulmak İngilizceye kıyasla daha zordur. Aşağıdaki kaynaklar kullanılabilir başlangıç noktaları sunar:

• malhajar/turkish-instructions — HuggingFace üzerinde 50K+ Türkçe instruction örneği, Alpaca formatında
• umarigan/alpaca-data-turkish — İngilizce Alpaca verisinin çevirisi; hızlı prototipleme için uygun
• bkazaz/alpaca-cleaned-turkish — Temizlenmiş, kalite filtreli Alpaca verileri
• boun-tabi/turkish-nlp-datasets — NER, metin sınıflandırma ve soru-cevap görevleri için akademik veri setleri

Kendi veri setinizi oluştururken dikkat edilmesi gereken noktalar: doğal Türkçe kullanımı (makine çevirisi kokusundan kaçının), standart yazım ve noktalama, instruction’ların net ve görev odaklı olması. Hatalı ya da tutarsız 100 örnek, temiz 1000 örnekten daha zararlı olabilir.

Tokenizer ve Türkçe Karakter Sorunları

# pad_token eksikse SFTTrainer eğitimi crash eder — her zaman kontrol edin
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# Türkçe karakterlerin doğru encode edildiğini doğrulayın
sample = "İstanbul'daki yapay zeka araştırmaları hızlanıyor."
tokens = tokenizer(sample, return_tensors="pt")
decoded = tokenizer.decode(tokens["input_ids"][0])
assert "İstanbul" in decoded, "Büyük İ karakteri kayboldu!"

Llama 3 ve Qwen2 tokenizer’ları Türkçe özel karakterleri (İ, Ş, Ğ, Ü, Ö, Ç) genellikle doğru işler. Mistral’ın bazı eski versiyonlarında ş ve ğ birden fazla token’a bölünebilir; bu sequence uzunluğunu artırır ve max_seq_length parametresini buna göre ayarlamayı gerektirebilir.

from datasets import load_dataset

dataset = load_dataset("malhajar/turkish-instructions", split="train")

def format_alpaca(example):
    if example.get("input"):
        prompt = (f"### Görev:
{example['instruction']}

"
                  f"### Girdi:
{example['input']}

### Yanıt:
")
    else:
        prompt = f"### Görev:
{example['instruction']}

### Yanıt:
"
    return {"text": prompt + example["output"] + tokenizer.eos_token}

dataset = dataset.map(format_alpaca, remove_columns=dataset.column_names)

Adım Adım Fine-Tuning Akışı

1. LoRA Yapılandırması

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=42,
)

use_gradient_checkpointing="unsloth" seçeneği Unsloth’un özel implementasyonunu etkinleştirir; standart HuggingFace gradient checkpointing’e göre daha az overhead üretir ve özellikle max_seq_length 4096’yı aştığında fark yaratır.

2. SFTTrainer ile Eğitim

from trl import SFTTrainer
from transformers import TrainingArguments

training_args = TrainingArguments(
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,   # efektif batch = 8
    warmup_ratio=0.03,
    num_train_epochs=3,
    learning_rate=2e-4,
    fp16=not torch.cuda.is_bf16_supported(),
    bf16=torch.cuda.is_bf16_supported(),
    logging_steps=10,
    optim="adamw_8bit",
    weight_decay=0.01,
    lr_scheduler_type="cosine",
    seed=42,
    output_dir="./outputs",
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    dataset_num_proc=4,
    args=training_args,
)

trainer.train()

Eğitim sırasında dikkat edilmesi gereken iki uyarı sinyali: training loss’un sürekli artması (learning rate çok yüksek veya veri kalitesi sorunlu) ve validation loss’un training loss’tan uzaklaşmaya başlaması (aşırı öğrenme belirtisi). İkinci durumda epoch sayısını düşürmek ya da lora_dropout’u artırmak yardımcı olur.

Kritik TrainingArguments Özet Tablosu

Model Kaydetme

# Yalnızca LoRA adaptörlerini kaydet — hafif (~50-200 MB)
model.save_pretrained("lora-adapters")
tokenizer.save_pretrained("lora-adapters")

# Base modelle birleştir ve tam model olarak kaydet (~14-16 GB)
model.save_pretrained_merged(
    "merged-model", tokenizer, save_method="merged_16bit"
)

# GGUF formatına dönüştür — Ollama ve llama.cpp için
model.save_pretrained_gguf(
    "model-gguf", tokenizer, quantization_method="q4_k_m"
)

Benchmark Karşılaştırması: Unsloth vs. Standart Transformers

Unsloth’un hız avantajı iki ana kaynaktan beslenir. Birincisi Flash Attention 2: standart dikkat hesaplaması O(n²) bellek kullanırken Flash Attention IO-aware tiled computation ile bu bottleneck’i önemli ölçüde azaltır; özellikle uzun sequence’larda fark belirginleşir. İkincisi özel Triton kernel’ları: backpropagation sırasında attention ve MLP katmanlarının ağırlık güncellemeleri için elle optimize edilmiş CUDA/Triton kodu devreye girer. Bu iki optimizasyon birleşince token başına düşen hesaplama süresi azalır, GPU bellek bant genişliği daha verimli kullanılır.

Bir diğer pratik kazanım daha az bellek kullanımıdır. Aynı veri setiyle daha büyük batch size ya da daha uzun sequence’lar kullanılabilir. Bu hem eğitim stabilitesini iyileştirir hem de gradient’ların daha az gürültülü olmasını sağlar.

A100 80GB Üzerinde Karşılaştırma Tablosu

Tablodaki en çarpıcı satır Llama 3 70B’dir: standart yöntemle tek A100’a sığmazken QLoRA ile 48 GB’ta çalışabilir. Bu, 70B modeli A100 80GB sahibi tek bir kişinin fine-tune edebildiği anlamına gelir. Pratik etkisi büyük: artık 7B modellerin ötesine geçmek için bir küme kurmak zorunlu değil.

Hız farkı eğitim süresine doğrudan yansır: Unsloth ile 1000 örneklik bir Türkçe veri seti tek A100 üzerinde genellikle 30–60 dakikada tamamlanır; standart Transformers ile bu süre 60–120 dakikaya çıkar.

Model Birleştirme ve Dağıtım

Eğitim bittikten sonra iki temel seçenek vardır. Seçim, kullanım senaryonuza ve kaynakların kısıtlılığına göre şekillenir.

Seçenek A — Adaptörleri ayrı tut: İnce ayarlı model yüklenirken base model ve LoRA adaptörleri ayrı dosyalar halinde tutulur; PEFT kütüphanesi bunları çalışma zamanında birleştirir. Birden fazla adaptörünüz (farklı görevler için farklı LoRA’lar) varsa tek bir base model üzerinde dinamik geçiş yapılabilmesi açısından bu yaklaşım avantajlıdır. Disk alanı çok tasarrufludur.

Seçenek B — Merge et: merge_and_unload() ile ΔW = B × A hesaplanarak W₀’a eklenir; saf bir model elde edilir. Çıkarım sırasında sıfır ek yük vardır. Performans ve deployment kolaylığı isteyenler için bu yöntem önerilir.

from peft import PeftModel
import torch

base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model = PeftModel.from_pretrained(base_model, "lora-adapters")
merged_model = model.merge_and_unload()
merged_model.save_pretrained("final-model")

GGUF ve Quantization Seviyeleri

GGUF, llama.cpp ve Ollama tarafından kullanılan, CPU ve GPU’da verimli çalışabilen bir model formatıdır. İnce ayarlı modeli dağıtmak için genellikle en pratik yoldur.

Türkçe görevler için Q4_K_M genellikle kalite ile boyut arasında iyi bir denge noktasıdır.

Ollama ile Lokal Çalıştırma

cat > Modelfile <<'EOF'
FROM ./model-gguf/model-q4_k_m.gguf
SYSTEM "Sen Türkçe konuşan, yardımcı bir yapay zeka asistanısın."
PARAMETER temperature 0.7
PARAMETER top_p 0.9
EOF

ollama create turkce-llm -f Modelfile
ollama run turkce-llm "LoRA'nın temel avantajları nelerdir?"

HuggingFace Hub’a Yükleme

from huggingface_hub import HfApi

api = HfApi()
api.upload_folder(
    folder_path="lora-adapters",
    repo_id="kullanici-adi/llama3-8b-turkish-lora",
    repo_type="model",
    commit_message="Add Turkish LoRA fine-tuned adapter",
)

Sıkça Sorulan Sorular

LoRA fine-tuning için ne kadar veri gerekir?

Görev türüne bağlı olmakla birlikte instruction tuning için 500–5 000 kaliteli örnek genellikle yeterlidir. En kritik nokta miktardan önce kalitedir: hatalı ya da tutarsız örnekler modeli yanlış yönlendirir. 500’den az örnekte aşırı öğrenme riski artar; bu durumda lora_dropout değerini artırmak ve validation kaybı eğrisini takip etmek önerilir. 10 000’i aşan veri setlerinde tüm fine-tuning döngüsünü gözden geçirmek ve daha yüksek epoch’tan kaçınmak gerekir.

Unsloth, Axolotl ile karşılaştırıldığında nasıl?

Unsloth tek GPU kullanımını optimize eder, kurulumu basittir ve Colab/Kaggle gibi ortamlarda sorunsuz çalışır; küçük ekipler ve hızlı prototipleme için idealdir. Axolotl çok-GPU dağıtık eğitimi, çok sayıda veri formatını (Alpaca, ShareGPT, ORCA, vb.) ve daha ileri yapılandırma seçeneklerini destekler; production ölçeğinde esneklik sunar. Kısaca: tek kart varsa Unsloth, çoklu GPU klaster varsa Axolotl daha uygun seçimdir.

Fine-tuning sonrası model hallucination azalır mı?

Doğrudan azalmaz. Fine-tuning modelin davranışını, üslubunu ve görev uyumunu şekillendirir; olgusal doğruluğu kendi başına iyileştirmez. Halüsinasyonu azaltmak için veri setine açık “bilmiyorum” yanıtları eklemek, düşük güvenli yanıtları filtrelemek ve SFT sonrasında DPO ya da RLHF aşaması uygulamak gerekir. Yalnızca SFT ile halüsinasyonun ortadan kalkmasını beklemek gerçekçi değildir.

Llama 3 mı, Mistral mı, Qwen mi? Türkçe için hangisi?

Mevcut topluluk bulgularına ve çok dilli benchmark’lara göre Qwen2, Türkçeyi de kapsayan geniş çok dilli eğitim verisiyle başlangıç noktası olarak avantajlıdır. Llama 3 ve Mistral İngilizce ağırlıklıdır; ancak yeterli Türkçe fine-tuning verisiyle ikisi de rekabetçi sonuçlar üretir. Kesin yanıt kendi veri setinizde: üçünü küçük ölçekte deneyin, perplexity ve görev başarımını karşılaştırın; teorik avantaj her zaman pratiğe taşınmayabilir.

Base model mi, Instruct model mi fine-tune etmeliyim?

Instruction following görevleri (soru-cevap, özetleme, komut takibi) için Instruct versiyonundan başlamak daha verimlidir; model zaten komut formatını biliyor, az veriyle iyi sonuç veriyor. Tamamen özgün bir karakter, benzersiz bir ton ya da spesifik bir alan uzmanlığı kazandırmak istiyorsanız Base model daha esnek bir başlangıç noktasıdır. Kaynaklar kısıtlıysa Instruct model önerilir.

LoRA rank değeri nasıl seçilmeli?

İyi bir başlangıç noktası r=16’dır; çoğu instruction tuning görevi için yeterlidir. Görev karmaşıksa veya veri setiniz büyükse r=32 ya da r=64 deneyin. Kaynaklar çok sınırlıysa r=8 de makul sonuç verebilir. Genel kural: lora_alpha = 2 × r olarak ayarlayın. Farklı r değerleriyle kısa bir ablation çalışması (her biri ~200 adım, validation loss karşılaştırması) yapmak en güvenilir seçim yöntemidir; teorik rehberler veri setinizin karakteristiklerine göre yanıltıcı olabilir.