# SAM3 Video

    
        
        
    

## Genel Bakış

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

SAM3 Video, videolarda **Promptable Concept Segmentation (PCS)** gerçekleştirir. PCS, metin alır (ör. "yellow school bus") ve kavramla eşleşen **her bir nesne** için örnekleme ve anlamsal maskeleri tahmin ederken, nesne kimliklerini video kareleri boyunca korur.

Model, metin istemleri kullanılarak video kareleri arasında sağlam nesne takibi yapılmasını sağlamak için bir algılama modülü (SAM3) ile bir takip modülünü (SAM2 tarzı takipçi) birleştirir.

Makalenin özeti aşağıdaki gibidir:

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

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

## Kullanım örneği

### Video Segmentasyonu ve Takibi

#### Önceden Yüklenmiş Video Çıkarımı

Metin istemleri kullanarak tüm kareleri zaten mevcut olan bir videoyu işleyin:

```python
from transformers import Sam3VideoModel, Sam3VideoProcessor
import torch

model = Sam3VideoModel.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3VideoProcessor.from_pretrained("facebook/sam3")

# Load video frames
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,
    processing_device="cpu",
    video_storage_device="cpu",
)

# Add text prompt to detect and track objects
text = "person"
inference_session = processor.add_text_prompt(
    inference_session=inference_session,
    text=text,
)

# Process all frames in the video
outputs_per_frame = {}
# Pass show_progress_bar=True to display a tqdm progress bar.
for model_outputs in model.propagate_in_video_iterator(
    inference_session=inference_session, max_frame_num_to_track=50
):
    processed_outputs = processor.postprocess_outputs(inference_session, model_outputs)
    outputs_per_frame[model_outputs.frame_idx] = processed_outputs

print(f"Processed {len(outputs_per_frame)} frames")
Processed 51 frames

# Access results for a specific frame
frame_0_outputs = outputs_per_frame[0]
print(f"Detected {len(frame_0_outputs['object_ids'])} objects")
print(f"Object IDs: {frame_0_outputs['object_ids'].tolist()}")
print(f"Scores: {frame_0_outputs['scores'].tolist()}")
print(f"Boxes shape (XYXY format, absolute coordinates): {frame_0_outputs['boxes'].shape}")
print(f"Masks shape: {frame_0_outputs['masks'].shape}")
```

Birden fazla istem sağlayarak aynı anda birden fazla nesne kategorisini de izleyebilirsiniz. Model, tüm istemler arasında görme özelliklerini verimli bir şekilde yeniden kullanır:

```python
# Add multiple text prompts (or use a list in add_text_prompt)
multi_prompt_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
    processing_device="cpu",
    video_storage_device="cpu",
)
>>>
prompts = ["person", "bed", "lamp"]
processor.add_text_prompt(multi_prompt_session, prompts)
>>>
# Process video - detects objects from ALL prompts in a single pass
multi_outputs_per_frame = {}
# Pass show_progress_bar=True to display a tqdm progress bar.
for model_outputs in model.propagate_in_video_iterator(
    inference_session=multi_prompt_session, max_frame_num_to_track=50
):
    processed_outputs = processor.postprocess_outputs(multi_prompt_session, model_outputs)
    multi_outputs_per_frame[model_outputs.frame_idx] = processed_outputs
>>>
# Check which objects were detected by each prompt
frame_0_outputs = multi_outputs_per_frame[0]
prompt_to_obj_ids = frame_0_outputs["prompt_to_obj_ids"]
for prompt, obj_ids in prompt_to_obj_ids.items():
    print(f"{prompt}: {len(obj_ids)} objects")
person: 2 objects
bed: 1 objects
lamp: 1 objects
```

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

⚠️ **Akış Çıkarım Kalitesi Hakkında Not**: Akış çıkarımı, eşleşmeyen ve yinelenen nesneleri kaldıran hotstart sezgisel yaklaşımlarını devre dışı bırakır; çünkü bu yaklaşımlar bilinçli kararlar verebilmek için gelecek karelere erişim gerektirir. Bu durum, önceden yüklenmiş video çıkarımına kıyasla daha fazla yanlış pozitif algılama ve yinelenen nesne izlerine yol açabilir. En iyi sonuçlar için, tüm kareler mevcut olduğunda önceden yüklenmiş video çıkarımını kullanın.

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

```python
# Initialize session for streaming
streaming_inference_session = processor.init_video_session(
    inference_device=device,
    processing_device="cpu",
    video_storage_device="cpu",
)

# Add text prompt
text = "person"
streaming_inference_session = processor.add_text_prompt(
    inference_session=streaming_inference_session,
    text=text,
)

# Process frames one by one (streaming mode)
streaming_outputs_per_frame = {}
for frame_idx, frame in enumerate(video_frames[:50]):  # Process first 50 frames
    # First, process the frame using the processor
    inputs = processor(images=frame, device=device, return_tensors="pt").to(model.device)
...
    # Process frame using streaming inference - pass the processed pixel_values
    model_outputs = model(
        inference_session=streaming_inference_session,
        frame=inputs.pixel_values[0],  # Provide processed frame - this enables streaming mode
        reverse=False,
    )
...
    # Post-process outputs with original_sizes for proper resolution handling
    processed_outputs = processor.postprocess_outputs(
        streaming_inference_session,
        model_outputs,
        original_sizes=inputs.original_sizes,  # Required for streaming inference
    )
    streaming_outputs_per_frame[frame_idx] = processed_outputs
...
    if (frame_idx + 1) % 10 == 0:
        print(f"Processed {frame_idx + 1} frames...")

print(f"✓ Streaming inference complete! Processed {len(streaming_outputs_per_frame)} frames")
✓ Streaming inference complete! Processed 50 frames

# Access results
frame_0_outputs = streaming_outputs_per_frame[0]
print(f"Detected {len(frame_0_outputs['object_ids'])} objects in first frame")
print(f"Boxes are in XYXY format (absolute pixel coordinates): {frame_0_outputs['boxes'].shape}")
print(f"Masks are at original video resolution: {frame_0_outputs['masks'].shape}")
```

#### Özel Çözünürlükte Çıkarım

⚠️ **Performans Notu**: Özel çözünürlükler doğruluğu düşürebilir. Modelin 1008px çözünürlükte kullanılması amaçlanmıştır.

Daha hızlı çıkarım veya daha düşük bellek kullanımı için:

```python
config = Sam3VideoConfig.from_pretrained("facebook/sam3")
config.image_size = 560
model = Sam3VideoModel.from_pretrained("facebook/sam3", config=config, device_map="auto")
processor = Sam3VideoProcessor.from_pretrained("facebook/sam3", size={"height": 560, "width": 560})
```

## Sam3VideoConfig[[transformers.Sam3VideoConfig]]

#### transformers.Sam3VideoConfig[[transformers.Sam3VideoConfig]]

```python
transformers.Sam3VideoConfig(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, detector_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, tracker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02, low_res_mask_size: int = 288, score_threshold_detection: float = 0.5, det_nms_thresh: float = 0.1, assoc_iou_thresh: float = 0.1, trk_assoc_iou_thresh: float = 0.5, new_det_thresh: float = 0.7, recondition_on_trk_masks: bool = True, hotstart_delay: int = 15, hotstart_unmatch_thresh: int = 8, hotstart_dup_thresh: int = 8, suppress_unmatched_only_within_hotstart: bool = True, init_trk_keep_alive: int = 30, max_trk_keep_alive: int = 30, min_trk_keep_alive: int = -1, suppress_overlapping_based_on_recent_occlusion_threshold: float = 0.7, decrease_trk_keep_alive_for_empty_masklets: bool = False, fill_hole_area: int = 16, max_num_objects: int = 10000, recondition_every_nth_frame: int = 16, high_conf_thresh: float = 0.8, high_iou_thresh: float = 0.8)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/configuration_sam3_video.py#L28)

**Parametreler:**

detector_config (`dict` veya `Sam3Config`, *isteğe bağlı*) : Sam3 algılayıcı modeli için yapılandırma. Sağlanmazsa, varsayılan Sam3Config kullanılır.

tracker_config (`dict` veya `Sam2VideoConfig`, *isteğe bağlı*) : Sam2Video takipçi modeli için yapılandırma. Sağlanmazsa, varsayılan Sam2VideoConfig kullanılır.

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

low_res_mask_size (`int`, *opsiyonel*, varsayılan 288) : Takipçinin, video çözünürlüğüne yükseltilmeden önce ürettiği düşük çözünürlüklü maske çıktıları için boyut (yükseklik ve genişlik).

score_threshold_detection (`float`, *opsiyonel*, varsayılan 0.5) : Algılama çıktıları için olasılık eşiği - yalnızca bu eşiğin üzerindeki algılamaları korur.

det_nms_thresh (`float`, *isteğe bağlı*, varsayılan 0.1) : Algılama NMS (Non-Maximum Suppression) için IoU eşiği.

assoc_iou_thresh (`float`, *opsiyonel*, varsayılan 0.1) : Algılama-iz eşleştirmesi için IoU eşiği. Bir algılama, bu eşik üzerinde bir iz parçasıyla (tracklet) örtüşüyorsa o iz parçasıyla "eşleşmiş" sayılır. Genellikle 0.1 gibi gevşek bir eşik kullanılır.

trk_assoc_iou_thresh (`float`, *opsiyonel*, varsayılan 0.5) : Algılama-iz eşleştirmesi için IoU eşiği, bir masklet'in hiçbir algılama tarafından "eşleşmemiş" olarak belirlenip belirlenmediğini tespit etmek için kullanılır. Genellikle 0.5 gibi daha sıkı bir eşik kullanılır.

new_det_thresh (`float`, *isteğe bağlı*, varsayılan 0.7) : Bir algılamanın yeni bir nesne olarak eklenmesi için olasılık eşiği.

recondition_on_trk_masks (`bool`, *isteğe bağlı*, varsayılan `True`) : Yeniden koşullandırmada izlenen maskelerin (True) yoksa algılama maskelerinin (False) kullanılıp kullanılmayacağı. İzlenen maskelerin kalitesi daha yüksek olduğunda ve algılayıcının hafızayı güçlendirmek ve sapmayı önlemek için doğrulama sinyali olarak hizmet ettiği durumlarda True kullanın.

hotstart_delay (`int`, *isteğe bağlı*, varsayılan 15) : Hotstart sırasında çıktıların tamponlanacağı kare sayısı. Çıktıları `hotstart_delay` kare boyunca bekletir ve tracklet'leri hotstart heuristiklerine göre kaldırır.

hotstart_unmatch_thresh (`int`, *isteğe bağlı*, varsayılan 8) : Hotstart döneminde bir tracklet'in kaldırılması için gereken eşleşmeyen kare sayısı.

hotstart_dup_thresh (`int`, *isteğe bağlı*, varsayılan 8) : Hotstart döneminde yinelenen bir tracklet'in kaldırılması için gereken örtüşen kare sayısı.

suppress_unmatched_only_within_hotstart (`bool`, *isteğe bağlı*, varsayılan `True`) : Maskelerin yalnızca hotstart dönemi içinde bastırılıp bastırılmayacağını belirtir. False ise, maskeler hotstart döneminden önce başlasa bile bastırılabilir.

init_trk_keep_alive (`int`, *isteğe bağlı*, varsayılan 30) : Yeni izler için başlangıç keep-alive sayacı.

max_trk_keep_alive (`int`, *isteğe bağlı*, varsayılan 30) : Maksimum keep-alive sayacı değeri. Eşleşen algılamaları izleyen nesnelerin sayacı bu değere kadar artırılır.

min_trk_keep_alive (`int`, *isteğe bağlı*, varsayılan -1) : Minimum keep-alive sayaç değeri. Eşleşmeyen algılamalara sahip izler, sayaçları bu değere düşürülür.

suppress_overlapping_based_on_recent_occlusion_threshold (`float`, *opsiyonel*, varsayılan 0.7) : Son tıkanıklığa dayalı olarak üst üste binen nesneleri bastırmak için eşik değeri. Bu eşiğin üzerindeki IoU değerine sahip üst üste binen maskeler, en son tıkanan nesneye göre bastırılır.

decrease_trk_keep_alive_for_empty_masklets (`bool`, *isteğe bağlı*, varsayılan `False`) : SAM2 tahmininde alanı sıfır olan maskletler için keep-alive sayacının azaltılıp azaltılmayacağını belirtir.

fill_hole_area (`int`, *isteğe bağlı*, varsayılan 16) : Maskelerdeki delikleri doldurmak ve küçük püskürtmeleri kaldırmak için minimum alan (piksel cinsinden).

max_num_objects (`int`, *isteğe bağlı*, varsayılan 10000) : Takip edilecek nesnelerin maksimum sayısı. Varsayılan 10000 değeri bu sınırı fiilen devre dışı bırakır.

recondition_every_nth_frame (`int`, *isteğe bağlı*, varsayılan 16) : Maske yeniden koşullandırma sıklığı (kare cinsinden). Yeniden koşullandırmayı devre dışı bırakmak için 0 olarak ayarlayın.

high_conf_thresh (`float`, *opsiyonel*, varsayılan 0.8) : Yeniden koşullandırma için yüksek güven eşiği. Yalnızca bu eşiğin üzerindeki algılamalar tracklet'leri yeniden koşullandırabilir.

high_iou_thresh (`float`, *opsiyonel*, varsayılan 0.8) : Yeniden koşullandırma için yüksek IoU eşiği. Sadece IoU değeri bu eşiğin üzerindeki algılamalar tracklet'leri yeniden koşullandırabilir.

Bu, bir Sam3VideoModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Sam3 Video modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [facebook/sam3](https://huggingface.co/facebook/sam3) ile benzer bir yapılandırma elde edilir.

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

Örnek:
```python
>>> from transformers import Sam3VideoConfig, Sam3VideoModel

>>> # Initializing a SAM3 Video configuration with default detector and tracker
>>> configuration = Sam3VideoConfig()

>>> # Changing image size for custom resolution inference (automatically propagates to all nested configs)
>>> configuration.image_size = 560

>>> # Initializing a model from the configuration
>>> model = Sam3VideoModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
>>> detector_config = configuration.detector_config
>>> tracker_config = configuration.tracker_config
```

## Sam3VideoProcessor[[transformers.Sam3VideoProcessor]]

#### transformers.Sam3VideoProcessor[[transformers.Sam3VideoProcessor]]

```python
transformers.Sam3VideoProcessor(image_processor, video_processor, tokenizer, target_size: int | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/processing_sam3_video.py#L39)

**Parametreler:**

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

video_processor (`video_processor_class`) : Video işleyici zorunlu bir girdidir.

tokenizer (`CLIPTokenizer`) : Tokenizer zorunlu bir girdidir.

target_size (`int`, *isteğe bağlı*) : Görselin yeniden boyutlandırılacağı hedef boyut (target_size, target_size).

Bir görüntü işleyiciyi, bir video işleyiciyi ve bir belirteç oluşturucuyu tek bir işleyicide birleştiren bir Sam3VideoProcessor oluşturur.

[Sam3VideoProcessor](/docs/transformers/main/tr/model_doc/sam3_video#transformers.Sam3VideoProcessor), [Sam3ImageProcessor](/docs/transformers/main/tr/model_doc/sam3#transformers.Sam3ImageProcessor), `video_processor_class` ve [CLIPTokenizer](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPTokenizer) işlevlerinin tümünü sunar. Daha fazla bilgi için [~Sam3ImageProcessor](/docs/transformers/main/tr/model_doc/sam3#transformers.Sam3ImageProcessor), `~video_processor_class` ve [~CLIPTokenizer](/docs/transformers/main/tr/model_doc/clip#transformers.CLIPTokenizer) belgelerine bakın.

#### __call__[[transformers.Sam3VideoProcessor.__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, 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/main/src/transformers/models/sam3_video/processing_sam3_video.py#L55)

**Parametreler:**

images (`ImageInput`, *isteğe bağlı*) : İşlenecek görüntü(ler).

segmentation_maps (`ImageInput`, *isteğe bağlı*) : İşlenecek segmentasyon haritaları (isteğe bağlı, görüntü işleyici için).

original_sizes (`list[list[float]]`, `torch.Tensor`, *isteğe bağlı*) : Görsellerin orijinal boyutları. Yalnızca images sağlanmadığında kullanılır.

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/main/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`, *isteğe bağlı*): İşlenmiş segmentasyon haritaları (verildiyse).

#### postprocess_outputs[[transformers.Sam3VideoProcessor.postprocess_outputs]]

```python
postprocess_outputs(inference_session, model_outputs, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/processing_sam3_video.py#L247)

**Parametreler:**

inference_session (`Sam3VideoInferenceSession`) : Çıkarım oturumu nesnesi.

model_outputs (`Sam3VideoSegmentationOutput`) : `Sam3VideoModel.forward()` işlevinden gelen ham model çıktısı.

original_sizes (`list[list[float]]` veya `torch.Tensor`, *isteğe bağlı*) : İsteğe bağlı orijinal kare boyutları [yükseklik, genişlik]. Oturumda video_height/video_width ayarlanmadığında akış çıkarımı için gereklidir.

**Dönüş:** `dict`

Aşağıdaki anahtarları içeren bir sözlük:
- **object_ids** (`torch.Tensor`, şekli `(num_objects,)`): Algılanan her nesne için nesne kimlikleri.
- **scores** (`torch.Tensor`, şekli `(num_objects,)`): Her nesne için algılama puanları.
- **boxes** (`torch.Tensor`, şekli `(num_objects, 4)`): XYXY biçiminde sınırlayıcı kutular (top_left_x, top_left_y, bottom_right_x, bottom_right_y).
- **masks** (`torch.Tensor`, şekli `(num_objects, height, width)`): Orijinal video çözünürlüğünde her nesne için ikili segmentasyon maskeleri.
- **prompt_to_obj_ids** (`dict[str, list[int]]`): Prompt metninden, o prompt tarafından algılanan nesne kimlikleri listesine eşleme.

Son maskeleri, kutuları ve skorları elde etmek için model çıktılarını son işlemleyin.

#### init_video_session[[transformers.Sam3VideoProcessor.init_video_session]]

```python
init_video_session(video: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, inference_device: typing.Union[str, ForwardRef('torch.device')] = 'cpu', inference_state_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, processing_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, video_storage_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, max_vision_features_cache_size: int = 1, dtype: dtype = torch.float32)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/processing_sam3_video.py#L133)

**Parametreler:**

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

inference_device (`str` veya `torch.device`, *opsiyonel*, varsayılan "cpu") : Çıkarım için kullanılacak cihaz.

inference_state_device (`str` veya `torch.device`, *isteğe bağlı*) : Çıkarım durumunun saklanacağı cihaz.

processing_device (`str` veya `torch.device`, *isteğe bağlı*) : Video işleme için kullanılacak cihaz.

video_storage_device (`str` veya `torch.device`, *isteğe bağlı*) : İşlenmiş video karelerinin saklanacağı cihaz.

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

dtype (`torch.dtype`, *isteğe bağlı*, varsayılan `torch.float32`) : Tüm oturum için kullanılacak torch dtype.

Çıkarım için bir video oturumu başlatır. Bir video sağlanırsa (asenkron çıkarım), video işlenir ve `video_storage_device` üzerinde saklanır.

#### add_text_prompt[[transformers.Sam3VideoProcessor.add_text_prompt]]

```python
add_text_prompt(inference_session: Sam3VideoInferenceSession, text: str | list[str])
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/processing_sam3_video.py#L101)

**Parametreler:**

inference_session (`Sam3VideoInferenceSession`) : Çıkarım oturumu.

text (`str` veya `list[str]`) : Eklenecek metin istem(ler)i.

**Dönüş:** `Sam3VideoInferenceSession`

Eklenen metin istemcisi/istemcileriyle çıkarım oturumu.

Çıkarım oturumuna metin istemi(leri) ekleyin.

## Sam3VideoInferenceSession[[transformers.Sam3VideoInferenceSession]]

#### transformers.Sam3VideoInferenceSession[[transformers.Sam3VideoInferenceSession]]

```python
transformers.Sam3VideoInferenceSession(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/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L119)

**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.Sam3VideoInferenceSession.add_mask_inputs]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L255)

Otomatik cihaz yerleşimi ile maske girdileri ekleyin.

#### add_new_frame[[transformers.Sam3VideoInferenceSession.add_new_frame]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L384)

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

#### add_prompt[[transformers.Sam3VideoInferenceSession.add_prompt]]

```python
add_prompt(prompt_text: str)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L215)

Oturuma bir metin istemi ekler ve benzersiz kimliğini döndürür. İstem zaten mevcut ise, mevcut kimliği döndürür.

#### get_frame[[transformers.Sam3VideoInferenceSession.get_frame]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L400)

Videodan kare alın.

#### get_obj_num[[transformers.Sam3VideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L251)

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

#### get_output[[transformers.Sam3VideoInferenceSession.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/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L357)

**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.Sam3VideoInferenceSession.obj_id_to_idx]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L229)

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

#### obj_idx_to_id[[transformers.Sam3VideoInferenceSession.obj_idx_to_id]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L247)

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

#### remove_mask_inputs[[transformers.Sam3VideoInferenceSession.remove_mask_inputs]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L261)

Mask girişlerini kaldırın.

#### remove_object[[transformers.Sam3VideoInferenceSession.remove_object]]

```python
remove_object(obj_id: int, strict: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L265)

**Parametreler:**

obj_id (`int`) : Kaldırılacak nesne kimliği.

strict (`bool`, *isteğe bağlı*, varsayılan `False`) : Nesne mevcut değilse bir hata fırlatılacak mı?

Çıkarım oturumundan bir nesne kaldırın. Bu işlem, nesneyi videodaki tüm karelerden kaldırır.

#### reset_inference_session[[transformers.Sam3VideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L416)

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

#### reset_state[[transformers.Sam3VideoInferenceSession.reset_state]]

```python
reset_state()
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L428)

Çıkarım oturumu durumunu sıfırlayın.

#### reset_tracking_data[[transformers.Sam3VideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L404)

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

#### store_output[[transformers.Sam3VideoInferenceSession.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/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L320)

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

## Sam3VideoSegmentationOutput[[transformers.Sam3VideoSegmentationOutput]]

#### transformers.Sam3VideoSegmentationOutput[[transformers.Sam3VideoSegmentationOutput]]

```python
transformers.Sam3VideoSegmentationOutput(object_ids: list[int] | None = None, obj_id_to_mask: dict[int, torch.Tensor] | None = None, obj_id_to_score: dict[int, float] | None = None, obj_id_to_tracker_score: dict[int, float] | None = None, removed_obj_ids: set[int] | None = None, suppressed_obj_ids: set[int] | None = None, frame_idx: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L462)

**Parametreler:**

object_ids (`list[int]`, *isteğe bağlı*) : Mevcut karede izlenen nesne kimliklerinin listesi.

obj_id_to_mask (`dict[int, torch.Tensor]`, *isteğe bağlı*) : Nesne kimliklerini tahmin edilen düşük çözünürlüklü maskelerine eşleyen sözlük. Her maskenin şekli `(1, H_low, W_low)`'dir.

obj_id_to_score (`dict[int, float]`, *isteğe bağlı*) : Nesne kimliklerini algılama puanlarına eşleyen sözlük.

obj_id_to_tracker_score (`dict[int, float]`, *isteğe bağlı*) : Mevcut karede nesne kimliklerini, izleyici puanlarına eşleyen sözlük.

removed_obj_ids (`set[int]`, *isteğe bağlı*) : Kaldırılmış nesit kimliklerinin kümesi (ör. hotstart sezgiselleri yoluyla).

suppressed_obj_ids (`set[int]`, *isteğe bağlı*) : Geçerli çerçevede bastırılmış nesne kimliklerinin kümesi.

frame_idx (`int`, *isteğe bağlı*) : Videoyun kare indeksi.

Sam3Video modelinin çıktısı için temel sınıf.

## Sam3VideoModel[[transformers.Sam3VideoModel]]

#### transformers.Sam3VideoModel[[transformers.Sam3VideoModel]]

```python
transformers.Sam3VideoModel(config: Sam3VideoConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L507)

**Parametreler:**

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

Üzerinde herhangi bir özel head bulunmayan, ham hidden-states üreten çıplak Sam3 Video Model.

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

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

#### forward[[transformers.Sam3VideoModel.forward]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L1693)

**Parametreler:**

inference_session (`~models.sam3_video.modeling_sam3_video.Sam3VideoInferenceSession`) : 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ı?

Nesneleri, akışkan video karesi boyunca ilerletin.

#### propagate_in_video_iterator[[transformers.Sam3VideoModel.propagate_in_video_iterator]]

```python
propagate_in_video_iterator(inference_session: Sam3VideoInferenceSession, start_frame_idx: int = 0, max_frame_num_to_track: int | None = None, reverse: bool = False, show_progress_bar: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_video/modeling_sam3_video.py#L1784)

**Parametreler:**

inference_session (`~models.sam3_video.modeling_sam3_video.Sam3VideoInferenceSession`) : Video çıkarım oturumu nesnesi.

start_frame_idx (`int`, *isteğe bağlı*, varsayılan `0`) : Yayılım için başlangıç kare indeksi.

max_frame_num_to_track (`int`, *isteğe bağlı*) : Takip edilecek maksimum kare sayısı. Verilmezse, videodaki tüm kareler takip edilir.

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

show_progress_bar (`bool`, *isteğe bağlı*, varsayılan `False`) : Yayılma sırasında bir ilerleme çubuğu gösterilip gösterilmeyeceği.

**Dönüş:** [Sam3VideoSegmentationOutput](/docs/transformers/main/tr/model_doc/sam3_video#transformers.Sam3VideoSegmentationOutput) veya `tuple(torch.Tensor)`

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

Tüm video için yerelleştirme sonuçlarını almak üzere istemleri yaydırır. Tüm bir video ile çıkarım oturumu başlatılırken kullanılır. Her kare için Sam3VideoSegmentationOutput üretir.

- **object_ids** (`list[int]`, *isteğe bağlı*) -- Mevcut karede izlenen nesne kimliklerinin listesi.
- **obj_id_to_mask** (`dict[int, torch.Tensor]`, *isteğe bağlı*) -- Nesne kimliklerini tahmin edilen düşük çözünürlüklü maskelerine eşleyen sözlük. Her maskenin şekli `(1, H_low, W_low)`'dur.
- **obj_id_to_score** (`dict[int, float]`, *isteğe bağlı*) -- Nesne kimliklerini algılama puanlarına eşleyen sözlük.
- **obj_id_to_tracker_score** (`dict[int, float]`, *isteğe bağlı*) -- Mevcut karede nesne kimliklerini takipçi puanlarına eşleyen sözlük.
- **removed_obj_ids** (`set[int]`, *isteğe bağlı*) -- Kaldırılmış nesit kimliklerinin kümesi (ör. hotstart sezgiselleri yoluyla).
- **suppressed_obj_ids** (`set[int]`, *isteğe bağlı*) -- Geçerli çerçevede bastırılmış nesne kimliklerinin kümesi.
- **frame_idx** (`int`, *isteğe bağlı*) -- Videoyun kare indeksi.