LLAMA 3 ve Unsloth ile Adım Adım Fine-Tuning Rehberi

LLAMA 3 ve Unsloth ile Nutuk Eğitimi: Adım Adım Fine-Tuning Rehberi

Merhabalar arkadaşlar, Murat Karakaya Akademi YouTube kanalına hoş geldiniz. Bugün, daha önce başladığımız "İnce Ayar (Fine-Tuning)" eğitim serimizin en kritik aşamalarından birini gerçekleştireceğiz. 8 milyar parametreli devasa bir dil modeli olan LLAMA 3'ü, kendi hazırladığımız Nutuk veri setiyle nasıl eğitebileceğimizi ve ona Atatürk'ün ölümsüz eseri hakkında nasıl uzmanlık kazandırabileceğimizi göreceğiz.

Bu eğitimde sadece kod yazmayacağız; arkadaki matematiksel hileyi (LoRA), bellek optimizasyonunu ve modelin neden Unsloth kütüphanesiyle 2 kat daha hızlı eğitildiğini derinlemesine inceleyeceğiz. Hazırsanız, yapay zekanın "ince ayar" dünyasına giriş yapalım.

Bu konuyu uygulamalı olarak görmek ve kodları adım adım takip etmek için videoyu izlemenizi öneririm:

Bu Eğitimde Neler Öğreneceksiniz?

• PEFT ve LoRA Kavramları: Milyarlarca parametreyi eğitmek yerine neden küçük "adaptörler" kullanıyoruz?
• Unsloth Kütüphanesi: Bellek dostu ve yüksek performanslı Fine-Tuning nasıl yapılır?
• Veri Hazırlığı: Nutuk metinlerini ShareGPT formatına ve modelin anlayacağı "Instruction" yapısına dönüştürme.
• QLoRA (4-bit Quantization): T4 gibi ücretsiz GPU'larda dev modelleri eğitmenin sırrı.
• Model Yayını: Eğitilen modeli Hugging Face'e yükleme ve tekrar geri çağırma.

Fine-Tuning'in Arkasındaki "Sihir": LoRA ve Düşük Dereceli Matrisler

Normalde 8 milyar parametreli bir modeli baştan aşağı eğitmek (Full Fine-Tuning) devasa sunucu parkları gerektirir. Ancak biz LoRA (Low-Rank Adaptation) yöntemini kullanıyoruz. Peki bu nedir?

Düşünün ki dev bir matrisiniz var (modelin ağırlıkları). Biz bu matrisin kendisini değiştirmek yerine, onun yanına çok daha küçük iki matris ekliyoruz. Bu iki küçük matrisin çarpımı, orijinal matristeki değişimi temsil ediyor. Örneğin, 200 milyon parametreyi temsil etmek için sadece 120 bin parametre eğitmemiz yetiyor. İşte bu "matematiksel hile", evdeki bilgisayarlarımızda bile yapay zeka eğitmemizi sağlıyor.

Teknik Derinleşme: Unsloth ve Model Yükleme

Unsloth kütüphanesi, Hugging Face ve Llama.cpp kütüphanelerini temel alarak optimizasyonlar yapar. Bellek kullanımını %70'e kadar azaltırken hızı 2 kat artırabilir. İlk adım olarak modelimizi 4-bit kuantize edilmiş halde yüklüyoruz:

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048 # İstediğiniz uzunluk
dtype = None # Otomatik algılama
load_in_4bit = True # Bellek dostu eğitim için

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/llama-3-8b-Instruct-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

Veri Seti Hazırlığı: Nutuk'u Modele Öğretmek

Bir önceki dersimizde hazırladığımız 4300 soruluk Nutuk veri setini, modelin "sohbet" edebilmesi için ShareGPT formatına çeviriyoruz. Modelin sadece soruyu değil, bir sohbet akışını (User -> Assistant) anlaması için "Conversation" yapısını kuruyoruz:

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs       = examples["input"]
    outputs      = examples["output"]
    texts = []
    for instruction, input, output in zip(instructions, inputs, outputs):
        # Modelin chat template'ine göre formatlama
        text = f"### Instruction:\n{instruction}\n\n### Input:\n{input}\n\n### Response:\n{output}"
        texts.append(text)
    return { "text" : texts, }

# Veri setini yükleme ve formatlama adımı burada gerçekleşir

Eğitim Parametreleri ve Optimizasyon

Eğitim esnasında en önemli parametrelerden biri Rank (R) değeridir. Bu değer, adaptörün ne kadar karmaşık olacağını belirler. Biz bu örnekte R=16 kullandık. Daha yüksek değerler daha fazla öğrenme kapasitesi sunsa da bellek maliyetini artırır. 17 dakikalık bir eğitim sonucunda modelin "loss" değerinin 2.7'den 1.2'ye düştüğünü gözlemledik.

Önemli Not: Fine-tuning yapmadan önce model Sivas Kongresi sorularına İngilizce cevap verirken, eğitim sonrası veri setimizdeki üslupla Türkçe ve net cevaplar vermeye başladı.

Sıkça Sorulan Sorular (SSS)

1. Kendi veri setimle bu eğitimi yapabilir miyim?
Kesinlikle. Tek yapmanız gereken verilerinizi "Soru-Cevap" formatında bir JSON veya CSV dosyasına dönüştürmek ve videoda gösterdiğimiz formatting_prompts_func fonksiyonuyla modele sunmaktır.

2. LoRA Rank (R) değerini nasıl belirlemeliyim?
Genellikle 8, 16 veya 32 değerleri standarttır. Eğer modeliniz çok karmaşık bir konuyu (örneğin ileri düzey tıp veya hukuk) öğreniyorsa rank değerini artırabilirsiniz, ancak aşırı öğrenme (overfitting) riskine dikkat etmelisiniz.

3. Google Colab'ın ücretsiz GPU'su yeterli mi?
Evet, Unsloth kütüphanesinin 4-bit optimizasyonu sayesinde LLAMA 3 (8B) modelini ücretsiz T4 GPU'da sorunsuzca eğitebilirsiniz. Bellek kullanımımız yaklaşık 13-15 GB civarında seyretmektedir.

Sonuç

Özetle; doğru araçları (Unsloth), doğru yöntemleri (QLoRA) ve kaliteli bir veri setini (Nutuk) bir araya getirdiğinizde, devasa dil modellerini kendi ihtiyaçlarınıza göre özelleştirmeniz artık hayal değil. Bu model artık sadece genel bir dil modeli değil, aynı zamanda Nutuk konusunda uzmanlaşmış bir asistandır.

Daha Fazlasını Keşfedin:
Yapay zeka ve yazılım dünyasındaki gelişmeleri kaçırmamak için Murat Karakaya Akademi YouTube kanalına abone olun.

Kanalı Ziyaret Et & Abone Ol 🚀

#MuratKarakayaAkademi #FineTuning #Llama3 #Unsloth #Nutuk #YapayZeka #DeepLearning #Python

İnce Ayar (Fine-Tuning): QLoRA Adaptörünü GGUF Formatına Dönüştürme ve Ollama Entegrasyonu

İnce Ayar (Fine-Tuning) Serisi: QLoRA Adaptörünü GGUF Formatına Dönüştürme ve Ollama Entegrasyonu

Değerli arkadaşlar, Murat Karakaya Akademi'ye hoş geldiniz. İnce ayar (Fine-Tuning) eğitim serimizin dördüncü ve tamamlayıcı bölümüyle karşınızdayım. Hatırlarsanız bu seriye veri setimizi hazırlayarak başlamış, ardından temel kavramları incelemiş ve üçüncü videomuzda Llama 3 modelini "Nutuk" verisiyle Unsloth kütüphanesini kullanarak eğitmiştik.

Bugünkü dersimizde ise eğittiğimiz bu QLoRA adaptörünü, baz (base) model ile birleştirip tek bir dosya haline getireceğiz. Daha sonra bu modeli GGUF formatına dönüştürüp 4-bit quantization (nitelik kaybı olmadan boyut küçültme) işlemini uygulayacağız. Son olarak da elde ettiğimiz bu modeli Ollama ve Llama.cpp kullanarak yerel bilgisayarımızda nasıl çalıştırabileceğimizi adım adım göreceğiz. Bu işlem, eğittiğiniz modelleri dağıtmak ve CPU üzerinde bile hızlıca çalıştırmak için kritik bir adımdır.

Bu teknik süreci uygulamalı olarak görmek, kodları adım adım takip etmek ve modelin canlı performansını izlemek için videoyu izlemenizi öneririm:

Bu Eğitimde Neler Öğreneceksiniz?

• QLoRA adaptörünün baz model (Llama 3) ile birleştirilmesi (Merging).
• Unsloth kütüphanesi ile GGUF formatına dönüşüm ve 4-bit Quantization.
• Modelin Hugging Face Hub üzerine yüklenmesi.
• Eğitilen modelin Ollama ve Llama.cpp ile yerel bilgisayarda çalıştırılması.
• Gradio kullanarak model için basit bir sohbet arayüzü oluşturulması.

Neden Birleştirme (Merging) ve GGUF?

Bir önceki dersimizde modelimizi QLoRA tekniği ile eğitmiş ve elimizde sadece eğitilen parametreleri içeren küçük bir "adaptör" dosyası kalmıştı. Ancak modeli kullanmak istediğimizde hem devasa baz modeli hem de adaptörü aynı anda yüklememiz gerekiyordu. Bu durum hem bellek yönetimi açısından zorlayıcıdır hem de çıkarım (inference) hızını düşürür.

Bugün yapacağımız "Merging" işlemi ile adaptörü baz modelin içine gömeceğiz. Ardından yapacağımız GGUF dönüşümü ile modeli tek bir dosya haline getirip, Apple Silicon (Mac) veya standart CPU'lu bilgisayarlarda bile çok hızlı çalışabilir hale getireceğiz. Unsloth kütüphanesi, normalde Llama.cpp ile yapılan bu karmaşık işlemi bizim için çok basit bir hale getiriyor.

Unsloth ile GGUF Dönüşümü ve Hugging Face Upload

Unsloth kütüphanesi, modelin kaydedilmesi aşamasında bize save_pretrained_gguf metodunu sunar. Bu metod sayesinde hem 16-bit (orijinal) hem de 4-bit (quantize edilmiş) versiyonları tek komutla oluşturabilir ve Hugging Face hesabımıza yükleyebiliriz.

Aşağıdaki kod bloğunda, eğittiğimiz modelin "q4_k_m" (4-bit medium) formatında dönüştürülüp yüklenmesini görüyoruz:

# Modeli GGUF formatında kaydetme ve Hugging Face'e yükleme
model.push_to_hub_gguf(
    "hf_kullanici_adiniz/Nutuk-Llama-3-8B-GGUF", # Hugging Face Repo Adı
    tokenizer,
    quantization_method = "q4_k_m", # Yaygın kullanılan 4-bit quantization
    token = "hf_token_buraya_gelecek" # Hugging Face Token'ınız
)

Ollama ile Yerelde Çalıştırma

Modelimiz Hugging Face üzerinde GGUF formatında hazır olduğunda, artık onu Ollama ile çalıştırmak çocuk oyuncağı. Ollama'nın yeni özelliklerinden biri, doğrudan Hugging Face üzerindeki GGUF dosyalarını indirip çalıştırabilmesidir.

Google Colab veya yerel terminalinizde şu komutu kullanarak modeli indirebilir ve sohbeti başlatabilirsiniz:

# Ollama'yı arka planda çalıştırın (Linux/Colab için)
ollama serve &

# Hugging Face üzerindeki GGUF modelini çalıştırın
ollama run hf.co/hf_kullanici_adiniz/Nutuk-Llama-3-8B-GGUF

Python ve Gradio ile Arayüz Oluşturma

Sadece terminalden değil, Python kodları içerisinden de modelimize erişebiliriz. Videoda gösterdiğim gibi, llama-cpp-python kütüphanesini kullanarak bir çıkarım (inference) fonksiyonu yazabilir ve bunu Gradio ile basit bir web arayüzüne dönüştürebiliriz.

from llama_cpp import Llama

# Modeli yükle (Hugging Face'den indirdiğiniz GGUF dosya yolu)
llm = Llama(
    model_path="./Nutuk-Llama-3-8B.Q4_K_M.gguf",
    chat_format="llama-3"
)

# Örnek sorgu
response = llm.create_chat_completion(
    messages=[
        {"role": "user", "content": "Sivas Kongresi ne zaman yapıldı?"}
    ]
)

print(response['choices'][0]['message']['content'])

Sıkça Sorulan Sorular (SSS)

1. Neden modeli GGUF formatına çeviriyoruz?
GGUF formatı, modelin tek bir dosya içinde tutulmasını sağlar ve özellikle CPU (işlemci) üzerinde çalıştırmak için optimize edilmiştir. Ayrıca 4-bit quantization ile model boyutu 16GB'lardan 4-5GB seviyelerine düşer, bu da standart bilgisayarlarda çalışmasını mümkün kılar.

2. Unsloth kullanmadan bu işlemi yapabilir miyim?
Evet, llama.cpp kütüphanesini doğrudan kullanarak da dönüşüm yapabilirsiniz ancak bu süreç çok daha manuel ve karmaşıktır. Unsloth, bu süreci optimize ederek arka planda gerekli dönüşümleri otomatik yapar.

3. Eğittiğim modeli ticari olarak kullanabilir miyim?
Bu, temel aldığınız modelin (Llama 3) lisansına ve kullandığınız veri setinin telif haklarına bağlıdır. Llama 3 genellikle açık bir lisansa sahiptir ancak "Nutuk" gibi kamuya mal olmuş veriler dışında özel veri setleri kullanıyorsanız dikkatli olmalısınız.

Sonuç

Bu eğitimle birlikte, veri seti hazırlamadan başlayıp, modeli eğitme ve son kullanıcıya sunulabilir bir formata (GGUF) dönüştürme sürecini tamamlamış olduk. Artık kendi özelleştirilmiş yapay zeka modellerinizi oluşturup, şirketinizde veya kişisel projelerinizde internete ihtiyaç duymadan (lokal olarak) çalıştırabilirsiniz.

Daha Fazlasını Keşfedin:
Yapay zeka, Büyük Dil Modelleri (LLM) ve yazılım dünyasındaki en güncel gelişmeleri teknik derinlikle öğrenmek için Murat Karakaya Akademi YouTube kanalına abone olun.

Kanalı Ziyaret Et & Abone Ol 🚀

#MuratKarakayaAkademi #FineTuning #Llama3 #GGUF #Ollama #YapayZeka

Fine-Tuning: Concepts, Methods, Tools, and Libraries

Fine-Tuning: Concepts, Methods, Tools, and Libraries

Hello dear readers! Greetings from the Murat Karakaya Akademi YouTube channel. In this article, we’ll dive deep into the rising stars of the AI world: Large Language Models (LLMs). Specifically, we'll focus on fine-tuning these LLMs—an essential process for unlocking their full potential and optimizing them for specific tasks. We’ll explore the conceptual framework and practical methods, tools, and libraries that enable real-world applications. Ethical considerations will also be addressed. If you wish you can watch the complete tutorial on Fine-Tuning on my YouTube channel: https://youtube.com/live/23J-kU38-6w?feature=share 

---

🧠 Understanding the Core Concepts: Foundation Models vs. Instruct Models

When discussing LLMs, it’s essential to differentiate between foundation models and instruct models. These two categories define how a model is trained and what its primary use cases are.

🔍 Foundation Model: The Backbone of LLMs

A foundation model is a large-scale pre-trained model that serves as a general-purpose language understanding system. These models are trained on massive amounts of text data using self-supervised or unsupervised learning techniques. The primary goal is to build a general understanding of human language, grammar, semantics, and contextual relationships.

🏗️ Training Methods for Foundation Models:

1. Causal Language Modeling (CLM): The model learns by predicting the next word in a sequence based on previous words. This is an autoregressive approach used in models like GPT and Llama.

2. Masked Language Modeling (MLM): The model learns by predicting randomly masked words within a sentence. This technique is used in models like BERT and RoBERTa.

3. Next Sentence Prediction (NSP): The model learns relationships between sentences by predicting whether one sentence follows another logically (used in early BERT models).

4. Contrastive Learning (CL): The model learns through contrastive objectives, improving its ability to distinguish between similar and dissimilar text.

🛠️ Tools for Training Foundation Models:

• PyTorch/TensorFlow: The most commonly used deep learning frameworks for training models.

• Hugging Face Transformers: Provides pre-trained models and APIs for fine-tuning.

• DeepSpeed & FSDP: Optimized training frameworks for large-scale distributed training.

• TPU/GPU Accelerators: Hardware accelerators for faster training.

📝 Instruct Model: Fine-Tuning for Specific Tasks

While foundation models have broad linguistic knowledge, they are not optimized for specific tasks. Instruct models are fine-tuned versions of foundation models that are adapted to follow human instructions effectively.

🔄 Fine-Tuning Techniques for Instruct Models:

1. Supervised Fine-Tuning: The model is trained on a dataset of input-output pairs where human-generated responses serve as labels.

2. Reinforcement Learning with Human Feedback (RLHF): The model is trained using reinforcement learning, guided by human feedback to improve its responses.

3. Reward Modeling: AI-generated outputs are ranked, and the model is trained to optimize for preferred responses.

4. Few-Shot Learning: Fine-tuning with a small dataset, leveraging prior knowledge from the foundation model.

🛠️ Tools for Fine-Tuning Instruct Models:

• Hugging Face Trainer API: High-level API for fine-tuning models.

• LoRA & Q-LoRA: Parameter-efficient fine-tuning techniques that reduce computational costs.

• RLHF Implementations: Open-source implementations like DeepMind’s TRL library.

• Datasets: OpenAI’s GPT datasets, Google’s FLAN, and Hugging Face’s OpenAssistant datasets.

---

🔗 Grounding: Connecting LLMs with Real-World Knowledge

LLMs are trained on static datasets, meaning they lack real-time knowledge. Grounding techniques help bridge this gap by enabling models to access up-to-date information from external sources.

🌍 Methods for Grounding LLMs:

1. Retrieval-Augmented Generation (RAG): The model fetches external documents before generating a response.

2. API Calls & Plugins: LLMs can call APIs for real-time data retrieval (e.g., weather updates, stock prices).

3. Vector Databases: Knowledge bases that store embeddings, allowing the model to retrieve relevant context dynamically.

4. Prompt Engineering with Context Injection: Manually providing additional context to improve model outputs.

🛠️ Tools for Grounding:

• FAISS, Pinecone: Popular vector database solutions.

• LangChain: Framework for integrating LLMs with external tools.

• Google Search API, Wikipedia API: Sources for real-time data retrieval.

---

🔧 Fine-Tuning Methods: From Standard to Parameter-Efficient Approaches

Fine-tuning LLMs involves multiple approaches, each suited for different computational constraints and objectives.

📌 Types of Fine-Tuning:

1. Standard Fine-Tuning: Updates all parameters; requires extensive computational resources.

2. Parameter-Efficient Fine-Tuning (PEFT): Modifies only a subset of model weights, improving efficiency. Includes:

   • LoRA (Low-Rank Adaptation): Adds small, trainable matrices to layers without modifying all weights.

   • Adapter Layers: Inserts lightweight layers between transformer layers.

   • Prefix-Tuning & Prompt-Tuning: Modifies input embeddings rather than internal model weights.

3. Continual Pre-Training: Extends training on domain-specific datasets to enhance knowledge retention.

🛠️ Fine-Tuning Tools:

• Hugging Face PEFT Library: Implements LoRA, adapters, and other PEFT techniques.

• DeepSpeed & FairScale: Optimized frameworks for fine-tuning large models.

• Weights & Biases (W&B): Tool for tracking fine-tuning experiments.

---

⚙️ GML and GGuf: The Future of LLM Model Formats

To improve efficiency, new model formats are emerging:

• GML (Generalized Graph Model Learning): A framework enabling interoperability across different AI ecosystems.

• GGuf: An optimized format that improves loading speeds, reduces memory usage, and enhances inference efficiency.

🛠️ Tools for Deployment:

• ONNX: Converts models for cross-platform inference.

• vLLM: Optimized LLM inference library for fast serving.

• llama.cpp: Enables efficient LLM inference on CPU.

---

✅ Conclusion: Unlocking the Full Potential of LLMs

Fine-tuning is an essential step in making LLMs more capable and efficient for real-world applications. By leveraging advanced training methods, grounding strategies, and deployment optimizations, developers can build high-performance AI models suited for specific tasks.

With your continued support, Murat Karakaya Akademi will keep producing more in-depth content and analyses in this field. We look forward to your comments and questions! 🚀