Transformers documentation

VidEoMT

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Model ini dipublikasikan di HF papers pada 2026-02-19 dan disumbangkan ke Hugging Face Transformers pada 2026-03-25.

VidEoMT

Ikhtisar

Model VidEoMT diusulkan dalam Your ViT is Secretly Also a Video Segmentation Model oleh Narges Norouzi, Idil Esen Zulfikar, Niccolò Cavagnero, Tommie Kerssies, Bastian Leibe, Gijs Dubbelman, Daan de Geus. Video Encoder-only Mask Transformer (VidEoMT) adalah model encoder-only ringan untuk segmentasi video online yang dibangun di atas Vision Transformer (ViT) biasa. Ini merupakan ekstensi minimal dari EoMT ke video, yang melakukan penalaran spasial dan temporal di dalam encoder ViT, tanpa bergantung pada modul pelacakan khusus atau kepala tugas yang berat.

Abstrak dari makalah tersebut adalah sebagai berikut:

Model segmentasi video online yang ada saat ini umumnya menggabungkan segmenter per-frame dengan modul pelacakan khusus yang kompleks. Meskipun efektif, modul-modul ini memperkenalkan kompleksitas arsitektur dan beban komputasi yang signifikan. Studi-studi terbaru menunjukkan bahwa encoder Vision Transformer (ViT) biasa, ketika diskalakan dengan kapasitas yang memadai dan pre-training berskala besar, dapat melakukan segmentasi gambar yang akurat tanpa memerlukan modul khusus. Terinspirasi oleh pengamatan ini, kami mengusulkan Video Encoder-only Mask Transformer (VidEoMT), yaitu model segmentasi video encoder-only yang sederhana yang menghilangkan kebutuhan akan modul pelacakan khusus. Untuk memungkinkan pemodelan temporal pada ViT encoder-only, VidEoMT memperkenalkan mekanisme propagasi query yang ringan yang membawa informasi antar frame dengan memanfaatkan ulang query dari frame sebelumnya. Untuk menyeimbangkan hal ini dengan kemampuan beradaptasi terhadap konten baru, model ini menerapkan strategi fusi query yang menggabungkan query yang dipropagasikan dengan seperangkat query yang dipelajari dan tidak bergantung pada temporal. Akibatnya, VidEoMT memperoleh manfaat dari sebuah tracker tanpa menambah kompleksitas, mencapai akurasi yang kompetitif sekaligus 5x—10x lebih cepat, berjalan hingga 160 FPS dengan backbone ViT-L.

Tips:

VidEoMT saat ini hanya mendukung backbone DINOv2 (dengan register tokens). Ukuran model yang tersedia adalah ViT-S, ViT-B, dan ViT-L.
Model menerima input video sebagai tensor 5D dengan bentuk (batch_size, num_frames, 3, height, width).
VidEoMT mendukung tiga tugas segmentasi video: segmentasi instance, semantic, dan panoptic, masing-masing dengan metode pascaproses yang khusus pada video processor.

Model ini disumbangkan oleh nielsr. Kode aslinya dapat ditemukan di sini.

Info Arsitektur

VidEoMT dibangun di atas EoMT, yang memanfaatkan Vision Transformer yang dilatih sebelumnya dengan DINOv2 biasa dan register tokens sebagai model segmentasi. EoMT memperkenalkan object queries yang dipelajari dan mask prediction head ringan langsung di dalam encoder ViT, sehingga menghilangkan kebutuhan akan decoder yang spesifik untuk tugas tertentu.

VidEoMT memperluas ini ke video dengan dua penambahan utama:

Propagasi kueri: kueri objek dari bingkai sebelumnya dibawa ke bingkai berikutnya melalui proyeksi linear (query_updater), sehingga memungkinkan penalaran temporal tanpa pelacak khusus.
Fusi kueri: kueri yang dipropagasi ditambahkan ke seperangkat kueri yang dipelajari dan tidak bergantung pada waktu, sehingga model dapat beradaptasi dengan objek baru yang muncul dalam video.

Lapisan encoder awal memproses semua frame secara independen (paralel), sementara blok-blok akhir beroperasi per-frame dengan query yang telah digabungkan, menghasilkan prediksi mask dan kelas per-frame.

Contoh Penggunaan

Gunakan implementasi VidEoMT dari Hugging Face untuk inferensi dengan model terlatih. Contoh di bawah ini menggunakan ulang checkpoint publik tue-mps/videomt-dinov2-small-ytvis2019 untuk mendemonstrasikan pascapemrosesan instance, semantik, dan panoptic video pada video sampel.

Segmentasi Instans 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()

Segmentasi Semantik 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()

Segmentasi Panoptik 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

kelas transformers.VideomtVideoProcessor

< source >

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

Parameter

do_convert_rgb (bool, kwargs, opsional, default True) — Apakah akan mengkonversi gambar ke RGB.
do_resize (bool, kwargs, opsional, default True) — Apakah akan mengubah ukuran gambar.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya {'height' -- 640, 'width': 640}): Menggambarkan dimensi input maksimum untuk model.
default_to_square (bool, kwargs, opsional, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya 2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
do_center_crop (bool, kwargs, opsional, default False) — Apakah akan melakukan center crop pada gambar.
do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
- "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
- "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
- "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
do_sample_frames (bool, kwargs, opsional, default False) — Apakah akan mengambil sampel frame dari video sebelum diproses atau memproses seluruh video.
video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadata dari video yang berisi informasi tentang durasi total, fps, dan jumlah total frame. Metadata ini akan digunakan untuk mengambil sampel frame dari video atau menghitung timestamp. Jangan kirimkan metadata apa pun kecuali Anda mencoba mendekode video secara manual sebelum diproses
fps (Annotated[int | float | None, None], kwargs) — Target frame yang akan disampel per detik ketika do_sample_frames=True.
num_frames (Annotated[int | None, None], kwargs) — Jumlah maksimum frame yang akan disampelkan saat do_sample_frames=True.
return_metadata (bool, kwargs, opsional, default False) — Apakah akan mengembalikan metadata video atau tidak. Metadata video adalah objek yang berisi informasi tentang durasi video, fps, backend decoding, dll.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:
- 'pt': Mengembalikan objek PyTorch torch.Tensor.
- 'np': Mengembalikan objek NumPy np.ndarray.
**kwargs (VideosKwargs, opsional) — Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

Membangun prosesor video VideomtVideoProcessor.

post_process_semantic_segmentation

< source >

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

Parameter

outputs (VideomtForUniversalSegmentationOutput) — Output mentah dari model.
target_sizes (list[tuple[int, int]]) — Daftar tuple (height, width) yang sesuai dengan ukuran akhir yang diminta untuk setiap prediksi. Panjangnya harus sesuai dengan jumlah frame dalam output.
return_segmentation_scores (bool, opsional, default False) — Apakah akan mengembalikan skor segmentasi bersama peta segmentasi. Ketika True, setiap elemen dari daftar yang dikembalikan adalah SemanticSegmentationPostProcessorOutput dengan field segmentation (ID kelas, bentuk (height, width)) dan segmentation_scores (bentuk (num_classes, height, width)).

Mengembalikan

list[torch.Tensor] atau list[SemanticSegmentationPostProcessorOutput]

Ketika return_segmentation_scores=False (default), sebuah daftar dengan panjang batch_size di mana setiap item adalah peta segmentasi dengan bentuk (height, width) berisi ID kelas. Ketika return_segmentation_scores=True, sebuah daftar SemanticSegmentationPostProcessorOutput dengan field segmentation (ID kelas, bentuk (height, width)) dan segmentation_scores (bentuk (num_classes, height, width)). Dalam kedua kasus, (height, width) sesuai dengan ukuran target.

Mengonversi output dari VideomtForUniversalSegmentation menjadi prediksi segmentasi semantik.

post_process_instance_segmentation

< source >

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

Parameter

outputs (VideomtForUniversalSegmentationOutput) — Output mentah dari model.
target_sizes (list[tuple[int, int]]) — Daftar tuple (height, width) yang sesuai dengan ukuran akhir yang diminta untuk setiap prediksi. Panjangnya harus sesuai dengan jumlah frame dalam output.
threshold (float, opsional, default 0.5) — Skor gabungan minimum untuk mempertahankan sebuah instance.

Mengembalikan

list[dict]

Daftar dict (satu per frame), masing-masing berisi:

"segmentation" — Sebuah torch.Tensor dengan bentuk (height, width) yang berisi ID instance (atau -1 untuk latar belakang).
"segments_info" — Daftar dict dengan "id", "label_id", dan "score" untuk setiap instance.

Mengonversi output dari VideomtForUniversalSegmentation menjadi prediksi segmentasi instance.

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]

Parameter

outputs (VideomtForUniversalSegmentationOutput) — Output mentah dari model.
target_sizes (list[tuple[int, int]]) — Daftar tuple (height, width) yang sesuai dengan ukuran akhir yang diminta untuk setiap prediksi. Panjangnya harus sesuai dengan jumlah frame dalam output.
threshold (float, opsional, default 0.8) — Skor minimum untuk mempertahankan segmen prediksi.
mask_threshold (float, opsional, default 0.5) — Ambang batas untuk mambinarkan probabilitas mask.
overlap_mask_area_threshold (float, opsional, default 0.8) — Ambang batas tumpang tindih untuk menggabungkan mask menjadi satu segmen.
label_ids_to_fuse (set[int], opsional) — ID label yang harus digabungkan di antara wilayah yang tidak terhubung.

Mengembalikan

list[dict]

Daftar dict (satu per frame), masing-masing berisi:

"segmentation" — Sebuah torch.Tensor dengan bentuk (height, width) yang berisi ID segmen (atau -1 untuk latar belakang).
"segments_info" — Daftar dict dengan "id", "label_id", dan "score" untuk setiap segmen.

Mengonversi output dari VideomtForUniversalSegmentation menjadi prediksi segmentasi panoptik.

VideomtConfig

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

Parameter

hidden_size (int, opsional, default 1024) — Dimensi dari representasi tersembunyi.
num_hidden_layers (int, opsional, default 24) — Jumlah lapisan tersembunyi dalam decoder Transformer.
num_attention_heads (int, opsional, default 16) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer.
hidden_act (str, opsional, defaultnya gelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, "gelu", "relu", "silu", dan sebagainya.
hidden_dropout_prob (Union[float, int], opsional, default 0.0) — Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.
initializer_range (float, opsional, defaultnya 0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
layer_norm_eps (float, opsional, defaultnya 1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
image_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 640) — Ukuran (resolusi) setiap gambar.
patch_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 16) — Ukuran (resolusi) dari setiap patch.
num_channels (int, opsional, defaultnya 3) — Jumlah saluran input.
mlp_ratio (int, opsional, default 4) — Rasio dimensi tersembunyi MLP terhadap dimensi embedding.
layerscale_value (float, opsional, default 1.0) — Nilai awal untuk parameter LayerScale.
drop_path_rate (Union[float, int], opsional, defaultnya 0.0) — Tingkat drop path untuk fusi patch.
num_upscale_blocks (int, opsional, default 2) — Jumlah blok upsampling yang digunakan dalam decoder atau head segmentasi.
attention_dropout (Union[float, int], opsional, default 0.0) — Rasio dropout untuk probabilitas perhatian.
use_swiglu_ffn (bool, opsional, defaultnya False) — Apakah akan menggunakan jaringan saraf feedforward SwiGLU.
num_blocks (int, opsional, default 4) — Jumlah blok fitur atau tahap dalam arsitektur.
no_object_weight (float, opsional, default 0.1) — Bobot loss untuk kelas ‘no object’ dalam segmentasi panoptik/instans.
class_weight (float, opsional, default 2.0) — Bobot loss untuk target klasifikasi.
mask_weight (float, opsional, default 5.0) — Bobot loss untuk prediksi mask.
dice_weight (float, opsional, default 5.0) — Bobot relatif dari dice loss dalam loss segmentasi panoptik.
train_num_points (int, opsional, default 12544) — Jumlah titik yang diambil untuk menghitung mask loss selama pelatihan.
oversample_ratio (float, opsional, default 3.0) — Rasio oversampling yang digunakan dalam pengambilan sampel titik untuk pelatihan mask.
importance_sample_ratio (float, opsional, default 0.75) — Rasio titik yang akan disampel berdasarkan kepentingan selama pelatihan.
num_queries (int, opsional, default 200) — Jumlah kueri objek dalam Transformer.
num_register_tokens (int, opsional, default 4) — Jumlah token register yang dapat dipelajari dan ditambahkan ke input transformer.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VideomtModel. Kelas ini digunakan untuk membuat instans model Videomt berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari tue-mps/videomt-dinov2-small-ytvis2019

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

>>> from transformers import VideomtConfig, VideomtForUniversalSegmentation

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

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

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

VideomtPreTrainedModel

kelas transformers.VideomtPreTrainedModel

< source >

( config: PreTrainedConfig*inputs**kwargs )

Parameter

config (PreTrainedConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

forward

( *args**kwargs )

Nilai mock untuk jalur bertitik (mis. torch.float32): rantai akses atribut, pemanggilan berperilaku sebagai dekorator pass-through, repr adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar type polos (PEP 560 __mro_entries__), sehingga subkelas asli tetap mempertahankan metakelas normal dan inspect.signature membaca __init__ asli mereka, bukan milik mock.

VideomtForUniversalSegmentation

kelas transformers.VideomtForUniversalSegmentation

< source >

( config: VideomtConfig )

Parameter

config (VideomtConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model Videomt dengan head di bagian atas untuk segmentasi instance/semantic/panoptic.

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.FloatTensor)

Parameter

pixel_values_videos (torch.Tensor, opsional) — Input video dengan bentuk (batch_size, num_frames, num_channels, height, width).
mask_labels (list[torch.Tensor], opsional) — Tidak didukung untuk input video 5D.
class_labels (list[torch.LongTensor], opsional) — Tidak didukung untuk input video 5D.
patch_offsets (list[torch.Tensor], opsional) — Tidak digunakan untuk input video dan hanya dipertahankan untuk kompatibilitas modular.

Mengembalikan

VideomtForUniversalSegmentationOutput atau tuple(torch.FloatTensor)

Sebuah VideomtForUniversalSegmentationOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (VideomtConfig) dan input.

Metode forward dari VideomtForUniversalSegmentation menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.Tensor, opsional) — Loss yang dihitung, dikembalikan saat label ada.
class_queries_logits (torch.FloatTensor, opsional) — Tensor dengan bentuk (batch_size, num_queries, num_labels + 1) yang mewakili kelas yang diusulkan untuk setiap query. Perhatikan bahwa + 1 diperlukan karena kami mengintegrasikan kelas null.
masks_queries_logits (torch.FloatTensor, opsional) — Tensor dengan bentuk (batch_size, num_queries, height, width) yang merepresentasikan mask yang diusulkan untuk setiap query.
last_hidden_state (torch.FloatTensor dengan bentuk (batch_size, num_channels, height, width)) — State tersembunyi terakhir (peta fitur akhir) dari lapisan terakhir.
hidden_states (tuple(torch.FloatTensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output embeddings + satu untuk output setiap tahap) dengan bentuk (batch_size, sequence_length, hidden_size). Hidden-states dari semua lapisan model.
attentions (tuple(tuple(torch.FloatTensor)), opsional, dikembalikan ketika output_attentions=True dilewatkan atau ketika config.output_attentions=True) — Tuple dari tuple(torch.FloatTensor) (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length). Bobot Self dan Cross Attentions dari decoder transformer.

Update on GitHub

←UVDoc Vision Transformer (ViT)→