# EdgeTAMVideo

## Genel Bakış

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

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

Makalenin özeti aşağıdaki gibidir:

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

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

## Kullanım örneği

### Video Segmentasyonu ve Takibi

EdgeTAM Video'nun temel gücü, nesneleri mobil cihazlarda video kareleri arasında verimli bir şekilde izleme yeteneğidir. Video segmentasyonu için nasıl kullanılacağı aşağıda gösterilmektedir:

#### Temel Video Takibi

```python
from transformers import EdgeTamVideoModel, Sam2VideoProcessor
import torch

model = EdgeTamVideoModel.from_pretrained("yonigozlan/edgetam-video-1", device_map="auto")
processor = Sam2VideoProcessor.from_pretrained("yonigozlan/edgetam-video-1")

# Load video frames (example assumes you have a list of PIL Images)
# video_frames = [Image.open(f"frame_{i:05d}.jpg") for i in range(num_frames)]

# For this example, we'll use the video loading utility
from transformers.video_utils import load_video
video_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/bedroom.mp4"
video_frames, _ = load_video(video_url)

# Initialize video inference session
inference_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
)

# Add click on first frame to select object
ann_frame_idx = 0
ann_obj_id = 1
points = [[[[210, 350]]]]
labels = [[[1]]]

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=ann_obj_id,
    input_points=points,
    input_labels=labels,
)

# Segment the object on the first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Segmentation shape: {video_res_masks.shape}")
Segmentation shape: torch.Size([1, 1, 540, 960])

# Propagate through the entire video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = video_res_masks

print(f"Tracked object through {len(video_segments)} frames")
Tracked object through 200 frames
```

#### Çoklu Nesne Video Takibi

Video kareleri boyunca birden fazla nesneyi eş zamanlı olarak izleyin:

```python
# Reset for new tracking session
inference_session.reset_inference_session()

# Add multiple objects on the first frame
ann_frame_idx = 0
obj_ids = [2, 3]
input_points = [[[[200, 300]], [[400, 150]]]]  # Points for two objects (batched)
input_labels = [[[1], [1]]]

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=obj_ids,
    input_points=input_points,
    input_labels=input_labels,
)

# Get masks for both objects on first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)

# Propagate both objects through video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = {
        obj_id: video_res_masks[i]
        for i, obj_id in enumerate(inference_session.obj_ids)
    }

print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
Tracked 2 objects through 200 frames
```

#### Video Segmentasyonunu İnce Ayar

Herhangi bir karede ek tıklamalar yaparak takibi iyileştirebilirsiniz:

```python
# Add refinement click on a later frame
refine_frame_idx = 50
ann_obj_id = 2  # Refining first object
points = [[[[220, 280]]]]  # Additional point
labels = [[[1]]]  # Positive click

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=refine_frame_idx,
    obj_ids=ann_obj_id,
    input_points=points,
    input_labels=labels,
)

# Re-propagate with the additional information
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = video_res_masks
```

### Akışkan Video Çıkarımı

Gerçek zamanlı uygulamalar için EdgeTAM Video, video kareleri geldikçe işlenmesini destekler:

```python
# Initialize session for streaming
inference_session = processor.init_video_session(
    inference_device=device,
)

# Process frames one by one
for frame_idx, frame in enumerate(video_frames[:10]):  # Process first 10 frames
    inputs = processor(images=frame, device=device, return_tensors="pt").to(model.device)
...
    if frame_idx == 0:
        # Add point input on first frame
        processor.add_inputs_to_inference_session(
            inference_session=inference_session,
            frame_idx=0,
            obj_ids=1,
            input_points=[[[[210, 350], [250, 220]]]],
            input_labels=[[[1, 1]]],
            original_size=inputs.original_sizes[0], # need to be provided when using streaming video inference
        )
...
    # Process current frame
    sam2_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0])
...
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False
    )[0]
    print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}")

Frame 0: mask shape torch.Size([1, 1, 540, 960])
...
```

#### Çoklu Nesneler için Video Toplu İşleme

Video'da birden fazla nesneyi aynı anda izlemek için hepsini tek seferde ekleyin:

```python
# Initialize video session
inference_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
)

# Add multiple objects on the first frame using batch processing
ann_frame_idx = 0
obj_ids = [2, 3]  # Track two different objects
input_points = [
    [[[200, 300], [230, 250], [275, 175]], [[400, 150]]]
]  # Object 2: 3 points (2 positive, 1 negative); Object 3: 1 point
input_labels = [
    [[1, 1, 0], [1]]
]  # Object 2: positive, positive, negative; Object 3: positive

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=obj_ids,
    input_points=input_points,
    input_labels=input_labels,
)

# Get masks for all objects on the first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Generated masks for {video_res_masks.shape[0]} objects")
Generated masks for 2 objects

# Propagate all objects through the video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = {
        obj_id: video_res_masks[i]
        for i, obj_id in enumerate(inference_session.obj_ids)
    }

print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
Tracked 2 objects through 200 frames
```

## EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]]

#### transformers.EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]]

```python
transformers.EdgeTamVideoMaskDecoderConfig(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/edgetam_video/configuration_edgetam_video.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 EdgeTamVideoModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam Video modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) 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.

## EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]]

#### transformers.EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]]

```python
transformers.EdgeTamVideoPromptEncoderConfig(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/edgetam_video/configuration_edgetam_video.py#L32)

**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 EdgeTamVideoModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam Video modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) 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.

## EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]]

#### transformers.EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]]

```python
transformers.EdgeTamVideoConfig(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, num_maskmem: int = 7, image_size: int | list[int] | tuple[int, int] = 1024, sigmoid_scale_for_mem_enc: float = 20.0, sigmoid_bias_for_mem_enc: float = -10.0, enable_occlusion_spatial_embedding: bool = True, multimask_output_in_sam: bool = True, multimask_min_pt_num: int = 0, multimask_max_pt_num: int = 1, multimask_output_for_tracking: bool = True, max_object_pointers_in_encoder: int = 16, max_cond_frame_num: int = -1, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 2, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_mlp_hidden_size: int = 2048, memory_attention_mlp_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list | None = None, memory_attention_rope_k_sizes: list | None = None, memory_attention_rope_dropout: float | int = 0.1, rope_parameters: dict | None = None, perceiver_resampler_num_latents: int = 256, perceiver_resampler_num_latents_2d: int = 256, perceiver_resampler_hidden_size: int = 64, perceiver_resampler_mlp_intermediate_size: int = 256, perceiver_resampler_num_attention_heads: int = 1, perceiver_resampler_attention_head_dim: int = 64, perceiver_resampler_num_layers: int = 2, perceiver_resampler_hidden_dropout: float | int = 0.0, perceiver_resampler_attention_dropout: float | int = 0.0, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, mask_downsampler_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/configuration_edgetam_video.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`, `EdgeTamVideoPromptEncoderConfig`], *opsiyonel*) : [EdgeTamVideoPromptEncoderConfig](/docs/transformers/v5.23.0/tr/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig) sınıfını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

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

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

num_maskmem (`int`, *isteğe bağlı*, varsayılan 7) : Maske belleği için bellek yuvası sayısı.

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üğü).

sigmoid_scale_for_mem_enc (`float`, *opsiyonel*, varsayılan 20.0) : Bellek kodlayıcıdaki sigmoid fonksiyonu için ölçekleme faktörü.

sigmoid_bias_for_mem_enc (`float`, *isteğe bağlı*, varsayılan -10.0) : Bellek kodlayıcıdaki sigmoid fonksiyonu için önyargı.

enable_occlusion_spatial_embedding (`bool`, *isteğe bağlı*, varsayılan `True`) : Gölgelenmeler için uzamsal gömme (spatial embedding) etkinleştirilecek mi?

multimask_output_in_sam (`bool`, *isteğe bağlı*, varsayılan `True`) : SAM başından çoklu maske çıktısı alınacak mı.

multimask_min_pt_num (`int`, *isteğe bağlı*, varsayılan 0) : Çoklu maske çıktısını tetiklemek için gereken minimum nokta sayısı.

multimask_max_pt_num (`int`, *isteğe bağlı*, varsayılan 1) : Çoklu maske çıktısını tetikleyecek en fazla nokta sayısı.

multimask_output_for_tracking (`bool`, *isteğe bağlı*, varsayılan `True`) : Takip için çoklu maske çıktısının kullanılıp kullanılmayacağı.

max_object_pointers_in_encoder (`int`, *isteğe bağlı*, varsayılan 16) : Kodlayıcıdaki nesne işaretçilerinin maksimum sayısı.

max_cond_frame_num (`int`, *opsiyonel*, varsayılan -1) : Bellek dikkatinde kullanılacak maksimum koşullama karesi sayısı. Tüm koşullama karelerini kullanmak için -1 olarak ayarlayın.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *isteğe bağlı*, varsayılan `True`) : Nesne işaretçileri için zamansal konumsal kodlamanın etkinleştirilip etkinleştirilmeyeceğini belirtir.

memory_attention_hidden_size (`int`, *isteğe bağlı*, varsayılan 256) : Bellek dikkati gizli durumlarının boyutluluğu.

memory_attention_num_layers (`int`, *isteğe bağlı*, varsayılan 2) : Bellek dikkat modülündeki katman sayısı.

memory_attention_num_attention_heads (`int`, *isteğe bağlı*, varsayılan 1) : Bellek dikkatindeki her dikkat katmanı için dikkat başı sayısı.

memory_attention_downsample_rate (`int`, *isteğe bağlı*, varsayılan 1) : Dikkat katmanları için örnekleme azaltma oranı.

memory_attention_mlp_hidden_size (`int`, *opsiyonel*, varsayılan 2048) : Bellek dikkat modülündeki ileri beslemeli ağın boyutu.

memory_attention_mlp_hidden_act (`str`, *isteğe bağlı*, varsayılan `"relu"`) : Bellek dikkat modülündeki ileri beslemeli ağdaki doğrusal olmayan aktivasyon fonksiyonu.

memory_attention_dropout (`float`, *opsiyonel*, varsayılan 0.1) : Bellek dikkat modülü için dropout oranı.

memory_attention_rope_feat_sizes (`Tuple[int, int]`, *isteğe bağlı*, varsayılan `[64, 64]`) : Rope konumsal kodlaması için özellik boyutları.

memory_attention_rope_k_sizes (`List[int]`, *isteğe bağlı*, varsayılan `[16, 16]`) : Bellek dikkatindeki RoPE konumsal kodlama için anahtar özellik boyutları.

memory_attention_rope_dropout (`float`, *opsiyonel*, varsayılan 0.1) : Rope konumsal kodlama için dropout oranı.

rope_parameters (`dict`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

perceiver_resampler_num_latents (`int`, *isteğe bağlı*, varsayılan 256) : Perceiver resampler'daki 1B latent token sayısı.

perceiver_resampler_num_latents_2d (`int`, *isteğe bağlı*, varsayılan 256) : Perceiver resampler'daki 2B latent token sayısı.

perceiver_resampler_hidden_size (`int`, *isteğe bağlı*, varsayılan 64) : Perceiver resampler'ın gizli boyutu.

perceiver_resampler_mlp_intermediate_size (`int`, *opsiyonel*, varsayılan 256) : Perceiver resampler'daki ileri beslemeli ağın ara boyutu.

perceiver_resampler_num_attention_heads (`int`, *isteğe bağlı*, varsayılan 1) : Perceiver resampler'daki dikkat başlarının sayısı.

perceiver_resampler_attention_head_dim (`int`, *isteğe bağlı*, varsayılan 64) : Perceiver resampler'da her dikkat başlığının boyutu.

perceiver_resampler_num_layers (`int`, *isteğe bağlı*, varsayılan 2) : Perceiver resampler'daki katman sayısı.

perceiver_resampler_hidden_dropout (`float`, *opsiyonel*, varsayılan 0.0) : Perceiver resampler'daki gizli katmanlar için dropout oranı.

perceiver_resampler_attention_dropout (`float`, *opsiyonel*, varsayılan 0.0) : Perceiver resampler'daki dikkat katmanları için dropout oranı.

memory_encoder_hidden_size (`int`, *opsiyonel*, varsayılan 256) : Bellek kodlayıcısı gizli durumlarının boyutluluğu.

memory_encoder_output_channels (`int`, *isteğe bağlı*, varsayılan 64) : Bellek kodlayıcısı için çıktı kanalı sayısı.

mask_downsampler_embed_dim (`int`, *isteğe bağlı*, varsayılan 256) : Mask downsampler gömme boyutu.

memory_fuser_intermediate_dim (`int`, *isteğe bağlı*, varsayılan 1024) : Bellek füzyonu ileri besleme ağının ara boyutu.

mask_downsampler_kernel_size (`int`, *isteğe bağlı*, varsayılan 3) : Maske küçültücü için çekirdek boyutu.

mask_downsampler_stride (`int`, *isteğe bağlı*, varsayılan 2) : Maske küçültücünün (downsampler) adım boyutu (stride).

mask_downsampler_padding (`int`, *isteğe bağlı*, varsayılan 1) : Maske küçültücünün dolgusu.

mask_downsampler_total_stride (`int`, *isteğe bağlı*, varsayılan 16) : Maske küçültücüsü için toplam adım.

mask_downsampler_hidden_act (`str`, *isteğe bağlı*, varsayılan `"gelu"`) : Maske küçültücüdeki doğrusal olmayan aktivasyon fonksiyonu.

memory_fuser_num_layers (`int`, *isteğe bağlı*, varsayılan 2) : Bellek birleştiricisindeki katman sayısı.

memory_fuser_embed_dim (`int`, *isteğe bağlı*, varsayılan 256) : Bellek füzyonu gömme boyutu.

memory_fuser_kernel_size (`int`, *isteğe bağlı*, varsayılan 7) : Bellek birleştiricisi için çekirdek boyutu.

memory_fuser_padding (`int`, *isteğe bağlı*, varsayılan 3) : Bellek birleştiricisi için dolgu.

memory_fuser_layer_scale_init_value (`float`, *opsiyonel*, varsayılan 1e-06) : Bellek birleştiricisinde katman ölçeğinin başlangıç değeri.

memory_fuser_hidden_act (`str`, *isteğe bağlı*, varsayılan `"gelu"`) : Bellek birleştiricisindeki doğrusal olmayan aktivasyon fonksiyonu.

Bu, bir EdgeTamVideoModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Edgetam Video modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) 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 (
...     EdgeTamVisionConfig,
...     EdgeTamVideoPromptEncoderConfig,
...     EdgeTamVideoMaskDecoderConfig,
...     EdgeTamVideoModel,
...     EdgeTamVideoConfig,
... )

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

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

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

>>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig

>>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations
>>> vision_config = EdgeTamVisionConfig()
>>> prompt_encoder_config = EdgeTamVideoPromptEncoderConfig()
>>> mask_decoder_config = EdgeTamVideoMaskDecoderConfig()

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

## EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]]

#### transformers.EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]]

```python
transformers.EdgeTamVideoInferenceSession(video: typing.Optional[torch.Tensor] = None, video_height: int | None = None, video_width: int | None = None, inference_device: typing.Union[torch.device, str] = 'cpu', inference_state_device: typing.Union[torch.device, str] = 'cpu', video_storage_device: typing.Union[torch.device, str] = 'cpu', dtype: typing.Union[torch.dtype, str] = 'float32', max_vision_features_cache_size: int = 1)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L942)

**Parametreler:**

video (`torch.Tensor`, *isteğe bağlı*) : İşlenecek video. Akış sırasında sağlamanıza gerek yoktur.

video_height (`int`, *isteğe bağlı*) : Video yüksekliği.

video_width (`int`, *isteğe bağlı*) : Video genişliği.

inference_device (`torch.device`, *isteğe bağlı*, varsayılan `"cpu"`) : Çıkarım için kullanılacak cihaz.

inference_state_device (`torch.device`, *isteğe bağlı*, varsayılan `"cpu"`) : Çıkarım durumunun saklanacağı cihaz.

video_storage_device (`torch.device`, *isteğe bağlı*, varsayılan `"cpu"`) : Videonun saklanacağı cihaz.

dtype (`torch.dtype`, *isteğe bağlı*, varsayılan `"float32"`) : Video için kullanılacak dtype.

max_vision_features_cache_size (`int`, *isteğe bağlı*, varsayılan 1) : Önbelleğe alınacak en fazla görsel özellik sayısı.

Video çıkarım oturumu parametrelerini, durumunu ve önbelleğini yönetir.

#### add_mask_inputs[[transformers.EdgeTamVideoInferenceSession.add_mask_inputs]]

```python
add_mask_inputs(obj_idx: int, frame_idx: int, inputs: Tensor)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1062)

Otomatik cihaz yerleşimi ile maske girdileri ekleyin.

#### add_new_frame[[transformers.EdgeTamVideoInferenceSession.add_new_frame]]

```python
add_new_frame(pixel_values: Tensor, frame_idx: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1137)

Otomatik cihaz yerleşimi ile yeni çerçeve ekleyin.

#### add_point_inputs[[transformers.EdgeTamVideoInferenceSession.add_point_inputs]]

```python
add_point_inputs(obj_idx: int, frame_idx: int, inputs: dict)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1048)

Otomatik cihaz yerleşimi ile nokta girdileri ekleyin.

#### get_frame[[transformers.EdgeTamVideoInferenceSession.get_frame]]

```python
get_frame(frame_idx: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1153)

Videodan kare alın.

#### get_obj_num[[transformers.EdgeTamVideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1043)

Bu oturumda şimdiye kadar alınan benzersiz nesne kimliklerinin toplam sayısını alın.

#### get_output[[transformers.EdgeTamVideoInferenceSession.get_output]]

```python
get_output(obj_idx: int, frame_idx: int, output_key: str, is_conditioning_frame: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1110)

**Parametreler:**

obj_idx (int) : Nesnenin indeksi.

frame_idx (int) : Kare indeksi.

output_key (str) : Çıktının anahtarı.

is_conditioning_frame (bool) : Çıktının bir koşullandırma çerçevesi için olup olmadığı.

Akıllı cihaz yönetimi ile çıktı alın.

#### obj_id_to_idx[[transformers.EdgeTamVideoInferenceSession.obj_id_to_idx]]

```python
obj_id_to_idx(obj_id: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1017)

Gerekirse yeni bir giriş oluşturarak nesne kimliğini indekse eşler.

#### obj_idx_to_id[[transformers.EdgeTamVideoInferenceSession.obj_idx_to_id]]

```python
obj_idx_to_id(obj_idx: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1039)

Model tarafındaki nesne dizinini istemci tarafındaki nesne kimliğine eşleyin.

#### remove_mask_inputs[[transformers.EdgeTamVideoInferenceSession.remove_mask_inputs]]

```python
remove_mask_inputs(obj_idx: int, frame_idx: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1068)

Mask girişlerini kaldırın.

#### remove_point_inputs[[transformers.EdgeTamVideoInferenceSession.remove_point_inputs]]

```python
remove_point_inputs(obj_idx: int, frame_idx: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1058)

Nokta girdilerini kaldırın.

#### reset_inference_session[[transformers.EdgeTamVideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1169)

İzleme verilerini ve önbelleği sıfırlayın.

#### reset_tracking_data[[transformers.EdgeTamVideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1157)

İzleme verilerini sıfırla ancak önbelleği koru.

#### store_output[[transformers.EdgeTamVideoInferenceSession.store_output]]

```python
store_output(obj_idx: int, frame_idx: int, output_key: str | None = None, output_value: typing.Union[torch.Tensor, dict, NoneType] = None, is_conditioning_frame: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1073)

**Parametreler:**

obj_idx (int) : Nesnenin indeksi.

frame_idx (int) : Kare indeksi.

output_key (Optional[str]) : Çıktının anahtarı. None ise, çıktı bir sözlük olarak saklanır.

output_value (Optional[Union[torch.Tensor, dict]]) : Çıktının değeri.

is_conditioning_frame (bool) : Çıktının bir koşullandırma çerçevesi için olup olmadığı.

Akıllı cihaz yönetimi ile çıktıyı saklayın. output_key None ise, çıktı bir sözlük olarak saklanır.

## EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

#### transformers.EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

```python
transformers.EdgeTamVideoModel(config: EdgeTamVideoConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2062)

**Parametreler:**

config ([EdgeTamVideoConfig](/docs/transformers/v5.23.0/tr/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) : 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.

Üzerinde herhangi bir özel head olmadan ham hidden-states üreten çıplak Edgetam Video Model.

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

```python
forward(inference_session: EdgeTamVideoInferenceSession, frame_idx: int | None = None, frame: typing.Optional[torch.Tensor] = None, reverse: bool = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2196)

**Parametreler:**

inference_session (`~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession`) : Video çıkarım oturumu nesnesi.

frame_idx (`int`, *isteğe bağlı*) : Çıkarımın (inference) çalıştırılacağı karein indeksi. Yeni bir akış karesi üzerinde çıkarım yaparken belirtmenize gerek yoktur.

frame (`torch.Tensor`, *isteğe bağlı*) : İşlenecek kare. Akış sırasında sağlanır.

reverse (`bool`, *isteğe bağlı*, varsayılan `False`) : Ters yönde yaygınlaştırılacak mı?

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

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

Nesneleri, akışkan video karesi boyunca ilerletin.

- **object_ids** (`list[int]`, *isteğe bağlı*) -- Mevcut karede izlenen nesne kimliklerinin listesi.
- **pred_masks** (`torch.Tensor`, şekli `(batch_size, num_masks, height, width)`) -- Modelin çözünürlüğünde saklanan tahmini maskeler.
- **object_score_logits** (`torch.Tensor`, şekli `(batch_size,)`, *isteğe bağlı*) -- Nesnelerin var olup olmadığını gösteren nesne skorları için logitler.
- **frame_idx** (`int`, *isteğe bağlı*) -- Videoyun kare indeksi.

#### get_image_features[[transformers.EdgeTamVideoModel.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/edgetam_video/modeling_edgetam_video.py#L2295)

**Parametreler:**

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

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

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

