Llama 3 veya Herhangi Bir Diğer Açık Kaynak Modeli İnce Ayarlamak için Gereken Tek Rehber

Büyük dil modellerini (LLM) ince ayarlamak, önceden eğitilmiş bir modeli, bir domaine özgü veri kümesi kullanarak belirli görevlere uyarlamak anlamına gelir. Bu işlem, modelin önceden var olan bilgilerini kullanır, böylece sıfırdan eğitim yapmaya kıyasla verimli ve maliyet etkin olur. Bu rehberde, QLoRA (Quantized LoRA) adlı bir parametreye dayalı yöntemi kullanarak Llama 3’ü ince ayarlamaya ilişkin adımları ele alacağız. QLoRA, bellek kullanımını ve hesaplama maliyetlerini en aza indirir.

İnce Ayarmanın Genel Bakışı

İnce ayarlamak birkaç önemli adımdan oluşur:

1. Önceden Eğitilmiş Modeli Seçme: İstenilen mimariye uygun bir temel model seçin.
2. İlgili Veri Kümesini Toplama: Görevinize özgü bir veri kümesini toplayın ve ön işlemden geçirin.
3. İnce Ayarlama: Modeli, görevinizdeki performansını iyileştirmek için veri kümesi kullanarak uyarlayın.
4. Değerlendirme: İnce ayarlanmış modeli, hem nitel hem de nicel ölçütler kullanarak değerlendirin.

Kavramlar ve Teknikler

Büyük Dil Modellerini İnce Ayarlama

Tam İnce Ayarlama

Tam ince ayarlama, modelin tüm parametrelerini günceller, böylece model yeni görev için özelleşir. Bu yöntem önemli miktarda hesaplama kaynağı gerektirir ve çok büyük modeller için genellikle pratik değildir.

Parametreye Dayalı İnce Ayarlama (PEFT)

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

Düşük Rütbeli Uyum (LoRA) ve Quantized LoRA (QLoRA)

LoRA, yalnızca birkaç düşük rütbeli matrisi ince ayarlar, जबकi QLoRA bu matrisleri daha da azaltmak için bunları nicemlendirmektedir.

İnce Ayarlama Yöntemleri

1. Tam İnce Ayarlama: Bu, tüm model parametrelerinin görev özgü veri kümesi üzerinde eğitilmesini içerir. Bu yöntem çok etkili olabilir, ancak aynı zamanda hesaplama açısından pahalı ve önemli miktarda bellek gerektirir.
2. Parametreye Dayalı İnce Ayarlama (PEFT): PEFT, modelin yalnızca bir alt kümesindeki parametrelerini günceller, böylece bellek gereksinimlerini azaltır. LoRA ve QLoRA gibi teknikler bu kategoriye girer.

LoRA Nedir?

İnce Ayarlama Yöntemlerini Karşılaştırma: QLORA, LoRA’yı 4 bitlik nicemleme ve sayfalandırılmış optimize edici ile geliştirir

LoRA, önceden eğitilmiş modelin tüm ağırlıklarını ince ayarlamak yerine, daha küçük iki matrisi ince ayarlayarak ve bu matrislerin daha büyük matrisi yaklaşık olarak temsil etmesini sağlayan bir yöntemdir. Bu matrisler, LoRA adaptörünü oluşturur. Bu ince ayarlanmış adaptör daha sonra önceden eğitilmiş modele yüklenir ve çıkarım için kullanılır.

LoRA’nın Ana Avantajları:

• Bellek Verimliliği: LoRA, yalnızca küçük matrisleri ince ayarlayarak bellek izini azaltır.
• Yeniden Kullanılabilirlik: Orijinal model değişmez kalır ve birden fazla LoRA adaptörü ile birlikte kullanılabilir, böylece daha düşük bellek gereksinimleriyle birden fazla görevi işleme kolaylığı sağlar.

Quantized LoRA (QLoRA) Nedir?

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

QLoRA’nın Ana Avantajları:

• Daha Büyük Bellek Verimliliği: Ağırlıkları nicemlendirerek, QLoRA modelin bellek ve depolama gereksinimlerini önemli ölçüde azaltır.
• Performansı Koruma: Azaltılmış precisa rağmen, QLoRA tam preciseli modellere benzer performans seviyelerini korur.

Görev Özgü Uyum

İnce ayarlama sırasında, model parametreleri yeni veri kümesine dayanarak ayarlanır, böylece model görevle ilgili içeriği daha iyi anlar ve üretir. Bu işlem, önceden eğitilmiş modelin genel dil bilgilerini korurken, modeli hedef alanın nüanslarına uyarlar.

Pratikte İnce Ayarlama

Tam İnce Ayarlama vs. PEFT

• Tam İnce Ayarlama: Tüm modeli eğitilmesini içerir, bu da hesaplama açısından pahalı ve önemli miktarda bellek gerektirir.
• PEFT (LoRA ve QLoRA): Yalnızca modelin bir alt kümesindeki parametrelerini günceller, böylece bellek gereksinimlerini azaltır ve felaket niteliğinde unutmayı önler, daha verimli bir alternatif haline gelir.

Uygulama Adımları

1. Çevreyi Ayarlama: Gerekli kütüphaneleri yükleyin ve hesap ortamını kurun.
2. Veri Kümesini Yükleme ve Ön İşleme: Veri kümesini yükleyin ve model için uygun bir formata dönüştürün.
3. Önceden Eğitilmiş Modeli Yükleme: QLoRA kullanıyorsanız, modele nicemleme yapılandırması ile birlikte yükleyin.
4. Tokenization: Veri kümesini eğitim için hazırlamak üzere tokenize edin.
5. Eğitim: Hazırlanmış veri kümesi kullanarak modeli ince ayarlayın.
6. Değerlendirme: Modelin performansını belirli görevlerde nitel ve nicel ölçütler kullanarak değerlendirin.

LLM İnce Ayarlamak için Adım Adım Rehber

Çevreyi Ayarlama

Bu eğitim için bir Jupyter defteri kullanacağız. Kaggle gibi ücretsiz GPU kullanımı sunan platformlar veya Google Colab gibi ortamlar bu deneyleri çalıştırmak için idealdir.

1. Gerekli Kütüphaneleri Yükleyin

İlk olarak, gerekli kütüphanelerin yüklenmesini sağlayın:

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

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

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ükleme

Bu eğitim için DialogSum veri kümesini kullanacağız:

Veri kümesini modelin gereksinimlerine uygun olarak işleyin, şablonları uygulayın ve veri formatının ince ayarlama 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şturma

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ükleme

Bu eğitim 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 İnce Ayarlama

Llama 3 veya diğer son teknoloji açık kaynaklı LLM’leri ince ayarlarken, optimal performansı sağlamak için belirli hususlar ve ayarlamalar gerekir. İşte, Llama 3, GPT-3 ve Mistral gibi modeller için ayrıntılı adımlar ve içgörüler.

5.1 Llama 3 Kullanma

Model Seçimi:

• Llama 3 modeli için Hugging Face model hub’ından doğru model tanımlayıcısını edinin. Örneğin, Llama 3 modeli meta-llama/Meta-Llama-3-8B olarak tanımlanabilir.
• Gerekiyorsa, modeller gibi Llama 3 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 gerektirdiği özelliklerle uyumlu olduğundan emin olun.

Bellek ve Hesaplama:

• Büyük modelleri ince ayarlama, önemli miktarda hesaplama kaynağı gerektirir. Çevrenizin, güçlü bir GPU kurulumunun, gereksinimleri 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:

Bağlamınıza ve model gereksinimlerine bağlı olarak, tokenizatör yapılandırmasını 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 Kullanma (Örneğin GPT-3, Mistral)

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ı edinin.

Tokenization:

• Benzer şekilde, tokenizatörün model ile uyumlu ve gerektirdiği ö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 Hususları: Her modelin benzersiz tokenization gereksinimleri olabilir. Tokenizatörün model ile uyumlu ve doğru 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 Etme

Önceden eğitilmiş modeli bir örnek girdi ile değerlendirin:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Aşağıdaki konuşmayı özetleyin.\n{prompt}\nOutput:\n"

# Çıktı üretme
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)

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

print(f'GİRDİ PROMPT:\n{formatted_prompt}')
print(f'MODEL ÜRETİMİ - SIFIR ATIŞLI:\n{output}')

8. Veri Kümesini Ön İşleme

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

def create_prompt_formats(sample):
blurb = "Aşağıda bir görevi tanımlayan bir talimat vardır. İsteği uygun şekilde tamamlayan bir yanıt yazın."
instruction = "### Instruct: Aşağıdaki konuşmayı özetleyin."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"

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

dataset = dataset.map(create_prompt_formats)

Biçimlendirilmiş veri kümesini tokenize edin:

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

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)

Modeli parametreye dayalı ince ayarlama için hazırlayın:

original_model = prepare_model_for_kbit_training(original_model)

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

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ümü kaçırabilir. 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ı: Bu parametre, daha büyük toplu işlem boyutlarını simüle etmek için birden fazla adımda gradyanları biriktirerek yardımcı olur.
4. Epoch Sayısı: Tüm veri kümesinin model üzerinden geçirildiği epoch sayısı. Daha fazla epoch, performansı iyileştirebilir, ancak aşırı uyarlama sorunlarına neden olabilir.
5. Ağırlık Çürümesi: Aşırı uyarlama ö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ı ve yakınsamayı iyileştirir.

Eğitim yapılandırmasını, öğrenme oranı, toplu işlem boyutu ve gradyan birikme adımları gibi hyperparametreleri 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ğitin

Eğitmeni 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")

İnce Ayarlanmış Modeli Değerlendirme

Eğitime sonra, modelin performansını hem nitel hem de nicel yöntemler kullanarak değerlendirin.

1. İnsan Değerlendirmesi

Üretilen özetleri insan tarafından yazılmış özetlerle karşılaştırarak kaliteyi değerlendirin.

2. Nicel Değerlendirme

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

from rouge_score import rouge_scorer

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

Yaygın Sorunlar ve Çözümler

1. Bellek Sınırlamaları

QLoRA, model ağırlıklarını 4 bitlik nicemleyerek bellek sorunlarını hafifletmeye yardımcı olur. Toplu işlem boyutunuz ve model büyüklüğünüzü karşılayabilecek yeterli GPU belleğiniz olduğundan emin olun.

2. Aşırı Uyarlama

Doğrulama metriğini izleyerek aşırı uyarlama önleyin. 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ümesinin temiz ve iyi ön işlenmiş olduğundan emin olun. Kötü veri kalitesi, model performansını önemli ölçüde etkileyebilir.

Sonuç

QLoRA kullanarak büyük dil modellerini ince ayarlama, belirli görevlere uyarlamak için verimli bir yöntemdir. Bu rehberi takip ederek, Llama 3 veya diğer açık kaynaklı modelleri görevinize özgü olarak ince ayarlayabilir ve yüksek performans elde edebilirsiniz.