Transformers documentation
VidEoMT
Este modelo foi publicado no HF papers em 19/02/2026 e contribuído para o Hugging Face Transformers em 25/03/2026.
VidEoMT
Visão geral
O modelo VidEoMT foi proposto em Your ViT is Secretly Also a Video Segmentation Model por Narges Norouzi, Idil Esen Zulfikar, Niccolò Cavagnero, Tommie Kerssies, Bastian Leibe, Gijs Dubbelman, Daan de Geus. O Video Encoder-only Mask Transformer (VidEoMT) é um modelo leve, somente de codificador, para segmentação de vídeo online, construído sobre um Vision Transformer (ViT) simples. Trata-se de uma extensão mínima do EoMT para vídeo, que realiza raciocínio espacial e temporal dentro do codificador ViT, sem depender de módulos de rastreamento dedicados ou cabeças específicas de tarefa pesadas.
O resumo do artigo é o seguinte:
Os modelos existentes de segmentação de vídeo online geralmente combinam um segmentador por quadro com módulos de rastreamento especializados e complexos. Embora sejam eficazes, esses módulos introduzem uma complexidade arquitetural significativa e sobrecarga computacional. Estudos recentes sugerem que codificadores Vision Transformer (ViT) simples, quando escalados com capacidade suficiente e pré-treinamento em larga escala, podem realizar segmentação de imagem precisa sem a necessidade de módulos especializados. Motivados por essa observação, propomos o Video Encoder-only Mask Transformer (VidEoMT), um modelo simples de segmentação de vídeo apenas com codificador que elimina a necessidade de módulos de rastreamento dedicados. Para permitir a modelagem temporal em um ViT apenas com codificador, o VidEoMT introduz um mecanismo leve de propagação de consultas que carrega informações entre quadros reutilizando as consultas do quadro anterior. Para equilibrar isso com a adaptabilidade a novos conteúdos, ele emprega uma estratégia de fusão de consultas que combina as consultas propagadas com um conjunto de consultas aprendidas agnósticas ao tempo. Como resultado, o VidEoMT atinge os benefícios de um rastreador sem complexidade adicional, alcançando precisão competitiva enquanto é 5x a 10x mais rápido, operando a até 160 FPS com um backbone ViT-L.
Dicas:
- O VidEoMT atualmente suporta apenas um backbone DINOv2 (com tokens de registro). Os tamanhos de modelo disponíveis são ViT-S, ViT-B e ViT-L.
- O modelo aceita entrada de vídeo como um tensor 5D de forma
(batch_size, num_frames, 3, height, width). - O VidEoMT suporta três tarefas de segmentação de vídeo: segmentação de instância, segmentação semântica e segmentação panótica, cada uma com um método de pós-processamento dedicado no processador de vídeo.
Este modelo foi contribuído por nielsr. O código original pode ser encontrado aqui.
Informações da Arquitetura
VidEoMT é construído sobre o EoMT, que reaproveita um Vision Transformer pré-treinado com DINOv2, com register tokens, como um modelo de segmentação. O EoMT introduz object queries aprendidas e uma mask prediction head leve diretamente dentro do codificador ViT, eliminando a necessidade de decodificadores específicos para a tarefa.
VidEoMT estende isso para vídeo com duas adições principais:
- Propagação de consultas: as consultas de objetos do quadro anterior são transportadas para o próximo quadro por meio de uma projeção linear (
query_updater), permitindo raciocínio temporal sem um rastreador dedicado. - Fusão de consultas: as consultas propagadas são adicionadas a um conjunto de consultas aprendidas que não dependem do tempo, permitindo que o modelo se adapte a novos objetos que aparecem no vídeo.
As camadas iniciais do codificador processam todos os frames de forma independente (em paralelo), enquanto os blocos finais operam por frame com as consultas fundidas, produzindo previsões de máscara e classe por frame.
Exemplos de uso
Use a implementação do VidEoMT do Hugging Face para inferência com modelos pré-treinados. Os exemplos abaixo reutilizam o checkpoint público tue-mps/videomt-dinov2-small-ytvis2019 para demonstrar o pós-processamento de instância, semântico e panótico de vídeo em um vídeo de exemplo.
Segmentação de Instâncias em Vídeo
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()Segmentação Semântica de Vídeo
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()Segmentação Panóptica de Vídeo
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
classe transformers.VideomtVideoProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.VideosKwargs'> )
Parâmetros
- do_convert_rgb (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional, padrãoTrue) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'height' -- 640, 'width': 640}): Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional, padrãoTrue) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão2) — Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional, padrãoTrue) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional, padrão0.00392156862745098) — Fator de reescala para reescalar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_center_crop (
bool, kwargs, opcional, padrãoFalse) — Se deve recortar a imagem pelo centro. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação decenter_crop. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - do_sample_frames (
bool, kwargs, opcional, padrãoFalse) — Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro. - video_metadata (
Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadados do vídeo contendo informações sobre a duração total, fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento - fps (
Annotated[int | float | None, None], kwargs) — Quantidade de quadros-alvo a amostrar por segundo quandodo_sample_frames=True. - num_frames (
Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quandodo_sample_frames=True. - return_metadata (
bool, kwargs, opcional, padrãoFalse) — Se deve retornar ou não os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo NumPy.
- **kwargs (VideosKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
Constrói um processador de vídeo VideomtVideoProcessor.
post_process_semantic_segmentation
< source >( outputstarget_sizes: listreturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Parâmetros
- outputs (
VideomtForUniversalSegmentationOutput) — Saídas brutas do modelo. - target_sizes (
list[tuple[int, int]]) — Lista de tuplas(height, width)correspondentes ao tamanho final solicitado de cada previsão. O comprimento deve corresponder ao número de quadros na saída. - return_segmentation_scores (
bool, opcional, padrãoFalse) — Indica se as pontuações de segmentação devem ser retornadas junto com o mapa de segmentação. QuandoTrue, cada elemento da lista retornada é umSemanticSegmentationPostProcessorOutputcom os campossegmentation(IDs de classe, forma(height, width)) esegmentation_scores(forma(num_classes, height, width)).
Retorna
list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]
Quando
return_segmentation_scores=False (padrão), uma lista de comprimento batch_size em que cada item é um
mapa de segmentação de forma (height, width) com IDs de classe. Quando return_segmentation_scores=True,
uma lista de SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma
(height, width)) e segmentation_scores (forma (num_classes, height, width)). Em ambos os casos,
(height, width) corresponde ao tamanho alvo.
Converte a saída de VideomtForUniversalSegmentation em previsões de segmentação semântica.
post_process_instance_segmentation
< source >( outputstarget_sizes: listthreshold: float = 0.5 ) → list[dict]
Parâmetros
- outputs (
VideomtForUniversalSegmentationOutput) — Saídas brutas do modelo. - target_sizes (
list[tuple[int, int]]) — Lista de tuplas(height, width)correspondentes ao tamanho final solicitado de cada previsão. O comprimento deve corresponder ao número de quadros na saída. - threshold (
float, opcional, padrão 0.5) — Pontuação combinada mínima para manter uma instância.
Retorna
list[dict]
Uma lista de dicionários (um por quadro), cada um contendo:
"segmentation"— Umtorch.Tensorde forma(height, width)com IDs de instância (ou -1 para o fundo)."segments_info"— Uma lista de dicts com"id","label_id"e"score"para cada instância.
Converte a saída de VideomtForUniversalSegmentation em previsões de segmentação de instâncias.
post_process_panoptic_segmentation
< source >( 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) — Saídas brutas do modelo. - target_sizes (
list[tuple[int, int]]) — Lista de tuplas(height, width)correspondentes ao tamanho final solicitado de cada previsão. O comprimento deve corresponder ao número de quadros na saída. - threshold (
float, opcional, padrão 0.8) — Pontuação mínima para manter um segmento previsto. - mask_threshold (
float, opcional, padrão 0.5) — Limiar para binarizar as probabilidades da máscara. - overlap_mask_area_threshold (
float, opcional, padrão 0.8) — Limite de sobreposição para mesclar máscaras em um único segmento. - label_ids_to_fuse (
set[int], opcional) — IDs de rótulo que devem ser fundidos entre regiões desconectadas.
Retorna
list[dict]
Uma lista de dicionários (um por quadro), cada um contendo:
"segmentation"— Umtorch.Tensorde forma(height, width)com IDs de segmentos (ou -1 para o fundo)."segments_info"— Uma lista de dicts com"id","label_id"e"score"para cada segmento.
Converte a saída de VideomtForUniversalSegmentation em previsões de segmentação panótica.
VideomtConfig
classe transformers.VideomtConfig
< source >( 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, padrão1024) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], opcional, padrão0.0) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização de camada. - image_size (
Union[int, list[int], tuple[int, int]], opcional, padrão640) — O tamanho (resolução) de cada imagem. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, padrão16) — O tamanho (resolução) de cada patch. - num_channels (
int, opcional, padrão3) — O número de canais de entrada. - mlp_ratio (
int, opcional, padrão4) — Proporção entre a dimensão oculta do MLP e a dimensão de incorporação. - layerscale_value (
float, opcional, padrão 1.0) — Valor inicial para o parâmetro LayerScale. - drop_path_rate (
Union[float, int], opcional, padrão0.0) — Taxa de drop path para a fusão de patches. - num_upscale_blocks (
int, opcional, padrão 2) — Número de blocos de ampliação usados no decodificador ou na cabeça de segmentação. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - use_swiglu_ffn (
bool, opcional, padrãoFalse) — Se deve usar a rede neural feedforward SwiGLU. - num_blocks (
int, opcional, padrão 4) — Número de blocos de recursos ou estágios na arquitetura. - no_object_weight (
float, opcional, padrão 0.1) — Peso da perda para a classe 'no object' em segmentação panotópica/por instância. - class_weight (
float, opcional, padrão 2.0) — Peso da perda para os alvos de classificação. - mask_weight (
float, opcional, padrão 5.0) — Peso da perda para a previsão de máscara. - dice_weight (
float, opcional, padrão5.0) — Peso relativo da perda dice na perda de segmentação panótica. - train_num_points (
int, opcional, padrão 12544) — Número de pontos a amostrar para o cálculo da perda de máscara durante o treinamento. - oversample_ratio (
float, opcional, padrão 3.0) — Razão de sobreamostragem usada na amostragem de pontos para o treinamento de máscaras. - importance_sample_ratio (
float, opcional, padrão 0.75) — Proporção de pontos a serem amostrados com base na importância durante o treinamento. - num_queries (
int, opcional, padrão 200) — Número de consultas de objetos no Transformer. - num_register_tokens (
int, opcional, padrão 4) — Número de tokens de registro aprendíveis adicionados à entrada do transformer.
Esta é a classe de configuração para armazenar a configuração de um VideomtModel. Ela é usada para instanciar um modelo Videomt de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do tue-mps/videomt-dinov2-small-ytvis2019
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
VideomtPreTrainedModel
classe transformers.VideomtPreTrainedModel
< source >( config: PreTrainedConfig*inputs**kwargs )
Parâmetros
- config (PreTrainedConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
Um valor simulado para um caminho pontilhado (por exemplo, torch.float32): cadeias de acesso a atributos, chamadas se comportam como decoradores de passagem, repr é o caminho pontilhado, e usá-lo como classe base substitui uma base de type simples (PEP 560 __mro_entries__), de modo que subclasses reais mantêm uma metaclass normal e inspect.signature lê o __init__ real delas, em vez do de um mock.
VideomtForUniversalSegmentation
classe transformers.VideomtForUniversalSegmentation
< source >( config: VideomtConfig )
Parâmetros
- config (VideomtConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo Videomt com head no topo para segmentação de instância/semântica/panótica.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( 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 vídeo com forma(batch_size, num_frames, num_channels, height, width). - mask_labels (
list[torch.Tensor], opcional) — Não suportado para entradas de vídeo 5D. - class_labels (
list[torch.LongTensor], opcional) — Não suportado para entradas de vídeo 5D. - patch_offsets (
list[torch.Tensor], opcional) — Não utilizado para entradas de vídeo e mantido apenas para compatibilidade modular.
Retorna
VideomtForUniversalSegmentationOutput ou tuple(torch.Tensor)
Uma VideomtForUniversalSegmentationOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (VideomtConfig) e das entradas.
O método forward de VideomtForUniversalSegmentation substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
- loss (
torch.Tensor, opcional) — A perda calculada, retornada quando os rótulos estão presentes. - class_queries_logits (
torch.Tensor, opcional) — Um tensor de forma(batch_size, num_queries, num_labels + 1)representando as classes propostas para cada query. Observe que o+ 1é necessário porque incorporamos a classe nula. - masks_queries_logits (
torch.Tensor, opcional) — Um tensor de forma(batch_size, num_queries, height, width)representando as máscaras propostas para cada consulta. - last_hidden_state (
torch.Tensorde forma(batch_size, num_channels, height, width)) — Últimos estados ocultos (mapa de recursos final) da última camada. - hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada estágio) de forma(batch_size, sequence_length, hidden_size). Hidden-states de todas as camadas do modelo. - attentions (
tuple(tuple(torch.Tensor)), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detuple(torch.Tensor)(uma para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de Self e Cross Attentions do decodificador do transformer.