Llama 3'e veya Diğer Açık Kaynak Modellerine İnce Ayar Yapmanız Gereken Tek Kılavuz

Llama 3 gibi büyük dil modellerinin (LLM) ince ayarını yapmak, önceden eğitilmiş bir modeli, alana özgü bir veri kümesi kullanarak belirli görevlere uyarlamayı içerir. Bu süreç, modelin önceden var olan bilgisinden yararlanarak, sıfırdan eğitime kıyasla verimli ve uygun maliyetli hale getirir. Bu kılavuzda, bellek kullanımını ve hesaplama maliyetlerini en aza indiren parametre açısından verimli bir yöntem olan QLoRA (Kantitize LoRA) kullanarak Llama 3'ü ince ayarlama adımlarını ele alacağız.

İnce Ayara Genel Bakış

İnce ayar birkaç önemli adımı içerir:

1. Önceden Eğitilmiş Bir Modelin Seçilmesi: İstediğiniz mimariye uygun bir temel model seçin.
2. İlgili Bir Veri Kümesinin Toplanması: Görevinize özel bir veri kümesi toplayın ve önceden işleyin.
3. İnce ayar: Belirli görevlerdeki performansını artırmak için veri kümesini kullanarak modeli uyarlayın.
4. Değerlendirme : İnce ayarlı modeli hem niteliksel hem de niceliksel ölçümleri kullanarak değerlendirin.

Kavramlar ve Teknikler

Büyük Dil Modellerinde İnce Ayar Yapma

Tam İnce Ayar

Tam ince ayar modelin tüm parametrelerini güncelleyerek onu yeni göreve özgü hale getirir. Bu yöntem önemli hesaplama kaynakları gerektirir ve genellikle çok büyük modeller için pratik değildir.

Parametre Verimli İnce Ayar (PEFT)

PEFT, modelin parametrelerinin yalnızca bir alt kümesini güncelleyerek bellek gereksinimlerini ve hesaplama maliyetini azaltır. Bu teknik felaketle sonuçlanan unutmayı önler ve modele ilişkin genel bilgiyi korur.

Düşük Sıralı Uyarlama (LoRA) ve Nicelenmiş LoRA (QLoRA)

LoRA yalnızca birkaç düşük dereceli matriste ince ayar yaparken QLoRA, bellek ayak izini daha da azaltmak için bu matrisleri niceler.

İnce Ayar Yöntemleri

1. Tam İnce Ayar: Bu, modelin tüm parametrelerinin göreve özel veri kümesi üzerinde eğitilmesini içerir. Bu yöntem çok etkili olabilse de hesaplama açısından pahalıdır ve önemli miktarda bellek gerektirir.
2. Parametre Verimli İnce Ayar (PEFT): PEFT, modelin parametrelerinin yalnızca bir alt kümesini güncelleyerek onu bellek açısından daha verimli hale getirir. Düşük Sıralı Uyarlama (LoRA) ve Nicelenmiş LoRA (QLoRA) gibi teknikler bu kategoriye girer.

LoRA nedir?

İnce ayar yöntemlerinin karşılaştırılması: QLORA, LoRA'yı 4 bit hassas niceleme ve bellek artışı yönetimi için sayfalanmış optimize edicilerle geliştirir

LoRA, önceden eğitilmiş modelin tüm ağırlıklarına ince ayar yapmak yerine, daha büyük matrise yaklaşan iki küçük matrisin ince ayarını yaptığı gelişmiş bir ince ayar yöntemidir. Bu matrisler LoRA bağdaştırıcısını oluşturur. Bu ince ayarlı adaptör daha sonra önceden eğitilmiş modele yüklenir ve çıkarım için kullanılır.

LoRA'nın Temel Avantajları:

• Bellek Verimliliği: LoRA, modelin tamamı yerine yalnızca küçük matrislere ince ayar yaparak bellek ayak izini azaltır.
• Reus yeteneği: Orijinal model değişmeden kalır ve birden fazla LoRA bağdaştırıcısı onunla birlikte kullanılabilir; bu, daha düşük bellek gereksinimleriyle birden fazla görevi yerine getirmeyi kolaylaştırır.

Nicelenmiş LoRA (QLoRA) nedir?

QLoRA, LoRA bağdaştırıcılarının ağırlıklarını ölçerek hassasiyeti düşürerek (örneğin 4 bit yerine 8 bit) LoRA'yı bir adım daha ileri götürür. Bu, karşılaştırılabilir bir verimlilik düzeyini korurken bellek kullanımını ve depolama gereksinimlerini daha da azaltır.

QLoRA'nın Temel Avantajları:

• Daha da Yüksek Bellek Verimliliği: QLoRA, ağırlıkları sayısallaştırarak modelin bellek ve depolama gereksinimlerini önemli ölçüde azaltır.
• Performansı Korur: Azaltılmış hassasiyete rağmen QLoRA, tam hassasiyetli modellere yakın performans seviyelerini korur.

Göreve Özel Uyarlama

İnce ayar sırasında, modelin parametreleri yeni veri kümesine göre ayarlanarak modelin daha iyi anlamasına ve belirli göreve uygun içerik oluşturmasına yardımcı olur. Bu süreç, modeli hedef alanın nüanslarına göre ayarlarken, ön eğitim sırasında kazanılan genel dil bilgisini korur.

Uygulamada İnce Ayar

Tam İnce Ayar vs. PEFT

• Tam İnce Ayar: Hesaplama açısından pahalı olabilecek ve önemli miktarda bellek gerektiren tüm modelin eğitilmesini içerir.
• PEFT (LoRA ve QLoRA): Yalnızca bir parametre alt kümesine ince ayar yaparak bellek gereksinimlerini azaltır ve felaketle sonuçlanabilecek unutmayı önleyerek onu daha verimli bir alternatif haline getirir.

Uygulama Adımları

1. Kurulum Ortamı: Gerekli kütüphaneleri kurun ve bilgi işlem ortamını kurun.
2. Veri Kümesini Yükleme ve Ön İşleme: Veri kümesini yükleyin ve modele uygun bir formatta ön işleme tabi tutun.
3. Önceden eğitilmiş Modeli Yükle: QLoRA kullanılıyorsa temel modeli niceleme yapılandırmalarıyla yükleyin.
4. dizgeciklere: Eğitime hazırlamak için veri kümesini simgeleştirin.
5. Eğitim: Hazırlanan veri kümesini kullanarak modele ince ayar yapın.
6. Değerlendirme : Modelin belirli görevlerdeki performansını nitel ve nicel metrikleri kullanarak değerlendirin.

LLM'de İnce Ayar Yapmak için Adım Adım Steo Kılavuzu

Ortamı Ayarlama

Bu eğitim için Jupyter Notebook kullanacağız. Ücretsiz GPU kullanımı sunan Kaggle veya Google Colab gibi platformlar bu deneyleri yürütmek için idealdir.

1. Gerekli Kitaplıkları Kurun

Öncelikle gerekli kütüphanelerin kurulu olduğundan emin olun:

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

2. Kitaplıkları İçe Aktarın ve Ortamı Kurun

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

# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Veri Kümesini Yükleyin

Bu eğitimde DialogSum veri setini kullanacağız:

Uygun şablonların uygulanması ve veri formatının ince ayar için uygun olduğundan emin olunması da dahil olmak üzere, veri kümesini modelin gereksinimlerine göre ön işleme tabi tutun (Sarılma Yüz)â € <â € < (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 biçiminde 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 eğitimde Microsoft'un Phi-2 modeli kullanılıyor:

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. Belirleme

Belirteçleyiciyi 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 Modellerin İnce Ayarı

Llama 3 veya diğer son teknolojiye sahip açık kaynaklı LLM'ler gibi modellerde ince ayar yapılırken, optimum performansı sağlamak için gereken özel hususlar ve ayarlamalar vardır. Llama 3, GPT-3 ve Mistral dahil olmak üzere farklı modeller için bu konuya nasıl yaklaşılacağına dair ayrıntılı adımları ve bilgileri burada bulabilirsiniz.

5.1 Lama 3'ü Kullanmak

Model Seçimi:

• Hugging Face model merkezinden doğru model tanımlayıcısına sahip olduğunuzdan emin olun. Örneğin, Llama 3 modeli şu şekilde tanımlanabilir: meta-llama/Meta-Llama-3-8B Sarılma Yüzünde.
• Llama 3 gibi modeller için gerekiyorsa Hugging Face hesabınıza erişim talep ettiğinizden ve oturum açtığınızdan emin olun. (Sarılma Yüz)â € <â € <

dizgeciklere:

• Modelle uyumlu olduğundan ve dolgu ve özel jetonlar gibi gerekli özellikleri desteklediğinden emin olmak için Llama 3 için uygun jetonlaştırıcıyı kullanın.

Bellek ve Hesaplama:

• Llama 3 gibi büyük modellere ince ayar yapmak önemli hesaplama kaynakları gerektirir. Güçlü bir GPU kurulumu gibi ortamınızın bellek ve işleme gereksinimlerini karşılayabildiğinden emin olun. Ortamın bellek gereksinimlerini karşılayabildiğinden emin olun; bellek ayak izini azaltmak için QLoRA gibi teknikler kullanılarak bu azaltılabilir. (Sarılma Yüz Forumları)

Ö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
)

dizgeciklere:

Özel kullanım durumuna ve model gereksinimlerine bağlı olarak, yedek ayarlar olmadan doğru tokenizer yapılandırmasını sağlayın. Örneğin, use_fast=True Daha iyi performans için önerilir (Sarılma Yüz)â € <â € < (Ağırlıklar ve Önyargılar).

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 Modellerin Kullanımı (örn. GPT-3, Mistral)

Model Seçimi:

• GPT-3 ve Mistral gibi modeller için Hugging Face model merkezinden veya diğer kaynaklardan doğru model adını ve tanımlayıcıyı kullandığınızdan emin olun.

dizgeciklere:

• Llama 3'e benzer şekilde tokenizer'ın doğru şekilde kurulduğundan ve modelle uyumlu olduğundan emin olun.

Bellek ve Hesaplama:

• Her modelin farklı bellek gereksinimleri olabilir. Ortam kurulumunuzu buna göre ayarlayın.

GPT-3 için örnek:

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'e örnek:

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
)

Tokenizasyonla İlgili Hususlar: Her modelin benzersiz tokenizasyon gereksinimleri olabilir. Belirteçleyicinin modelle eşleştiğinden ve doğru şekilde yapılandırıldığından emin olun.

Lama 3 Tokenizer Ö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 Tokenizer Örneği:

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

7. Modeli Sıfır Atış Çıkarımıyla Test Edin

Temel modeli örnek bir girdiyle değerlendirin:

from transformers import set_seed

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

# Generate output
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'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

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

Diyalog özeti çiftlerini bilgi istemlerine dönüştürün:

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"
    
    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 simgeleştirin:

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 parametre açısından verimli ince ayar için hazırlayın:

original_model = prepare_model_for_kbit_training(original_model)

Hiperparametreler modelinizin performansını optimize etmede çok önemli bir rol oynar. Göz önünde bulundurulması gereken bazı önemli hiperparametreler şunlardır:

1. Öğrenme oranı: Modelin parametrelerini güncelleme hızını kontrol eder. Yüksek bir öğrenme oranı daha hızlı yakınsamaya yol açabilir ancak optimal çözümün aşılmasına neden olabilir. Düşük bir öğrenme oranı istikrarlı yakınsama sağlar ancak daha fazla dönem gerektirebilir.
2. Parti boyutu: Model parametrelerini güncellemeden önce işlenen örneklerin sayısı. Daha büyük toplu iş boyutları kararlılığı artırabilir ancak daha fazla bellek gerektirir. Daha küçük parti boyutları, eğitim sürecinde daha fazla gürültüye yol açabilir.
3. Gradyan Biriktirme Adımları: Bu parametre, bir parametre güncellemesi gerçekleştirmeden önce birden fazla adımdaki degradeleri toplayarak daha büyük parti boyutlarının simüle edilmesine yardımcı olur.
4. Dönem Sayısı: Tüm veri kümesinin modelden geçme sayısı. Daha fazla dönem performansı artırabilir ancak uygun şekilde yönetilmezse aşırı uyumla sonuçlanabilir.
5. Ağırlık Azalması: Büyük ağırlıkları cezalandırarak aşırı uyumu önleyen düzenleme tekniği.
6. Öğrenme Hızı Planlayıcısı: Performansı ve yakınsamayı geliştirmek için eğitim sırasında öğrenme oranını ayarlar.

Belirli model ve görev gereksinimlerine göre öğrenme hızı, toplu iş boyutu ve gradyan biriktirme adımları gibi hiperparametreleri ayarlayarak eğitim yapılandırmasını özelleştirin. Örneğin, Llama 3 modelleri daha küçük modellere göre farklı öğrenme oranları gerektirebilir (Ağırlıklar ve Önyargılar)â € <â € < (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ğ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")

İnce Ayarlı Modelin Değerlendirilmesi

Eğitimden sonra modelin performansını hem nitel hem de nicel yöntemlerle değerlendirin.

1. İnsan Değerlendirmesi

Kaliteyi değerlendirmek için oluşturulan özetleri insanlar tarafından yazılan özetlerle karşılaştırın.

2. Nicel Değerlendirme

Performansı değerlendirmek için ROUGE gibi ölçümleri kullanın:

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)

Ortak Zorluklar ve Çözümler

1. Bellek Sınırlamaları

QLoRA'nın kullanılması, model ağırlıklarını 4 bit olarak nicelendirerek bellek sorunlarının azaltılmasına yardımcı olur. Toplu iş boyutunuz ve model boyutunuz için yeterli GPU belleğiniz olduğundan emin olun.

2. Aşırı uyum gösterme

Aşırı uyumu önlemek için doğrulama ölçümlerini izleyin. Erken durma ve kilo verme gibi teknikleri kullanın.

3. Yavaş Eğitim

Toplu iş boyutunu, öğrenme oranını ayarlayarak ve degrade birikimini kullanarak eğitim hızını optimize edin.

4. Veri kalitesi

Veri kümenizin temiz olduğundan ve önceden iyi bir şekilde işlendiğinden emin olun. Zayıf veri kalitesi model performansını önemli ölçüde etkileyebilir.

Sonuç

QLoRA kullanarak LLM'lerde ince ayar yapmak, önceden eğitilmiş büyük modelleri, azaltılmış hesaplama maliyetleriyle belirli görevlere uyarlamanın etkili bir yoludur. Bu kılavuzu takip ederek PHI, Llama 3 veya başka herhangi bir açık kaynak modele ince ayar yaparak belirli görevlerinizde yüksek performans elde edebilirsiniz.