Fine-Tuning Llama 3 veya Diğer Açık Kaynaklı Modelleri için Tek Gereken Rehber

Büyük dil modellerini (LLM) fine-tune etme, bir önceden eğitilmiş modeli belirli görevlere uyarlamak için bir domaine özgü veri kümesini kullanarak yapılır. Bu süreç, modelin önceden var olan bilgilerini kullanır, böylece verimlilik ve maliyet açısından hiệu quả olur. Bu kılavuzda, Llama 3’ü QLoRA (Quantized LoRA) kullanarak fine-tune etme adımlarını yürüyeceğiz. QLoRA, parametre verimliliği yüksek bir yöntemdir ve bellek kullanımını ve hesaplama maliyetlerini en aza indirir.

Fine-Tuning Hakkında Genel Bilgi

Fine-tuning beberapa ana adımdan oluşur:

1. Önceden Eğitilmiş Model Seçimi: İstenilen mimariye uygun bir temel model seçin.
2. İlgili Veri Kümesinin Toplanması: Görevinize özgü bir veri kümesini toplayın ve ön işlemden geçirin.
3. Fine-Tuning: Modeli, görevinize özgü performansını iyileştirmek için veri kümesi kullanarak uyarlayın.
4. Değerlendirme: Fine-tune edilmiş modeli, hem nitel hem de nicel ölçütlere göre değerlendirin.

Kavramlar ve Teknikler

Büyük Dil Modellerini Fine-Tuning

Tam Fine-Tuning

Tam fine-tuning, modelin tüm parametrelerini günceller, böylece model yeni görev için özgü hale gelir. Bu yöntem önemli miktarda hesaplama kaynağı gerektirir ve çok büyük modeller için genellikle uygulanamaz.

Parametre Verimliliği Yüksek Fine-Tuning (PEFT)

PEFT, modelin yalnızca bir alt kümesi parametrelerini günceller, böylece bellek gereksinimlerini ve hesaplama maliyetlerini azaltır. Bu teknik, felaket niteliğindeki unutmayı önler ve modelin genel bilgilerini korur.

Düşük Rütbe Uyarlaması (LoRA) ve Quantized LoRA (QLoRA)

LoRA, yalnızca birkaç düşük rütbeli matrisi fine-tune eder, जबकi QLoRA bu matrisleri daha da azaltmak için onları quantize eder.

Fine-Tuning Yöntemleri

1. Tam Fine-Tuning: Bu, modelin tüm parametrelerini görev özgü veri kümesi üzerinde eğitme işlemini içerir. Bu yöntem çok etkili olabilir, ancak aynı zamanda hesaplama açısından pahalıdır ve önemli miktarda bellek gerektirir.
2. Parametre Verimliliği Yüksek Fine-Tuning (PEFT): PEFT, modelin yalnızca bir alt kümesi parametrelerini günceller, böylece bellek gereksinimlerini azaltır. LoRA ve QLoRA gibi teknikler bu kategoriye girer.

LoRA Nedir?

Fine-Tuning Yöntemlerinin Karşılaştırması: QLORA, LoRA’yı 4-bit kesinlikli quantization ve paged optimizers ile geliştirir

LoRA, önceden eğitilmiş modelin tüm ağırlıklarını fine-tune etmek yerine, iki küçük matrisi fine-tune eden bir fine-tuning yöntemidir. Bu matrisler, LoRA adaptörünü oluşturur. Bu fine-tune edilmiş adaptör, daha sonra önceden eğitilmiş modelde yüklenir ve çıkarım için kullanılır.

LoRA’nın Ana Avantajları:

• Bellek Verimliliği: LoRA, yalnızca küçük matrisleri fine-tune ederek bellek izini azaltır.
• Yeniden Kullanılabilirlik: Orijinal model değişmez, ve birden fazla LoRA adaptörü ile kullanılabilir, böylece birden fazla görevi düşük bellek gereksinimi ile işleyebilir.

Quantized LoRA (QLoRA) Nedir?

QLoRA, LoRA’yı bir adım öteye taşıyarak, LoRA adaptörlerinin ağırlıklarını daha düşük kesinlikte (örneğin, 4-bit yerine 8-bit) quantize eder. Bu, bellek kullanımını ve depolama gereksinimlerini daha da azaltırken, benzer bir performans seviyesini korur.

QLoRA’nın Ana Avantajları:

• Daha Fazla Bellek Verimliliği: Ağırlıkları quantize ederek, QLoRA modelin bellek ve depolama gereksinimlerini önemli ölçüde azaltır.
• Performansı Koruma: Düşük kesinlikte olmasına rağmen, QLoRA tam kesinlikli modellere benzer bir performans seviyesini korur.

Görev Özgü Uyarlanma

Fine-tuning sırasında, model parametreleri yeni veri kümesi temelinde ayarlanır, böylece model görevin özgü detaljerini daha iyi anlar ve ilgili içerik oluşturur. Bu süreç, genel dil bilgilerini korurken modeli hedef domaine uyarlar.

Pratikte Fine-Tuning

Tam Fine-Tuning vs. PEFT

• Tam Fine-Tuning: Tüm modeli eğitme işlemini içerir, hesaplama açısından pahalı ve önemli miktarda bellek gerektirir.
• PEFT (LoRA ve QLoRA): Modelin yalnızca bir alt kümesi parametrelerini günceller, bellek gereksinimlerini azaltır ve felaket niteliğindeki unutmayı önler, böylece daha verimli bir alternatif sunar.

Uygulama Adımları

1. Çevreyi Hazırlama: Gerekli kütüphaneleri kurun ve hesap ortamını ayarlayın.
2. Veri Kümesini Yükleyin ve Ön İşlemden Geçirin: Veri kümesini yükleyin ve model için uygun formata dönüştürün.
3. Önceden Eğitilmiş Modeli Yükleyin: Temel modeli, QLoRA kullanıyorsanız quantization yapılandırması ile yükleyin.
4. Tokenization: Veri kümesini tokenize edin, böylece model için hazırlanmış olsun.
5. Eğitim: Modeli, hazırlanmış veri kümesi ile fine-tune edin.
6. Değerlendirme: Modelin performansını, görev özgü ölçütlere göre değerlendirin.

LLM’yi Fine-Tune Etmek için Adım Adım Kılavuz

Çevreyi Hazırlama

Bu öğretici için bir Jupyter defteri kullanacağız. Kaggle gibi platformlar veya Google Colab, bu deneyleri çalıştırmak için idealdir.

1. Gerekli Kütüphaneleri Kurun

İlk olarak, gerekli kütüphanelerin kurulu olduğundan emin olun:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. Kütüphaneleri İçe Aktarın ve Çevreyi Ayarlayın

import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# Weights and Biases günlüğünü devre dışı bırakın
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Veri Kümesini Yükleyin

Bu öğretici için DialogSum veri kümesini kullanacağız:

Veri kümesini, modelin gereksinimlerine uygun şekilde ön işlemden geçirin, şablonları uygulayın ve veri formatının fine-tuning için uygun olduğundan emin olun (Hugging Face)​​ (DataCamp)​.

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

Veri kümesi yapısını inceleyin:

print(dataset['test'][0])

4. BitsAndBytes Yapılandırmasını Oluşturun

Modeli 4-bit formatında yüklemek için:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)

5. Önceden Eğitilmiş Modeli Yükleyin

Bu öğretici için Microsoft’un Phi-2 modelini kullanacağız:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

6. Tokenization

Tokenizatörü yapılandırın:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Llama 3 veya Diğer Modelleri Fine-Tune Etmek

Llama 3 veya diğer son teknoloji açık kaynaklı LLM’leri fine-tune ederken, optimal performansı sağlamak için belirli考虑ler ve ayarlamalar gerekir. İşte bu modelleri, özellikle Llama 3, GPT-3 ve Mistral için fine-tune etme adımları ve ipuçları.

5.1 Llama 3 Kullanma

Model Seçimi:

• Hugging Face model hub’ından doğru model tanımlayıcısını alın. Örneğin, Llama 3 modeli meta-llama/Meta-Llama-3-8B olarak tanımlanabilir.
• Llama 3 gibi modeller için erişim isteyin ve Hugging Face hesabınıza giriş yapın (Hugging Face)​​

Tokenization:

• Llama 3 için uygun tokenizatörü kullanın, model ve gerekli özellikler ile uyumlu olduğundan emin olun.

Bellek ve Hesaplama:

• Büyük modelleri fine-tune etmek için önemli miktarda hesaplama kaynağı gereklidir. Çevrenizin, güçlü bir GPU kurulumu gibi, bellek ve işlem gereksinimlerini karşılayabileceğinden emin olun. QLoRA gibi teknikleri kullanarak bellek izini azaltabilirsiniz (Hugging Face Forums)

Örnek:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Tokenization:

Özel kullanım durumuna ve model gereksinimlerine bağlı olarak, tokenizatör yapılandırmasını gereksiz ayarlamalar olmadan doğru şekilde ayarlayın. Örneğin, use_fast=True daha iyi performans için önerilir (Hugging Face)​​ (Weights & Biases)​.

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

5.2 Diğer Popüler Modelleri (Örneğin GPT-3, Mistral) Kullanma

Model Seçimi:

• GPT-3 ve Mistral gibi modeller için, Hugging Face model hub’ından veya diğer kaynaklardan doğru model adını ve tanımlayıcısını kullanın.

Tokenization:

• Llama 3’e benzer şekilde, tokenizatörün model ile uyumlu ve gerekli özelliklere sahip olduğundan emin olun.

Bellek ve Hesaplama:

• Her modelin farklı bellek gereksinimleri olabilir. Çevrenizi buna göre ayarlayın.

GPT-3 Örneği:

model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Mistral Örneği:

model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Tokenization Düşünceleri: Her modelin benzersiz tokenization gereksinimleri olabilir. Tokenizatörün model ile uyumlu ve doğru şekilde yapılandırıldığından emin olun.

Llama 3 Tokenizatör Örneği:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

GPT-3 ve Mistral Tokenizatör Örneği:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

7. Modeli Sıfır Atışlı Çıkarımla Test Edin

Örnek bir girdi ile temel modeli değerlendirin:

from transformers import set_seed

<p>set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"</p>

<p># Çıktı oluşturun
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)</p>

<p>res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]</p>

<p>print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. Veri Kümesini Ön İşlemden Geçirin

Sohbet-özet çiftlerini istemlere dönüştürün:

<p>def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"</p>

<p>parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample</p>

<p>dataset = dataset.map(create_prompt_formats)</p>

Yapılandırılmış veri kümesini tokenize edin:

<p>def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)</p>

<p>max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)</p>

Modeli parametre verimliliği yüksek fine-tuning için hazırlayın:

<p>original_model = prepare_model_for_kbit_training(original_model)</p>

Hiperparametreler, modelinizin performansını optimize etmede kritik bir rol oynar. İşte dikkate almanız gereken bazı ana hiperparametreler:

1. Öğrenme Oranı: Modelin parametrelerini güncelleme hızını kontrol eder. Yüksek öğrenme oranı daha hızlı yakınsama sağlayabilir, ancak optimal çözüme ulaşmadan önce atlayabilir. Düşük öğrenme oranı, daha稳il bir yakınsama sağlar, ancak daha fazla epoch gerektirebilir.
2. Toplu İşlem Boyutu: Modelin parametrelerini güncellemeden önce işlenen örneklerin sayısı. Daha büyük toplu işlem boyutları daha稳il bir eğitim süreci sağlayabilir, ancak daha fazla bellek gerektirebilir. Küçük toplu işlem boyutları, eğitim sürecinde daha fazla gürültüye neden olabilir.
3. Gradyan Birikme Adımları: Daha büyük toplu işlem boyutlarını simüle etmek için birden fazla adımda gradyanları biriktirme işlemini sağlar.
4. Epoch Sayısı: Tüm veri kümesinin model üzerinden geçirildiği epoch sayısı. Daha fazla epoch, performansı iyileştirebilir, ancak doğru yönetilmezse overfittinge neden olabilir.
5. Ağırlık Çürümesi: Overfittingi önlemek için büyük ağırlıkları cezalandıran bir düzenleme tekniği.
6. Öğrenme Oranı Zamanlayıcı: Eğitim sırasında öğrenme oranını ayarlayarak performansı iyileştirmeye ve yakınsamayı hızlandırmaya yardımcı olur.

Eğitim yapılandırmanızı, öğrenme oranı, toplu işlem boyutu ve gradyan birikme adımları gibi hiperparametreleri model ve görev gereksinimlerine göre ayarlayarak özelleştirin. Örneğin, Llama 3 modelleri, daha küçük modellere kıyasla farklı öğrenme oranlarına ihtiyaç duyabilir (Weights & Biases)​​ (GitHub)​

Örnek Eğitim Yapılandırması

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/',)

10. Modeli Eğitme

Eğiticiyi kurun ve eğitime başlayın:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

Fine-Tune Edilmiş Modeli Değerlendirme

Eğitimden sonra, modelin performansını nitel ve nicel yöntemler ile değerlendirin.

1. İnsan Değerlendirmesi

Üretilen özetleri insan tarafından yazılmış özetlerle karşılaştırın, kaliteyi değerlendirmek için.

2. Nicel Değerlendirme

ROUGE gibi metriklere dayalı olarak performansı değerlendirin:

from rouge_score import rouge_scorer

<p>scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)</p>

Yaygın Sorunlar ve Çözümler

1. Bellek Sınırlamaları

QLoRA, ağırlıkları 4-bit’e quantize ederek bellek sorunlarını hafifletmeye yardımcı olur. Toplu işlem boyutunuz ve model boyutunuz için yeterli GPU belleğiniz olduğundan emin olun.

2. Overfitting

Doğrulama metriklarını izleyin ve overfittingi önlemek için erken durdurma ve ağırlık çürümesi gibi teknikleri kullanın.

3. Yavaş Eğitim

Eğitim hızını, toplu işlem boyutunu, öğrenme oranını ve gradyan birikme adımlarını ayarlayarak optimize edin.

4. Veri Kalitesi

Veri kümenizin temiz ve iyi ön işlemden geçirildiğinden emin olun. Kötü veri kalitesi, model performansı üzerinde önemli bir etkiye sahip olabilir.

Sonuç

LLM’leri QLoRA kullanarak fine-tune etmek, büyük önceden eğitilmiş modelleri belirli görevlere uyarlamak için verimlilik yüksek ve hesaplama maliyetleri düşük bir yöntemdir. Bu kılavuzu takip ederek, PHI, Llama 3 veya diğer açık kaynaklı modelleri görevinize özgü yüksek performans için fine-tune edebilirsiniz.