Mistral 7B Eğitimi: Mistral 7B'yi Kullanma ve İnce Ayar Yapma için Adım Adım Kılavuz

Mistral 7B'ye Erişim

Mistral 7B'ye HuggingFace, Vertex AI, Replicate, Sagemaker Jumpstart ve Baseten üzerinden erişebiliriz.

Modele erişmenin, Kaggle'ın Models adlı yeni özelliği sayesinde yeni ve daha iyi bir yolu daha var. Bu, modeli veya veri setini indirmenize gerek olmadığı, birkaç dakika içinde çıkarım veya ince ayara başlayabileceğiniz anlamına gelir.

Bu bölümde, Kaggle modelini yüklemeyi ve birkaç dakika içinde çıkarım çalıştırmayı öğreneceğiz.

Başlamadan önce, KeyError: 'mistral hatasından kaçınmak için temel kütüphaneleri güncellememiz gerekiyor.

!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytes

Bundan sonra, modelimizi 4-bit hassasiyette yüklemek için BitsAndBytes kullanarak NF4 türü yapılandırmayla 4-bit miktarlandırma oluşturacağız. Bu, modeli daha hızlı yüklememize ve bellek kullanımını azaltmamıza yardımcı olur; böylece Google Colab veya tüketici GPU'larında çalıştırılabilir.

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

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

Şimdi Mistral 7B modelini Kaggle Notebook'umuza eklemeyi öğreneceğiz.

Görsel: Mistral | Kaggle

1. Sağ yan paneldeki “+Add Models” düğmesine tıklayın.
2. Modelinizi arayın ve eklemek için Artı düğmesine tıklayın.
3. Doğru varyasyonu “7b-v0.1-hf” ve sürümü seçin.
4. Ardından, dizin yolunu kopyalayıp notebook'unuza ekleyin.

Şimdi modeli ve belirteçleyiciyi (tokenizer) transformers kütüphanesini kullanarak yükleyeceğiz.

model_name = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
        model_name,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
    )

İşi kolaylaştırmak için, Transformers kütüphanesindeki pipeline işlevini kullanarak isteme (prompt) dayalı yanıt üreteceğiz.

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer = tokenizer, 
    torch_dtype=torch.bfloat16, 
    device_map="auto"
)

Ardından, pipeline nesnesine istem verecek ve en fazla yeni belirteç sayısını belirlemek ve yanıtımızı iyileştirmek için ek parametreler ayarlayacağız.

prompt = "As a data scientist, can you explain the concept of regularization in machine learning?"

sequences = pipe(
    prompt,
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

Görüldüğü gibi, Mistral 7B makine öğrenmesinde düzenlileştirme sürecini açıklayan düzgün sonuçlar üretti.

As a data scientist, can you explain the concept of regularization in machine learning?

Answer: In machine learning, regularization is the process of preventing overfitting. Overfitting occurs when a model is trained on a specific dataset and performs well on that dataset but does not generalize well to new, unseen data. Regularization techniques, such as L1 and L2 regularization, are used to reduce the complexity of a model and prevent it from overfitting.

Kaggle üzerinde Mistral 7B 4-bit çıkarım defterini kopyalayıp kodu çalıştırabilirsiniz.

Not: Kaggle, modeli 4-bit miktarlandırma olmadan yüklemeniz için yeterli GPU belleği sağlar. Nasıl yapıldığını öğrenmek için Mistral 7B Basit Çıkarım defterini takip edebilirsiniz.

Mistral 7B İnce Ayarı

Bu bölümde, en sevdiğimiz veri seti guanaco-llama2-1k üzerinde Mistral 7B modeline ince ayar yapmak için LLaMA 2'ye İnce Ayar: Büyük Dil Modelini Özelleştirmek için Adım Adım Kılavuz rehberindeki benzer adımları uygulayacağız. Ayrıca PEFT, 4-bit miktarlandırma, QLoRA ve SFT hakkında bilgi edinmek için rehberi okuyabilirsiniz.

Kurulum

Gerekli Python kütüphanelerini güncelleyecek ve kuracağız.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl

Bundan sonra, modelin etkili şekilde ince ayarı için gerekli modülleri yükleyeceğiz.

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 SFTTrainer

Modelimize ince ayar yapmak için Kaggle Notebook kullanıyoruz. API anahtarlarını güvenle depolamak için "Add-ons" düğmesine tıklayıp "Secret" seçeneğini belirleyeceğiz. Notebook içinde API'ye erişmek için, aşağıda gösterildiği gibi kod parçacığını kopyalayıp çalıştıracağız.

Bizim durumumuzda Hugging Face ve Weights and Biases API anahtarlarını kaydedip Kaggle defterinde bunlara erişeceğiz.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")

Modeli Hugging Face Hub'a kaydetmek ve göndermek için Hugging Face API'sini kullanacağız.

!huggingface-cli login --token $secret_hf

LLM performansını izlemek için, API kullanarak Weights and Biases deneylerini başlatacağız.

wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning mistral 7B', 
    job_type="training", 
    anonymous="allow"
)

Bu bölümde, temel modeli, veri setini ve yeni model adını belirleyeceğiz. Yeni modelin adı, ince ayar yapılmış modeli kaydetmek için kullanılacaktır.

Not: Colab'ın ücretsiz sürümünü kullanıyorsanız, modelin parçalanmış sürümünü (someone13574/Mistral-7B-v0.1-sharded) yüklemelisiniz.

Ayrıca, temel model adını kullanarak modeli Hugging Face Hub'dan da yükleyebilirsiniz: mistralai/Mistral-7B-v0.1

base_model = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"
dataset_name = "mlabonne/guanaco-llama2-1k"
new_model = "mistral_7b_guanaco"

Veri yükleme

Şimdi veri setini Hugging Face Hub'dan yükleyecek ve 100. satırı görselleştireceğiz.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset["text"][100]

Mistral 7B modelini yükleme

Şimdi daha hızlı eğitim için Kaggle üzerinden 4-bit hassasiyetle bir model yükleyeceğiz. Tüketici bir GPU üzerinde modeli yüklemek ve ince ayar yapmak istiyorsanız bu adım gereklidir.

bnb_config = BitsAndBytesConfig(  
    load_in_4bit= True,
    bnb_4bit_quant_type= "nf4",
    bnb_4bit_compute_dtype= torch.bfloat16,
    bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
)
model.config.use_cache = False # silence the warnings
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()

Belirteçleyiciyi Yükleme

Sonraki adımda, belirteçleyiciyi yükleyecek ve fp16 ile ilgili sorunu giderecek şekilde yapılandıracağız.

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_token

Katmana adapter ekleme

Bir sonraki adımda, modelimize bir adapter katmanı ekleyeceğiz. Bu, az sayıda parametre kullanarak modele ince ayar yapmamızı sağlar ve tüm süreci daha hızlı ve bellek açısından verimli hale getirir. Parametreler hakkında daha iyi bir anlayış için PEFT'in resmî belgelerine bakabilirsiniz.

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=["q_proj", "k_proj", "v_proj", "o_proj","gate_proj"]
)
model = get_peft_model(model, peft_config)

Hiperparametreler

Doğru hiperparametreleri belirlemek kritik öneme sahiptir. Her bir hiperparametre hakkında bilgi edinmek için LLaMA 2'ye İnce Ayar eğitimini okuyabilirsiniz.

training_arguments = TrainingArguments(
    output_dir="./results",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_steps=25,
    logging_steps=25,
    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",
    report_to="wandb"
)

SFT parametreleri

HuggingFace'in TRL kütüphanesi, az kodla veri setiniz üzerinde Denetimli ince ayar (SFT) modelleri oluşturup eğitmenize olanak tanıyan kullanıcı dostu bir API sunar. SFT Trainer'a model, veri seti, Lora yapılandırması, belirteçleyici ve eğitim parametreleri gibi gerekli bileşenleri sağlayacağız.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= None,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Model eğitimi

Her şeyi ayarladıktan sonra modelimizi eğiteceğiz.

trainer.train()

T4 x2 sürümü GPU kullandığınızı ve bunun eğitim süresini 1 saat 30 dakikaya düşürebileceğini unutmayın.

İnce ayarlı modeli kaydetme

Son aşamada, önceden eğitilmiş adapter'ı kaydedecek ve W&B oturumunu sonlandıracağız.

trainer.model.save_pretrained(new_model)
wandb.finish()
model.config.use_cache = True

Modelimizi tek satırlık bir kodla Hugging Face Hub'a kolayca yükleyebilir, böylece herhangi bir makinadan erişebiliriz.

trainer.model.push_to_hub(new_model, use_temp_dir=False)

Model değerlendirme

Sistem metriklerini ve model performansını wandb.ai'ye gidip son çalışmayı kontrol ederek görüntüleyebilirsiniz.

Görsel: wandb.ai

Model çıkarımı gerçekleştirmek için, pipeline'a hem model hem de belirteçleyici nesnelerini sağlamamız gerekir. Ardından, pipeline nesnesine veri seti tarzında istem verebiliriz.

logging.set_verbosity(logging.CRITICAL)

prompt = "How do I find true love?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Başka bir istem için yanıt oluşturalım.

prompt = "What is Datacamp Career track?"
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Görünen o ki basit sorularımıza kusursuz yanıtlar alıyoruz.

Mistral 7B için önemli bağlantılar:

• Mistral 7B İnce Ayar Defteri
• Mistral 7B İnce Ayarlı Model

Görsel: Mistral 7B 4bit QLoRA İnce Ayar | Kaggle

Mistral 7B Instruct için önemli bağlantılar:

• Mistral 7B Instruct İnce Ayar Defteri

Mistral 7B Instruct İnce Ayarlı Model

Adapter'ı birleştirme

Bu bölümde, temel modeli yükleyip PeftModel kullanarak adapter'ı ekleyecek, çıkarım çalıştıracak, model ağırlıklarını birleştirecek ve Hugging Face Hub'a göndereceğiz.

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

Adapter ile temel modeli yükleyin

Önce, peft kullanarak temel modeli ve ince ayarlı adapter'ı yeniden yükleyeceğiz. Aşağıdaki işlev, adapter'ı temel modele ekleyecektir.

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        device_map="auto",
        trust_remote_code=True,
)

model = PeftModel.from_pretrained(base_model_reload, new_model)

Belirteçleyiciyi yeniden yükleyin

Temel model belirteçleyicisini yükleyin ve fp16 ile ilgili sorunu giderin.

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

Çıkarım

Belirteçleyici ve model ile bir çıkarım hattı (pipeline) oluşturun.

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer = tokenizer, 
    torch_dtype=torch.bfloat16, 
    device_map="auto"
)

İstemi verin ve yanıt üretmek için pipeline'ı çalıştırın.

prompt = "How become a DataCamp certified data professional"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

İnce ayarlı modeli gönderme

Şimdi adapter'ı temel modelle birleştireceğiz; böylece ince ayarlı modeli, orijinal Mistral 7B modeli gibi doğrudan kullanabilir ve çıkarım çalıştırabilirsiniz. Bunun için merge_and_unload işlevini kullanacağız.

Modeli birleştirdikten sonra hem belirteçleyiciyi hem de modeli Hugging Face Hub'a göndereceğiz. Bir yerde takılırsanız Kaggle defterini de takip edebilirsiniz.

model = model.merge_and_unload()

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)

Görsel: kingabzpro/mistral_7b_guanaco

Gördüğünüz gibi, yalnızca bir adapter yerine artık 13,98 GB boyutunda tam bir modele sahibiz.

Görsel: kingabzpro/mistral_7b_guanaco

İnce ayarlı modele erişim

Temel modelin yardımına gerek kalmadan yükleyip çıkarım çalıştırabileceğimizi göstermek için, ince ayarlı modeli Hugging Face Hub'dan yükleyip çıkarım çalıştıracağız.

from transformers import pipeline


pipe = pipeline(
    "text-generation", 
    model = "kingabzpro/mistral_7b_guanaco",
    device_map="auto"
)

prompt = "How do I become a data engineer in 6 months?"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=200, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,)

print(sequences[0]['generated_text'])

Sonuç

Mistral 7B, büyük dil modeli yeteneklerinde heyecan verici bir ilerlemeyi temsil ediyor. Grouped-query Attention ve Sliding Window Attention gibi yenilikler sayesinde, dağıtıma uygun kalırken son teknoloji performans elde ediyor.

Bu eğitimde, Mistral 7B modeline Kaggle üzerinden nasıl erişileceğini öğrendik. Ayrıca, modeli küçük bir veri seti üzerinde nasıl ince ayar yapacağımızı ve adapter'ı temel modelle nasıl birleştireceğimizi gördük.

Bu kılavuz, büyük dil modelini tüketici GPU'larında denemek ve eğitmek isteyen hem makine öğrenmesi meraklıları hem de yeni başlayanlar için kapsamlı bir kaynaktır.

Büyük dil modellerine yeni başlıyorsanız, LLM Kavramlarında Usta Olun kursunu öneririz. Yapay zekâ alanında kariyere başlamak isteyenler için AI Fundamentals beceri yoluna kaydolmak harika bir ilk adımdır.

Kaynaklar

• Resmî Blog
• GitHub
• Araştırma Makalesi
• Hugging Face
• Ollama