Bu notebook’ta, özel veri seti üzerinde bir semantik segmentasyon modelinin fine tune sürecini adım adım gözden geçireceğiz. Kullanacağımız model, segmentasyon görevleri için güçlü ve esnek bir transformer mimarisi tabanlı olan ve önceden eğitilmiş Segformer olacaktır.

Veri seti olarak, etiketli kaldırım görüntüleri içeren segments/sidewalk-semantic veri setini kullanacağız; bu modelimizi kentsel ortamlardaki uygulamalar için ideal hale getirecek.

Örnek kullanım durumu: Bu model, pizza siparişlerinizi kapınıza kadar teslim etmek için kaldırımda otonom olarak gezinme yeteneğine sahip bir teslimat robotunda kullanılabilir. 🍕

Modeli Fine-Tune yaptıktan sonra, onu Serverless Inference API kullanarak nasıl kullanacağımızı göstereceğiz ve basit bir API endpoint aracılığıyla erişilebilir hale getireceğiz.

1. Kütüphanelerin Kurulumu

Başlamak için, semantik segmentasyon modelimizi fine-tuning yapmak için gerekli olan temel kütüphaneleri yükleyeceğiz.

!pip install -q datasets transformers evaluate wandb
# datasets==3.0.0, transformers==4.44.2, evaluate==0.4.3, wandb==0.18.1 ile test edildi

2. Verisetinin Yüklenmesi 📁

Belçika’da 2021 yılı yazında toplanan kaldırım görüntülerinden oluşan sidewalk-semantic veri setini kullanacağız.

Bu veri seti sınırlı erişimdedir, bu yüzden erişim sağlamak için oturum açmanız ve lisansı kabul etmeniz gerekmektedir. Ayrıca, eğitimin ardından fine-tuned modeli Hub’a yüklemek için kimlik doğrulaması gerekmektedir.

from huggingface_hub import notebook_login

notebook_login()

sidewalk_dataset_identifier = "segments/sidewalk-semantic"

from datasets import load_dataset

dataset = load_dataset(sidewalk_dataset_identifier)

Veri seti sadece eğitim seti içerdiği için, bunu manuel olarak eğitim ve test setlerine ayıracağız. Verilerin %80’ini eğitim için ayıracak ve kalan %20’sini değerlendirme ve test için saklayacağız. ➗

dataset = dataset.shuffle(seed=42)
dataset = dataset["train"].train_test_split(test_size=0.2)
train_ds = dataset["train"]
test_ds = dataset["test"]

Bir örnekte bulunan nesne türlerini inceleyelim. pixels_values RGB görüntüyü tutarken, label gerçek referans maske(ground truth mask) içeriyor. Maske, her pikselin RGB görüntüsündeki karşılık gelen pikselin kategorisini temsil ettiği tek kanallı bir görüntüdür.

image = train_ds[0]
image

3. Örneklerin Görselleştirilmesi! 👀

Veri setini yükledikten sonra, yapısını daha iyi anlamak için birkaç örneği maskeleriyle birlikte görselleştirelim.

Veri seti, her bir ID ile ilişkilendirilen kategori etiketlerini içeren bir JSON dosyası içerir. Bu dosyayı açarak her id2label ile eşleşenleri okuyacağız.

>>> import json
>>> from huggingface_hub import hf_hub_download

>>> filename = "id2label.json"
>>> id2label = json.load(
...     open(hf_hub_download(repo_id=sidewalk_dataset_identifier, filename=filename, repo_type="dataset"), "r")
... )
>>> id2label = {int(k): v for k, v in id2label.items()}
>>> label2id = {v: k for k, v in id2label.items()}

>>> num_labels = len(id2label)
>>> print("Id2label:", id2label)

Her kategoriye renkler atayalım 🎨. Bu, segmentasyon sonuçlarını daha etkili bir şekilde görselleştirmemize ve görüntülerimizdeki farklı kategorileri yorumlamamızı kolaylaştıracaktır.

sidewalk_palette = [
    [0, 0, 0],  # unlabeled / etiketlenmemiş
    [216, 82, 24],  # flat-road / düz-yol
    [255, 255, 0],  # flat-sidewalk / düz-kaldırım
    [125, 46, 141],  # flat-crosswalk / düz-yaya geçidi
    [118, 171, 47],  # flat-cyclinglane / düz-bisiklet yolu
    [161, 19, 46],  # flat-parkingdriveway / düz-park yeri/garaj yolu
    [255, 0, 0],  # flat-railtrack / düz-ray hattı
    [0, 128, 128],  # flat-curb / düz-kaldırım kenarı
    [190, 190, 0],  # human-person / insan-kişi
    [0, 255, 0],  # human-rider / insan-sürücü
    [0, 0, 255],  # vehicle-car / araç-araba
    [170, 0, 255],  # vehicle-truck / araç-kamyon
    [84, 84, 0],  # vehicle-bus / araç-otobüs
    [84, 170, 0],  # vehicle-tramtrain / araç-tramvay/tren
    [84, 255, 0],  # vehicle-motorcycle / araç-motosiklet
    [170, 84, 0],  # vehicle-bicycle / araç-bisiklet
    [170, 170, 0],  # vehicle-caravan / araç-karavan
    [170, 255, 0],  # vehicle-cartrailer / araç-römork
    [255, 84, 0],  # construction-building / inşaat-bina
    [255, 170, 0],  # construction-door / inşaat-kapı
    [255, 255, 0],  # construction-wall / inşaat-duvar
    [33, 138, 200],  # construction-fenceguardrail / inşaat-çit/korkuluk
    [0, 170, 127],  # construction-bridge / inşaat-köprü
    [0, 255, 127],  # construction-tunnel / inşaat-tünel
    [84, 0, 127],  # construction-stairs / inşaat-merdiven
    [84, 84, 127],  # object-pole / nesne-direk
    [84, 170, 127],  # object-trafficsign / nesne-trafik levhası
    [84, 255, 127],  # object-trafficlight / nesne-trafik ışığı
    [170, 0, 127],  # nature-vegetation / doğa-bitki örtüsü
    [170, 84, 127],  # nature-terrain / doğa-arazi
    [170, 170, 127],  # sky / gökyüzü
    [170, 255, 127],  # void-ground / boşluk-zemin
    [255, 0, 127],  # void-dynamic / boşluk-dinamik
    [255, 84, 127],  # void-static / boşluk-statik
    [255, 170, 127],  # void-unclear / boşluk-belirsiz
]

Veri setinden bazı örnekleri görselleştirebiliriz; bunlar RGB görüntü ve ona karşılık gelen maske ve maskenin görüntü üzerine bindirilmiş hali bulunur. Bu, veri setini ve maskelerin görüntülerle nasıl eşleştiğini daha iyi anlamamıza yardımcı olacaktır. 📸

>>> from matplotlib import pyplot as plt
>>> import numpy as np
>>> from PIL import Image
>>> import matplotlib.patches as patches

>>> # Legend'i(Açıklama/lejant) ayrı olarak oluştrup ve gösterelim
>>> fig, ax = plt.subplots(figsize=(18, 2))

>>> legend_patches = [
...     patches.Patch(color=np.array(color) / 255, label=label)
...     for label, color in zip(id2label.values(), sidewalk_palette)
... ]

>>> ax.legend(handles=legend_patches, loc="center", bbox_to_anchor=(0.5, 0.5), ncol=5, fontsize=8)
>>> ax.axis("off")

>>> plt.show()

>>> for i in range(5):
...     image = train_ds[i]

...     fig, ax = plt.subplots(1, 3, figsize=(18, 6))

...     # Orjinal resmi göster
...     ax[0].imshow(image["pixel_values"])
...     ax[0].set_title("Orjinal Resim")
...     ax[0].axis("off")

...     mask_np = np.array(image["label"])

...     # Boş bir RGB resim oluştur
...     colored_mask = np.zeros((mask_np.shape[0], mask_np.shape[1], 3), dtype=np.uint8)

...     # Her etikete denk gelen maske için bir renk atayalım
...     for label_id, color in enumerate(sidewalk_palette):
...         colored_mask[mask_np == label_id] = color

...     colored_mask_img = Image.fromarray(colored_mask, "RGB")

...     # Segmentasyon maskesini göster
...     ax[1].imshow(colored_mask_img)
...     ax[1].set_title("Segmentasyon Maskesi")
...     ax[1].axis("off")

...     # Şeffaflığı desteklemek için orijinal görüntüyü RGBA formatına dönüştürün
...     image_rgba = image["pixel_values"].convert("RGBA")
...     colored_mask_rgba = colored_mask_img.convert("RGBA")

...     # Maskenin şeffaflığını ayarlayın
...     alpha = 128  # Şeffaflık seviyesi (0 tamamen şeffaf, 255 tamamen opak)
...     image_2_with_alpha = Image.new("RGBA", colored_mask_rgba.size)
...     for x in range(colored_mask_rgba.width):
...         for y in range(colored_mask_rgba.height):
...             r, g, b, a = colored_mask_rgba.getpixel((x, y))
...             image_2_with_alpha.putpixel((x, y), (r, g, b, alpha))

...     superposed = Image.alpha_composite(image_rgba, image_2_with_alpha)

...     # Show the mask overlay
...     ax[2].imshow(superposed)
...     ax[2].set_title("Maske Katmanı")
...     ax[2].axis("off")

...     plt.show()

4. Sınıf Görünümlerini Görselleştirme 📊

Veri seti hakkında daha derinlemesine bilgiler edinmek için, her bir sınıfın görünüm sayılarını grafiğe dökelim. Bu, sınıfların dağılımını anlamamıza ve veri setindeki olası önyargıları veya dengesizlikleri belirlememize yardımcı olacaktır.

import matplotlib.pyplot as plt
import numpy as np

class_counts = np.zeros(len(id2label))

for example in train_ds:
    mask_np = np.array(example["label"])
    unique, counts = np.unique(mask_np, return_counts=True)
    for u, c in zip(unique, counts):
        class_counts[u] += c

>>> from matplotlib import pyplot as plt
>>> import numpy as np
>>> from matplotlib import patches

>>> labels = list(id2label.values())

>>> # Renkleri [0, 1] aralığına normalleştir
>>> normalized_palette = [tuple(c / 255 for c in color) for color in sidewalk_palette]

>>> # Görselleştirme
>>> fig, ax = plt.subplots(figsize=(12, 8))

>>> bars = ax.bar(range(len(labels)), class_counts, color=[normalized_palette[i] for i in range(len(labels))])

>>> ax.set_xticks(range(len(labels)))
>>> ax.set_xticklabels(labels, rotation=90, ha="right")

>>> ax.set_xlabel("Kategoriler", fontsize=14)
>>> ax.set_ylabel("Görünüm Sayısı", fontsize=14)
>>> ax.set_title("Kategoriye Göre Görünüm Sayısı", fontsize=16)

>>> ax.grid(axis="y", linestyle="--", alpha=0.7)

>>> # Y ekseni limitini ayarlayın
>>> y_max = max(class_counts)
>>> ax.set_ylim(0, y_max * 1.25)

>>> for bar in bars:
...     height = int(bar.get_height())
...     offset = 10  # Metin konumunu ayarlayın
...     ax.text(
...         bar.get_x() + bar.get_width() / 2.0,
...         height + offset,
...         f"{height}",
...         ha="center",
...         va="bottom",
...         rotation=90,
...         fontsize=10,
...         color="black",
...     )

>>> fig.legend(
...     handles=legend_patches, loc="center left", bbox_to_anchor=(1, 0.5), ncol=1, fontsize=8
... )  # ncol'u gereken durumlarda ayarlayın

>>> plt.tight_layout()
>>> plt.show()

5. Image Processor’un Oluşturulması ve Albumentations ile Veri Artırımı Yapımı (Data Augmentation) 📸

Image Processor’u oluşturduktan sonra Albumentations kullanarak veri artırımı 🪄 uygulayacağız. Bu, veri setimizi zenginleştirmeye ve semantik segmentasyon modelimizin performansının artmasına yardımcı olacaktır.

import albumentations as A
from transformers import SegformerImageProcessor

image_processor = SegformerImageProcessor()

albumentations_transform = A.Compose(
    [
        A.HorizontalFlip(p=0.5),
        A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=30, p=0.7),
        A.RandomResizedCrop(height=512, width=512, scale=(0.8, 1.0), ratio=(0.75, 1.33), p=0.5),
        A.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25, p=0.5),
        A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=25, val_shift_limit=20, p=0.5),
        A.GaussianBlur(blur_limit=(3, 5), p=0.3),
        A.GaussNoise(var_limit=(10, 50), p=0.4),
    ]
)


def train_transforms(example_batch):
    augmented_images = [albumentations_transform(image=np.array(x))["image"] for x in example_batch["pixel_values"]]
    labels = [x for x in example_batch["label"]]
    inputs = image_processor(augmented_images, labels)
    return inputs


def val_transforms(example_batch):
    images = [x for x in example_batch["pixel_values"]]
    labels = [x for x in example_batch["label"]]
    inputs = image_processor(images, labels)
    return inputs


# Transformları ayarlayın
train_ds.set_transform(train_transforms)
test_ds.set_transform(val_transforms)

6. Modeli Checkpoint’ten Başlatın

from transformers import SegformerForSemanticSegmentation

pretrained_model_name = "nvidia/mit-b0"
model = SegformerForSemanticSegmentation.from_pretrained(pretrained_model_name, id2label=id2label, label2id=label2id)

7. Eğitim Argümanlarını Ayarlayın ve Weights & Biases ile Bağlantı Kurulumu 📉

Sonraki adımda, eğitim argümanlarını yapılandırılması ve Weights & Biases (W&B) ile bağlantı kuracağız. W&B, deneyleri takip etmemize, metrikleri görselleştirmemize ve model eğitim iş akışını yönetmemize yardımcı olacak, süreç boyunca değerli bilgiler sağlayacaktır.

from transformers import TrainingArguments

output_dir = "segformer-b0-segments-sidewalk-finetuned"

training_args = TrainingArguments(
    output_dir=output_dir,
    learning_rate=6e-5,
    num_train_epochs=20,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    save_total_limit=2,
    evaluation_strategy="steps",
    save_strategy="steps",
    save_steps=20,
    eval_steps=20,
    logging_steps=1,
    eval_accumulation_steps=5,
    load_best_model_at_end=True,
    push_to_hub=True,
    report_to="wandb",
)

import wandb

wandb.init(
    project="segformer-b0-segments-sidewalk-finetuned",  # bunu değiştirin
    name="segformer-b0-segments-sidewalk-finetuned",  # bunu değiştirin
    config=training_args,
)

8. evaluate ile Geliştirilmiş Loglama için Özel compute_metrics Methodunu Ayarlanamsı

Ayrıca, çıktıdaki uyarıları en aza indirmek için değerlendirme modülünün loglama seviyesini ayarlayacağız. Bir kategori bir görüntüde tespit edilmezse, aşağıdaki gibi uyarılar görebilirsiniz:

RuntimeWarning: invalid value encountered in divide iou = total_area_intersect / total_area_union

Bu hücreyi atlayabilirsiniz eğer bu uyarıları görmek isterseniz ve bir sonraki adıma geçebilirsiniz.

import evaluate

evaluate.logging.set_verbosity_error()

import torch
from torch import nn
import multiprocessing

metric = evaluate.load("mean_iou")


def compute_metrics(eval_pred):
    with torch.no_grad():
        logits, labels = eval_pred
        logits_tensor = torch.from_numpy(logits)
        # Etiket boyutuna göre logitleri ölçeklendirin
        logits_tensor = nn.functional.interpolate(
            logits_tensor,
            size=labels.shape[-2:],
            mode="bilinear",
            align_corners=False,
        ).argmax(dim=1)

        # şimdilik compute yerine _compute kullanılıyor: https://github.com/huggingface/evaluate/pull/328#issuecomment-1286866576
        pred_labels = logits_tensor.detach().cpu().numpy()
        import warnings

        with warnings.catch_warnings():
            warnings.simplefilter("ignore", RuntimeWarning)
            metrics = metric._compute(
                predictions=pred_labels,
                references=labels,
                num_labels=len(id2label),
                ignore_index=0,
                reduce_labels=image_processor.do_reduce_labels,
            )

        # kategorilere özel metrikleri ayrı key-value çiftleri olarak ekleyin
        per_category_accuracy = metrics.pop("per_category_accuracy").tolist()
        per_category_iou = metrics.pop("per_category_iou").tolist()

        metrics.update({f"accuracy_{id2label[i]}": v for i, v in enumerate(per_category_accuracy)})
        metrics.update({f"iou_{id2label[i]}": v for i, v in enumerate(per_category_iou)})

        return metrics

9. Modeli Özel Veri Setimiz Üzerinde Eğitimi 🏋

Artık modeli özel veri setimiz üzerinde eğitme zamanı geldi. Eğitim sürecini izlemek ve gerekirse ayarlamalar yapmak için hazırlanan eğitim argümanlarını ve bağlı Weights & Biases entegrasyonunu kullanacağız. Eğitime başlayalım ve modelin performansını geliştirmesini izleyelim!

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=test_ds,
    tokenizer=image_processor,
    compute_metrics=compute_metrics,
)

10. Yeni Görüntüler Üzerinde Model Performansını Değerlendirelim 📸

Eğitimden sonra, modelin yeni görüntüler üzerindeki performansını değerlendireceğiz. Bir test görüntüsü kullanacak ve modelin görünmeyen veriler üzerindeki performansını değerlendirmek için bir pipeline kullanacağız.

import requests
from transformers import pipeline
import numpy as np
from PIL import Image, ImageDraw

url = "https://images.unsplash.com/photo-1594098742644-314fedf61fb6?q=80&w=2672&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D"

image = Image.open(requests.get(url, stream=True).raw)

image_segmentator = pipeline(
    "image-segmentation",
    model="sergiopaniego/segformer-b0-segments-sidewalk-finetuned",  # Bu model adını kendi eğittiniz model ile değiştirin
)

results = image_segmentator(image)

>>> plt.imshow(image)
>>> plt.axis("off")
>>> plt.show()

Model bazı maskeler oluşturdu, bunları görselleştirerek performansını değerlendirebilir ve anlayabiliriz. Bu, modelin görüntülerinin ne kadar iyi segmente edildiğini görmemize ve iyileştirmemiz gerektiren alanları belirlememize yardımcı olacaktır.

>>> image_array = np.array(image)

>>> segmentation_map = np.zeros_like(image_array)

>>> for result in results:
...     mask = np.array(result["mask"])
...     label = result["label"]

...     label_index = list(id2label.values()).index(label)

...     color = sidewalk_palette[label_index]

...     for c in range(3):
...         segmentation_map[:, :, c] = np.where(mask, color[c], segmentation_map[:, :, c])

>>> plt.figure(figsize=(10, 10))
>>> plt.imshow(image_array)
>>> plt.imshow(segmentation_map, alpha=0.5)
>>> plt.axis("off")
>>> plt.show()

11. Test Set Üzerinde Performansı Değerlendirin 📊

metrics = trainer.evaluate(test_ds)
print(metrics)

12. Modeli Inference API’si ile Erişip ve Sonuçları Görselleştirelim 🔌

Hugging Face 🤗, “API endpoint” aracılığıyla modelleri doğrudan test etmenizi sağlayan Serverless Inference API sunmaktadır. Bu API’yi kullanma konusunda ayrıntılı bilgi için bu cookbook sayfasına göz atın.

Bu API’yi modelimizi test etmek ve API işlevselliğini öğrenmek amacıyla kullanacağız.

Serverless Inference API’sini kullanmadan önce, bir model kartı oluşturarak model görevini ayarlamanız gerekir. Fine-Tune yapılmış modeliniz için model kartını oluştururken, görevi uygun bir şekilde belirttiğinizden emin olun.

Model görevini ayarlandıktan sonra, bir görüntü indirebilir ve modeli test etmek için InferenceClient kullanabiliriz. Bu istemci, görüntüyü API aracılığıyla modele göndermemizi ve değerlendirme için sonuçları almamızı sağlayacaktır.

>>> url = "https://images.unsplash.com/photo-1594098742644-314fedf61fb6?q=80&w=2672&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> plt.imshow(image)
>>> plt.axis("off")
>>> plt.show()

InferenceClient’tan image_segmentation metodunu kullanacağız. Bu metod, model ve bir görüntü girişi alır ve tahmin edilen maskeleri döndürür. Bu, modelin yeni görüntüler üzerindeki performansını test etmemizi sağlayacaktır.

from huggingface_hub import InferenceClient

client = InferenceClient()

response = client.image_segmentation(
    model="sergiopaniego/segformer-b0-segments-sidewalk-finetuned",  # Kendi modeliniz ile değiştirin
    image="https://images.unsplash.com/photo-1594098742644-314fedf61fb6?q=80&w=2672&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D",
)

print(response)

>>> image_array = np.array(image)
>>> segmentation_map = np.zeros_like(image_array)

>>> for result in response:
...     mask = np.array(result["mask"])
...     label = result["label"]

...     label_index = list(id2label.values()).index(label)

...     color = sidewalk_palette[label_index]

...     for c in range(3):
...         segmentation_map[:, :, c] = np.where(mask, color[c], segmentation_map[:, :, c])

>>> plt.figure(figsize=(10, 10))
>>> plt.imshow(image_array)
>>> plt.imshow(segmentation_map, alpha=0.5)
>>> plt.axis("off")
>>> plt.show()

Inferenece API’ı Javascript ile kullanmak da mümkündür. JavaScript kullanarak API’yi kullanacağımıza dair bir örnek:

import { HfInference } from "@huggingface/inference";

const inference = new HfInference(HF_TOKEN);
await inference.imageSegmentation({
    data: await (await fetch("https://picsum.photos/300/300")).blob(),
    model: "sergiopaniego/segformer-b0-segments-sidewalk-finetuned",
});

from IPython.display import IFrame

IFrame(src="https://sergiopaniego-segformer-b0-segments-sidewalk-finetuned.hf.space", width=1000, height=800)

Sonuç

Bu kılavuzda, özel bir veri seti üzerinde bir semantik segmentasyon modelini başarıyla fine tune yaptık ve Serverless Inference API’yi kullanarak test ettik. Bu, modeli çeşitli uygulamalara nasıl kolayca entegre edebileceğinizi ve dağıtım için Hugging Face araçlarını nasıl kullanabileceğinizi göstermektedir.

Umarım bu kılavuz, kendi modellerinizi güvenle fine tune yapma ve dağıtma konusunda size gerekli araçları ve bilgileri sağlar! 🚀

Özel Bir Veri Seti Üzerinde Semantik Segmentasyon Modeli Fine-Tuning Etmek ve Inference API Üzerinden Kullanımı