Hugging Face's logo

Transformers documentation

EdgeTAMVideo

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

该模型于 2025-01-13 在 HF papers 上发布，并于 2025-09-29 贡献至 Hugging Face Transformers。

SDPA FlashAttention

EdgeTAMVideo

概述

EdgeTAM 模型在 EdgeTAM: On-Device Track Anything Model 中提出，作者为 Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra, Bilge Soran。

EdgeTAM 是 SAM 2 的一种高效适配方案，它引入了 2D Spatial Perceiver 架构，以优化内存注意力机制，从而在移动设备上实现实时视频分割。

该论文的摘要如下：

在 Segment Anything Model (SAM) 的基础上，SAM 2 通过记忆库机制将其能力从图像输入扩展到视频输入，与以往方法相比取得了显著的性能提升，使其成为视频分割任务的基础模型。本文旨在大幅提升 SAM 2 的效率，使其在保持可比性能的同时，甚至能在移动设备上运行。尽管已有若干工作致力于优化 SAM 以提升效率，但我们发现这些方法对于 SAM 2 而言并不充分，因为它们都聚焦于压缩图像编码器，而我们的基准测试表明，新引入的记忆注意力模块同样是延迟瓶颈。基于这一观察，我们提出了 EdgeTAM，它利用一种新颖的 2D Spatial Perceiver 来降低计算成本。具体而言，所提出的 2D Spatial Perceiver 使用一个包含固定数量可学习查询的轻量级 Transformer，对密集存储的帧级记忆进行编码。鉴于视频分割是一项密集预测任务，我们发现保留记忆的空间结构至关重要，因此将查询划分为全局级和块级两组。我们还提出了一种蒸馏流程，在不增加推理开销的情况下进一步提升性能。最终，EdgeTAM 在 DAVIS 2017、MOSE、SA-V val 和 SA-V test 上分别取得了 87.7、70.0、72.3 和 71.7 的 J&F 分数，同时在 iPhone 15 Pro Max 上以 16 FPS 的速度运行。

该模型由 yonigozlan 贡献。 原始代码可在此处找到。

使用示例

视频分割与跟踪

EdgeTAM Video 的核心优势在于其能够在移动设备上高效地跨视频帧跟踪对象。以下是如何使用它进行视频分割：

基础视频跟踪

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

多目标视频跟踪

在视频帧中同时跟踪多个对象：

# 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

优化视频分割

您可以在任意帧上添加额外的点击以优化跟踪：

# 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

流式视频推理

对于实时应用，EdgeTAM Video 支持在视频帧到达时进行处理：

# 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])
...

多对象视频批量处理

通过一次性添加所有对象，在视频中同时跟踪多个对象：

# 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

class transformers.EdgeTamVideoMaskDecoderConfig

< >

( 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 )

参数

  • hidden_size (int，可选，默认为 256) — 隐藏表示的维度。
  • hidden_act (str，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • mlp_dim (int，可选，默认为 2048) — 双向 transformer 中 MLP 的维度。
  • num_hidden_layers (int，可选，默认为 2) — Transformer 解码器中的隐藏层数。
  • num_attention_heads (int，可选，默认为 8) — Transformer 解码器中每个注意力层的注意力头数量。
  • attention_downsample_rate (int，可选，默认为 2) — 注意力层的下采样率。
  • num_multimask_outputs (int，可选，默认为 3) — 多掩码输出的数量。
  • iou_head_depth (int, 可选，默认为 3) — IoU 头的深度。
  • iou_head_hidden_dim (int, 可选，默认为 256) — IoU 头的隐藏维度。
  • dynamic_multimask_via_stability (bool，可选，默认为 True) — 是否通过稳定性使用动态多掩码。
  • dynamic_multimask_stability_delta (float，可选，默认值为 0.05) — 动态多掩码的稳定性增量。
  • dynamic_multimask_stability_thresh (float，可选，默认值为 0.98) — 动态多掩码的稳定性阈值。

这是用于存储 EdgeTamVideoModel 配置的类。它根据指定的参数实例化 Edgetam Video 模型，并定义模型架构。使用默认值实例化配置将得到与 yonigozlan/EdgeTAM-hf 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

EdgeTamVideoPromptEncoderConfig

class transformers.EdgeTamVideoPromptEncoderConfig

< >

( 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 )

参数

  • hidden_size (int，可选，默认为 256) — 隐藏表示的维度。
  • image_size (Union[int, list[int], tuple[int, int]]，可选，默认为 1024) — 每张图片的尺寸（分辨率）。
  • patch_size (Union[int, list[int], tuple[int, int]]，可选，默认为 16) — 每个 patch 的大小（分辨率）。
  • mask_input_channels (int，可选，默认为 16) — 输入到 MaskDecoder 模块的通道数。
  • num_point_embeddings (int，可选，默认为 4) — 要使用的点嵌入数量。
  • hidden_act (str，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
  • scale (float，可选，默认为 1) — 提示编码器的缩放因子。

这是用于存储 EdgeTamVideoModel 配置的类。它根据指定的参数实例化 Edgetam Video 模型，并定义模型架构。使用默认值实例化配置将得到与 yonigozlan/EdgeTAM-hf 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

EdgeTamVideoConfig

class transformers.EdgeTamVideoConfig

< >

( 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 = 2memory_attention_num_attention_heads: int = 1memory_attention_downsample_rate: int = 1memory_attention_mlp_hidden_size: int = 2048memory_attention_mlp_hidden_act: str = 'relu'memory_attention_dropout: float | int = 0.1memory_attention_rope_feat_sizes: list | None = Nonememory_attention_rope_k_sizes: list | None = Nonememory_attention_rope_dropout: float | int = 0.1rope_parameters: dict | None = Noneperceiver_resampler_num_latents: int = 256perceiver_resampler_num_latents_2d: int = 256perceiver_resampler_hidden_size: int = 64perceiver_resampler_mlp_intermediate_size: int = 256perceiver_resampler_num_attention_heads: int = 1perceiver_resampler_attention_head_dim: int = 64perceiver_resampler_num_layers: int = 2perceiver_resampler_hidden_dropout: float | int = 0.0perceiver_resampler_attention_dropout: float | int = 0.0memory_encoder_hidden_size: int = 256memory_encoder_output_channels: int = 64mask_downsampler_embed_dim: int = 256memory_fuser_intermediate_dim: int = 1024mask_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_kernel_size: int = 7memory_fuser_padding: int = 3memory_fuser_layer_scale_init_value: float = 1e-06memory_fuser_hidden_act: str = 'gelu' )

参数

  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 视觉骨干网络的配置对象或字典。
  • prompt_encoder_config (Union[dict, EdgeTamVideoPromptEncoderConfig]，可选) — 用于初始化 EdgeTamVideoPromptEncoderConfig 的配置选项字典。
  • mask_decoder_config (Union[dict, EdgeTamVideoMaskDecoderConfig]，可选) — 用于初始化 EdgeTamMaskDecoderConfig 的配置选项字典。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • num_maskmem (int，可选，默认为 7) — 掩码内存的内存槽数量。
  • image_size (Union[int, list[int], tuple[int, int]]，可选，默认为 1024) — 每张图片的尺寸（分辨率）。
  • sigmoid_scale_for_mem_enc (float, 可选，默认为 20.0) — 内存编码器中 sigmoid 函数的缩放因子。
  • sigmoid_bias_for_mem_enc (float, 可选，默认为 -10.0) — 记忆编码器中 sigmoid 函数的偏置。
  • enable_occlusion_spatial_embedding (bool，可选，默认为 True) — 是否启用遮挡的空间嵌入。
  • multimask_output_in_sam (bool，可选，默认为 True) — 是否从 SAM 头输出多个掩码。
  • 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) — 在内存注意力中使用的最大条件帧数。设置为 -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，可选，默认值为 0.1) — 内存注意力模块的 dropout 率。
  • memory_attention_rope_feat_sizes (Tuple[int, int]，可选，默认为 [64, 64]) — Rope 位置编码的特征尺寸。
  • memory_attention_rope_k_sizes (List[int], 可选，默认为 [16, 16]) — 内存注意力中 RoPE 位置编码的键特征尺寸。
  • memory_attention_rope_dropout (float, 可选，默认值为 0.1) — Rope 位置编码的 dropout 率。
  • rope_parameters (dict, 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值，并且如果希望使用 RoPE 处理更长的 max_position_embeddings，则可选地包含用于缩放的参数。
  • perceiver_resampler_num_latents (int, 可选，默认为 256) — perceiver resampler 中 1D 潜在 token 的数量。
  • perceiver_resampler_num_latents_2d (int，可选，默认为 256) — Perceiver resampler 中 2D 潜在 token 的数量。
  • perceiver_resampler_hidden_size (int，可选，默认为 64) — Perceiver resampler 的隐藏层大小。
  • perceiver_resampler_mlp_intermediate_size (int, 可选，默认为 256) — perceiver resampler 中前馈网络的中间层大小。
  • perceiver_resampler_num_attention_heads (int，可选，默认为 1) — Perceiver resampler 中注意力头的数量。
  • perceiver_resampler_attention_head_dim (int，可选，默认值为 64) — Perceiver Resampler 中每个注意力头的维度。
  • perceiver_resampler_num_layers (int，可选，默认为 2) — Perceiver resampler 的层数。
  • perceiver_resampler_hidden_dropout (float, 可选，默认为 0.0) — Perceiver resampler 中隐藏层的 dropout 率。
  • perceiver_resampler_attention_dropout (float，可选，默认值为 0.0) — Perceiver resampler 中注意力层的 dropout 率。
  • 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 嵌入的维度。
  • memory_fuser_kernel_size (int，可选，默认为 7) — 内存融合器的卷积核大小。
  • memory_fuser_padding (int, 可选，默认为 3) — 内存融合器的填充值。
  • memory_fuser_layer_scale_init_value (float, 可选，默认为 1e-06) — memory fuser 中层缩放的初始值。
  • memory_fuser_hidden_act (str, 可选，默认为 "gelu") — 内存融合器中的非线性激活函数。

这是用于存储 EdgeTamVideoModel 配置的类。它根据指定的参数实例化 Edgetam Video 模型，并定义模型架构。使用默认值实例化配置将得到与 yonigozlan/EdgeTAM-hf 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

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

class transformers.EdgeTamVideoInferenceSession

< >

( 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 )

参数

  • video (torch.Tensor, 可选) — 要处理的视频。流式传输时无需提供。
  • video_height (int，可选) — 视频的高度。
  • video_width (int，可选) — 视频的宽度。
  • inference_device (torch.device，可选，默认为 "cpu") — 用于推理的设备。
  • inference_state_device (torch.device，可选，默认为 "cpu") — 用于存储推理状态的设备。
  • video_storage_device (torch.device，可选，默认为 "cpu") — 用于存储视频的设备。
  • dtype (torch.dtype，可选，默认为 "float32") — 用于视频的 dtype。
  • max_vision_features_cache_size (int，可选，默认为 1) — 要缓存的视觉特征的最大数量。

管理视频推理会话的参数、状态和缓存。

add_mask_inputs

< >

( obj_idx: intframe_idx: intinputs: Tensor )

添加掩码输入，并自动进行设备放置。

add_new_frame

< >

( pixel_values: Tensorframe_idx: int | None = None )

添加新帧并自动进行设备放置。

add_point_inputs

< >

( obj_idx: intframe_idx: intinputs: dict )

添加点输入，并自动进行设备放置。

get_frame

< >

( frame_idx: int )

从视频中获取帧。

get_obj_num

< >

( )

获取当前会话中已接收到的唯一对象 ID 总数。

get_output

< >

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

参数

  • obj_idx (int) — 对象的索引。
  • frame_idx (int) — 帧的索引。
  • output_key (str) — 输出的键。
  • is_conditioning_frame (bool) — 输出是否用于条件帧。

通过智能设备管理获取输出。

obj_id_to_idx

< >

( obj_id: int )

将对象 ID 映射到索引，如有必要则创建新条目。

obj_idx_to_id

< >

( obj_idx: int )

将模型端的对象索引映射到客户端的对象 ID。

remove_mask_inputs

< >

( obj_idx: intframe_idx: int )

移除 mask 输入。

remove_point_inputs

< >

( obj_idx: intframe_idx: int )

移除点输入。

reset_inference_session

< >

( )

重置跟踪数据和缓存。

reset_tracking_data

< >

( )

重置跟踪数据，但保留缓存。

store_output

< >

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

参数

  • obj_idx (int) — 对象的索引。
  • frame_idx (int) — 帧的索引。
  • output_key (Optional[str]) — 输出的键。如果为 None，输出将存储为字典。
  • output_value (Optional[Union[torch.Tensor, dict]]) — 输出的值。
  • is_conditioning_frame (bool) — 输出是否用于条件帧。

使用智能设备管理来存储输出。 如果 output_key 为 None，则输出将以字典形式存储。

EdgeTamVideoModel

class transformers.EdgeTamVideoModel

< >

( config: EdgeTamVideoConfig )

参数

  • config (EdgeTamVideoConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

未添加任何特定头部的裸 Edgetam Video Model，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( inference_session: EdgeTamVideoInferenceSessionframe_idx: int | None = Noneframe: typing.Optional[torch.Tensor] = Nonereverse: bool = False**kwargs ) → EdgeTamVideoSegmentationOutput or tuple(torch.Tensor)

参数

  • inference_session (~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession) — 视频推理会话对象。
  • frame_idx (int, 可选) — 用于执行推理的帧索引。在对新的流式帧进行推理时无需提供。
  • frame (torch.Tensor, 可选) — 要处理的帧。在流式处理时提供。
  • reverse (bool，可选，默认为 False) — 是否反向传播。

返回值

EdgeTamVideoSegmentationOutput 或 tuple(torch.Tensor)

EdgeTamVideoSegmentationOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（EdgeTamVideoConfig）和输入。

通过流式视频帧传播对象。

  • object_ids (list[int]，可选) — 当前帧中正在跟踪的对象 ID 列表。
  • pred_masks（形状为 (batch_size, num_masks, height, width) 的 torch.Tensor）— 以模型分辨率存储的预测掩码。
  • object_score_logits (torch.Tensor，形状为 (batch_size,)，可选) — 对象分数的 logits，用于指示是否存在对象。
  • frame_idx (int, 可选) — 视频的帧索引。

get_image_features

< >

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

参数

  • pixel_values (torch.Tensor) — 形状为 (batch_size, num_channels, height, width) 的输入像素值。

返回值

EdgeTamVideoVisionEncoderOutput 或 tuple(torch.Tensor)

EdgeTamVideoVisionEncoderOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（EdgeTamVideoConfig）和输入。

  • last_hidden_state（形状为 (batch_size, height, width, hidden_size) 的 torch.Tensor）— 模型最后一层输出的隐藏状态序列。

  • pooler_output (torch.Tensor，形状为 (batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后得到。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。

  • hidden_states (tuple(torch.Tensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

  • fpn_hidden_states (tuple(torch.Tensor)) — 一个 torch.Tensor 元组（每个特征层一个，从高分辨率到低分辨率），形状为 (batch_size, hidden_size, height, width)。来自特征金字塔网络（Feature Pyramid Network）颈部的特征图。

  • fpn_position_encoding (tuple(torch.Tensor)) — torch.Tensor 的元组（每个特征层一个，从高分辨率到低分辨率），形状为 (batch_size, hidden_size, height, width)。与 fpn_hidden_states 对应的位置编码。

Update on GitHub

←EdgeTAM EmbeddingGemma2→