Salesforce XGen-7B: XGen-7B’yi Kullanma ve İnce Ayar Yapma Üzerine Adım Adım Bir Eğitim

Şu anda, bu altısı en popüler açık kaynak LLM’lerden bazıları:

1. LLaMA2
2. BLOOM
3. Falcon 180B
4. OPT-175B
5. GPT-Neox
6. Vicuna 13-B

Ve hepsinin aynı dezavantajı var — bağlam uzunluğu çok kısa; en fazla 2048 tokene kadar çıkabiliyor. 32k tokene kadar (50 sayfa metin!) bağlam uzunluğu sunan GPT-3.5 ve GPT-4 gibi tescilli modellere kıyasla, açık kaynak LLM’ler ciddi bir dezavantaj altında görünüyor.

Bağlam uzunluğu, özünde LLM’lerin “hafızasıdır”. 2048 tokenlık bir bağlam penceresi, modelin bir seferde konuşmanın yalnızca 2048 tokenını hatırlayabildiği anlamına gelir. Bu durum, özetleme, çeviri, kod üretimi gibi geniş bağlamın kritik olduğu görevlerde performansı önemli ölçüde etkiler.

Bu kritik sorunu ele almak için Salesforce, 8k token gibi muazzam bir bağlam uzunluğuna sahip XGen-7B modelini duyurdu (benzer diğer LLM’lerden 4 kat daha uzun). Bu makale, modelin temel özelliklerini ele alır ve örnek bir veri kümesi üzerinde nasıl kullanılacağını ve ince ayar yapılacağını gösterir.

Neden XGen 7B’yi Seçmelisiniz?

Çoğu kişi için bağlam uzunluğu gibi istatistikler, somut faydalara dönüşmedikçe pek anlam ifade etmez. İşte bazı ana özellikleri ve kendi projeleriniz üzerindeki olası etkileri:

Kompakt ama güçlü

Görece küçük, 7 milyar parametrelik boyutuna rağmen XGen, ağırlığının çok üstünde bir performans sergiler — çok daha büyük modellerle yarışan, hatta onları aşan sonuçlar verir. Bu verimlilik, geliştiriciler ve araştırmacılar için oyunun kurallarını değiştirir; geniş bulut kaynaklarına gerek kalmadan, üst düzey yerel makinelerde son teknoloji yapay zekâ uygulamalarını çalıştırmayı ve dağıtmayı mümkün kılar. Boyut ve performans arasındaki bu denge, XGen’i küçük girişimlerden akademik araştırmacılara kadar geniş bir kullanıcı kitlesi için özellikle cazip kılar.

Çok yönlü model varyantları

Farklı kullanıcı ihtiyaçlarını gözeten XGen, belirli uygulamalara uygun üç sürüm sunar:

• XGen-7B-4K-base: 4k token dizisi uzunluğuyla, orta büyüklükte bağlam gerektiren görevler için uygundur. Apache 2.0 lisansı altındadır.
• XGen-7B-8K-base: 8k token dizi uzunluğuyla amiral gemisi modeldir; büyük metin bloklarının analizinden fayda sağlayan karmaşık görevler için tasarlanmıştır. Kardeşi gibi Apache 2.0 lisansı altında sunulur; bu da neredeyse her amaçla kullanılabileceği anlamına gelir.
• XGen-7B-{4K,8K}-inst: Kamuya açık yönerge verileriyle ince ayar yapılmış bu modeller, etkileşimli ve yönerge tabanlı uygulamalar için özelleştirilmiştir ve ticari olmayan kullanım için mevcuttur. Bu varyant, eğitim araçları, etkileşimli botlar ve yönlendirme veya talimatın önemli olduğu diğer uygulamalar için idealdir.

Kıyaslamalarda yüksek performans

Modelin gücünün gerçek ölçütü, kıyaslama sonuçlarında görülür. XGen, benzer boyuttaki modellerle karşılaştırıldığında MMLU, HumanEval ve benzeri çeşitli kıyaslarda zirvede yer alır. Derinlemesine bir analiz için, duyuru gönderisi XGen’in kıyaslar genelindeki başarılarına kapsamlı bir bakış sunar.

Uzun dizi görevleri için optimizasyon

Tekrar etme riskine rağmen, XGen’in büyük bağlam pencereleri gerektiren görevler için yüksek düzeyde optimize edildiğini vurgulayayım. Bu yetenek, doğru özetler üretmek için metnin tamamını anlamanın kritik olduğu ayrıntılı belge özetleme gibi uygulamalar için hayati önemdedir. Benzer şekilde kapsamlı soru-cevap ve uzun biçimli içerik üretiminde, XGen’in büyük miktarda bilgiyi işleyebilmesi daha tutarlı ve bağlamsal olarak ilgili çıktılar sağlar.

Salesforce XGen 7B Eğitim Ayrıntıları

Peki XGen bu etkileyici sonuçlara nasıl ulaşıyor? Elbette yanıt, Salesforce yapay zekâ araştırmacılarının kullandığı eğitim ve optimizasyon yöntemlerinde yatıyor.

XGen’in eğitim stratejisi iki aşamadan oluşur. 1. aşamada, sıfırdan bir model; doğal dil verileri ve kod karışımı içeren 1,37 trilyon token üzerinde eğitilir.

İkinci aşamada, daha iyi kod üretimi için ek 55 milyar tokenlık kod kullanılmıştır:

Eğitim, TPU-v4 donanımı için hem veri hem de model paralelleştirmesi altında verimli LLM eğitimi amacıyla özel olarak tasarlanmış JaxFormer adlı kurum içi bir kütüphane kullanılarak gerçekleştirildi.

XGen 7B Önkoşullar ve Kurulum

Küçük boyutuna rağmen XGen 7B, sinir ağları açısından hâlâ oldukça büyük. Bulut kaynakları olmadan çalıştırmayı düşünürseniz, üst düzey yerel makinelere ihtiyaç duyar. Birincil gereksinim, yeterince büyük bir RAM’dir; HuggingFace’ten indirme boyutu ~30 GB olduğundan 32 GB’ın epey üzerinde RAM önerilir. GPU tarafında ise ne kadar büyükse o kadar iyi.

PC’nizde bu özellikler yoksa, en ucuz seçenek 40 GB RAM ve 40 GB GPU vRAM (A100) ile gelen Colab Pro’dur. Bu eğitimde ben Colab Pro kullanıyorum:

Uyumlu bir makine ayarladıktan sonra, modelin kurulum ve indirme zamanı. Yerel olarak ilerliyorsanız, 0. adım bir sanal ortam oluşturmaktır:

$ conda create -n xgen -y
$ conda activate xgen
Altyapı:

Modeli HuggingFace’ten indirmek için GPU destekli torch kurulumu gereklidir. Gerekli tüm kütüphaneleri kurmak için komut:

$ pip install torch torchvision torchaudio transformers[torch]
Altyapı:

İlerideki ince ayar adımı için aşağıdaki kütüphanelere de ihtiyacımız olacak:

$ pip install accelerate peft bitsandbytes trl datasets --upgrade
Altyapı:

Kütüphaneleri kurduktan sonra çekirdeği yeniden başlatmayı unutmayın.

Her bir kütüphaneyi ilgili bölüme geldiğimizde açıklayacağım.

Şimdi, aşağıdaki kod parçasıyla modeli ilk kez çalıştıralım.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Salesforce/xgen-7b-8k-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("Salesforce/xgen-7b-8k-base", torch_dtype=torch.bfloat16)

inputs = tokenizer("DataCamp is one he ...", return_tensors="pt")
sample = model.generate(**inputs, max_length=128)

print(tokenizer.decode(sample[0]))
Altyapı:

AutoTokenizer sınıfı, 4098 uzunluklu xgen-7b-4k-base modelinin otomatik belirteçleyicisini yükler. AutoModelForCausalLM sınıfı ise metin üretimi için modelleri yükler.

İstemi inputs olarak belirtiyor ve model.generate içinde açarak azami 128 token uzunluğu belirliyoruz. Yukarıdaki kod ilk çalıştırmada bir süre alacaktır çünkü model indirilmelidir.

İşte sonunda aldığım çıktı:

DataCamp is one of the world’s leading providers of data science courses and training...Altyapı:

Yanıtın başlangıcı fena değil, ancak sona doğru kademeli olarak kötüleşiyor. Daha iyi performans için ince ayar yapmamız gerekiyor.

Salesforce XGen 7B’ye İnce Ayar Yapma

LLM’ler sklearn modelleri gibi değildir — hiperparametrelerini birkaç satır kodla ayarlayamazsınız. Bu nedenle XGen 7B’ye birkaç adımda ince ayar yapacağız. Bol detay olacağından her adımı sakin kafayla ilerlemenizi öneririm.

Aşağıda özetleyeceğim iş akışının, yeterli hesaplama gücünüz olduğu sürece HuggingFace’teki pek çok LLM için çalışacağını unutmayın.

Başlayalım.

1. Kurulum

Bu adımı zaten önce ele aldık. Şimdi, neden gerekli olduklarını da ekleyerek kurduğumuz kütüphaneleri gözden geçirelim:

• torch: PyTorch; tensörler ve sinir ağları için; GPU hızlandırmasını etkinleştirir.
• transformers: Hugging Face’in önceden eğitilmiş NLP model kütüphanesi.
• datasets: HuggingFace veri kümeleriyle kolay veri yükleme ve işleme.
• accelerate: HuggingFace’in LLM’lerin dağıtık eğitimini basitleştiren resmi kütüphanesi.
• peft: Eğitimi hızlandırmak için LLM parametrelerinin küçük bir kısmına ince ayar yapmayı sağlayan paket.
• bitsandbytes: Bellek ve hesaplama verimliliği açısından LLM optimizasyon kütüphanesi.
• trl: İnsan geribildirimiyle pekiştirmeli öğrenme (RLHF) kullanarak büyük modellere ince ayar teknikleri.

Her kütüphanenin faydalarını, kullanımına geldiğimizde açıklayacağız.

2. Gerekli modüllerin içe aktarılması

import os
import torch

from datasets import load_dataset
from transformers import (
   AutoModelForCausalLM,
   AutoTokenizer,
   BitsAndBytesConfig,
   TrainingArguments,
   pipeline,
)

from peft import LoraConfig
from trl import SFTTrainer
Altyapı:

İçe aktardığımız yeni sınıf ve fonksiyonların genel görünümü:

• BitsAndBytesConfig: Model parametrelerini bits and bytes teknikleriyle optimize etmeye yönelik yapılandırma; bellek ve hesaplama verimliliğini artırır.
• TrainingArguments: İnce ayar eğitimi için öğrenme oranı, yığın boyutu gibi eğitim parametrelerini belirtir.
• pipeline: Metin üretimi gibi görevlere modelleri uygulama sürecini basitleştirir.
• LoraConfig: LoRA (Low-Rank Adaptation) için yapılandırma; modeli uyarlamak için küçük bir parametre setini ayarlayan, parametre-verimli bir ince ayar yöntemi.
• SFTTrainer: Denetimli İnce Ayar (SFT) için eğitici sınıf; insan geribildirimi veya etiketli veri kümeleriyle eğitimi kolaylaştırır.

3. Taban ve ince ayarlı model için yapılandırmaları tanımlayın

# Model from HF
base_model = "Salesforce/xgen-7b-8k-base"

# New instruction dataset
guanaco_dataset = "mlabonne/guanaco-llama2-1k"

# Fine-tuned model
new_model = "xgen-7b-8k-tuned"
Altyapı:

Veri kümesi olarak, etkileşimli ve yönerge tabanlı görevlere (sohbet botlarını düşünün) LLM’lere ince ayar yapmak için 1000 yönerge-çıktı çifti içeren Guanaco LLaMA2 veri kümesini kullanacağız.

4. Veriyi yükleyin

dataset = load_dataset(guanaco_dataset, split="train")Altyapı:

Veriyi HuggingFace’ten yüklemek için veri kümesinin yolunu ve bölünmesini belirterek load_dataset fonksiyonunu kullanırız. Veri kümesini metin biçimine çevirip rastgele bir yönerge-çıktı çiftini indeksleyerek örneklere bakabiliriz:

>>> dataset["text"][89]

<s>[INST] In England, what vegetable is referred to as a rocket? [/INST] The species name for "rocket" is "Eruca vesicaria", and it's also sometimes called "eruca".
However, other countries have different names for it:
* Arugula - America
* Garden Rocket or Rocket - Britain, Australia, South Africa, Ireland, New Zealand

Other names include "ruchetta", "rucola", "rucoli", "rugula", "colewoort", and "roquette".

The word transferred from Latin to Italian to English, which might explain the variants with similar pronunciation. </s>
Altyapı:

5. Kuantizasyon parametrelerini tanımlayın

Kuantizasyon, veriyi temsil etmek için kullanılan bit sayısını azaltmakta kullanılan güçlü bir tekniktir. Bu, orijinal verinin daha az bit ile yaklaşıklandırılmasıyla yapılır ve daha kompakt bir gösterim elde edilir.

Kuantizasyon, bir modelin bellek ayak izini azaltmak, hesaplama verimliliğini artırmak ve bazen doğruluğu dahi iyileştirmek için kullanılabilir.

compute_dtype = torch.float16

quant_config = BitsAndBytesConfig(
   load_in_4bit=True,
   bnb_4bit_quant_type="nf4",
   bnb_4bit_compute_dtype=compute_dta
Altyapı:

Önce her tensör için veri tipini compute_dtype ile float16 olarak ayarlarız. Ardından BitsAndBytesConfig kullanarak aşağıdaki kuantizasyon parametrelerini tanımlarız:

• load_in_4bit=True: Girdilerin 4 bit olarak kuantize edileceğini belirtir.
• bnb_4bit_compute_dtype=compute_dtype: Hesaplamalar için kullanılacak veri tipini belirtir; az önce alınan float16’dır.
• bnb_4bit_quant_type="nf4": 4 bit kuantizasyon için tip belirler; burada "nf4".

nf4, 4 bit ile yapılan, uniform olmayan bir kuantizasyon tipini ifade eder. Uniform olmayana dayalı kuantizasyon, kimi zaman düz uniform kuantizasyondan daha iyi olabilir.

6. Modeli ve parametrelerini tanımlayın

model = AutoModelForCausalLM.from_pretrained(
   base_model,
   quantization_config=quant_config,
   device_map="auto"
)
Altyapı:

Bu adım, XGen’i ilk indirdiğimiz adıma benzer; fakat bu kez quantization_config’e kuantizasyon parametrelerini geçiyor ve device_map’i otomatik olarak GPU’nun kullanılabilmesi için auto olarak ayarlıyoruz.

7. Belirteçleyiciyi yükleyin

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
Altyapı:

Belirteçleyiciyi yükledikten sonra dolgu (padding) belirteci parametrelerini yapılandırırız. NLP’de dolgu belirteçleri, bir anlama sahip olmayan özel sembollerdir ve tüm girişlerin aynı boyuta gelmesi için her giriş belirtecine eklenirler. Sabit boyutlu belirteçler, NLP’deki pek çok model mimarisi için gerekliliktir.

tokenizer.pad_token = tokenizer.eos_token, belirteçleyicinin dolgu belirtecini tümce sonu (EOS) belirteciyle aynı yapar. Bu, modelin tümce sonu ile dolgu belirteçlerini ayırt etmesini sağlayan yaygın bir uygulamadır. tokenizer.padding_side = "right" ise doldurmanın giriş dizilerinin sağına eklenmesini belirtir.

8. PEFT parametreleri

peft_params = LoraConfig(
   lora_alpha=16,
   lora_dropout=0.1,
   r=64,
   bias="none",
   task_type="CAUSAL_LM",
)
Altyapı:

Önceden eğitilmiş LLM’lere ince ayar yapmak, muazzam miktarda veri ve hesaplama kaynağı gerektirir. Parametre-Verimli İnce Ayar (PEFT) kullanarak, toplam model parametrelerinin yalnızca küçük bir kısmına ince ayar yapabilir, böylece çalışma süresini önemli ölçüde azaltabiliriz. Bu teknik hakkında daha fazlasını resmi dokümantasyondan okuyabilirsiniz.

LoraConfig sınıfı, Low-Rank Adaptation yönteminin yapılandırmalarını belirler. LoRA, PEFT içinde kullanılan belirli bir parametreleştirme türüdür. Genel olarak yukarıdaki kod parçası, LoRA katmanlarının uyarlama gücünü, eğitilebilir parametre sayısını ve katmanların diğer yönlerini kontrol eder.

9. Eğitim parametrelerini ayarlama

training_params = TrainingArguments(
   output_dir="./results",
   num_train_epochs=1,
   per_device_train_batch_size=1,
   gradient_accumulation_steps=1,
   optim="paged_adamw_32bit",
   learning_rate=2e-4,
   weight_decay=0.001,
   fp16=False,
   bf16=False,
   max_grad_norm=0.3,
   max_steps=-1,
   warmup_ratio=0.03,
   group_by_length=True,
   lr_scheduler_type="constant",
)
Altyapı:

Şimdiye kadar tanımladıklarımıza ek olarak, XGen’e ince ayar yapmak bir düzine kadar eğitim parametresi daha gerektirir. Bunlar arasında öğrenme oranı, öğrenme oranı planlayıcıları, epoch sayısı, optimize ediciler gibi aşina olduklarımızın yanı sıra warmup_ratio, fp16, bf16, weight_decay gibi yenileri de bulunur.

Odağı dağıtmamak için tüm bu parametrelerin ne yaptığını tek tek ele almayacağız; bunları açıklayan LLaMA2’ye ince ayar üzerine bu harika makaleye yönlendiriyorum.

10. Nihayet ince ayar!

Bir PEFT modeline ince ayar yapmak için, RLHF’nin kilit bir adımı olan trl kütüphanesinden SFTTrainer (Denetimli İnce Ayar) sınıfını kullanacağız.

trainer = SFTTrainer(
   model=model,
   train_dataset=dataset,
   peft_config=peft_params,
   dataset_text_field="text",
   max_seq_length=None,
   tokenizer=tokenizer,
   args=training_params,
   packing=False,
)
Altyapı:

Eğiticiyi başlatmak için modele, eğitim veri kümesine, PEFT parametrelerine, eğitim parametrelerine ve belirteçleyiciye ihtiyacımız var. İnce ayar sürecini başlatmak için yalnızca .train() çağrısı yeterlidir:

trainer.train()
Altyapı:

Eğitim parametrelerine (özellikle epoch sayısına) bağlı olarak eğitim 15 dakikadan saatlere kadar sürebilir.

11. Değerlendirme

Eğitim tamamlandığında, nihayet ince ayarlı modelimizi test edebiliriz:

prompt = "Who wrote Python?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)

result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])
Altyapı:

İstemi ince ayarlı model’e geçmeden önce, model ve tokenizer’ı bir pipeline içine veriyoruz. pipeline işlevi, önceden eğitilmiş modelleri yüklemek, girdiyi belirteçleyiciyle ön işlemek ve varsa üretilen metne özel son işlem adımlarını uygulamak için kullanılır.

Yukarıda, eğitim sırasında kullanılan yönergelerle birebir aynı şekilde <s>[INST] {prompt} [/INST] ile sarmalanmış, özel biçimlendirilmiş bir istemle pipeline’ı çalıştırıyoruz. Sonuç şöyle:

<s>[INST] Who wrote Python? [/INST] Python was created by Guido van Rossum, a Dutch computer programmer. He started working on the language in the late 1980s and released the first version in 1991. </s>

Python is a high-level, general-purpose programming language that is widely used in various fields, including data science, machine learning, and web development. It is known for its readability, flexibility, and ease of use, making it a popular choice for beginners and experienced developers alike. </s>

Python is an open-source language, meaning that anyone can access and modify the source code, making it a popular choice for developers who want to contribute to the community. </s>...
Altyapı:

12. Modeli ve belirteçleyiciyi kaydedin

Modelimizden memnun kaldığımızda, artık kaydedebiliriz:

trainer.model.save_pretrained(new_model)
trainer.tokenizer.save_pretrained(new_model)
Altyapı:

Bunu yeniden yüklemek için yine AutoModelForCausalLM sınıfını kullanabilirsiniz:

fine_tuned_xgen = AutoModelForCausalLM.from_pretrained(new_model, ...)
Altyapı:

Sonuç

Salesforce’un XGen 7B’si gibi Büyük Dil Modelleri (LLM) ile işe başlamak kolaydır; ancak onları belirli ihtiyaçlara göre özelleştirmek daha karmaşıktır. XGen 7B modeline küçük bir yönerge veri kümesiyle yaptığımız ince ayar deneyimi bu zorluğu ortaya koyuyor. Modeli farklı görevlere uyarlamak; ilgili veri kümelerine (Hugging Face’in datasets kütüphanesi üzerinden erişilebilir) ve bu veri kümeleri genelinde 7 milyar parametreli bir modelin eğitimini yönetebilecek hesaplama kaynaklarına erişim gerektirir.

İnce ayar süreci şu adımlarla özetlenebilir:

1. Kütüphanelerin kurulumu
2. Gerekli modüllerin içe aktarılması
3. Genel yapılandırmaların tanımlanması
4. İnce ayar için bir veri kümesinin yüklenmesi
5. bitsandbytes ile kuantizasyon parametrelerinin tanımlanması
6. transformers ile modelin ve başlangıç parametrelerinin tanımlanması
7. Modele uygun bir belirteçleyicinin yüklenmesi
8. LoraConfig ile LoRA katmanları olarak PEFT parametrelerinin tanımlanması
9. transformers üzerinden eğitim parametrelerinin ayarlanması
10. trl içindeki SFTTrainer ile modelin ince ayarının yapılması
11. Örnek istemlerle modelin test/değerlendirilmesi
12. Model ve belirteçleyicinin daha sonra kullanmak üzere kaydedilmesi

Bazı kavramlar veya kod parçaları hâlâ yabancı ya da muğlak geliyorsa, şu mükemmel kaynakları öneririm:

• LLM kavramları kursu
• Python ile LLM’lere Giriş
• Mistral 7B’ye ince ayar
• PyTorch ile LLM eğitimi

Okuduğunuz için teşekkürler!