Büyük Dil Modellerini İnce Ayar Neden Zorlu Bir Süreçtir?

Büyük dil modellerini (LLM) özel veri setlerinizle kişiselleştirmek mi istiyorsunuz ancak yüksek maliyetler ve kaynak gereksinimleri gözünüzü mü korkutuyor? LoRA (Low-Rank Adaptation) tekniği, bu zorlukların üstesinden gelerek modellerinizi verimli bir şekilde ince ayarlamanıza olanak tanır. Bu rehberde, LoRA’nın temel prensiplerinden adım adım uygulamasına, özel veri seti hazırlığından ileri düzey ipuçlarına kadar her şeyi bulacaksınız.

Büyük Dil Modellerini İnce Ayar Neden Zorlu Bir Süreçtir?

Günümüzün yapay zeka dünyasında, ChatGPT gibi büyük dil modelleri (LLM’ler) hayatımızın vazgeçilmez bir parçası haline geldi. Bu modeller, milyarlarca parametreye sahip olup internetteki devasa metin verileri üzerinde eğitilmişlerdir. Bu geniş bilgi tabanı sayesinde, genel soruları yanıtlama, metin üretme, çeviri yapma gibi birçok karmaşık görevi başarıyla yerine getirebilirler. Ancak, bir LLM’in genel yeteneklerinin ötesine geçerek belirli bir sektöre, şirket kültürüne veya özel bir göreve özgü bilgiyle donatılmasını istediğimizde, “ince ayar” (fine-tuning) süreci devreye girer. Peki, bu süreç neden bu kadar zorlu ve kaynak yoğun olabilir?

Geleneksel ince ayar yönteminde, önceden eğitilmiş bir modelin tüm parametreleri, yeni ve daha küçük bir veri seti üzerinde tekrar eğitilir. Bu, modelin belirli bir göreve veya veri dağılımına adapte olmasını sağlar. Ancak, bir LLM’in yüz milyarlarca parametresi olduğunu düşündüğümüzde, bu yaklaşımın beraberinde getirdiği zorluklar şunlardır:

• Yüksek Hesaplama Maliyeti: Tüm parametreleri eğitmek, devasa miktarda işlem gücü (GPU/TPU) ve zaman gerektirir. Bu durum, küçük ve orta ölçekli şirketler veya bireysel geliştiriciler için erişilemez maliyetler anlamına gelebilir. Her bir ince ayar denemesi, günler hatta haftalar sürebilir.
• Büyük Bellek İhtiyacı: Modelin tüm parametreleri ve optimizasyon durumları bellekte tutulmalıdır. Bu, terabaytlarca belleğe sahip özel sunucular veya bulut tabanlı yüksek performanslı sanal makineler gerektirir. Özellikle 16-bit veya 32-bit hassasiyette eğitim yapılıyorsa, bellek tüketimi katlanarak artar.
• Depolama ve Sürüm Kontrolü Zorlukları: İnce ayarlı modelin tamamını her seferinde kaydetmek, yüzlerce gigabaytlık depolama alanı gerektirir. Farklı ince ayar denemeleri ve model versiyonları arasında geçiş yapmak, büyük dosya boyutları nedeniyle oldukça hantal hale gelir. Bu da sürüm kontrolünü ve model yönetimini karmaşıklaştırır.
• Aşırı Uyum (Overfitting) Riski: Küçük bir özel veri seti üzerinde çok fazla parametreyi eğitmek, modelin sadece o veri setindeki örüntüleri ezberlemesine ve genelleme yeteneğini kaybetmesine neden olabilir. Bu durum, modelin yeni ve benzer veriler üzerinde kötü performans göstermesiyle sonuçlanır.
• Çevre Dostu Değil: Yüksek enerji tüketimi, yapay zeka eğitiminin karbon ayak izini önemli ölçüde artırır. Sürdürülebilirlik açısından, daha verimli eğitim yöntemlerine ihtiyaç duyulmaktadır.

Bu zorluklar, geliştiricileri ve araştırmacıları, büyük dil modellerini daha verimli bir şekilde ince ayarlamanın yollarını aramaya itmiştir. İşte tam da bu noktada, LoRA gibi parametre-verimli ince ayar (PEFT – Parameter-Efficient Fine-Tuning) teknikleri devreye girerek, geleneksel ince ayarın getirdiği yükleri hafifletmeyi hedefler. Bu teknikler, modelin yalnızca küçük bir kısmını veya ek parametreleri eğiterek, benzer performans elde etmeyi mümkün kılar. Böylece, hem maliyetler düşer hem de ince ayar süreci hızlanır, daha geniş bir geliştirici kitlesi için erişilebilir hale gelir. Bu durum, yapay zekanın daha demokratikleşmesine ve daha fazla alanda kişiselleştirilmiş uygulamaların geliştirilmesine olanak tanır.

LoRA (Low-Rank Adaptation) Nedir ve Nasıl Çalışır?

Büyük dil modellerini ince ayar yapmanın getirdiği zorlukları ele aldıktan sonra, şimdi bu sorunlara zarif bir çözüm sunan LoRA (Low-Rank Adaptation) tekniğine daha yakından bakalım. LoRA, parametre-verimli ince ayar (PEFT) yöntemlerinden biridir ve temel amacı, çok sayıda parametreye sahip büyük modelleri, çok daha az ek parametre eğiterek belirli görevlere adapte etmektir. Bu sayede, hesaplama maliyeti, bellek tüketimi ve depolama ihtiyacı önemli ölçüde azaltılırken, orijinal modelin performansına yakın sonuçlar elde edilebilir.

LoRA’nın Temel Prensibi: Düşük Rank Matrisler

LoRA’nın arkasındaki ana fikir, önceden eğitilmiş bir modeldeki her bir ağırlık matrisinin (örneğin, dikkat mekanizmalarındaki sorgu, anahtar, değer veya çıktı projeksiyon matrisleri), ince ayar sırasında maruz kaldığı değişimin düşük ranklı bir matrisle temsil edilebileceği varsayımıdır. Matematiksel olarak ifade etmek gerekirse, orijinal bir ağırlık matrisi W‘nin ince ayar sonrası değişimi ΔW olarak düşünülebilir. LoRA, bu ΔW‘yi doğrudan eğitmek yerine, onu iki küçük matrisin çarpımı olarak ifade eder: B * A. Burada A ve B, orijinal W matrisinden çok daha az parametreye sahip matrislerdir.

Örneğin, W matrisi d x k boyutunda ise, B matrisi d x r boyutunda ve A matrisi r x k boyutunda olacaktır. Burada r (rank), d ve k‘den çok daha küçük bir sayıdır (genellikle 4, 8, 16 gibi değerler alır). Bu, ΔW‘yi doğrudan eğitmek yerine, sadece A ve B matrislerindeki parametreleri eğittiğimiz anlamına gelir. Toplam eğitilebilir parametre sayısı, d * r + r * k olur ki bu, d * k‘ye kıyasla çok daha küçüktür.

LoRA’nın Mimari ve Parametre Verimliliği

LoRA’nın çalışma mekanizması şu adımları içerir:

1. Orijinal Model Sabit Kalır: Önceden eğitilmiş büyük dil modelinin (LLM) ana ağırlıkları, ince ayar süreci boyunca dondurulur ve güncellenmez. Bu, modelin temel bilgisini korumasını sağlar ve aşırı uyumu engellemeye yardımcı olur.
2. Ek LoRA Matrisleri: Modelin belirli katmanlarına (genellikle dikkat mekanizmalarındaki sorgu ve değer projeksiyon matrisleri) küçük, düşük ranklı A ve B matris çiftleri eklenir. Bu matrisler rastgele veya sıfırlarla başlatılabilir.
3. Eğitim Sadece LoRA Matrislerinde: İnce ayar sırasında, sadece bu eklenen A ve B matrislerinin parametreleri eğitilir. Orijinal model ağırlıkları sabit kaldığı için, geriye yayılım (backpropagation) sadece bu küçük matrisler üzerinden yapılır.
4. Çıkarım (Inference) Sırasında Birleştirme: Eğitim tamamlandıktan sonra, eğitilmiş B * A matrisi, orijinal W matrisine eklenerek (W’ = W + B * A) yeni, ince ayarlı bir ağırlık matrisi oluşturulur. Bu birleştirme, çıkarım sırasında herhangi bir ek hesaplama yükü getirmez, çünkü artık tek bir matris olarak işlem görür. Alternatif olarak, W ve B * A ayrı tutulup, çıkarım sırasında dinamik olarak toplanabilir. Bu, farklı LoRA adaptörlerini aynı temel model üzerinde hızlıca değiştirmeye olanak tanır.

Sonuç olarak, LoRA, büyük dil modellerinin kişiselleştirilmesi için oyunun kurallarını değiştiren bir yaklaşımdır. Geleneksel ince ayarın getirdiği yüksek maliyetleri ve teknik engelleri aşarak, yapay zekayı daha erişilebilir ve uygulanabilir hale getirir. Bu da daha fazla geliştiricinin ve kuruluşun, kendi özel ihtiyaçlarına göre uyarlanmış güçlü yapay zeka modelleri oluşturmasına olanak tanır.

Özel Veri Seti Hazırlığı: LoRA İçin Nelere Dikkat Etmeliyiz?

LoRA ile başarılı bir ince ayar süreci gerçekleştirmek, büyük ölçüde kaliteli ve iyi hazırlanmış bir özel veri setine bağlıdır. Model ne kadar gelişmiş olursa olsun, eğitildiği verinin kalitesi ve formatı, elde edilecek sonuçları doğrudan etkiler. Bu bölümde, LoRA için özel veri setinizi nasıl hazırlayacağınızı ve nelere dikkat etmeniz gerektiğini adım adım inceleyeceğiz.

1. Veri Toplama ve Temizleme: Kalite Her Şeyden Önemlidir

Özel veri setinizin ilk adımı, ilgili verileri toplamaktır. Bu veriler, şirketinizin dahili belgeleri, müşteri destek kayıtları, ürün incelemeleri, belirli bir alandaki makaleler veya herhangi bir metin tabanlı kaynak olabilir. Veri toplandıktan sonra, ham veriyi doğrudan kullanmak yerine kapsamlı bir temizlik sürecinden geçirmek hayati önem taşır:

• Gürültü Giderme: Reklamlar, menü öğeleri, anlamsız karakter dizileri gibi alakasız veya tekrarlayan içerikleri kaldırın.
• Benzersiz İçerik Sağlama: Yinelenen kayıtları tespit edin ve silin. Modelin aynı bilgiyi tekrar tekrar öğrenmesini engeller ve eğitim süresini optimize eder.
• Biçimlendirme ve Tutarlılık: Metinleri tek tip bir biçime getirin. Örneğin, tüm metinleri küçük harfe çevirme (eğer büyük/küçük harf ayrımı önemli değilse), noktalama işaretlerini standartlaştırma gibi işlemler yapın.
• Yanlış Bilgileri Ayıklama: Verilerinizde yanlış veya yanıltıcı bilgiler varsa, bunları düzeltin veya çıkarın. Modeliniz, eğitim aldığı veriyi yansıtacaktır, bu nedenle yanlış veri, yanlış çıktılara yol açar.
• Hassas Veri Yönetimi: Kişisel tanımlayıcı bilgileri (PII) veya hassas şirket bilgilerini maskeleyin veya anonimleştirin.

2. Veri Formatı: Modelin Anlayacağı Dil

Çoğu ince ayar çerçevesi (özellikle Hugging Face ekosisteminde), veri setlerini belirli bir formatta bekler. En yaygın ve esnek formatlardan biri JSON Lines (JSONL) formatıdır. Her satırın bir JSON nesnesi olduğu bu format, metin ve ilgili etiketleri veya yönergeleri saklamak için idealdir. Örneğin, bir soru-cevap botu eğitiyorsanız, her JSON nesnesi bir “prompt” (istek) ve bir “completion” (tamamlama) alanı içerebilir:

{"prompt": "Ürününüz X'in garanti süresi nedir?", "completion": "Ürün X için standart garanti süresi 2 yıldır."}
{"prompt": "Fatura bilgilerimi nasıl güncelleyebilirim?", "completion": "Fatura bilgilerinizi güncellemek için müşteri panelinize giriş yapıp 'Hesap Ayarları' bölümüne gidebilirsiniz."}

Eğer modelinizi sohbet botu gibi diyaloglar için eğitiyorsanız, format biraz daha karmaşık olabilir ve ‘messages’ alanı altında ‘role’ ve ‘content’ çiftlerini içerebilir:

{"messages": [{"role": "user", "content": "Merhaba, ürün iadesi yapmak istiyorum."}, {"role": "assistant", "content": "Elbette, iade işlemleri için sipariş numaranızı ve iade nedeninizi belirtebilir misiniz?"}]}
{"messages": [{"role": "user", "content": "Hesabımı nasıl kapatabilirim?"}, {"role": "assistant", "content": "Hesabınızı kapatmak için güvenlik doğrulaması yapmamız gerekiyor. Lütfen e-posta adresinizi ve kayıtlı telefon numaranızın son dört hanesini girin."}]}

Bu format, modelin hangi metnin kullanıcıdan geldiğini (prompt/user) ve hangi metnin model tarafından üretilmesi gerektiğini (completion/assistant) anlamasına yardımcı olur.

3. Veri Miktarı ve Çeşitliliği: Ne Kadar Yeterlidir?

LoRA, geleneksel ince ayara göre çok daha az veriyle iyi sonuçlar verebilse de, veri miktarı ve çeşitliliği hala önemlidir:

• Miktar: Kesin bir sayı olmamakla birlikte, birkaç yüz ila birkaç bin yüksek kaliteli örnekle başlayabilirsiniz. Çok küçük veri setleri (örneğin 50 örnekten az) genellikle yetersiz kalır ve modelin genelleme yeteneğini geliştirmez.
• Çeşitlilik: Modelin farklı senaryoları ve dil varyasyonlarını anlaması için veri setinizde yeterli çeşitlilik olmalıdır. Sadece tek tip sorular veya ifadelerle eğitilmiş bir model, benzer olmayan yeni girdilere zayıf yanıtlar verebilir.
• Denge: Eğer farklı kategoriler veya niyetler arasında ayrım yapıyorsanız, her kategori için yeterli örnek olduğundan emin olun. Aksi takdirde, model az temsil edilen kategorilerde zayıf performans gösterebilir.

4. Eğitim ve Doğrulama Setlerinin Ayrılması

Veri setinizi hazırlarken, modelin eğitim sırasında görmediği veriler üzerinde performansını değerlendirebilmek için verilerinizi eğitim (%80-90) ve doğrulama (%10-20) setlerine ayırmayı unutmayın. Doğrulama seti, modelin aşırı uyum yapıp yapmadığını anlamanıza ve hiperparametreleri ayarlamanıza yardımcı olur.

import pandas as pd
from sklearn.model_selection import train_test_split
import json

# Örnek veri seti oluşturma
data = [
    {"prompt": "Ürün A'nın özellikleri nelerdir?", "completion": "Ürün A, 12MP kamera, 6.1 inç ekran ve 256GB depolama ile gelir."},
    {"prompt": "Ürün B'nin fiyatı ne kadar?", "completion": "Ürün B'nin güncel fiyatı 1200 TL'dir."},
    {"prompt": "İade politikası hakkında bilgi verir misiniz?", "completion": "İade politikamız, ürün teslimatından sonra 14 gün içinde geçerlidir."},
    {"prompt": "Siparişimi nasıl takip edebilirim?", "completion": "Siparişinizi takip etmek için 'Siparişlerim' sayfasını ziyaret edebilirsiniz."},
    {"prompt": "Ürün A stokta var mı?", "completion": "Evet, Ürün A şu anda stoklarımızda mevcuttur."},
    {"prompt": "Ürün B'nin renk seçenekleri nelerdir?", "completion": "Ürün B gümüş, siyah ve mavi renk seçenekleriyle sunulmaktadır."},
    {"prompt": "Müşteri hizmetleri telefon numaranız nedir?", "completion": "Müşteri hizmetlerimize 0850 123 4567 numaralı telefondan ulaşabilirsiniz."},
    {"prompt": "Ürün C'nin kurulumu nasıl yapılır?", "completion": "Ürün C'nin kurulumu için kutu içerisindeki kullanım kılavuzunu inceleyebilirsiniz."},
    {"prompt": "Garanti belgesini nereden bulabilirim?", "completion": "Garanti belgesi ürününüzle birlikte gönderilir ve web sitemizden de indirilebilir."},
    {"prompt": "Ödeme yöntemleri nelerdir?", "completion": "Kredi kartı, banka havalesi ve kapıda ödeme seçeneklerimiz mevcuttur."}
]

df = pd.DataFrame(data)

# Veriyi eğitim ve test setlerine ayırma
train_df, eval_df = train_test_split(df, test_size=0.2, random_state=42)

# JSONL formatında kaydetme
with open("train_data.jsonl", "w", encoding="utf-8") as f:
    for record in train_df.to_dict(orient="records"):
        f.write(json.dumps(record, ensure_ascii=False) + "\n")

with open("eval_data.jsonl", "w", encoding="utf-8") as f:
    for record in eval_df.to_dict(orient="records"):
        f.write(json.dumps(record, ensure_ascii=False) + "\n")

print("Veri setleri başarıyla oluşturuldu: train_data.jsonl ve eval_data.jsonl")

Özel veri setinizi bu prensiplere göre hazırlamak, LoRA ile ince ayar yaparken modelinizin en iyi performansı göstermesini sağlayacak temel adımlardan biridir. Kaliteli veri, başarılı bir yapay zeka uygulamasının anahtarıdır.

LoRA ile İnce Ayar Nasıl Yapılır? Adım Adım Uygulama Rehberi

Özel veri setimizi hazırladıktan sonra, sıra geldi LoRA’yı kullanarak büyük dil modelimizi (LLM) ince ayarlamaya. Bu bölümde, Hugging Face ekosistemini kullanarak LoRA ile ince ayar yapmanın adım adım nasıl gerçekleştirileceğini, gerekli kod blokları ve açıklamalarla birlikte ele alacağız. Bu rehber, temel Python bilgisine sahip herkesin takip edebileceği şekilde tasarlanmıştır.

1. Gerekli Kütüphanelerin Kurulumu

İlk olarak, LoRA ile ince ayar yapmak için gerekli olan Python kütüphanelerini kurmamız gerekiyor. Bu kütüphaneler şunlardır:

• transformers: Hugging Face’in popüler kütüphanesi, önceden eğitilmiş modelleri ve tokenizer’ları kolayca yüklememizi sağlar.
• peft: Parameter-Efficient Fine-Tuning (PEFT) kütüphanesi, LoRA gibi verimli ince ayar yöntemlerini uygulamak için özel olarak tasarlanmıştır.
• bitsandbytes: Modelleri nicemleme (quantization) yaparak bellek kullanımını azaltmamızı sağlayan bir kütüphanedir. Özellikle büyük modellerle çalışırken çok faydalıdır.
• accelerate: Dağıtık eğitimi kolaylaştıran bir kütüphane olsa da, tek GPU üzerinde bile eğitim döngüsünü basitleştirmek için kullanılabilir.
• datasets: Veri setlerini yüklemek ve işlemek için kullanılır.

!pip install transformers peft bitsandbytes accelerate datasets

2. Model ve Tokenizer Yükleme

LoRA ile ince ayar yapacağımız temel modeli ve ona uygun tokenizer’ı Hugging Face Hub’dan yüklememiz gerekiyor. Burada örnek olarak bir Llama 2 modelini kullanacağız, ancak istediğiniz başka bir modeli de seçebilirsiniz.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# Kullanılacak temel modelin adı
model_name = "meta-llama/Llama-2-7b-hf" # Bu model için erişim izni gerekebilir, alternatif olarak "mistralai/Mistral-7B-v0.1" kullanılabilir.

# 4-bit nicemleme (quantization) konfigürasyonu
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=False,
)

# Modeli ve tokenizer'ı yükleme
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto" # Birden fazla GPU varsa otomatik dağıtımı sağlar
)
model.config.use_cache = False # Eğitim sırasında önbelleği devre dışı bırak
model.config.pretraining_tp = 1 # Çoklu GPU pretraining ayarı

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token # Pad token'ı EOS token olarak ayarla
tokenizer.padding_side = "right" # Tokenizer padding yönü

Burada BitsAndBytesConfig kullanarak modeli 4-bit nicemleme ile yüklüyoruz. Bu, modelin bellek ayak izini önemli ölçüde azaltır ve daha az GPU belleğiyle çalışmamızı sağlar. device_map="auto" parametresi, modelin katmanlarını mevcut GPU’lara otomatik olarak dağıtmaya çalışır.

3. LoRA Konfigürasyonu

Şimdi PEFT kütüphanesinden LoraConfig nesnesini oluşturarak LoRA’nın nasıl uygulanacağını tanımlayacağız. Bu konfigürasyon, hangi katmanlara LoRA adaptörlerinin ekleneceğini, düşük rank (r) değerini ve ölçeklendirme faktörünü (lora_alpha) belirler.

from peft import LoraConfig, get_peft_model

# LoRA konfigürasyonu
lora_alpha = 16 # Ölçeklendirme faktörü
lora_dropout = 0.1 # Dropout oranı
lora_r = 64 # Düşük rank değeri

peft_config = LoraConfig(
    lora_alpha=lora_alpha,
    lora_dropout=lora_dropout,
    r=lora_r,
    bias="none", # Bias parametrelerini eğitme
    task_type="CAUSAL_LM", # Görev tipi: Nedensel Dil Modelleme
    target_modules=[ # LoRA'nın uygulanacağı katmanlar (model mimarisine göre değişebilir)
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
        "lm_head",
    ]
)

# Temel modele LoRA adaptörlerini ekle
model = get_peft_model(model, peft_config)
model.print_trainable_parameters() # Eğitilebilir parametre sayısını göster

print_trainable_parameters() çıktısı, modelin toplam parametrelerinin çok küçük bir yüzdesinin eğitileceğini gösterir. Bu, LoRA’nın parametre verimliliğinin somut bir kanıtıdır.

4. Veri Setinin Hazırlanması

Daha önce hazırladığımız JSONL formatındaki veri setimizi Hugging Face datasets kütüphanesi ile yükleyeceğiz ve modelin anlayacağı formata dönüştüreceğiz. Bu genellikle metinleri tokenize etme ve uygun formatta etiketleme adımlarını içerir.

from datasets import load_dataset

# Özel veri setini yükleme
dataset = load_dataset("json", data_files={"train": "train_data.jsonl", "validation": "eval_data.jsonl"})

# Veriyi formatlama fonksiyonu (örn: sohbet formatı için)
def format_data_for_training(example):
    # Bu fonksiyonu veri setinizin yapısına göre özelleştirmeniz gerekecektir.
    # Örnek: "prompt" ve "completion" alanları olan bir veri seti için
    formatted_text = f"# İSTEK:\n{example['prompt']}\n\n### YANIT:\n{example['completion']}{tokenizer.eos_token}"
    return {"text": formatted_text}

# Veriyi işleme (tokenize etme)
def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, max_length=512) # Max uzunluğu ayarlayın

# Veri setini formatla ve tokenize et
formatted_dataset = dataset.map(format_data_for_training, remove_columns=["prompt", "completion"])
tokenized_dataset = formatted_dataset.map(preprocess_function, batched=True)

print(tokenized_dataset["train"][0]) # Tokenize edilmiş ilk örneği görüntüle

format_data_for_training fonksiyonunu kendi veri setinizin yapısına göre uyarlamanız çok önemlidir. Genellikle, modelin belirli bir formatta (örneğin, “# İSTEK: … ### YANIT: …” gibi) girdi ve çıktı beklediği durumlarda bu formatlama adımına ihtiyaç duyulur.

5. Eğitim Süreci

Son olarak, transformers kütüphanesinden TrainingArguments ve Trainer sınıflarını kullanarak modeli eğiteceğiz. Bu aşamada, öğrenme oranı, epoch sayısı, batch boyutu gibi hiperparametreleri belirleriz.

from transformers import TrainingArguments, Trainer
import os

# Eğitim argümanları
training_arguments = TrainingArguments(
    output_dir="./results", # Eğitim çıktıları için dizin
    num_train_epochs=3, # Eğitim epoch sayısı
    per_device_train_batch_size=4, # Cihaz başına eğitim batch boyutu
    gradient_accumulation_steps=2, # Gradyan biriktirme adımları
    optim="paged_adamw_8bit", # Optimize edici (bellek verimliliği için)
    save_steps=100, # Her 100 adımda bir modeli kaydet
    logging_steps=10, # Her 10 adımda bir loglama yap
    learning_rate=2e-4, # Öğrenme oranı
    weight_decay=0.001, # Ağırlık azaltma
    fp16=False, # Yarı hassasiyetli eğitimi etkinleştir (GPU destekliyorsa True yapın)
    bf16=True, # Bfloat16 eğitimi etkinleştir (GPU destekliyorsa True yapın)
    max_grad_norm=0.3, # Maksimum gradyan normu
    max_steps=-1, # Adım sayısı (epoch sayısı ile çakışır, -1 sınırsız anlamına gelir)
    warmup_ratio=0.03, # Isınma oranı
    group_by_length=True, # Benzer uzunluktaki örnekleri grupla
    lr_scheduler_type="cosine", # Öğrenme oranı zamanlayıcı tipi
    report_to="tensorboard", # Eğitim metriklerini TensorBoard'a raporla
    evaluation_strategy="steps", # Doğrulama stratejisi
    eval_steps=100, # Her 100 adımda bir doğrulama yap
)

# Trainer oluşturma
trainer = Trainer(
    model=model,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["validation"],
    args=training_arguments,
    data_collator=None, # Veri toplama fonksiyonu (tokenizer'ın kendisi halleder)
)

# Modeli eğit
trainer.train()

# Eğitilmiş LoRA adaptörünü kaydet
trainer.model.save_pretrained("./lora_model")

# İsterseniz adaptörü temel modelle birleştirip kaydedebilirsiniz
# merged_model = model.merge_and_unload()
# merged_model.save_pretrained("./merged_llama_lora")
# tokenizer.save_pretrained("./merged_llama_lora")

Eğitim tamamlandıktan sonra, eğitilmiş LoRA adaptörleri ./lora_model dizinine kaydedilecektir. Bu adaptörler, daha sonra orijinal temel model üzerine yüklenebilir ve çıkarım için kullanılabilir. model.merge_and_unload() fonksiyonu, LoRA adaptörlerini temel modelle kalıcı olarak birleştirmenize olanak tanır, böylece tek bir birleşik model elde edersiniz.

Bu adımları takip ederek, kendi özel veri setinizle LoRA kullanarak bir büyük dil modelini başarılı bir şekilde ince ayarlayabilirsiniz. Unutmayın ki hiperparametreler (lora_alpha, lora_r, learning_rate vb.) ve veri setinin kalitesi, elde edeceğiniz sonuçlar üzerinde büyük etkiye sahip olacaktır. Deneme yanılma yoluyla en iyi konfigürasyonu bulmak genellikle gereklidir.

Bir Vaka Analizi: Müşteri Hizmetleri Botunu Kişiselleştirme

Şirketlerin karşılaştığı yaygın bir sorun, genel amaçlı yapay zeka modellerinin kendi özel ürünleri, hizmetleri ve şirket politikaları hakkında yeterli bilgiye sahip olmamasıdır. Bu durum, müşteri hizmetleri departmanları için bir yük oluşturabilir ve müşteri memnuniyetini düşürebilir. İşte LoRA’nın bu senaryoda nasıl bir çözüm sunduğuna dair bir vaka analizi:

Senaryo: “TechSolutions” Şirketi İçin Akıllı Müşteri Hizmetleri Botu

TechSolutions, çeşitli elektronik cihazlar üreten ve satan bir şirkettir. Müşterilerden gelen garanti sorguları, ürün teknik özellikleri, iade politikaları ve sorun giderme adımları hakkında yüz binlerce soru almaktadırlar. Mevcut genel amaçlı bir LLM (örneğin, Llama 2) bu soruların çoğunu genel bilgilerle yanıtlayabilse de, TechSolutions’ın spesifik ürün kodları, garanti süreleri, iade formları veya benzersiz sorun giderme kılavuzları hakkında bilgi verememektedir.

Hedef

TechSolutions, mevcut Llama 2 modelini, şirket içi dokümanları ve müşteri hizmetleri kayıtlarını kullanarak, kendi ürünleri ve politikaları hakkında doğru ve güncel bilgi sağlayabilen bir müşteri hizmetleri botuna dönüştürmek istemektedir. Bu dönüşümün hızlı, maliyet etkin ve yüksek performanslı olması beklenmektedir.

LoRA Çözümü

1. Özel Veri Seti Oluşturma:
   • Şirketin tüm ürün kılavuzları, SSS belgeleri, garanti koşulları, iade politikaları, teknik destek notları ve önceki müşteri sohbet kayıtları toplanır.
   • Bu veriler, “prompt” (müşteri sorusu) ve “completion” (bot yanıtı) çiftleri halinde JSONL formatına dönüştürülür. Örneğin:

     
     {"prompt": "TechSolutions X5 modelinin garanti süresi nedir?", "completion": "TechSolutions X5 modelinin standart garanti süresi 2 yıldır ve uzatılmış garanti seçeneği mevcuttur."}
     {"prompt": "X5 modelinde ekranım çalışmıyor, ne yapmalıyım?", "completion": "X5 modelinde ekran sorunu yaşıyorsanız, lütfen cihazı yeniden başlatın. Sorun devam ederse, teknik destek sayfamızdaki sorun giderme adımlarını takip edin veya bizimle iletişime geçin."}
                     

   • Yaklaşık 10.000 adet yüksek kaliteli, şirkete özel soru-cevap çifti oluşturulur.
2. LoRA ile İnce Ayar:
   • Önceden eğitilmiş Llama 2 modeli (7B parametre) 4-bit nicemleme ile yüklenir.
   • PEFT kütüphanesi kullanılarak bir LoraConfig nesnesi tanımlanır (örneğin, r=64, lora_alpha=16).
   • Hazırlanan özel veri seti, tokenizer aracılığıyla modele uygun hale getirilir.
   • Model, bir adet NVIDIA A100 GPU üzerinde sadece 3 epoch boyunca eğitilir.

Faydalar ve Sonuçlar

• Maliyet ve Zaman Tasarrufu: Geleneksel tam ince ayar, birden fazla pahalı GPU üzerinde haftalar sürebilirken, LoRA ile bu süreç tek bir A100 GPU’da birkaç saat içinde tamamlanır. Bu, TechSolutions’a on binlerce dolar tasarruf sağlar.
• Performans Artışı: İnce ayarlı LoRA modeli, genel Llama 2’ye kıyasla TechSolutions’ın ürünleri ve politikaları hakkında %90’ın üzerinde doğrulukla yanıt verebilir. Müşteri sorularına spesifik ve doğru cevaplar vererek müşteri memnuniyetini artırır.
• Kaynak Verimliliği: Eğitilen LoRA adaptörü sadece birkaç megabayt boyutundadır (örneğin, 60MB). Bu, modelin kolayca depolanabilmesi, dağıtılabilmesi ve farklı sürümlerinin yönetilebilmesi anlamına gelir. Temel modelin tamamını her seferinde kopyalamaya gerek kalmaz.
• Esneklik: TechSolutions, gelecekte yeni ürünler veya politikalar eklediğinde, sadece küçük bir ek veri setiyle mevcut LoRA adaptörünü güncelleyebilir veya yeni bir adaptör eğitebilir. Temel modeli baştan sona tekrar eğitmeye gerek kalmaz.
• Geliştirici Erişimi: Daha az kaynak gerektirdiğinden, şirket içindeki daha fazla geliştirici, kendi uygulamaları için kişiselleştirilmiş modeller üzerinde deney yapabilir ve bunları devreye alabilir.

Bu vaka analizi, LoRA’nın gerçek dünya senaryolarında, özellikle şirketlerin kendi spesifik ihtiyaçlarına göre büyük dil modellerini kişiselleştirmeleri gerektiğinde ne kadar değerli bir araç olduğunu göstermektedir. Hem maliyetleri düşürür hem de geliştirme sürecini hızlandırarak işletmelere rekabet avantajı sağlar.

Performans İpuçları ve İleri Düzey LoRA Teknikleri Nelerdir?

LoRA’nın temel uygulama adımlarını öğrendikten sonra, şimdi modelinizin performansını daha da artırmak ve kaynak kullanımını optimize etmek için kullanabileceğiniz ileri düzey ipuçlarına ve tekniklere göz atalım. Bu teknikler, özellikle daha büyük modellerle çalışırken veya sınırlı donanım kaynaklarına sahipken kritik öneme sahip olabilir.

1. Quantization (Nicemleme) ile Bellek Optimizasyonu

Daha önce de bahsettiğimiz gibi, 4-bit veya 8-bit nicemleme, modellerin bellek ayak izini önemli ölçüde azaltır. Bu, daha büyük modelleri daha az GPU belleğiyle çalıştırmanıza olanak tanır. BitsAndBytes kütüphanesi bu konuda harikalar yaratır:

• 4-bit Quantization (NF4/FP4): En popüler ve en verimli yöntemlerden biridir. Model ağırlıklarını 4-bit’e düşürerek bellek kullanımını 8 kat azaltır. Küçük bir performans kaybı yaşanabilir ancak çoğu durumda kabul edilebilir düzeydedir.
• 8-bit Quantization (Int8): Daha az bellek tasarrufu sağlar ancak genellikle 4-bit’e göre daha iyi performans sunar.

from transformers import BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,              # Modeli 4-bit olarak yükle
    bnb_4bit_quant_type="nf4",      # Nicemleme tipi (NormalFloat 4-bit)
    bnb_4bit_compute_dtype=torch.bfloat16, # Hesaplama sırasında kullanılacak veri tipi
    bnb_4bit_use_double_quant=True, # Çift nicemleme ile daha fazla bellek tasarrufu
)
# Modeli bu konfigürasyon ile yükleyin
# model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config, device_map="auto")

bnb_4bit_use_double_quant=True ayarı, nicemlenmiş sabitlerin de nicemlenmesini sağlayarak ek bir bellek tasarrufu sunar, ancak bu genellikle daha küçük bir fark yaratır.

2. LoRA Parametrelerinin Ayarlanması: r ve alpha

LoraConfig içindeki r (rank) ve lora_alpha parametreleri, LoRA adaptörlerinin boyutunu ve öğrenme kapasitesini doğrudan etkiler:

• r (Rank): LoRA matrislerinin iç boyutunu belirler. Daha yüksek bir r değeri, daha fazla eğitilebilir parametre anlamına gelir ve modelin daha karmaşık örüntüleri öğrenmesine olanak tanır. Ancak, çok yüksek bir r değeri, geleneksel ince ayara yaklaşır ve bellek/hesaplama maliyetlerini artırır. Genellikle 8, 16, 32 veya 64 gibi değerler kullanılır. Görevinizin karmaşıklığına göre denemeler yapın.
• lora_alpha: Ölçeklendirme faktörüdür. r değeri ne kadar büyükse, lora_alpha da o kadar büyük olmalıdır. Genellikle lora_alpha = 2 * r veya lora_alpha = r gibi oranlar kullanılır. Bu, LoRA katmanlarının çıktılarının ne kadar etkili olacağını kontrol eder. Daha yüksek bir lora_alpha, LoRA adaptörlerinin temel model üzerinde daha fazla etkiye sahip olmasını sağlar.

3. Öğrenme Oranı Zamanlayıcıları (Learning Rate Schedulers)

Eğitim sırasında öğrenme oranını dinamik olarak değiştirmek, modelin daha iyi yakınsamasına yardımcı olabilir. TrainingArguments içinde lr_scheduler_type parametresi ile farklı zamanlayıcılar seçebilirsiniz:

• “cosine”: Öğrenme oranını kosinüs eğrisi boyunca azaltır. Genellikle iyi performans gösterir.
• “linear”: Öğrenme oranını doğrusal olarak azaltır.
• “constant”: Öğrenme oranını sabit tutar.
• “warmup_ratio”: Eğitim başında öğrenme oranını yavaşça artırır (warmup), ardından seçilen zamanlayıcıya göre azaltır. Bu, modelin başlangıçta daha stabil öğrenmesine yardımcı olur.

training_arguments = TrainingArguments(
    # ... diğer argümanlar ...
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.03, # İlk %3'lük adımda öğrenme oranını artır
)

4. Çoklu LoRA Adaptörleri ve Birleştirme

Tek bir temel model üzerinde birden fazla LoRA adaptörü eğitebilirsiniz. Her adaptör farklı bir görev veya veri seti için optimize edilebilir. Çıkarım sırasında, istediğiniz adaptörü yükleyip kullanabilirsiniz:

from peft import PeftModel, PeftConfig

# Temel modeli yükle
base_model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config, device_map="auto")

# Eğitilmiş LoRA adaptörünü yükle
lora_model = PeftModel.from_pretrained(base_model, "./lora_model_task1")

# Başka bir LoRA adaptörünü yükle
# lora_model_task2 = PeftModel.from_pretrained(base_model, "./lora_model_task2")

Eğer LoRA adaptörünü temel modelle kalıcı olarak birleştirmek isterseniz, merge_and_unload() fonksiyonunu kullanabilirsiniz. Bu, çıkarım hızını hafifçe artırabilir ve tek bir model dosyası oluşturmanızı sağlar.

merged_model = lora_model.merge_and_unload()
merged_model.save_pretrained("./merged_model_task1")
tokenizer.save_pretrained("./merged_model_task1")

5. LoRA’nın Uygulanacağı Katmanların Seçimi (target_modules)

LoraConfig içindeki target_modules parametresi, LoRA adaptörlerinin hangi katmanlara ekleneceğini belirler. Genellikle dikkat mekanizmalarındaki lineer katmanlar (q_proj, k_proj, v_proj, o_proj) hedef alınır. Ancak, bazı modellerde MLP katmanlarına (gate_proj, up_proj, down_proj) veya hatta çıktı katmanına (lm_head) LoRA eklemek performansı artırabilir. Modelinizin mimarisini inceleyerek en uygun katmanları seçmeniz önemlidir.

peft_config = LoraConfig(
    # ...
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj", # MLP katmanı
        "up_proj",   # MLP katmanı
        "down_proj", # MLP katmanı
        # "lm_head", # Çıktı katmanı (bazen faydalı olabilir)
    ]
)

Bu ileri düzey teknikler ve ipuçları, LoRA ile ince ayar yaparken modelinizin performansını optimize etmenize ve mevcut kaynaklarınızı en verimli şekilde kullanmanıza yardımcı olacaktır. Her zaman olduğu gibi, en iyi sonuçlar için kendi veri setiniz ve modeliniz üzerinde farklı konfigürasyonlarla denemeler yapmaktan çekinmeyin.

Mobil Cihazlarda LoRA Modellerini Kullanmak Mümkün müdür?

Büyük dil modellerinin mobil cihazlarda doğrudan çalıştırılması, bellek, işlem gücü ve batarya ömrü kısıtlamaları nedeniyle geleneksel olarak zorlu bir görev olmuştur. Ancak LoRA gibi parametre-verimli ince ayar teknikleri ve model nicemleme (quantization) yöntemleri sayesinde, bu alanda önemli ilerlemeler kaydedilmiştir.

Mobil Uyumluluk ve Çıkarım (Inference) Hızı

LoRA’nın mobil cihazlarda kullanılabilirliğini artıran başlıca faktörler şunlardır:

1. Küçük Adaptör Boyutu: LoRA ile eğitilen adaptörler, temel modelin tamamına kıyasla çok küçüktür (genellikle megabayt düzeyinde). Bu, mobil cihazlara kolayca indirilebilir ve depolanabilir olmalarını sağlar. Temel modelin kendisi hala büyük olabilir, ancak cihazda yalnızca temel modelin nicemlenmiş versiyonu ve LoRA adaptörü tutulur.
2. Bellek Optimizasyonu: 4-bit veya 8-bit nicemleme teknikleri, temel modelin bellek ayak izini drastik şekilde azaltır. Bu, mobil cihazların sınırlı RAM’inde bile büyük modellerin (nicemlenmiş halleriyle) yüklenebilmesini mümkün kılar.
3. Hızlı Çıkarım: LoRA adaptörleri, çıkarım sırasında orijinal model ağırlıklarıyla birleştirildiğinde (merge_and_unload()), ek bir hesaplama yükü getirmezler. Bu, modelin çıkarım hızının (yani bir yanıt üretme süresinin) temel modelin nicemlenmiş versiyonuyla aynı olmasını sağlar. Bazı durumlarda, dinamik birleştirme (eğitim sırasında olduğu gibi) ek küçük bir gecikmeye neden olabilir, ancak bu genellikle ihmal edilebilir düzeydedir.
4. Özel Donanım Hızlandırma: Yeni nesil mobil işlemciler (örneğin Apple’ın Neural Engine’i, Qualcomm’un AI Engine’i), yapay zeka çıkarımı için özel donanım hızlandırma birimleri içerir. Bu birimler, nicemlenmiş modellerin çok daha verimli çalışmasını sağlar.

Özetle, LoRA ile ince ayar yapılmış ve nicemlenmiş bir büyük dil modeli, doğrudan mobil cihaz üzerinde veya bir kenar bilişim (edge computing) sunucusunda çalıştırılabilir. Bu, özellikle düşük gecikme süresi gerektiren, çevrimdışı çalışabilen veya veri gizliliğinin önemli olduğu uygulamalar için büyük avantajlar sunar.

Mobil Uyumlu HTML ve CSS Örnekleri

Mobil cihazlarda LoRA modellerini kullanan bir web uygulaması geliştirirken, kullanıcı arayüzünün (UI) de mobil uyumlu olması esastır. Responsive tasarım, farklı ekran boyutlarına ve yönelimlerine uyum sağlayarak kullanıcı deneyimini iyileştirir. İşte basit bir CSS media query örneği:

/* Genel stil tanımlamaları */
body {
    font-family: Arial, sans-serif;
    margin: 0;
    padding: 0;
    background-color: #f4f4f4;
    color: #333;
}

.container {
    max-width: 1200px;
    margin: 20px auto;
    padding: 20px;
    background-color: #fff;
    border-radius: 8px;
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.chat-input {
    width: 100%;
    padding: 10px;
    border: 1px solid #ddd;
    border-radius: 4px;
    box-sizing: border-box; /* Padding'in genişliği etkilemesini engeller */
}

/* Mobil cihazlar için özel stiller (örneğin, ekran genişliği 768px'den küçükse) */
@media (max-width: 768px) {
    .container {
        margin: 10px;
        padding: 15px;
    }

    h2 {
        font-size: 1.5em;
    }

    .chat-input {
        padding: 8px;
    }
    
    /* Örneğin, mobil cihazlarda yan menüyü gizle */
    .sidebar {
        display: none;
    }
}

/* Daha küçük telefon ekranları için (örneğin, 480px'den küçükse) */
@media (max-width: 480px) {
    .container {
        margin: 5px;
        padding: 10px;
    }

    h2 {
        font-size: 1.2em;
    }
}

Bu CSS kodu, ekran genişliğine göre .container ve .chat-input gibi elementlerin stilini ayarlayarak uygulamanın mobil cihazlarda daha iyi görünmesini sağlar. Bu tür responsive tasarım prensipleri, LoRA destekli mobil uygulamaların kullanıcı dostu olmasında önemli bir rol oynar.

Sonuç ve Sıkça Sorulan Sorular

Bu makalede, büyük dil modellerinin (LLM) ince ayar süreçlerinin zorluklarından başlayarak, LoRA (Low-Rank Adaptation) tekniğinin bu zorluklara nasıl yenilikçi bir çözüm sunduğunu detaylı bir şekilde inceledik. LoRA’nın parametre verimliliği sayesinde, özel veri setleriyle kişiselleştirilmiş LLM’leri çok daha az hesaplama gücü, bellek ve zaman harcayarak eğitebileceğimizi gördük. Özel veri seti hazırlığından adım adım uygulama rehberine, vaka analizlerinden ileri düzey optimizasyon tekniklerine kadar geniş bir yelpazede LoRA’nın gücünü ve esnekliğini ele aldık. Özellikle mobil cihazlarda dahi LoRA ile ince ayarlı modellerin kullanılabilirliği, bu teknolojinin erişilebilirliğini ve uygulama potansiyelini bir kez daha ortaya koymaktadır.

LoRA, yapay zeka dünyasında, özellikle kişiselleştirilmiş ve niş uygulamalar geliştirmek isteyenler için vazgeçilmez bir araç haline gelmiştir. Geliştiricilerin daha az kaynakla daha fazla deney yapmasına olanak tanıyarak, yapay zeka inovasyonunu demokratikleştirmektedir. Gelecekte, LoRA ve benzeri PEFT tekniklerinin daha da gelişerek, daha karmaşık görevlerde ve daha çeşitli donanım ortamlarında yaygınlaşmasını bekleyebiliriz.

Sıkça Sorulan Sorular

1. LoRA, tüm ince ayar senaryoları için en iyi çözüm müdür?

   LoRA, çoğu senaryo için harika bir parametre-verimli çözüm olsa da, her zaman en iyi çözüm olmayabilir. Çok küçük ve spesifik görevler için tam ince ayar, bazen daha yüksek performans sunabilir. Ancak, maliyet, bellek ve zaman kısıtlamaları olan durumlarda LoRA genellikle üstün bir seçenektir.

2. LoRA ile eğitilmiş bir modeli nasıl dağıtabilirim?

   LoRA ile eğitilmiş bir modeli dağıtmanın iki ana yolu vardır:

   1. Temel modeli nicemlenmiş haliyle ve LoRA adaptörünü ayrı ayrı dağıtıp, çıkarım sırasında birleştirme. Bu, farklı adaptörleri kolayca değiştirmenize olanak tanır.
   2. LoRA adaptörünü temel modelle kalıcı olarak birleştirip (merge_and_unload()) tek bir birleşik model olarak dağıtma. Bu, genellikle daha basit bir dağıtım süreci sunar.
3. LoRA’nın performansını etkileyen en önemli faktörler nelerdir?

   LoRA’nın performansını etkileyen en önemli faktörler şunlardır: özel veri setinin kalitesi ve boyutu, temel modelin gücü, r ve lora_alpha gibi LoRA hiperparametreleri, öğrenme oranı ve öğrenme oranı zamanlayıcısı gibi eğitim hiperparametreleri ve LoRA’nın uygulandığı katmanların seçimi.

4. LoRA, farklı dillerdeki modellerle de çalışır mı?

   Evet, LoRA dil agnostic bir tekniktir. Eğer temel model belirli bir dilde (örneğin Türkçe) iyi eğitilmişse, LoRA’yı kullanarak o modelin Türkçe özel veri setleriyle ince ayarını yapabilirsiniz. Önemli olan, temel modelin ve veri setinin uyumlu olmasıdır.