# SAM3 Takipçi

    
        
        
    

## Genel Bakış

SAM3 (Segment Anything Model 3), [SAM 3: Segment Anything with Concepts](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/) makalesinde tanıtılmıştır.

Sam3Tracker, görüntüler üzerinde **Promptable Visual Segmentation (PVS)** gerçekleştirir. PVS, etkileşimli görsel istemleri (noktalar, kutular, maskeler) veya metin girdilerini kullanarak her istem için **belirli bir nesne örneğini** segmente eder. Bu, SAM 1 ve SAM 2'nin odaklandığı ve SAM 3'ün üzerinde iyileştirme yaptığı görevdir.

Sam3Tracker, SAM2'nin (Segment Anything Model 2) aynı API'yi koruyarak geliştirilmiş performans ve yetenekler sunan güncellenmiş bir sürümüdür.

Makalenin özeti aşağıdaki gibidir:

*Segment Anything Model (SAM) 3'ü sunuyoruz; bu, kısa isim tamlamaları (ör. "yellow school bus"), görüntü örnekleri veya her ikisinin birleşimi olarak tanımladığımız kavram istemlerine (concept prompts) dayanarak görüntülerde ve videolarda nesneleri algılayan, segmente eden ve izleyen birleşik bir modeldir. İstemlenebilir Kavram Segmentasyonu (PCS), bu tür istemleri alır ve eşleşen tüm nesne örnekleri için segmentasyon maskeleri ve benzersiz kimlikler döndürür. PCS'yi ilerletmek için, görüntüler ve videolar arasında zor negatifleri de içeren, 4M benzersiz kavram etiketine sahip yüksek kaliteli bir veri seti üreten ölçeklenebilir bir veri motoru geliştiriyoruz. Modelimiz, tek bir omurga (backbone) paylaşan görüntü düzeyinde bir algılayıcı ve bellek tabanlı bir video izleyicisinden oluşmaktadır. Tanıma ve konumlandırma, algılama doğruluğunu artıran bir varlık başlığı (presence head) ile ayrıştırılmıştır. SAM 3, hem görüntü hem de video PCS'de mevcut sistemlerin doğruluğunu ikiye katlar ve önceki SAM yeteneklerini görsel segmentasyon görevlerinde iyileştirir. İstemlenebilir kavram segmentasyonu için yeni Segment Anything with Concepts (SA-Co) benchmark'ımızla birlikte SAM 3'ü açık kaynak olarak yayımlıyoruz.*

Bu model [yonigozlan](https://huggingface.co/yonigozlan) ve [ronghanghu](https://huggingface.co/ronghanghu) tarafından katkıda bulunmuştur.

## Kullanım örneği

### Pipeline ile Otomatik Maske Oluşturma

Sam3Tracker, `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="facebook/sam3", 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 Sam3TrackerProcessor, Sam3TrackerModel
import torch
from PIL import Image
import requests

model = Sam3TrackerModel.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3TrackerProcessor.from_pretrained("facebook/sam3")

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, 1500, 2250])
```

#### İ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]
```

#### Sınır Kutusu Girdisi

Sam3Tracker, 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]
```

#### Ç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
```

### 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 Sam3TrackerProcessor, Sam3TrackerModel
import torch
from PIL import Image
import requests

model = Sam3TrackerModel.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3TrackerProcessor.from_pretrained("facebook/sam3")

# 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
```

#### 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
```

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

Sam3Tracker, 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,
    )
```

## Sam3TrackerConfig[[transformers.Sam3TrackerConfig]]

#### transformers.Sam3TrackerConfig[[transformers.Sam3TrackerConfig]]

```python
transformers.Sam3TrackerConfig(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/v5.23.0/src/transformers/models/sam3_tracker/configuration_sam3_tracker.py#L96)

**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`, `Sam3TrackerPromptEncoderConfig`], *opsiyonel*) : [Sam3TrackerPromptEncoderConfig](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerPromptEncoderConfig) sınıfını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

mask_decoder_config (Union[`dict`, `Sam3TrackerMaskDecoderConfig`], *opsiyonel*) : [Sam3TrackerMaskDecoderConfig](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerMaskDecoderConfig) 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 Sam3TrackerModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam3 Tracker modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam3](https://huggingface.co/facebook/sam3) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import (
...     Sam3TrackerVisionConfig,
...     Sam3TrackerPromptEncoderConfig,
...     Sam3TrackerMaskDecoderConfig,
...     Sam3TrackerModel,
... )

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

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

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

>>> # We can also initialize a Sam3TrackerConfig from a Sam3TrackerVisionConfig, Sam3TrackerPromptEncoderConfig, and Sam3TrackerMaskDecoderConfig
>>> # Initializing SAM3_TRACKER vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam3TrackerVisionConfig()
>>> prompt_encoder_config = Sam3TrackerPromptEncoderConfig()
>>> mask_decoder_config = Sam3TrackerMaskDecoderConfig()

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

## Sam3TrackerPromptEncoderConfig[[transformers.Sam3TrackerPromptEncoderConfig]]

#### transformers.Sam3TrackerPromptEncoderConfig[[transformers.Sam3TrackerPromptEncoderConfig]]

```python
transformers.Sam3TrackerPromptEncoderConfig(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] = 1008, patch_size: int | list[int] | tuple[int, int] = 14, 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/v5.23.0/src/transformers/models/sam3_tracker/configuration_sam3_tracker.py#L31)

**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 `1008`) : 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 `14`) : 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 Sam3TrackerModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam3 Tracker modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam3](https://huggingface.co/facebook/sam3) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## Sam3TrackerMaskDecoderConfig[[transformers.Sam3TrackerMaskDecoderConfig]]

#### transformers.Sam3TrackerMaskDecoderConfig[[transformers.Sam3TrackerMaskDecoderConfig]]

```python
transformers.Sam3TrackerMaskDecoderConfig(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/v5.23.0/src/transformers/models/sam3_tracker/configuration_sam3_tracker.py#L57)

**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 Sam3TrackerModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam3 Tracker modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam3](https://huggingface.co/facebook/sam3) ile benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## Sam3TrackerProcessor[[transformers.Sam3TrackerProcessor]]

#### transformers.Sam3TrackerProcessor[[transformers.Sam3TrackerProcessor]]

```python
transformers.Sam3TrackerProcessor(image_processor, target_size: int | None = None, point_pad_value: int = -10, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/processing_sam3_tracker.py#L36)

**Parametreler:**

image_processor (`Sam3ImageProcessor`) : Görüntü işleyici zorunlu bir girdidir.

target_size (`int`, *isteğe bağlı*) : Girdi noktalarını ve sınırlayıcı kutuları normalize etmek için hedef boyut (piksel cinsinden). Sağlanmazsa, varsayılan olarak görüntü işleyicisinin boyut yapılandırması kullanılır. Modelde kullanılmadan önce tüm girdi koordinatları (noktalar ve kutular) bu boyuta normalize edilir. Bu, orijinal görüntü boyutlarından bağımsız olarak tutarlı bir koordinat temsilini sağlar.

point_pad_value (`int`, *isteğe bağlı*, varsayılan -10) : Farklı uzunluklardaki dizilerin toplu işlenmesi sırasında giriş noktalarının dolgu (padding) işlemi için kullanılan değer. Bu değer, dolgulu konumları işaretlemek için kullanılır ve koordinat normalizasyonu sırasında korunur.

Bir görüntü işleyicisini tek bir işleyiciye sararak bir Sam3TrackerProcessor oluşturur.

[Sam3TrackerProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerProcessor), [Sam3ImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3#transformers.Sam3ImageProcessor)'ün tüm işlevlerini sunar. Daha fazla bilgi için [~Sam3ImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3#transformers.Sam3ImageProcessor) sayfasına bakın.

#### __call__[[transformers.Sam3TrackerProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, input_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/processing_sam3_tracker.py#L52)

**Parametreler:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *isteğe bağlı*) : Ön işleme tabi tutulacak görüntü. Piksel değerleri 0 ile 255 arasında değişen tek bir görüntü veya görüntü grubu beklenir. Piksel değerleri 0 ile 1 arasında olan görüntüler geçiriliyorsa `do_rescale=False` olarak ayarlayın.

segmentation_maps (`ImageInput`, *isteğe bağlı*) : İşlenecek segmentasyon haritaları.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *isteğe bağlı*) : Çerçeveye eklenecek noktalar.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *isteğe bağlı*) : Noktaların etiketleri.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *isteğe bağlı*) : Kareye eklenecek sınırlayıcı kutular.

original_sizes (`list[list[float]]`, `torch.Tensor`, *isteğe bağlı*) : Görsellerin orijinal boyutları.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *isteğe bağlı*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

**Dönüş:** Aşağıdaki alanlara sahip bir [BatchEncoding](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.BatchEncoding)

- `pixel_values` (`torch.Tensor`): İşlenmiş görüntü(ler).
- `original_sizes` (`list[list[float]]`): Görsellerin orijinal boyutları.
- `labels` (`torch.Tensor`): İşlenmiş segmentasyon haritaları (verildiyse).
- `input_points` (`torch.Tensor`): İşlenmiş noktalar.
- `input_labels` (`torch.Tensor`): İşlenmiş etiketler.
- `input_boxes` (`torch.Tensor`): İşlenmiş sınırlayıcı kutuları.

#### post_process_masks[[transformers.Sam3TrackerProcessor.post_process_masks]]

```python
post_process_masks(masks, original_sizes, mask_threshold = 0.0, binarize = True, max_hole_area = 0.0, max_sprinkle_area = 0.0, apply_non_overlapping_constraints = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/processing_sam3_tracker.py#L458)

**Parametreler:**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : mask_decoder'dan gelen, (batch_size, num_channels, height, width) biçiminde toplu maskeler.

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Modelin beklenen giriş şekline yeniden boyutlandırılmadan önce her bir görüntünün orijinal boyutları, (yükseklik, genişlik) biçiminde.

mask_threshold (`float`, *isteğe bağlı*, varsayılan 0.0) : Binarizasyon ve son işlemleme işlemleri için eşik değeri.

binarize (`bool`, *isteğe bağlı*, varsayılan `True`) : Maskelerin ikileştirilip ikileştirilmeyeceğini belirtir.

max_hole_area (`float`, *opsiyonel*, varsayılan 0.0) : Dolacak deliğin maksimum alanı.

max_sprinkle_area (`float`, *opsiyonel*, varsayılan 0.0) : Dolacak bir serpinin maksimum alanı.

apply_non_overlapping_constraints (`bool`, *isteğe bağlı*, varsayılan `False`) : Maskelere örtüşmeyen kısıtlamaların uygulanıp uygulanmayacağı.

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

Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size.

Dolgu (padding) kaldırılır ve maskeler orijinal görüntü boyutuna ölçeklenir.

## Sam3TrackerModel[[transformers.Sam3TrackerModel]]

#### transformers.Sam3TrackerModel[[transformers.Sam3TrackerModel]]

```python
transformers.Sam3TrackerModel(config: Sam3TrackerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/modeling_sam3_tracker.py#L772)

**Parametreler:**

config ([Sam3TrackerConfig](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerConfig)) : 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/v5.23.0/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/v5.23.0/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.Sam3TrackerModel.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/v5.23.0/src/transformers/models/sam3_tracker/modeling_sam3_tracker.py#L886)

**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 [Sam3ImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3#transformers.Sam3ImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [Sam3ImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın ([Sam3TrackerProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerProcessor), görüntü işleme için [Sam3ImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/sam3#transformers.Sam3ImageProcessor) 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üş:** `Sam3TrackerImageSegmentationOutput` veya `tuple(torch.Tensor)`

`Sam3TrackerImageSegmentationOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); yapılandırma ([Sam3TrackerConfig](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Sam3TrackerModel](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerModel) 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/sam3_tracker.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/sam3_tracker.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.Sam3TrackerModel.get_image_features]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/modeling_sam3_tracker.py#L1064)

**Parametreler:**

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

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

`Sam3TrackerVisionEncoderOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([Sam3TrackerConfig](/docs/transformers/v5.23.0/tr/model_doc/sam3_tracker#transformers.Sam3TrackerConfig)) 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
```

## Sam3TrackerPreTrainedModel[[transformers.Sam3TrackerPreTrainedModel]]

#### transformers.Sam3TrackerPreTrainedModel[[transformers.Sam3TrackerPreTrainedModel]]

```python
transformers.Sam3TrackerPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker/modeling_sam3_tracker.py#L117)

**Parametreler:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig)) : 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/v5.23.0/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 3 (SAM 3).

#### forward[[transformers.Sam3TrackerPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerleştirilir (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir metasınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

