Llama 3’ü İnce Ayarlama ve Yerelde Kullanma: Adım Adım Kılavuz

Llama 3’ü Anlamak

Meta, Llama 3 adlı, önceden eğitilmiş ve talimatla ince ayarlanmış metinden-metine modellerden oluşan yeni bir büyük dil modeli (LLM) serisi yayımladı.

Llama 3, optimize edilmiş bir transformer mimarisi kullanan oto-gerileyici bir dil modelidir. Hem önceden eğitilmiş hem de talimatla ince ayarlanmış sürümler, 8B ve 70B parametreli olarak 8K belirteç bağlam uzunluğuyla gelir.

Llama 3 8B, Hugging Face’te en çok beğenilen LLM’dir. Talimatla ince ayarlı sürümü, çeşitli performans metriklerinde Google Gemma 7B-It ve Mistral 7B Instruct’tan daha iyidir. 70B talimatla ince ayarlı sürüm ise çoğu performans metriğinde Gemini Pro 1.5 ve Claude Sonnet’i geride bırakmıştır:

Kaynak: Meta Llama 3

Meta, Llama 3’ü herkese açık çevrimiçi verilerin yeni bir karması üzerinde, 15 trilyondan fazla belirteçle eğitti. 8B modelinin bilgi kesim tarihi Mart 2023, 70B modelinin ise Aralık 2023’tür. Modeller, bellek bant genişliğini azaltıp verimliliği artıran Grouped-Query Attention (GQA) kullanır.

Llama 3 modelleri özel bir ticari lisans altında yayımlanmıştır. Modele erişmek için adınız, kurumunuz ve e-postanızla formu doldurmalı ve hüküm ve koşulları kabul etmelisiniz. Kaggle ve Hugging Face gibi farklı platformlar için farklı e-postalar kullanıyorsanız formu birden fazla kez doldurmanız gerekebilir.

Llama 3 hakkında daha fazla bilgi için şu makaleye göz atabilirsiniz: Llama 3 nedir?.

1. Llama 3’ü İnce Ayarlama

Bu eğitimde, ruslanmv/ai-medical-chatbot veri kümesini kullanarak Llama 3 8B-Chat modelini ince ayarlayacağız. Veri kümesi, bir hasta ile doktor arasında 250 bin diyaloğu içerir. Bu model ve ücretsiz GPU’lara erişim için Kaggle Notebook kullanacağız.

Kurulum

Kaggle Notebook’u başlatmadan önce, Meta indirme formunu Kaggle e-posta adresinizle doldurun; ardından Kaggle’daki Llama 3 model sayfasına gidip sözleşmeyi kabul edin. Onay süreci bir ila iki gün sürebilir.

Şimdi şu adımları izleyelim:

1. Kaggle’da yeni bir Notebook başlatın ve + Add Input düğmesine tıklayıp Models seçeneğini belirleyerek Llama 3 modelinin yanındaki + düğmesine basıp modeli ekleyin. Ardından doğru çatı, varyasyon ve sürümü seçip modeli ekleyin.

2. Session options bölümüne gidip hızlandırıcı olarak GPU P100’ü seçin.

3. Hugging Face ve Weights & Biases belirtecini (token) oluşturun ve Kaggle Secrets’ı tanımlayın. Add-ons > Secrets > Add adımlarını izleyerek yeni bir secret oluşturup etkinleştirebilirsiniz.

4. Gerekli tüm Python paketlerini yükleyerek Kaggle oturumunu başlatın.

%%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

5. Veri kümesini, modeli ve belirteçleyiciyi yüklemek ve ince ayar için gerekli Python sayfalarını içe aktarın.

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

6. Eğitim sürecini Weights & Biases ile takip edeceğiz ve ardından ince ayarlı modeli Hugging Face’e kaydedeceğiz; bunun için her iki platforma da API anahtarıyla giriş yapmamız gerekiyor.

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)

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3 8B on Medical Dataset', 
    job_type="training", 
    anonymous="allow"
)

7. Temel model, veri kümesi ve yeni model değişkenini ayarlayın. Temel modeli Kaggle’dan, veri kümesini HuggingFace Hub’dan yükleyecek ve ardından yeni modeli kaydedeceğiz.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
dataset_name = "ruslanmv/ai-medical-chatbot"
new_model = "llama-3-8b-chat-doctor"

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

torch_dtype = torch.float16
attn_implementation = "eager"

Modeli ve belirteçleyiciyi yükleme

Bu bölümde modeli Kaggle’dan yükleyeceğiz. Ancak bellek kısıtları nedeniyle tam modeli yükleyemiyoruz. Bu yüzden modeli 4-bit hassasiyetle yüklüyoruz.

Bu projedeki amacımız bellek kullanımını azaltmak ve ince ayar sürecini hızlandırmaktır.

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

Belirteçleyiciyi yükleyin ve ardından sohbet amaçlı görevler için model ve belirteçleyiciyi yapılandırın. Varsayılan olarak OpenAI’nin chatml şablonunu kullanır; bu, girişi sohbet benzeri bir biçime dönüştürür.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
model, tokenizer = setup_chat_format(model, tokenizer)

Katmana adaptör ekleme

Tüm modeli ince ayarlamak çok zaman alacaktır; bu yüzden eğitimi hızlandırmak için az sayıda parametreye sahip bir adaptör katmanı ekleyip süreci daha hızlı ve bellek açısından verimli hale getireceğiz.

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)
model = get_peft_model(model, peft_config)

Veri kümesini yükleme

Veri kümemizi yüklemek ve ön işlemek için şunları yapıyoruz:

1. ruslanmv/ai-medical-chatbot veri kümesini yükleyip karıştırın ve yalnızca ilk 1000 satırı seçin. Bu, eğitim süresini önemli ölçüde azaltır.

2. Sohbet şablonunu konuşma biçimine getirin. Hasta soruları ve doktor yanıtlarını "text" sütununda birleştirin.

3. Metin sütunundan bir örnek görüntüleyin (“text” sütunu, özel belirteçlerle sohbet benzeri bir biçimdedir).

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "user", "content": row["Patient"]},
               {"role": "assistant", "content": row["Doctor"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

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

dataset['text'][3]

4. Veri kümesini eğitim ve doğrulama olarak ikiye ayırın.

dataset = dataset.train_test_split(test_size=0.1)

Modeli derleme ve eğitme

Modelin hiperparametrelerini Kaggle’da çalışacak şekilde ayarlıyoruz. Her bir hiperparametre hakkında bilgi edinmek için Llama 2’yi İnce Ayarlama eğitimini okuyabilirsiniz.

Modeli bir epoch boyunca ince ayarlıyor ve metrikleri Weights and Biases ile kaydediyoruz.

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,
    evaluation_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 kurup eğitim ve değerlendirme veri kümeleri, LoRA yapılandırması, eğitim argümanları, belirteçleyici ve modeli sağlayacağız. Eğitim sırasında GPU belleğini aşmamak için max_seq_length değerini 512 olarak tutuyoruz.

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

Aşağıdaki kodu çalıştırarak ince ayar sürecini başlatacağız.

trainer.train()

Hem eğitim hem de doğrulama kayıpları azaldı. Daha iyi sonuçlar için modeli tam veri kümesi üzerinde üç epoch eğitmeyi düşünebilirsiniz.

Model değerlendirme

Weights & Biases oturumunu bitirdiğinizde, çalışma geçmişi ve özeti oluşturulur.

wandb.finish()
model.config.use_cache = True

Model performans metrikleri, Weights & Biases hesabınızda belirli proje adı altında da saklanır.

Modelin doğru şekilde ince ayarlanıp ayarlanmadığını görmek için örnek bir hasta sorgusunda değerlendirelim.

Bir yanıt üretmek için iletileri sohbet biçimine dönüştürmemiz, bunları belirteçleyiciden geçirip modeli beslememiz ve ardından üretilen belirteci çözüp metni göstermemiz gerekir.

messages = [
    {
        "role": "user",
        "content": "Hello doctor, I have bad acne. How do I get rid of it?"
    }
]

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_length=150, 
                         num_return_sequences=1)

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

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

Görünüşe göre tek bir epoch ile bile ortalama sonuçlar alabiliyoruz.

Model dosyasını kaydetme

Şimdi ince ayarlı adaptörü kaydedip Hugging Face Hub’a yükleyeceğiz. Hub API’si, depoyu otomatik olarak oluşturup adaptör dosyasını saklayacaktır.

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

Görüldüğü gibi, kaydettiğimiz adaptör dosyası temel modelden belirgin ölçüde daha küçüktür.

Son olarak, yeni not defterinde temel modelle birleştirmek üzere adaptör dosyasını içeren not defterini kaydedeceğiz.

Kaggle Notebook’u kaydetmek için sağ üstteki Save Version düğmesine tıklayın, sürüm türü olarak Quick Save’i seçin, gelişmiş ayarları açın, Always save output when creating a Quick Save seçeneğini işaretleyin ve Save düğmesine basın.

Kodu çalıştırırken sorun yaşıyorsanız şu Kaggle Notebook’a bakın: Fine-tune Llama 3 8B on Medical Dataset.

Modelimizi GPU kullanarak ince ayarladık. Ayrıca TPU’lar ile LLM’leri nasıl ince ayarlayacağınızı Google’ın Gemma Modelinde TPU’larla İnce Ayar ve Çıkarım eğitimini izleyerek öğrenebilirsiniz.

Diğer modelleri nasıl ince ayarlayacağınızı öğrenmek isterseniz şu eğitime göz atın: Mistral 7B Eğitimi: Mistral 7B’yi Kullanma ve İnce Ayarlama için Adım Adım Kılavuz.

2. Llama 3’ü Birleştirme

İnce ayarlı modeli yerelde kullanmak için önce adaptörü temel modelle birleştirmeli ve ardından tam modeli kaydetmeliyiz.

Kurulum

Şu adımları izleyelim:

1. Yeni bir Kaggle Notebook oluşturun ve gerekli tüm Python paketlerini yükleyin. Hızlandırıcı olarak GPU kullandığınızdan emin olun.

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

2. Kaggle Secrets’ı kullanarak Hugging Face Hub’a giriş yapın. Bu, tam ince ayarlı modeli kolayca yüklememize yardımcı olacaktır.

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)

3. Llama 3 8B Chat modelini ve az önce kaydettiğimiz ince ayarlı Kaggle Notebook’unu ekleyin. Not defterlerini, veri kümesi ve modelleri eklediğiniz gibi mevcut oturuma ekleyebilirsiniz.

Kaggle oturumuna Not Defteri eklemek, çıktı dosyalarına erişmemizi sağlar. Bizim örneğimizde bu, bir model adaptör dosyasıdır.

4. Temel modelin ve adaptörün konumunu belirten değişkenleri ayarlama.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
new_model = "/kaggle/input/fine-tune-llama-3-8b-on-medical-dataset/llama-3-8b-chat-doctor/"

Temel modeli adaptörle birleştirme

transformers kütüphanesini kullanarak önce belirteçleyiciyi ve temel modeli yükleyeceğiz. Ardından trl kütüphanesiyle sohbet biçimini ayarlayacağız. Son olarak PEFT kütüphanesiyle adaptörü temel modele yükleyip birleştireceğiz.

merge_and_unload() işlevi, adaptör ağırlıklarını temel modelle birleştirip modeli bağımsız bir model olarak kullanmamıza yardımcı olur.

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

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

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, new_model)

model = model.merge_and_unload()

Model Çıkarımı

Modelimizin doğru şekilde birleştirilip birleştirilmediğini doğrulamak için, transformers kütüphanesindeki pipeline ile basit bir çıkarım yapacağız. İletiyi sohbet şablonuyla dönüştürüp ardından pipeline’a bir istem vereceğiz. Pipeline, model, belirteçleyici ve görev türüyle başlatıldı.

Not olarak, birden fazla GPU kullanmak isterseniz device_map’i "auto" olarak ayarlayabilirsiniz.

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Birleştirmenin ardından ince ayarlı modelimiz beklendiği gibi çalışıyor.

Birleştirilmiş modeli kaydetme ve yükleme

save_pretrained() işlevini kullanarak şimdi belirteçleyiciyi ve modeli kaydedeceğiz.

model.save_pretrained("llama-3-8b-chat-doctor")
tokenizer.save_pretrained("llama-3-8b-chat-doctor")

Model dosyaları safetensors formatında saklanır ve toplam model boyutu yaklaşık 16 GB’tır.

push_to_hub() işlevini kullanarak tüm dosyaları Hugging Face Hub’a yükleyebiliriz.

model.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)

Sonunda, Kaggle Notebook’u önceki gibi kaydedebiliriz.

Fine Tuned Adapter to fully model Kaggle Notebook’unu kullanmak, kodu kendi başınıza çalıştırırken yaşanabilecek sorunları çözmenize yardımcı olur.

3. Modeli Llama.cpp GGUF’a Dönüştürme

Çoğu yerel yapay zekâ sohbet botu safetensors dosyalarını desteklemediği için bunları yerelde kullanamayız. Bunun yerine llama.cpp GGUF dosya formatına dönüştüreceğiz.

Kurulum

Yeni bir Kaggle Notebook oturumu başlatın ve Fine Tuned Adapter to the full model Not Defteri’ni ekleyin.

Aşağıda gösterildiği gibi llama.cpp deposunu klonlayın ve make komutuyla llama.cpp çerçevesini kurun.

Not: Aşağıdaki komut yalnızca Kaggle Notebook için çalışır. Diğer platformlarda veya yerelde çalıştırmak için bazı düzenlemeler yapmanız gerekebilir.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Safetensors’ı GGUF model formatına dönüştürme

Modeli GGUF formatına dönüştürmek için Kaggle Notebook hücresinde aşağıdaki komutu çalıştırın.

convert-hf-to-gguf.py girdi model dizini, çıktı dosya dizini ve çıktı türüne ihtiyaç duyar.

!python convert-hf-to-gguf.py /kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/ \
    --outfile /kaggle/working/llama-3-8b-chat-doctor.gguf \
    --outtype f16

Birkaç dakika içinde model dönüştürülüp yerelde kaydedilir. Ardından dosyayı kaydetmek için not defterini kaydedebiliriz.

Yukarıdaki kodu çalıştırırken sorun yaşarsanız HF LLM to GGUF Kaggle Notebook’una bakın.

4. GGUF modelini kuantize etme

Standart dizüstü bilgisayarlar tüm modeli yüklemek için yeterli RAM ve GPU belleğine sahip değildir; bu yüzden GGUF modelini kuantize ederek 16 GB’lık modeli yaklaşık 4–5 GB’a düşürmemiz gerekir.

Kurulum

Yeni bir Kaggle Notebook oturumu başlatın ve HF LLM to GGUF Not Defteri’ni ekleyin.

Ardından, Kaggle Notebook hücresinde aşağıdaki komutları çalıştırarak llama.cpp’yi kurun.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Kuantizasyon

Kuantize komutu, bir GGUF model dizini, çıktı dosya dizini ve kuantizasyon yöntemine ihtiyaç duyar. Modeli Q4_K_M yöntemiyle dönüştürüyoruz.

%cd /kaggle/working/

!./llama.cpp/llama-quantize /kaggle/input/hf-llm-to-gguf/llama-3-8b-chat-doctor.gguf llama-3-8b-chat-doctor-Q4_K_M.gguf Q4_K_M

Model boyutumuz 15317,05 MB’tan 4685,32 MB’a önemli ölçüde azaldı.

Model dosyasını Hugging Face’e yükleme

Tek dosyayı Hugging Face Hub’a yüklemek için şunları yapacağız:

1. API anahtarıyla Hugging Face Hub’a giriş yapın.
2. API nesnesini oluşturun.
3. Yerel yol, depo yolu, depo kimliği ve depo türünü sağlayarak dosyayı yükleyin.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
from huggingface_hub import HfApi
user_secrets = UserSecretsClient()
hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/llama-3-8b-chat-doctor-Q4_K_M.gguf",
    path_in_repo="llama-3-8b-chat-doctor-Q4_K_M.gguf",
    repo_id="kingabzpro/llama-3-8b-chat-doctor",
    repo_type="model",
)

Modelimiz aşağıda gösterildiği gibi başarıyla uzak sunucuya yüklendi.

Hâlâ sorun yaşıyorsanız, tüm kod ve çıktıları içeren GGUF to Quantize Kaggle Notebook’una bakın.

Modelinizi dönüştürüp kuantize etmenin daha basit bir yolunu arıyorsanız, bu Hugging Face Space’e gidip Hub Model Id bilgisini verin.

5. İnce Ayarlı Modelleri Yerelde Kullanma

GGUF modeli yerelde kullanmak için Jan uygulamasına indirip içe aktarmanız gerekir.

Modeli Hugging Face’ten indirme

Modeli indirmek için şunları yapmamız gerekir:

1. Hugging Face deposuna gidin.

2. Files sekmesine tıklayın.

3. GGUF uzantılı kuantize model dosyasına tıklayın.

4. download düğmesine tıklayın.

Dosyanın yerelde indirilmesi birkaç dakika sürecektir.

Jan uygulamasını kurma

Jan AI üzerinden Jan uygulamasını indirip kurun.

Jan Windows uygulamasını başlattığınızda şöyle görünür:

İnce ayarlı modeli Jan’a yükleme

Modeli Jan uygulamasına eklemek için kuantize GGUF dosyasını içe aktarmamız gerekir.

Aşağıda gösterildiği gibi Hub menüsüne gidip Import Model’e tıklamamız gerekiyor. Yeni indirdiğimiz dosyanın konumunu veriyoruz ve işlem tamam.

Thread menüsüne gidip ince ayarlı modeli seçiyoruz.

İnce ayarlı modeli Jan’da kullanma

Modeli kullanmadan önce, yanıtın doğru görüntülenmesi için özelleştirmemiz gerekir. İlk olarak, Model Parameters bölümünde Prompt şablonunu değiştiriyoruz.

<|im_start|>system
{system_message}<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistant

Çıkarım parametrelerinde Stop belirtecini ekliyor ve azami belirteç sayısını 512’ye değiştiriyoruz.

<endofstring>, Best, Regards, Thanks,-->

Sorguları yazmaya başlıyoruz ve doktor buna göre yanıt veriyor.

İnce ayarlı modelimiz yerelde kusursuz şekilde çalışıyor.

Bu model, GPT4ALL, Llama.cpp, Ollama ve daha birçok yerel yapay zekâ uygulamasıyla çalışır. Her birini nasıl kullanacağınızı öğrenmek için LLM’leri yerelde çalıştırma eğitimine göz atın.

Sonuç

Llama 3 modelini özel bir veri kümesi üzerinde ince ayarlayıp yerelde kullanmak, yenilikçi uygulamalar geliştirmek için pek çok olasılığı beraberinde getirdi. Potansiyel kullanım alanları; özel ve kişiselleştirilmiş konuşma odaklı yapay zekâ çözümlerinden alan odaklı sohbet botlarına, metin sınıflandırma, dil çevirisi, soru-cevap, kişiselleştirilmiş öneri sistemleri ve hatta sağlık ve pazarlama otomasyonu uygulamalarına kadar uzanır.

Ollama ve Langchain çerçeveleriyle, yalnızca birkaç satır kodla kendi yapay zekâ uygulamanızı geliştirmek artık her zamankinden daha erişilebilir. Bunu yapmak için LlamaIndex: Büyük Dil Modelleri (LLM) Tabanlı Uygulamalar için Bir Veri Çerçevesi eğitimini izleyin.

Bu eğitimde, Llama 3 8B Chat’i tıbbi bir veri kümesinde ince ayarlamayı öğrendik. Adaptörü temel modelle birleştirme, GGUF formatına dönüştürme ve Jan sohbet botu uygulamasında yerel kullanım için kuantize etme süreçlerini adım adım ele aldık.

Daha fazlasını öğrenmek isterseniz Developing Large Language Models adlı dört derslik beceri yoluna göz atın.