# EdgeTAMVideo

## Обзор

Модель EdgeTAM была предложена в работе [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 — это эффективная адаптация 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 достигает 87,7, 70,0, 72,3 и 71,7 J&F на DAVIS 2017, MOSE, SA-V val и SA-V test, при этом работая со скоростью 16 FPS на iPhone 15 Pro Max.*

Эта модель была добавлена пользователем [yonigozlan](https://huggingface.co/yonigozlan). Исходный код можно найти [здесь](https://github.com/facebookresearch/EdgeTAM).

## Пример использования

### Сегментация и отслеживание объектов на видео

Ключевое преимущество EdgeTAM Video заключается в его способности эффективно отслеживать объекты между кадрами видео на мобильных устройствах. Вот как использовать его для сегментации видео:

#### Базовое отслеживание видео

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

#### Отслеживание нескольких объектов на видео

Одновременное отслеживание нескольких объектов в кадрах видео:

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

#### Уточнение сегментации видео

Вы можете добавлять дополнительные клики на любом кадре, чтобы уточнить отслеживание:

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

### Потоковое видео-инференс

Для приложений реального времени EdgeTAM Video поддерживает обработку кадров видео по мере их поступления:

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

#### Пакетная обработка видео для нескольких объектов

Одновременно отслеживайте несколько объектов в видео, добавляя их все сразу:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L57)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `256`) : Размерность скрытых представлений.

hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

mlp_dim (`int`, *optional*, по умолчанию 2048) : Размерность MLP в двухстороннем трансформере.

num_hidden_layers (`int`, *необязательный*, по умолчанию `2`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

attention_downsample_rate (`int`, *optional*, по умолчанию 2) : Коэффициент downsampling для слоев внимания.

num_multimask_outputs (`int`, *необязательный*, по умолчанию 3) : Количество выходов multimask.

iou_head_depth (`int`, *optional*, по умолчанию 3) : Глубина IoU-головы.

iou_head_hidden_dim (`int`, *optional*, по умолчанию 256) : Скрытое измерение головы IoU.

dynamic_multimask_via_stability (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли динамическую мультимаску через стабильность.

dynamic_multimask_stability_delta (`float`, *необязательный*, по умолчанию 0.05) : Дельта стабильности для динамической мультимаски.

dynamic_multimask_stability_thresh (`float`, *optional*, по умолчанию 0.98) : Порог стабильности для динамической мультимаски.

Это класс конфигурации для хранения конфигурации модели EdgeTamVideoModel. Он используется для создания модели Edgetam Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L32)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `256`) : Размерность скрытых представлений.

image_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `1024`) : Размер (разрешение) каждого изображения.

patch_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `16`) : Размер (разрешение) каждого патча.

mask_input_channels (`int`, *необязательный*, по умолчанию 16) : Количество каналов, передаваемых в модуль `MaskDecoder`.

num_point_embeddings (`int`, *optional*, по умолчанию 4) : Количество используемых встраиваний точек.

hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-06`) : Значение epsilon, используемое слоями нормализации.

scale (`float`, *необязательный*, по умолчанию 1) : Коэффициент масштабирования для кодировщика промпта.

Это класс конфигурации для хранения конфигурации модели EdgeTamVideoModel. Он используется для создания модели Edgetam Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L96)

**Параметры:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь для визуального бэкбона.

prompt_encoder_config (Union[`dict`, `EdgeTamVideoPromptEncoderConfig`], *optional*) : Словарь параметров конфигурации, используемых для инициализации [EdgeTamVideoPromptEncoderConfig](/docs/transformers/main/ru/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `EdgeTamVideoMaskDecoderConfig`], *optional*) : Словарь параметров конфигурации, используемых для инициализации [EdgeTamMaskDecoderConfig](/docs/transformers/main/ru/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig).

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

num_maskmem (`int`, *optional*, по умолчанию 7) : Количество слотов памяти для маски памяти.

image_size (`Union[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`) : Включает ли вывод нескольких масок из SAM-головы.

multimask_min_pt_num (`int`, *optional*, по умолчанию 0) : минимальное количество точек для запуска вывода multimask.

multimask_max_pt_num (`int`, *optional*, по умолчанию 1) : Максимальное количество точек для запуска вывода multimask.

multimask_output_for_tracking (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли многомасочный вывод для отслеживания.

max_object_pointers_in_encoder (`int`, *optional*, по умолчанию 16) : Максимальное количество указателей на объекты в кодировщике.

max_cond_frame_num (`int`, *optional*, по умолчанию -1) : Максимальное количество кадров условий, используемых в памяти внимания. Установите -1, чтобы использовать все кадры условий.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *необязательный*, по умолчанию `True`) : Включает ли временное позиционное кодирование для указателей на объекты.

memory_attention_hidden_size (`int`, *optional*, по умолчанию 256) : Размерность скрытых состояний внимания памяти.

memory_attention_num_layers (`int`, *необязательный*, по умолчанию 2) : Количество слоёв в модуле внимания памяти.

memory_attention_num_attention_heads (`int`, *необязательный*, по умолчанию 1) : Количество головок внимания для каждого слоя внимания в памяти внимания.

memory_attention_downsample_rate (`int`, *optional*, по умолчанию 1) : Коэффициент downsampling для слоев внимания.

memory_attention_mlp_hidden_size (`int`, *optional*, по умолчанию 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`, *optional*, по умолчанию 0.1) : Коэффициент dropout для позиционного кодирования Rope.

rope_parameters (`dict`, *необязательный*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`.

perceiver_resampler_num_latents (`int`, *необязательный*, по умолчанию 256) : Количество одномерных латентных токенов в перцепторном ресемплере.

perceiver_resampler_num_latents_2d (`int`, *необязательный*, по умолчанию 256) : Количество 2D-латентных токенов в перцепторном ресемплере.

perceiver_resampler_hidden_size (`int`, *optional*, по умолчанию 64) : Размер скрытого слоя перцепторного ресемплера.

perceiver_resampler_mlp_intermediate_size (`int`, *optional*, по умолчанию 256) : Промежуточный размер сети прямого распространения в перцепторном ресемплере.

perceiver_resampler_num_attention_heads (`int`, *optional*, по умолчанию 1) : Количество головок внимания в перцепторном ресемплере.

perceiver_resampler_attention_head_dim (`int`, *optional*, по умолчанию 64) : Размерность каждой головы внимания в perceiver resampler.

perceiver_resampler_num_layers (`int`, *optional*, по умолчанию 2) : Количество слоёв в perceiver resampler.

perceiver_resampler_hidden_dropout (`float`, *optional*, по умолчанию 0.0) : Коэффициент dropout для скрытых слоев в perceiver resampler.

perceiver_resampler_attention_dropout (`float`, *optional*, по умолчанию 0.0) : Коэффициент dropout для слоев внимания в perceiver resampler.

memory_encoder_hidden_size (`int`, *optional*, по умолчанию 256) : Размерность скрытых состояний кодировщика памяти.

memory_encoder_output_channels (`int`, *optional*, по умолчанию 64) : Количество выходных каналов для кодировщика памяти.

mask_downsampler_embed_dim (`int`, *optional*, по умолчанию 256) : Размерность встраивания downsampler маски.

memory_fuser_intermediate_dim (`int`, *optional*, по умолчанию 1024) : Промежуточное измерение сети прямого распространения (feedforward) модуля слияния памяти.

mask_downsampler_kernel_size (`int`, *optional*, по умолчанию 3) : Размер ядра для downsampler маски.

mask_downsampler_stride (`int`, *optional*, по умолчанию 2) : Шаг для downsampler маски.

mask_downsampler_padding (`int`, *optional*, по умолчанию 1) : Отступ для модуля уменьшения маски.

mask_downsampler_total_stride (`int`, *optional*, по умолчанию 16) : Общий шаг для модуля уменьшения маски.

mask_downsampler_hidden_act (`str`, *необязательный*, по умолчанию `"gelu"`) : Нелинейная функция активации в модуле downsampler маски.

memory_fuser_num_layers (`int`, *необязательный*, по умолчанию 2) : Количество слоев в модуле слияния памяти.

memory_fuser_embed_dim (`int`, *optional*, по умолчанию 256) : Размерность встраивания memory fuser.

memory_fuser_kernel_size (`int`, *optional*, по умолчанию 7) : Размер ядра для модуля слияния памяти.

memory_fuser_padding (`int`, *необязательный*, по умолчанию 3) : Отступ для объединителя памяти.

memory_fuser_layer_scale_init_value (`float`, *optional*, по умолчанию 1e-06) : Начальное значение для масштаба слоя в модуле слияния памяти.

memory_fuser_hidden_act (`str`, *необязательный*, по умолчанию `"gelu"`) : Нелинейная функция активации в модуле слияния памяти.

Это класс конфигурации для хранения конфигурации модели EdgeTamVideoModel. Он используется для создания модели Edgetam Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L942)

**Параметры:**

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[[transformers.EdgeTamVideoInferenceSession.add_mask_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1062)

Добавьте входные маски с автоматическим размещением на устройстве.

#### add_new_frame[[transformers.EdgeTamVideoInferenceSession.add_new_frame]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1137)

Добавить новый кадр с автоматическим размещением на устройстве.

#### add_point_inputs[[transformers.EdgeTamVideoInferenceSession.add_point_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1048)

Добавьте входные данные в виде точек с автоматическим размещением на устройстве.

#### get_frame[[transformers.EdgeTamVideoInferenceSession.get_frame]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1153)

Получить кадр из видео.

#### get_obj_num[[transformers.EdgeTamVideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1043)

Получите общее количество уникальных идентификаторов объектов, полученных на данный момент в этой сессии.

#### get_output[[transformers.EdgeTamVideoInferenceSession.get_output]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1110)

**Параметры:**

obj_idx (int) : индекс объекта.

frame_idx (int) : Индекс кадра.

output_key (str) : Ключ вывода.

is_conditioning_frame (bool) : Указывает, является ли вывод для кадра, задающего условия.

Получите вывод с умным управлением устройствами.

#### obj_id_to_idx[[transformers.EdgeTamVideoInferenceSession.obj_id_to_idx]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1017)

Соответствие идентификатора объекта индексу, при необходимости создавая новую запись.

#### obj_idx_to_id[[transformers.EdgeTamVideoInferenceSession.obj_idx_to_id]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1039)

Соответствие индекса объекта на стороне модели идентификатору объекта на стороне клиента.

#### remove_mask_inputs[[transformers.EdgeTamVideoInferenceSession.remove_mask_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1068)

Удалите входные маски.

#### remove_point_inputs[[transformers.EdgeTamVideoInferenceSession.remove_point_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1058)

Удалите входные точки.

#### reset_inference_session[[transformers.EdgeTamVideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1169)

Сбросить данные отслеживания и кэш.

#### reset_tracking_data[[transformers.EdgeTamVideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1157)

Сбросить данные отслеживания, но сохранить кэш.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1073)

**Параметры:**

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[[transformers.EdgeTamVideoModel]]

#### transformers.EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

```python
transformers.EdgeTamVideoModel(config: EdgeTamVideoConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2062)

**Параметры:**

config ([EdgeTamVideoConfig](/docs/transformers/main/ru/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Edgetam Video в базовом виде, выводящая необработанные скрытые состояния без какого-либо специализированного слоя на выходе.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EdgeTamVideoModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2196)

**Параметры:**

inference_session (`~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession`) : объект сессии инференса видео.

frame_idx (`int`, *optional*) : Индекс кадра, на котором выполняется инференс. Не требуется указывать при инференсе на новом потоковом кадре.

frame (`torch.Tensor`, *необязательный*) : Кадры для обработки. Укажите при потоковой обработке.

reverse (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли распространять в обратном направлении.

**Возвращает:** `EdgeTamVideoSegmentationOutput` или `tuple(torch.Tensor)`

Объект `EdgeTamVideoSegmentationOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EdgeTamVideoConfig](/docs/transformers/main/ru/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) и входных данных.

Передайте объекты через кадр потокового видео.

- **object_ids** (`list[int]`, *необязательный*) -- Список идентификаторов объектов, отслеживаемых в текущем кадре.
- **pred_masks** (`torch.Tensor` формы `(batch_size, num_masks, height, width)`) -- Предсказанные маски, сохранённые в разрешении модели.
- **object_score_logits** (`torch.Tensor` формы `(batch_size,)`, *необязательный*) -- Логиты для оценок объектов, указывающие на наличие объектов.
- **frame_idx** (`int`, *необязательный*) -- Индекс кадра видео.

#### get_image_features[[transformers.EdgeTamVideoModel.get_image_features]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2295)

**Параметры:**

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](/docs/transformers/main/ru/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) и входных данных.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, height, width, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации 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`.