Büyük Dil Modelleri (LLM’ler), özellikle doğal dil işleme için, modern yapay zekâ uygulamalarının başlıca bileşenleridir. Sanal asistanlardan makine çevirisine, metin özetlemeden soru-cevaplamaya kadar uzanan kullanım alanlarıyla, insan dilini verimli bir şekilde işleme ve anlama potansiyeline sahiptirler.
LangChain gibi kütüphaneler, yukarıda bahsedilen türden uçtan uca yapay zekâ uygulamalarının hayata geçirilmesini kolaylaştırır. Veri Mühendisliği ve Veri Uygulamaları için LangChain’e Giriş adlı eğitimimiz, LangChain ile neler yapabileceğinize, LangChain’in çözdüğü problemlere ve veri kullanım örneklerine genel bir bakış sunar.
Bu makale, çalışma alanının kurulmasından PyTorch 2.0.1 kullanılarak yapılan son uygulamaya kadar, büyük bir dil modelini eğitme sürecinin tamamını açıklayacaktır. PyTorch, net ve kolay bir model uygulamasına imkân veren dinamik ve esnek bir derin öğrenme çatısıdır.
Önkoşullar
Bu içerikten en iyi şekilde yararlanmak için Python programlamada rahat olmanız, derin öğrenme kavramları ve transformer’lar hakkında temel bilgiye sahip olmanız ve PyTorch çatısına aşina olmanız önemlidir. Tüm kaynak kodu GitHub’da mevcut olacaktır.
Temel uygulamaya dalmadan önce ilgili kütüphaneleri kurup içe aktarmamız gerekiyor. Ayrıca, eğitim betiğinin Hugging Face’teki bu depodan esinlendiğini not etmek önemlidir.
Kütüphane kurulumu
Kurulum süreci aşağıda ayrıntılandırılmıştır:
Öncelikle, Jupyter Notebook’ta tek bir hücrede bash komutu olarak kurulum komutlarını çalıştırmak için %%bash ifadesini kullanıyoruz.
- Trl: pekiştirmeli öğrenme ile transformer dil modellerini eğitmek için kullanılır.
- Peft: önceden eğitilmiş modelin verimli şekilde uyarlanmasını sağlamak için parametre-verimli ince ayar (PEFT) yöntemlerini kullanır.
- Torch: yaygın olarak kullanılan açık kaynak bir makine öğrenimi kütüphanesi.
- Datasets: yaygın makine öğrenimi veri kümelerinin indirilmesi ve yüklenmesine yardımcı olur.
Transformers: Hugging Face tarafından geliştirilmiş olup, sınıflandırma, özetleme ve çeviri gibi çeşitli metin tabanlı görevler için binlerce önceden eğitilmiş modelle birlikte gelir.
%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers
Artık bu modüller aşağıdaki gibi içe aktarılabilir:
import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArgumentsVeri Yükleme ve Hazırlama
alpaca veri seti, Hugging Face’te ücretsiz olarak mevcuttur ve bu örnekte kullanılacaktır. Veri setinin üç ana sütunu vardır: instructions, input ve output. Bu sütunlar birleştirilerek nihai bir metin sütunu oluşturulur.
İlgilenilen veri setinin adını, yani tatsu-lab/alpaca’yı vererek veri setini yükleme talimatı aşağıda verilmiştir:
train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)Ortaya çıkan verilerin iki anahtar içeren bir sözlük yapısında olduğunu görebiliriz:
- Features: verilerin ana sütunlarını içerir
- Num_rows: verideki toplam satır sayısına karşılık gelir
train_dataset’in yapısı
İlk beş satır aşağıdaki komutla görüntülenebilir. Önce sözlüğü bir pandas veri çerçevesine dönüştürün, ardından satırları gösterin.
pandas_format = train_dataset.to_pandas()
display(pandas_format.head())
train_dataset’in ilk beş satırı
Daha iyi görselleştirme için, ilk üç satıra ait bilgileri yazdıralım; ancak bundan önce, satır başına en fazla 50 kelime sınırı koymak için textwrap kütüphanesini kurmamız gerekiyor. İlk yazdırma ifadesi her bloğu 15 kısa çizgi ile ayırır.
import textwrap
for index in range(3):
print("---"*15)
print("Instruction:
{}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],
width=50)))
print("Output:
{}".format(textwrap.fill(pandas_format.iloc[index]["output"],
width=50)))
print("Text:
{}".format(textwrap.fill(pandas_format.iloc[index]["text"],
width=50)))
İlk üç satırın ayrıntıları
Model Eğitimi
Modele eğitim vermeye geçmeden önce bazı önkoşulları ayarlamamız gerekiyor:
- Önceden Eğitilmiş Model: Hugging Face’te bulunan Salesforce/xgen-7b-8k-base adlı önceden eğitilmiş modeli kullanacağız. Salesforce, XGen-7B olarak adlandırılan bu 7B LLM serisini, 1,5T tokene kadar 8K diziler üzerinde standart yoğun dikkat (dense attention) ile eğitti.
- Tokenizer: Eğitim verisi üzerinde tokenleştirme görevleri için gereklidir. Önceden eğitilmiş model ve tokenizer’ı yüklemek için kod aşağıdaki gibidir:
pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)Eğitim yapılandırması
Eğitim için bazı argümanlar ve yapılandırmalar gerekir; aşağıda iki önemli yapılandırma nesnesi tanımlanmıştır: bir TrainingArguments örneği, bir LoraConfig modeli örneği ve son olarak SFTTrainer modeli.
TrainingArguments
Bu sınıf, model eğitimi için parametreleri tanımlamakta kullanılır.
Bu özel senaryoda, önce output_dir özniteliğini kullanarak eğitilmiş modelin depolanacağı hedefi belirleyip, ardından öğrenme oranı, epoch sayısı ve diğerleri gibi ek hiperparametreleri tanımlıyoruz.
model_training_args = TrainingArguments(
output_dir="xgen-7b-8k-base-fine-tuned",
per_device_train_batch_size=4,
optim="adamw_torch",
logging_steps=80,
learning_rate=2e-4,
warmup_ratio=0.1,
lr_scheduler_type="linear",
num_train_epochs=1,
save_strategy="epoch"
)LoRAConfig
Bu senaryoda kullanılan ana argümanlar şunlardır: LoRA’daki düşük dereceli dönüşüm matrisinin rütbesi 16 olarak ayarlanmıştır. Ardından, LoRA’daki ek parametreler için ölçekleme katsayısı 32 olarak belirlenmiştir.
Ayrıca, bırakma (dropout) oranı 0,05’tir; bu da eğitim sırasında giriş birimlerinin %5’inin yok sayılacağı anlamına gelir. Son olarak, nedensel dil modellemesiyle uğraştığımız için görev CAUSAL_LM özniteliğiyle başlatılır.
SFTTrainer
Bu bileşen, modeli eğitim verileri, tokenizer ve yukarıdaki modeller gibi ek bilgilerle eğitmeyi amaçlar.
Eğitim verilerindeki text alanını kullandığımızdan, belirli bir dizideki maksimum token sayısını belirlemeye yardımcı olması için dağılıma göz atmak önemlidir.
import matplotlib.pyplot as plt
pandas_format['text_length'] = pandas_format['text'].apply(len)
plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()
Metin sütunu uzunluğunun dağılımı
Yukarıdaki gözleme dayanarak, metinlerin çoğunluğunun uzunluğunun 0 ile 1000 arasında olduğunu görebiliriz. Ayrıca, aşağıda gördüğümüz gibi, metin belgelerinin yalnızca %4,5’inin uzunluğu 1024’ten büyüktür.
mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100
print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")
Daha sonra, dizideki maksimum token sayısını 1024 olarak ayarlıyoruz; böylece bundan daha uzun olan metinler kesilir.
SFT_trainer = SFTTrainer(
model=model,
train_dataset=train_dataset,
dataset_text_field="text",
max_seq_length=1024,
tokenizer=tokenizer,
args=model_training_args,
packing=True,
peft_config=lora_peft_config,
)Eğitimi yürütme
Tüm önkoşullar hazır olduğuna göre, artık modelin eğitim sürecini aşağıdaki gibi çalıştırabiliriz:
tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()Bu eğitimin, genel eğitim sürecini hızlandıran GPU’lu bir bulut ortamında gerçekleştirildiğini belirtmek önemlidir. Ancak, yerel bir bilgisayarda eğitim daha uzun sürebilir.
LLM’leri Bulutta Kullanmanın Artıları ve Eksileri ile Yerelde Çalıştırma başlıklı blog yazımız, LLM’ler için en uygun dağıtım stratejisini seçmeye yönelik temel değerlendirmeleri sunar.
Yukarıdaki kod parçasında neler olduğuna bakalım:
- tokenizer.pad_token = tokenizer.eos_token: Doldurma (padding) token’ını, cümle sonu (EOS) token’ı ile aynı olacak şekilde ayarlar.
- model.resize_token_embeddings(len(tokenizer)): Modelin token gömme katmanını, tokenizer sözlüğünün uzunluğuna uyacak şekilde yeniden boyutlandırır.
- model = prepare_model_for_int8_training(model): Modeli muhtemelen kuantizasyon uygulayarak INT8 hassasiyette eğitime hazırlar.
- model = get_peft_model(model, lora_peft_config): Verilen modeli PEFT yapılandırmasına göre uyarlar.
- training_args = model_training_args: Önceden tanımlanmış eğitim argümanlarını training_args değişkenine atar.
- trainer = SFT_trainer: SFTTrainer örneğini trainer değişkenine atar.
- trainer.train(): Sağlanan özelliklere göre modelin eğitim sürecini başlatır.
Sonuç
Bu makale, PyTorch kullanarak büyük bir dil modelinin nasıl eğitileceğine dair net bir rehber sundu. Veri seti hazırlığından başlayarak, önkoşulların hazırlanması, eğitmenin kurulması ve nihayetinde eğitim sürecinin yürütülmesi adımlarını ele aldı.
Spesifik bir veri seti ve önceden eğitilmiş bir model kullanılmış olsa da süreç, diğer uyumlu seçenekler için de büyük ölçüde aynıdır. Artık bir LLM’in nasıl eğitileceğini anladığınıza göre, bu bilgiyi çeşitli NLP görevleri için diğer gelişmiş modelleri eğitmekte kullanabilirsiniz.
LangChain ile LLM uygulamaları nasıl geliştirilir rehberimize göz atarak büyük dil modellerinin gücünü daha fazla keşfedin. Ya da hâlâ büyük dil modeli kavramlarını keşfetmeniz gerekiyorsa, öğreniminizi ilerletmek için kursumuza göz atın.
