Llama 3.2’yi İnce Ayarlama ve Yerelde Kullanma: Adım Adım Kılavuz

Son dönemde büyük dil modelleri (LLM’ler) alanı hızla değişiyor. Yeni LLM’ler daha küçük ve daha akıllı olacak şekilde tasarlanıyor; bu da onları daha büyük modellere kıyasla daha ucuz ve kullanımı daha kolay hale getiriyor. 

Llama 3.2’nin piyasaya sürülmesiyle 1B ve 3B varyantları gibi daha küçük modellere erişimimiz var. Bu küçük modeller genel görevlerde büyük modellerin doğruluğuna ulaşamayabilir; ancak müşteri desteği etkileşimlerinde duygu sınıflandırması gibi belirli alanlarda olağanüstü performans gösterecek şekilde ince ayarlanabilirler. Bu yetenek, ilgili alanlarda geleneksel modellerin yerini almalarını mümkün kılar.

Bu eğitimde Llama 3.2 görme ve hafif modellerinin yeteneklerini keşfedeceğiz. Llama 3.2 3B modeline nasıl erişileceğini, onu bir müşteri destek veri kümesi üzerinde nasıl ince ayarlayacağımızı ve ardından Hugging Face hub’ına nasıl birleştirip dışa aktaracağımızı öğreneceğiz. Son olarak modeli GGUF biçimine dönüştürüp Jan uygulamasıyla yerelde kullanacağız.

Yapay zekâya yeni başlıyorsanız, AI Fundamentals beceri yolunu almanız ve ChatGPT, büyük dil modelleri, üretken yapay zekâ ve daha fazlasının temellerini öğrenmeniz şiddetle tavsiye edilir.

Görsel: Yazar

Llama 3.2’ye Giriş

Açık kaynak Llama 3.2 ailesi iki varyanta sahiptir: hafif ve görme modelleri. Görme modelleri görüntü akıl yürütmede ve görme ile dili köprülemede öne çıkarken, hafif modeller çok dilli metin üretimi ve uç cihazlarda araç çağırma konusunda başarılıdır.

Hafif modeller

Hafif modelin iki küçük varyantı vardır: 1B ve 3B. Bu modeller çok dilli metin üretimi ve araç çağırma görevlerinde iyidir. Küçüktürler; bu da verinin cihazdan çıkmamasını sağlar ve düşük hesaplama maliyetiyle yüksek hızlı metin üretimi sunar.

Bu verimli hafif modelleri oluşturmak için Llama 3.2 budama (pruning) ve bilgi damıtma (knowledge distillation) tekniklerini kullanır. Budama, performansı korurken model boyutunu küçültür; bilgi damıtma ise daha büyük ağların bilgisini küçüklere aktararak performansı artırır.

3B model, Gemma 2 (2,6B) ve Phi 3.5-mini gibi modelleri yönerge izleme, özetleme, istem yeniden yazma ve araç kullanımı gibi görevlerde geride bırakır.

Kaynak: Llama 3.2: Açık, özelleştirilebilir modellerle uç yapay zekâ ve görmede devrim

Görme modelleri

Görme modelleri iki varyantla gelir: 11B ve 90B. Bu modeller, görüntü akıl yürütmeyi desteklemek üzere tasarlanmıştır. 11B ve 90B belgeleri, çizelgeleri ve grafikleri anlayıp yorumlayabilir; görüntü altyazılama ve görsel sabitleme (visual grounding) gibi görevleri yerine getirebilir. Bu gelişmiş görsel yetenekler, önceden eğitilmiş görüntü kodlayıcılarının çapraz dikkat katmanlarından oluşan adaptör ağırlıklarıyla dil modellerine entegre edilmesiyle mümkün kılınmıştır.

Claude 3 Haiku ve GPT-4o mini ile karşılaştırıldığında, Llama 3.2 görme modelleri görüntü tanıma ve çeşitli görsel anlama görevlerinde başarılı olmuş; çok modlu yapay zekâ uygulamaları için güçlü araçlar hâline gelmiştir.

Kaynak: Llama 3.2: Açık, özelleştirilebilir modellerle uç yapay zekâ ve görmede devrim

Llama 3.2 kullanım senaryoları, kıyaslamalar, Llama Guard 3 ve model mimarisi hakkında daha fazlasını en güncel blog yazımızı okuyarak öğrenebilirsiniz: Llama 3.2 Rehberi: Nasıl Çalışır, Kullanım Alanları & Daha Fazlası.

Kaggle’da Llama 3.2 Hafif Modellerine Erişim

Llama 3.2 modeli ücretsiz ve açık kaynak olsa da, yine de hüküm ve koşulları kabul edip sitedeki formu doldurmanız gerekir. 

Kaggle platformunda en güncel Llama 3.2 modeline erişmek için:

1. llama.com sitesine gidin ve bilgilerinizi girerek formu doldurun. Hem hafif hem de görme modellerini seçin. 

Kaynak: Llama’ı İndir

2. Meta | Llama 3.2 model sayfasına gidin ve “Submit Form” düğmesine tıklayın. 

Kaynak: Meta | Llama 3.2 | Kaggle

3. Tüm hüküm ve koşulları kabul edin ve “Submit” düğmesine basın. 

Kaynak: Meta | Llama 3.2 | Kaggle

4. Birkaç dakika bekleyin; indirme veya yeni bir not defteri oluşturma seçeneğini gördüğünüzde Dönüştürücüler (Transformers) sekmesini ve model varyantını seçin, ardından “+ New Notebook” düğmesine tıklayın.

5. Kaggle not defteri en yeni Llama modeliyle açılacaktır. Çalışması için hızlandırıcıyı “GPU T4 x2” olarak değiştirmemiz yeterlidir.

6. Transformers ve Accelerate Python paketlerini güncelleyin. 

%%capture
%pip install -U transformers accelerate

7. Tokenizer’ı ve modeli Transformers paketiyle yükleyin. Hugging Face model depo bağlantısı vermek yerine, modelimizin bulunduğu yerel dizini belirtiyoruz.

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


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

model = AutoModelForCausalLM.from_pretrained(
    base_model,
    return_dict=True,
    low_cpu_mem_usage=True,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
)

8. pad_token_id’yi uyarı mesajlarını almamak için ayarlayın.

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_id

9. Model ve tokenizer ile metin üretim hattını (pipeline) oluşturun. 

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

10. Özel istemle hattı çalıştırın. Bizim örneğimizde Vincent van Gogh hakkında soruyoruz.

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])

Yanıt oldukça isabetli. 

11. Karmaşık istemleri anlayıp takip edebildiğini görmek için sistem talimatları verelim. Sonuçları Markdown kodunu birleştirerek HTML olarak göstereceğiz. 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )

Sonuç oldukça doğru. Model yalnızca 3 milyar parametreye rağmen gayet iyi performans gösteriyor.

Llama 3.2 hafif modellere erişmekte zorlanıyorsanız, Llama 3.2 Hafif Modellerine Erişim not defterine bakın.

Kaggle’da Llama 3.2 Görme Modellerine Erişim

Görme modeline erişim basittir ve bu kılavuzda birden fazla GPU kullanacağımız için GPU belleği hakkında endişelenmenize gerek yok. 

1. Meta | Llama 3.2 Vision model sayfasında formu gönderin. Tüm şartları kabul edip “Submit” düğmesine tıklayın. 

Kaynak: Meta | Llama 3.2 Vision | Kaggle

2. Aşağı kaydırın, Transformers sekmesini ve görme model varyantını seçin, ardından “+ New Notebook”a tıklayın.

Kaynak: Meta | Llama 3.2 Vision | Kaggle

3. Hızlandırıcı olarak “GPU T4 x2” kullandığınızdan emin olun. 
4. Transformers ve Accelerate Python paketlerini güncelleyin.

%%capture
%pip install -U transformers accelerate

5. Görüntü işleyiciyi ve Llama 3.2 görme modelini yükleyin. 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

Gördüğümüz gibi neredeyse 25 GB GPU belleği kullanıyor. Bu, bir dizüstü bilgisayarda ya da Google Colab’ın ücretsiz sürümünde çalıştırılamaz.

6. Görüntüyü yükleyin. Eğitimin öne çıkan görselini sağladık: OpenAI o1-preview Eğitimi: Bir Makine Öğrenimi Projesi Oluşturma.
7. Mesajı yazın ve bir sohbet şablonu kullanarak isteme dönüştürün. Mesajı yazın ve bir sohbet şablonu kullanarak isteme dönüştürün. 
8. Hem görüntüyü hem metni işleyip modele verin ve yanıt üretin. 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))

Sonuç olarak görüntünün ayrıntılı bir açıklamasını alıyoruz. Oldukça isabetli. 

Yukarıdaki kodu çalıştırırken sorunlarla karşılaşırsanız lütfen Llama 3.2 Görme Modellerine Erişim Kaggle not defterine bakın.

Llama 3.2 3B Instruct’ı İnce Ayarlama

Bu bölümde, Transformers kütüphanesini kullanarak Llama 3.2 3B Instruct modelini müşteri destek veri kümesi üzerinde nasıl ince ayarlayacağımızı öğreneceğiz. Ücretsiz GPU’lara erişmek ve Colab’dan daha yüksek RAM elde etmek için Kaggle’ı kullanacağız. 

1. Kurulum

Kaggle’da yeni bir not defteri başlatın ve ortam değişkenlerini ayarlayın. Modeli kaydetmek için Hugging Face API’sini, performansı izlemek için Weights & Biases’i kullanacağız.

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

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

İnce ayar ve değerlendirme süreci boyunca kullanacağımız Python paketlerini ve işlevleri 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 SFTTrainer, setup_chat_format

API anahtarını kullanarak Hugging Face CLI’da oturum açın. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

Weights & Biases’te API anahtarıyla oturum açın ve yeni projeyi başlatın. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)

Temel model, veri kümesi ve yeni model adı için değişkenleri ayarlayın. Bu projede birden fazla yerde kullanacağımız için en başta ayarlamak karışıklığı önler.

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"

2. Modeli ve tokenizer’ı yükleme

Veri türünü ve dikkat (attention) uygulamasını ayarlayın.

# Set torch dtype and attention implementation
if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"

Modeli ve tokenizer’ı yerel model dizinini sağlayarak yükleyin. Modelimiz küçük olsa da tam modeli yüklemek ve ince ayarlamak zaman alacaktır. Bunun yerine modeli 4 bit niceleme ile yükleyeceğiz.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)
# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)

3. Veri kümesini yükleme ve işleme

Hugging Face hub’ından Bitext-customer-support-llm-chatbot veri kümesini yükleyeceğiz. Kendi özelleştirilmiş müşteri destek sohbet botumuzu oluşturmak için kullanacağımız melez bir sentetik veri kümesidir.

Yükleyip karıştıracağız ve yalnızca 1000 örnek seçeceğiz. Eğitim süresini azaltmak için modelin küçük bir alt kümesi üzerinde ince ayar yapıyoruz; ancak her zaman tamamını seçebilirsiniz.

Ardından sistem talimatları, kullanıcı sorguları ve asistan yanıtlarını kullanarak "text" sütununu oluşturacağız. Sonrasında JSON yanıtını sohbet biçimine dönüştüreceğiz.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)

Görüldüğü gibi müşteri sorgusunu ve asistan yanıtını sohbet formatında birleştirdik. 

dataset['text'][3]

4. Modeli ayarlama

Modelden doğrusal (linear) modül adını çıkarın. 

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)

Doğrusal modül adını kullanarak LoRA adaptörünü oluşturun. Sadece LoRA adaptörünü ince ayarlayacağız, modelin geri kalanını ise bellek tasarrufu ve daha hızlı eğitim için olduğu gibi bırakacağız. 

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)

Model hiperparametrelerini Kaggle ortamında çalışacak şekilde yapılandırıyoruz. Her bir hiperparametreyi anlamak ve sisteminizdeki eğitimi optimize etmek için Llama 2’yi İnce Ayarlama eğitimine bakabilir ve değişiklik yapabilirsiniz.

#Hyperparamter
training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    eval_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)

Şimdi, denetimli ince ayar (SFT) eğitmenini kuracak ve ona eğitim ve değerlendirme veri kümesi, LoRA yapılandırması, eğitim argümanları, tokenizer ve modeli sağlayacağız. 

# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

5. Model eğitimi

Eğitim sürecini başlatın ve eğitim ile doğrulama kayıp metriklerini izleyin. 

trainer.train()

Eğitim kaybı kademeli olarak azaldı. Bu iyi bir işaret. 

Weights & Biases çalışması tamamlandığında ayrıntılı çalışma geçmişi oluşturulur. 

wandb.finish()

Model metriklerini ayrıntılı incelemek için Weights & Biases panosunu dilediğiniz zaman ziyaret edebilirsiniz.

6. Model çıkarımı

İnce ayarlı modeli test etmek için veri kümesinden bir örnek istem vereceğiz. 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

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

print(text.split("assistant")[1])

İnce ayarlı model üslubu benimsedi ve doğru bir yanıt verdi.

7. Tokenizer ve modeli kaydetme

İnce ayarlı modeli yerelde kaydedin ve Hugging Face hub’ına gönderin. push_to_hub işlevi yeni bir model deposu oluşturur ve model dosyalarını Hugging Face hesabınızdaki depoya yükler. 

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

Kaynak: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Daha büyük Llama 3 modellerini ince ayarlamak için Metin Sınıflandırma için Llama 3.1’i İnce Ayarlama eğitimine göz atmalısınız. Bu eğitim oldukça popülerdir ve LLM’leri tüm göreve nasıl uygulatacağınızı anlamanıza yardımcı olur. 

8. Not defterini kaydetme

Sağ üstteki "Save Version" düğmesine tıklayın, hızlı kaydetme seçeneğini seçin ve kayıt çıktısı seçeneğini model dosyasını ve tüm kodu kaydedecek şekilde değiştirin.

Kod kaynağı, sonuçlar ve çıktı için Müşteri Desteği Üzerinde Llama 3.2’yi İnce Ayarlama Kaggle not defterine göz atın. 

Bu, kod ağırlıklı bir kılavuzdur. LLM’leri ince ayarlamak için kodsuz ya da az kodlu bir kılavuz arıyorsanız LlaMA-Factory WebUI Yeni Başlayanlar Rehberi: LLM’leri İnce Ayarlama içeriğine göz atın. 

İnce Ayarlı Llama 3.2’yi Birleştirme ve Dışa Aktarma 

Yeni bir not defteri oluşturacak ve bellek sorunlarından kaçınmak için daha önce kaydedilen not defterini ekleyerek ince ayarlı LoRA adaptörüne erişeceğiz. 

Temel model “Llama 3.2 3B Instruct”ı da eklediğinizden emin olun.

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

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

Birleştirilen modeli Hugging Face hub’ına göndermek için Hugging Face CLI’da oturum açın. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

Temel modelin ve ince ayarlı LoRA’nın konumunu belirtin. Temel modeli yüklemek ve adaptörle birleştirmek için bunları kullanacağız.

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"

Tokenizer’ı ve tam modeli yükleyin. 

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

base_model_reload= AutoModelForCausalLM.from_pretrained(
    base_model_url,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map="auto",
)

Sohbet biçimini model ve tokenizer’a uygulayın. Ardından temel modeli LoRA adaptörüyle birleştirin.

# Merge adapter with base model
base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()

Modelin başarıyla birleştirildiğini kontrol etmek için örnek istemi verin ve yanıt üretin. 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

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

print(text.split("assistant")[1])

Gördüğümüz gibi, ince ayarlı modelimiz mükemmel şekilde çalışıyor. 

Tokenizer’ı ve modeli yerelde kaydedin. 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)

Tokenizer’ı ve birleştirilmiş modeli Hugging Face model deposuna gönderin.

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

Birkaç dakika sonra Hugging Face deponuzda tüm model dosyalarını ve meta veri dosyalarını görüntüleyebilirsiniz.

Kaynak: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Kaynak kodu ayrıca İnce Ayarlı Llama 3.2’yi Birleştirme ve Dışa Aktarma Kaggle not defterinde inceleyerek birleştirme ve modelinizi Hugging Face hub’ına yükleme hakkında daha fazla bilgi edinebilirsiniz.

Bu projedeki bir sonraki adım, tam modeli GGUF biçimine dönüştürmek ve ardından nicelemektir. Sonrasında Jan, Msty veya GPT4ALL gibi favori sohbet uygulamanızla yerelde kullanabilirsiniz. Tüm LLM’leri GGUF biçimine dönüştürmeyi ve dizüstü bilgisayarınızda yerelde kullanmayı öğrenmek için Llama 3’ü İnce Ayarlama ve Yerelde Kullanma kılavuzunu takip edin.

Birleştirilmiş Modeli GGUF Biçimine Dönüştürme

İnce ayarlı modeli yerelde kullanmak için önce GGUF biçimine dönüştürmemiz gerekir. Neden? Çünkü bu, llama.cpp biçimidir ve masaüstü sohbet botu uygulamalarının tamamınca kabul edilir. 

Birleştirilmiş modeli llama.ccp biçimine dönüştürmek oldukça kolaydır. Tek yapmamız gereken GGUF My Repo Hugging Face Hub sayfasına gitmek. Hugging Face hesabınızla oturum açın. İnce ayarlı model depo bağlantısını “kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot” olarak yazın ve “Submit” düğmesine basın. 

Kaynak: GGUF My Repo

Birkaç saniye içinde modelin nicelemeli sürümü yeni bir Hugging Face deposunda oluşturulacaktır. 

Kaynak: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

“Files” sekmesine tıklayın ve yalnızca GGUF dosyasını indirin. 

Kaynak: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

İnce Ayarlı Modeli Yerelde Kullanma

Jan sohbet botu uygulamasını kullanarak ince ayarlı modelimizi yerelde çalıştıracağız. Resmî siteye, jan.ai adresine gidip uygulamayı indirip kurun. 

Kaynak: Jan

Ayarlar’a tıklayın, “My Models” menüsünü seçin ve “Import Model” düğmesine basın. Ardından modelin yerel dizinini belirtin. 

Sohbet menüsüne gidin ve aşağıda gösterildiği gibi ince ayarlı modeli seçin.

Sağ paneldeki “Assistant” sekmesine tıklayın ve sistem istemini yazın.

Sistem istemi: “Adı John olan, en yüksek puanlı bir müşteri hizmetleri temsilcisisiniz. Müşterilere nazik olun ve tüm sorularını yanıtlayın.”

“Assistant” sekmesinin hemen yanındaki “Model” sekmesine tıklayın ve durdurma belirtecini “<|eot_id|>” olarak değiştirin

Hepsi bu. Yapmanız gereken tek şey, yaşadığınız sorun hakkında müşteri desteği yapay zekâsına soru sormak. 

İstem: “Aynı satıcıdan birden fazla ürünü nasıl sipariş ederim?”

Yanıt doğruydu ve çok hızlıydı—saniyede neredeyse 102 belirteç.

Sonuç

Daha küçük LLM’leri ince ayarlamak maliyetleri düşürmemizi ve çıkarım süresini iyileştirmemizi sağlar. Yeterli veriyle, model performansını belirli görevlerde GPT-4-mini’ye yaklaşacak şekilde artırabilirsiniz. Kısaca, yapay zekânın geleceği, ana-ikincil (master-slave) ilişkisine sahip bir ızgarada birden çok küçük LLM kullanmayı içerir. 

Ana model ilk istemi alır ve yanıtları üretmek için hangi uzmanlaşmış modelin kullanılacağına karar verir. Bu, hesaplama süresini azaltır, sonuçları iyileştirir ve çalışma maliyetlerini düşürür.

Bu eğitimde Llama 3.2’yi ve Kaggle’da nasıl erişileceğini öğrendik. Ayrıca hafif Llama 3.2 modelini müşteri destek veri kümesi üzerinde ince ayarlamayı; belirli bir üslupta yanıt verip alanına özgü doğru bilgi sağlamayı öğretmeyi de öğrendik. Ardından LoRA adaptörünü temel modelle birleştirip tam modeli Hugging Face Hub’a gönderdik. Son olarak, birleştirilmiş modeli GGUF biçimine dönüştürüp Jan sohbet botu uygulamasıyla dizüstü bilgisayarda yerelde kullandık.

Aracı kullanmayı ve modelleri ince ayarlamayı öğrenmek için Working with Hugging Face interaktif kursumuzu alın.