# EdgeTAM

## Genel Bakış

EdgeTAM modeli, [EdgeTAM: On-Device Track Anything Model](https://huggingface.co/papers/2501.07256) adlı makalede Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra ve Bilge Soran tarafından önerilmiştir.

EdgeTAM, mobil cihazlarda gerçek zamanlı video segmentasyonu için bellek dikkat mekanizmalarını optimize etmek amacıyla 2B Uzamsal Perceiver mimarisi tanıtan SAM 2'nin verimli bir uyarlamasıdır.

Makalenin özeti aşağıdaki gibidir:

*Segment Anything Model (SAM) üzerine kurulu SAM 2, bir hafıza bankası mekanizması aracılığıyla yetkinliğini görüntüden video girdilerine doğru daha da genişletir ve önceki yöntemlere kıyasla olağanüstü bir performans elde ederek video segmentasyon görevi için bir temel model haline gelir. Bu makalede, SAM 2'yi çok daha verimli hale getirerek, karşılaştırılabilir bir performansı korurken mobil cihazlarda bile çalışmasını sağlamayı hedefliyoruz. SAM'ın verimliliğini artırmak için optimize eden birkaç çalışma olmasına rağmen, bunların SAM 2 için yeterli olmadığını tespit ettik; çünkü tümü görüntü kodlayıcısını sıkıştırmaya odaklanırken, benchmark'ımız yeni tanıtılan hafıza dikkat bloklarının da gecikme darboğazı olduğunu gösteriyor. Bu gözlem ışığında, hesaplama maliyetini azaltmak için yeni bir 2D Mekânsal Perceiver'dan yararlanan EdgeTAM'ı öneriyoruz. Özellikle, önerilen 2D Mekânsal Perceiver, yoğun olarak saklanan kare düzeyindeki hafızaları, sabit bir öğrenilebilir sorgu kümesi içeren hafif bir Transformer ile kodlar. Video segmentasyonunun yoğun bir tahmin görevi olması nedeniyle, sorguların küresel düzeyde ve yama (patch) düzeyinde gruplara ayrılması gerektiğinden, hafızaların mekânsal yapısının korunmasının hayati önem taşıdığını tespit ettik. Ayrıca, çıkarım (inference) maliyeti olmadan performansı daha da artıran bir damıtma (distillation) hattı öneriyoruz. Sonuç olarak EdgeTAM, DAVIS 2017, MOSE, SA-V val ve SA-V test setlerinde sırasıyla 87,7, 70,0, 72,3 ve 71,7 J&F değerlerine ulaşırken, iPhone 15 Pro Max üzerinde 16 FPS hızında çalışmaktadır.*

Bu model [yonigozlan](https://huggingface.co/yonigozlan) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/facebookresearch/EdgeTAM) bulunabilir.

## Kullanım örneği

### Pipeline ile Otomatik Maske Oluşturma

EdgeTAM, `mask-generation` hattı kullanılarak bir görüntüdeki tüm nesneleri segmente etmek için otomatik maske üretimi amacıyla kullanılabilir:

```python
from transformers import pipeline

generator = pipeline("mask-generation", model="yonigozlan/edgetam-1", device=0)
image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
outputs = generator(image_url, points_per_batch=64)

len(outputs["masks"])  # Number of masks generated
39
```

### Temel Görüntü Segmentasyonu

#### Tek Nokta Tıklama

Nesneleri segmentlemek istediğiniz nesne üzerinde tek bir tıklama yaparak nesneleri segmentleyebilirsiniz:

```python
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests

model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")

image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
raw_image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

input_points = [[[[500, 375]]]]  # Single point click, 4 dimensions (image_dim, object_dim, point_per_object_dim, coordinates)
input_labels = [[[1]]]  # 1 for positive click, 0 for negative click, 3 dimensions (image_dim, object_dim, point_label)

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, 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]

# The model outputs multiple mask predictions ranked by quality score
print(f"Generated {masks.shape[1]} masks with shape {masks.shape}")
Generated 3 masks with shape torch.Size([1, 3, 1200, 1800])
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.0463, 0.4859, 0.7616], device='cuda:0')
```

#### İnce Ayar İçin Birden Fazla Nokta

Segmentasyonu iyileştirmek için birden çok nokta sağlayabilirsiniz:

```python
# Add both positive and negative points to refine the mask
input_points = [[[[500, 375], [1125, 625]]]]  # Multiple points for refinement
input_labels = [[[1, 1]]]  # Both positive clicks

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, 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]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.8362, 0.6900, 0.2120], device='cuda:0')
```

#### Sınır Kutusu Girdisi

EdgeTAM, segmentasyon için sınırlayıcı kutu girdilerini de destekler:

```python
# Define bounding box as [x_min, y_min, x_max, y_max]
input_boxes = [[[75, 275, 1725, 850]]]

inputs = processor(images=raw_image, input_boxes=input_boxes, 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]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605], device='cuda:0')
```

#### Çoklu Nesne Segmentasyonu

Birden fazla nesneyi aynı anda segmente edebilirsiniz:

```python
# Define points for two different objects
input_points = [[[[500, 375]], [[650, 750]]]]  # Points for two objects in same image
input_labels = [[[1], [1]]]  # Positive clicks for both objects

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

# Each object gets its own mask
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"Generated masks for {masks.shape[0]} objects")
Generated masks for 2 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7616, 0.9465], device='cuda:0')
```

### Toplu Çıkarım

#### Toplu Görseller

Daha iyi verimlilik için birden fazla görüntüyü eş zamanlı olarak işleyin:

```python
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests

model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")

# Load multiple images
image_urls = [
    "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg",
    "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dog_sam.png"
]
raw_images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]

# Single point per image
input_points = [[[[500, 375]]], [[[770, 200]]]]  # One point for each image
input_labels = [[[1]], [[1]]]  # Positive clicks for both images

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

# Post-process masks for each image
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(all_masks)} images, each with {all_masks[0].shape[0]} objects")
Processed 2 images, each with 1 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7618, 0.7999], device='cuda:0')
```

#### Görüntü Başına Toplu Nesneler

Her görüntüdeki birden fazla nesneyi toplu çıkarım (batch inference) kullanarak segmente edin:

```python
# Multiple objects per image - different numbers of objects per image
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects
    [[[770, 200]]]  # Dog image: 1 object
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks for both objects
    [[1]]  # Dog image: positive click for the object
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
```

#### Toplu Görseller, Toplu Nesneler ve Çoklu Noktalar

Nesne başına çoklu nokta içeren karmaşık parti senaryolarını yönetin:

```python
# Add groceries image for more complex example
groceries_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/groceries.jpg"
groceries_image = Image.open(requests.get(groceries_url, stream=True).raw).convert("RGB")
raw_images = [raw_images[0], groceries_image]  # Use truck and groceries images

# Complex batching: multiple images, multiple objects, multiple points per object
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects with 1 point each
    [[[400, 300]], [[630, 300], [550, 300]]]  # Groceries image: obj1 has 1 point, obj2 has 2 points
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks
    [[1], [1, 1]]  # Groceries image: positive clicks for refinement
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
```

#### Toplu Sınır Kutuları

Sınır kutusu girdileriyle birden fazla görüntü işleyin:

```python
# Multiple bounding boxes per image (using truck and groceries images)
input_boxes = [
    [[75, 275, 1725, 850], [425, 600, 700, 875], [1375, 550, 1650, 800], [1240, 675, 1400, 750]],  # Truck image: 4 boxes
    [[450, 170, 520, 350], [350, 190, 450, 350], [500, 170, 580, 350], [580, 170, 640, 350]]  # Groceries image: 4 boxes
]

# Update images for this example
raw_images = [raw_images[0], groceries_image]  # truck and groceries

inputs = processor(images=raw_images, input_boxes=input_boxes, return_tensors="pt").to(model.device)

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

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(input_boxes)} images with {len(input_boxes[0])} and {len(input_boxes[1])} boxes respectively")
Processed 2 images with 4 and 4 boxes respectively
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605, 0.9465], device='cuda:0')
```

### Giriş Olarak Önceki Maskelerin Kullanılması

EdgeTAM, segmentasyonu iyileştirmek için önceki tahminlerden gelen maskeleri girdi olarak kullanabilir:

```python
# Get initial segmentation
input_points = [[[[500, 375]]]]
input_labels = [[[1]]]
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

# Use the best mask as input for refinement
mask_input = outputs.pred_masks[:, :, torch.argmax(outputs.iou_scores.squeeze())]

# Add additional points with the mask input
new_input_points = [[[[500, 375], [450, 300]]]]
new_input_labels = [[[1, 1]]]
inputs = processor(
    input_points=new_input_points,
    input_labels=new_input_labels,
    original_sizes=inputs["original_sizes"],
    return_tensors="pt",
).to(model.device)

with torch.no_grad():
    refined_outputs = model(
        **inputs,
        input_masks=mask_input,
        image_embeddings=outputs.image_embeddings,
        multimask_output=False,
    )
```

## EdgeTamConfig[[transformers.EdgeTamConfig]]

#### transformers.EdgeTamConfig[[transformers.EdgeTamConfig]]

```python
transformers.EdgeTamConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L152)

**Parametreler:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Görüntü iskeletinin yapılandırma nesnesi veya sözlüğü.

prompt_encoder_config (Union[`dict`, `EdgeTamPromptEncoderConfig`], *opsiyonel*) : [EdgeTamPromptEncoderConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamPromptEncoderConfig) sınıfını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

mask_decoder_config (Union[`dict`, `EdgeTamMaskDecoderConfig`], *opsiyonel*) : [EdgeTamMaskDecoderConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig) sınıfını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

Bu, bir EdgeTamModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) modelinin yapılandırmasına benzer bir yapılandırma elde etmenizi sağlar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import (
...     EdgeTamVisionConfig,
...     EdgeTamPromptEncoderConfig,
...     EdgeTamMaskDecoderConfig,
...     EdgeTamModel,
... )

>>> # Initializing a EdgeTamConfig with `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> configuration = EdgeTamConfig()

>>> # Initializing a EdgeTamModel (with random weights) from the `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> model = EdgeTamModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig
>>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations
>>> vision_config = EdgeTamVisionConfig()
>>> prompt_encoder_config = EdgeTamPromptEncoderConfig()
>>> mask_decoder_config = EdgeTamMaskDecoderConfig()

>>> config = EdgeTamConfig(vision_config, prompt_encoder_config, mask_decoder_config)
```

## EdgeTamVisionConfig[[transformers.EdgeTamVisionConfig]]

#### transformers.EdgeTamVisionConfig[[transformers.EdgeTamVisionConfig]]

```python
transformers.EdgeTamVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, backbone_channel_list: list[int] | None = None, backbone_feature_sizes: list | None = None, fpn_hidden_size: int = 256, fpn_kernel_size: int = 1, fpn_stride: int = 1, fpn_padding: int = 0, fpn_top_down_levels: list[int] | None = None, num_feature_levels: int = 3, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L29)

**Parametreler:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Omurga modelinin yapılandırması.

backbone_channel_list (`List[int]`, *isteğe bağlı*, varsayılan `[384, 192, 96, 48]`) : Omurga (backbone) için kanal boyutlarının listesi.

backbone_feature_sizes (`List[List[int]]`, *isteğe bağlı*, varsayılan `[[256, 256], [128, 128], [64, 64]]`) : Backbone'dan gelen özellik haritalarının uzamsal boyutları.

fpn_hidden_size (`int`, *isteğe bağlı*, varsayılan 256) : FPN'nin gizli boyutu.

fpn_kernel_size (`int`, *opsiyonel*, varsayılan 1) : Boyundaki konvolüsyonlar için çekirdek boyutu.

fpn_stride (`int`, *isteğe bağlı*, varsayılan 1) : Boyundaki konvolüsyonlar için adım (stride).

fpn_padding (`int`, *isteğe bağlı*, varsayılan 0) : Boyundaki konvolüsyonlar için dolgu.

fpn_top_down_levels (`List[int]`, *isteğe bağlı*, varsayılan `[2, 3]`) : Yukarıdan aşağıya FPN bağlantıları için seviyeler.

num_feature_levels (`int`, *isteğe bağlı*, varsayılan 3) : Kullanılacak FPN özellik seviyesi sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : Katman normalizasyonu katmanlarında kullanılan epsilon.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

Bu, bir EdgeTamModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) modelinin yapılandırmasına benzer bir yapılandırma elde etmenizi sağlar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## EdgeTamMaskDecoderConfig[[transformers.EdgeTamMaskDecoderConfig]]

#### transformers.EdgeTamMaskDecoderConfig[[transformers.EdgeTamMaskDecoderConfig]]

```python
transformers.EdgeTamMaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, hidden_act: str = 'gelu', mlp_dim: int = 2048, num_hidden_layers: int = 2, num_attention_heads: int = 8, attention_downsample_rate: int = 2, num_multimask_outputs: int = 3, iou_head_depth: int = 3, iou_head_hidden_dim: int = 256, dynamic_multimask_via_stability: bool = True, dynamic_multimask_stability_delta: float = 0.05, dynamic_multimask_stability_thresh: float = 0.98)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L113)

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `256`) : Gizli temsillerin boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

mlp_dim (`int`, *isteğe bağlı*, varsayılan 2048) : İki yönlü dönüştürücüdeki MLP'nin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `2`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

attention_downsample_rate (`int`, *isteğe bağlı*, varsayılan 2) : Dikkat katmanları için alt örneklem oranı.

num_multimask_outputs (`int`, *isteğe bağlı*, varsayılan 3) : Çoklu maske çıktılarının sayısı.

iou_head_depth (`int`, *isteğe bağlı*, varsayılan 3) : IoU başlığının derinliği.

iou_head_hidden_dim (`int`, *opsiyonel*, varsayılan 256) : IoU başlığının gizli boyutu.

dynamic_multimask_via_stability (`bool`, *isteğe bağlı*, varsayılan `True`) : Stabilite yoluyla dinamik çoklu maske kullanılıp kullanılmayacağı.

dynamic_multimask_stability_delta (`float`, *isteğe bağlı*, varsayılan 0.05) : Dinamik çoklu maske için kararlılık deltayı.

dynamic_multimask_stability_thresh (`float`, *isteğe bağlı*, varsayılan 0.98) : Dinamik çoklu maske için kararlılık eşiği.

Bu, bir EdgeTamModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) modelinin yapılandırmasına benzer bir yapılandırma elde etmenizi sağlar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## EdgeTamPromptEncoderConfig[[transformers.EdgeTamPromptEncoderConfig]]

#### transformers.EdgeTamPromptEncoderConfig[[transformers.EdgeTamPromptEncoderConfig]]

```python
transformers.EdgeTamPromptEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, mask_input_channels: int = 16, num_point_embeddings: int = 4, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, scale: int = 1)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L88)

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `256`) : Gizli temsillerin boyutu.

image_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `1024`) : Her bir görüntünün boyutu (çözünürlüğü).

patch_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `16`) : Her yamanın boyutu (çözünürlüğü).

mask_input_channels (`int`, *isteğe bağlı*, varsayılan 16) : `MaskDecoder` modülüne verilecek kanal sayısı.

num_point_embeddings (`int`, *isteğe bağlı*, varsayılan 4) : Kullanılacak nokta gömme sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : Katman normalizasyonu katmanlarında kullanılan epsilon.

scale (`float`, *isteğe bağlı*, varsayılan 1) : Prompt kodlayıcısı için ölçekleme faktörü.

Bu, bir EdgeTamModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) modelinin yapılandırmasına benzer bir yapılandırma elde etmenizi sağlar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## EdgeTamVisionModel[[transformers.EdgeTamVisionModel]]

#### transformers.EdgeTamVisionModel[[transformers.EdgeTamVisionModel]]

```python
transformers.EdgeTamVisionModel(config: EdgeTamVisionConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L452)

**Parametreler:**

config ([EdgeTamVisionConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamVisionConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir başlık veya projeksiyon olmadan EdgeTAM'nin görme modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.EdgeTamVisionModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L470)

## EdgeTamModel[[transformers.EdgeTamModel]]

#### transformers.EdgeTamModel[[transformers.EdgeTamModel]]

```python
transformers.EdgeTamModel(config: EdgeTamConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L945)

**Parametreler:**

config ([EdgeTamConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Girdi olarak bir görüntü ile girdi noktaları ve etiketleri, kutuları veya maskeleri verildiğinde segmentasyon maskeleri üretmek için Segment Anything Model 2 (SAM 2).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.EdgeTamModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, input_points: typing.Optional[torch.Tensor] = None, input_labels: typing.Optional[torch.LongTensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_masks: typing.Optional[torch.LongTensor] = None, image_embeddings: typing.Optional[torch.Tensor] = None, multimask_output: bool = True, attention_similarity: typing.Optional[torch.Tensor] = None, target_embedding: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L1051)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [Sam2ImageProcessor](/docs/transformers/main/tr/model_doc/sam2#transformers.Sam2ImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [Sam2ImageProcessor.__call__()](/docs/transformers/main/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([Sam2Processor](/docs/transformers/main/tr/model_doc/sam2#transformers.Sam2Processor), görüntü işleme için [Sam2ImageProcessor](/docs/transformers/main/tr/model_doc/sam2#transformers.Sam2ImageProcessor) kullanır).

input_points (`torch.Tensor`, şekli `(batch_size, num_points, 2)`) : Girdi 2B uzamsal noktalar, bu, prompt kodlayıcısının (prompt encoder) prompt'u kodlamak için kullanır. Genel olarak çok daha iyi sonuçlar verir. Noktalar, işlemciye (processor) liste içi liste içi liste geçirilerek elde edilebilir; işlemci, 4 boyutlu karşılık gelen `torch` tensörlerini oluşturur. İlk boyut, görüntü parti boyutudur (image batch size); ikinci boyut, nokta parti boyutudur (yani girdi noktası başına modelden kaç segmentasyon maskesi tahmin etmesini istiyoruz); üçüncü boyut, segmentasyon maskesi başına nokta sayısıdır (tek bir maske için birden fazla nokta geçirmek mümkündür) ve son boyut, noktanın x (dikey) ve y (yatay) koordinatlarıdır. Her görüntü için veya her maske için farklı sayıda nokta geçirilirse, işlemci (0, 0) koordinatına karşılık gelen "PAD" noktaları oluşturur ve etiketler kullanılarak bu noktalar için gömme (embedding) hesabı atlanır.

input_labels (`torch.LongTensor`, şekli `(batch_size, point_batch_size, num_points)`) : Noktalar için giriş etiketleri, bu, prompt kodlayıcısının (prompt encoder) prompt'u kodlamasında kullanılır. Resmi uygulamanın belirttiğine göre 3 tür etiket vardır - `1`: nokta, ilgi nesnesini içeren bir noktadır - `0`: nokta, ilgi nesnesini içermeyen bir noktadır - `-1`: nokta, arka plana karşılık gelir  Eklediğimiz etiket:  - `-10`: nokta, dolgu (padding) noktasıdır, bu nedenle prompt kodlayıcısı tarafından yok sayılmalıdır  Dolgu etiketleri, işlemci (processor) tarafından otomatik olarak yapılmalıdır.

input_boxes (`torch.Tensor`, şekli `(batch_size, num_boxes, 4)`) : Noktalar için giriş kutuları, bu, prompt kodlayıcısının prompt'u kodlaması için kullanılır. Genel olarak çok daha iyi üretilen maskeler sağlar. Kutular, işlemciye (processor) liste içi liste içi liste geçirilerek elde edilebilir; bu işlem, her boyutun sırasıyla görüntü parti boyutuna, görüntü başına kutu sayısına ve kutunun sol üst ile sağ alt noktasının koordinatlarına karşılık geldiği bir `torch` tensörü oluşturur. Sıralama (`x1`, `y1`, `x2`, `y2`):  - `x1`: giriş kutusunun sol üst noktasının x koordinatı - `y1`: giriş kutusunun sol üst noktasının y koordinatı - `x2`: giriş kutusunun sağ alt noktasının x koordinatı - `y2`: giriş kutusunun sağ alt noktasının y koordinatı

input_masks (`torch.Tensor`, şekli `(batch_size, image_size, image_size)`) : SAM modeli ayrıca segmentasyon maskelerini de girdi olarak kabul eder. Maske, prompt encoder tarafından gömülecek (embed) ve daha sonra mask decoder'a beslenecek olan karşılık gelen bir gömme (embedding) üretecektir. Bu maskelerin kullanıcı tarafından manuel olarak sağlanması gerekir ve şekilleri (`batch_size`, `image_size`, `image_size`) olmalıdır.

image_embeddings (`torch.Tensor`, şekli `(batch_size, output_channels, window_size, window_size)`) : Görsel gömlemeleri (embeddings), bunlar mask çözücü tarafından maskeler ve iou skorları üretmek için kullanılır. Daha bellek verimli hesaplama için kullanıcılar, `pixel_values` yerine önce `get_image_embeddings` yöntemini kullanarak görsel gömlemelerini alabilir ve ardından bunları `forward` yöntemine iletebilir.

multimask_output (`bool`, *isteğe bağlı*) : Orijinal uygulama ve makalede, model her zaman görüntü başına 3 maske (ilgili durumlarda nokta başına / sınırlayıcı kutu başına) üretir. Ancak, `multimask_output=False` parametresini belirleyerek yalnızca "en iyi" maskeye karşılık gelen tek bir maske üretmek mümkündür.

attention_similarity (`torch.Tensor`, *isteğe bağlı*) : [PerSAM](https://huggingface.co/papers/2305.03048)'de tanıtıldığı gibi model kişiselleştirme için kullanıldığında, hedefe yönelik dikkat için mask kodlayıcıya sağlanacak dikkat benzerlik tensörü.

target_embedding (`torch.Tensor`, *isteğe bağlı*) : Model, [PerSAM](https://huggingface.co/papers/2305.03048)'de tanıtıldığı gibi kişiselleştirme için kullanılıyorsa, hedef-antikavram istemciliği için mask çözücüye sağlanacak hedef kavram gömümü.

**Dönüş:** `EdgeTamImageSegmentationOutput` veya `tuple(torch.Tensor)`

`EdgeTamImageSegmentationOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([EdgeTamConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[EdgeTamModel](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **iou_scores** (`torch.Tensor`, şekli `(batch_size, point_batch_size, num_masks)`) -- Tahmin edilen maskelerin Intersection over Union (IoU) puanları.
- **pred_masks** (`torch.Tensor`, şekli `(batch_size, point_batch_size, num_masks, height, width)`) -- Tahmin edilen düşük çözünürlüklü maskeler. Bu, `low_res_masks`'in bir takma adıdır. Bu maskelerin orijinal görüntü boyutuna getirilebilmesi için işlemci tarafından son işlem görmesi gerekir.
- **object_score_logits** (`torch.Tensor`, şekli `(batch_size, point_batch_size, 1)`) -- Bir nesnenin var olup olmadığını gösteren nesne puanı logitleri.
- **image_embeddings** (`tuple(torch.Tensor)`) -- Mask decoder tarafından kullanılan FPN özellikleri. Bu, her tensörün `(batch_size, channels, height, width)` şekline sahip olduğu `torch.Tensor` içeren bir tuple'dır.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` olduğunda döndürülür) -- Her aşamanın çıktısı için bir adet içeren, `(batch_size, height, width, hidden_size)` biçiminde `torch.Tensor` içeren bir tuple. Görüntü modelinin her aşamanın çıktısındaki gizli durumları.
- **vision_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Görüntü modelinin dikkat ağırlıkları.
- **mask_decoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Mask decoder'ın dikkat ağırlıkları.

Örnek:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor

>>> model = AutoModel.from_pretrained("danelcsb/edgetam.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/edgetam.1_hiera_tiny")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     raw_image = Image.open(BytesIO(response.read())).convert("RGB")
>>> input_points = [[[400, 650]]]  # 2D location of a window on the car
>>> inputs = processor(images=raw_image, input_points=input_points, return_tensors="pt")

>>> # Get segmentation mask
>>> outputs = model(**inputs)

>>> # Postprocess masks
>>> masks = processor.post_process_masks(
...     outputs.pred_masks, inputs["original_sizes"]
... )
```

#### get_image_features[[transformers.EdgeTamModel.get_image_features]]

```python
get_image_features(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L1229)

**Parametreler:**

pixel_values (`torch.Tensor`) : `(batch_size, num_channels, height, width)` biçiminde girdi piksel değerleri.

**Dönüş:** `EdgeTamVisionEncoderOutput` veya `tuple(torch.Tensor)`

`EdgeTamVisionEncoderOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([EdgeTamConfig](/docs/transformers/main/tr/model_doc/edgetam#transformers.EdgeTamConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, height, width, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- `torch.Tensor` (her bir özellik seviyesi için bir tane, yüksekten düşük çözünürlüğe doğru) içeren bir tuple, şekli `(batch_size, hidden_size, height, width)`. Feature Pyramid Network boyunundan gelen özellik haritaları.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- `torch.Tensor` (her bir özellik seviyesi için bir tane, yüksekten düşük çözünürlüğe doğru) içeren bir tuple, şekli `(batch_size, hidden_size, height, width)`. `fpn_hidden_states` ile eşleşen konumsal kodlamalar.

Örnek:

```python
```