Unsloth ile PubMedQA Üzerinde DiffusionGemma Nasıl İnce Ayar Yapılır

1. RunPod Jupyter Notebook Açın

Bir NVIDIA H100 GPU içeren yeni bir RunPod pod'u oluşturun ve bir PyTorch/Jupyter şablonu seçin. Pod durduğunda model dosyalarınız ve eğitim çıktılarını kaybetmemek için en az 100 GB kalıcı depolama yapılandırın.

Hugging Face erişim tokenınızı bir ortam değişkeni olarak ekleyin:

HF_TOKEN=your_hugging_face_token

Bu, modellerin ve veri kümelerinin daha hızlı indirilmesini sağlar ve kaydedilen LoRA adaptörünü not defterinden elle giriş yapmadan Hugging Face'e yüklemenize olanak tanır.

Yapılandırılan pod'un saatte yaklaşık 3 ABD doları maliyeti olmalıdır; ancak nihai fiyat, GPU kullanılabilirliğine ve seçilen pod türüne bağlı olarak değişebilir.

Pod çalışmaya başladıktan sonra RunPod arayüzünden JupyterLab veya Jupyter Notebook'u açın ve diffusiongemma_pubmedqa.ipynb adlı yeni bir not defteri oluşturun.

2. Gerekli Paketleri Yükleyin

Unsloth ve DiffusionGemma'yı yükleme, ince ayar ve kaydetme için gerekli kütüphaneleri kurmak üzere ilk not defteri hücresinde aşağıdaki komutları çalıştırın.

%%capture
%pip install --upgrade pip wheel setuptools packaging ninja
%pip install unsloth
%pip install --no-deps --upgrade --force-reinstall git+https://github.com/unslothai/unsloth-zoo.git git+https://github.com/unslothai/unsloth.git
%pip install sentencepiece protobuf "datasets==4.3.0" "huggingface_hub>=0.34.0" hf_transfer
%pip install --no-deps bitsandbytes accelerate peft trl triton
%pip install --no-deps --upgrade "torchao>=0.16.0"
%pip install --no-deps transformers==5.11.0 "tokenizers>=0.22.0,<=0.23.0"

%%capture komutu, uzun kurulum çıktısını gizler. Paket sürümleri, DiffusionGemma, Transformers, Unsloth ve eğitim kütüphaneleri arasındaki uyumluluk sorunlarından kaçınmak için sabitlenmiştir.

Kurulum tamamlandıktan sonra devam etmeden önce not defteri çekirdeğini yeniden başlatın.

3. Kütüphaneleri İçe Aktarın

Veri kümesi hazırlama, model yükleme, eğitim ve değerlendirme için gerekli kütüphaneleri içe aktarın.

import copy
import os
import random
import time

import torch
from datasets import load_dataset
from unsloth import FastModel

os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
torch._dynamo.config.recompile_limit = 64

print("Torch:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())
print(
    "GPU:",
    torch.cuda.get_device_name(0)
    if torch.cuda.is_available()
    else "None",
)

HF_HUB_ENABLE_HF_TRANSFER Hugging Face Hub'dan daha hızlı indirmeleri etkinleştirir; Dynamo yeniden derleme sınırını artırmak ise modelle çalışırken kesintileri önlemeye yardımcı olur.

Hücre başarıyla çalıştığında, Unsloth eğitim ortamını yamalayacak ve çıktı CUDA'nın kullanılabilir olduğunu ve H100 GPU'nun algılandığını doğrulayacaktır.

🦥 Unsloth: Will patch your computer to enable 2x faster free fine-tuning.
🦥 Unsloth Zoo will now patch everything to make training faster!
Torch: 2.10.0+cu128
CUDA available: True
GPU: NVIDIA H100 80GB HBM3

4. Yapılandırmayı Ayarlayın

Modeli, veri kümesini, eğitim parametrelerini, değerlendirme ayarlarını ve çıktı dizinini tek bir yerde tanımlayın.

MODEL_NAME = "unsloth/diffusiongemma-26B-A4B-it"
DATASET_NAME = "qiaojin/PubMedQA"

TRAIN_SUBSET = "pqa_artificial"
EVAL_SUBSET = "pqa_labeled"

N_TRAIN = 3000
N_EVAL = 200

MAX_CONTEXT_CHARS = 2500

STEPS = 60
GRAD_ACCUM = 4
LR = 1e-4
T_LO = 0.1

EVAL_TOTAL = 50
EVAL_DENOISING_STEPS = 16

OUTPUT_DIR = "diffusiongemma_pubmedqa_lora"

Eğitim için 3.000 yapay örnek ve değerlendirme için 200 elle etiketlenmiş örnek kullanacağız. Deneyi hızlı tutmak için model 60 adım eğitilecek ve her yanıtta 16 gürültü giderme adımıyla 50 örnek değerlendirilecektir.

DiffusionGemma Nasıl Çalışır

Modeli yüklemeden önce, DiffusionGemma'nın gerçekte bir yanıtı nasıl ürettiğini gözünüzde canlandırmak faydalıdır. Tokenları arka arkaya yazmak yerine, sabit uzunlukta bir token tuvaliyle başlar ve birkaç gürültü giderme adımı boyunca birçok konumu aynı anda güncelleyerek metni tutarlı bir yanıta dönüştürür. 

Aşağıdaki kod tek bir bloğun boyutu olan 256 tuval uzunluğu raporlar. Kısa yes/no/maybe yanıtlarımız için tek bir tuval fazlasıyla yeterlidir; daha uzun çıktılar ise blok blok tuvalleri zincirleyerek üretilir. Aşağıdaki diyagram, bu iyileştirme sürecini üst düzeyde göstermektedir:

5. DiffusionGemma'yı Yükleyin

Talimatla ayarlanmış DiffusionGemma modelini bfloat16 duyarlıkta yükleyin. H100 GPU, modeli daha yüksek duyarlıkta yüklemek için yeterli belleğe sahip olduğundan 4-bit quantization kullanmayacağız.

model, tokenizer = FastModel.from_pretrained(
    model_name=MODEL_NAME,
    dtype=torch.bfloat16,
    load_in_4bit=False,
)

processor = tokenizer
tok = processor.tokenizer if hasattr(processor, "tokenizer") else processor

vocab = model.config.text_config.vocab_size
canvas_len = model.config.canvas_length

dev = next(
    (p.device for p in model.parameters() if p.device.type != "meta"),
    torch.device("cuda"),
)

print("Vocab size:", vocab)
print("Canvas length:", canvas_len)
print("Model device:", dev)

Sözlük boyutu, difüzyon eğitiminde rastgele gürültü eklenirken kullanılır. Tuval uzunluğu, modelin tek bir üretim bloğunda iyileştirebileceği maksimum token sayısını belirler.

Şuna benzer bir çıktı görmelisiniz:

Vocab size: 262144
Canvas length: 256
Model device: cuda:0

6. Bir LoRA Adaptörü Ekleyin

26 milyar parametreli tüm modeli güncellemek yerine yalnızca küçük bir ek parametre kümesinin eğitilmesi için bir LoRA adaptörü ekleyin.

model = FastModel.get_peft_model(
    model,
    r=64,
    lora_alpha=128,
    use_gradient_checkpointing=False,
)

Bu, ince ayar için gereken bellek ve hesaplamayı önemli ölçüde azaltır. Bu deneyde H100 yeterli GPU belleğine sahip olduğundan gradient checkpointing devre dışı bırakılmıştır.

7. PubMedQA'yı Yükleyin

Eğitim için yapay PubMedQA alt kümesini ve değerlendirme için elle etiketlenmiş alt kümeyi yükleyin.

train_data = load_dataset(
    DATASET_NAME,
    TRAIN_SUBSET,
    split="train",
)

eval_data = load_dataset(
    DATASET_NAME,
    EVAL_SUBSET,
    split="train",
)

print("Train size:", len(train_data))
print("Eval size:", len(eval_data))
print(train_data[0])

Eğitim alt kümesi otomatik olarak oluşturulmuş örnekler içerirken, değerlendirme alt kümesi uzmanlar tarafından etiketlenmiş biyomedikal sorulardan oluşur. 

İlk satırı yazdırmak, veriyi biçimlendirmeden önce soruyu, özet bağlamını ve nihai kararı incelememizi sağlar.

Şunu görmelisiniz:

Train size: 211269
Eval size: 1000

Her örnek bir biyomedikal soru, bir veya daha fazla destekleyici özet pasajı ve yes, no veya maybe şeklinde bir nihai yanıt içerir.

8. Veri Kümesini Dönüştürün

Her PubMedQA örneğini bir kullanıcı istemi ve bir asistan yanıtı içeren sohbet tarzı bir formata dönüştürün.

def make_prompt(row):
    context = " ".join(row["context"]["contexts"])
    context = context[:MAX_CONTEXT_CHARS]
    question = row["question"]

    return f"""Answer the biomedical research question using only the context.

Context:
{context}

Question:
{question}

Answer with only one word: yes, no, or maybe."""


def make_answer(row):
    return row["final_decision"].strip().lower()


def convert_row(row):
    answer = make_answer(row)

    if answer not in ["yes", "no", "maybe"]:
        return None

    return {
        "messages": [
            {"role": "user", "content": make_prompt(row)},
            {"role": "assistant", "content": answer},
        ]
    }


train_rows = []

for row in train_data.select(range(N_TRAIN)):
    item = convert_row(row)

    if item is not None:
        train_rows.append(item)


eval_rows = []

for row in eval_data.select(range(N_EVAL)):
    item = convert_row(row)

    if item is not None:
        eval_rows.append(item)


print("Prepared train examples:", len(train_rows))
print("Prepared eval examples:", len(eval_rows))
print(train_rows[0]["messages"][0]["content"])
print("Answer:", train_rows[0]["messages"][1]["content"])

Bağlam pasajları tek bir metinde birleştirilir ve girdiyi yönetilebilir tutmak için 2.500 karakterle sınırlandırılır. Her yanıt küçük harfe dönüştürülür ve etiketi yes, no veya maybe dışında olan örnekler kaldırılır.

İlk dönüştürülmüş örneği yazdırmak, eğitime başlamadan önce bağlamın, sorunun ve yanıtın doğru biçimlendirildiğini doğrulamaya yardımcı olur.

9. Difüzyon Eğitim Örneklerini Oluşturun

DiffusionGemma, hedef yanıtın sabit uzunluklu bir tuval içine yerleştirilmesini gerektirir. Bu fonksiyon, istemi tokenize eder, yanıtı token ID'lerine dönüştürür, modeli tuval uzunluğuna kadar doldurur ve hangi tokenların kayba katkıda bulunması gerektiğini gösteren bir maske oluşturur.

eos = model.generation_config.eos_token_id or [1]
eos = eos[0] if isinstance(eos, (list, tuple)) else eos

pad = tok.pad_token_id if tok.pad_token_id is not None else eos


def build_examples(rows):
    examples = []

    for row in rows:
        user_message = row["messages"][0]
        assistant_message = row["messages"][1]

        prompt_ids = processor.apply_chat_template(
            [user_message],
            tokenize=True,
            add_generation_prompt=True,
            return_tensors="pt",
        )[0]

        answer_ids = tok.encode(
            assistant_message["content"],
            add_special_tokens=False,
        )

        content = answer_ids + [eos]
        n = len(content)

        if n > canvas_len:
            continue

        x0 = torch.tensor(
            content + [pad] * (canvas_len - n),
            dtype=torch.long,
        )

        loss_mask = torch.zeros(canvas_len, dtype=torch.bool)
        loss_mask[:n] = True

        examples.append((prompt_ids, x0, loss_mask))

    return examples


examples = build_examples(train_rows)

Her yanıtın sonuna dizinin sonu tokenı eklenir; kalan tuval konumları ise dolgu tokenlarıyla doldurulur. Kayıp maskesi, eğitimin dolgulu konumlar yerine yalnızca yanıt ve dizinin sonu tokenlarına odaklanmasını sağlar.

10. Çıkarım ve Değerlendirme Fonksiyonlarını Oluşturun

Sonraki adımda, yanıt üretmek, model çıktısını temizlemek ve değerlendirme doğruluğunu hesaplamak için kullanılan fonksiyonları tanımlayın.

Bir yanıt üretin

answer_question() fonksiyonu, istemi biçimlendirir, birkaç gürültü giderme adımıyla bir yanıt üretir ve üretilen tokenları metne çözümler.

def answer_question(prompt, steps=64):
    input_ids = processor.apply_chat_template(
        [{"role": "user", "content": prompt}],
        tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt",
    ).to(dev)

    gen_config = copy.deepcopy(model.generation_config)
    gen_config.max_denoising_steps = steps
    gen_config.max_new_tokens = canvas_len

    model.eval()

    with torch.no_grad():
        output = model.generate(
            input_ids=input_ids,
            generation_config=gen_config,
        )

    generated = output.sequences[0, input_ids.shape[1]:]
    text = tok.decode(
        generated.tolist(),
        skip_special_tokens=True,
    )

    return text.strip().lower()

Tahmini çıkarın

İstem tek kelimelik bir yanıt talep etse de model bazen fazladan metin üretebilir. Bu fonksiyon, ilk geçerli yes, no veya maybe tahminini ayıklar.

def clean_prediction(text):
    text = text.lower().strip()

    if text.startswith("yes"):
        return "yes"

    if text.startswith("no"):
        return "no"

    if text.startswith("maybe"):
        return "maybe"

    words = text.replace(".", " ").replace(",", " ").split()

    for word in words:
        if word in ["yes", "no", "maybe"]:
            return word

    return "unknown"

Doğruluğu değerlendirin

Değerlendirme fonksiyonu, temizlenmiş her tahmini doğru yanıtla karşılaştırır, her örnek için sonucu yazdırır ve genel doğruluğu bireysel tahminlerle birlikte döndürür.

def evaluate_model(
    rows,
    total=50,
    steps=64,
    title="Evaluation",
):
    correct = 0
    results = []
    total = min(total, len(rows))

    print(title)
    print("-" * len(title))

    for i, row in enumerate(rows[:total], start=1):
        prompt = row["messages"][0]["content"]
        gold = row["messages"][1]["content"]

        raw_pred = answer_question(prompt, steps=steps)
        pred = clean_prediction(raw_pred)

        is_correct = pred == gold
        correct += int(is_correct)

        results.append({
            "index": i,
            "gold": gold,
            "prediction": pred,
            "raw_prediction": raw_pred,
            "correct": is_correct,
        })

        print(
            f"{i:02d}. Gold: {gold} | "
            f"Pred: {pred} | Correct: {is_correct}"
        )

    accuracy = correct / total if total else 0

    print()
    print("Accuracy:", accuracy)
    print()

    return {
        "accuracy": accuracy,
        "correct": correct,
        "total": total,
        "results": results,
    }

11. İnce Ayardan Önce Modeli Değerlendirin

Bir temel seviye oluşturmak için eğitimden önce değerlendirmeyi çalıştırın.

before_eval = evaluate_model(
    eval_rows,
    total=EVAL_TOTAL,
    steps=EVAL_DENOISING_STEPS,
    title="Before Fine-Tuning Evaluation",
)

Bu, her yanıtta 16 gürültü giderme adımı kullanarak 50 örneği değerlendirir. Bu deneyde, temel model 50 sorudan 30'una doğru yanıt verdi.

Bu temel seviye, daha sonra ince ayar sonrası modelin doğruluğu ile karşılaştırılacaktır.

12. Eğitimi Kurun

Modeli eğitim moduna alın, optimizer ve öğrenme oranı zamanlayıcısını oluşturun ve difüzyon eğitimi sırasında temiz yanıt tokenlarının nasıl bozulacağını tanımlayın.

model.config.use_cache = True
model.train()

opt = torch.optim.AdamW(
    [p for p in model.parameters() if p.requires_grad],
    lr=LR,
    betas=(0.9, 0.95),
    weight_decay=0.0,
)

sched = torch.optim.lr_scheduler.OneCycleLR(
    opt,
    max_lr=LR,
    total_steps=STEPS,
    pct_start=0.03,
    anneal_strategy="cos",
)

Yalnızca requires_grad=True olan parametreler optimizer'a aktarılır; bu da eğitim sürecinin tam model yerine LoRA adaptörünü güncellediği anlamına gelir.

Sonraki adımda, yanıt tuvalinin rastgele bir oranını rastgele tokenlarla değiştiren bir bozma fonksiyonu oluşturun.

def corrupt(x0):
    noise_level = random.uniform(T_LO, 1.0)

    xt = x0.to(dev).clone()

    noise_mask = (
        torch.rand(canvas_len, device=dev) < noise_level
    )

    xt[noise_mask] = torch.randint(
        0,
        vocab,
        (canvas_len,),
        device=dev,
    )[noise_mask]

    return xt.unsqueeze(0)

Gürültü miktarı her örnek için değişir. Eğitim sırasında model, bu bozulmuş tuval tokenlarından orijinal yanıtı yeniden oluşturmayı öğrenir.

13. Modeli Eğitin

Aşağıdaki döngü, LoRA adaptörünü gradient biriktirme kullanarak 60 adım boyunca eğitir.

order = list(range(len(examples)))
ptr = 0
start_time = time.time()

opt.zero_grad(set_to_none=True)

for step in range(1, STEPS + 1):
    step_loss = 0.0

    for _ in range(GRAD_ACCUM):
        if ptr >= len(order):
            random.shuffle(order)
            ptr = 0

        prompt_ids, x0, loss_mask = examples[order[ptr]]
        ptr += 1

        output = model(
            input_ids=prompt_ids.unsqueeze(0).to(dev),
            canvas_ids=corrupt(x0),
            self_conditioning_logits=None,
        )

        logits = output.logits[0].float()
        mask = loss_mask.to(dev)

        loss = torch.nn.functional.cross_entropy(
            logits[mask],
            x0.to(dev)[mask],
        )

        (loss / GRAD_ACCUM).backward()
        step_loss += loss.item() / GRAD_ACCUM

    torch.nn.utils.clip_grad_norm_(
        [
            p
            for p in model.parameters()
            if p.requires_grad
        ],
        1.0,
    )

    opt.step()
    sched.step()
    opt.zero_grad(set_to_none=True)

    if step % 20 == 0:
        elapsed = time.time() - start_time

        print(
            f"step {step}/{STEPS} | "
            f"loss {step_loss:.4f} | "
            f"{elapsed:.0f}s"
        )

Her eğitim örneği için model, biyomedikal istemi ve bozulmuş bir yanıt tuvali alır. Çapraz entropi kaybı yalnızca kayıp maskesi tarafından seçilen gerçek yanıt tokenları için hesaplanır.

Gradient biriktirme, modeli güncellemeden önce dört örneği birleştirir. Gradient kırpma da eğitimi kararlı tutmak için uygulanır.

Bu deneyde eğitim yaklaşık iki dakika içinde tamamlandı:

step 20/60 | loss 0.0019 | 43s
step 40/60 | loss 0.0003 | 85s
step 60/60 | loss 0.0001 | 126s

Düzenli olarak azalan kayıp, adaptörün bozulmuş tuvalden beklenen yanıtları yeniden inşa etmeyi öğrendiğini gösterir. Eğitim sırasında, GPU bellek kullanımını ve kullanım oranını izlemek için RunPod terminalinde nvidia-smi komutunu da çalıştırabilirsiniz.

14. İnce Ayar Yapılmış Modeli Değerlendirin

İnce ayarın modelin performansını iyileştirip iyileştirmediğini ölçmek için eğitimden sonra aynı değerlendirmeyi tekrar çalıştırın.

after_eval = evaluate_model(
    eval_rows,
    total=EVAL_TOTAL,
    steps=EVAL_DENOISING_STEPS,
    title="After Fine-Tuning Evaluation",
)

İnce ayarlı model, temel değerlendirmede olduğu gibi aynı 50 örnek üzerinde ve aynı 16 gürültü giderme adımı kullanılarak değerlendirilir.

Sonraki adımda, ince ayardan önce ve sonra doğruluğu karşılaştırın.

before_accuracy = before_eval["accuracy"]
after_accuracy = after_eval["accuracy"]
improvement = after_accuracy - before_accuracy

print("Before fine-tuning accuracy:", before_accuracy)
print("After fine-tuning accuracy:", after_accuracy)
print("Improvement:", improvement)

Before fine-tuning accuracy: 0.6
After fine-tuning accuracy: 0.8
Improvement: 0.2

Bu deneyde, modelin doğruluğu 0,60'tan 0,80'e yükseldi.

Bu, eğitimden önce 50 sorudan 30'unu doğru yanıtlayan modele kıyasla, ince ayardan sonra 50 sorudan 40'ını doğru yanıtlayarak 20 yüzde puanlık bir iyileşme anlamına gelir.

15. İnce Ayarlı Adaptörü Kaydedin ve Yükleyin

Eğitilmiş LoRA adaptörünü ve işlemci dosyalarını daha önce tanımlanan çıktı dizinine kaydedin.

model.save_pretrained(OUTPUT_DIR)
processor.save_pretrained(OUTPUT_DIR)

print(f"Saved LoRA adapter to: {OUTPUT_DIR}")

Şunu görmelisiniz:

Saved LoRA adapter to: diffusiongemma_pubmedqa_lora

Bu, 26 milyar parametreli temel modelin başka bir tam kopyası yerine yalnızca hafif LoRA adaptörünü kaydeder.

Sonraki adımda, adaptörü ve işlemci dosyalarını Hugging Face Hub'a yükleyin:

REPO_ID = "kingabzpro/diffusiongemma_pubmedqa"

model.push_to_hub(REPO_ID)
processor.push_to_hub(REPO_ID)

HF_TOKEN ortam değişkeni RunPod pod yapılandırması sırasında eklendiğinden, Hugging Face otomatik olarak kimlik doğrulaması yapmalıdır. Token zaten yapılandırılmadığında yalnızca notebook_login() çalıştırmanız gerekir:

from huggingface_hub import notebook_login

notebook_login()

Yükleme tamamlandıktan sonra depo, daha sonra ince ayarlı modeli yüklemek için gereken LoRA adaptörünü ve işlemci yapılandırmasını içerecektir.

Kaynak: kingabzpro/diffusiongemma_pubmedqa · Hugging Face 

Son Düşünceler

DiffusionGemma'yı Unsloth ile ince ayar yapmak şaşırtıcı derecede kolaydı. En çok zaman alan kısım, doğru bağımlılıkları kurmak ve difüzyona özgü eğitim sürecinin nasıl çalıştığını anlamaktı. Ortam kurulduktan sonra modeli yüklemek, LoRA adaptörünü eğitmek, değerlendirmek ve sonuçları Hugging Face'e yüklemek oldukça sorunsuz ilerledi.

DiffusionGemma'yı özellikle ilginç buldum; çünkü geleneksel bir dil modeli gibi metni birer token halinde üretmiyor. Bunun yerine sabit bir tuvalle çalışıyor ve gürültülü tokenları gürültü giderme adımlarıyla kademeli olarak iyileştiriyor. Bu farklı üretim sürecini anlamak ve biyomedikal soru-cevap görevinde ince ayar yapmak, deneyi benim için özellikle değerli kıldı.

Küçük bir kurulumla bile, 50 örnekli numune üzerinde doğruluk 0,60'tan 0,80'e yükseldi—ancak bu büyüklükte bir numunede hata payı geniştir ve "her zaman yes" temel seviyesi bile bu değerlendirme setinde yaklaşık %55 puan alır. 

Ayrıca, yapay eğitim alt kümesinin neredeyse hiç "maybe" etiketi içermediğini ve bu nedenle modelin, değerlendirme verisinde yer almasına rağmen bu sınıfı öğrenme şansının çok az olduğunu belirtmek gerekir. Bunu, ince ayar sürecinin nasıl çalıştığına dair hızlı bir deney olarak görün; modelin gerçek tıbbi kullanım için hazır olduğuna dair bir kanıt olarak değil.

Tek bir ince ayar çalışmasının ötesine geçmeye hazır mısınız? Bizim Geniş Dil Modelleri Geliştirme eğitim yolumuz, sizi PyTorch ve transformers temellerinden kendi LLM'lerinizi oluşturmaya ve dağıtmaya kadar götürür.