# VidEoMT

## Genel Bakış

VidEoMT modeli, Narges Norouzi, Idil Esen Zulfikar, Niccolò Cavagnero, Tommie Kerssies, Bastian Leibe, Gijs Dubbelman ve Daan de Geus tarafından [Your ViT is Secretly Also a Video Segmentation Model](https://huggingface.co/papers/2602.17807) makalesinde önerilmiştir. Video Encoder-only Mask Transformer (VidEoMT), düz bir [Vision Transformer (ViT)](vit) üzerine inşa edilmiş, çevrimiçi video segmentasyonu için hafif bir yalnızca-encoder modelidir. [EoMT](./eomt)'nin videoya yönelik minimal bir uzantısı olan bu model, ViT encoder'ı içinde hem mekânsal hem de zamansal akıl yürütme gerçekleştirir; bunun için özel takip modüllerine veya ağır görev-özel kafalara (head) ihtiyaç duymaz.

Makalenin özeti aşağıdaki gibidir:

*Mevcut çevrimiçi video segmentasyon modelleri genellikle çerçeve başına bir segmentleyiciyi karmaşık, özel izleme modülleriyle birleştirir. Etkili olsalar da bu modüller önemli bir mimari karmaşıklık ve hesaplama yükü getirir. Son çalışmalar, düz Görüntü Dönüştürücü (ViT) kodlayıcılarının yeterli kapasite ve büyük ölçekli ön eğitimle ölçeklendirildiğinde, özel modüllere ihtiyaç duymadan doğru görüntü segmentasyonu gerçekleştirebileceğini göstermektedir. Bu gözlemden ilham alarak, Video Sadece Kodlayıcı Mask Dönüştürücüsü (VidEoMT)'nü öneriyoruz; bu, özel izleme modüllerine olan ihtiyacı ortadan kaldıran basit bir sadece kodlayıcı video segmentasyon modelidir. Sadece kodlayıcı bir ViT içinde zaman modellemesini mümkün kılmak için VidEoMT, önceki çerçevedeki sorguları yeniden kullanarak bilgiyi çerçeveler arasında taşıyan hafif bir sorgu yayılım mekanizması sunar. Yeni içeriğe uyumlulukla dengelemek için, yayılan sorguları zamanla ilgisiz öğrenilmiş bir sorgu kümesiyle birleştiren bir sorgu birleştirme stratejisi kullanır. Sonuç olarak VidEoMT, ek karmaşıklık olmadan bir izleyicinin avantajlarını elde eder; ViT-L omurgasıyla 160 FPS'ye kadar çalışarak 5x--10x daha hızlı bir şekilde rekabetçi doğruluk sağlar.*

İpuçları:

- VidEoMT şu anda yalnızca DINOv2 omurgasını (register token'larla) desteklemektedir. Kullanılabilir model boyutları ViT-S, ViT-B ve ViT-L'dir.
- Model, video girdisini `(batch_size, num_frames, 3, height, width)` biçiminde 5 boyutlu bir tensör olarak kabul eder.
- VidEoMT üç video segmentasyon görevini destekler: **instance**, **semantic** ve **panoptic** segmentasyon; her biri video işleyicide özel bir son işlem yöntemine sahiptir.

Bu model [nielsr](https://huggingface.co/nielsr) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/tue-mps/videomt) bulunabilir.

## Mimari Bilgileri

VidEoMT, **register token** içeren, düz DINOv2 ile ön eğitilmiş bir Vision Transformer'ı segmentasyon modeli olarak yeniden kullanan [EoMT](./eomt) üzerine inşa edilmiştir. EoMT, görev özelinde çözücü (decoder) ihtiyacını ortadan kaldırmak için öğrenilmiş **object query** bileşenlerini ve hafif bir **mask prediction head** bileşenini doğrudan ViT kodlayıcısının (encoder) içine yerleştirir.

VidEoMT bunu videoya iki temel ekleme ile genişletir:

1. **Sorgu yayılımı**: önceki kareden gelen nesne sorguları, `query_updater` üzerinden doğrusal bir projeksiyonla bir sonraki kareye taşınarak, ayrı bir izleyiciye ihtiyaç duymadan zamansal akıl yürütme sağlanır.
2. **Sorgu birleştirme**: yayılan sorgular, zamanla bağımsız öğrenilmiş sorgu kümesine eklenir; bu sayede model, videoda beliren yeni nesnelere uyum sağlayabilir.

Erken kodlayıcı katmanları tüm kareleri bağımsız olarak (paralel) işlerken, son bloklar füzyonlu sorgularla kare bazlı çalışır ve kare bazlı maske ve sınıf tahminleri üretir.

## Kullanım Örnekleri

Önceden eğitilmiş modellerle çıkarım için Hugging Face'in VidEoMT uygulamasını kullanın. Aşağıdaki örnekler, örnek bir videoda video örneği, semantik ve panoptik son işleme süreçlerini göstermek için herkese açık `tue-mps/videomt-dinov2-small-ytvis2019` kontrol noktasını yeniden kullanır.

### Video Örneği Segmentasyonu

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

### Video Anlamsal Segmentasyon

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

### Video Panotik Segmentasyon

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

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

**Parametreler:**

do_convert_rgb (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, varsayılan `{'height' : 640, 'width': 640}`): Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görüntü kullanılıp kullanılmayacağını belirtir.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, varsayılan `2`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*, varsayılan `0.00392156862745098`) : `do_rescale` `True` olarak ayarlandığında görüntüyü yeniden ölçeklemek için kullanılan yeniden ölçekleme faktörü.

do_normalize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan değeri `[0.485, 0.456, 0.406]`) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan `[0.229, 0.224, 0.225]`) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_center_crop (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

do_pad (`bool`, *kwargs*, *isteğe bağlı*) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

do_sample_frames (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : İşleme başlamadan önce videodan kare örneklenip örneklenmeyeceği veya videonun tamamının işleneceği.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Toplam süre, fps ve toplam kare sayısı hakkında bilgi içeren videonun metadata'sı. Videodan kare örneklemek veya zaman damgalarını hesaplamak için kullanılacaktır. Videoyu işlemden önce manuel olarak çözmeye çalışmıyorsanız herhangi bir metadata geçirmeyin

fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True` olduğunda saniyede örneklenmesi hedeflenen kareler.

num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True` olduğunda örneklenmesi gereken maksimum kare sayısı.

return_metadata (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : Video meta verilerinin döndürülüp döndürülmemesi. Video meta verileri, video süresi, fps, çözümleme arka ucu gibi bilgileri içeren bir nesnedir.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Ayarlanırsa, belirli bir çerçeveye ait tensörler döndürülür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([VideosKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.VideosKwargs), *opsiyonel*) : Her modallite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Model-özel parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

VideomtVideoProcessor video işleyicisi oluşturur.

#### post_process_semantic_segmentation[[transformers.VideomtVideoProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list, return_segmentation_scores: bool = False)
```

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

**Parametreler:**

outputs (`VideomtForUniversalSegmentationOutput`) : Modelin ham çıktıları.

target_sizes (`list[tuple[int, int]]`) : Her tahminin istenen nihai boyutuna karşılık gelen `(height, width)` demetlerinin listesi. Uzunluk, çıktıdaki kare sayısıyla eşleşmelidir.

return_segmentation_scores (`bool`, *isteğe bağlı*, varsayılan `False`) : Segmentasyon haritasının yanı sıra segmentasyon puanlarının da döndürülüp döndürülmeyeceğini belirtir. `True` olduğunda, döndürülen listenin her öğesi `segmentation` (sınıf kimlikleri, şekil `(height, width)`) ve `segmentation_scores` (şekil `(num_classes, height, width)`) alanlarına sahip bir `SemanticSegmentationPostProcessorOutput` nesnesidir.

**Dönüş:** `list[torch.Tensor]` veya `list[SemanticSegmentationPostProcessorOutput]`

`return_segmentation_scores=False` (varsayılan) olduğunda, her öğesi sınıf kimliklerine sahip, `(height, width)` biçiminde bir segmentasyon haritası olan, uzunluğu `batch_size` olan bir liste döndürülür. `return_segmentation_scores=True` olduğunda, `segmentation` (sınıf kimlikleri, `(height, width)` biçiminde) ve `segmentation_scores` (`(num_classes, height, width)` biçiminde) alanlarına sahip `SemanticSegmentationPostProcessorOutput` nesnelerinden oluşan bir liste döndürülür. Her iki durumda da `(height, width)`, hedef boyuta karşılık gelir.

[VideomtForUniversalSegmentation](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtForUniversalSegmentation) çıktısını anlamsal segmentasyon tahminlerine dönüştürür.

#### post_process_instance_segmentation[[transformers.VideomtVideoProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list, threshold: float = 0.5)
```

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

**Parametreler:**

outputs (`VideomtForUniversalSegmentationOutput`) : Modelin ham çıktıları.

target_sizes (`list[tuple[int, int]]`) : Her tahminin istenen nihai boyutuna karşılık gelen `(height, width)` demetlerinin listesi. Uzunluk, çıktıdaki kare sayısıyla eşleşmelidir.

threshold (`float`, *isteğe bağlı*, varsayılan 0.5) : Bir örneğin korunması için gereken minimum birleşik puan.

**Dönüş:** `list[dict]`

Bir sözlükler listesi (kare başına bir tane), her biri şunları içerir:
- `"segmentation"` -- Örnek kimliklerini (veya arka plan için -1) içeren, `(height, width)` biçiminde bir `torch.Tensor`.
- `"segments_info"` -- Her örnek için `"id"`, `"label_id"` ve `"score"` içeren sözlüklerden oluşan bir liste.

[VideomtForUniversalSegmentation](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtForUniversalSegmentation) çıktısını örnek segmentasyon tahminlerine dönüştürür.

#### post_process_panoptic_segmentation[[transformers.VideomtVideoProcessor.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list, threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None)
```

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

**Parametreler:**

outputs (`VideomtForUniversalSegmentationOutput`) : Modelin ham çıktıları.

target_sizes (`list[tuple[int, int]]`) : Her tahminin istenen nihai boyutuna karşılık gelen `(height, width)` demetlerinin listesi. Uzunluk, çıktıdaki kare sayısıyla eşleşmelidir.

threshold (`float`, *isteğe bağlı*, varsayılan 0.8) : Tahmin edilen bir segmentin korunması için gereken minimum puan.

mask_threshold (`float`, *isteğe bağlı*, varsayılan 0.5) : Maske olasılıklarını ikileştirmek için eşik değeri.

overlap_mask_area_threshold (`float`, *opsiyonel*, varsayılan 0.8) : Maskelerin tek bir segmente birleştirilmesi için örtüşme eşiği.

label_ids_to_fuse (`set[int]`, *isteğe bağlı*) : Kopuk bölgeler arasında birleştirilmesi gereken etiket kimlikleri.

**Dönüş:** `list[dict]`

Bir sözlükler listesi (kare başına bir tane), her biri şunları içerir:
- `"segmentation"` -- Segment kimliklerini (veya arka plan için -1) içeren, `(height, width)` biçiminde bir `torch.Tensor`.
- `"segments_info"` -- Her segment için `"id"`, `"label_id"` ve `"score"` içeren sözlüklerden oluşan bir liste.

[VideomtForUniversalSegmentation](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtForUniversalSegmentation) çıktısını panoptik segmentasyon tahminlerine dönüştürür.

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

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

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `1024`) : Gizli temsillerin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `24`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `16`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

hidden_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : Katman normalizasyonu katmanlarında kullanılan epsilon.

image_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `640`) : Her bir görüntünün boyutu (çözünürlüğü).

patch_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `16`) : Her yamanın boyutu (çözünürlüğü).

num_channels (`int`, *opsiyonel*, varsayılan `3`) : Girdi kanal sayısı.

mlp_ratio (`int`, *isteğe bağlı*, varsayılan `4`) : MLP gizli boyutunun gömme boyutuna oranı.

layerscale_value (`float`, *isteğe bağlı*, varsayılan 1.0) : LayerScale parametresi için başlangıç değeri.

drop_path_rate (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Yama birleştirme için drop path oranı.

num_upscale_blocks (`int`, *isteğe bağlı*, varsayılan 2) : Dekoderde veya segmentasyon başlığında kullanılan yukarı örneklemeye bloklarının sayısı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

use_swiglu_ffn (`bool`, *isteğe bağlı*, varsayılan `False`) : SwiGLU ileri beslemeli sinir ağı kullanılıp kullanılmayacağı.

num_blocks (`int`, *isteğe bağlı*, varsayılan 4) : Mimarideki özellik bloğu veya aşama sayısı.

no_object_weight (`float`, *opsiyonel*, varsayılan 0.1) : Panoptik/nesne segmentasyonunda 'nesne yok' sınıfı için kayıp ağırlığı.

class_weight (`float`, *isteğe bağlı*, varsayılan 2.0) : Sınıflandırma hedefleri için kayıp ağırlığı.

mask_weight (`float`, *isteğe bağlı*, varsayılan 5.0) : Maske tahmini için kayıp ağırlığı.

dice_weight (`float`, *isteğe bağlı*, varsayılan `5.0`) : Panoptik segmentasyon kaybında dice kaybının göreli ağırlığı.

train_num_points (`int`, *opsiyonel*, varsayılan 12544) : Eğitim sırasında maske kaybı hesabı için örneklenmesi gereken nokta sayısı.

oversample_ratio (`float`, *isteğe bağlı*, varsayılan 3.0) : Maske eğitimi için nokta örneklemesinde kullanılan aşırı örneklem oranı.

importance_sample_ratio (`float`, *opsiyonel*, varsayılan 0.75) : Eğitim sırasında önem bazlı örneklenen noktaların oranı.

num_queries (`int`, *isteğe bağlı*, varsayılan 200) : Transformer'daki nesne sorgularının sayısı.

num_register_tokens (`int`, *isteğe bağlı*, varsayılan 4) : Transformer girdisine eklenen öğrenilebilir kayıt (register) token sayısı.

Bu, bir VideomtModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Videomt modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [tue-mps/videomt-dinov2-small-ytvis2019](https://huggingface.co/tue-mps/videomt-dinov2-small-ytvis2019) modelinin yapılandırmasına benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

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

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

**Parametreler:**

config ([PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerleştirilir (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir metasınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

## VideomtForUniversalSegmentation[[transformers.VideomtForUniversalSegmentation]]

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

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

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

**Parametreler:**

config ([VideomtConfig](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Örnek/semantik/panoptik segmentasyon için üstte başa sahip Videomt Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

**Parametreler:**

pixel_values_videos (`torch.Tensor`, *isteğe bağlı*) : `(batch_size, num_frames, num_channels, height, width)` biçiminde video girdileri.

mask_labels (`list[torch.Tensor]`, *isteğe bağlı*) : 5B video girdileri için desteklenmez.

class_labels (`list[torch.LongTensor]`, *isteğe bağlı*) : 5B video girdileri için desteklenmez.

patch_offsets (`list[torch.Tensor]`, *isteğe bağlı*) : Video girdileri için kullanılmaz ve yalnızca modüler uyumluluk için korunur.

**Dönüş:** `VideomtForUniversalSegmentationOutput` veya `tuple(torch.Tensor)`

A `VideomtForUniversalSegmentationOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([VideomtConfig](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VideomtForUniversalSegmentation](/docs/transformers/main/tr/model_doc/videomt#transformers.VideomtForUniversalSegmentation) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, *isteğe bağlı*) -- Etiketler mevcut olduğunda döndürülen hesaplanan kayıp.
- **class_queries_logits** (`torch.Tensor`, *isteğe bağlı*) -- Her sorgu için önerilen sınıfları temsil eden, `(batch_size, num_queries, num_labels + 1)` biçiminde bir tensör. `+ 1`'in, null sınıfını dahil ettiğimiz için gerekli olduğunu unutmayın.
- **masks_queries_logits** (`torch.Tensor`, *isteğe bağlı*) -- Her sorgu için önerilen maskeleri temsil eden, `(batch_size, num_queries, height, width)` biçiminde bir tensör.
- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, num_channels, height, width)`) -- Son katmanın son gizli durumları (son özellik haritası).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her aşamanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet. Modelin tüm katmanlarının gizli durumları.
- **attentions** (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `tuple(torch.Tensor)` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`. Transformer decoder'dan Self ve Cross Attentions ağırlıkları.