# SAM2 Video

    
        
        
    

## Обзор

SAM2 (Segment Anything Model 2) был предложен в статье [Segment Anything in Images and Videos](https://ai.meta.com/research/publications/sam-2-segment-anything-in-images-and-videos/) Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer.

Модель может использоваться для предсказания масок сегментации любого объекта интереса по входному изображению или видео, а также входным точкам или ограничивающим рамкам.

![example image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam2_header.gif)

Аннотация из статьи следующая:

*Мы представляем Segment Anything Model 2 (SAM 2) — фундаментальную модель для решения задачи интерактивной визуальной сегментации на изображениях и в видео. Мы создали движок данных, который совершенствует модель и данные за счёт взаимодействия с пользователем, и с его помощью собрали крупнейший на сегодняшний день датасет для сегментации видео. Наша модель построена на простой архитектуре трансформера с потоковой памятью для обработки видео в реальном времени. SAM 2, обученный на наших данных, демонстрирует высокую производительность на широком спектре задач. В задаче сегментации видео мы наблюдаем более высокую точность при использовании в 3 раза меньше взаимодействий, чем в предыдущих подходах. В задаче сегментации изображений наша модель точнее и в 6 раз быстрее, чем Segment Anything Model (SAM). Мы считаем, что наши данные, модель и полученные результаты станут значимой вехой для сегментации видео и связанных с ней задач восприятия. Мы публикуем версию нашей модели, датасет и интерактивную демонстрацию.*

Советы:

- Поддержка пакетной обработки и видео: SAM2 изначально поддерживает пакетную обработку и бесшовную сегментацию видео, тогда как исходная SAM разработана для статичных изображений и более простых сценариев работы с одним изображением за раз.
- Точность и обобщение: SAM2 демонстрирует улучшенное качество сегментации, устойчивость и способность к обобщению в режиме zero-shot на новые домены по сравнению с исходной моделью SAM, особенно при использовании смешанных промптов.

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

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

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

Ключевое преимущество SAM2 — его способность отслеживать объекты между кадрами видео. Вот как использовать его для сегментации видео:

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

```python
from transformers import Sam2VideoModel, Sam2VideoProcessor
import torch

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

# Load video frames (example assumes you have a list of PIL Images)
# video_frames = [Image.open(f"frame_{i:05d}.jpg") for i in range(num_frames)]

# For this example, we'll use the video loading utility
from transformers.video_utils import load_video
video_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/bedroom.mp4"
video_frames, _ = load_video(video_url)

# Initialize video inference session
inference_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
)

# Add click on first frame to select object
ann_frame_idx = 0
ann_obj_id = 1
points = [[[[210, 350]]]]
labels = [[[1]]]

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=ann_obj_id,
    input_points=points,
    input_labels=labels,
)

# Segment the object on the first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Segmentation shape: {video_res_masks.shape}")
Segmentation shape: torch.Size([1, 1, 480, 854])

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

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

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

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

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

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

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

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

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

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

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

## Ресурсы

Список официальных ресурсов Hugging Face и сообщества (отмечены значком 🌎), которые помогут вам начать работу с SAM.

- [Демо-ноутбук 🌎](https://colab.research.google.com/drive/1Z0NGLE7p8qnc9UpuI8KBETHd2xBbOEhv?usp=sharing) по использованию модели, предоставленный [Sangbum Choi](https://github.com/SangbumChoi).

## Sam2VideoConfig[[transformers.Sam2VideoConfig]]

#### transformers.Sam2VideoConfig[[transformers.Sam2VideoConfig]]

```python
transformers.Sam2VideoConfig(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 = 4, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_feed_forward_hidden_size: int = 2048, memory_attention_feed_forward_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list[int] | None = None, memory_attention_rope_dropout: float | int = 0.1, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, rope_parameters: dict | None = None, mask_downsampler_embed_dim: int = 256, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu')
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/configuration_sam2_video.py#L96)

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

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

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

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

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

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`, *необязательный*, по умолчанию 4) : Количество слоёв в модуле внимания памяти.

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

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

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

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

memory_attention_dropout (`float`, *необязательный*, по умолчанию 0.1) : Коэффициент dropout для модуля внимания памяти.

memory_attention_rope_feat_sizes (`list[int]`, *необязательный*, по умолчанию `[64, 64]`) : Размеры признаков для позиционного кодирования Rope.

memory_attention_rope_dropout (`float`, *optional*, по умолчанию 0.1) : Коэффициент dropout для позиционного кодирования Rope.

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

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

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

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

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_intermediate_dim (`int`, *optional*, по умолчанию 1024) : Размерность промежуточного слоя в модуле слияния памяти.

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"`) : Нелинейная функция активации в модуле memory fuser.

Это класс конфигурации для хранения настроек модели Sam2VideoModel. Он используется для создания модели Sam2 Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

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

Пример:

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

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

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

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

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

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

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

## Sam2VideoMaskDecoderConfig[[transformers.Sam2VideoMaskDecoderConfig]]

#### transformers.Sam2VideoMaskDecoderConfig[[transformers.Sam2VideoMaskDecoderConfig]]

```python
transformers.Sam2VideoMaskDecoderConfig(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/v5.23.0/src/transformers/models/sam2_video/configuration_sam2_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) : Порог стабильности для динамической мультимаски.

Это класс конфигурации для хранения настроек модели Sam2VideoModel. Он используется для создания модели Sam2 Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

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

## Sam2VideoPromptEncoderConfig[[transformers.Sam2VideoPromptEncoderConfig]]

#### transformers.Sam2VideoPromptEncoderConfig[[transformers.Sam2VideoPromptEncoderConfig]]

```python
transformers.Sam2VideoPromptEncoderConfig(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/v5.23.0/src/transformers/models/sam2_video/configuration_sam2_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) : Коэффициент масштабирования для кодировщика промпта.

Это класс конфигурации для хранения настроек модели Sam2VideoModel. Он используется для создания модели Sam2 Video в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

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

## Sam2VideoProcessor[[transformers.Sam2VideoProcessor]]

#### transformers.Sam2VideoProcessor[[transformers.Sam2VideoProcessor]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L37)

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

image_processor (`Sam2ImageProcessor`) : процессор изображений является обязательным входным параметром.

video_processor (`Sam2VideoVideoProcessor`) : процессор видео является обязательным входным параметром.

target_size (`int`, *optional*) : Целевой размер (в пикселях) для нормализации входных точек и ограничивающих прямоугольников. Если не указан, по умолчанию используется конфигурация размера процессора изображений. Все входные координаты (точки и прямоугольники) нормализуются до этого размера перед передачей в модель. Это обеспечивает согласованное представление координат независимо от исходных размеров изображения.

point_pad_value (`int`, *optional*, по умолчанию -10) : Значение, используемое для дополнения входных точек при пакетной обработке последовательностей разной длины. Это значение используется для пометки дополненных позиций и сохраняется при нормализации координат.

Создаёт Sam2VideoProcessor, который объединяет процессор изображений и процессор видео в единый процессор.

[Sam2VideoProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2_video#transformers.Sam2VideoProcessor) предоставляет все возможности [Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor) и [Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor). Подробнее см. в [~Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor) и [~Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor).

#### __call__[[transformers.Sam2VideoProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, input_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L55)

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

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *необязательный*) : Изображение для предварительной обработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`.

segmentation_maps (`ImageInput`, *необязательный*) : карты сегментации для обработки.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *необязательный*) : Точки, которые нужно добавить в систему координат.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *необязательный*) : Метки для точек.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *необязательный*) : Границы объектов, которые нужно добавить в кадр.

original_sizes (`list[list[float]]`, `torch.Tensor`, *необязательный*) : Исходные размеры изображений.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *необязательный*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

**Возвращает:** [BatchEncoding](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.BatchEncoding) со следующими полями

- `pixel_values` (`torch.Tensor`): Обработанное изображение или изображения.
- `original_sizes` (`list[list[float]]`): исходные размеры изображений.
- `labels` (`torch.Tensor`): Обработанные карты сегментации (если предоставлены).
- `input_points` (`torch.Tensor`): Обработанные точки.
- `input_labels` (`torch.Tensor`): Обработанные метки.
- `input_boxes` (`torch.Tensor`): Обработанные ограничивающие рамки.

#### post_process_masks[[transformers.Sam2VideoProcessor.post_process_masks]]

```python
post_process_masks(masks, original_sizes, mask_threshold = 0.0, binarize = True, max_hole_area = 0.0, max_sprinkle_area = 0.0, apply_non_overlapping_constraints = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L461)

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

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Пакетные маски из mask_decoder в формате (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : исходные размеры каждого изображения до его изменения до ожидаемой входной формы модели, в формате (высота, ширина).

mask_threshold (`float`, *необязательный*, по умолчанию 0.0) : Порог для бинаризации и операций постобработки.

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

max_hole_area (`float`, *необязательный*, по умолчанию 0.0) : Максимальная площадь отверстия, подлежащего заполнению.

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

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

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

Маски в формате batch_size, num_channels, height, width, где (height, width) задается параметром original_size.

Удалите заполнение (padding) и масштабируйте маски до исходного размера изображения.

#### init_video_session[[transformers.Sam2VideoProcessor.init_video_session]]

```python
init_video_session(video: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, inference_device: typing.Union[str, ForwardRef('torch.device')] = 'cpu', inference_state_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, processing_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, video_storage_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, max_vision_features_cache_size: int = 1, dtype: dtype = torch.float32)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L512)

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

video (`VideoInput`, *необязательный*) : Видео для обработки. Не требуется при потоковой передаче.

inference_device (`str` или `torch.device`, *необязательный*, по умолчанию "cpu") : Устройство, используемое для вывода.

inference_state_device (`str` или `torch.device`, *необязательный*) : Устройство, на котором хранится состояние инференса.

processing_device (`str` или `torch.device`, *необязательный*) : Устройство, используемое для обработки видео.

video_storage_device (`str` или `torch.device`, *необязательный*) : Устройство, на котором будут храниться обработанные кадры видео.

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

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

Инициализирует видеосессию для инференса. Если видео предоставлено (асинхронный инференс), оно будет обработано и сохранено на `video_storage_device`.

#### add_inputs_to_inference_session[[transformers.Sam2VideoProcessor.add_inputs_to_inference_session]]

```python
add_inputs_to_inference_session(inference_session: Sam2VideoInferenceSession, frame_idx: int, obj_ids: list[int] | int, input_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, input_masks: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], NoneType] = None, original_size: tuple[int, int] | None = None, clear_old_inputs: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L565)

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

inference_session (`Sam2VideoInferenceSession`) : сессия инференса для видео.

frame_idx (`int`) : Индекс обрабатываемого кадра.

obj_ids (`list[int]` или `int`) : Идентификатор(ы) объекта, который нужно связать с точками или рамкой. Это могут быть любые целые числа, которые можно повторно использовать позже для указания объекта.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *необязательный*) : Точки, которые нужно добавить в систему координат.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *необязательный*) : Метки для точек.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *необязательный*) : Границы объектов, которые нужно добавить в кадр.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]` или `list[torch.Tensor]`, *необязательно*) : Маска(и), которую(е) нужно добавить к кадру.

original_size (`tuple[int, int]`, *необязательный*) : исходный размер видео. Укажите при потоковой передаче.

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

Обрабатывайте новые точки, рамки или маски для кадра видео и добавляйте их в сессию инференса.

## Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

#### transformers.Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/video_processing_sam2_video.py#L27)

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

do_convert_rgb (`bool`, *kwargs*, *необязательный*, по умолчанию `True`) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли изменять размер изображения.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'height' : 1024, 'width': 1024}`): Описывает максимальные размеры входных данных для модели.

default_to_square (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Использовать ли квадратное изображение по умолчанию при изменении размера, если size является int.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, по умолчанию `2`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только если `do_resize` установлено в `True`.

do_rescale (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00392156862745098`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.485, 0.456, 0.406]`) : Средние значения изображения, используемые для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.229, 0.224, 0.225]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке.

do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео.

do_sample_frames (`bool`, *kwargs*, *optional*) : Нужно ли выбирать кадры из видео перед обработкой или обрабатывать всё видео целиком.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Метаданные видео, содержащие информацию о общей длительности, fps и общем количестве кадров. Будут использоваться для выборки кадров из видео или вычисления временных меток. Не передавайте метаданные, если вы не пытаетесь декодировать видео вручную перед обработкой

fps (`Annotated[int | float | None, None]`, *kwargs*) : Целевое количество кадров для выборки в секунду при `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Максимальное количество кадров для выборки при `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Нужно ли возвращать метаданные видео. Метаданные видео — это объект, содержащий информацию о длительности видео, частоте кадров, бэкенде декодирования и т. д.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/ru/main_classes/processors#transformers.VideosKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

Создаёт процессор видео Sam2VideoVideoProcessor.

#### post_process_masks[[transformers.Sam2VideoVideoProcessor.post_process_masks]]

```python
post_process_masks(masks, original_sizes, reshaped_input_sizes, mask_threshold = 0.0, binarize = True, pad_size = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/video_processing_sam2_video.py#L58)

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

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Пакетные маски из mask_decoder в формате (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : исходные размеры каждого изображения до его изменения до ожидаемой входной формы модели, в формате (высота, ширина).

reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Размер каждого изображения, передаваемого в модель, в формате (высота, ширина). Используется для удаления отступов.

mask_threshold (`float`, *необязательный*, по умолчанию 0.0) : Порог, используемый для бинаризации масок.

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

pad_size (`int`, *необязательный*, по умолчанию `self.pad_size`) : Целевой размер, до которого изображения были дополнены перед передачей в модель. Если значение равно None, целевой размер считается равным `pad_size` процессора.

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

Маски в формате batch_size, num_channels, height, width, где (height, width) задается параметром original_size.

Удалите заполнение (padding) и масштабируйте маски до исходного размера изображения.

## Sam2VideoInferenceSession[[transformers.Sam2VideoInferenceSession]]

#### transformers.Sam2VideoInferenceSession[[transformers.Sam2VideoInferenceSession]]

```python
transformers.Sam2VideoInferenceSession(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/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L109)

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

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.Sam2VideoInferenceSession.add_mask_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L229)

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

#### add_new_frame[[transformers.Sam2VideoInferenceSession.add_new_frame]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L304)

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

#### add_point_inputs[[transformers.Sam2VideoInferenceSession.add_point_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L215)

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

#### get_frame[[transformers.Sam2VideoInferenceSession.get_frame]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L320)

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

#### get_obj_num[[transformers.Sam2VideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L210)

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

#### get_output[[transformers.Sam2VideoInferenceSession.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/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L277)

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

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

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

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

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

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

#### obj_id_to_idx[[transformers.Sam2VideoInferenceSession.obj_id_to_idx]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L184)

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

#### obj_idx_to_id[[transformers.Sam2VideoInferenceSession.obj_idx_to_id]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L206)

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

#### remove_mask_inputs[[transformers.Sam2VideoInferenceSession.remove_mask_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L235)

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

#### remove_point_inputs[[transformers.Sam2VideoInferenceSession.remove_point_inputs]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L225)

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

#### reset_inference_session[[transformers.Sam2VideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L336)

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

#### reset_tracking_data[[transformers.Sam2VideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L324)

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

#### store_output[[transformers.Sam2VideoInferenceSession.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/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L240)

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

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, вывод сохраняется в виде словаря.

## Sam2VideoModel[[transformers.Sam2VideoModel]]

#### transformers.Sam2VideoModel[[transformers.Sam2VideoModel]]

```python
transformers.Sam2VideoModel(config: Sam2VideoConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1643)

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

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

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

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

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

#### forward[[transformers.Sam2VideoModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1776)

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

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : объект сессии видеоинференса.

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

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

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

run_mem_encoder (`bool`, *необязательный*, по умолчанию `True`) : Запускать ли кодировщик памяти на предсказанных масках. Кодировщик памяти обрабатывает все объекты в одном батче для повышения эффективности.

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

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

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

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

#### propagate_in_video_iterator[[transformers.Sam2VideoModel.propagate_in_video_iterator]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L2797)

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

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : объект сессии видеоинференса.

start_frame_idx (`int`, *optional*) : Начальный индекс кадра для распространения. Необходимо указать, если `forward` ещё не вызывался для новых входных данных. Если не указано, начальным индексом кадра станет самый ранний кадр с входными точками.

max_frame_num_to_track (`int`, *необязательный*) : Максимальное количество кадров для отслеживания.

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

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

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

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

Передаёт объекты через кадры видео. Используется при инициализации сессии инференса с целым видео. Возвращает Sam2VideoSegmentationOutput для каждого кадра.

- **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.Sam2VideoModel.get_image_features]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1901)

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

pixel_values (`torch.Tensor`) : Входные значения пикселей формы `(batch_size, num_channels, height, width)`.

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

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

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

