Bir Dil Modelinin Çalışma Şekli

Adım 1: Tokenizasyon

• Model, kelimeleri veya alt kelimeleri küçük parçalara ayırır (token).
• Örneğin, “Merhaba dünya” cümlesi şu şekilde tokenize edilebilir:
  ["Mer", "haba", "dün", "ya"]
• Subword (alt kelime) tokenizasyonu sayesinde model yeni kelimeleri de öğrenebilir.

Adım 2: Vektör Temsili

• Her token, yüksek boyutlu bir vektörle temsil edilir.
• Örneğin, “dünya” kelimesi 300 boyutlu bir vektör olarak gösterilebilir.
• Bu vektörler, anlamsal yakınlıklarına göre organize edilir.

Adım 3: Modelin Örüntü Öğrenmesi

• Model, bağlamsal ilişkileri anlamak için bir sinir ağı (genellikle Transformer) kullanır.
• Eğitim sırasında model, bir sonraki üretelecek kelime(token) tahmini yapar. Örneğin: “Bugün hava çok [MASK]” ifadesinde model, “[MASK]” yerine “güzel”, “soğuk” veya “sıcak” gibi olası kelimeleri tahmin etmeye çalışır. Yani aslında bir sonraki kelime tahmini tamamen olasılıksal bir süreçtir ve bu olasılıklar hesaplanır.
• Model, eğitim süresince her kelime için bir çıktı olasılık dağılımı çıkarır. Örneğin, “Uzayda yaşam var mı?” girdisine yanıt olarak şu olasılıklar hesaplanabilir:
  • “Evet” → %40
  • “Hayır” → %30
  • “Bilinmiyor” → %20
  • “Muhtemelen” → %10
• Model, genellikle en yüksek olasılığa sahip kelimeyi seçer veya örnekleme (sampling) gibi yöntemlerle yanıt oluşturur.
• Kelime tahmini süreci adım adım ilerleyerek cümle oluşturulur.

Fine-Tuning: Modeli İyileştirme

Fine-tuning, önceden eğitilmiş bir modelin ağırlıklarını tamamen veya kısmen güncelleyerek spesifik bir görevde daha iyi performans göstermesini sağlama işlemidir. Ağırlık dediğimiz şey yukarıda bahsettiğimiz katmanların olasılık dağılımlarıdır.

Amacı:

• Genel dil bilgisinden özel bir konuya odaklanmak (örneğin, tıp, hukuk, mühendislik).
• Belirli bir dil için modelin yeteneklerini artırmak (örneğin, LLaMA’yı Türkçe için iyileştirmek).
• Özel bir metin stili veya formatında çıktı üretmesini sağlamak (örneğin, müşteri destek botu, akademik yazılar).
• Görev bazlı performansı artırmak (soru-cevap, çeviri, özetleme vb.).

Süreci

Veri Setini Hazırlama

Modelin öğrenmesini istediğimiz konuya uygun bir veri seti oluşturulmalıdır. Veri seti dediğimiz şey en kaba tabirle soru ve yanıt örnekleri içerir.

• Diyalog verileri (chatbot eğitimi için).
• Çeviri verileri (çeviri modeli oluşturmak için).
• Teknik makaleler veya belgeler (alan spesifik uzmanlık kazandırmak için).

Veri formatı genellikle JSON, CSV veya metin formatında olur. Örneğin, LLaMA için fine-tuning yaparken Alpaca formatı kullanılabilir.

[
  {
    "instruction": "Bir Python fonksiyonunun nasıl tanımlanacağını açıkla.",
    "input": "",
    "output": "Python'da bir fonksiyon 'def' anahtar kelimesiyle tanımlanır. Örneğin:\n\ndef merhaba():\n    print('Merhaba Dünya')"
  }
]

Veri Seti Büyüklüğüne Göre Tahmini Soru-Cevap Sayıları

Veri Seti Boyutu	Tahmini Token Sayısı	Tahmini Soru-Cevap Çiftleri	Kullanım Senaryosu
Küçük	100K – 1M token	10K – 100K Soru-Cevap	Küçük ölçekli domain adaptasyonu (örneğin, tıbbi chatbot eğitme)
Orta	1M – 10M token	100K – 1M Soru-Cevap	Spesifik bir alan için güçlü ince ayar (örneğin, hukuk, finans, akademik metinler)
Büyük	10M – 100M token	1M – 10M Soru-Cevap	Genel amaçlı model ince ayarı, büyük ölçekli adaptasyon
Çok Büyük	100M – 1B+ token	10M – 100M+ Soru-Cevap	Tam model fine-tuning, devasa ölçekli AI sistemleri (örneğin, GPT-4, Claude)

Model ve Eğitim Ortamını Hazırlama

Kullanım Amacı

• Basit Görevler (3B-7B): Çeviri, sınıflandırma, temel soru-cevap gibi görevlerde küçük modeller yeterli olabilir.
• Daha Karmaşık Görevler (7B-13B): Daha uzun ve anlamlı metin üretimi, kod tamamlama, mantıksal çıkarım gibi işler için orta ölçekli modeller gerekir.
• Gelişmiş Kullanım (13B-30B+): Genel amaçlı büyük dil modelleri, çok aşamalı düşünme, detaylı diyalog yönetimi, karmaşık problem çözme gibi işler için büyük modeller gereklidir.

Donanım Kaynakları

• 3B-7B modelleri tek bir güçlü GPU (24GB VRAM) ile fine-tune edebilirsin.
• 8B-13B modelleri için en az 48GB VRAM (örneğin A100 40GB veya RTX 3090/4090 çift GPU) gerekir.
• 30B+ modelleri genellikle birden fazla A100/H100 gibi sunucu seviyesinde GPU gerektirir.

Veri Setinin Büyüklüğü

• Küçük veri setleri için 3B-7B modelleri daha iyi çalışır çünkü aşırı öğrenmeyi (overfitting) önlemek daha kolaydır.
• Büyük veri setlerin varsa ve modelin daha genel bir yetenek kazanmasını istiyorsan 7B-13B veya daha büyük bir model seçebilirsin.

Inference (Kullanım) Performansı

• Küçük modeller daha hızlı yanıt verir ve düşük gecikmeyle çalışır.
• Büyük modeller daha güçlü olsa da yüksek gecikme ve fazla bellek tüketimi olabilir.

Mevcut Modelin Yetenekleri

• Eğer seçtiğin model zaten iyi bir temel modelse (örn: Mistral, LLaMA 3.2, Falcon vb.), daha küçük bir versiyonunu alıp fine-tune etmek yeterli olabilir.

Eğitim Ortamı

Fine-tune için genellikle Python kullanılır. Genel olarak şu bileşenlere ihtiyaç vardır:

• İyi bir ekran kartı: Örneğin, Nvidia 4060 Ti.
• Python Geliştirme Ortamı: Ekran kartı sürücüsü gereklidir (Windows, Linux fark etmez).
• Python Kütüphaneleri: Genellike Unsloth kütüphanesi kullanılır. Bu kütüphane, CUDA(eğitimde kullanılan olasılık hesapları için GPU kullanımına olanak sağlayan ekran kartı sürücüsüdür.), Transformers, PyTorch, Triton gibi bağımlılıklara sahiptir. Bu bağımlılıkların versiyonları dikkate alınmalıdır. Çünkü sadece belirli versiyonları birbiriyle çalışabilir. Detaylarına Unsloth’un kendi github sayfasından bakılabilir.
• Hugging Face Hesabı: Veri setleri ve açık kaynak dil modelleri için GitHub tabanlı bir platformdur.

Fine-Tuning İçin LoRA veya Tam Model Güncelleme Seçenekleri

Fine-tuning genellikle iki yöntemle yapılır:

Tam Model Fine-Tuning (Full Fine-Tuning) – (Büyük ve Çok Büyü Veri Seti İle)

Tam model fine-tuning, önceden eğitilmiş bir büyük dil modelinin (LLM) tüm parametrelerini güncelleyerek yeniden eğitilmesi sürecidir. Bu yöntem, modeli belirli bir veri setine tam olarak adapte etmek için kullanılır. Modelin tüm ağırlıkları güncellendiğinden çok fazla GPU belleği gerektirir ve büyük modellerde maliyetli olabilir.

Avantajları:

• Modelin tam kapasitesi kullanılır. Yani modelin tüm parametreleri güncellendiği için, eğitildiği veri setine en iyi şekilde adapte olur.
• Özel uygulamalar ve görevler için en yüksek doğruluk elde edilebilir.
• Özel bir veri setiyle eğitildiğinde, modelin doğruluk oranı artar ve yanlış bilgi üretme ihtimali azalır.

Dezavantajları:

• Modelin tüm parametreleri güncellendiği için, eğitim süresi LoRA veya adapter tabanlı yöntemlere göre çok daha uzundur. Büyük veri setleriyle çalışırken, eğitim süresi günler veya haftalar alabilir.
• Tam model fine-tuning yapmak için büyük GPU’lar veya TPU’lar gereklidir. Özellikle büyük modellerde (örneğin, 7B, 13B veya 65B parametreli modellerde) çok fazla VRAM ve RAM kullanılır.
• Tam fine-tuning, çok fazla parametre güncellediği için, küçük veri setleriyle overfitting (aşırı öğrenme) riski taşır.
• Modelin tüm parametrelerini güncellediğin için, eğitilmiş model büyük boyutta olur.

Tam Fine Tunning Örnek Python kodu:

from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments

model_name = "meta-llama/Llama-2-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

training_args = TrainingArguments(
    output_dir="./fine_tuned_llama",
    per_device_train_batch_size=2,
    num_train_epochs=3,
    save_steps=500,
    logging_dir="./logs"
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=my_dataset
)

trainer.train()

LoRA ile Hafif Fine-Tuning (Low-Rank Adaptation) – (Küçük ve Orta Boyut Veri Seti İle)

LoRA (Low-Rank Adaptation), büyük dil modellerini (LLM) tam olarak güncellemeden eğitmek için kullanılan hafif bir ince ayar yöntemidir. Tam model fine-tuning yerine, sadece belirli katmanlara düşük dereceli (low-rank) matriksler ekleyerek modeli eğitir. Yani, modelin tüm ağırlıklarını değiştirmek yerine, sadece bazı belirli katmanları küçük bir değişiklikle günceller. Bu sayede çok daha az hesaplama gücü ve bellek kullanarak modelin öğrenmesini sağlar.

Avantajları

• Modelin tüm ağırlıklarını değiştirmek yerine sadece birkaç katmanı günceller. GPU belleği (VRAM) gereksinimi azalır.
• Daha az parametre güncellendiği için eğitme süresi kısalır. Küçük veri setleriyle de çalışabilir.
• LoRA sadece ek ağırlıkları eğittiği için orijinal model zarar görmez. LoRA ağırlıkları ayrı olarak saklanır.
• Aynı temel modeli farklı diller veya konular için LoRA ile eğitip, ihtiyaca göre değiştirebilirsin. (Örn: Genel LLaMA + Türkçe LoRA)
• Tam model fine-tune için milyonlarca örnek gerekirken, LoRA daha az veriden öğrenebilir (~50K – 100K Soru-Cevap gibi).

Dezavantajları:

• Sadece belirli katmanlar eğitildiği için bazen tam model fine-tune kadar iyi sonuç vermez.
• Eğer modelin tamamen farklı bir dil veya konu öğrenmesini istiyorsan, LoRA yeterli olmayabilir.
• Hangi modüllerin hedefleneceği iyi seçilmezse, LoRA yeterli performans sağlayamaz.

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, config)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=my_dataset
)

trainer.train()

from transformers import pipeline

generator = pipeline("text-generation", model="./fine_tuned_llama")
output = generator("Uzayda yaşam var mı?", max_length=50)
print(output)

Modeli Kaydetme ve Kullanma

Eğitim tamamlandıktan sonra modelin kaydedilmesi gerekir. LLaMA modelleri genellikle PyTorch tabanlıdır ve Hugging Face gibi kütüphanelerle entegre edilebilir.

PyTorch Checkpoint (PT) Formatı

LLaMA’nın eğitimi tamamlandıktan sonra, model PyTorch checkpoint (.pt veya .bin) formatında kaydedilebilir.
Örneğin:

import torch

model.save_pretrained("llama_trained_model")
torch.save(model.state_dict(), "llama_trained_model/model.pth")

• Avantajları: PyTorch ile kolayca yüklenebilir.
• Dezavantajları: Dosya boyutu büyük olabilir.

SafeTensor Formatı (HF Transformers Desteğiyle)

Hugging Face transformers kütüphanesi kullanılıyorsa, LLaMA modeli safetensor formatında kaydedilebilir:

from transformers import AutoModelForCausalLM

model.save_pretrained("llama_hf_model", safe_serialization=True)

Bu format, Hugging Face API’leriyle kolayca yüklenebilir.

GGUF ve GGML Formatları (Daha Küçük Boyut ve CPU Kullanımı İçin)

Eğer LLaMA modelini düşük donanımlı cihazlarda çalıştırmak istiyorsan, GGUF veya GGML formatında kaydetmek iyi bir seçenek olabilir. llama.cpp ve benzeri projeler bu formatları destekler. llama.cpp projesi içinde hf formatını gguf formatına dönüştürmek için gereli scriptler ve araçlar bulunur.

• GGML/GGUF Avantajları: Küçük boyut, düşük RAM kullanımı, CPU üzerinde çalıştırılabilir.
• Dezavantajları: Daha az hassasiyet (quantization uygulanır).

Quantization (Model Boyutunu Küçültme)

Quantization, model ağırlıklarını düşük bit seviyesine (örneğin 8-bit, 4-bit) düşürerek bellek kullanımını azaltır ve CPU/GPU performansını iyileştirir.

• Avantajları: Bellek tüketimi azalır, inference daha hızlı olur.
• Dezavantajları: Model hassasiyeti bir miktar düşebilir.

• q4_0: 4-bit en düşük kalite
• q4_K_M: 4-bit en iyi kalite
• q5_0: 5-bit orta kalite
• q8_0: 8-bit en iyi kalite

Yöntem	Dosya Formatı	Avantajları	Dezavantajları
PyTorch Checkpoint	.pt, .bin	Kolay kullanım, PyTorch uyumu	Büyük boyutlu
Hugging Face Format	.safetensors	HF API ile kolay kullanım	Büyük boyutlu
GGML / GGUF	.gguf, .ggml	Küçük boyut, CPU uyumlu	Hassasiyet kaybı
4-bit Quantization	PyTorch + HF	Düşük RAM kullanımı	Hassasiyet kaybı

Fine-Tune Parametreleri ve Model Eğitim Süreci

LoRA Parametreleri:

model = FastLanguageModel.get_peft_model(
    model,
    r=64,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=64,
    lora_dropout=0, # 0.1
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
    use_rslora=False,
    loftq_config=None,
)

Parametre:	r = (8,16,32,64,128…)
Açıklama:	LoRA’nın eğitim için kullanılacak matris boyutunu belirler. LoRA, modelin tüm ağırlıklarını değiştirmek yerine, belirli katmanlara küçük ek matrisler ekler. Bu küçük matrislerin rank değeri r’dir. Daha büyük r değerleri, daha fazla öğrenme kapasitesi sağlar ama daha fazla bellek tüketir.
Avantajı:	Hafifleşmiş Fine-Tuning: LoRA, modelin orijinal parametrelerini değiştirmek yerine, düşük dereceli projeksiyon matrislerini ekleyerek ince ayar yapar. Bu, parametrelerin sayısını önemli ölçüde azaltır, böylece daha az kaynak kullanılarak daha hızlı eğitim yapılmasını sağlar. Daha Hızlı Eğitim: r boyutu düşük tutulduğunda, eğitim süresi hızlanabilir çünkü matrislerin boyutu küçülür ve daha az hesaplama yapılır. Özelleştirilebilir Performans: r değeri arttıkça, model daha fazla bilgi öğrenebilir, ancak eğitim süresi artar ve daha fazla hafıza gerektirir.
Kullanım:	Daha düşük bir r değeri, eğitim kaynaklarını azaltır, daha hızlı ince ayar yapılmasını sağlar. Eğer modelin daha fazla kapasiteye ihtiyacı varsa (yani, modelin öğrenmesi gereken çok fazla özel bilgi varsa), r değerini arttırmak faydalı olabilir.

Parametre:	target_modules = (q_proj, k_proj,v _proj, o_proj | gate_proj, up_proj, down_proj )
Açıklama:	LoRA’yı hangi ağırlık matrislerine uygulayacağımızı belirlemek için kullanılır. Seçilen modüller genellikle modelin dikkat mekanizması (self-attention) ve ileri beslemeli ağ (feed-forward network) içindeki kritik bileşenlerdir. Dikkat mekanizması sayesinde giriş dizisindeki farklı kelimeler arasındaki ilişkileri yakalar.
Avantajı:	Hedefli İnce Ayar (Targeted Fine-Tuning): Böylelikle yalnızca kritik katmanlarda değişiklik yapılır, bu da daha hızlı ince ayar yapılmasını sağlar. Böylece modelin geneli üzerinde değişiklik yapmadan, sadece ihtiyaç duyulan yerlerde parametre güncellemeleri yapılabilir. Kaynak Verimliliği: Modelin dikkat mekanizması ve feed-forward ağındaki seçilmiş bileşenler üzerinde LoRA uygulamak, eğitimde kullanılacak hesaplama ve bellek kaynaklarını daha verimli hale getirir. Bu, daha düşük bellek kullanımı ve daha hızlı eğitim süreçleri sağlar. Performans İyileştirme: Dikkat mekanizmasındaki q_proj, k_proj, v_proj, o_proj ve feed-forward ağındaki gate_proj, up_proj, down_proj gibi temel matrislerin optimize edilmesi, modelin daha iyi genelleme yapabilmesini sağlar. Bu, modelin hem daha hızlı hem de daha doğru öğrenmesini destekler. *Dikkat Mekanizması İçindeki Modüller: q_proj (Query Projection – Sorgu Projeksiyonu): Girdi vektörünü “query” vektörüne dönüştüren ağırlık matrisidir. Dikkat skorları hesaplanırken kullanılır.
Kullanım:	q_proj (sorgu projeksiyonu) Modelin hangi kelimelerin diğer kelimelerle nasıl ilişkili olduğunu belirlemek için kullandığı sorgu vektörlerini oluşturur. Örneğin, “kitap” kelimesi “okumak” kelimesiyle ilişkili mi?” gibi bir ilişkiyi bulmaya yardımcı olur. k_proj (Anahtar projeksiyonu) Sorguların hangi vektörlerle karşılaştırılacağını belirler. query (q) ile key (k) çarpımı yapılarak dikkat puanı hesaplanır. v_proj (Değer projeksiyonu) Dikkat mekanizmasının hangi bilgiyi taşıyacağını belirler. Yani model, hangi kelimenin bağlam için önemli olduğunu anladığında, bu kelimenin temsilini oluşturur. o_proj (Çıktı projeksiyonu) q, k, v projeksiyonlarının sonucunda ortaya çıkan dikkat çıktısını işleyerek nihai modele uygun hale getirir. Modelin nihai kararına etki eden vektörleri oluşturur. gate_proj (Geçit Projeksiyonu) Amacı, bazı bilgileri dinamik olarak filtrelemek ve modelin gereksiz bilgileri eleyerek daha verimli çalışmasını sağlamaktır. up_proj (Yukarı Doğru Projeksiyon) Daha geniş bir uzaya projeksiyon yaparak modelin bilgiyi işleyebilmesini sağlar. Boyut arttırılır, böylece daha fazla özellik öğrenilebilir. down_proj (Aşağı Doğru Projeksiyon) up_proj tarafından büyütülen vektörleri tekrar küçültür, böylece modele uygun hale gelir.

Parametre:	lora_alpha= (8,16,32,64,128…)
Açıklama:	LoRA’nın ölçeklendirme faktörüdür. Öğrenme sürecinde LoRA’nın katkısını belirler. Yüksek değerler, daha güçlü bir etki yapar.
Avantajı:	LoRA’nın etkisini kontrol eder, modelin öğrenme sürecinde önemli değişikliklere neden olabilir.
Kullanım:	Daha Güçlü Etki Gerektiğinde: Eğer modelin daha fazla kapasiteye ihtiyacı varsa, yüksek lora_alpha kullanılabilir.

Parametre:	lora_dropout= 0.xx
Açıklama:	LoRA’nın düşük dereceli ağırlıkları üzerinde uygular. Dropout, derin öğrenme modellerinde aşırı öğrenmeyi (overfitting) önlemek için kullanılan bir tekniktir.
Avantajı:	Daha İyi Genel Performans: LoRA ağırlıklarına dropout uygulamak, modelin belirli ağırlıklara aşırı bağımlı olmasını engelleyerek daha iyi genelleştirme sağlar. Overfitting’i Azaltma: Özellikle küçük veri kümeleriyle ince ayar (fine-tuning) yaparken, modelin veri setine aşırı uyum sağlamasını önleyerek daha dengeli bir öğrenme sağlar. Daha Dayanıklı Bir Adaptasyon: Modelin, eğitilirken bazı LoRA parametrelerini rastgele bırakması, farklı parametre kombinasyonlarını öğrenmesine yardımcı olur.
Kullanım:	Overfitting riski varsa (küçük veri kümesiyle eğitim yapıyorsanız). Genelleme performansını artırmak istiyorsanız. Modelin daha kararlı ve çeşitli öğrenmesini sağlamak için.

Parametre:	bias= “none”, “all”, “lora_only”
Açıklama:	Bu parametre, LoRA’nın bias (sapma) terimlerini nasıl ele alacağını belirler. Bias (sapma) terimi, yapay sinir ağlarında her nöronun çıktısına eklenen sabit bir değerdir. Amacı, modelin daha esnek öğrenmesini sağlamaktır.
Avantajı:	Daha Hafif ve Daha Hızlı Model Bias terimleri değiştirilmezse ek hesaplama yükü getirmez. LoRA’yı daha az bellek ve işlem gücü kullanarak uygular. Mevcut Modelin Davranışını Korumak Modelin orijinal bias değerleri bozulmaz. Eğer bias’lar zaten optimize edilmişse, onları değiştirmemek kararlılığı artırabilir. Bellek Kullanımını Azaltır Ekstra bias terimleri saklanmadığı için VRAM/RAM tasarrufu sağlar.
Kullanım:	"none"; Az esneklik sağlar. Modelin mevcut bias’ları iyi çalışıyorsa, daha az bellek kullanmak için kullanılabilir. "all": Daha ağır ve en esneğidir. Küçük modellerde veya LoRA’nın daha fazla etki etmesi isteniyorsa kullanılabilir. "lora_only"; Orta seviyedir. Sadece LoRA uygulanan katmanlara bias eklemek isteniyorsa kullanılabilir.

Parametre:	use_gradient_checkpointing= “unsloth”, “hf”,”mem_ef”, None
Açıklama:	Gradient Checkpointing, büyük modellerin eğitimi sırasında bellek kullanımını azaltan bir tekniktir. Bunu, bazı ara aktivasyonları kaydetmek yerine tekrar hesaplayarak yapar.
Avantajı:	Daha Az Bellek Kullanımı (VRAM / RAM Tasarrufu) Gradient Checkpointing, ileri yayılım (forward pass) sırasında bazı bilgileri silerek belleği boşaltır ve geri yayılım (backward pass) sırasında tekrar hesaplar. Böylece daha büyük modelleri daha küçük donanımlarda eğitme imkanı sağlar. Daha Büyük Batch Size Kullanma İmkanı Bellek tasarrufu sağladığı için daha büyük mini-batch’lerle çalışabilirsin. Büyük Modelleri Daha Küçük GPU’larda Eğitme Şansı Eğer GPU’nun VRAM’i yetersizse, normalde eğitemeyeceğin büyük modelleri Gradient Checkpointing ile eğitebilirsin.
Kullanım:	None veya False: Kapalıdır. Bellek tüketimi fazla olur, ancak ileri ve geri yayılım hızlı çalışır. "unsloth": Unsloth optimize edilmiş versiyonu. Daha az bellek kullanır ve geri yayılım daha hızlıdır. "hf": Hugging Face’in Gradient Checkpointing yöntemini kullanır. PyTorch’un standart yöntemine benzer ancak Transformer modellerine özel optimize edilmiştir. "mem_eff": “Memory Efficient” mod. Daha agresif bellek optimizasyonları yapar, ancak hesaplama süresi biraz daha uzun olabilir.

Parametre:	random_state= xxxx
Açıklama:	Bu parametre, eğitim sürecinde rastgeleliği kontrol etmek için kullanılır. Aynı random_state değeriyle çalıştırıldığında, aynı başlangıç noktalarından başlar ve sonuçların tekrarlanabilir olmasını sağlar.
Avantajı:	Deterministik Sonuçlar: Aynı random_state değeriyle tekrar çalıştırıldığında aynı sonuçları elde edersin. Hata Ayıklama (Debugging) Kolaylığı: Farklı denemeler arasında karşılaştırma yaparken eğitim sürecinin rastgeleliğinden kaynaklanan değişkenlikleri ortadan kaldırır.
Kullanım:	Eğer farklı sonuçlar almak istersen random_state değerini değiştirebilir veya None yapabilirsin. Özellikle deneysel çalışmalarda veya akademik makalelerde sonuçların tekrarlanabilir olması gerektiğinde random_state sabit tutulur.

Parametre:	use_rslora= False, True
Açıklama:	Rank Stabilized LoRA (RS-LoRA) yönteminin kullanılıp kullanılmayacağını belirler. RS-LoRA, düşük dereceli adaptasyon (LoRA) sırasında rank değişimini stabilize eden bir tekniktir.
Avantajı:	Daha Kararlı İnce Ayar (Fine-Tuning): LoRA’nın bazı durumlarda dengesizleşmesini önleyerek daha tutarlı sonuçlar almanı sağlar. Eğitim Sürecinde Daha Az Dalgalanma: Modele eklenen düşük dereceli adaptasyon katmanlarının (LoRA) daha kararlı çalışmasını sağlar.
Kullanım:	True olarak ayarlanırsa RS-LoRA aktif olur ve LoRA ağırlıklarının daha stabil hale gelmesini sağlar. False olarak ayarlanırsa standart LoRA kullanılır, yani RS-LoRA’nın sağladığı stabilite optimizasyonlarından faydalanılmaz.

Parametre:	loftq_config= None, Dict
Açıklama:	Rank Stabilized LoRA (RS-LoRA) yönteminin kullanılıp LoftQ (LoRA + Quantization), LoRA ile model küçültme (quantization) tekniklerini birleştiren bir yöntemdir. loftq_config parametresi, LoftQ ile ilgili yapılandırma (config) ayarlarını içerir.
Avantajı:	Daha Az Bellek Kullanımı: LoRA ile birlikte quantization (ağırlıkları düşük hassasiyetli veri türlerine çevirme) kullanarak VRAM/RAM tasarrufu sağlar. Hızlı Çalışma: Küçültülmüş model ağırlıkları, hesaplama maliyetini düşürerek eğitim sürecini hızlandırabilir.
Kullanım:	None olarak ayarlandığında LoftQ devre dışıdır ve model normal hassasiyette çalışır. Eğer bir dict veya yapılandırma nesnesi verilirse, LoftQ özelleştirilmiş ayarlarla çalışır.

SFTTrainer parametreleri:

    trainer = SFTTrainer(
        model = model,
        tokenizer = tokenizer,
        train_dataset = train_dataset,
        eval_dataset = eval_dataset,
        dataset_text_field = "text",
        max_seq_length = max_seq_length,
        dataset_num_proc = 2,
        packing = False, # Can make training 5x faster for short sequences.
        args = TrainingArguments(
            per_device_train_batch_size = 2,
            gradient_accumulation_steps = 4,
            warmup_steps = 5, #5
            # num_train_epochs = 1, # Set this for 1 full training run.
            max_steps = 10000,
            learning_rate = 2e-4,
            fp16 = not is_bfloat16_supported(),
            bf16 = is_bfloat16_supported(),
            logging_steps = 1,
            optim = "adamw_8bit",
            weight_decay = 0.05, # 0.01
            lr_scheduler_type = "linear",
            seed = 3407,
            output_dir = "outputs",
            report_to = "none", # Use this for WandB etc
            evaluation_strategy="steps",  # Add this to enable evaluation
            # evaluation_strategy="steps",  # Değerlendirmeyi adımlarla yap
            eval_steps=500,  # 100 adımda bir eval çalıştır
            save_strategy="steps",
            save_safetensors=500,
            # resume_from_checkpoint=True, 
        ),
        callbacks=[RealTimePlottingCallback(log_file)],  # Add the callback here

    )

Parametre:	model= model
Açıklama:	Eğitilecek modeli belirtir. Burada önceden yüklenmiş bir Transformer modeli kullanılıyor.

Parametre:	tokenizer= tokenizer
Açıklama:	Metni token’lere (alt kelime, karakter vb.) bölmek için kullanılan tokenizer nesnesi. Modelin anladığı formata dönüştürmeyi sağlar.

Parametre:	train_dataset= train_dataset
Açıklama:	Modelin eğitim sırasında değerlendirileceği (validation) veri seti.Modelin eğitileceği veri seti. Eğitim sürecinde kullanılan metin verisini içerir.

Parametre:	eval_dataset= eval_dataset
Açıklama:	Modelin eğitim sırasında değerlendirileceği (validation) veri seti.Modelin performansını belirli adımlarda ölçmek için kullanılır.

Parametre:	dataset_text_field= “text”
Açıklama:	Veri setindeki metinlerin bulunduğu alanın adını belirtir. Eğer veri kümesinde metin "content" gibi farklı bir sütunda olsaydı, bu değeri "content" yapman gerekirdi.

Parametre:	max_seq_length = 2048
Açıklama:	Modelin işleyebileceği maksimum giriş dizisi uzunluğu. Uzun diziler daha fazla bellek kullanır, çok kısa olursa modelin öğrenme kapasitesi düşebilir.

Parametre:	dataset_num_proc = 2
Açıklama:	Veri setinin işlenmesi için kullanılacak CPU iş parçacığı (thread) sayısı. Daha yüksek değerler veri yüklemeyi hızlandırabilir ama CPU kullanımını artırır.

Parametre:	packing = False
Açıklama:	True olursa, kısa dizileri tek bir giriş içinde birleştirerek eğitim hızını artırır. False olduğunda, diziler tek tek kullanılır (daha fazla bellek tüketebilir ama hassasiyet korunur)

Eğitim Parametreleri (TrainingArguments İçinde)

Parametre:	per_device_train_batch_size= 2
Açıklama:	Her bir GPU için kaç örnek işleneceğini belirler. Daha yüksek değerler bellek tüketimini artırır, Ancak eğitimi hızlandırabilir.

Parametre:	gradient_accumulation_steps = 4
Açıklama:	Bellek tasarrufu yapmak için küçük batch’lerle eğitimi simüle eder. Örneğin, batch_size 2 ise ve bu değer 4 ise, model aslında batch_size 8 gibi davranır.

Parametre:	warmup_steps= 5
Açıklama:	Eğer model hassas veya çok büyükse, aniden büyük bir öğrenme oranı (learning_rate) ile başlaması ağırlıkların bozulmasına ve kötü bir başlangıç yapmasına neden olabilir. Öğrenme oranı başta sıfırdan başlayarak warmup_steps adımda yavaşça artırılır. Modelin ani büyük ağırlık değişikliklerinden kaçınmasını sağlar.

Parametre:	learning_rate=2e-4
Açıklama:	Modelin ağırlıklarını güncellerken kullanılan hızdır. Daha yüksekse model daha hızlı öğrenir, ancak aşırı öğrenme (overfitting) riski oluşturur.

Parametre:	fp16 = not is_bfloat16_supported() & bf16 = is_bfloat16_supported()
Açıklama:	Eğer donanım bf16 destekliyorsa, bf16 kullanılır. Desteklemiyorsa, fp16 ile çalışır (bellek optimizasyonu için önemlidir).

Parametre:	logging_steps = 100
Açıklama:	(100 step) bir log kaydı tutulur. Log dosyası veya terminalde daha sık çıktı almak için düşük, daha az çıktı almak için yüksek yapılabilir.

Parametre:	optim = “adamw_8bit”
Açıklama:	Bir optimizasyon yöntemidir. Bellek kullanımını azaltarak daha büyük modellerin eğitilmesine olanak tanır.

Optimizer	Avantajları	Dezavantajları	Ne Zaman Kullanılmalı?
adamw_8bit	Düşük VRAM tüketimi, büyük modelleri küçük GPU’larda eğitme imkanı	Hassasiyet kaybı olabilir	Küçük VRAM’li GPU kullanıyorsan
adamw_torch	Tam hassasiyet, PyTorch uyumlu	Fazla bellek kullanır	Bellek sıkıntın yoksa
adamw_hf	Transformer’lar için optimize	Büyük fark yaratmaz	Transformer model eğitirken
adamw_apex_fused	GPU hızlandırması ile daha hızlı	APEX kurulu olmalı	NVIDIA APEX ve FP16 kullanıyorsan
sgd	Overfitting’i önleyebilir	Yavaş çalışır, verimsiz olabilir	Daha iyi genelleme istiyorsan
adafactor	Minimum bellek kullanımı	Hassasiyet kaybı yaşanabilir	Çok büyük modelleri düşük bellekle eğitmek için

Parametre:	weight_decay = 0.05
Açıklama:	Bu, her eğitim adımında ağırlıkların %5 oranında küçültüldüğü anlamına gelir. Daha büyük değerler (örneğin 0.1) ağırlıkları daha fazla küçültür, bu küçültme aşırı öğrenmeyi önleyebilir.

Parametre:	lr_scheduler_type = “linear”
Açıklama:	Başlangıçta, öğrenme oranı learning_rate parametresiyle belirlenen değerden başlar (2e-4 gibi). Adım adım (step bazında) bu oran lineer olarak sıfıra yaklaşır. Bu, her eğitim adımında ağırlıkların %5 oranında Öğrenme oranını (learning rate) lineer olarak azaltan bir zamanlayıcı kullanır. Alternatifler: "cosine", "exponential", "constant" vb.

Planlayıcı	Avantajları	Dezavantajları
linear	Öğrenme oranını lineer olarak azaltır, stabil eğitim sağlar.	Bazen daha karmaşık öğrenme oranı desenlerine ihtiyaç duyulabilir.
constant	Öğrenme oranını sabit tutar, küçük datasetlerde işe yarar.	Büyük datasetlerde genellikle optimizasyonu zorlaştırır.
constant_with_warmup	Başlangıçta düşük öğrenme oranı ile başlar, sonra sabit kalır.	Küçük batch size ile daha stabil çalışır ama büyük modellerde yavaş olabilir.
cosine	Öğrenme oranı sinüs dalgası gibi azalır, hızlı başlar, yavaş kapanır.	Büyük batch’lerde bazen öğrenmeyi çok erken durdurabilir.
cosine_with_restarts	Cosine decay’in tekrar sıfırdan başladığı versiyonu. Modellerin zaman zaman farklı bölgelere odaklanmasını sağlar.	Daha fazla hesaplama gerektirir, bazı durumlarda gereksiz olabilir.
polynomial	Öğrenme oranını polinom fonksiyonla azaltır, daha esnek bir düşüş sağlar.	Zor ayarlanabilir, yanlış değerler optimizasyonu bozabilir.
inverse_sqrt	Öğrenme oranı 1/t1 / \sqrt{t}1/t​ oranında azalır. NLP ve Transformer modellerinde yaygındır.	Bazı durumlarda öğrenmeyi erken durdurabilir.

Parametre:	seed = 3407
Açıklama:	Rastgeleliği kontrol eder. Aynı değerle tekrar çalıştırıldığında aynı sonuçları üretir.

Parametre:	seed = 3407
Açıklama:	Rastgeleliği kontrol eder. Aynı değerle tekrar çalıştırıldığında aynı sonuçları üretir.

Parametre:	evaluation_strategy=”steps”
Açıklama:	Değerlendirme (eval) işlemini belirli adımlarla çalıştırır.

Parametre:	evaluation_strategy=”steps”
Açıklama:	Değerlendirme (eval) işlemini belirli adımlarla çalıştırır.

Parametre:	save_strategy=”steps”
Açıklama:	Belirli adımlarda modeli kaydeder.

Model Eğitim Sonucu

Train Loss Per Step (Adım Başına Eğitim Kaybı)

• Açıklama: Loss (Kayıp), modelin tahmin ettiği değerler ile gerçek değerler arasındaki farkı ölçen bir hata metriğidir. Yani modelin ne kadar kötü tahmin yaptığını gösterir. Bu değer her adımda hesaplanır.
• İdeal Eğilim: Eğitim ilerledikçe azalmalıdır. Başlangıçta hızlı bir düşüş görmen normaldir, ancak zamanla daha yavaş bir şekilde düşerek plato yapması beklenir. Eğer kayıp çok dalgalanıyorsa, öğrenme oranı yüksek olabilir veya model aşırı uyum (overfitting) yapıyor olabilir. İdealde bu değerin 0′ a yaklaşması beklenir.Genellikle 1’in altına düşmesi iyi bir işarettir.
  -> Eğer Train Loss çok düşükse (örneğin 0.1’in altı), model overfitting yapıyor olabilir.
  -> Eğer Train Loss çok yüksekse (örneğin 3.0 ve üzeri), model yeterince öğrenemiyor olabilir.

Model Boyutu	İdeal Train Loss Aralığı
3B	0.5 – 2.0
7B	0.3 – 1.5
13B+	0.2 – 1.2

Learning Rate Per Step (Adım Başına Öğrenme Oranı)

• Açıklama: Modelin ağırlıklarını ne kadar büyük güncellediğini gösterir. Çok yüksek bir öğrenme oranı modelin dengesiz olmasına neden olabilir, çok düşük bir öğrenme oranı ise eğitim süresini uzatabilir.
• İdeal Eğilim: Öğrenme oranı genellikle cosine decay, linear warmup gibi tekniklerle yönetilir. İlk başta artıp daha sonra kademeli olarak azalan bir grafik beklenir. Eğer modelin öğrenme oranı sürekli sabitse ve loss düşmüyorsa, öğrenme oranını artırmak gerekebilir. Genellikle 1e-4 (0.0001) başlangıç için iyi bir değerdir.
  ->1e-3 (0.001) veya daha büyükse, model öğrenemeyebilir veya dengesiz hale gelebilir.
  ->1e-6 (0.000001) veya daha küçükse, model çok yavaş öğrenebilir ve eğitim süresi uzayabilir.

Model Boyutu	İdeal Learning Rate (LR) Aralığı
3B	1e-4 – 5e-4 (0.0001 – 0.0005)
7B	5e-5 – 3e-4 (0.00005 – 0.0003)
13B+	1e-5 – 2e-4 (0.00001 – 0.0002)

Eval Loss Per Evaluation (Değerlendirme Kaybı)

• Açıklama: Modelin doğrulama (validation) verisi üzerindeki kayıp değeridir. Eğitim sırasında modelin sadece eğitim verisine ezber (overfitting) yapıp yapmadığınıgörmek için izlenir. Modelin ezber yapması kötü bir eğitimi gösterir.
• İdeal Eğilim: Eğitim kaybı gibi azalmalıdır, ancak eğer önce düşüp sonra yükseliyorsa, bu modelin aşırı öğrenmeye başladığını gösterir. Bu durumda early stopping ya da regularization (dropout, weight decay gibi yöntemler) uygulanabilir. Genellikle 1.0’ın altına düşmek iyidir, ancak çok düşük olması da aşırı öğrenmeye (overfitting) işaret edebilir. 1.5’in üzerine çıkıyorsa, modelin öğrenme kapasitesi düşük olabilir veya yeterli veriyle eğitilmiyor olabilir.0.5’in altına iniyorsa, aşırı öğrenme riski vardır, model validation setine ezber yapıyor olabilir.
  -> Eğer Eval Loss, Train Loss’tan çok yüksekse, model underfitting yaşıyor olabilir.
  -> Eğer Eval Loss çok düşük ama model gerçek kullanımda kötü sonuç veriyorsa, overfitting olabilir.

Model Boyutu	İdeal Eval Loss Aralığı
3B	0.8 – 2.0
7B	0.6 – 1.5
13B+	0.5 – 1.2

Epoch (Dönem)

• Açıklama: Modelin tüm eğitim verisini kaç kez gördüğünü gösterir. Genellikle birkaç epoch sonunda model öğrenmeye başlar ve birkaç epoch sonra aşırı öğrenmeye (overfitting) girebilir.

• İdeal Eğilim: Kayıp değerlerinin (loss) bir noktada plato yapması beklenir. Epoch sayısı çok artarsa genelleme yeteneği düşebilir, az olursa model yeterince öğrenmemiş olabilir.Küçük veri setleri için 5-10 epoch yeterli olabilir. Orta büyüklükteki veri setleri için 10-30 epoch ideal olabilir. Büyük veri setlerinde 3-10 epoch genellikle yeterlidir, çünkü fazla epoch overfitting riskini arttırır.

Model Boyutu	Epoch Aralığı (Genel Öneri)
3B	10-50 epoch
7B	5-20 epoch
13B+	3-10 epoch

Gradient Norm per Step (Adım Başına Gradyan Normu)

• Açıklama: Ağırlık güncellemelerinin büyüklüğünü gösterir. Eğer gradyan normu çok büyükse, modelin ağırlıkları çok fazla güncelleniyor olabilir ve bu eğitimde dengesizliğe yol açabilir (exploding gradients). Eğer çok küçükse, model yeterince öğrenmiyor olabilir (vanishing gradients).
• İdeal Eğilim: Başlangıçta biraz dalgalı olabilir, ancak zamanla istikrarlı bir seviyeye oturmalıdır.
• ->Eğer gradyan normu sürekli 5+ seviyelerine çıkıyorsa, learning rate çok yüksek olabilir veya model aşırı büyük güncellemeler yapıyor olabilir.
  ->Eğer gradyan normu 0.1’in altına iniyorsa, model çok yavaş öğreniyor olabilir ve arning rate artırılabilir.

Model Boyutu	İdeal Gradient Norm Aralığı
3B	0.5 – 2.5
7B	1.0 – 3.0
13B+	1.5 – 4.0

Modeli Test Etme

from unsloth.chat_templates import get_chat_template
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch
from unsloth import FastLanguageModel 

# Define model directory
model_path = "outputs\checkpoint-3000"

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, device_map="auto")


tokenizer = get_chat_template(
    tokenizer,
    chat_template = "llama-3.1",
)

FastLanguageModel.for_inference(model) # Enable native 2x faster inference

messages = [
    {"role": "user", "content": "merhaba nasılsın?"},
]
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize = True,
    add_generation_prompt = True, # Must add for generation
    return_tensors = "pt",
).to("cuda")

outputs = model.generate(input_ids = inputs, max_new_tokens = 200, use_cache = True,
                         temperature = 0.5)
decoded = tokenizer.batch_decode(outputs)
print(decoded)

Model belli bir checkpoint aralıklarla kaydedilir ve bu kaydedilen modeli yukarıdaki kod ile yükleyip test edebiliriz. Burada generata fonsiyonu için geçerli bazı sorgu parametreleri vardır.

• max_new_tokens: Modelin üreteceği maksimum yeni token sayısını belirler. Bu durumda, en fazla 200 yeni token üretecek.
• use_cache: Önceki adımlarda hesaplanan gizli durumları (hidden states) önbelleğe alıp tekrar kullanarak üretim sürecini hızlandırır. Özellikle, metin tamamlamada önemli bir optimizasyon sağlar.
• temperature: Modelin çıktılarında çeşitliliği kontrol eden bir sıcaklık (temperature) parametresidir. Daha düşük sıcaklık (örn. 0.2), daha kesin ve tahmin edilebilir çıktılar üretirken, daha yüksek sıcaklık (örn. 1.0 veya üzeri), daha yaratıcı ve rastgele sonuçlar üretir.
• max_length=max_length: Üretilen çıktının maksimum uzunluğunu belirler. Model, belirlenen max_length kadar token üretebilir ancak daha erken de durabilir.
• do_sample=True: Modelin örnekleme (sampling) yapmasını sağlar. Varsayılan olarak, model en olası kelimeyi seçerek ilerler (greedy decoding), ancak do_sample=True kullanıldığında model, olasılıklara göre rastgele seçimler yapar. Bu, çıktının daha çeşitli olmasını sağlar.
• top_k: Modelin her adımda sadece en olası 50 token arasından seçim yapmasını sağlar. Düşük top_k (örn. 10-50) → Modelin belirli kelimeleri seçme ihtimali artar, çıktılar daha tutarlı olur. Yüksek top_k (örn. 100-500) → Daha geniş bir kelime havuzundan seçim yapılır, çıktılar daha çeşitli olabilir.
• top_p: Nükleus örnekleme olarak da bilinen bu yöntem, belirli bir olasılık yüzdesine ulaşana kadar en olası token’ları dahil eder. Düşük top_p (örn. 0.8-0.9) → Model, yalnızca en güvenilir token’ları seçmeye odaklanır. Yüksek top_p (örn. 0.95-1.0) → Daha rastgele sonuçlar üretir, model düşük olasılıklı kelimeleri de seçebilir. Örneğin top_p=0.9, modelin olasılıkların %90’ını kapsayacak şekilde token seçmesine neden olur, yani daha güvenilir token’lar tercih edilirken belirli bir rastgelelik de korunur.

Eğitim İçin Kullanılan Kodun Tamamı

from unsloth import FastLanguageModel 
from unsloth import is_bfloat16_supported
import torch
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
from unsloth.chat_templates import get_chat_template
from transformers import TrainingArguments, DataCollatorForSeq2Seq
from unsloth.chat_templates import standardize_sharegpt
from unsloth.chat_templates import train_on_responses_only
from datasets import load_dataset
from transformers import AutoTokenizer
from huggingface_hub import login
import os
import matplotlib.pyplot as plt
from transformers import Trainer, TrainingArguments, TrainerCallback
from datasets import Dataset
from datasets import concatenate_datasets
import json
import time



login("<Hugging Face Access Token>")

max_seq_length = 2048 # Choose any! We auto support RoPE Scaling internally!
dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
load_in_4bit = True # Use 4bit quantization to reduce memory usage. Can be False.


max_seq_length = 2048 # Supports RoPE Scaling interally, so choose any!


print("Model and tokenizer loaded successfully!")

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3.2-3B-Instruct",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
)


model = FastLanguageModel.get_peft_model(
    model,
    r=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=32,
    lora_dropout=0.1, # 0.1
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
    use_rslora=False,
    loftq_config=None,
)



alpaca_prompt = """Aşağıda bir görevi tanımlayan bir talimat bulunmaktadır. Ayrıca ek bağlam sağlayan bir giriş de verilmiştir. Görevi tamamlayan uygun bir yanıt yazın.

### Talimat:
{}

### Giriş:
{}

### Yanıt:
{}"""

EOS_TOKEN = tokenizer.eos_token # Must add EOS_TOKEN
def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs       = examples["input"]
    outputs      = examples["output"]
    texts = []
    for instruction, input, output in zip(instructions, inputs, outputs):
        # Must add EOS_TOKEN, otherwise your generation will go on forever!
        text = alpaca_prompt.format(instruction, input, output) + EOS_TOKEN
        texts.append(text)
    return { "text" : texts, }
pass

# Read the formatted data from the file
formatted_data_file = 'formatted_data_gsm8k_tr.txt'
data = []

with open(formatted_data_file, 'r', encoding='utf-8') as f:
    for line in f:
        # Parse each line as a JSON object
        entry = json.loads(line.strip())
        # Append the data to the new_data list
        data.append({
            "instruction": entry["instruction"],
            "input": entry["input"],  # This will be empty as per your format
            "output": entry["output"]
        })


custom_dataset = Dataset.from_dict({"instruction": [item["instruction"] for item in data],
                                    "input": [item["input"] for item in data],
                                    "output": [item["output"] for item in data]})

train_dataset = custom_dataset.map(formatting_prompts_func, batched = True,)
eval_dataset = custom_dataset.map(formatting_prompts_func, batched = True,)


train_dataset = train_dataset.shuffle(seed=42)  # You can set any seed for reproducibility
eval_dataset = eval_dataset.shuffle(seed=42)  # You can set any seed for reproducibility

class RealTimePlottingCallback(TrainerCallback):
    def __init__(self, log_file):
        self.log_file = log_file
        self.train_losses = []  # Store training loss values
        self.val_losses = []  # Store validation loss values
        self.steps_train_loss = []  # Store step numbers
        self.steps_eval_loss = []  # Store step numbers
        self.last_log_time = time.time()  # İlk log zamanı

    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs is not None:
            current_time = time.time()
            elapsed_time = current_time - self.last_log_time  # Son logdan geçen süre
            self.last_log_time = current_time  # Şu anki zamanı kaydet
            # Capture metrics and write them to the file
            with open(self.log_file, "a") as f:
                f.write(f"Step: {state.global_step}, ")
                f.write(f"Loss: {logs.get('loss', 'N/A')}, ")
                f.write(f"Eval Loss: {logs.get('eval_loss', 'N/A')}, ")
                f.write(f"Grad Norm: {logs.get('grad_norm', 'N/A')}, ")
                f.write(f"Learning Rate: {logs.get('learning_rate', 'N/A')}, ")
                f.write(f"Epoch: {logs.get('epoch', 'N/A')}\n")
                f.write(f"Elapsed Time: {elapsed_time:.2f} sec\n")  # Geçen zamani ekle


if __name__ == '__main__':

    log_file = "training_metrics.txt"
    open(log_file, 'w').close()


    trainer = SFTTrainer(
        model = model,
        tokenizer = tokenizer,
        train_dataset = train_dataset,
        eval_dataset = eval_dataset,
        dataset_text_field = "text",
        max_seq_length = max_seq_length,
        dataset_num_proc = 2,
        packing = False, # Can make training 5x faster for short sequences.
        args = TrainingArguments(
            per_device_train_batch_size = 2,
            gradient_accumulation_steps = 4,
            warmup_steps = 5, #5
            # num_train_epochs = 1, # Set this for 1 full training run.
            max_steps = 4000,
            learning_rate = 2e-4,
            fp16 = not is_bfloat16_supported(),
            bf16 = is_bfloat16_supported(),
            logging_steps = 1,
            optim = "adamw_8bit",
            weight_decay = 0.05, # 0.01
            lr_scheduler_type = "linear",
            seed = 3407,
            output_dir = "outputs",
            report_to = "none", # Use this for WandB etc
            evaluation_strategy="steps",  # Add this to enable evaluation
            eval_steps=200,  # 100 adımda bir eval çalıştır
            save_strategy="steps",
            save_safetensors=200,
        ),
        callbacks=[RealTimePlottingCallback(log_file)],  # Add the callback here

    )

    gpu_stats = torch.cuda.get_device_properties(0)
    start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
    max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)
    print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.")
    print(f"{start_gpu_memory} GB of memory reserved.")
    
    trainer_stats = trainer.train()

    FastLanguageModel.for_inference(model) # Enable native 2x faster inference
    
    while True:
        user_instruction = input("Lütfen talimatı girin (Çıkmak için 'exit' yazın): ")
        if user_instruction.lower() == 'exit':
            break
        
        user_input = input("Lütfen giriş verisini girin: ")
        
        inputs = tokenizer(
            [alpaca_prompt.format(user_instruction, user_input, "")],
            return_tensors="pt"
        ).to("cuda")
        
        outputs = model.generate(**inputs, max_new_tokens=64, use_cache=True)
        
        result = tokenizer.batch_decode(outputs, skip_special_tokens=True)
        print("Model Çıktısı:", result[0])
    

    print("saving...")
    
    
    model.save_pretrained("model_safetensors", safe_serialization=True)
    tokenizer.save_pretrained("model_safetensors")


    print("succesffully...")

Eğitilen Lora ile Asıl Modeli Birleştirme

Lora ile eğitim yaptığımızda kaydedilen dosya adapter.safetensor dosyası sadece lora katmanlarını içerir. Tüm modeli oluşturmak için bu adapter ile modeli merge etmek gerekiyor.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
from unsloth import FastLanguageModel 

max_seq_length = 2048 # Choose any! We auto support RoPE Scaling internally!
dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
load_in_4bit = True # Use 4bit quantization to reduce memory usage. Can be False.


# Ana model ve adaptör yolu
# base_model_path = "path/to/base_model"  # Ana modelin Hugging Face yolunu veya dizinini gir
adapter_path = "model_safetensors"  # LoRA adaptörünün tam yolu

# Model ve tokenizer'ı yükle
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Llama-3.2-3B-Instruct",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
)
# LoRA adaptörünü yükle
model = PeftModel.from_pretrained(model, adapter_path)
model = model.merge_and_unload()  # LoRA katmanlarını ana modele entegre eder

# Birleştirilmiş modeli kaydet
merged_model_path = "merged_model"
model.save_pretrained(merged_model_path)
tokenizer.save_pretrained(merged_model_path)

print(f"Model başarıyla birleştirildi ve {merged_model_path} klasörüne kaydedildi.")