# EdgeTAMVideo ## Ikhtisar Model EdgeTAM diusulkan dalam [EdgeTAM: On-Device Track Anything Model](https://huggingface.co/papers/2501.07256) Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra, Bilge Soran. EdgeTAM adalah adaptasi efisien dari SAM 2 yang memperkenalkan arsitektur 2D Spatial Perceiver untuk mengoptimalkan mekanisme perhatian memori bagi segmentasi video real-time pada perangkat mobile. Abstrak dari makalah tersebut adalah sebagai berikut: *Di atas Segment Anything Model (SAM), SAM 2 lebih lanjut memperluas kemampuannya dari input gambar ke input video melalui mekanisme memory bank dan memperoleh kinerja yang luar biasa dibandingkan dengan metode sebelumnya, menjadikannya model fondasi untuk tugas segmentasi video. Dalam makalah ini, kami bertujuan untuk membuat SAM 2 jauh lebih efisien sehingga bahkan dapat berjalan pada perangkat seluler sambil mempertahankan kinerja yang sebanding. Meskipun ada beberapa karya yang mengoptimalkan SAM untuk efisiensi yang lebih baik, kami menemukan bahwa mereka tidak cukup untuk SAM 2 karena semuanya berfokus pada kompresi image encoder, sementara benchmark kami menunjukkan bahwa blok memory attention yang baru diperkenalkan juga merupakan bottleneck latensi. Mengingat observasi ini, kami mengusulkan EdgeTAM, yang memanfaatkan 2D Spatial Perceiver baru untuk mengurangi biaya komputasi. Secara khusus, 2D Spatial Perceiver yang diusulkan mengkodekan memori tingkat frame yang disimpan secara padat dengan Transformer ringan yang berisi himpunan tetap dari query yang dapat dipelajari. Mengingat segmentasi video adalah tugas prediksi padat, kami menemukan bahwa mempertahankan struktur spasial dari memori sangat penting sehingga query dipecah menjadi kelompok tingkat global dan tingkat patch. Kami juga mengusulkan pipeline distilasi yang lebih lanjut meningkatkan kinerja tanpa overhead inferensi. Akibatnya, EdgeTAM mencapai 87,7, 70,0, 72,3, dan 71,7 J&F pada DAVIS 2017, MOSE, SA-V val, dan SA-V test, sambil berjalan pada 16 FPS di iPhone 15 Pro Max.* Model ini disumbangkan oleh [yonigozlan](https://huggingface.co/yonigozlan). Kode aslinya dapat ditemukan [di sini](https://github.com/facebookresearch/EdgeTAM). ## Contoh penggunaan ### Segmentasi dan Pelacakan Video Kekuatan utama EdgeTAM Video adalah kemampuannya untuk melacak objek di antara bingkai video secara efisien pada perangkat mobile. Berikut cara menggunakannya untuk segmentasi video: #### Pelacakan Video Dasar ```python from transformers import EdgeTamVideoModel, Sam2VideoProcessor import torch model = EdgeTamVideoModel.from_pretrained("yonigozlan/edgetam-video-1", device_map="auto") processor = Sam2VideoProcessor.from_pretrained("yonigozlan/edgetam-video-1") # Load video frames (example assumes you have a list of PIL Images) # video_frames = [Image.open(f"frame_{i:05d}.jpg") for i in range(num_frames)] # For this example, we'll use the video loading utility from transformers.video_utils import load_video video_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/bedroom.mp4" video_frames, _ = load_video(video_url) # Initialize video inference session inference_session = processor.init_video_session( video=video_frames, inference_device=device, ) # Add click on first frame to select object ann_frame_idx = 0 ann_obj_id = 1 points = [[[[210, 350]]]] labels = [[[1]]] processor.add_inputs_to_inference_session( inference_session=inference_session, frame_idx=ann_frame_idx, obj_ids=ann_obj_id, input_points=points, input_labels=labels, ) # Segment the object on the first frame outputs = model( inference_session=inference_session, frame_idx=ann_frame_idx, ) video_res_masks = processor.post_process_masks( [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False )[0] print(f"Segmentation shape: {video_res_masks.shape}") Segmentation shape: torch.Size([1, 1, 540, 960]) # Propagate through the entire video video_segments = {} for sam2_video_output in model.propagate_in_video_iterator(inference_session): video_res_masks = processor.post_process_masks( [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False )[0] video_segments[sam2_video_output.frame_idx] = video_res_masks print(f"Tracked object through {len(video_segments)} frames") Tracked object through 200 frames ``` #### 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 outputs = model( inference_session=inference_session, frame_idx=ann_frame_idx, ) # Propagate both objects through video video_segments = {} for sam2_video_output in model.propagate_in_video_iterator(inference_session): video_res_masks = processor.post_process_masks( [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False )[0] video_segments[sam2_video_output.frame_idx] = { obj_id: video_res_masks[i] for i, obj_id in enumerate(inference_session.obj_ids) } print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames") Tracked 2 objects through 200 frames ``` #### 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 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, EdgeTAM Video mendukung pemrosesan bingkai video saat mereka 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 sam2_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0]) ... video_res_masks = processor.post_process_masks( [sam2_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False )[0] print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}") Frame 0: mask shape torch.Size([1, 1, 540, 960]) ... ``` #### 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 sam2_video_output in model.propagate_in_video_iterator(inference_session): video_res_masks = processor.post_process_masks( [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False )[0] video_segments[sam2_video_output.frame_idx] = { obj_id: video_res_masks[i] for i, obj_id in enumerate(inference_session.obj_ids) } print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames") Tracked 2 objects through 200 frames ``` ## EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]] #### transformers.EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]] ```python transformers.EdgeTamVideoMaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, hidden_act: str = 'gelu', mlp_dim: int = 2048, num_hidden_layers: int = 2, num_attention_heads: int = 8, attention_downsample_rate: int = 2, num_multimask_outputs: int = 3, iou_head_depth: int = 3, iou_head_hidden_dim: int = 256, dynamic_multimask_via_stability: bool = True, dynamic_multimask_stability_delta: float = 0.05, dynamic_multimask_stability_thresh: float = 0.98) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L57) **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 EdgeTamVideoModel. Kelas ini digunakan untuk membuat instans model Edgetam Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. ## EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]] #### transformers.EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]] ```python transformers.EdgeTamVideoPromptEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, mask_input_channels: int = 16, num_point_embeddings: int = 4, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, scale: int = 1) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L32) **Parameter:** hidden_size (`int`, *opsional*, defaultnya `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 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 EdgeTamVideoModel. Kelas ini digunakan untuk membuat instans model Edgetam Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. ## EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]] #### transformers.EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]] ```python transformers.EdgeTamVideoConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02, num_maskmem: int = 7, image_size: int | list[int] | tuple[int, int] = 1024, sigmoid_scale_for_mem_enc: float = 20.0, sigmoid_bias_for_mem_enc: float = -10.0, enable_occlusion_spatial_embedding: bool = True, multimask_output_in_sam: bool = True, multimask_min_pt_num: int = 0, multimask_max_pt_num: int = 1, multimask_output_for_tracking: bool = True, max_object_pointers_in_encoder: int = 16, max_cond_frame_num: int = -1, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 2, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_mlp_hidden_size: int = 2048, memory_attention_mlp_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list | None = None, memory_attention_rope_k_sizes: list | None = None, memory_attention_rope_dropout: float | int = 0.1, rope_parameters: dict | None = None, perceiver_resampler_num_latents: int = 256, perceiver_resampler_num_latents_2d: int = 256, perceiver_resampler_hidden_size: int = 64, perceiver_resampler_mlp_intermediate_size: int = 256, perceiver_resampler_num_attention_heads: int = 1, perceiver_resampler_attention_head_dim: int = 64, perceiver_resampler_num_layers: int = 2, perceiver_resampler_hidden_dropout: float | int = 0.0, perceiver_resampler_attention_dropout: float | int = 0.0, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, mask_downsampler_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu') ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L96) **Parameter:** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari vision backbone. prompt_encoder_config (Union[`dict`, `EdgeTamVideoPromptEncoderConfig`], *opsional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [EdgeTamVideoPromptEncoderConfig](/docs/transformers/main/id/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig). mask_decoder_config (Union[`dict`, `EdgeTamVideoMaskDecoderConfig`], *opsional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [EdgeTamMaskDecoderConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig). initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. 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*, 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 -1) : Jumlah maksimum frame conditioning yang digunakan dalam memori perhatian. Atur ke -1 untuk menggunakan semua frame conditioning. 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 2) : 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_mlp_hidden_size (`int`, *opsional*, defaultnya 2048) : Dimensi dari jaringan feedforward dalam modul perhatian memori. memory_attention_mlp_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 (`Tuple[int, int]`, *opsional*, defaultnya `[64, 64]`) : Ukuran fitur untuk encoding posisi Rope. memory_attention_rope_k_sizes (`List[int]`, *opsional*, defaultnya `[16, 16]`) : Ukuran fitur kunci untuk encoding posisi RoPE dalam memori perhatian. memory_attention_rope_dropout (`float`, *opsional*, default 0.1) : Tingkat dropout untuk pengkodean posisi Rope. 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. perceiver_resampler_num_latents (`int`, *opsional*, default 256) : Jumlah token laten 1D dalam perceiver resampler. perceiver_resampler_num_latents_2d (`int`, *opsional*, default 256) : Jumlah token laten 2D dalam perceiver resampler. perceiver_resampler_hidden_size (`int`, *opsional*, defaultnya 64) : Ukuran tersembunyi dari perceiver resampler. perceiver_resampler_mlp_intermediate_size (`int`, *opsional*, defaultnya 256) : Ukuran perantara dari jaringan feedforward dalam perceiver resampler. perceiver_resampler_num_attention_heads (`int`, *opsional*, default 1) : Jumlah kepala perhatian dalam perceiver resampler. perceiver_resampler_attention_head_dim (`int`, *opsional*, defaultnya 64) : Dimensi dari setiap kepala perhatian (attention head) dalam perceiver resampler. perceiver_resampler_num_layers (`int`, *opsional*, defaultnya 2) : Jumlah lapisan dalam perceiver resampler. perceiver_resampler_hidden_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout untuk lapisan tersembunyi dalam perceiver resampler. perceiver_resampler_attention_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout untuk lapisan perhatian dalam perceiver resampler. 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. mask_downsampler_embed_dim (`int`, *opsional*, default 256) : Dimensi dari embedding downsampler mask. memory_fuser_intermediate_dim (`int`, *opsional*, default 1024) : Dimensi antara dari jaringan feedforward fuser memori. 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*, default 256) : Dimensi dari embedding 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 EdgeTamVideoModel. Kelas ini digunakan untuk membuat instans model Edgetam Video sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```python >>> from transformers import ( ... EdgeTamVisionConfig, ... EdgeTamVideoPromptEncoderConfig, ... EdgeTamVideoMaskDecoderConfig, ... EdgeTamVideoModel, ... EdgeTamVideoConfig, ... ) >>> # Initializing a EdgeTamVideoConfig with `"facebook/edgetam.1_hiera_tiny"` style configuration >>> configuration = EdgeTamVideoConfig() >>> # Initializing a EdgeTamVideoModel (with random weights) from the `"facebook/edgetam.1_hiera_tiny"` style configuration >>> model = EdgeTamVideoModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig >>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations >>> vision_config = EdgeTamVisionConfig() >>> prompt_encoder_config = EdgeTamVideoPromptEncoderConfig() >>> mask_decoder_config = EdgeTamVideoMaskDecoderConfig() >>> config = EdgeTamVideoConfig(vision_config, prompt_encoder_config, mask_decoder_config) ``` ## EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]] #### transformers.EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]] ```python transformers.EdgeTamVideoInferenceSession(video: typing.Optional[torch.Tensor] = None, video_height: int | None = None, video_width: int | None = None, inference_device: typing.Union[torch.device, str] = 'cpu', inference_state_device: typing.Union[torch.device, str] = 'cpu', video_storage_device: typing.Union[torch.device, str] = 'cpu', dtype: typing.Union[torch.dtype, str] = 'float32', max_vision_features_cache_size: int = 1) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L942) **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.EdgeTamVideoInferenceSession.add_mask_inputs]] ```python add_mask_inputs(obj_idx: int, frame_idx: int, inputs: Tensor) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1062) Tambahkan input mask dengan penempatan perangkat otomatis. #### add_new_frame[[transformers.EdgeTamVideoInferenceSession.add_new_frame]] ```python add_new_frame(pixel_values: Tensor, frame_idx: int | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1137) Tambahkan frame baru dengan penempatan perangkat otomatis. #### add_point_inputs[[transformers.EdgeTamVideoInferenceSession.add_point_inputs]] ```python add_point_inputs(obj_idx: int, frame_idx: int, inputs: dict) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1048) Tambahkan input titik dengan penempatan perangkat otomatis. #### get_frame[[transformers.EdgeTamVideoInferenceSession.get_frame]] ```python get_frame(frame_idx: int) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1153) Ambil frame dari video. #### get_obj_num[[transformers.EdgeTamVideoInferenceSession.get_obj_num]] ```python get_obj_num() ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1043) Dapatkan jumlah total id objek unik yang diterima sejauh ini dalam sesi ini. #### get_output[[transformers.EdgeTamVideoInferenceSession.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/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1110) **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.EdgeTamVideoInferenceSession.obj_id_to_idx]] ```python obj_id_to_idx(obj_id: int) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1017) Petakan ID objek ke indeks, buat entri baru jika diperlukan. #### obj_idx_to_id[[transformers.EdgeTamVideoInferenceSession.obj_idx_to_id]] ```python obj_idx_to_id(obj_idx: int) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1039) Petakan indeks objek sisi model ke id objek sisi klien. #### remove_mask_inputs[[transformers.EdgeTamVideoInferenceSession.remove_mask_inputs]] ```python remove_mask_inputs(obj_idx: int, frame_idx: int) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1068) Hapus input mask. #### remove_point_inputs[[transformers.EdgeTamVideoInferenceSession.remove_point_inputs]] ```python remove_point_inputs(obj_idx: int, frame_idx: int) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1058) Hapus input titik. #### reset_inference_session[[transformers.EdgeTamVideoInferenceSession.reset_inference_session]] ```python reset_inference_session() ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1169) Reset data pelacakan dan cache. #### reset_tracking_data[[transformers.EdgeTamVideoInferenceSession.reset_tracking_data]] ```python reset_tracking_data() ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1157) Reset data pelacakan tetapi pertahankan cache. #### store_output[[transformers.EdgeTamVideoInferenceSession.store_output]] ```python store_output(obj_idx: int, frame_idx: int, output_key: str | None = None, output_value: typing.Union[torch.Tensor, dict, NoneType] = None, is_conditioning_frame: bool = True) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1073) **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. ## EdgeTamVideoModel[[transformers.EdgeTamVideoModel]] #### transformers.EdgeTamVideoModel[[transformers.EdgeTamVideoModel]] ```python transformers.EdgeTamVideoModel(config: EdgeTamVideoConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2062) **Parameter:** config ([EdgeTamVideoConfig](/docs/transformers/main/id/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Edgetam Video polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.EdgeTamVideoModel.forward]] ```python forward(inference_session: EdgeTamVideoInferenceSession, frame_idx: int | None = None, frame: typing.Optional[torch.Tensor] = None, reverse: bool = False, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2196) **Parameter:** inference_session (`~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession`) : 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. **Mengembalikan:** `EdgeTamVideoSegmentationOutput` atau `tuple(torch.Tensor)` Sebuah `EdgeTamVideoSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([EdgeTamVideoConfig](/docs/transformers/main/id/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) 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. #### get_image_features[[transformers.EdgeTamVideoModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2295) **Parameter:** pixel_values (`torch.Tensor`) : Nilai piksel input dengan bentuk `(batch_size, num_channels, height, width)`. **Mengembalikan:** `EdgeTamVideoVisionEncoderOutput` atau `tuple(torch.Tensor)` Sebuah `EdgeTamVideoVisionEncoderOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([EdgeTamVideoConfig](/docs/transformers/main/id/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) 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`.