# Maske oluşturma

Mask üretimi, bir görüntü için anlamlı maskeler üretme görevidir. Bu görev [görüntü segmentasyonu](semantic_segmentation) ile çok benzerdir, ancak aralarında birçok fark vardır. Görüntü segmentasyonu modelleri etiketli veri kümeleri üzerinde eğitilir ve eğitim sırasında gördükleri sınıflarla sınırlıdır; bir görüntü verildiğinde bir dizi maske ve bunlara karşılık gelen sınıfları döndürürler.

Mask oluşturma modelleri büyük miktarda veri üzerinde eğitilir ve iki modda çalışır.

- Prompting modu: Bu modda model, bir görüntü ve bir prompt alır; prompt, bir nesnenin içindeki 2B nokta konumu (XY koordinatları) veya bir nesneyi çevreleyen sınırlayıcı kutu olabilir. Prompting modunda model yalnızca nesne üzerindeki maskesini döndürür
istemcinin işaret ettiği
- Segment Everything modu: Segment everything modunda, verilen bir görüntü için model, görüntüdeki tüm maskeleri üretir. Bunu yapmak için, çıkarım sırasında görüntünün üzerine bindirilmek üzere bir nokta ızgarası oluşturulur.
- Video çıkarımı: Model, bir videoyu ve video karesindeki bir nokta veya kutu komutunu kabul eder; bu, videonun tamamı boyunca izlenir. Video çıkarımını nasıl yapacağınız hakkında daha fazla bilgi almak için [SAM 2 belgelerini](../model_doc/sam2) takip edebilirsiniz.

Mask oluşturma görevi [Segment Anything Model (SAM)](../model_doc/sam) ve [Segment Anything Model 2 (SAM2)](../model_doc/sam2) tarafından desteklenirken, video çıkarımı [Segment Anything Model 2 (SAM2)](../model_doc/sam2) tarafından desteklenir. SAM, Vision Transformer tabanlı bir görüntü kodlayıcı, bir istem kodlayıcı ve iki yönlü bir transformer mask çözücüden oluşan güçlü bir modeldir. Görüntüler ve istemler kodlanır ve çözücü, bu gömme değerlerini alarak geçerli maskeler üretir. Bu arada SAM 2, maskeleri izlemek için bir bellek modülü ekleyerek SAM'i genişletir.

     

SAM, geniş veri kapsamına sahip olması nedeniyle segmentasyon için güçlü bir temel model olarak hizmet eder. [SA-1B](https://ai.meta.com/datasets/segment-anything/) adlı, 1 milyon görüntü ve 1,1 milyar maske içeren bir veri setinde eğitilmiştir.

Bu kılavuzda şunları öğreneceksiniz:

- Toplu işlem (batching) ile her şeyi segmentasyon modunda çıkarım yapın,
- Nokta istemleme modunda çıkarım yapın,
- Kutuda istem (prompting) modunda çıkarım yapın.

Önce `transformers` paketini yükleyelim:

```bash
pip install -q transformers
```

## Mask Oluşturma Hattı

Mask üretim modelleri için çıkarım yapmanın en kolay yolu `mask-generation` hattını kullanmaktır.

```python
>>> from transformers import pipeline

>>> checkpoint = "facebook/sam2-hiera-base-plus"
>>> mask_generator = pipeline(model=checkpoint, task="mask-generation")
```

Görseli inceleyelim.

```python
from PIL import Image
import requests

img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
```

     

Her şeyi segmentleyelim. `points-per-batch`, segment everything modunda noktaların paralel çıkarımını (inference) etkinleştirir. Bu, çıkarımı hızlandırır ancak daha fazla bellek tüketir. Ayrıca SAM, yalnızca noktalar üzerinde toplu işlemi (batching) etkinleştirir, görüntüler üzerinde değil. `pred_iou_thresh`, yalnızca belirli bir eşiğin üzerindeki maskelerin döndürüldüğü IoU güven eşiğidir.

```python
masks = mask_generator(image, points_per_batch=128, pred_iou_thresh=0.88)
```

`masks` aşağıdaki gibidir:

```bash
{'masks': [tensor([[False, False, False,  ...,  True,  True,  True],
          [False, False, False,  ...,  True,  True,  True],
          [False, False, False,  ...,  True,  True,  True],
          ...,
          [False, False, False,  ..., False, False, False], .. 
 'scores': tensor([0.9874, 0.9793, 0.9780, 0.9776, ... 0.9016])}
```

Bunları şu şekilde görselleştirebiliriz:

```python
import matplotlib.pyplot as plt

plt.imshow(image, cmap='gray')

for i, mask in enumerate(masks["masks"]):
    plt.imshow(mask, cmap='viridis', alpha=0.1, vmin=0, vmax=1)

plt.axis('off')
plt.show()
```

Aşağıda, renkli haritaların üzerine bindirilmiş gri tonlamalı orijinal görüntü yer alıyor. Çok etkileyici.

     

## Model Çıkarımı

### Nokta İstemleme

Modeli pipeline olmadan da kullanabilirsiniz. Bunu yapmak için model ve işlemciyi başlatın.

```python
from transformers import SamModel, SamProcessor
from accelerate import Accelerator
import torch
device = Accelerator().device
model = SamModel.from_pretrained("facebook/sam-vit-base").to(device)
processor = SamProcessor.from_pretrained("facebook/sam-vit-base")
```

Nokta istemleme yapmak için girdi noktasını işlemciye iletin, ardından işlemci çıktısını alıp çıkarım için modele iletin. Model çıktısını son işlemek için çıktıları ve `original_sizes` değerlerini işlemcinin ilk çıktısından alın. İşlemci görüntüyü yeniden boyutlandırdığı ve çıktının dışa doğru genişletilmesi gerektiği için bu değerleri iletmemiz gerekir.

```python
input_points = [[[2592, 1728]]] # point location of the bee

inputs = processor(image, input_points=input_points, return_tensors="pt").to(device)
with torch.no_grad():
    outputs = model(**inputs)
masks = processor.image_processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"].cpu())
```

Üç maskenin `masks` çıktısında görselleştirilebilir.

```python
import matplotlib.pyplot as plt
import numpy as np

fig, axes = plt.subplots(1, 4, figsize=(15, 5))

axes[0].imshow(image)
axes[0].set_title('Original Image')
mask_list = [masks[0][0][0].numpy(), masks[0][0][1].numpy(), masks[0][0][2].numpy()]

for i, mask in enumerate(mask_list, start=1):
    overlayed_image = np.array(image).copy()

    overlayed_image[:,:,0] = np.where(mask == 1, 255, overlayed_image[:,:,0])
    overlayed_image[:,:,1] = np.where(mask == 1, 0, overlayed_image[:,:,1])
    overlayed_image[:,:,2] = np.where(mask == 1, 0, overlayed_image[:,:,2])
    
    axes[i].imshow(overlayed_image)
    axes[i].set_title(f'Mask {i}')
for ax in axes:
    ax.axis('off')

plt.show()
```

     

### Box Prompting

Kutu ile istem (box prompting) de, nokta ile istem (point prompting) ile benzer bir şekilde yapılabilir. Girdi kutusunu `[x_min, y_min, x_max, y_max]` biçiminde bir liste olarak, görselle birlikte `processor`'a iletmek yeterlidir. İşleyicinin (processor) çıktısını alın ve doğrudan modele iletin, ardından çıktıyı yine son işlem (post-process) uygulayın.

```python
# bounding box around the bee
box = [2350, 1600, 2850, 2100]

inputs = processor(
        image,
        input_boxes=[[[box]]],
        return_tensors="pt"
    ).to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

mask = processor.image_processor.post_process_masks(
    outputs.pred_masks.cpu(),
    inputs["original_sizes"].cpu(),
)[0][0][0].numpy()
```

Aşağıda gösterildiği gibi, arı etrafındaki sınırlayıcı kutuyu görselleştirebilirsiniz.

```python
import matplotlib.patches as patches

fig, ax = plt.subplots()
ax.imshow(image)

rectangle = patches.Rectangle((2350, 1600), 500, 500, linewidth=2, edgecolor='r', facecolor='none')
ax.add_patch(rectangle)
ax.axis("off")
plt.show()
```

     

Aşağıda çıkarım çıktısını görebilirsiniz.

```python
fig, ax = plt.subplots()
ax.imshow(image)
ax.imshow(mask, cmap='viridis', alpha=0.4)

ax.axis("off")
plt.show()
```

     

## Mask Üretimi için İnce Ayar

SAM2.1'i, görüntü matting için MicroMat veri setinin küçük bir bölümünde ince ayarlayacağız. DICE kaybını kullanmak için [monai](https://github.com/Project-MONAI/MONAI) kütüphanesini, eğitim sırasında maskeleri günlüğe kaydetmek için ise [trackio](https://huggingface.co/docs/trackio/index) kütüphanesini yüklememiz gerekiyor.

```bash
pip install -q datasets monai trackio
``` 
Şimdi veri setimizi yükleyip inceleyebiliriz.

```python
from datasets import load_dataset

dataset = load_dataset("merve/MicroMat-mini", split="train")
dataset
# Dataset({
#    features: ['image', 'mask', 'prompt', 'image_id', 'object_id', 'sample_idx', 'granularity', 
# 'image_path', 'mask_path', 'prompt_path'],  num_rows: 94
#})
```

Görsel, maske ve istem sütunlarına ihtiyacımız var. Eğitim ve test için bölüyoruz.

```python
dataset = dataset.train_test_split(test_size=0.1)
train_ds = dataset["train"]
val_ds = dataset["test"]
```

Bir örneğe göz atalım.

```python
train_ds[0]
```

```json
 {'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=2040x1356>,
 'mask': <PIL.PngImagePlugin.PngImageFile image mode=L size=2040x1356>,
 'prompt': '{"point": [[137, 1165, 1], [77, 1273, 0], [58, 1351, 0]], "bbox": [0, 701, 251, 1356]}',
 'image_id': '0034',
 'object_id': '34',
 'sample_idx': 1,
 'granularity': 'fine',
 'image_path': '/content/MicroMat-mini/img/0034.png',
 'mask_path': '/content/MicroMat-mini/mask/0034_34.png',
 'prompt_path': '/content/MicroMat-mini/prompt/0034_34.json'}
```

Prompts, sözlük dizilerinden oluştuğu için aşağıda gösterildiği gibi sınırlayıcı kutuları alabilirsiniz.

```python
import json

json.loads(train_ds["prompt"][0])["bbox"]
# [0, 701, 251, 1356]
```

Örnek bir görüntüyü, istemi ve maskenin görselleştirmesini yapın.

```python
import matplotlib.pyplot as plt
import numpy as np

def show_mask(mask, ax):
    color = np.array([0.12, 0.56, 1.0, 0.6])
    mask = np.array(mask)
    h, w = mask.shape
    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, 4)
    ax.imshow(mask_image)
    x0, y0, x1, y1 = eval(train_ds["prompt"][0])["bbox"]
    ax.add_patch(
        plt.Rectangle((x0, y0), x1 - x0, y1 - y0,
                      fill=False, edgecolor="lime", linewidth=2))

example = train_ds[0]
image = np.array(example["image"])
ground_truth_mask = np.array(example["mask"])

fig, ax = plt.subplots()
ax.imshow(image)
show_mask(ground_truth_mask, ax)
ax.set_title("Ground truth mask")
ax.set_axis_off()

plt.show() 
```

Şimdi verileri yüklemek için veri setimizi tanımlayabiliriz. SAMDataset, veri setimizi sarar ve her örneği SAM işlemcisinin beklediği biçimde düzenler. Böylece ham görüntüler ve maskeler yerine, eğitim için hazır işlenmiş görüntüler, sınırlayıcı kutular ve gerçek değer maskeleri elde edersiniz.

Varsayılan olarak, processor görüntüleri yeniden boyutlandırır; bu nedenle görüntülerin ve maskelerin yanı sıra orijinal boyutları da döndürür. Maskenin [0, 255] aralığında değerler içermesi nedeniyle ikileştirilmesi (binarize edilmesi) de gerekir.

```python
from torch.utils.data import Dataset
import torch

class SAMDataset(Dataset):
  def __init__(self, dataset, processor):
    self.dataset = dataset
    self.processor = processor

  def __len__(self):
    return len(self.dataset)

  def __getitem__(self, idx):
    item = self.dataset[idx]
    image = item["image"]
    prompt = eval(item["prompt"])["bbox"]
    inputs = self.processor(image, input_boxes=[[prompt]], return_tensors="pt")
    inputs["ground_truth_mask"] = (np.array(item["mask"]) > 0).astype(np.float32)
    inputs["original_image_size"] = torch.tensor(image.size[::-1])

    return inputs
```

İşleyiciyi ve veri setini onunla başlatabiliriz.

```python
from transformers import Sam2Processor

processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-small")
train_dataset = SAMDataset(dataset=train_ds, processor=processor)
``` 

Farklı boyutlardaki gerçeklik maskelerini aynı şekle sahip yeniden şekillendirilmiş maskelerden oluşan toplulara dönüştürecek bir veri toplayıcı (data collator) tanımlamamız gerekiyor. Bunları en yakın komşu interpolasyonu kullanarak yeniden şekillendiriyoruz. Topludaki diğer öğeler için de toplu tensörler oluşturuyoruz. Maskelerinizin hepsi aynı boyuttaysa bu adımı atlayabilirsiniz.

```python
import torch.nn.functional as F

def collate_fn(batch, target_hw=(256, 256)):

    pixel_values = torch.cat([item["pixel_values"] for item in batch], dim=0)
    original_sizes = torch.stack([item["original_sizes"] for item in batch])
    input_boxes = torch.cat([item["input_boxes"] for item in batch], dim=0)
    ground_truth_masks = torch.cat([
        F.interpolate(
            torch.as_tensor(x["ground_truth_mask"]).unsqueeze(0).unsqueeze(0).float(),
            size=(256, 256),
            mode="nearest"
        )
        for x in batch
    ], dim=0).long()

    return {
        "pixel_values": pixel_values,
        "original_sizes": original_sizes,
        "input_boxes": input_boxes,
        "ground_truth_mask": ground_truth_masks,
        "original_image_size": torch.stack([item["original_image_size"] for item in batch]),
    }

from torch.utils.data import DataLoader
train_dataloader = DataLoader(
    train_dataset,
    batch_size=4,
    shuffle=True,
    collate_fn=collate_fn,
)
```

Veri yükleyicisinin ne ürettiğine bir bakalım.

```python
batch = next(iter(train_dataloader))
for k,v in batch.items():
  print(k,v.shape)

# pixel_values torch.Size([4, 3, 1024, 1024])
# original_sizes torch.Size([4, 1, 2])
# input_boxes torch.Size([4, 1, 4])
# ground_truth_mask torch.Size([4, 1, 256, 256])
#original_image_size torch.Size([4, 2])
```

Şimdi modeli yükleyecek ve yalnızca mask decoder'ı eğitmek için vision ve prompt encoder'ı donduracağız.

```python
from transformers import Sam2Model

model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-small")

for name, param in model.named_parameters():
  if name.startswith("vision_encoder") or name.startswith("prompt_encoder"):
    param.requires_grad_(False)
``` 

Şimdi optimizatörü ve kayıp fonksiyonunu tanımlayabiliriz.
```python 
from torch.optim import Adam
import monai

optimizer = Adam(model.mask_decoder.parameters(), lr=1e-5, weight_decay=0)
seg_loss = monai.losses.DiceCELoss(sigmoid=True, squared_pred=True, reduction='mean')
```

Modelin eğitimden önceki performansına bakalım.

```python
import matplotlib.pyplot as plt

item = val_ds[1]
img = item["image"]
bbox = json.loads(item["prompt"])["bbox"]
inputs = processor(images=img, input_boxes=[[bbox]], return_tensors="pt").to(model.device)

with torch.no_grad():
  outputs = model(**inputs)

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
preds = masks.squeeze(0)
mask = (preds[0] > 0).cpu().numpy()

overlay = np.asarray(img, dtype=np.uint8).copy()
overlay[mask] = 0.55 * overlay[mask] + 0.45 * np.array([0, 255, 0], dtype=np.float32)

plt.imshow(overlay)
plt.axis("off")
plt.show()
```

![SAM2 result after training](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/sam2_before_training.png)

Eğitimin ortasında modelin gelişimini izleyebilmemiz için tahminlerimizi trackio'ya kaydetmemiz gerekiyor.

```python
from PIL import Image
import trackio
import json

@torch.no_grad()
def predict_fn(img, bbox):

  inputs = processor(images=img, input_boxes=[[bbox]], return_tensors="pt").to(model.device)

  with torch.no_grad():
      outputs = model(**inputs)

  masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
  return masks

def log_eval_masks_trackio(dataset, indices, step, predict_fn,  project=None, sample_cap=8):
    logs = {"eval/step": int(step)}
    for idx in indices[:sample_cap]:
        item = dataset[idx] 
        img = item["image"]
        bbox = json.loads(item["prompt"])["bbox"]
        preds = predict_fn(img, bbox)
        preds = preds.squeeze(0)
        mask = (preds[0] > 0).cpu().numpy()  

        overlay = np.asarray(img, dtype=np.uint8).copy()
        overlay[mask] = 0.55 * overlay[mask] + 0.45 * np.array([0, 255, 0], dtype=np.float32)
        logs[f"{idx}/overlay"] = trackio.Image(overlay, caption="overlay")
        
    trackio.log(logs)
```

Şimdi eğitim döngümüzü yazıp eğitebiliriz!

trackio ile kayıp ve değerlendirme maskelerimizi nasıl kaydettiğimize dikkat edin.

```python
from tqdm import tqdm
from statistics import mean
import trackio
import torch

num_epochs = 30

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
model.to(device)

model.train()
trackio.init(project="mask-eval")
for epoch in range(num_epochs):
    epoch_losses = []
    for batch in tqdm(train_dataloader):
      outputs = model(pixel_values=batch["pixel_values"].to(device),
                      input_boxes=batch["input_boxes"].to(device),
                      multimask_output=False)

      predicted_masks = outputs.pred_masks.squeeze(1)
      ground_truth_masks = batch["ground_truth_mask"].float().to(device)
      loss = seg_loss(predicted_masks, ground_truth_masks)

      optimizer.zero_grad()
      loss.backward()

      optimizer.step()
      epoch_losses.append(loss.item())
      
    log_eval_masks_trackio(dataset=val_ds, indices=[0, 3, 6, 9], step=epoch, predict_fn=predict_fn, project="mask-eval")
    print(f'Epoch: {epoch}')
    print(f'Mean loss: {mean(epoch_losses)}')
    trackio.log({"loss": mean(epoch_losses)})

trackio.finish()
```

Eğitilen modeli test edelim.

```python
import matplotlib.pyplot as plt

item = val_ds[1]
img = item["image"]
bbox = json.loads(item["prompt"])["bbox"]

inputs = processor(images=img, input_boxes=[[bbox]], return_tensors="pt").to(model.device)

with torch.no_grad():
  outputs = model(**inputs)

preds = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]

preds = preds.squeeze(0)
mask = (preds[0] > 0).cpu().numpy()

overlay = np.asarray(img, dtype=np.uint8).copy()
overlay[mask] = 0.55 * overlay[mask] + 0.45 * np.array([0, 255, 0], dtype=np.float32)

plt.imshow(overlay)
plt.axis("off")
plt.show()
```

Küçük bir veri setinde yalnızca 20 epoch boyunca eğitim yaptıktan sonra harika bir iyileşme!

![SAM2 result after training](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/sam2_after_training.png)

