# SAM2

    
        
        
    

## Genel Bakış

SAM2 (Segment Anything Model 2), Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár ve Christoph Feichtenhofer tarafından [Segment Anything in Images and Videos](https://ai.meta.com/research/publications/sam-2-segment-anything-in-images-and-videos/) makalesinde önerilmiştir.

Model, girdi olarak bir görüntü veya video ile girdi noktaları veya sınırlayıcı kutular verildiğinde, ilgi duyulan herhangi bir nesnenin segmentasyon maskelerini tahmin etmek için kullanılabilir.

![example image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam2_header.gif)

Makalenin özeti aşağıdaki gibidir:

*Segment Anything Model 2 (SAM 2)'yi sunuyoruz; bu, görüntülerde ve videolarda istemlenebilir görsel segmentasyonu çözmeye yönelik bir temel modeldir. Kullanıcı etkileşimi yoluyla model ve veriyi iyileştiren bir veri motoru geliştirerek, bugüne kadar toplanan en büyük video segmentasyon veri setini derledik. Modelimiz, gerçek zamanlı video işleme için akış belleğine sahip basit bir transformer mimarisidir. Verilerimiz üzerinde eğitilen SAM 2, geniş bir görev yelpazesinde güçlü performans sağlar. Video segmentasyonunda, önceki yaklaşımlara kıyasla 3 kat daha az etkileşimle daha yüksek doğruluk gözlemliyoruz. Görüntü segmentasyonunda ise modelimiz, Segment Anything Model (SAM)'den daha doğru ve 6 kat daha hızlıdır. Verilerimizin, modelimizin ve içgörülerimizin, video segmentasyonu ve ilgili algılama görevleri için önemli bir kilometre taşı olacağına inanıyoruz. Modelimizin bir sürümünü, veri setini ve etkileşimli bir demo'yu yayınlıyoruz.*

İpuçları:

- Batch & Video Desteği: SAM2, yerel olarak batch işleme ve sorunsuz video segmentasyonunu desteklerken, orijinal SAM statik görüntüler ve daha basit, tek seferde tek görüntü işleme akışları için tasarlanmıştır.
- Doğruluk ve Genelgeçerlik: SAM2, orijinal SAM'a kıyasla özellikle karma prompt'larla birlikte segmentasyon kalitesinde, sağlamlıkta ve yeni alanlara sıfır atış genelgeçerliğinde iyileşme göstermektedir.

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

## Kullanım örneği

### Pipeline ile Otomatik Maske Oluşturma

SAM2, `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/sam2.1-hiera-large", 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, Sam2Model
import torch
from PIL import Image
import requests

model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")

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

SAM2 ayrıca 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 Sam2Processor, Sam2Model
import torch
from PIL import Image
import requests

model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")

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

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

## Sam2Config[[transformers.Sam2Config]]

#### transformers.Sam2Config[[transformers.Sam2Config]]

```python
transformers.Sam2Config(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/sam2/configuration_sam2.py#L220)

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

mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *opsiyonel*) : [Sam2MaskDecoderConfig](/docs/transformers/v5.23.0/tr/model_doc/sam2#transformers.Sam2MaskDecoderConfig) 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 Sam2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny) modelinin yapılandırmasına 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 (
...     Sam2VisionConfig,
...     Sam2PromptEncoderConfig,
...     Sam2MaskDecoderConfig,
...     Sam2Model,
... )

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

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

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

>>> # We can also initialize a Sam2Config from a Sam2VisionConfig, Sam2PromptEncoderConfig, and Sam2MaskDecoderConfig

>>> # Initializing SAM2 vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam2VisionConfig()
>>> prompt_encoder_config = Sam2PromptEncoderConfig()
>>> mask_decoder_config = Sam2MaskDecoderConfig()

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

## Sam2HieraDetConfig[[transformers.Sam2HieraDetConfig]]

#### transformers.Sam2HieraDetConfig[[transformers.Sam2HieraDetConfig]]

```python
transformers.Sam2HieraDetConfig(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 = 96, num_attention_heads: int = 1, num_channels: int = 3, image_size: int | list[int] | None = None, patch_kernel_size: int | list[int] | None = None, patch_stride: int | list[int] | None = None, patch_padding: int | list[int] | None = None, query_stride: int | list[int] | None = None, window_positional_embedding_background_size: list[int] | None = None, num_query_pool_stages: int = 3, blocks_per_stage: list[int] | None = None, embed_dim_per_stage: list[int] | None = None, num_attention_heads_per_stage: list[int] | None = None, window_size_per_stage: list[int] | None = None, global_attention_blocks: list[int] | None = None, mlp_ratio: float = 4.0, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L25)

**Parametreler:**

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

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

num_channels (`int`, *opsiyonel*, varsayılan `3`) : Girdi kanal sayısı.

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

patch_kernel_size (`list[int]`, *isteğe bağlı*, varsayılan `[7, 7]`) : Yamanın çekirdek boyutu.

patch_stride (`list[int]`, *isteğe bağlı*, varsayılan `[4, 4]`) : Yamanın (patch) adım aralığı (stride).

patch_padding (`list[int]`, *isteğe bağlı*, varsayılan `[3, 3]`) : Yamanlamanın dolgusu.

query_stride (`list[int]`, *isteğe bağlı*, varsayılan `[2, 2]`) : Aşamalar arasındaki örnekleme azaltma adımı.

window_positional_embedding_background_size (`list[int]`, *isteğe bağlı*, varsayılan `[7, 7]`) : Küresel dikkat kullanılmadığında aşama başına pencere boyutu.

num_query_pool_stages (`int`, *isteğe bağlı*, varsayılan 3) : Sorgu havuzlama aşamalarının sayısı.

blocks_per_stage (`list[int]`, *isteğe bağlı*, varsayılan `[1, 2, 7, 2]`) : Aşama başına blok sayısı.

embed_dim_per_stage (`list[int]`, *isteğe bağlı*, varsayılan `[96, 192, 384, 768]`) : Aşama başına gömme boyutu.

num_attention_heads_per_stage (`list[int]`, *isteğe bağlı*, varsayılan `[1, 2, 4, 8]`) : Aşama başına dikkat başı sayısı.

window_size_per_stage (`list[int]`, *isteğe bağlı*, varsayılan `[8, 4, 14, 7]`) : Aşama başına pencere boyutu.

global_attention_blocks (`list[int]`, *isteğe bağlı*, varsayılan `[5, 7, 9]`) : Küresel dikkatin kullanıldığı bloklar.

mlp_ratio (`float`, *isteğe bağlı*, varsayılan `4.0`) : MLP gizli boyutunun gömme boyutuna oranı.

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 Sam2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny) modelinin yapılandırmasına 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.

## Sam2VisionConfig[[transformers.Sam2VisionConfig]]

#### transformers.Sam2VisionConfig[[transformers.Sam2VisionConfig]]

```python
transformers.Sam2VisionConfig(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/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L103)

**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 `[768, 384, 192, 96]`) : 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 Sam2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny) modelinin yapılandırmasına 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.

## Sam2MaskDecoderConfig[[transformers.Sam2MaskDecoderConfig]]

#### transformers.Sam2MaskDecoderConfig[[transformers.Sam2MaskDecoderConfig]]

```python
transformers.Sam2MaskDecoderConfig(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/sam2/configuration_sam2.py#L181)

**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 Sam2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny) modelinin yapılandırmasına 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.

## Sam2PromptEncoderConfig[[transformers.Sam2PromptEncoderConfig]]

#### transformers.Sam2PromptEncoderConfig[[transformers.Sam2PromptEncoderConfig]]

```python
transformers.Sam2PromptEncoderConfig(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/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L156)

**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 Sam2Model yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam2 modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny) modelinin yapılandırmasına 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.

## Sam2Processor[[transformers.Sam2Processor]]

#### transformers.Sam2Processor[[transformers.Sam2Processor]]

```python
transformers.Sam2Processor(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/sam2/processing_sam2.py#L37)

**Parametreler:**

image_processor (`Sam2ImageProcessor`) : 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 Sam2Processor oluşturur.

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

#### __call__[[transformers.Sam2Processor.__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/sam2/processing_sam2.py#L53)

**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.Sam2Processor.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/sam2/processing_sam2.py#L459)

**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.

## Sam2ImageProcessor[[transformers.Sam2ImageProcessor]]

#### transformers.Sam2ImageProcessor[[transformers.Sam2ImageProcessor]]

```python
transformers.Sam2ImageProcessor(**kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/image_processing_sam2.py#L369)

**Parametreler:**

do_convert_rgb (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, varsayılan `{'height' : 1024, 'width': 1024}`): Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görüntü kullanılıp kullanılmayacağını belirtir.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, varsayılan `2`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*, varsayılan `0.00392156862745098`) : `do_rescale` `True` olarak ayarlandığında görüntüyü yeniden ölçeklemek için kullanılan yeniden ölçekleme faktörü.

do_normalize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan değeri `[0.485, 0.456, 0.406]`) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan `[0.229, 0.224, 0.225]`) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *opsiyonel*, varsayılan `None`) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, varsayılan `None`) : Görsellerin boyutlandırılacağı `{"height": int, "width" int}` boyutu. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe boyutlandırılır. Yalnızca `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

mask_size (`dict[str, *kwargs*, int]`, *isteğe bağlı*) : Segmentasyon haritalarının yeniden boyutlandırılacağı `{"height": int, "width": int}` boyutu.

Sam2ImageProcessor görüntü işleyicisi oluşturur.

#### preprocess[[transformers.Sam2ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], 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, **kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/image_processing_sam2.py#L389)

**Parametreler:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ön işlenecek 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ı*) : Ön işleme tabi tutulacak segmentasyon haritaları.

do_convert_rgb (`bool`, *kwargs*, *isteğe bağlı*) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *isteğe bağlı*) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görsel kullanılıp kullanılmayacağı.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*) : `do_rescale` `True` olarak ayarlanırsa görüntüyü yeniden ölçeklemek için yeniden ölçekleme çarpanı.

do_normalize (`bool`, *kwargs*, *isteğe bağlı*) : Görüntünün normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *isteğe bağlı*) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Görsellerin doldurulacağı boyut, `{"height": int, "width" int}` biçiminde. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe doldurulur. Yalnızca `do_pad=True.` olduğunda uygulanır.

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

mask_size (`dict[str, *kwargs*, int]`, *isteğe bağlı*) : Segmentasyon haritalarının yeniden boyutlandırılacağı `{"height": int, "width": int}` boyutu.

**Dönüş:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ yönteminin döndürdüğü listeler/diziler/tensörler sözlüğü ('pixel_values' vb.).
- **tensor_type** (`Union[None, str, TensorType]`, *isteğe bağlı*) -- Başlatma sırasında PyTorch/Numpy Tensörlerindeki tamsayı listelerini dönüştürmek için burada bir tensor_type verebilirsiniz.

## Sam2HieraDetModel[[transformers.Sam2HieraDetModel]]

#### transformers.Sam2HieraDetModel[[transformers.Sam2HieraDetModel]]

```python
transformers.Sam2HieraDetModel(config: Sam2HieraDetConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L603)

#### forward[[transformers.Sam2HieraDetModel.forward]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L646)

## Sam2VisionModel[[transformers.Sam2VisionModel]]

#### transformers.Sam2VisionModel[[transformers.Sam2VisionModel]]

```python
transformers.Sam2VisionModel(config: Sam2VisionConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L677)

**Parametreler:**

config ([Sam2VisionConfig](/docs/transformers/v5.23.0/tr/model_doc/sam2#transformers.Sam2VisionConfig)) : 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 bakın.

Üzerinde herhangi bir başlık veya projeksiyon olmadan Sam'dan gelen görme modeli.

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.Sam2VisionModel.forward]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L699)

## Sam2Model[[transformers.Sam2Model]]

#### transformers.Sam2Model[[transformers.Sam2Model]]

```python
transformers.Sam2Model(config: Sam2Config)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L1314)

**Parametreler:**

config ([Sam2Config](/docs/transformers/v5.23.0/tr/model_doc/sam2#transformers.Sam2Config)) : 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.Sam2Model.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/sam2/modeling_sam2.py#L1413)

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

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

[Sam2Model](/docs/transformers/v5.23.0/tr/model_doc/sam2#transformers.Sam2Model) 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/sam2.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/sam2.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.Sam2Model.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/sam2/modeling_sam2.py#L1589)

**Parametreler:**

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

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

A `Sam2VisionEncoderOutput` veya bir `torch.Tensor` tuple'ı (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya ([Sam2Config](/docs/transformers/v5.23.0/tr/model_doc/sam2#transformers.Sam2Config)) 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
```

