Hugging Face's logo

Transformers documentation

SAM2 Video

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Model ini disumbangkan ke Hugging Face Transformers pada 2025-08-14.

SAM2 Video

SDPA FlashAttention

Ikhtisar

SAM2 (Segment Anything Model 2) diusulkan dalam Segment Anything in Images and Videos oleh Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer.

Model ini dapat digunakan untuk memprediksi mask segmentasi dari objek apa pun yang menjadi perhatian, dengan diberikan gambar atau video sebagai input, serta titik atau kotak batas sebagai input.

example image

Abstrak dari makalah tersebut adalah sebagai berikut:

Kami memperkenalkan Segment Anything Model 2 (SAM 2), sebuah model fondasi untuk menyelesaikan pemisahan visual yang dapat dipromptkan pada gambar dan video. Kami membangun mesin data, yang meningkatkan model dan data melalui interaksi pengguna, untuk mengumpulkan dataset pemisahan video terbesar hingga saat ini. Model kami adalah arsitektur transformer sederhana dengan memori streaming untuk pemrosesan video real-time. SAM 2 yang dilatih pada data kami memberikan kinerja yang kuat di berbagai tugas. Dalam pemisahan video, kami mengamati akurasi yang lebih baik, menggunakan 3x lebih sedikit interaksi dibandingkan pendekatan sebelumnya. Dalam pemisahan gambar, model kami lebih akurat dan 6x lebih cepat daripada Segment Anything Model (SAM). Kami percaya bahwa data, model, dan wawasan kami akan menjadi tonggak penting untuk pemisahan video dan tugas persepsi terkait. Kami merilis versi model kami, dataset, dan demo interaktif.

Tips:

  • Dukungan Batch & Video: SAM2 secara native mendukung pemrosesan batch dan segmentasi video yang mulus, sedangkan SAM asli dirancang untuk gambar statis dan alur kerja yang lebih sederhana, yaitu satu gambar pada satu waktu.
  • Akurasi & Generalisasi: SAM2 menunjukkan kualitas segmentasi, ketangguhan, dan generalisasi zero-shot ke domain baru yang lebih baik dibandingkan SAM asli, terutama dengan prompt campuran.

Model ini disumbangkan oleh sangbumchoi dan yonigozlan. Kode aslinya dapat ditemukan di sini.

Contoh penggunaan

Segmentasi dan Pelacakan Video

Kekuatan utama SAM2 adalah kemampuannya untuk melacak objek di antara bingkai video. Berikut cara menggunakannya untuk segmentasi video:

Pelacakan Video Dasar

from transformers import Sam2VideoModel, Sam2VideoProcessor
import torch

model = Sam2VideoModel.from_pretrained("facebook/sam2.1-hiera-tiny", device_map="auto")
processor = Sam2VideoProcessor.from_pretrained("facebook/sam2.1-hiera-tiny")

# 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, 480, 854])

# 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 180 frames

Pelacakan Video Multi-Objek

Lacak beberapa objek secara bersamaan di antara bingkai video:

# 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 180 frames

Menyempurnakan Segmentasi Video

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

# 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

Inferensi Video Streaming

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

# 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}")

Pemrosesan Batch Video untuk Beberapa Objek

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

# 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 180 frames

Sumber daya

Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan SAM.

Sam2VideoConfig

kelas transformers.Sam2VideoConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonemask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02num_maskmem: int = 7image_size: int | list[int] | tuple[int, int] = 1024sigmoid_scale_for_mem_enc: float = 20.0sigmoid_bias_for_mem_enc: float = -10.0enable_occlusion_spatial_embedding: bool = Truemultimask_output_in_sam: bool = Truemultimask_min_pt_num: int = 0multimask_max_pt_num: int = 1multimask_output_for_tracking: bool = Truemax_object_pointers_in_encoder: int = 16max_cond_frame_num: int = -1enable_temporal_pos_encoding_for_object_pointers: bool = Truememory_attention_hidden_size: int = 256memory_attention_num_layers: int = 4memory_attention_num_attention_heads: int = 1memory_attention_downsample_rate: int = 1memory_attention_feed_forward_hidden_size: int = 2048memory_attention_feed_forward_hidden_act: str = 'relu'memory_attention_dropout: float | int = 0.1memory_attention_rope_feat_sizes: list[int] | None = Nonememory_attention_rope_dropout: float | int = 0.1memory_encoder_hidden_size: int = 256memory_encoder_output_channels: int = 64rope_parameters: dict | None = Nonemask_downsampler_embed_dim: int = 256mask_downsampler_kernel_size: int = 3mask_downsampler_stride: int = 2mask_downsampler_padding: int = 1mask_downsampler_total_stride: int = 16mask_downsampler_hidden_act: str = 'gelu'memory_fuser_num_layers: int = 2memory_fuser_embed_dim: int = 256memory_fuser_intermediate_dim: int = 1024memory_fuser_kernel_size: int = 7memory_fuser_padding: int = 3memory_fuser_layer_scale_init_value: float = 1e-06memory_fuser_hidden_act: str = 'gelu' )

Parameter

  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari vision backbone.
  • prompt_encoder_config (Union[dict, Sam2PromptEncoderConfig], opsional) — Kamus opsi konfigurasi yang digunakan untuk menginisialisasi Sam2PromptEncoderConfig.
  • mask_decoder_config (Union[dict, Sam2MaskDecoderConfig], opsional) — Kamus opsi konfigurasi yang digunakan untuk menginisialisasi Sam2MaskDecoderConfig.
  • initializer_range (float, opsional, default 0.02) — Deviasi standar untuk inisialisasi parameter.
  • num_maskmem (int, opsional, defaultnya 7) — Jumlah slot memori untuk memori mask.
  • image_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 1024) — Ukuran (resolusi) dari setiap gambar.
  • 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, default True) — Apakah akan mengaktifkan spatial embedding untuk oklusi.
  • multimask_output_in_sam (bool, opsional, default True) — Apakah akan mengoutputkan beberapa mask dari head 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 -1) — Jumlah maksimum frame conditioning yang digunakan dalam memori attention. Atur ke -1 untuk menggunakan semua frame conditioning.
  • enable_temporal_pos_encoding_for_object_pointers (bool, opsional, default True) — Apakah akan mengaktifkan temporal positional encoding untuk object pointers.
  • memory_attention_hidden_size (int, opsional, default 256) — Dimensi dari hidden states memori attention.
  • memory_attention_num_layers (int, opsional, default 4) — Jumlah lapisan dalam modul memory attention.
  • memory_attention_num_attention_heads (int, opsional, default 1) — Jumlah attention head untuk setiap lapisan attention dalam memory attention.
  • memory_attention_downsample_rate (int, opsional, default 1) — Laju downsample untuk lapisan attention.
  • memory_attention_feed_forward_hidden_size (int, opsional, default 2048) — Dimensi dari jaringan feedforward dalam modul memory attention.
  • memory_attention_feed_forward_hidden_act (str, opsional, default "relu") — Fungsi aktivasi non-linear pada jaringan feedforward di dalam modul memory attention.
  • memory_attention_dropout (float, opsional, default 0.1) — Tingkat dropout untuk modul memory attention.
  • memory_attention_rope_feat_sizes (list[int], opsional, default [64, 64]) — 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 memory encoder.
  • memory_encoder_output_channels (int, opsional, defaultnya 64) — Jumlah saluran keluar untuk memory encoder.
  • rope_parameters (dict, opsional) — Kamus yang berisi parameter konfigurasi untuk embedding RoPE. Kamus tersebut 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 mask downsampler.
  • mask_downsampler_kernel_size (int, opsional, default 3) — Ukuran kernel untuk downsampler mask.
  • mask_downsampler_stride (int, opsional, defaultnya 2) — Stride untuk mask downsampler.
  • mask_downsampler_padding (int, opsional, defaultnya 1) — Padding untuk mask downsampler.
  • mask_downsampler_total_stride (int, opsional, default 16) — Stride total untuk mask downsampler.
  • mask_downsampler_hidden_act (str, opsional, defaultnya "gelu") — Fungsi aktivasi non-linear pada mask downsampler.
  • memory_fuser_num_layers (int, opsional, defaultnya 2) — Jumlah lapisan dalam memory fuser.
  • memory_fuser_embed_dim (int, opsional, default 256) — Dimensi dari lapisan embedding di 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 skala layer dalam memory fuser.
  • memory_fuser_hidden_act (str, opsional, default "gelu") — Fungsi aktivasi non-linear dalam memory fuser.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2VideoModel. Kelas ini digunakan untuk membuat instans model Sam2 Video berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

>>> from transformers import (
...     Sam2VisionConfig,
...     Sam2PromptEncoderConfig,
...     Sam2MaskDecoderConfig,
...     Sam2Model,
... )

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

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

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

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

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

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

Sam2VideoMaskDecoderConfig

kelas transformers.Sam2VideoMaskDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256hidden_act: str = 'gelu'mlp_dim: int = 2048num_hidden_layers: int = 2num_attention_heads: int = 8attention_downsample_rate: int = 2num_multimask_outputs: int = 3iou_head_depth: int = 3iou_head_hidden_dim: int = 256dynamic_multimask_via_stability: bool = Truedynamic_multimask_stability_delta: float = 0.05dynamic_multimask_stability_thresh: float = 0.98 )

Parameter

  • hidden_size (int, opsional, default 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, default 2048) — Dimensi dari MLP dalam transformer dua arah.
  • num_hidden_layers (int, opsional, default 2) — Jumlah lapisan tersembunyi dalam decoder Transformer.
  • num_attention_heads (int, opsional, default 8) — Jumlah attention heads untuk setiap lapisan attention di decoder Transformer.
  • attention_downsample_rate (int, opsional, default 2) — Rasio downsample untuk lapisan attention.
  • num_multimask_outputs (int, opsional, defaultnya 3) — Jumlah output multimask.
  • iou_head_depth (int, opsional, defaultnya 3) — Kedalaman dari IoU head.
  • iou_head_hidden_dim (int, opsional, default 256) — Dimensi tersembunyi dari kepala IoU.
  • dynamic_multimask_via_stability (bool, opsional, defaultnya True) — Apakah akan menggunakan dynamic multimask via stability.
  • dynamic_multimask_stability_delta (float, opsional, default 0.05) — Delta stabilitas untuk dynamic multimask.
  • dynamic_multimask_stability_thresh (float, opsional, default 0.98) — Ambang batas stabilitas untuk dynamic multimask.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2VideoModel. Kelas ini digunakan untuk membuat instans model Sam2 Video berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2_video.1-hiera-tiny

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Sam2VideoPromptEncoderConfig

kelas transformers.Sam2VideoPromptEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16mask_input_channels: int = 16num_point_embeddings: int = 4hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06scale: int = 1 )

Parameter

  • hidden_size (int, opsional, default 256) — Dimensi dari representasi tersembunyi.
  • image_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 1024) — Ukuran (resolusi) dari setiap gambar.
  • patch_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 16) — 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 embeddings 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 Sam2VideoModel. Kelas ini digunakan untuk membuat instans model Sam2 Video berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2_video.1-hiera-tiny

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Sam2VideoProcessor

kelas transformers.Sam2VideoProcessor

< >

( image_processorvideo_processortarget_size: int | None = Nonepoint_pad_value: int = -10**kwargs )

Parameter

  • image_processor (Sam2ImageProcessor) — Image processor adalah input yang wajib diisi.
  • video_processor (Sam2VideoVideoProcessor) — Video processor adalah input yang wajib diisi.
  • target_size (int, opsional) — Ukuran target (dalam piksel) untuk menormalisasi titik input dan kotak batas. 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, default -10) — Nilai yang digunakan untuk mengisi titik input saat melakukan batching pada sekuens dengan panjang berbeda. Nilai ini digunakan untuk menandai posisi yang di-*pad* dan dipertahankan selama normalisasi koordinat.

Membangun Sam2VideoProcessor yang membungkus image processor dan video processor menjadi satu processor.

Sam2VideoProcessor menyediakan semua fungsionalitas dari Sam2ImageProcessor dan Sam2VideoVideoProcessor. Lihat ~Sam2ImageProcessor dan ~Sam2VideoVideoProcessor untuk informasi lebih lanjut.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonesegmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneinput_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = Noneinput_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = Noneinput_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = Noneoriginal_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs ) → A BatchEncoding with the following fields

Parameter

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opsional) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan 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 tersebut.
  • input_boxes (list[list[list[float]]], torch.Tensor, opsional) — Kotak pembatas (bounding boxes) 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

BatchEncoding dengan field-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

< >

( masksoriginal_sizesmask_threshold = 0.0binarize = Truemax_hole_area = 0.0max_sprinkle_area = 0.0apply_non_overlapping_constraints = False**kwargs ) → (torch.Tensor)

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 model, dalam format (tinggi, lebar).
  • mask_threshold (float, opsional, default 0.0) — Ambang batas untuk operasi binarisasi dan pascaproses.
  • binarize (bool, opsional, default True) — Apakah akan membinerisasi mask.
  • max_hole_area (float, opsional, default 0.0) — Luas maksimum lubang yang akan diisi.
  • max_sprinkle_area (float, opsional, default 0.0) — Area maksimum sprinkle yang akan diisi.
  • apply_non_overlapping_constraints (bool, opsional, default False) — Apakah akan menerapkan kendala non-overlapping pada mask.

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

< >

( 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] = Noneinference_device: typing.Union[str, ForwardRef('torch.device')] = 'cpu'inference_state_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = Noneprocessing_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = Nonevideo_storage_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = Nonemax_vision_features_cache_size: int = 1dtype: dtype = torch.float32 )

Parameter

  • video (VideoInput, opsional) — Video yang akan diproses. Tidak perlu disediakan saat streaming.
  • inference_device (str atau torch.device, opsional, default “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, default torch.float32) — torch dtype yang digunakan untuk seluruh sesi.

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

add_inputs_to_inference_session

< >

( inference_session: Sam2VideoInferenceSessionframe_idx: intobj_ids: list[int] | intinput_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = Noneinput_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = Noneinput_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = Noneinput_masks: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneoriginal_size: tuple[int, int] | None = Noneclear_old_inputs: bool = True )

Parameter

  • inference_session (Sam2VideoInferenceSession) — Sesi inferensi untuk video.
  • frame_idx (int) — Indeks 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 tersebut.
  • input_boxes (list[list[list[float]]], torch.Tensor, opsional) — Kotak pembatas (bounding boxes) 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. Sediakan saat streaming.
  • clear_old_inputs (bool, opsional, default True) — Apakah akan menghapus input lama untuk objek tersebut.

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

Sam2VideoVideoProcessor

kelas transformers.Sam2VideoVideoProcessor

< >

( **kwargs: *<class 'transformers.processing_utils.VideosKwargs'> )

Parameter

  • do_convert_rgb (bool, kwargs, opsional, default True) — Apakah akan mengkonversi gambar ke RGB.
  • do_resize (bool, kwargs, opsional, default True) — Apakah akan mengubah ukuran gambar.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya {'height' -- 1024, 'width': 1024}): Menggambarkan dimensi input maksimum ke model.
  • default_to_square (bool, kwargs, opsional, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya 2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
  • do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
  • rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
  • do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
  • do_center_crop (bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar.
  • do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
    • "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
    • "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
    • "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
  • do_sample_frames (bool, kwargs, opsional) — Apakah akan mengambil sampel frame dari video sebelum diproses atau memproses seluruh video.
  • video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadata dari video yang berisi informasi tentang durasi total, fps, dan jumlah total frame. Metadata ini akan digunakan untuk mengambil sampel frame dari video atau menghitung timestamp. Jangan kirimkan metadata apa pun kecuali Anda mencoba mendekode video secara manual sebelum diproses
  • fps (Annotated[int | float | None, None], kwargs) — Target frame yang akan disampel per detik ketika do_sample_frames=True.
  • num_frames (Annotated[int | None, None], kwargs) — Jumlah maksimum frame yang akan disampelkan saat do_sample_frames=True.
  • return_metadata (bool, kwargs, opsional, default False) — Apakah akan mengembalikan metadata video atau tidak. Metadata video adalah objek yang berisi informasi tentang durasi video, fps, backend decoding, dll.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:
    • 'pt': Mengembalikan objek PyTorch torch.Tensor.
    • 'np': Mengembalikan objek NumPy np.ndarray.
  • **kwargs (VideosKwargs, opsional) — Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

Membangun prosesor video Sam2VideoVideoProcessor.

post_process_masks

< >

( masksoriginal_sizesreshaped_input_sizesmask_threshold = 0.0binarize = Truepad_size = None ) → (torch.Tensor)

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 model, dalam format (tinggi, lebar).
  • reshaped_input_sizes (Union[torch.Tensor, List[Tuple[int,int]]]) — Ukuran setiap gambar saat dimasukkan ke model, dalam format (tinggi, lebar). Digunakan untuk menghapus padding.
  • mask_threshold (float, opsional, default 0.0) — Ambang batas yang digunakan untuk membinerkan mask.
  • binarize (bool, opsional, default True) — Apakah akan membinerisasi mask.
  • pad_size (int, opsional, defaultnya self.pad_size) — Ukuran target yang digunakan untuk melakukan padding pada gambar sebelum diteruskan ke model. Jika None, ukuran target diasumsikan sebagai pad_size dari processor.

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.

Sam2VideoInferenceSession

kelas transformers.Sam2VideoInferenceSession

< >

( video: typing.Optional[torch.Tensor] = Nonevideo_height: int | None = Nonevideo_width: int | None = Noneinference_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 )

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 digunakan untuk inferensi.
  • inference_state_device (torch.device, opsional, default "cpu") — Perangkat untuk menyimpan state inferensi.
  • video_storage_device (torch.device, opsional, default "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

< >

( obj_idx: intframe_idx: intinputs: Tensor )

Tambahkan input mask dengan penempatan perangkat otomatis.

add_new_frame

< >

( pixel_values: Tensorframe_idx: int | None = None )

Tambahkan frame baru dengan penempatan perangkat otomatis.

add_point_inputs

< >

( obj_idx: intframe_idx: intinputs: dict )

Tambahkan input titik dengan penempatan perangkat otomatis.

get_frame

< >

( frame_idx: int )

Ambil frame dari video.

get_obj_num

< >

( )

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

get_output

< >

( obj_idx: intframe_idx: intoutput_key: stris_conditioning_frame: bool = True )

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

Dapatkan output dengan manajemen perangkat pintar.

obj_id_to_idx

< >

( obj_id: int )

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

obj_idx_to_id

< >

( obj_idx: int )

Petakan indeks objek sisi model ke id objek sisi klien.

remove_mask_inputs

< >

( obj_idx: intframe_idx: int )

Hapus input mask.

remove_point_inputs

< >

( obj_idx: intframe_idx: int )

Hapus input titik.

reset_inference_session

< >

( )

Reset data pelacakan dan cache.

reset_tracking_data

< >

( )

Reset data pelacakan tetapi pertahankan cache.

store_output

< >

( obj_idx: intframe_idx: intoutput_key: str | None = Noneoutput_value: typing.Union[torch.Tensor, dict, NoneType] = Noneis_conditioning_frame: bool = True )

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

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

Sam2VideoModel

kelas transformers.Sam2VideoModel

< >

( config: Sam2VideoConfig )

Parameter

  • config (Sam2VideoConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

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

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari 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

< >

( inference_session: Sam2VideoInferenceSessionframe_idx: int | None = Noneframe: typing.Optional[torch.Tensor] = Nonereverse: bool = Falserun_mem_encoder: bool = True**kwargs ) → Sam2VideoSegmentationOutput or tuple(torch.Tensor)

Parameter

  • inference_session (~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession) — Objek sesi inferensi video.
  • frame_idx (int, opsional) — Indeks 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, default False) — Apakah akan melakukan propagasi secara terbalik.
  • run_mem_encoder (bool, opsional, default True) — Apakah akan menjalankan memory encoder pada mask yang diprediksi. Memory encoder di-batch untuk semua objek demi efisiensi.

Mengembalikan

Sam2VideoSegmentationOutput atau tuple(torch.Tensor)

Sam2VideoSegmentationOutput atau tuple dari torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Sam2VideoConfig) 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 hadir.
  • frame_idx (int, opsional) — Indeks frame dari video.

propagate_in_video_iterator

< >

( inference_session: Sam2VideoInferenceSessionstart_frame_idx: int | None = Nonemax_frame_num_to_track: int | None = Nonereverse: bool = Falseshow_progress_bar: bool = False ) → Sam2VideoSegmentationOutput or tuple(torch.Tensor)

Parameter

  • inference_session (~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession) — 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, default False) — Apakah akan melakukan propagasi secara terbalik.
  • show_progress_bar (bool, opsional, default False) — Apakah menampilkan progress bar selama propagasi.

Mengembalikan

Sam2VideoSegmentationOutput atau tuple(torch.Tensor)

A Sam2VideoSegmentationOutput atau tuple dari torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Sam2VideoConfig) dan input.

Propagasi objek melalui bingkai video. Digunakan saat menginisialisasi sesi inferensi dengan video utuh. Menghasilkan Sam2VideoSegmentationOutput 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 hadir.
  • frame_idx (int, opsional) — Indeks frame dari video.

get_image_features

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sam2VideoVisionEncoderOutput or tuple(torch.Tensor)

Parameter

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

Mengembalikan

Sam2VideoVisionEncoderOutput atau tuple(torch.Tensor)

Sam2VideoVisionEncoderOutput atau tuple dari torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Sam2VideoConfig) dan input.

  • last_hidden_state (torch.Tensor dengan bentuk (batch_size, height, width, hidden_size)) — Urutan hidden-states pada output 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 saat output_attentions=True dilewatkan atau saat 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 perhatian diri (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). Encoding posisi yang sesuai dengan fpn_hidden_states.

Update on GitHub

←PE Video Sam3TrackerVideo→