# Pelacak Video SAM3

    
        
        
    

## Ikhtisar

SAM3 (Segment Anything Model 3) diperkenalkan dalam [SAM 3: Segment Anything with Concepts](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/).

Sam3TrackerVideo melakukan **Promptable Visual Segmentation (PVS)** pada video. PVS menerima prompt visual interaktif (titik, kotak, mask) atau input teks untuk melacak **instans objek tertentu** per prompt di seluruh frame video.

Sam3TrackerVideo adalah versi pembaruan dari SAM2 Video yang mempertahankan API yang sama sambil menyediakan kinerja dan kemampuan yang lebih baik.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami memperkenalkan Segment Anything Model (SAM) 3, sebuah model terpadu yang mendeteksi, memsegmentasi, dan melacak objek dalam gambar dan video berdasarkan prompt konsep, yang kami definisikan sebagai frasa nomina pendek (misalnya, "yellow school bus"), contoh gambar, atau kombinasi keduanya. Promptable Concept Segmentation (PCS) mengambil prompt semacam itu dan mengembalikan mask segmentasi serta identitas unik untuk semua instans objek yang cocok. Untuk memajukan PCS, kami membangun mesin data yang dapat diskalakan yang menghasilkan dataset berkualitas tinggi dengan 4 juta label konsep unik, termasuk negatif yang sulit, di seluruh gambar dan video. Model kami terdiri dari detektor tingkat gambar dan pelacak video berbasis memori yang berbagi satu backbone tunggal. Pengenalan dan lokalisasi dipisahkan dengan presence head, yang meningkatkan akurasi deteksi. SAM 3 menggandakan akurasi sistem yang ada dalam PCS gambar dan video, serta meningkatkan kemampuan SAM sebelumnya pada tugas segmentasi visual. Kami membuka sumber SAM 3 bersama dengan benchmark baru kami, Segment Anything with Concepts (SA-Co), untuk segmentasi konsep yang dapat diprompt.*

Model ini disumbangkan oleh [yonigozlan](https://huggingface.co/yonigozlan) dan [ronghanghu](https://huggingface.co/ronghanghu).

## Contoh penggunaan

### Segmentasi dan Pelacakan Video

#### Pelacakan Video Dasar

```python
from transformers import Sam3TrackerVideoModel, Sam3TrackerVideoProcessor
import torch

model = Sam3TrackerVideoModel.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3TrackerVideoProcessor.from_pretrained("facebook/sam3")

# 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 (optional, you can also propagate the masks through the video directly)
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, 480, 854])

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

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

#### Pelacakan Video Multi-Objek

Lacak beberapa objek secara bersamaan di antara bingkai video:

```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 (optional, you can also propagate the masks through the video directly)
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)

# Propagate both objects through video
video_segments = {}
for sam3_tracker_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam3_tracker_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 180 frames
```

#### Menyempurnakan Segmentasi Video

Anda dapat menambahkan klik tambahan pada frame mana pun untuk menyempurnakan pelacakan:

```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 sam3_tracker_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam3_tracker_video_output.frame_idx] = video_res_masks
```

### Inferensi Video Streaming

Untuk aplikasi real-time, Sam3TrackerVideo mendukung pemrosesan bingkai video saat bingkai tersebut tiba:

```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
    sam3_tracker_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0])
...
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False
    )[0]
    print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}")
```

#### Pemrosesan Batch Video untuk Beberapa Objek

Lacak beberapa objek secara bersamaan dalam video dengan menambahkan semuanya sekaligus:

```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 sam3_tracker_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam3_tracker_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 180 frames
```

## Sam3TrackerVideoConfig[[transformers.Sam3TrackerVideoConfig]]

#### transformers.Sam3TrackerVideoConfig[[transformers.Sam3TrackerVideoConfig]]

```python
transformers.Sam3TrackerVideoConfig(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, 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 = 4, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 4, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_feed_forward_hidden_size: int = 2048, memory_attention_feed_forward_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list | None = None, memory_attention_rope_dropout: float | int = 0.1, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, rope_parameters: dict | None = None, mask_downsampler_embed_dim: int = 256, 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_intermediate_dim: int = 1024, 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')
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/configuration_sam3_tracker_video.py#L99)

**Parameter:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari vision backbone.

prompt_encoder_config (Union[`dict`, `Sam3TrackerVideoPromptEncoderConfig`], *opsional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [Sam3TrackerVideoPromptEncoderConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `Sam3TrackerVideoMaskDecoderConfig`], *optional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [Sam3TrackerVideoMaskDecoderConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoMaskDecoderConfig).

initializer_range (`float`, *opsional*, default 0.02) : Standar deviasi untuk inisialisasi parameter.

num_maskmem (`int`, *opsional*, defaultnya 7) : Jumlah slot memori untuk memori mask.

sigmoid_scale_for_mem_enc (`float`, *opsional*, default 20.0) : Faktor skala untuk fungsi sigmoid dalam memory encoder.

sigmoid_bias_for_mem_enc (`float`, *opsional*, default -10.0) : Bias untuk fungsi sigmoid dalam memory encoder.

enable_occlusion_spatial_embedding (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengaktifkan spatial embedding untuk oklusi.

multimask_output_in_sam (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengoutputkan beberapa mask dari kepala SAM.

multimask_min_pt_num (`int`, *opsional*, default 0) : Jumlah minimum titik untuk memicu output multimask.

multimask_max_pt_num (`int`, *opsional*, default 1) : Jumlah maksimum titik untuk memicu output multimask.

multimask_output_for_tracking (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan output multimask untuk pelacakan.

max_object_pointers_in_encoder (`int`, *opsional*, defaultnya 16) : Jumlah maksimum pointer objek dalam encoder.

max_cond_frame_num (`int`, *opsional*, default 4) : Jumlah maksimum frame kondisioning yang digunakan dalam memori perhatian.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengaktifkan pengkodean posisi temporal untuk penunjuk objek.

memory_attention_hidden_size (`int`, *opsional*, default 256) : Dimensi dari hidden states memori attention.

memory_attention_num_layers (`int`, *opsional*, defaultnya 4) : Jumlah lapisan dalam modul perhatian memori.

memory_attention_num_attention_heads (`int`, *opsional*, default 1) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam perhatian memori.

memory_attention_downsample_rate (`int`, *opsional*, default 1) : Tingkat downsampling untuk lapisan attention.

memory_attention_feed_forward_hidden_size (`int`, *opsional*, defaultnya 2048) : Dimensi dari jaringan feedforward dalam modul perhatian memori.

memory_attention_feed_forward_hidden_act (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi non-linear dalam jaringan feedforward di modul perhatian memori.

memory_attention_dropout (`float`, *opsional*, default 0.1) : Tingkat dropout untuk modul perhatian memori.

memory_attention_rope_feat_sizes (`list[int]`, *opsional*, defaultnya `[72, 72]`) : Ukuran fitur untuk encoding posisi Rope.

memory_attention_rope_dropout (`float`, *opsional*, default 0.1) : Tingkat dropout untuk pengkodean posisi Rope.

memory_encoder_hidden_size (`int`, *opsional*, default 256) : Dimensi dari hidden states encoder memori.

memory_encoder_output_channels (`int`, *opsional*, defaultnya 64) : Jumlah kanal output untuk encoder memori.

rope_parameters (`dict`, *opsional*) : Kamus yang berisi parameter konfigurasi untuk embedding RoPE. Kamus ini harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk penskalaan jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang.

mask_downsampler_embed_dim (`int`, *opsional*, default 256) : Dimensi dari embedding downsampler mask.

mask_downsampler_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel untuk downsampler mask.

mask_downsampler_stride (`int`, *opsional*, defaultnya 2) : Stride untuk downsampler mask.

mask_downsampler_padding (`int`, *opsional*, default 1) : Padding untuk downsampler mask.

mask_downsampler_total_stride (`int`, *opsional*, default 16) : Total stride untuk downsampler mask.

mask_downsampler_hidden_act (`str`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi non-linear dalam mask downsampler.

memory_fuser_num_layers (`int`, *opsional*, defaultnya 2) : Jumlah lapisan dalam memory fuser.

memory_fuser_embed_dim (`int`, *opsional*, defaultnya 256) : Dimensi dari lapisan embedding dalam memory fuser.

memory_fuser_intermediate_dim (`int`, *opsional*, default 1024) : Dimensi dari lapisan perantara dalam memory fuser.

memory_fuser_kernel_size (`int`, *opsional*, defaultnya 7) : Ukuran kernel untuk memory fuser.

memory_fuser_padding (`int`, *opsional*, defaultnya 3) : Padding untuk memory fuser.

memory_fuser_layer_scale_init_value (`float`, *opsional*, default 1e-06) : Nilai awal untuk layer scale di memory fuser.

memory_fuser_hidden_act (`str`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi non-linear dalam memory fuser.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam3TrackerVideoModel. Kelas ini digunakan untuk membuat instans model Sam3 Tracker Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/sam3](https://huggingface.co/facebook/sam3)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```python
>>> from transformers import (
...     Sam3VisionConfig,
...     Sam3TrackerVideoPromptEncoderConfig,
...     Sam3TrackerVideoMaskDecoderConfig,
...     Sam3TrackerVideoModel,
... )

>>> # Initializing a Sam3TrackerVideoConfig with `"facebook/sam3"` style configuration
>>> configuration = Sam3TrackerVideoConfig()

>>> # Initializing a Sam3TrackerVideoModel (with random weights) from the `"facebook/sam3"` style configuration
>>> model = Sam3TrackerVideoModel(configuration)

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

>>> # We can also initialize a Sam3TrackerVideoConfig from a Sam3TrackerVideoVisionConfig, Sam3TrackerVideoPromptEncoderConfig, and Sam3TrackerVideoMaskDecoderConfig

>>> # Initializing SAM3 tracker video vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam3TrackerVideoVisionConfig()
>>> prompt_encoder_config = Sam3TrackerVideoPromptEncoderConfig()
>>> mask_decoder_config = Sam3TrackerVideoMaskDecoderConfig()

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

## Sam3TrackerVideoMaskDecoderConfig[[transformers.Sam3TrackerVideoMaskDecoderConfig]]

#### transformers.Sam3TrackerVideoMaskDecoderConfig[[transformers.Sam3TrackerVideoMaskDecoderConfig]]

```python
transformers.Sam3TrackerVideoMaskDecoderConfig(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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/configuration_sam3_tracker_video.py#L60)

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

mlp_dim (`int`, *opsional*, defaultnya 2048) : Dimensi dari MLP dalam transformer dua arah.

num_hidden_layers (`int`, *opsional*, defaultnya `2`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

attention_downsample_rate (`int`, *opsional*, defaultnya 2) : Laju downsampling untuk lapisan attention.

num_multimask_outputs (`int`, *opsional*, defaultnya 3) : Jumlah output multimask.

iou_head_depth (`int`, *opsional*, defaultnya 3) : Kedalaman dari kepala IoU.

iou_head_hidden_dim (`int`, *opsional*, default 256) : Dimensi tersembunyi dari kepala IoU.

dynamic_multimask_via_stability (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan multimask dinamis melalui stabilitas.

dynamic_multimask_stability_delta (`float`, *opsional*, default 0.05) : Delta stabilitas untuk multimask dinamis.

dynamic_multimask_stability_thresh (`float`, *opsional*, default 0.98) : Ambang batas stabilitas untuk multimask dinamis.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam3TrackerVideoModel. Kelas ini digunakan untuk membuat instans model Sam3 Tracker Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/sam3](https://huggingface.co/facebook/sam3)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## Sam3TrackerVideoPromptEncoderConfig[[transformers.Sam3TrackerVideoPromptEncoderConfig]]

#### transformers.Sam3TrackerVideoPromptEncoderConfig[[transformers.Sam3TrackerVideoPromptEncoderConfig]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/configuration_sam3_tracker_video.py#L34)

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `1008`) : Ukuran (resolusi) dari setiap gambar.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `14`) : Ukuran (resolusi) dari setiap patch.

mask_input_channels (`int`, *opsional*, default 16) : Jumlah channel yang akan diberikan ke modul `MaskDecoder`.

num_point_embeddings (`int`, *opsional*, defaultnya 4) : Jumlah point embedding yang akan digunakan.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

scale (`float`, *opsional*, default 1) : Faktor skala untuk prompt encoder.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam3TrackerVideoModel. Kelas ini digunakan untuk membuat instans model Sam3 Tracker Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/sam3](https://huggingface.co/facebook/sam3)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## Sam3TrackerVideoProcessor[[transformers.Sam3TrackerVideoProcessor]]

#### transformers.Sam3TrackerVideoProcessor[[transformers.Sam3TrackerVideoProcessor]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L39)

**Parameter:**

image_processor (`Sam3ImageProcessor`) : Prosesor gambar adalah input yang wajib.

video_processor (`video_processor_class`) : Prosesor video adalah input yang wajib.

target_size (`int`, *opsional*) : Ukuran target (dalam piksel) untuk menormalisasi titik dan kotak batas input. Jika tidak disediakan, secara default menggunakan konfigurasi ukuran dari image processor. Semua koordinat input (titik dan kotak) dinormalisasi ke ukuran ini sebelum diteruskan ke model. Hal ini memastikan representasi koordinat yang konsisten terlepas dari dimensi gambar asli.

point_pad_value (`int`, *opsional*, defaultnya -10) : Nilai yang digunakan untuk mengisi titik input saat pengelompokan (batching) sekuens dengan panjang berbeda. Nilai ini digunakan untuk menandai posisi yang di-*padding* dan dipertahankan selama normalisasi koordinat.

Membangun Sam3TrackerVideoProcessor yang membungkus image processor dan video processor menjadi satu processor tunggal.

[Sam3TrackerVideoProcessor](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoProcessor) menyediakan semua fungsionalitas dari [Sam3ImageProcessor](/docs/transformers/v5.23.0/id/model_doc/sam3#transformers.Sam3ImageProcessor) dan `video_processor_class`. Lihat [~Sam3ImageProcessor](/docs/transformers/v5.23.0/id/model_doc/sam3#transformers.Sam3ImageProcessor) dan `~video_processor_class` untuk informasi lebih lanjut.

#### __call__[[transformers.Sam3TrackerVideoProcessor.__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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L57)

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opsional*) : Gambar untuk dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

segmentation_maps (`ImageInput`, *opsional*) : Peta segmentasi yang akan diproses.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opsional*) : Titik-titik yang akan ditambahkan ke frame.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opsional*) : Label untuk titik-titik.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opsional*) : Kotak pembatas yang akan ditambahkan ke bingkai.

original_sizes (`list[list[float]]`, `torch.Tensor`, *opsional*) : Ukuran asli dari gambar-gambar tersebut.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek PyTorch `torch.Tensor`. - `'np'`: Mengembalikan objek NumPy `np.ndarray`.

**Mengembalikan:** Sebuah [BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding) dengan field berikut

- `pixel_values` (`torch.Tensor`): Gambar yang telah diproses.
- `original_sizes` (`list[list[float]]`): Ukuran asli dari gambar-gambar tersebut.
- `labels` (`torch.Tensor`): Peta segmentasi yang telah diproses (jika disediakan).
- `input_points` (`torch.Tensor`): Titik-titik yang telah diproses.
- `input_labels` (`torch.Tensor`): Label yang telah diproses.
- `input_boxes` (`torch.Tensor`): Kotak pembatas yang telah diproses.

#### post_process_masks[[transformers.Sam3TrackerVideoProcessor.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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L463)

**Parameter:**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Mask yang di-batch dari mask_decoder dalam format (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Ukuran asli setiap gambar sebelum di-resize ke bentuk input yang diharapkan oleh model, dalam format (tinggi, lebar).

mask_threshold (`float`, *opsional*, default 0.0) : Ambang batas untuk operasi binarisasi dan pascaproses.

binarize (`bool`, *opsional*, defaultnya `True`) : Apakah akan mbinerisasi mask.

max_hole_area (`float`, *opsional*, default 0.0) : Area maksimum lubang yang akan diisi.

max_sprinkle_area (`float`, *opsional*, default 0.0) : Area maksimum sprinkle untuk diisi.

apply_non_overlapping_constraints (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan kendala non-tumpang tindih pada masker.

**Mengembalikan:** (`torch.Tensor`)

Mask yang di-batch dalam format batch_size, num_channels, height, width, di mana (height, width) ditentukan oleh original_size.

Hapus padding dan upscale mask ke ukuran gambar asli.

#### init_video_session[[transformers.Sam3TrackerVideoProcessor.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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L514)

**Parameter:**

video (`VideoInput`, *opsional*) : Video yang akan diproses. Tidak perlu disediakan saat streaming.

inference_device (`str` atau `torch.device`, *opsional*, defaultnya "cpu") : Perangkat yang akan digunakan untuk inferensi.

inference_state_device (`str` atau `torch.device`, *opsional*) : Perangkat untuk menyimpan state inferensi.

processing_device (`str` atau `torch.device`, *opsional*) : Perangkat yang akan digunakan untuk pemrosesan video.

video_storage_device (`str` atau `torch.device`, *opsional*) : Perangkat untuk menyimpan bingkai video yang telah diproses.

max_vision_features_cache_size (`int`, *opsional*, default 1) : Jumlah maksimum fitur visual yang akan di-cache.

dtype (`torch.dtype`, *opsional*, defaultnya `torch.float32`) : dtype torch yang akan digunakan untuk seluruh sesi.

Menginisialisasi sesi video untuk inferensi. Jika video disediakan (inferensi asinkron), video akan diproses dan disimpan di `video_storage_device`.

#### add_inputs_to_inference_session[[transformers.Sam3TrackerVideoProcessor.add_inputs_to_inference_session]]

```python
add_inputs_to_inference_session(inference_session: Sam3TrackerVideoInferenceSession, frame_idx: int, obj_ids: list[int] | int, 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, input_masks: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], NoneType] = None, original_size: tuple[int, int] | None = None, clear_old_inputs: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L567)

**Parameter:**

inference_session (`Sam3TrackerVideoInferenceSession`) : Sesi inferensi untuk video.

frame_idx (`int`) : Indeks dari frame yang akan diproses.

obj_ids (`list[int]` atau `int`) : ID objek yang akan dikaitkan dengan titik atau kotak. Nilai ini dapat berupa bilangan bulat apa pun dan dapat digunakan kembali di kemudian hari untuk menentukan sebuah objek.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opsional*) : Titik-titik yang akan ditambahkan ke frame.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opsional*) : Label untuk titik-titik.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opsional*) : Kotak pembatas yang akan ditambahkan ke bingkai.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, atau `list[torch.Tensor]`, *opsional*) : Masker yang akan ditambahkan ke frame.

original_size (`tuple[int, int]`, *opsional*) : Ukuran asli video. Berikan saat streaming.

clear_old_inputs (`bool`, *opsional*, defaultnya `True`) : Apakah akan membersihkan input lama untuk objek tersebut.

Proses titik, kotak, atau mask baru untuk bingkai video dan tambahkan ke sesi inferensi.

## Sam3TrackerVideoInferenceSession[[transformers.Sam3TrackerVideoInferenceSession]]

#### transformers.Sam3TrackerVideoInferenceSession[[transformers.Sam3TrackerVideoInferenceSession]]

```python
transformers.Sam3TrackerVideoInferenceSession(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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L109)

**Parameter:**

video (`torch.Tensor`, *opsional*) : Video yang akan diproses. Tidak perlu disediakan saat streaming.

video_height (`int`, *opsional*) : Tinggi video.

video_width (`int`, *opsional*) : Lebar video.

inference_device (`torch.device`, *opsional*, default `"cpu"`) : Perangkat yang akan digunakan untuk inferensi.

inference_state_device (`torch.device`, *opsional*, defaultnya `"cpu"`) : Perangkat untuk menyimpan state inferensi.

video_storage_device (`torch.device`, *opsional*, defaultnya `"cpu"`) : Perangkat untuk menyimpan video.

dtype (`torch.dtype`, *opsional*, defaultnya `"float32"`) : dtype yang akan digunakan untuk video.

max_vision_features_cache_size (`int`, *opsional*, default 1) : Jumlah maksimum fitur visual yang akan di-cache.

Mengelola parameter, status, dan cache sesi inferensi video.

#### add_mask_inputs[[transformers.Sam3TrackerVideoInferenceSession.add_mask_inputs]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L229)

Tambahkan input mask dengan penempatan perangkat otomatis.

#### add_new_frame[[transformers.Sam3TrackerVideoInferenceSession.add_new_frame]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L304)

Tambahkan frame baru dengan penempatan perangkat otomatis.

#### add_point_inputs[[transformers.Sam3TrackerVideoInferenceSession.add_point_inputs]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L215)

Tambahkan input titik dengan penempatan perangkat otomatis.

#### get_frame[[transformers.Sam3TrackerVideoInferenceSession.get_frame]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L320)

Ambil frame dari video.

#### get_obj_num[[transformers.Sam3TrackerVideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L210)

Dapatkan jumlah total id objek unik yang diterima sejauh ini dalam sesi ini.

#### get_output[[transformers.Sam3TrackerVideoInferenceSession.get_output]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L277)

**Parameter:**

obj_idx (int) : Indeks dari objek.

frame_idx (int) : Indeks dari frame.

output_key (str) : Kunci dari output.

is_conditioning_frame (bool) : Apakah output tersebut untuk frame kondisioning.

Dapatkan output dengan manajemen perangkat pintar.

#### obj_id_to_idx[[transformers.Sam3TrackerVideoInferenceSession.obj_id_to_idx]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L184)

Petakan ID objek ke indeks, buat entri baru jika diperlukan.

#### obj_idx_to_id[[transformers.Sam3TrackerVideoInferenceSession.obj_idx_to_id]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L206)

Petakan indeks objek sisi model ke id objek sisi klien.

#### remove_mask_inputs[[transformers.Sam3TrackerVideoInferenceSession.remove_mask_inputs]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L235)

Hapus input mask.

#### remove_point_inputs[[transformers.Sam3TrackerVideoInferenceSession.remove_point_inputs]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L225)

Hapus input titik.

#### reset_inference_session[[transformers.Sam3TrackerVideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L336)

Reset data pelacakan dan cache.

#### reset_tracking_data[[transformers.Sam3TrackerVideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L324)

Reset data pelacakan tetapi pertahankan cache.

#### store_output[[transformers.Sam3TrackerVideoInferenceSession.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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L240)

**Parameter:**

obj_idx (int) : Indeks dari objek.

frame_idx (int) : Indeks dari frame.

output_key (Optional[str]) : Kunci dari output. Jika None, output disimpan sebagai kamus.

output_value (Optional[Union[torch.Tensor, dict]]) : Nilai dari output.

is_conditioning_frame (bool) : Apakah output tersebut untuk frame kondisioning.

Simpan output dengan manajemen perangkat yang cerdas. Jika output_key adalah None, output disimpan sebagai kamus.

## Sam3TrackerVideoModel[[transformers.Sam3TrackerVideoModel]]

#### transformers.Sam3TrackerVideoModel[[transformers.Sam3TrackerVideoModel]]

```python
transformers.Sam3TrackerVideoModel(config: Sam3TrackerVideoConfig, remove_vision_encoder: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L1647)

**Parameter:**

config ([Sam3TrackerVideoConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

remove_vision_encoder (`bool`, *opsional*, defaultnya `False`) : Apakah akan menghapus vision encoder. Jika True, vision encoder akan diatur ke None.

Model Pelacak Video Sam3 polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.Sam3TrackerVideoModel.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L1789)

**Parameter:**

inference_session (`~models.sam3_tracker_video.modeling_sam3_tracker_video.Sam3TrackerVideoInferenceSession`) : Objek sesi inferensi video.

frame_idx (`int`, *opsional*) : Indeks dari frame tempat inferensi dijalankan. Tidak perlu disediakan saat melakukan inferensi pada frame streaming baru.

frame (`torch.Tensor`, *opsional*) : Frame yang akan diproses. Berikan saat streaming.

reverse (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan propagasi secara terbalik.

run_mem_encoder (`bool`, *opsional*, defaultnya `True`) : Apakah akan menjalankan memory encoder pada mask yang diprediksi. Memory encoder di-batch di seluruh objek untuk efisiensi.

**Mengembalikan:** `Sam3TrackerVideoSegmentationOutput` atau `tuple(torch.Tensor)`

Sebuah `Sam3TrackerVideoSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Sam3TrackerVideoConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) dan input.

Propagasi objek melalui bingkai video yang dialirkan.

- **object_ids** (`list[int]`, *opsional*) -- Daftar ID objek yang dilacak pada frame saat ini.
- **pred_masks** (`torch.Tensor` dengan bentuk `(batch_size, num_masks, height, width)`) -- Mask yang diprediksi dan disimpan pada resolusi model.
- **object_score_logits** (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*) -- Logits untuk skor objek, yang menunjukkan apakah objek ada.
- **frame_idx** (`int`, *opsional*) -- Indeks frame dari video.

#### propagate_in_video_iterator[[transformers.Sam3TrackerVideoModel.propagate_in_video_iterator]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L2812)

**Parameter:**

inference_session (`~models.sam3_tracker_video.modeling_sam3_tracker_video.Sam3TrackerVideoInferenceSession`) : Objek sesi inferensi video.

start_frame_idx (`int`, *opsional*) : Indeks frame awal untuk propagasi. Harus disediakan jika `forward` belum dipanggil pada input baru. Jika tidak disediakan, indeks frame awal akan menjadi frame terawal yang memiliki titik input.

max_frame_num_to_track (`int`, *opsional*) : Jumlah maksimum frame yang akan dilacak.

reverse (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan propagasi secara terbalik.

show_progress_bar (`bool`, *opsional*, defaultnya `False`) : Apakah akan menampilkan bilah kemajuan selama propagasi.

**Mengembalikan:** `Sam3TrackerVideoSegmentationOutput` atau `tuple(torch.Tensor)`

Sebuah `Sam3TrackerVideoSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Sam3TrackerVideoConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) dan input.

Propagasi objek melalui bingkai video. Digunakan saat menginisialisasi sesi inferensi dengan seluruh video. Menghasilkan Sam3TrackerVideoSegmentationOutput untuk setiap bingkai.

- **object_ids** (`list[int]`, *opsional*) -- Daftar ID objek yang dilacak pada frame saat ini.
- **pred_masks** (`torch.Tensor` dengan bentuk `(batch_size, num_masks, height, width)`) -- Mask yang diprediksi dan disimpan pada resolusi model.
- **object_score_logits** (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*) -- Logits untuk skor objek, yang menunjukkan apakah objek ada.
- **frame_idx** (`int`, *opsional*) -- Indeks frame dari video.

#### get_image_features[[transformers.Sam3TrackerVideoModel.get_image_features]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L1914)

**Parameter:**

pixel_values (`torch.Tensor`) : Nilai piksel input dengan bentuk `(batch_size, num_channels, height, width)`.

**Mengembalikan:** `Sam3TrackerVideoVisionEncoderOutput` atau `tuple(torch.Tensor)`

Sebuah `Sam3TrackerVideoVisionEncoderOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Sam3TrackerVideoConfig](/docs/transformers/v5.23.0/id/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) dan input.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, height, width, hidden_size)`) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tuple dari `torch.Tensor` (satu untuk setiap level fitur, dari resolusi tinggi ke rendah) dengan bentuk `(batch_size, hidden_size, height, width)`. Peta fitur dari leher Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tuple dari `torch.Tensor` (satu untuk setiap level fitur, dari resolusi tinggi ke rendah) dengan bentuk `(batch_size, hidden_size, height, width)`. Positional encoding yang sesuai dengan `fpn_hidden_states`.

