Google Gemma’yı İnce Ayarlama: Özelleştirilmiş Talimatlarla LLM’leri Geliştirme

Yapay zekâ dünyasında heyecan verici bir dönemden geçiyoruz. Google, Meta ve Twitter gibi büyük şirketler, büyük dil modellerini (LLM) açık kaynaklı hâle getirmeye ağırlık veriyor. Google DeepMind ekibi yakın zamanda Gemma’yı yayınladı — Google’ın Gemini modellerini oluşturmak için kullanılan aynı araştırma ve teknolojiden yararlanılarak geliştirilen, hafif ve açık kaynaklı LLM’lerden oluşan bir aile.

Görsel Kaynağı

Burada Gemma modellerini, bulut GPU ve TPU’lar üzerinden bunlara nasıl erişileceğini ve en yeni Gemma 7b-it modelinin rol yapma veri kümesi üzerinde nasıl eğitileceğini öğreneceğiz.

Google’ın Gemma’sını Anlamak

Gemma (Latince “değerli taş”), özellikle Google DeepMind olmak üzere Google’daki çeşitli ekipler tarafından geliştirilen, yalnızca kod çözücü içeren metinden-metne açık modeller ailesidir. Gemini modellerinden ilham alır ve hafif olacak şekilde, tüm büyük çerçevelerle uyumlu biçimde tasarlanmıştır.

Google, Gemma’nın iki boyutu için model ağırlıklarını yayınladı: Gemma 2B ve Gemma 7B. Bunlar, Gemma 2B-it ve Gemma 7B-it gibi, ön eğitimli ve talimatlarla ince ayarlanmış varyantlarla birlikte sunuluyor.

Bilindiği üzere, Gemma teknik bileşenler açısından Gemini ile benzerlik gösterir ve Meta’nın Llama-2 modeli gibi diğer açık modellerle karşılaştırıldığında, kendi boyutları için sınıfının en iyi performansını sergiler. Llama-2’yi tüm LLM karşılaştırmalarında geride bırakmıştır.

Görsel Kaynağı

Gemma; Keras 3.0, yerel PyTorch, JAX ve Hugging Face Transformers gibi çoklu çerçeve araçları da dâhil olmak üzere çok çeşitli araç ve sistemleri destekler. Ayrıca dizüstü, masaüstü, IoT, mobil ve bulut gibi popüler aygıt türlerinde de çalışır.

Artık Keras 3.0 gibi sevdiğiniz makine öğrenimi çerçevesini kullanarak ücretsiz Bulut TPU’larda çıkarım ve denetimli ince ayar (SFT) çalıştırabilirsiniz.

Google ayrıca, geliştiricilerin daha güvenli yapay zekâ uygulamaları oluşturmasına rehberlik etmek için Gemma ile birlikte Sorumlu Üretken Yapay Zekâ Araç Takımı’nı tanıttı; bu araç takımı gerekli araçlar ve güvenlik sınıflandırma yöntemleri sunuyor.

Yapay zekâ ve LLM’lere yeniyseniz, AI Fundamentals yetkinlik yolunu takip etmeniz önerilir. Bu yol, ChatGPT, büyük dil modelleri, üretken yapay zekâ ve daha fazlası gibi popüler konularda pratik bilgi edinmenizi sağlar.

Google’ın Gemma Modeline Nasıl Erişilir

Gemma’ya erişmek son derece kolay; HuggingChat ve Poe üzerinde ücretsiz olarak kullanmaya başlayabilirsiniz. Model ağırlıklarını Hugging Face’ten indirip GPT4ALL veya LMStudio ile yerel olarak da kullanabilirsiniz.

Bu bölümde, Gemma modelini yüklemeyi ve Kaggle platformunun sunduğu ücretsiz GPU ve TPU’lar ile çıkarım çalıştırmayı öğreneceğiz.

TPU’larda Gemma Çıkarımı Çalıştırma

Keras/Gemma sayfasına gidip aşağı kaydırın, “gemma_instruct_2b_en” model varyantını seçin ve “New Notebook” düğmesine tıklayın. Bu işlem, giriş dizininde Gemma modeli bulunan bir Bulut Defteri başlatacaktır.

Sağ panele gidip aşağı kaydırarak hızlandırıcı olarak “TPU VM v3-8” seçeneğini işaretleyin.

Gerekli tüm Python kütüphanelerini yüklediğinizden ve güncellediğinizden emin olun.

!pip install -q tensorflow-cpu
!pip install -q -U keras-nlp tensorflow-hub
!pip install -q -U keras>=3
!pip install -q -U tensorflow-textAltyapı:

Kullanılabilir TPU sayısını kontrol etmek için `jax` kütüphanesini ve `device` işlevini kullanarak TPU aygıtlarını görüntüleyebilirsiniz. 8 TPU’ya erişimimiz var.

import jax

jax.devices()Altyapı:

[TpuDevice(id=0, process_index=0, coords=(0,0,0), core_on_chip=0),
 TpuDevice(id=1, process_index=0, coords=(0,0,0), core_on_chip=1),
 TpuDevice(id=2, process_index=0, coords=(1,0,0), core_on_chip=0),
 TpuDevice(id=3, process_index=0, coords=(1,0,0), core_on_chip=1),
 TpuDevice(id=4, process_index=0, coords=(0,1,0), core_on_chip=0),
 TpuDevice(id=5, process_index=0, coords=(0,1,0), core_on_chip=1),
 TpuDevice(id=6, process_index=0, coords=(1,1,0), core_on_chip=0),
 TpuDevice(id=7, process_index=0, coords=(1,1,0), core_on_chip=1)]Altyapı:

Şimdi Keras 3 için arka uç olarak `jax` ayarlayarak TPU’yu etkinleştireceğiz.

import os

os.environ["KERAS_BACKEND"] = "jax"Altyapı:

İlk kurulumdan sonra, Gemma modeline erişmek ve yanıt üretmek oldukça kolaydır. Kaggle’dan modeli yüklemek için `keras_nlp` kütüphanesini kullanacak, ardından istemi `generate` işlevine vereceğiz.

import keras
import keras_nlp

model_name = "/kaggle/input/gemma/keras/gemma_instruct_2b_en/2"
gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
prompt = "Can you share an interesting fact about Leonardo da Vinci?"

gemma_lm.generate(prompt, max_length=100)Altyapı:

Sonuç şöyle:

"Can you share an interesting fact about Leonardo da Vinci?\n\nSure, here's an interesting fact about Leonardo da Vinci:\n\nLeonardo da Vinci was born in a village called Vinci, Italy, which is now part of the city of Florence."

Kaggle defterini (Gemma-2B-V2 Simple Inference on TPU) kolayca çalıştırabilir ve ücretsiz TPU’larla yanıt üretmeye başlayabilirsiniz.

GPU’larda Gemma Çıkarımı Çalıştırma

Şimdi, Keras yerine bir transformer çerçevesi kullanarak GPU’lar üzerinde yanıt üretmeyi öğreneceğiz.

google/gemma sayfasına gidin, aşağı kaydırıp transformers’ı seçin, “7b-it” model varyantını işaretleyin ve “New Notebook” düğmesine tıklayın. Bu işlem, giriş dizininde doğru Gemma sürümünün bulunduğu bir Bulut Defteri başlatır.

Not: Sayfayı daha da aşağı kaydırarak çıkarım bölümüne ulaşabilirsiniz. Burada bir istem girip tüm Gemma varyantlarını test edebilir ve yanıt üretebilirsiniz. Hızlı ve pratiktir.

Yeni defterde başlığı değiştirin ve ardından hızlandırıcıyı GPT T4 x2 olarak ayarlayın.

Gerekli tüm Python paketlerini yükleyip güncelleyin.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerateAltyapı:

Sınırlı VRAM nedeniyle, Kaggle GPU’larında Gemma 7b-it modelinin tamamını yükleyemiyoruz. Bunu aşmak için, BitsAndBytes kullanarak NF4 türü yapılandırmayla 4 bit niceleme ile modeli yükleyeceğiz. Ayrıca, belirteçleyiciyi de yükleyin.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig

modelName = "/kaggle/input/gemma/transformers/7b-it/2"

bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    modelName,
    device_map = "auto",
    quantization_config=bnbConfig
)

tokenizer = AutoTokenizer.from_pretrained(modelName)Altyapı:

Sistem, Kullanıcı ve Yapay Zekâ bölümlerini içeren basit bir istem şablonu oluşturun. Modelden, Python kullanarak yıldız desenini gösteren kod üretmesini istedik.

Nihai istemi bir belirteçleyiciden geçirip ardından modele vererek çıktı üreteceğiz. Daha sonra bu çıktıları çözüp yanıtı bir metin dizesine dönüştüreceğiz. Son olarak, yanıtı Markdown biçeminde göstermek için Markdown işlevini kullanacağız.

from IPython.display import Markdown, display
system =  "You are a skilled software engineer who consistently produces high-quality Python code."
user = "Write a Python code to display text in a star pattern."

prompt = f"System: {system} \n User: {user} \n AI: "
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

Markdown(text.split("AI:")[1])Altyapı:

Görüldüğü gibi, Gemma 7b-it işi gayet iyi yapıyor.

Kodu, Gemma-7B Simple Inference on GPU adlı Kaggle defterini klonlayarak kendiniz de çalıştırabilirsiniz.

Google’ın Gemma’sını Nasıl İnce Ayarlarsınız: Adım Adım Kılavuz

Bu bölümde, Gemma 7b-it modelini hieunguyenminh/roleplay veri kümesi üzerinde ince ayarlamayı öğreneceğiz. Hızlandırıcı olarak Kaggle GPU P100 kullanacağız.

Her adımı ayrıntılı biçimde anlamak için LLM’leri İnce Ayarlamaya Giriş Kılavuzu yazımızı okuyun.

Kurulum

Hataları önlemek için gerekli tüm Python paketlerini yüklemek ve güncellemek önemlidir.

%%capture 
%pip install -U bitsandbytes 
%pip install -U transformers 
%pip install -U peft 
%pip install -U accelerate 
%pip install -U trl
%pip install -U datasetsAltyapı:

Veri kümesini, modeli ve belirteçleyiciyi yüklemek; denetimli ince ayar (SFT) ve çıkarım yapmak için kullanacağımız tüm paketleri yükleyin.

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainerAltyapı:

Temel model ve veri kümesi için adları, ayrıca daha sonra Hugging Face Hub’a yükleyeceğimiz ince ayarlı modelin adını tanımlayın.

Bu değişkenler; veri kümesi ve modeli yükleme, belirteçleme, eğitim ve modeli kaydetme gibi çeşitli aşamalarda kullanılacaktır.

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "gemma-7b-it-v2-role-play"Altyapı:

Hugging Face CLI’da oturum açma

Hugging Face API anahtarını Kaggle sırlarından (ortam değişkenlerinden) yükleyeceğiz.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Altyapı:

Modeli erişmek ve Hugging Face Hub’da kaydetmek için API anahtarını kullanarak Hugging Face CLI’da oturum açın.

!huggingface-cli login --token $secret_hfAltyapı:

W&B çalışma alanını başlatma

W&B API anahtarını kullanarak Weights & Biases (W&B) çalışma alanını başlatın. Bu çalışma alanını model eğitimini izlemek için kullanacağız.

secret_wandb = user_secrets.get_secret("wandb")

# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning Gemma 7B', 
    job_type="training", 
    anonymous="allow"
)Altyapı:

Veri kümesini yükleme

Hugging Face’te bulunan rol yapma veri kümesinin ilk 1000 satırını alın ve `text` sütunundan bir örnek görüntüleyin.

#Loading the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]Altyapı:

Veri kümemiz, ünlülerin tarzına dayalı olarak kullanıcı ile asistan arasında geçen kesintisiz bir sohbetten oluşuyor. Yani rol yapma formatında.

Modeli ve belirteçleyiciyi yükleme

Bellek sorunlarından kaçınmak için modelimizi BitsAndBytesConfig kullanarak 4 bit hassasiyetle yükleyeceğiz. Model, indirilmeden doğrudan Kaggle’dan yüklenecek.

# Load base model(Gemma 7B-it)
bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
        base_model,
        quantization_config=bnbConfig,
        device_map="auto"
)

model.config.use_cache = False # silence the warnings. Please re-enable for inference!
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()Altyapı:

Belirteçleyiciyi yükleyin ve fp16 ile ilgili sorunu gidermek için pad belirtecini yapılandırın.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenAltyapı:

Adaptör katmanı ekleme

Modelimize adaptör katmanı ekleyerek daha verimli biçimde ince ayar yapabiliriz. Tüm modeli eğitmek yerine yalnızca adaptör katmanlarının parametrelerini güncellememiz yeterli olur; bu da eğitim sürecini hızlandırır.

Hedef modüllerimiz 'o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj' ve 'gate_proj' olacaktır.

model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj']
)
model = get_peft_model(model, peft_config)Altyapı:

Modeli eğitme

Eğitime başlamak için hiperparametreleri belirtmemiz gerekir. Bu parametreler temel düzeydedir ve eğitim sürecini iyileştirmek ve modelin performansını artırmak için değiştirilebilir.

Her bir hiperparametreyi daha iyi kavramak isterseniz LLaMA 2’yi İnce Ayarlama eğitimini okumanızı öneririz.

training_arguments = TrainingArguments(
    output_dir="./gemma-7b-v2-role-play",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_strategy="epoch",
    logging_steps=100,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)Altyapı:

Denetimli İnce Ayar (SFT) eğiticisini kurmak için modele, veri kümesine, Lora yapılandırmasına, belirteçleyiciye ve eğitim parametrelerine bağımsız değişken olarak vermemiz gerekir.

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

Şimdi eğitim sürecini `.train` işleviyle çalıştıracağız. İnce ayar yaklaşık 1 saat 1 dakika sürdü. Eğitim kaybı kademeli olarak azaldı; dönem sayısını artırarak bu kaybı daha da düşürebilirsiniz.

trainer.train()Altyapı:

W&B oturumunu sonlandırın ve modeli çıkarım için yapılandırın.

wandb.finish()
model.config.use_cache = TrueAltyapı:

Modeli iki tür GPU hızlandırıcıda eğittik. Görünüşe göre P100, T4 2X’ten iki kat daha hızlıydı.

Modeli kaydetme

Şimdi model adaptörünü yerel olarak kaydedecek ve ardından modeli Hugging Face hub’ına yükleyeceğiz. `push_to_hub` komutu, depoyu oluşturacak ve adaptör yapılandırması ile adaptör ağırlıklarını hub’a gönderecektir.

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Altyapı:

Not: Burada yalnızca bir adaptörü kaydediyoruz; tamamı yaklaşık 18 GB olan tam modeli değil.

Profil sayfasına gidip yeni modeli kontrol ederek Hugging Face üzerinde görüntüleyebiliriz.

Görsel Kaynağı

Model çıkarımı

İnce ayarlı modelimizi kullanarak yanıt üretmek için birkaç adımı izlememiz gerekir.

Önce, rol yapma veri kümesi biçiminde bir istem oluşturacağız. Ardından istemi belirteçleyiciye, sonrasında modele vererek tahmin üreteceğiz.

Tahmin edilen çıktıyı okunabilir metne dönüştürmek için belirteçleyiciyle çözeceğiz.

prompt = '''<|system|>Harry Potter is a wizard known for his distinctive lightningshaped scar and his remarkable journey through magic and battles against the dark wizard Voldemort.
<|user|> What is the meaning of hate? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)Altyapı:

Hiç fena değil. Ayrıca ilgili takip soruları da soruyor.

Yeni bir karakterle tekrar deneyin: Michel Jordan.

prompt = '''<|system|>Michael Jordan an NBA legend known for his competitive drive six championship wins with the Chicago Bulls.
<|user|> What motivates you in the life? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)Altyapı:

Temel modeli, yeni yanıt üretim tarzını anlaması için ince ayarlamada iyi bir iş çıkardığımızı düşünüyorum.

Modelinizi kendi veri kümeniz üzerinde ince ayarlamada zorluk yaşıyorsanız, lütfen Gemma-7B 4-bit QLoRA Fine-tuning Kaggle defterine göz atın.

Ayrıca, oyunun en iyisi ve en yüksek performanslı modeli nasıl ince ayarlayacağınızı OpenAI’nin GPT-4’ünü İnce Ayarlama eğitimini takip ederek öğrenebilirsiniz.

Rol Yapma Adaptörüyle Gemma 7B Çıkarımı

Yanıt üretmek için, kaydedilen adaptörü tek başına yükleyemeyiz. İnce ayarlı adaptörü temel model (Gemma 7b-it) ile birleştirmemiz gerekir.

Bu bölümde, temel modeli ve adaptörü nasıl yükleyip birleştirerek yanıt üreteceğimizi öğreneceğiz.

1. Gerekli tüm Python kütüphanelerini yükleyin.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftAltyapı:

2. API anahtarını Kaggle sırlarından yükleyin ve Hugging Face CLI’da oturum açın.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Altyapı:

!huggingface-cli login --token $secret_hfAltyapı:

3. Temel modelin ve adaptörün konumunu belirtin.

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
new_model = "kingabzpro/gemma-7b-it-v2-role-play"Altyapı:

4. Temel modeli yükleyin.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch



base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)Altyapı:

5. Adaptörü yükleyip temel modelle birleştirin

model = PeftModel.from_pretrained(base_model_reload, new_model)Altyapı:

6. 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ı:

7. Yanıt üretimi için istemi belirteçleyiciden, ardından modelden geçirin.

prompt = '''<|system|> Alan Watts's colorful journey explored the depths of philosophy and religion, weaving together Eastern wisdom and Western insights.
<|user|> What does the self actually amount to? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)Altyapı:

Alan Watts, “benlik” kavramının anlamını mükemmel biçimde açıklıyor.

Temel modeli adaptörle birleştirmek için kullanılan kod kaynağına Rol Yapma Adaptörüyle Gemma 7B Çıkarımı bağlantısından ulaşabilirsiniz.

Kendi Llama 2 Modelinizi İnce Ayarlama webinarına kaydolun ve sektör uzmanının video eğitimini izleyin.

Son Düşünceler

Google, yıllar önce büyük dil modelleri devrimini başlatmıştı ancak bunun meyvelerini yeterince toplayamadı. Şimdi şirket, yeniden sektör lideri olmak için stratejisinde gerekli değişiklikleri yapıyor.

Açık kaynaklı Gemma modelinin yakın zamanda piyasaya sürülmesiyle Google, yapay zekâ araştırmalarını teşvik etme yolunda bir adım attı ve bunun karşılığında gelecekte çok daha iyi modeller geliştirebilecek.

Şirket nihayet açık kaynak topluluğunun gücünü ve bundan nasıl yararlanabileceğini idrak etti. Google; Kaggle, Colab ve Vertex AI gibi platformlar ile bulut ortamlarını ve yerel çerçeveleri kullanarak açık kaynak topluluğundan en iyi şekilde faydalanmayı ve rekabette öne geçmeyi hedefliyor.

Bu eğitimde, Gemma modellerini ve bunlara bulut GPU ve TPU’lar aracılığıyla nasıl erişileceğini öğrendik. Ayrıca, en yeni Gemma 7b-it modelinin bir rol yapma veri kümesiyle nasıl ince ayarlandığı süreci de ele aldık.

Yapay zekâ yolculuğunuzun bir sonraki adımı, kendi LLM tabanlı uygulamanızı oluşturmaktır. LangChain ile LLM uygulamaları nasıl geliştirilir eğitimine göz atın ve son teknoloji yapay zekâ uygulamaları geliştirmek için güçlü bir Python çerçevesini nasıl kullanacağınızı keşfedin.