# Video Vision Transformer (ViViT)

## Genel Bakış

Vivit modeli, Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić ve Cordelia Schmid tarafından [ViViT: A Video Vision Transformer](https://huggingface.co/papers/2103.15691) makalesinde önerilmiştir. Makale, video anlama için en başarılı saf dönüştürücü tabanlı model setlerinden birini önermektedir.

Makalenin özeti aşağıdaki gibidir:

*Görüntü sınıflandırmada bu tür modellerin son başarısından ilham alarak, video sınıflandırma için saf transformer tabanlı modeller sunuyoruz. Modelimiz, girdi videosundan uzamsal-zamansal (spatio-temporal) token'lar çıkarır; bu token'lar daha sonra bir dizi transformer katmanı tarafından kodlanır. Videoda karşılaşılan uzun token dizilerini işlemek için, girdinin uzamsal ve zamansal boyutlarını ayrıştıran (factorise) modelimizin çeşitli verimli varyantlarını öneriyoruz. Transformer tabanlı modellerin yalnızca büyük eğitim veri kümeleri mevcut olduğunda etkili olduğu bilinse de, eğitim sırasında modeli etkili bir şekilde düzenleyebildiğimizi (regularise) ve karşılaştırmalı olarak küçük veri kümelerinde eğitim yapabilmek için önceden eğitilmiş görüntü modellerinden yararlanabildiğimizi gösteriyoruz. Kapsamlı ablatasyon çalışmaları (ablation studies) gerçekleştiriyor ve Kinetics 400 ve 600, Epic Kitchens, Something-Something v2 ile Moments in Time dahil olmak üzere birden fazla video sınıflandırma benchmark'ında en iyi sonuçları (state-of-the-art) elde ediyor, derin 3D konvolüsyonel ağlara dayalı önceki yöntemleri geride bırakıyoruz.*

Bu model [jegormeister](https://huggingface.co/jegormeister) tarafından katkıda bulunmuştur. Orijinal kod (JAX ile yazılmış) [burada](https://github.com/google-research/scenic/tree/main/scenic/projects/vivit) bulunabilir.

### Ölçekli Nokta Çarpımı Dikkat (SDPA) Kullanımı

PyTorch, `torch.nn.functional` parçası olarak yerel ölçekli nokta çarpımı dikkati (SDPA) operatörünü içerir. Bu fonksiyon, girdilere ve kullanılan donanıma bağlı olarak uygulanabilecek çeşitli uygulamaları kapsar. Daha fazla bilgi için [resmi dokümantasyonu](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) veya [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) sayfasına bakın.

`torch>=2.1.1` için bir uygulama mevcut olduğunda varsayılan olarak SDPA kullanılır, ancak SDPA'nın kullanılmasını açıkça istemek için `from_pretrained()` içinde `attn_implementation="sdpa"` ayarlayabilirsiniz.

```python
from transformers import VivitModel

model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400", attn_implementation="sdpa", device_map="auto")
...
```

En iyi hızlanmalar için, modelin yarım hassasiyette (ör. `torch.float16` veya `torch.bfloat16`) yüklenmesini öneririz.

Yerel bir benchmark'ta (A100-40GB, PyTorch 2.3.0, OS Ubuntu 22.04) `float32` ve `google/vivit-b-16x2-kinetics400` modeliyle, çıkarım sırasında aşağıdaki hızlanmaları gözlemledik.

### Eğitim

|   num_training_steps |   batch_size |   cuda |   Hızlanma (%) |   Eager zirve bellek (MB) |   sdpa zirve bellek (MB) |   Bellek tasarrufu (%) |
|---------------------:|-------------:|----------:|--------------:|----------------------:|---------------------:|-----------------:|
|                  100 |            1 |      True |         7.122 |               2575.28 |              5932.54 |           130.364 |

### Çıkarım

|   num_batches |   batch_size |   cuda |   yarı |   Hızlanma (%) |   Hafıza aceleci (MB) |   Bellek BT (MB) |   Bellek tasarrufu (%) |
|---------------|--------------|-----------|-----------|---------------|------------------|---------------|-----------------|
|            20 |             1 |   True    |   False   |      15.422   |     715.807      |    317.079    |      125.75     |
|            20 |             2 |   True    |   False   |      17.146   |    1234.75       |    447.175    |      176.122    |
|            20 |             4 |   True    |   False   |      18.093   |    2275.82       |    709.864    |      220.6      |
|            20 |             8 |   True    |   False   |      19.284   |    4358.19       |   1233.24     |      253.393    |

## VivitConfig[[transformers.VivitConfig]]

#### transformers.VivitConfig[[transformers.VivitConfig]]

```python
transformers.VivitConfig(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, image_size: int | list[int] | tuple[int, int] = 224, num_frames: int = 32, tubelet_size: list[int] | tuple[int, ...] = (2, 16, 16), num_channels: int = 3, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu_fast', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, qkv_bias: bool = True, pooler_output_size: int | None = None, pooler_act: str = 'tanh')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/configuration_vivit.py#L24)

**Parametreler:**

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

num_frames (`int`, *isteğe bağlı*, varsayılan 32) : Her videodaki kare sayısı.

tubelet_size (`list[int]`, *isteğe bağlı*, varsayılan `[2, 16, 16]`) : Her tüpletin boyutu (çözünürlüğü).

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

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

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

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

intermediate_size (`int`, *isteğe bağlı*, varsayılan `3072`) : MLP temsil boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu_fast`) : Dekoderdeki 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ığı.

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

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.

qkv_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Sorgulara, anahtarlara ve değerlere bir sapma (bias) eklenip eklenmeyeceğini belirtir.

pooler_output_size (`int`, *opsiyonel*) : Pooler katmanının boyutluluğu. None ise, varsayılan olarak `hidden_size` değerini alır.

pooler_act (`str`, *isteğe bağlı*, varsayılan `"tanh"`) : Pooler tarafından kullanılacak aktivasyon fonksiyonu.

Bu, bir VivitModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Vivit modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [google/vivit-b-16x2-kinetics400](https://huggingface.co/google/vivit-b-16x2-kinetics400) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import VivitConfig, VivitModel

>>> # Initializing a ViViT google/vivit-b-16x2-kinetics400 style configuration
>>> configuration = VivitConfig()

>>> # Initializing a model (with random weights) from the google/vivit-b-16x2-kinetics400 style configuration
>>> model = VivitModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## VivitImageProcessor[[transformers.VivitImageProcessor]]

#### transformers.VivitImageProcessor[[transformers.VivitImageProcessor]]

```python
transformers.VivitImageProcessor(do_resize: bool = True, size: dict[str, int] | None = None, resample: Resampling = <Resampling.BILINEAR: 2>, do_center_crop: bool = True, crop_size: dict[str, int] | None = None, do_rescale: bool = True, rescale_factor: int | float = 0.00784313725490196, offset: bool = True, do_normalize: bool = True, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/image_processing_vivit.py#L63)

**Parametreler:**

do_resize (`bool`, *isteğe bağlı*, varsayılan `True`) : Görselin (yükseklik, genişlik) boyutlarını belirtilen `size` değerine yeniden boyutlandırılacak mı? `preprocess` metodundaki `do_resize` parametresi tarafından geçersiz kılınabilir.

size (`dict[str, int]` *isteğe bağlı*, varsayılan `{"shortest_edge" : 256}`): Yeniden boyutlandırma sonrası çıktı görüntüsünün boyutu. Görüntünün en kısa kenarı, orijinal görüntünün en-boy oranını koruyarak `size["shortest_edge"]` değerine yeniden boyutlandırılır. `preprocess` yöntemindeki `size` parametresi tarafından geçersiz kılınabilir.

resample (`PILImageResampling`, *isteğe bağlı*, varsayılan `Resampling.BILINEAR`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. `preprocess` yöntemindeki `resample` parametresi ile geçersiz kılınabilir.

do_center_crop (`bool`, *isteğe bağlı*, varsayılan `True`) : Görselin belirtilen `crop_size` boyutuna göre ortadan kırpılıp kırpılmayacağını belirtir. `preprocess` metodundaki `do_center_crop` parametresi ile geçersiz kılınabilir.

crop_size (`dict[str, int]`, *isteğe bağlı*, varsayılan `{"height" : 224, "width": 224}`): Merkez kırpma uygulandıktan sonra görüntünün boyutu. `preprocess` yöntemindeki `crop_size` parametresi ile geçersiz kılınabilir.

do_rescale (`bool`, *isteğe bağlı*, varsayılan `True`) : Görselin belirtilen `rescale_factor` ölçeğine göre yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir. `preprocess` yöntemindeki `do_rescale` parametresi tarafından geçersiz kılınabilir.

rescale_factor (`int` veya `float`, *isteğe bağlı*, varsayılan `1/127.5`) : Görsel yeniden ölçeklendiriliyorsa kullanılacak ölçekleme çarpanını tanımlar. `preprocess` yöntemindeki `rescale_factor` parametresi tarafından geçersiz kılınabilir.

offset (`bool`, *isteğe bağlı*, varsayılan `True`) : Görselin hem negatif hem de pozitif yönlerde ölçeklenip ölçeklenmeyeceğini belirtir. `preprocess` yöntemindeki `offset` ile geçersiz kılınabilir.

do_normalize (`bool`, *isteğe bağlı*, varsayılan `True`) : Görüntünün normalize edilip edilmeyeceğini belirtir. `preprocess` yöntemindeki `do_normalize` parametresi ile geçersiz kılınabilir.

image_mean (`float` veya `list[float]`, *isteğe bağlı*, varsayılan `IMAGENET_STANDARD_MEAN`) : Görseli normalize ederken kullanılacak ortalama. Bu, görseldeki kanal sayısına eşit uzunlukta bir float veya float listesi olabilir. `preprocess` yöntemindeki `image_mean` parametresi ile geçersiz kılınabilir.

image_std (`float` veya `list[float]`, *isteğe bağlı*, varsayılan `IMAGENET_STANDARD_STD`) : Görseli normalleştirmek için kullanılacak standart sapma. Bu, görseldeki kanal sayısı kadar uzunlukta bir float veya float listesi olabilir. `preprocess` yöntemindeki `image_std` parametresi ile geçersiz kılınabilir.

Vivit görüntü işleyicisi oluşturur.

#### preprocess[[transformers.VivitImageProcessor.preprocess]]

```python
preprocess(videos: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], do_resize: bool | None = None, size: dict[str, int] | None = None, resample: PIL.Image.Resampling | None = None, do_center_crop: bool | None = None, crop_size: dict[str, int] | None = None, do_rescale: bool | None = None, rescale_factor: float | None = None, offset: bool | None = None, do_normalize: bool | None = None, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'>, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/image_processing_vivit.py#L285)

**Parametreler:**

videos (`ImageInput`) : Ön işleme yapılacak video kareleri. Piksel değerleri 0 ile 255 arasında değişen tek bir video karesi veya bir parti video karesi beklenir. Piksel değerleri 0 ile 1 arasında olan kareler geçiriliyorsa `do_rescale=False` olarak ayarlayın.

do_resize (`bool`, *isteğe bağlı*, varsayılan `self.do_resize`) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`dict[str, int]`, *isteğe bağlı*, varsayılan `self.size`) : Yeniden boyutlandırma uygulandıktan sonra görüntünün boyutu.

resample (`PILImageResampling`, *isteğe bağlı*, varsayılan `self.resample`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum'larından biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_center_crop (`bool`, *isteğe bağlı*, varsayılan `self.do_centre_crop`) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

crop_size (`dict[str, int]`, *isteğe bağlı*, varsayılan `self.crop_size`) : Merkez kırpma uygulandıktan sonra görüntünün boyutu.

do_rescale (`bool`, *isteğe bağlı*, varsayılan `self.do_rescale`) : `offset` `True` ise görüntü değerlerini `[-1 - 1]` arasında, aksi halde `[0, 1]` arasında yeniden ölçeklendirip ölçeklendirmeyeceğini belirtir.

rescale_factor (`float`, *isteğe bağlı*, varsayılan `self.rescale_factor`) : `do_rescale` `True` olarak ayarlanırsa görüntüyü yeniden ölçeklemek için kullanılan yeniden ölçekleme faktörü.

offset (`bool`, *isteğe bağlı*, varsayılan `self.offset`) : Görselin hem negatif hem de pozitif yönlerde ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

do_normalize (`bool`, *isteğe bağlı*, varsayılan `self.do_normalize`) : Görselin normalize edilip edilmeyeceğini belirtir.

image_mean (`float` veya `list[float]`, *isteğe bağlı*, varsayılan `self.image_mean`) : Görüntü ortalaması.

image_std (`float` veya `list[float]`, *isteğe bağlı*, varsayılan `self.image_std`) : Görüntü standart sapması.

return_tensors (`str` veya `TensorType`, *isteğe bağlı*) : Döndürülecek tensörlerin türü. Aşağıdakilerden biri olabilir: - Ayarlanmamış: `np.ndarray` türünde bir liste döndürür. - `TensorType.PYTORCH` veya `'pt'`: `torch.Tensor` türünde bir parti döndürür. - `TensorType.NUMPY` veya `'np'`: `np.ndarray` türünde bir parti döndürür.

data_format (`ChannelDimension` veya `str`, *isteğe bağlı*, varsayılan `ChannelDimension.FIRST`) : Çıktı görüntüsü için kanal boyutu biçimi. Aşağıdakilerden biri olabilir: - `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - Ayarlanmamış: Girdi görüntüsünün çıkarılan kanal boyutu biçimini kullanın.

input_data_format (`ChannelDimension` veya `str`, *isteğe bağlı*) : Girdi görüntüsü için 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ü.

Bir görüntüyü veya görüntü grubunu ön işleme tabi tutun.

## VivitVideoProcessor[[transformers.VivitVideoProcessor]]

#### transformers.VivitVideoProcessor[[transformers.VivitVideoProcessor]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/video_processing_vivit.py#L25)

**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 `{'shortest_edge' : 256}`): Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `False`) : 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.00784313725490196`) : `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 `[0.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : 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 `True`) : 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*, varsayılan `{'height' : 224, 'width': 224}`): `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/v5.23.0/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.

VivitVideoProcessor video işleyicisi oluşturur.

#### preprocess[[transformers.VivitVideoProcessor.preprocess]]

```python
preprocess(videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]]], **kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/video_processing_vivit.py#L49)

**Parametreler:**

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`) : Ön işleme yapılacak video. Piksel değerleri 0 ile 255 arasında değişen tek bir video veya video partisi beklenir. Piksel değerleri 0 ile 1 arasında olan videolar geçiriliyorsa `do_rescale=False` olarak ayarlayın.

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

do_resize (`bool`, *kwargs*, *isteğe bağlı*) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

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

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

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 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*) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*) : `do_rescale` `True` olarak ayarlanırsa görüntüyü yeniden ölçeklemek için yeniden ölçekleme çarpanı.

do_normalize (`bool`, *kwargs*, *isteğe bağlı*) : Görüntünün normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : 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*) : 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*) : 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*, *isteğe bağlı*) : İş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*, *isteğe bağlı*) : 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*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

**Dönüş:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ yönteminin döndürdüğü listeler/diziler/tensörler sözlüğü ('pixel_values' vb.).
- **tensor_type** (`Union[None, str, TensorType]`, *isteğe bağlı*) -- Başlatma sırasında PyTorch/Numpy Tensörlerindeki tamsayı listelerini dönüştürmek için burada bir tensor_type verebilirsiniz.

## VivitModel[[transformers.VivitModel]]

#### transformers.VivitModel[[transformers.VivitModel]]

```python
transformers.VivitModel(config: VivitConfig, add_pooling_layer: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/modeling_vivit.py#L318)

**Parametreler:**

config ([VivitConfig](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitConfig)) : 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/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

add_pooling_layer (`bool`, *isteğe bağlı*, varsayılan `True`) : Bir havuzlama katmanı eklenip eklenmeyeceği

Üzerinde herhangi bir özel head olmadan ham hidden-state çıktısı üreten çıplak Vivit Model.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.VivitModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/modeling_vivit.py#L333)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [VivitImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [VivitImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [VivitImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitImageProcessor) kullanır).

interpolate_pos_encoding (`bool`, *isteğe bağlı*, varsayılan `False`) : Ön eğitilmiş konum kodlamalarının interpolasyonunun yapılıp yapılmayacağını belirtir.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

**Dönüş:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); yapılandırma ([VivitConfig](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VivitModel](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitModel) 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.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıralamanın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, yardımcı ön eğitim görevi için kullanılan katmanlardan geçirildikten sonraki hali. Örneğin BERT ailesi modelleri için, bu, sınıflandırma token'ının doğrusal bir katman ve tanh aktivasyon fonksiyonundan geçirildikten sonraki halini döndürür. Doğrusal katman ağırlıkları, ön eğitim sırasında bir sonraki cümle tahmini (sınıflandırma) hedefinden eğitilir.
- **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 katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

```python
>>> import av
>>> import numpy as np

>>> from transformers import VivitImageProcessor, VivitModel
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`list[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`list[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> # prepare video for the model
>>> inputs = image_processor(list(video), return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 3137, 768]
```

## VivitForVideoClassification[[transformers.VivitForVideoClassification]]

#### transformers.VivitForVideoClassification[[transformers.VivitForVideoClassification]]

```python
transformers.VivitForVideoClassification(config: VivitConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/modeling_vivit.py#L447)

**Parametreler:**

config ([VivitConfig](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitConfig)) : 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/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üstünde video sınıflandırma kafası bulunan ViViT Transformer modeli (örneğin Kinetics-400 için) ([CLS] token'ının son gizli durumunun üstünde doğrusal bir katman).

Modelin forward'ında `interpolate_pos_encoding` parametresini `True` olarak ayarlayarak, ViT'nin eğitimde kullanıldığından daha yüksek çözünürlüklü görseller üzerinde ince ayar yapılmasının mümkün olduğunu unutmayın. Bu işlem, önceden eğitilmiş konum gömme değerlerini (position embeddings) daha yüksek çözünürlüğe göre içsel olarak (interpolate) hesaplar.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.VivitForVideoClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vivit/modeling_vivit.py#L460)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [VivitImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [VivitImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [VivitImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitImageProcessor) kullanır).

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Görüntü sınıflandırma/geri dönüşüm kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüşüm kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

interpolate_pos_encoding (`bool`, *isteğe bağlı*, varsayılan `False`) : Ön eğitilmiş konum kodlamalarının interpolasyonunun yapılıp yapılmayacağını belirtir.

**Dönüş:** [ImageClassifierOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) veya `tuple(torch.Tensor)`

[ImageClassifierOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([VivitConfig](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VivitForVideoClassification](/docs/transformers/v5.23.0/tr/model_doc/vivit#transformers.VivitForVideoClassification) 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`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma (config.num_labels==1 ise regresyon) kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma (veya config.num_labels==1 ise regresyon) puanları (SoftMax öncesi).
- **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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her aşamanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her aşamanın çıktısındaki gizli durumları (aynı zamanda özellik haritaları olarak da adlandırılır).
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, patch_size, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

```python
>>> import av
>>> import numpy as np
>>> import torch

>>> from transformers import VivitImageProcessor, VivitForVideoClassification
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`list[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`list[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> inputs = image_processor(list(video), return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
...     logits = outputs.logits

>>> # model predicts one of the 400 Kinetics-400 classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
LABEL_116
```

