Hugging Face's logo

Transformers documentation

VidEoMT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 19 de febrero de 2026 y se contribuyó a Hugging Face Transformers el 25 de marzo de 2026.

VidEoMT

Resumen

El modelo VidEoMT fue propuesto en Your ViT is Secretly Also a Video Segmentation Model 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) estándar. Es una extensión mínima de 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. El código original se puede encontrar aquí.

Información de la arquitectura

VidEoMT se basa en 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

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

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

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

clase transformers.VideomtVideoProcessor

< >

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

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 de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado True) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto 2) — Filtro de remuestreo a 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) — 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 a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_center_crop (bool, kwargs, opcional, valor predeterminado False) — 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • do_sample_frames (bool, kwargs, opcional, valor predeterminado False) — 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 pase ningún metadato a menos que intente decodificar el video manualmente antes de procesarlo
  • fps (Annotated[int | float | None, None], kwargs) — Fotogramas 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 vídeo. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, 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, 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

< >

( outputstarget_sizes: listreturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

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 (por defecto), 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 en predicciones de segmentación semántica.

post_process_instance_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.5 ) → list[dict]

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 en predicciones de segmentación de instancias.

post_process_panoptic_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.8mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8label_ids_to_fuse: set[int] | None = None ) → list[dict]

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 único 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 en predicciones de segmentación panóptica.

VideomtConfig

clase transformers.VideomtConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, int] = 640patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3mlp_ratio: int = 4layerscale_value: float = 1.0drop_path_rate: float | int = 0.0num_upscale_blocks: int = 2attention_dropout: float | int = 0.0use_swiglu_ffn: bool = Falsenum_blocks: int = 4no_object_weight: float = 0.1class_weight: float = 2.0mask_weight: float = 5.0dice_weight: float = 5.0train_num_points: int = 12544oversample_ratio: float = 3.0importance_sample_ratio: float = 0.75num_queries: int = 200num_register_tokens: int = 4 )

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 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 totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — La epsilon utilizada por las capas de normalización de capa.
  • 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) — Relación entre la dimensión oculta del MLP y la dimensión de la 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, valor predeterminado False) — Si se debe usar la red neuronal feedforward 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 que se muestrean 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import VideomtConfig, VideomtForUniversalSegmentation

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

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

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

VideomtPreTrainedModel

clase transformers.VideomtPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parámetros

  • config (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() para cargar los pesos del modelo.

Este modelo hereda de PreTrainedModel. Consulta 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 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

( *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 simulado.

VideomtForUniversalSegmentation

clase transformers.VideomtForUniversalSegmentation

< >

( config: VideomtConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( pixel_values_videos: typing.Optional[torch.Tensor] = Nonemask_labels: list[torch.Tensor] | None = Noneclass_labels: list[torch.Tensor] | None = Nonepatch_offsets: list[torch.Tensor] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VideomtForUniversalSegmentationOutput or tuple(torch.Tensor)

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 5D.
  • class_labels (list[torch.LongTensor], opcional) — No se admite para entradas de vídeo 5D.
  • patch_offsets (list[torch.Tensor], opcional) — No se utiliza para entradas de video y solo se conserva 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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.
Update on GitHub

←UVDoc Vision Transformer (ViT)→