# VidEoMT

## Обзор

Модель VidEoMT была предложена в статье [Your ViT is Secretly Also a Video Segmentation Model](https://huggingface.co/papers/2602.17807) авторами Narges Norouzi, Idil Esen Zulfikar, Niccolò Cavagnero, Tommie Kerssies, Bastian Leibe, Gijs Dubbelman, Daan de Geus. Video Encoder-only Mask Transformer (VidEoMT) — это легкая модель только с энкодером для онлайн-сегментации видео, построенная на обычном [Vision Transformer (ViT)](vit). Она представляет собой минимальное расширение [EoMT](./eomt) для видео, выполняющее как пространственные, так и временные рассуждения внутри энкодера ViT, без использования специализированных модулей отслеживания или тяжелых специфичных для задачи головок.

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

*Существующие модели онлайн-сегментации видео, как правило, комбинируют посегментный сегментатор с комплексными специализированными модулями отслеживания. Хотя такие подходы эффективны, эти модули вносят значительную архитектурную сложность и вычислительные накладные расходы. Недавние исследования показывают, что стандартные кодировщики Vision Transformer (ViT), при условии масштабирования с достаточной ёмкостью и предобучением на больших данных, способны выполнять точную сегментацию изображений без необходимости в специализированных модулях. Исходя из этого наблюдения, мы предлагаем Video Encoder-only Mask Transformer (VidEoMT) — простую модель сегментации видео с архитектурой только кодировщика, которая исключает потребность в выделенных модулях отслеживания. Для обеспечения временного моделирования в ViT с архитектурой только кодировщика VidEoMT вводит лёгкий механизм распространения запросов, который передаёт информацию между кадрами путём повторного использования запросов из предыдущего кадра. Для баланса между этим и адаптивностью к новому контенту используется стратегия слияния запросов, которая объединяет распространённые запросы с набором обученных запросов, не зависящих от времени. В результате VidEoMT получает преимущества трекера без дополнительной сложности, достигая конкурентоспособной точности при скорости в 5–10 раз выше и работая со скоростью до 160 FPS с использованием базовой модели ViT-L.*

Советы:

- VidEoMT в настоящее время поддерживает только backbone DINOv2 (с register tokens). Доступные размеры моделей: ViT-S, ViT-B и ViT-L.
- Модель принимает видео как вход в виде 5-мерного тензора с формой `(batch_size, num_frames, 3, height, width)`.
- VidEoMT поддерживает три задачи сегментации видео: **сегментацию инстансов**, **семантическую сегментацию** и **паноптическую сегментацию**, для каждой из которых предусмотрен собственный метод постобработки в видео-процессоре.

Эта модель была предоставлена пользователем [nielsr](https://huggingface.co/nielsr). Исходный код можно найти [здесь](https://github.com/tue-mps/videomt).

## Информация об архитектуре

VidEoMT основан на [EoMT](./eomt), который использует обычный Vision Transformer, предварительно обученный на DINOv2, с **register tokens** в качестве модели сегментации. EoMT вводит обучаемые **object queries** и лёгкий **mask prediction head** непосредственно внутри энкодера ViT, что исключает необходимость в декодерах, специфичных для конкретной задачи.

VidEoMT расширяет этот подход на видео с двумя ключевыми дополнениями:

1. **Передача запросов**: объектные запросы из предыдущего кадра переносятся в следующий кадр с помощью линейной проекции (`query_updater`), что обеспечивает временнóе рассуждение без выделенного трекера.
2. **Слияние запросов**: распространённые запросы добавляются к набору обученных запросов, не зависящих от времени, что позволяет модели адаптироваться к новым объектам, появляющимся в видео.

Ранние слои энкодера обрабатывают все кадры независимо (параллельно), тогда как финальные блоки работают по кадрам с объединёнными запросами, формируя предсказания масок и классов для каждого кадра.

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

Используйте реализацию VidEoMT от Hugging Face для инференса с предобученными моделями. Приведённые ниже примеры переиспользуют публичный чекпоинт `tue-mps/videomt-dinov2-small-ytvis2019`, чтобы продемонстрировать постобработку видео для instance, semantic и panoptic сегментации на примере видео.

### Сегментация экземпляров на видео

```python
import matplotlib.pyplot as plt
import numpy as np
import torch

from transformers import AutoModelForUniversalSegmentation, AutoVideoProcessor
from transformers.video_utils import load_video

model_id = "tue-mps/videomt-dinov2-small-ytvis2019"
processor = AutoVideoProcessor.from_pretrained(model_id)
model = AutoModelForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

video_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/videos/pexels-allan-mas-5362370.mp4"
# Sample 8 frames to keep the example lightweight.
video_frames, _ = load_video(video_url, num_frames=8)

inputs = processor(videos=[video_frames], return_tensors="pt").to(model.device)

with torch.inference_mode():
    outputs = model(**inputs)

original_height, original_width = video_frames[0].shape[:2]
target_sizes = [(original_height, original_width)] * len(video_frames)

results = processor.post_process_instance_segmentation(
    outputs,
    target_sizes=target_sizes,
)

fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for idx, (ax, frame, result) in enumerate(zip(axes.flatten(), video_frames, results)):
    ax.imshow(frame)
    seg = result["segmentation"].cpu().numpy()
    masked = np.ma.masked_where(seg == -1, seg)
    ax.imshow(masked, alpha=0.6, cmap="tab20")
    ax.set_title(f"Frame {idx}")
    ax.axis("off")
plt.suptitle("Video Instance Segmentation")
plt.tight_layout()
plt.show()
```

### Семантическая сегментация видео

```python
import matplotlib.pyplot as plt
import torch

from transformers import AutoModelForUniversalSegmentation, AutoVideoProcessor
from transformers.video_utils import load_video

model_id = "tue-mps/videomt-dinov2-small-ytvis2019"
processor = AutoVideoProcessor.from_pretrained(model_id)
model = AutoModelForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

video_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/videos/pexels-allan-mas-5362370.mp4"
# Sample 8 frames to keep the example lightweight.
video_frames, _ = load_video(video_url, num_frames=8)

inputs = processor(videos=[video_frames], return_tensors="pt").to(model.device)

with torch.inference_mode():
    outputs = model(**inputs)

original_height, original_width = video_frames[0].shape[:2]
target_sizes = [(original_height, original_width)] * len(video_frames)

preds = processor.post_process_semantic_segmentation(
    outputs,
    target_sizes=target_sizes,
)

fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for idx, (ax, frame, seg_map) in enumerate(zip(axes.flatten(), video_frames, preds)):
    ax.imshow(frame)
    ax.imshow(seg_map.cpu().numpy(), alpha=0.6, cmap="tab20")
    ax.set_title(f"Frame {idx}")
    ax.axis("off")
plt.suptitle("Video Semantic Segmentation")
plt.tight_layout()
plt.show()
```

### Панорамная сегментация видео

```python
import matplotlib.pyplot as plt
import numpy as np
import torch

from transformers import AutoModelForUniversalSegmentation, AutoVideoProcessor
from transformers.video_utils import load_video

model_id = "tue-mps/videomt-dinov2-small-ytvis2019"
processor = AutoVideoProcessor.from_pretrained(model_id)
model = AutoModelForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

video_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/videos/pexels-allan-mas-5362370.mp4"
# Sample 8 frames to keep the example lightweight.
video_frames, _ = load_video(video_url, num_frames=8)

inputs = processor(videos=[video_frames], return_tensors="pt").to(model.device)

with torch.inference_mode():
    outputs = model(**inputs)

original_height, original_width = video_frames[0].shape[:2]
target_sizes = [(original_height, original_width)] * len(video_frames)

results = processor.post_process_panoptic_segmentation(
    outputs,
    target_sizes=target_sizes,
)

fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for idx, (ax, frame, result) in enumerate(zip(axes.flatten(), video_frames, results)):
    ax.imshow(frame)
    seg = result["segmentation"].cpu().numpy()
    masked = np.ma.masked_where(seg == -1, seg)
    ax.imshow(masked, alpha=0.6, cmap="tab20")
    ax.set_title(f"Frame {idx}")
    ax.axis("off")
plt.suptitle("Video Panoptic Segmentation")
plt.tight_layout()
plt.show()
```

## VideomtVideoProcessor[[transformers.VideomtVideoProcessor]]

#### transformers.VideomtVideoProcessor[[transformers.VideomtVideoProcessor]]

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

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

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

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' : 640, 'width': 640}`): Описывает максимальные размеры входных данных для модели.

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*, по умолчанию `False`) : Нужно ли выполнять центрированный кроп изображения.

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*, по умолчанию `False`) : Нужно ли выбирать кадры из видео перед обработкой или обрабатывать всё видео целиком.

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.

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

#### post_process_semantic_segmentation[[transformers.VideomtVideoProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]], return_segmentation_scores: bool = False)
```

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

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

outputs (`VideomtForUniversalSegmentationOutput`) : Сырые выходные данные модели.

target_sizes (`list[tuple[int, int]]`) : Список кортежей `(height, width)`, соответствующих запрашиваемому конечному размеру каждого предсказания. Длина должна совпадать с количеством кадров в выводе.

return_segmentation_scores (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать оценки сегментации вместе с картой сегментации. Если `True`, каждый элемент возвращаемого списка представляет собой `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`).

**Возвращает:** `list[torch.Tensor]` или `list[SemanticSegmentationPostProcessorOutput]`

Если `return_segmentation_scores=False` (по умолчанию), возвращается список длины `batch_size`, где каждый элемент — карта сегментации формы `(height, width)` с идентификаторами классов. Если `return_segmentation_scores=True`, возвращается список объектов `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`). В обоих случаях `(height, width)` соответствует целевому размеру.

Преобразует выход [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/ru/model_doc/videomt#transformers.VideomtForUniversalSegmentation) в предсказания семантической сегментации.

#### post_process_instance_segmentation[[transformers.VideomtVideoProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.5)
```

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

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

outputs (`VideomtForUniversalSegmentationOutput`) : Сырые выходные данные модели.

target_sizes (`list[tuple[int, int]]`) : Список кортежей `(height, width)`, соответствующих запрашиваемому конечному размеру каждого предсказания. Длина должна совпадать с количеством кадров в выводе.

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

**Возвращает:** `list[dict]`

Список словарей (по одному на кадр), каждый из которых содержит:
- `"segmentation"` — `torch.Tensor` формы `(height, width)` с идентификаторами инстансов (или -1 для фона).
- `"segments_info"` -- список словарей с `"id"`, `"label_id"` и `"score"` для каждого экземпляра.

Преобразует вывод [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/ru/model_doc/videomt#transformers.VideomtForUniversalSegmentation) в предсказания сегментации объектов.

#### post_process_panoptic_segmentation[[transformers.VideomtVideoProcessor.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None)
```

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

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

outputs (`VideomtForUniversalSegmentationOutput`) : Сырые выходные данные модели.

target_sizes (`list[tuple[int, int]]`) : Список кортежей `(height, width)`, соответствующих запрашиваемому конечному размеру каждого предсказания. Длина должна совпадать с количеством кадров в выводе.

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

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

overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.8) : Порог перекрытия для слияния масок в один сегмент.

label_ids_to_fuse (`set[int]`, *необязательный*) : Идентификаторы меток, которые должны быть объединены между несвязанными областями.

**Возвращает:** `list[dict]`

Список словарей (по одному на кадр), каждый из которых содержит:
- `"segmentation"` — `torch.Tensor` формы `(height, width)` с идентификаторами сегментов (или -1 для фона).
- `"segments_info"` -- список словарей с `"id"`, `"label_id"` и `"score"` для каждого сегмента.

Преобразует выход [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/ru/model_doc/videomt#transformers.VideomtForUniversalSegmentation) в предсказания паноптической сегментации.

## VideomtConfig[[transformers.VideomtConfig]]

#### transformers.VideomtConfig[[transformers.VideomtConfig]]

```python
transformers.VideomtConfig(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 = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 640, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, mlp_ratio: int = 4, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, num_upscale_blocks: int = 2, attention_dropout: float | int = 0.0, use_swiglu_ffn: bool = False, num_blocks: int = 4, no_object_weight: float = 0.1, class_weight: float = 2.0, mask_weight: float = 5.0, dice_weight: float = 5.0, train_num_points: int = 12544, oversample_ratio: float = 3.0, importance_sample_ratio: float = 0.75, num_queries: int = 200, num_register_tokens: int = 4)
```

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

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

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

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

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

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

hidden_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере.

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

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

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

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

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

mlp_ratio (`int`, *optional*, по умолчанию `4`) : Соотношение скрытого размера MLP к размеру эмбеддинга.

layerscale_value (`float`, *необязательный*, по умолчанию 1.0) : Начальное значение для параметра LayerScale.

drop_path_rate (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент drop path для слияния патчей.

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

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания.

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

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

no_object_weight (`float`, *необязательный*, по умолчанию 0.1) : Вес потерь для класса «нет объекта» в панорамной/инстанс-сегментации.

class_weight (`float`, *необязательный*, по умолчанию 2.0) : Вес потерь для целей классификации.

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

dice_weight (`float`, *необязательный*, по умолчанию `5.0`) : Относительный вес функции потерь dice в функции потерь паноптической сегментации.

train_num_points (`int`, *optional*, по умолчанию 12544) : Количество точек для выборки при вычислении потерь маски во время обучения.

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

importance_sample_ratio (`float`, *optional*, по умолчанию 0.75) : Доля точек, отбираемых на основе важности во время обучения.

num_queries (`int`, *optional*, по умолчанию 200) : Количество объектных запросов в Transformer.

num_register_tokens (`int`, *optional*, по умолчанию 4) : Количество обучаемых регистрационных токенов, добавляемых на вход трансформера.

Это класс конфигурации для хранения настроек модели VideomtModel. Он используется для создания модели Videomt в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [tue-mps/videomt-dinov2-small-ytvis2019](https://huggingface.co/tue-mps/videomt-dinov2-small-ytvis2019)

Объекты конфигурации наследуются от [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 VideomtConfig, VideomtForUniversalSegmentation

>>> # Initialize configuration
>>> config = VideomtConfig()

>>> # Initialize model
>>> model = VideomtForUniversalSegmentation(config)

>>> # Access config
>>> config = model.config
```

## VideomtPreTrainedModel[[transformers.VideomtPreTrainedModel]]

#### transformers.VideomtPreTrainedModel[[transformers.VideomtPreTrainedModel]]

```python
transformers.VideomtPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

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

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

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

Эта модель наследуется от [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.VideomtPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Мок-значение для пути с точками (например, `torch.float32`): цепочки доступа к атрибутам и вызовы работают как пропускные декораторы, `repr` возвращает путь с точками, а использование в качестве базового класса подменяет его обычным базовым классом `type` (PEP 560 `__mro_entries__`), благодаря чему реальные дочерние классы сохраняют обычный метакласс, а `inspect.signature` читает их реальный `__init__`, а не мок.

## VideomtForUniversalSegmentation[[transformers.VideomtForUniversalSegmentation]]

#### transformers.VideomtForUniversalSegmentation[[transformers.VideomtForUniversalSegmentation]]

```python
transformers.VideomtForUniversalSegmentation(config: VideomtConfig)
```

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

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

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

Модель Videomt с головой сверху для сегментации объектов/семантической/паноптической сегментации.

Эта модель наследуется от [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.VideomtForUniversalSegmentation.forward]]

```python
forward(pixel_values_videos: typing.Optional[torch.Tensor] = None, mask_labels: list[torch.Tensor] | None = None, class_labels: list[torch.Tensor] | None = None, patch_offsets: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

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

pixel_values_videos (`torch.Tensor`, *необязательный*) : Входы видео с формой `(batch_size, num_frames, num_channels, height, width)`.

mask_labels (`list[torch.Tensor]`, *необязательный*) : Не поддерживается для 5D-видеовходов.

class_labels (`list[torch.LongTensor]`, *необязательный*) : Не поддерживается для 5D-видеовходов.

patch_offsets (`list[torch.Tensor]`, *необязательный*) : Не используется для видеовходов и сохраняется только для модульной совместимости.

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

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

Метод forward класса [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/ru/model_doc/videomt#transformers.VideomtForUniversalSegmentation) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor`, *optional*) -- Вычисленная величина потерь, возвращается при наличии меток.
- **class_queries_logits** (`torch.Tensor`, *optional*) — тензор формы `(batch_size, num_queries, num_labels + 1)`, представляющий предложенные классы для каждого запроса. Обратите внимание, что `+ 1` необходимо, так как мы учитываем нулевой класс.
- **masks_queries_logits** (`torch.Tensor`, *необязательный*) -- тензор формы `(batch_size, num_queries, height, width)`, представляющий предложенные маски для каждого запроса.
- **last_hidden_state** (`torch.Tensor` формы `(batch_size, num_channels, height, width)`) -- Состояния последнего скрытого слоя (финальная карта признаков) последнего слоя.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) — Кортеж `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого этапа) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния всех слоёв модели.
- **attentions** (`tuple(tuple(torch.Tensor))`, *optional*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) -- Кортеж `tuple(torch.Tensor)` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса Self и Cross Attention из декодера трансформера.