# Görüntü Segmentasyonu

Görüntü segmentasyon modelleri, bir görüntüdeki farklı ilgi alanlarına karşılık gelen bölgeleri ayırır. Bu modeller, her piksele bir etiket atayarak çalışır. Segmentasyonun çeşitli türleri vardır: anlamsal segmentasyon, örnek segmentasyonu ve panoptik segmentasyon.

Bu kılavuzda şunları yapacağız:

1. [Farklı segmentasyon türlerine göz atın](#types-of-segmentation).
2. [semantik segmentasyon için uçtan uca ince ayar örneği](#fine-tuning-a-model-for-segmentation).

Başlamadan önce, gerekli tüm kütüphanelerin yüklendiğinden emin olun:

```py
# uncomment to install the necessary libraries
!pip install -q datasets transformers evaluate accelerate trackio
```

Modelinizi yükleyip toplulukla paylaşabilmeniz için Hugging Face hesabınıza giriş yapmanızı öneririz. İstendiğinde giriş yapmak için token'ınızı girin:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Segmentasyon Türleri

Anlamsal segmentasyon, bir görüntüdeki her bir piksele bir etiket veya sınıf atar. Anlamsal segmentasyon modeli çıktısına bir bakalım. Bir görüntüde karşılaştığı bir nesnenin tüm örneklerine aynı sınıfı atar; örneğin, tüm kediler "cat-1", "cat-2" yerine "cat" olarak etiketlenir. Anlamsal bir segmentasyon modelini hızlıca çıkarım yapmak için transformers kütüphanesinin görüntü segmentasyon hattını kullanabiliriz. Örnek görüntüye bir bakalım.

```python
from transformers import pipeline
from PIL import Image
import requests

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/segmentation_input.jpg"
image = Image.open(requests.get(url, stream=True).raw)
image
```

     

[nvidia/segformer-b1-finetuned-cityscapes-1024-1024](https://huggingface.co/nvidia/segformer-b1-finetuned-cityscapes-1024-1024) kullanacağız.

```python
semantic_segmentation = pipeline("image-segmentation", "nvidia/segformer-b1-finetuned-cityscapes-1024-1024")
results = semantic_segmentation(image)
results
```

Segmentasyon hattı çıktısı, tahmin edilen her sınıf için bir maske içerir.

```bash
[{'score': None,
  'label': 'road',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'sidewalk',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'building',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'wall',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'pole',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'traffic sign',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'vegetation',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'terrain',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'sky',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': None,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>}]
```

Araba sınıfının maskesine baktığımızda, her arabanın aynı maske ile sınıflandırıldığını görebiliriz.

```python
results[-1]["mask"]
```

     

Örnek segmentasyonunda amaç her pikseli sınıflandırmak değil, verilen bir görüntüdeki **nesnenin her örneği** için bir maske tahmin etmektir. Nesne algılama ile çok benzer şekilde çalışır; her örnek için bir sınırlayıcı kutu yerine bir segmentasyon maskesi vardır. Bunun için [facebook/mask2former-swin-large-cityscapes-instance](https://huggingface.co/facebook/mask2former-swin-large-cityscapes-instance) kullanılacaktır.

```python
instance_segmentation = pipeline("image-segmentation", "facebook/mask2former-swin-large-cityscapes-instance")
results = instance_segmentation(image)
results
```

Aşağıda görebileceğiniz gibi, birden fazla araç sınıflandırılmış olup, araç ve kişi örneklerine ait olmayan pikseller için herhangi bir sınıflandırma yapılmamıştır.

```bash
[{'score': 0.999944,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999945,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999652,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.903529,
  'label': 'person',
  'mask': <PIL.Image.Image image mode=L size=612x415>}]
```

Aşağıdaki araç maskelerinden birini inceliyoruz.

```python
results[2]["mask"]
```

     

Panoptik segmentasyon, her pikselin bir sınıfa ve o sınıfın bir örneğine (instance) sınıflandırıldığı, her sınıf örneği için birden fazla maske bulunan semantik segmentasyon ve örnek segmentasyonunu birleştirir. Bunu [facebook/mask2former-swin-large-cityscapes-panoptic](https://huggingface.co/facebook/mask2former-swin-large-cityscapes-panoptic) ile yapabiliriz.

```python
panoptic_segmentation = pipeline("image-segmentation", "facebook/mask2former-swin-large-cityscapes-panoptic")
results = panoptic_segmentation(image)
results
```

Aşağıda görebileceğiniz gibi daha fazla sınıfımız var. Daha sonra, her pikselin sınıflardan birine sınıflandırıldığını göstermek için bir örnek sunacağız.

```bash
[{'score': 0.999981,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999958,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.99997,
  'label': 'vegetation',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999575,
  'label': 'pole',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999958,
  'label': 'building',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999634,
  'label': 'road',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.996092,
  'label': 'sidewalk',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.999221,
  'label': 'car',
  'mask': <PIL.Image.Image image mode=L size=612x415>},
 {'score': 0.99987,
  'label': 'sky',
  'mask': <PIL.Image.Image image mode=L size=612x415>}]
```

Tüm segmentasyon türleri için yan yana bir karşılaştırma yapalım.

     

Tüm segmentasyon türlerini gördükten sonra, semantik segmentasyon için bir modelin ince ayarına derinlemesine bakalım.

Anlamsal segmentasyonun yaygın gerçek dünya uygulamaları arasında, otonom araçların yaya ve önemli trafik bilgilerini tanımlaması için eğitim verilmesi, tıbbi görüntülerde hücreleri ve anormallikleri belirleme ve uydu görüntülerinden çevresel değişiklikleri izleme yer alır.

## Segmentasyon için Bir Modelin İnce Ayarı

Şimdi şunları yapacağız:

1. [SegFormer](../model_doc/segformer#segformer) modelini [SceneParse150](https://huggingface.co/datasets/merve/scene_parse_150) veri setinde ince ayarlayın.
2. İnce ayarladığınız modeli çıkarım için kullanın.

Bu görevle uyumlu tüm mimarileri ve denetim noktalarını görmek için [görev sayfasını](https://huggingface.co/tasks/image-segmentation) kontrol etmenizi öneririz.

### SceneParse150 veri setini yükle

Önce 🤗 Datasets kütüphanesinden SceneParse150 veri setinin daha küçük bir alt kümesini yükleyerek başlayın. Bu, tam veri setinde eğitim için daha fazla zaman harcamadan önce deneyler yapmanıza ve her şeyin çalıştığını doğrulamanıza olanak tanır.

```py
>>> from datasets import load_dataset

>>> ds = load_dataset("merve/scene_parse_150", split="train[:50]")
```

Veri setinin `train` bölümünü [train_test_split](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split) yöntemiyle eğitim ve test kümesine ayırın:

```py
>>> ds = ds.train_test_split(test_size=0.2)
>>> train_ds = ds["train"]
>>> test_ds = ds["test"]
```

Sonra bir örneğe göz atın:

```py
>>> train_ds[0]
{'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=512x683 at 0x7F9B0C201F90>,
 'annotation': <PIL.PngImagePlugin.PngImageFile image mode=L size=512x683 at 0x7F9B0C201DD0>,
 'scene_category': 368}

# view the image
>>> train_ds[0]["image"]
```

- `image`: Sahnenin bir PIL görüntüsü.
- `annotation`: segmentasyon haritasının PIL görüntüsü, bu aynı zamanda modelin hedefidir.
- `scene_category`: "mutfak" veya "ofis" gibi görüntü sahnesini tanımlayan bir kategori kimliği. Bu kılavuzda yalnızca `image` ve `annotation` alanlarına ihtiyacınız olacak; her ikisi de PIL görüntüleridir.

Daha sonra modeli yapılandırırken işinize yarayacak, bir etiket kimliğini bir etiket sınıfına eşleyen bir sözlük de oluşturmak isteyeceksiniz. Eşlemeleri Hub'dan indirin ve `id2label` ile `label2id` sözlüklerini oluşturun:

```py
>>> import json
>>> from pathlib import Path
>>> from huggingface_hub import hf_hub_download

>>> repo_id = "huggingface/label-files"
>>> filename = "ade20k-id2label.json"
>>> id2label = json.loads(Path(hf_hub_download(repo_id, filename, repo_type="dataset")).read_text())
>>> id2label = {int(k): v for k, v in id2label.items()}
>>> label2id = {v: k for k, v in id2label.items()}
>>> num_labels = len(id2label)
```

### Ön işleme

Bir sonraki adım, görüntüleri ve etiketleri model için hazırlamak üzere bir SegFormer görüntü işleyicisi yüklemektir. Bu gibi bazı veri setleri, arka plan sınıfı olarak sıfır indeksini kullanır. Ancak arka plan sınıfı aslında 150 sınıfın içinde yer almadığından, tüm etiketlerden bir çıkarmak için `do_reduce_labels=True` değerini ayarlamanız gerekir. Sıfır indeksi, SegFormer'ın kayıp fonksiyonu tarafından yok sayılması için `255` ile değiştirilir:

```py
>>> from transformers import AutoImageProcessor

>>> checkpoint = "nvidia/mit-b0"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint, do_reduce_labels=True)
```

Bir görüntü veri setine, modelin aşırı öğrenmeye karşı daha dayanıklı hale getirilmesi için bazı veri artırma (data augmentation) teknikleri uygulamak yaygın bir uygulamadır. Bu kılavuzda, [torchvision](https://pytorch.org/vision/stable/index.html) kütüphanesinden [`ColorJitter`](https://pytorch.org/vision/stable/generated/torchvision.transforms.ColorJitter.html) fonksiyonunu kullanarak bir görüntünün renk özelliklerini rastgele değiştireceksiniz; ancak istediğiniz herhangi bir görüntü kütüphanesini de kullanabilirsiniz.

```py
>>> from torchvision.transforms import ColorJitter

>>> jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1)
```

Şimdi, görüntüleri ve etiketleri modele hazırlamak için iki ön işleme fonksiyonu oluşturun. Bu fonksiyonlar görüntüleri `pixel_values` ve etiketleri `labels` biçimine dönüştürür. Eğitim seti için, görüntüler görüntü işleyiciye verilmeden önce `jitter` uygulanır. Test seti için ise görüntü işleyici `images` öğelerini kırpıp normalize eder ve test sırasında veri artırımı uygulanmadığından yalnızca `labels` öğelerini kırpma işlemini gerçekleştirir.

```py
>>> def train_transforms(example_batch):
...     images = [jitter(x) for x in example_batch["image"]]
...     labels = [x for x in example_batch["annotation"]]
...     inputs = image_processor(images, labels)
...     return inputs

>>> def val_transforms(example_batch):
...     images = [x for x in example_batch["image"]]
...     labels = [x for x in example_batch["annotation"]]
...     inputs = image_processor(images, labels)
...     return inputs
```

Veri setinin tamamına `jitter` uygulamak için 🤗 Datasets'in [set_transform](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.set_transform) işlevini kullanın. Dönüşüm anlık olarak uygulandığından daha hızlıdır ve daha az disk alanı tüketir:

```py
>>> train_ds.set_transform(train_transforms)
>>> test_ds.set_transform(val_transforms)
```

### Değerlendir

Eğitim sırasında bir metrik kullanmak, model performansınızı değerlendirmek için genellikle faydalıdır. 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) kütüphanesiyle bir değerlendirme yöntemini hızla yükleyebilirsiniz. Bu görev için [mean Intersection over Union](https://huggingface.co/spaces/evaluate-metric/accuracy) (IoU) metrikini yükleyin (metrik yükleme ve hesaplama hakkında daha fazla bilgi için 🤗 Evaluate [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) sayfasına bakın):

```py
>>> import evaluate

>>> metric = evaluate.load("mean_iou")
```

Ardından metrikleri [hesaplamak](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) için bir işlev oluşturun. Tahminlerinizin önce logitlere dönüştürülmesi, ardından etiketlerin boyutuyla eşleşecek şekilde yeniden şekillendirilmesi gerekir; ancak bu adımlardan sonra [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) çağrılabilir:

```py
>>> import numpy as np
>>> import torch
>>> from torch import nn

>>> def compute_metrics(eval_pred):
...     with torch.no_grad():
...         logits, labels = eval_pred
...         logits_tensor = torch.from_numpy(logits)
...         logits_tensor = nn.functional.interpolate(
...             logits_tensor,
...             size=labels.shape[-2:],
...             mode="bilinear",
...             align_corners=False,
...         ).argmax(dim=1)

...         pred_labels = logits_tensor.detach().cpu().numpy()
...         metrics = metric.compute(
...             predictions=pred_labels,
...             references=labels,
...             num_labels=num_labels,
...             ignore_index=255,
...             reduce_labels=False,
...         )
...         for key, value in metrics.items():
...             if isinstance(value, np.ndarray):
...                 metrics[key] = value.tolist()
...         return metrics
```

`compute_metrics` fonksiyonunuz artık hazır ve eğitiminizi yapılandırırken ona geri döneceksiniz.

### Eğit

[Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) ile bir modelin ince ayarını yapma konusunda deneyiminiz yoksa, temel öğreticiyi [burada](../training) inceleyebilirsiniz!

Modelinizi eğitmeye başlamak için hazırsınız! [AutoModelForSemanticSegmentation](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModelForSemanticSegmentation) ile SegFormer'ı yükleyin ve modele etiket kimlikleri ile etiket sınıfları arasındaki eşlemeyi iletin:

```py
>>> from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Trainer

>>> model = AutoModelForSemanticSegmentation.from_pretrained(checkpoint, id2label=id2label, label2id=label2id)
```

Bu noktada yalnızca üç adım kaldı:

1. Eğitim hiperparametrelerinizi [TrainingArguments](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.TrainingArguments) içinde tanımlayın. Kullanılmayan sütunları kaldırmamanız önemlidir, çünkü bu işlem `image` sütununu düşürür. `image` sütunu olmadan `pixel_values` oluşturamazsınız. Bu davranışı önlemek için `remove_unused_columns=False` ayarlayın! Tek diğer zorunlu parametre, modelinizi nereye kaydedeceğinizi belirten `output_dir`'dir. Modelinizi Hub'a `push_to_hub=True` ayarlayarak yükleyeceksiniz (modelinizi yüklemek için Hugging Face'e giriş yapmış olmanız gerekir). Her epoch sonunda [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer), IoU metrikini değerlendirir ve eğitim checkpoint'ini kaydeder.
2. Eğitim argümanlarını, model, veri seti, tokenizer, veri toplayıcı ve `compute_metrics` fonksiyonuyla birlikte [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer)'a iletin.
3. Modelinizi ince ayar yapmak için [train()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.train) çağrın.

```py
>>> training_args = TrainingArguments(
...     output_dir="segformer-b0-scene-parse-150",
...     learning_rate=6e-5,
...     num_train_epochs=50,
...     per_device_train_batch_size=2,
...     per_device_eval_batch_size=2,
...     save_total_limit=3,
...     eval_strategy="steps",
...     save_strategy="steps",
...     save_steps=20,
...     eval_steps=20,
...     logging_steps=1,
...     report_to="trackio",
...     run_name="scene-parse-150",
...     eval_accumulation_steps=5,
...     remove_unused_columns=False,
...     push_to_hub=True,
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=train_ds,
...     eval_dataset=test_ds,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()
```

Eğitim tamamlandıktan sonra, modelinizi herkesin kullanabilmesi için [push_to_hub()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.push_to_hub) yöntemiyle Hub'a paylaşın:

```py
>>> trainer.push_to_hub()
```

### Çıkarım

Harika, bir model ayarladıktan sonra artık çıkarım için kullanabilirsiniz!

Veri setini yeniden yükleyin ve çıkarım için bir görüntü yükleyin.

```py
>>> from datasets import load_dataset

>>> ds = load_dataset("merve/scene_parse_150", split="train[:50]")
>>> ds = ds.train_test_split(test_size=0.2)
>>> test_ds = ds["test"]
>>> image = ds["test"][0]["image"]
>>> image
```

    

Şimdi bir pipeline olmadan çıkarım yapmayı göreceğiz. Görüntüyü bir görüntü işleyiciyle işleyin ve `pixel_values` değerlerini bir GPU'ya yerleştirin:

```py
>>> from accelerate import Accelerator
>>> device = Accelerator().device
>>> encoding = image_processor(image, return_tensors="pt")
>>> pixel_values = encoding.pixel_values.to(device)
```

Girdinizi modele iletin ve `logits` değerlerini döndürün:

```py
>>> outputs = model(pixel_values=pixel_values)
>>> logits = outputs.logits.cpu()
```

Ardından, logitleri orijinal görüntü boyutuna yeniden ölçekleyin:

```py
>>> upsampled_logits = nn.functional.interpolate(
...     logits,
...     size=image.size[::-1],
...     mode="bilinear",
...     align_corners=False,
... )

>>> pred_seg = upsampled_logits.argmax(dim=1)[0]
```

Sonuçları görselleştirmek için, her sınıfı RGB değerlerine eşleyen [veri seti renk paletini](https://github.com/tensorflow/models/blob/3f1ca33afe3c1631b733ea7e40c294273b9e406d/research/deeplab/utils/get_dataset_colormap.py#L51) `ade_palette()` olarak yükleyin.

```py
def ade_palette():
  return np.asarray([
      [0, 0, 0],
      [120, 120, 120],
      [180, 120, 120],
      [6, 230, 230],
      [80, 50, 50],
      [4, 200, 3],
      [120, 120, 80],
      [140, 140, 140],
      [204, 5, 255],
      [230, 230, 230],
      [4, 250, 7],
      [224, 5, 255],
      [235, 255, 7],
      [150, 5, 61],
      [120, 120, 70],
      [8, 255, 51],
      [255, 6, 82],
      [143, 255, 140],
      [204, 255, 4],
      [255, 51, 7],
      [204, 70, 3],
      [0, 102, 200],
      [61, 230, 250],
      [255, 6, 51],
      [11, 102, 255],
      [255, 7, 71],
      [255, 9, 224],
      [9, 7, 230],
      [220, 220, 220],
      [255, 9, 92],
      [112, 9, 255],
      [8, 255, 214],
      [7, 255, 224],
      [255, 184, 6],
      [10, 255, 71],
      [255, 41, 10],
      [7, 255, 255],
      [224, 255, 8],
      [102, 8, 255],
      [255, 61, 6],
      [255, 194, 7],
      [255, 122, 8],
      [0, 255, 20],
      [255, 8, 41],
      [255, 5, 153],
      [6, 51, 255],
      [235, 12, 255],
      [160, 150, 20],
      [0, 163, 255],
      [140, 140, 140],
      [250, 10, 15],
      [20, 255, 0],
      [31, 255, 0],
      [255, 31, 0],
      [255, 224, 0],
      [153, 255, 0],
      [0, 0, 255],
      [255, 71, 0],
      [0, 235, 255],
      [0, 173, 255],
      [31, 0, 255],
      [11, 200, 200],
      [255, 82, 0],
      [0, 255, 245],
      [0, 61, 255],
      [0, 255, 112],
      [0, 255, 133],
      [255, 0, 0],
      [255, 163, 0],
      [255, 102, 0],
      [194, 255, 0],
      [0, 143, 255],
      [51, 255, 0],
      [0, 82, 255],
      [0, 255, 41],
      [0, 255, 173],
      [10, 0, 255],
      [173, 255, 0],
      [0, 255, 153],
      [255, 92, 0],
      [255, 0, 255],
      [255, 0, 245],
      [255, 0, 102],
      [255, 173, 0],
      [255, 0, 20],
      [255, 184, 184],
      [0, 31, 255],
      [0, 255, 61],
      [0, 71, 255],
      [255, 0, 204],
      [0, 255, 194],
      [0, 255, 82],
      [0, 10, 255],
      [0, 112, 255],
      [51, 0, 255],
      [0, 194, 255],
      [0, 122, 255],
      [0, 255, 163],
      [255, 153, 0],
      [0, 255, 10],
      [255, 112, 0],
      [143, 255, 0],
      [82, 0, 255],
      [163, 255, 0],
      [255, 235, 0],
      [8, 184, 170],
      [133, 0, 255],
      [0, 255, 92],
      [184, 0, 255],
      [255, 0, 31],
      [0, 184, 255],
      [0, 214, 255],
      [255, 0, 112],
      [92, 255, 0],
      [0, 224, 255],
      [112, 224, 255],
      [70, 184, 160],
      [163, 0, 255],
      [153, 0, 255],
      [71, 255, 0],
      [255, 0, 163],
      [255, 204, 0],
      [255, 0, 143],
      [0, 255, 235],
      [133, 255, 0],
      [255, 0, 235],
      [245, 0, 255],
      [255, 0, 122],
      [255, 245, 0],
      [10, 190, 212],
      [214, 255, 0],
      [0, 204, 255],
      [20, 0, 255],
      [255, 255, 0],
      [0, 153, 255],
      [0, 41, 255],
      [0, 255, 204],
      [41, 0, 255],
      [41, 255, 0],
      [173, 0, 255],
      [0, 245, 255],
      [71, 0, 255],
      [122, 0, 255],
      [0, 255, 184],
      [0, 92, 255],
      [184, 255, 0],
      [0, 133, 255],
      [255, 214, 0],
      [25, 194, 194],
      [102, 255, 0],
      [92, 0, 255],
  ])
```

Ardından görüntünüzü ve tahmin edilen segmentasyon haritasını birleştirip çizebilirsiniz:

```py
>>> import matplotlib.pyplot as plt
>>> import numpy as np

>>> color_seg = np.zeros((pred_seg.shape[0], pred_seg.shape[1], 3), dtype=np.uint8)
>>> palette = np.array(ade_palette())
>>> for label, color in enumerate(palette):
...     color_seg[pred_seg == label, :] = color
>>> color_seg = color_seg[..., ::-1]  # convert to BGR

>>> img = np.array(image) * 0.5 + color_seg * 0.5  # plot the image with the segmentation map
>>> img = img.astype(np.uint8)

>>> plt.figure(figsize=(15, 10))
>>> plt.imshow(img)
>>> plt.show()
```

    

