# VidEoMT

## Resumen

El modelo VidEoMT fue propuesto en [Your ViT is Secretly Also a Video Segmentation Model](https://huggingface.co/papers/2602.17807) por Narges Norouzi, Idil Esen Zulfikar, Niccolò Cavagnero, Tommie Kerssies, Bastian Leibe, Gijs Dubbelman y Daan de Geus. Video Encoder-only Mask Transformer (VidEoMT) es un modelo ligero, solo de codificador, para segmentación de video en línea, construido sobre un [Vision Transformer (ViT)](vit) estándar. Es una extensión mínima de [EoMT](./eomt) al dominio del video, que realiza razonamiento tanto espacial como temporal dentro del codificador ViT, sin depender de módulos de seguimiento dedicados ni de cabezas específicas de la tarea pesadas.

El resumen del artículo es el siguiente:

*Los modelos existentes de segmentación de video en línea suelen combinar un segmentador por cuadro con módulos de seguimiento especializados y complejos. Si bien son eficaces, estos módulos introducen una complejidad arquitectónica y una sobrecarga computacional significativas. Estudios recientes sugieren que los codificadores Vision Transformer (ViT) estándar, cuando se escalan con capacidad suficiente y preentrenamiento a gran escala, pueden realizar una segmentación de imágenes precisa sin necesidad de módulos especializados. Motivados por esta observación, proponemos el Video Encoder-only Mask Transformer (VidEoMT), un modelo simple de segmentación de video solo con codificador que elimina la necesidad de módulos de seguimiento dedicados. Para habilitar la modelización temporal en un ViT solo con codificador, VidEoMT introduce un mecanismo ligero de propagación de consultas que transporta información entre cuadros reutilizando las consultas del cuadro anterior. Para equilibrar esto con la adaptabilidad a nuevo contenido, emplea una estrategia de fusión de consultas que combina las consultas propagadas con un conjunto de consultas aprendidas agnósticas al tiempo. Como resultado, VidEoMT obtiene los beneficios de un rastreador sin complejidad añadida, logrando una precisión competitiva mientras es de 5 a 10 veces más rápido, funcionando a hasta 160 FPS con un backbone ViT-L.*

Consejos:

- VidEoMT actualmente solo admite un backbone DINOv2 (con tokens de registro). Los tamaños de modelo disponibles son ViT-S, ViT-B y ViT-L.
- El modelo acepta la entrada de video como un tensor de 5 dimensiones con forma `(batch_size, num_frames, 3, height, width)`.
- VidEoMT admite tres tareas de segmentación de video: segmentación **de instancias**, segmentación **semántica** y segmentación **panóptica**, cada una con un método de posprocesamiento dedicado en el procesador de video.

Este modelo fue aportado por [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/tue-mps/videomt).

## Información de la arquitectura

VidEoMT se basa en [EoMT](./eomt), que reutiliza un Vision Transformer preentrenado con DINOv2 y **register tokens** como modelo de segmentación. EoMT introduce **object queries** aprendidas y una **mask prediction head** ligera directamente dentro del codificador ViT, eliminando la necesidad de decodificadores específicos para la tarea.

VidEoMT extiende esto al video con dos adiciones clave:

1. **Propagación de consultas**: las consultas de objetos del fotograma anterior se llevan al siguiente mediante una proyección lineal (`query_updater`), lo que permite el razonamiento temporal sin un rastreador dedicado.
2. **Fusión de consultas**: las consultas propagadas se suman a un conjunto de consultas aprendidas que no dependen del tiempo, lo que permite al modelo adaptarse a nuevos objetos que aparecen en el video.

Las capas iniciales del codificador procesan todos los fotogramas de forma independiente (en paralelo), mientras que los bloques finales operan por fotograma con las consultas fusionadas, generando predicciones de máscara y clase por fotograma.

## Ejemplos de uso

Utilice la implementación de VidEoMT de Hugging Face para realizar inferencia con modelos preentrenados. Los ejemplos siguientes reutilizan el checkpoint público `tue-mps/videomt-dinov2-small-ytvis2019` para demostrar el postprocesado de instancias, semántico y panóptico de video en un video de muestra.

### Segmentación de instancias en video

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

### Segmentación semántica de video

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

### Segmentación Panóptica de Video

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/video_processing_videomt.py#L147)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 640, 'width': 640}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_center_crop (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe recortar la imagen centrada.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos objetivo a muestrear por segundo cuando `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Número máximo de fotogramas a muestrear cuando `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe devolver o no la metadatos del video. Los metadatos del video son un objeto que contiene información sobre la duración del video, los fps, el backend de decodificación, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.VideosKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/video_processing_videomt.py#L178)

**Parámetros:**

outputs (`VideomtForUniversalSegmentationOutput`) : Salidas sin procesar del modelo.

target_sizes (`list[tuple[int, int]]`) : Lista de tuplas `(height, width)` que corresponden al tamaño final solicitado de cada predicción. La longitud debe coincidir con el número de fotogramas en la salida.

return_segmentation_scores (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las puntuaciones de segmentación junto con el mapa de segmentación. Cuando `True`, cada elemento de la lista devuelta es un `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`).

**Devuelve:** `list[torch.Tensor]` o `list[SemanticSegmentationPostProcessorOutput]`

Cuando `return_segmentation_scores=False` (valor predeterminado), se devuelve una lista de longitud `batch_size` donde cada elemento es un mapa de segmentación de forma `(height, width)` con IDs de clase. Cuando `return_segmentation_scores=True`, se devuelve una lista de `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). En ambos casos, `(height, width)` corresponde al tamaño objetivo.

Convierte la salida de [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtForUniversalSegmentation) en predicciones de segmentación semántica.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/video_processing_videomt.py#L232)

**Parámetros:**

outputs (`VideomtForUniversalSegmentationOutput`) : Salidas sin procesar del modelo.

target_sizes (`list[tuple[int, int]]`) : Lista de tuplas `(height, width)` que corresponden al tamaño final solicitado de cada predicción. La longitud debe coincidir con el número de fotogramas en la salida.

threshold (`float`, *opcional*, valor predeterminado 0.5) : Puntuación combinada mínima para conservar una instancia.

**Devuelve:** `list[dict]`

Una lista de diccionarios (uno por fotograma), cada uno que contiene:
- `"segmentation"` -- Un `torch.Tensor` de forma `(height, width)` con IDs de instancia (o -1 para el fondo).
- `"segments_info"` -- Una lista de diccionarios con `"id"`, `"label_id"` y `"score"` para cada instancia.

Convierte la salida de [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtForUniversalSegmentation) en predicciones de segmentación de instancias.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/video_processing_videomt.py#L301)

**Parámetros:**

outputs (`VideomtForUniversalSegmentationOutput`) : Salidas sin procesar del modelo.

target_sizes (`list[tuple[int, int]]`) : Lista de tuplas `(height, width)` que corresponden al tamaño final solicitado de cada predicción. La longitud debe coincidir con el número de fotogramas en la salida.

threshold (`float`, *opcional*, valor predeterminado 0.8) : Puntuación mínima para conservar un segmento predicho.

mask_threshold (`float`, *opcional*, valor predeterminado 0.5) : Umbral para binarizar las probabilidades de la máscara.

overlap_mask_area_threshold (`float`, *opcional*, valor predeterminado 0.8) : Umbral de solapamiento para fusionar máscaras en un solo segmento.

label_ids_to_fuse (`set[int]`, *opcional*) : IDs de etiquetas que deben fusionarse entre regiones desconectadas.

**Devuelve:** `list[dict]`

Una lista de diccionarios (uno por fotograma), cada uno que contiene:
- `"segmentation"` -- Un `torch.Tensor` de forma `(height, width)` con IDs de segmento (o -1 para el fondo).
- `"segments_info"` -- Una lista de diccionarios con `"id"`, `"label_id"` y `"score"` para cada segmento.

Convierte la salida de [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtForUniversalSegmentation) en predicciones de segmentación panóptica.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/configuration_videomt.py#L29)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `24`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La probabilidad de dropout para todas las capas completamente conectadas en los embeddings, el codificador y el pooler.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `640`) : El tamaño (resolución) de cada imagen.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

mlp_ratio (`int`, *opcional*, valor predeterminado `4`) : Proporción entre la dimensión oculta del MLP y la dimensión de incrustación.

layerscale_value (`float`, *opcional*, valor predeterminado 1.0) : Valor inicial para el parámetro LayerScale.

drop_path_rate (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : Tasa de drop path para la fusión de parches.

num_upscale_blocks (`int`, *opcional*, valor predeterminado 2) : Número de bloques de remuestreo ascendente utilizados en el decodificador o la cabeza de segmentación.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

use_swiglu_ffn (`bool`, *opcional*, por defecto `False`) : Si se debe usar la red neuronal de avance SwiGLU.

num_blocks (`int`, *opcional*, valor predeterminado 4) : Número de bloques de características o etapas en la arquitectura.

no_object_weight (`float`, *opcional*, valor predeterminado 0.1) : Peso de la pérdida para la clase 'no object' en la segmentación panoptica/instancia.

class_weight (`float`, *opcional*, valor predeterminado 2.0) : Peso de la pérdida para los objetivos de clasificación.

mask_weight (`float`, *opcional*, valor predeterminado 5.0) : Peso de la pérdida para la predicción de la máscara.

dice_weight (`float`, *opcional*, valor predeterminado `5.0`) : Peso relativo de la pérdida dice en la pérdida de segmentación panóptica.

train_num_points (`int`, *opcional*, valor predeterminado 12544) : Número de puntos a muestrear para el cálculo de la pérdida de máscara durante el entrenamiento.

oversample_ratio (`float`, *opcional*, valor predeterminado 3.0) : Relación de sobremuestreo utilizada en el muestreo de puntos para el entrenamiento de máscaras.

importance_sample_ratio (`float`, *opcional*, valor predeterminado 0.75) : Proporción de puntos a muestrear en función de la importancia durante el entrenamiento.

num_queries (`int`, *opcional*, valor predeterminado 200) : Número de consultas de objetos en el Transformer.

num_register_tokens (`int`, *opcional*, valor predeterminado: 4) : Número de tokens de registro aprendibles añadidos a la entrada del transformer.

Esta es la clase de configuración para almacenar la configuración de un VideomtModel. Se utiliza para instanciar un modelo Videomt según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [tue-mps/videomt-dinov2-small-ytvis2019](https://huggingface.co/tue-mps/videomt-dinov2-small-ytvis2019)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/modeling_videomt.py#L924)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.

## VideomtForUniversalSegmentation[[transformers.VideomtForUniversalSegmentation]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/modeling_videomt.py#L1044)

**Parámetros:**

config ([VideomtConfig](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Videomt con una cabeza en la parte superior para segmentación de instancias/semántica/panóptica.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/videomt/modeling_videomt.py#L1103)

**Parámetros:**

pixel_values_videos (`torch.Tensor`, *opcional*) : Entradas de video con forma `(batch_size, num_frames, num_channels, height, width)`.

mask_labels (`list[torch.Tensor]`, *opcional*) : No se admite para entradas de vídeo de 5D.

class_labels (`list[torch.LongTensor]`, *opcional*) : No se admite para entradas de vídeo de 5D.

patch_offsets (`list[torch.Tensor]`, *opcional*) : No se utiliza para entradas de video y se conserva únicamente por compatibilidad modular.

**Devuelve:** `VideomtForUniversalSegmentationOutput` o `tuple(torch.Tensor)`

Un `VideomtForUniversalSegmentationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([VideomtConfig](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtConfig)) y las entradas.

El método forward de [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/videomt#transformers.VideomtForUniversalSegmentation) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor`, *opcional*) -- La pérdida calculada, devuelta cuando hay etiquetas presentes.
- **class_queries_logits** (`torch.Tensor`, *opcional*) -- Un tensor de forma `(batch_size, num_queries, num_labels + 1)` que representa las clases propuestas para cada consulta. Tenga en cuenta que el `+ 1` es necesario porque incorporamos la clase nula.
- **masks_queries_logits** (`torch.Tensor`, *opcional*) -- Un tensor de forma `(batch_size, num_queries, height, width)` que representa las máscaras propuestas para cada consulta.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Últimos estados ocultos (mapa de características final) de la última capa.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos de todas las capas del modelo.
- **attentions** (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `tuple(torch.Tensor)` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de Self y Cross Attentions del decodificador del transformer.

