Beyin MRI Veri Kümesi Üzerinde MedGemma’nın İnce Ayarı

MedGemma, tıbbi metin ve görsel anlama konusunda üstün performans göstermesi için tasarlanmış Gemma 3 varyantlarının bir koleksiyonudur. Koleksiyonda şu anda iki güçlü varyant bulunmaktadır: 4B çok kipli sürüm ve 27B yalnızca metin sürümü. 

MedGemma 4B modeli, göğüs röntgenleri, dermatoloji görselleri, oftalmoloji görselleri ve histopatoloji preparatları gibi çeşitli ve kimliği kaldırılmış tıbbi veri kümeleri üzerinde önceden eğitilmiş SigLIP görüntü kodlayıcısını, kapsamlı bir tıbbi veri yelpazesi üzerinde eğitilmiş büyük bir dil modeli (LLM) ile birleştirir.

Bu öğreticide, MedGemma 4B modelini bir görüntü sınıflandırma görevi için beyin MRI veri kümesi üzerinde nasıl ince ayarla uyarlayacağımızı öğreneceğiz. Amaç, daha küçük MedGemma 4B modelini beyin MRI taramalarını etkili bir şekilde sınıflandıracak ve beyin kanserini daha iyi doğruluk ve verimlilikle tahmin edecek şekilde uyarlamaktır.

Ortamın Hazırlanması

RunPod, JupyterLab desteğine sahip önceden yapılandırılmış ortamlar sunan ve GPU tabanlı iş yüklerini çalıştırmak için mükemmel bir platformdur. Bu sayede bir pod başlatıp tercih ettiğiniz editörle anında kodlamaya başlayabilirsiniz. Ortamınızı şu şekilde kurabilirsiniz:

1. RunPod’un kurulumu

Şuraya giriş yapın: RunPod ve A100 GPU’lu, en güncel PyTorch imajına sahip bir pod oluşturun. Ardından pod’u başlatmak için "Deploy On-Demand" düğmesine tıklayın.

Pod’u düzenleyin ve Hugging Face ile Kaggle entegrasyonu için aşağıdaki ortam değişkenlerini ekleyin:

• HF_TOKEN
• KAGGLE_USERNAME
• KAGGLE_KEY

Veri kümeleri ve model denetim noktalarını barındırmak için depolama kapasitesini 100 GB’a çıkarın

2. Python paketlerinin kurulumu

Pod çalışır durumdayken "Connect" düğmesine tıklayarak JupyterLab oturumunu başlatın. Yeni bir Python not defteri oluşturun ve gerekli Python paketlerini aşağıdaki komutu çalıştırarak kurun:

! pip install --upgrade --quiet transformers bitsandbytes datasets evaluate peft trl scikit-learn kaggleAltyapı:

Veri Kümesini Yükleme ve İşleme

Kaggle’dan Brain Cancer MRI veri kümesini kullanacağız. 

3. Veri kümesini indirme

Kaggle CLI kullanarak veri kümesini indirin ve çıkarın:

!kaggle datasets download -d orvile/brain-cancer-mri-dataset --unzipAltyapı:

Dataset URL: https://www.kaggle.com/datasets/orvile/brain-cancer-mri-dataset
License(s): CC-BY-SA-4.0
Downloading brain-cancer-mri-dataset.zip to /workspace
 90%|████████████████████████████████████▉    | 130M/144M [00:00<00:00, 231MB/s]
100%|█████████████████████████████████████████| 144M/144M [00:01<00:00, 108MB/s]Altyapı:

4. Veri kümesini yükleme

Veri kümesini bir Hugging Face veri kümesi olarak yükleyin, eğitim ve doğrulama kümelerine ayırın ve yapısını görüntüleyin:

from datasets import load_dataset

data_dir = "./Brain_Cancer raw MRI data/Brain_Cancer"

# Define proportions for train and validation splits
train_size = 0.8  
validation_size = 0.2  


data = load_dataset("imagefolder", data_dir=data_dir, split="train")

# Split the dataset into train and validation sets
data = data.train_test_split(
    train_size=train_size,
    test_size=validation_size,
    shuffle=True,
    seed=42,
)

# Rename the 'test' split to 'validation'
data["validation"] = data.pop("test")

# Display dataset details
print(data)Altyapı:

Çıktı:

DatasetDict({
    train: Dataset({
        features: ['image', 'label'],
        num_rows: 4844
    })
    validation: Dataset({
        features: ['image', 'label'],
        num_rows: 1212
    })
})Altyapı:

Eğitim kümesindeki ilk görseli ve karşılık gelen etiketini kontrol edin:

data["train"][0]["image"]Altyapı:

print(data["train"][0]["label"])Altyapı:

1Altyapı:

5. Veri kümesini işleme

Veri kümesini işlemeye başlamadan önce, sınıflandırma görevinin doğru ele alınması için etiket adlarını kontrol etmek önemlidir.

BRAIN_CANCER_CLASSES = data["train"].features["label"].names
print("Detected classes:", BRAIN_CANCER_CLASSES)Altyapı:

Saptanan sınıflar: ['brain_glioma', 'brain_menin', 'brain_tumor'].

Detected classes: ['brain_glioma', 'brain_menin', 'brain_tumor']Altyapı:

Sınıflandırma sürecini iyileştirmek için, bu sınıf etiketlerini bir önek (A, B, C) ekleyerek değiştireceğiz; böylece daha iyi bir düzen sağlanacak ve özel bir istem biçimiyle hizalanacaktır. 

BRAIN_CANCER_CLASSES = ['A: brain glioma', 'B: brain menin', 'C: brain tumor']Altyapı:

Ardından, ince ayar sırasında modeli yönlendirmek için kullanılacak özel bir istem oluşturuyoruz. İstem, güncellenmiş sınıf etiketlerini içerir.

options = "\n".join(BRAIN_CANCER_CLASSES)
PROMPT = f"What is the most likely type of brain cancer shown in the MRI image?\n{options}"Altyapı:

Veri kümesini ince ayara hazırlamak için "messages" adlı yeni bir sütun oluşturacağız. Bu sütun, bir kullanıcı sorgusunu (istem) ve asistan yanıtını (doğru etiket) temsil eden yapılandırılmış veriler içerecek. 

def format_data(example: dict[str, any]) -> dict[str, any]:
    example["messages"] = [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                },
                {
                    "type": "text",
                    "text": PROMPT,
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": BRAIN_CANCER_CLASSES[example["label"]],
                },
            ],
        },
    ]
    return example

# Apply the formatting to the dataset
formatted_data = data.map(format_data)Altyapı:

Biçimlendirmeyi doğrulamak için, ilk örneğin ileti sütununu inceleyebiliriz:

formatted_data["train"][0]["messages"]Altyapı:

Ortaya çıkan biçimlendirilmiş veri noktası şu şekildedir:

[{'content': [{'text': None, 'type': 'image'},
   {'text': 'What is the most likely type of brain cancer shown in the MRI image?\nA: brain glioma\nB: brain menin\nC: brain tumor',
    'type': 'text'}],
  'role': 'user'},
 {'content': [{'text': 'B: brain menin', 'type': 'text'}],
  'role': 'assistant'}]Altyapı:

Beyin MRI Veri Kümesi Üzerinde MedGemma’nın İnce Ayarı

Bu bölümde, MedGemma 4B Instruct modelini Beyin MRI veri kümesi üzerinde ince ayarla uyarlayacağız. Bu, model ve işlemciyi indirmeyi, LoRA adaptörünü kurmayı, eğitici yapılandırmasını ayarlamayı ve eğitimi başlatmayı içerir.

6. Modeli ve belirteçleyiciyi yükleme

MedGemma kapılı bir model olduğundan, API anahtarınızı kullanarak Hugging Face CLI’a giriş yapmanız gerekir. Bu, ince ayarlı modelinizi Hugging Face Hub’a kaydetmenize de olanak tanır. Tazeleme ihtiyacınız varsa şu kursumuza göz atın: Hugging Face ile Çalışmak: Hub’a Rehberiniz. 

from huggingface_hub import login
import os

hf_token = os.environ.get("HF_TOKEN")
login(hf_token)Altyapı:

MedGemma 4B Instruct modelini ve işlemcisini yüklemek için Transformers kütüphanesini kullanıyoruz. Model, GPU’larda verimli hesaplama için bfloat16 hassasiyetini kullanacak şekilde yapılandırılmıştır.

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig

model_id = "google/medgemma-4b-it"

# Check if GPU supports bfloat16
if torch.cuda.get_device_capability()[0] < 8:
    raise ValueError("GPU does not support bfloat16, please use a GPU that supports bfloat16.")

model_kwargs = dict(
    attn_implementation="eager",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

model = AutoModelForImageTextToText.from_pretrained(model_id, **model_kwargs)
processor = AutoProcessor.from_pretrained(model_id)

# Use right padding to avoid issues during training
processor.tokenizer.padding_side = "right"Altyapı:

7. Modelin yapılandırılması

MedGemma 4B Instruct modelini verimli bir şekilde ince ayarlamak için, bir parametre-verimli ince ayar yöntemi olan Low-Rank Adaptation (LoRA) kullanacağız. 

LoRA, yalnızca az sayıda ek parametreyi eğiterek büyük modelleri uyarlamamıza olanak tanır; böylece hesaplama maliyetlerini önemli ölçüde düşürürken performansı korur. 

from peft import LoraConfig

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.05,
    r=16,
    bias="none",
    target_modules="all-linear",
    task_type="CAUSAL_LM",
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)Altyapı:

Eğitim sırasında hem görsel hem metin girdilerini işlemek için özel bir birleştirme (collation) işlevi tanımlıyoruz. Bu işlev, veri kümesi örneklerini modele uygun bir biçime dönüştürür; metinlerin belirteçlenmesini ve görüntü verilerinin hazırlanmasını içerir.

def collate_fn(examples: list[dict[str, any]]):
    texts = []
    images = []
    for example in examples:
        images.append([example["image"]])
        texts.append(
            processor.apply_chat_template(
                example["messages"], add_generation_prompt=False, tokenize=False
            ).strip()
        )

    # Tokenize the texts and process the images
    batch = processor(text=texts, images=images, return_tensors="pt", padding=True)

    # The labels are the input_ids, with the padding and image tokens masked in
    # the loss computation
    labels = batch["input_ids"].clone()

    # Mask image tokens
    image_token_id = [
        processor.tokenizer.convert_tokens_to_ids(
            processor.tokenizer.special_tokens_map["boi_token"]
        )
    ]
    # Mask tokens that are not used in the loss computation
    labels[labels == processor.tokenizer.pad_token_id] = -100
    labels[labels == image_token_id] = -100
    labels[labels == 262144] = -100

    batch["labels"] = labels
    return batchAltyapı:

Eğitim argümanlarını tanımlamak için trl kütüphanesindeki SFTConfig sınıfını kullanıyoruz. Bu argümanlar, toplu iş boyutu, öğrenme oranı ve gradyan biriktirme adımları gibi ince ayar sürecini kontrol eder.

from trl import SFTConfig

args = SFTConfig(
    output_dir="medgemma-brain-cancer",            
    num_train_epochs=1,                       
    per_device_train_batch_size=8,                           
    per_device_eval_batch_size=8,                            
    gradient_accumulation_steps=8,                           
    gradient_checkpointing=True,                             
    optim="adamw_torch_fused",                               
    logging_steps=0.1,                                        
    save_strategy="epoch",                                   
    eval_strategy="steps",                                   
    eval_steps=0.1,                                           
    learning_rate=2e-4,                             
    bf16=True,                                               
    max_grad_norm=0.3,                                       
    warmup_ratio=0.03,                                       
    lr_scheduler_type="linear",                              
    push_to_hub=True,                                        
    report_to="none",
    gradient_checkpointing_kwargs={"use_reentrant": False},  
    dataset_kwargs={"skip_prepare_dataset": True},           
    remove_unused_columns = False,                           
    label_names=["labels"],                                  
)Altyapı:

SFTTrainer, modeli, veri kümesini, veri birleştiriciyi, eğitim argümanlarını ve LoRA yapılandırmasını tek bir iş akışında birleştirerek ince ayar sürecini basitleştirir. Bu, süreci daha akıcı ve kullanıcı dostu hale getirir.

from trl import SFTTrainer

trainer = SFTTrainer(
    model=model,
    args=args,
    train_dataset=formatted_data["train"],
    eval_dataset=formatted_data["validation"].shuffle().select(range(50)), 
    peft_config=peft_config,
    processing_class=processor,
    data_collator=collate_fn,
)Altyapı:

8. Modelin eğitilmesi

Model, veri kümesi ve eğitim yapılandırmaları ayarlandıktan sonra ince ayar sürecine başlayabiliriz. SFTTrainer bu adımı sadeleştirir ve yalnızca tek bir komutla modeli eğitmemizi sağlar:

trainer.train()Altyapı:

Eğitim süreci yaklaşık 1 saat 8 dakika sürdü. Bu süre boyunca, eğitim kaybı ve doğrulama kaybı her adımda istikrarlı şekilde azaldı; bu da modelin etkili biçimde öğrendiğini gösteriyor.

Eğitim tamamlandıktan sonra, ince ayarlı model yerel olarak kaydedilebilir ve save_model() yöntemi kullanılarak Hugging Face Hub’a gönderilebilir. 

trainer.save_model()Altyapı:

Model artık burada erişilebilir: kingabzpro/medgemma-brain-cancer · Hugging Face

Kaynak kingabzpro/medgemma-brain-cancer

Model Değerlendirmesi

MedGemma 4B modelinin performansını değerlendirmek için, doğrulama veri kümesi üzerinde hem temel modeli hem de ince ayarlı modeli test edeceğiz. Bu süreç; belleği temizlemeyi, test verisini hazırlamayı, yanıt üretmeyi ve doğruluk ile F1 skoru gibi temel metrikleri hesaplamayı içerir. 

Değerlendirmeye başlamadan önce, GPU belleğini boşaltmak ve test için temiz bir ortam sağlamak amacıyla eğitim kurulumunu kaldırıyoruz

del model
del trainer
torch.cuda.empty_cache()Altyapı:

9. Model testi için hazırlık

Doğrulama veri kümesini, modelin gerektirdiği girdi yapısına uyacak şekilde biçimlendiriyoruz. Bu, her örnek için kullanıcı istemini içeren bir "messages" sütunu oluşturmayı kapsar.

def format_test_data(example: dict[str, any]) -> dict[str, any]:
    example["messages"] = [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                },
                {
                    "type": "text",
                    "text": PROMPT,
                },
            ],
        },
    ]
    return example

test_data = data["validation"]
test_data = test_data.map(format_test_data)Altyapı:

Modelin performansını değerlendirmek için, sınıflandırma gibi görevler için önceden hazırlanmış metrikler sunan evaluate kütüphanesini kullanıyoruz. Kütüphaneyi içe aktarıp gerekli metrikleri yükledikten sonra, test veri kümesinden yer-gerçek (ground-truth) etiketleri çıkarıyoruz. Ardından, tahminleri bu etiketlerle karşılaştırarak doğruluk ve F1 skorunu hesaplayan bir yardımcı işlev olan compute_metrics tanımlanır.

import evaluate

accuracy_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")

# Ground-truth labels
REFERENCES = test_data["label"]


def compute_metrics(predictions: list[int]) -> dict[str, float]:
    metrics = {}
    metrics.update(
        accuracy_metric.compute(
            predictions=predictions,
            references=REFERENCES,
        )
    )
    metrics.update(
        f1_metric.compute(
            predictions=predictions,
            references=REFERENCES,
            average="weighted",
        )
    )
    return metricsAltyapı:

Etiket işleme tutarlılığını sağlamak için, veri kümesinin "label" sütununu bir ClassLabel türüne döküyoruz. Bu, etiket dizinleri ile bunların adları arasında verimli eşleme yapılmasını sağlar. Ayrıca, son işlem aşamasında etiket biçimlendirme varyasyonlarını ele almak için alternatif etiket eşlemeleri tanımlıyoruz.

from datasets import ClassLabel

test_data = test_data.cast_column(
    "label",
    ClassLabel(names=BRAIN_CANCER_CLASSES)
)

LABEL_FEATURE = test_data.features["label"]

ALT_LABELS = dict([
    (label, f"({label.replace(': ', ') ')}") for label in BRAIN_CANCER_CLASSES
])Altyapı:

Modelin tahminlerini doğru sınıf etiketleriyle eşlemek için bir postprocess işlevi tanımlıyoruz. Bu işlev, hem standart hem de alternatif etiket biçimlerini hesaba katarak tahminlerin uygun etiketle eşleşmesini sağlar.

def postprocess(prediction, do_full_match: bool = False) -> int:
    if isinstance(prediction, str):
        response_text = prediction
    else:
        response_text = prediction[0]["generated_text"]

    if do_full_match:
        return LABEL_FEATURE.str2int(response_text)

    for label in BRAIN_CANCER_CLASSES:
        # accept canonical or alternative wording
        if label in response_text or ALT_LABELS[label] in response_text:
            return LABEL_FEATURE.str2int(label)

    return -1Altyapı:

10. Temel modelde model performansı

Temel modelin performansını değerlendirmek için, önceden eğitilmiş modeli ve işlemciyi yüklüyor, üretim ayarlarını yapılandırıyor ve test için istemleri ve görselleri hazırlıyoruz.

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

model_kwargs = dict(
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

model = AutoModelForImageTextToText.from_pretrained(
    model_id, **model_kwargs
)

from transformers import GenerationConfig
gen_cfg = GenerationConfig.from_pretrained(model_id)
gen_cfg.update(
    do_sample          = False, 
    top_k              = None, 
    top_p              = None,
    cache_implementation = "dynamic" 
)
model.generation_config = gen_cfg

processor  = AutoProcessor.from_pretrained(args.output_dir)
tok = processor.tokenizer

model.config.pad_token_id            = tok.pad_token_id
model.generation_config.pad_token_id = tok.pad_token_id

def chat_to_prompt(chat_turns):
    return processor.apply_chat_template(
        chat_turns,
        add_generation_prompt=True,   # tells the model "your turn"
        tokenize=False                # we want raw text, not ids
    )

prompts = [chat_to_prompt(c) for c in test_data["messages"]]
images  = test_data["image"]                         # already a list of PIL images
assert len(prompts) == len(images), "1 prompt must match 1 image!"Altyapı:

batch_predict adlı, test veri kümesini toplu halde işleyen bir işlev oluşturduk. Bu işlev, her bir istem-görüntü çifti için tahminler üretir ve çıktıları doğru etiketlere eşlemek için son işlem uygular.

import torch
from typing import List, Any, Callable


def batch_predict(
    prompts,
    images,
    model,
    processor,
    postprocess,
    *,
    batch_size=64,
    device="cuda",
    dtype=torch.bfloat16,
    **gen_kwargs
):
    preds = []
    for i in range(0, len(prompts), batch_size):
        texts = prompts[i : i + batch_size]
        imgs = [[img] for img in images[i : i + batch_size]]
        enc = processor(text=texts, images=imgs, padding=True, return_tensors="pt").to(
            device, dtype=dtype
        )
        lens = enc["attention_mask"].sum(dim=1)
        with torch.inference_mode():
            out = model.generate(
                **enc,
                disable_compile=True,
                **gen_kwargs
            )
        for seq, ln in zip(out, lens):
            ans = processor.decode(seq[ln:], skip_special_tokens=True)
            preds.append(postprocess(ans))
    return predsAltyapı:

Temel model için test veri kümesinde tahminler üretmek üzere batch_predict işlevini kullanacağız. Ardından tahminler compute_metrics işleviyle değerlendirilecektir.

bf_preds = batch_predict(
    model         = model,
    processor     = processor,
    prompts       = prompts,
    images        = images,
    batch_size    = 64,
    max_new_tokens= 40,          # forwarded to generate
    postprocess= postprocess, # your label-mapping function
)




bf_metrics = compute_metrics(bf_preds)
print(f"Baseline metrics: {bf_metrics}")Altyapı:

Sonuç etkileyici değil. %33 doğruluk elde ettik; bu oldukça kötü. 

Baseline metrics: {'accuracy': 0.33745874587458746, 'f1': 0.1737287617650654}Altyapı:

Modelin davranışını daha iyi anlamak için, veri kümesinden tek bir örnek için tahmin üretebiliriz. Bu, girdiyi işleyip modelin yanıtını döndüren yardımcı bir işlev oluşturmayı içerir.

predict_one işlevi bir istem ve görüntüyü girdi olarak alır, bunları modelin işlemcisiyle işler ve bir yanıt üretir. İşlev, modelin çıktısının insan tarafından okunabilir metne çözümlenmesini sağlar.

import torch
from typing import Union, Dict, Any, List
from transformers import AutoModelForImageTextToText, AutoProcessor


def predict_one(
    prompt,
    image,
    model,
    processor,
    *,
    device="cuda",
    dtype=torch.bfloat16,
    disable_compile=True,
    **gen_kwargs
) -> str:
    inputs = processor(text=prompt, images=image, return_tensors="pt").to(
        device, dtype=dtype
    )
    plen = inputs["input_ids"].shape[-1]
    with torch.inference_mode():
        ids = model.generate(
            **inputs,
            disable_compile=disable_compile,
            **gen_kwargs
        )
    return processor.decode(ids[0, plen:], skip_special_tokens=True)Altyapı:

predict_one işlevini veri kümesindeki 11. örnek için bir yanıt üretmek üzere kullanacağız. Bu, istemin hazırlanmasını ve tahmin işlevinin çalıştırılmasını içerir.

idx     = 10
chat    = test_data["messages"][idx]
prompt  = processor.apply_chat_template(
            chat,
            add_generation_prompt=True,
            tokenize=False
          )

# run the one-sample helper
answer = predict_one(
    prompt   = prompt,
    image    = test_data["image"][idx],
    model    = model,
    processor= processor,
    max_new_tokens = 40 
)

print("Model answer:", answer)Altyapı:

Sonuç olarak, neden beyin gliomasının seçildiğini açıklayan uzun bir cümle aldık. Yanıt tamamen yanlış; sınıflandırma dahi hatalı.

Model answer: Based on the MRI image, the most likely type of brain cancer is **A: brain glioma**.

Here's why:

*   **Gliomas** are a common type of brain tumorAltyapı:

11. İnce ayarlı modelde model performansı

İnce ayarlı modeli değerlendirmek için, modeli çıktı dizininden yükleyerek, tahminler üreterek ve metrikleri hesaplayarak süreci tekrarlıyoruz.

Modeli ve işlemciyi çıktı dizininden yüklüyor, batch_predict işlevini çalıştırıyor ve metrikleri hesaplıyoruz. 

model = AutoModelForImageTextToText.from_pretrained(
    args.output_dir, **model_kwargs
)
model.generation_config = gen_cfg

processor  = AutoProcessor.from_pretrained(args.output_dir)
tok = processor.tokenizer

model.config.pad_token_id            = tok.pad_token_id
model.generation_config.pad_token_id = tok.pad_token_id

af_preds = batch_predict(
    model         = model,
    processor     = processor,
    prompts       = prompts,
    images        = images,
    batch_size    = 64,
    max_new_tokens= 40,          # forwarded to generate
    postprocess= postprocess, # your label-mapping function
)
af_metrics = compute_metrics(af_preds)
print(f"Fine-tuned metrics: {af_metrics}")Altyapı:

Bu sonuçlar, ince ayarın etkinliğini vurgulayarak temel modele göre önemli bir iyileşme gösteriyor. Doğruluk yalnızca 1 epok ile %33’ten %89’a sıçradı. 

Fine-tuned metrics: {'accuracy': 0.8927392739273927, 'f1': 0.892641793935792}Altyapı:

İnce ayarlı modelin performansını daha ayrıntılı analiz etmek için, test veri kümesinden tek bir örnek için tahmin üretiyoruz.

idx     = 10
chat    = test_data["messages"][idx]
prompt  = processor.apply_chat_template(
            chat,
            add_generation_prompt=True,
            tokenize=False
          )

# run the one-sample helper
answer = predict_one(
    prompt   = prompt,
    image    = test_data["image"][idx],
    model    = model,
    processor= processor,
    max_new_tokens = 40              # any generate-kwargs you need
)

print("Model answer:", answer)Altyapı:

Model, sonucu net ve isabetli bir şekilde üretti; sınıflandırma hem doğru hem de iyi yapılandırılmıştı.

Model answer: C: brain tumorAltyapı:

Yukarıdaki kodu çalıştırırken sorun yaşıyorsanız, eşlik eden not defterine bakın: Fine_tuning_MedGemma.ipynb

Sonuç

MedGemma, tıp bilimlerinde yapay zekâ kullanımında önemli bir ileri adıma işaret ediyor. Hekimlere daha hızlı ve daha isabetli yargılarda bulunma imkânı vererek, daha hızlı tanılar ve hastalar için daha etkili tedavi planları sağlar. 

MedGemma 4B Instruct gibi görsel-dil modellerinin ince ayarla uyarlanması, görüntü sınıflandırmadan akıl yürütme yeteneklerinin entegrasyonuna kadar çeşitli tıbbi görevlere uyarlanabilirlik sağlar. 

Bu öğreticide, bir Beyin MRI veri kümesi üzerinde beyin kanseri sınıflandırması için bir görsel-dil modelinin nasıl ince ayarla uyarlandığını öğrendik. Sonuçlar çarpıcıydı; modelin doğruluğu %33’ten %89’a yükseldi. Bu kayda değer sıçrama, tıbbi yapay zekâ uygulamalarında ince ayarın potansiyelini ortaya koyuyor.

Daha fazlasını öğrenmekle ilgileniyorsanız, şu kaynaklara göz atmanızı öneririm: 

• Python ile Biyomedikal Görüntü Analizi kursu
• PyTorch ile Görüntüler için Derin Öğrenme kursu
• Kendi Llama 3 Modelinizin İnce Ayarı code-along