# VidEoMT

## Ikhtisar

Model VidEoMT diusulkan dalam [Your ViT is Secretly Also a Video Segmentation Model](https://huggingface.co/papers/2602.17807) 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)](vit) biasa. Ini merupakan ekstensi minimal dari [EoMT](./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 overhead komputasi yang signifikan. Studi-studi terbaru menunjukkan bahwa encoder Vision Transformer (ViT) biasa, ketika diskalakan dengan kapasitas yang memadai dan pra-pelatihan berskala besar, dapat melakukan segmentasi gambar yang akurat tanpa memerlukan modul khusus. Terinspirasi oleh pengamatan ini, kami mengusulkan Video Encoder-only Mask Transformer (VidEoMT), sebuah model segmentasi video encoder-only yang sederhana yang menghilangkan kebutuhan akan modul pelacakan khusus. Untuk memungkinkan pemodelan temporal dalam ViT encoder-only, VidEoMT memperkenalkan mekanisme propagasi query 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 pelacak tanpa kompleksitas tambahan, 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](https://huggingface.co/nielsr). Kode aslinya dapat ditemukan [di sini](https://github.com/tue-mps/videomt).

## Info Arsitektur

VidEoMT dibangun di atas [EoMT](./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:

1. **Propagasi kueri**: kueri objek dari bingkai sebelumnya dibawa ke bingkai berikutnya melalui proyeksi linear (`query_updater`), sehingga memungkinkan penalaran temporal tanpa pelacak khusus.
2. **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

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

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

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

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

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'height' : 640, 'width': 640}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, 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 berdampak jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `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*, defaultnya `False`) : Apakah akan melakukan center crop pada gambar.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga 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 disetel, 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*, defaultnya `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 mengirim metadata apa pun kecuali Anda mencoba mendekode video secara manual sebelum diproses

fps (`Annotated[int | float | None, None]`, *kwargs*) : Bingkai target yang akan disampel per detik saat `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*, defaultnya `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 diatur, 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](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.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[[transformers.VideomtVideoProcessor.post_process_semantic_segmentation]]

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

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

**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*, defaultnya `False`) : Apakah akan mengembalikan skor segmentasi bersama dengan 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 bidang `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](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.VideomtForUniversalSegmentation) menjadi prediksi segmentasi semantik.

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

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

**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)` 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](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.VideomtForUniversalSegmentation) menjadi prediksi segmentasi instance.

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

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

**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 yang diprediksi.

mask_threshold (`float`, *opsional*, default 0.5) : Ambang batas untuk binarisasi probabilitas mask.

overlap_mask_area_threshold (`float`, *opsional*, default 0.8) : Ambang 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)` 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](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.VideomtForUniversalSegmentation) menjadi prediksi segmentasi panoptik.

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

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

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `1024`) : Dimensi dari representasi tersembunyi.

num_hidden_layers (`int`, *opsional*, defaultnya `24`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `16`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam 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*, defaultnya `0.0`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar 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) dari setiap gambar.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch.

num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input.

mlp_ratio (`int`, *opsional*, defaultnya `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*, defaultnya 2) : Jumlah blok upsampling yang digunakan dalam decoder atau kepala segmentasi.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `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*, defaultnya `5.0`) : Bobot relatif dari dice loss dalam loss segmentasi panoptik.

train_num_points (`int`, *opsional*, default 12544) : Jumlah titik yang akan disampel untuk perhitungan mask loss selama pelatihan.

oversample_ratio (`float`, *opsional*, default 3.0) : Rasio oversampling yang digunakan dalam point sampling 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 (learnable) yang 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, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [tue-mps/videomt-dinov2-small-ytvis2019](https://huggingface.co/tue-mps/videomt-dinov2-small-ytvis2019)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.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()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.VideomtPreTrainedModel.forward]]

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

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

## VideomtForUniversalSegmentation[[transformers.VideomtForUniversalSegmentation]]

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

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

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

**Parameter:**

config ([VideomtConfig](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.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()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

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

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[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'>)
```

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

**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.Tensor)`

Sebuah `VideomtForUniversalSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([VideomtConfig](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.VideomtConfig)) dan input.

Metode forward dari [VideomtForUniversalSegmentation](/docs/transformers/v5.23.0/id/model_doc/videomt#transformers.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.Tensor`, *opsional*) -- Tensor dengan bentuk `(batch_size, num_queries, num_labels + 1)` yang merepresentasikan kelas yang diusulkan untuk setiap query. Perhatikan bahwa `+ 1` diperlukan karena kami mengikutsertakan kelas null.
- **masks_queries_logits** (`torch.Tensor`, *opsional*) -- Tensor dengan bentuk `(batch_size, num_queries, height, width)` yang merepresentasikan mask yang diusulkan untuk setiap query.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) -- State tersembunyi terakhir (peta fitur akhir) dari lapisan terakhir.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap stage) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari semua lapisan model.
- **attentions** (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `tuple(torch.Tensor)` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot Self dan Cross Attentions dari decoder transformer.

