# Video Vision Transformer (ViViT)

## Aperçu

Le modèle Vivit a été proposé dans [ViViT: A Video Vision Transformer](https://huggingface.co/papers/2103.15691) par Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić, Cordelia Schmid. L’article propose l’un des premiers ensembles de modèles basés sur des transformers purs à avoir connu un succès dans la compréhension vidéo.

L'abstract de l'article est le suivant :

*Nous présentons des modèles basés sur des transformeurs purs pour la classification de vidéos, en nous appuyant sur le succès récent de ce type de modèles en classification d’images. Notre modèle extrait des jetons spatio-temporels à partir de la vidéo d’entrée, qui sont ensuite encodés par une série de couches de transformeur. Afin de gérer les longues séquences de jetons rencontrées dans les vidéos, nous proposons plusieurs variantes efficaces de notre modèle qui factorisent les dimensions spatiale et temporelle de l’entrée. Bien que les modèles basés sur des transformeurs soient connus pour n’être efficaces que lorsque de grands jeux de données d’entraînement sont disponibles, nous montrons comment régulariser efficacement le modèle pendant l’entraînement et exploiter des modèles d’images pré-entraînés afin de pouvoir entraîner sur des jeux de données relativement petits. Nous menons des études d’ablation approfondies et obtenons des résultats de l’état de l’art sur plusieurs benchmarks de classification de vidéos, y compris Kinetics 400 et 600, Epic Kitchens, Something-Something v2 et Moments in Time, surpassant les méthodes antérieures basées sur des réseaux de convolution 3D profonds.*

Ce modèle a été contribué par [jegormeister](https://huggingface.co/jegormeister). Le code d'origine (écrit en JAX) peut être trouvé [ici](https://github.com/google-research/scenic/tree/main/scenic/projects/vivit).

### Utilisation de l'attention à produit scalaire mis à l'échelle (SDPA)

PyTorch intègre un opérateur natif d'attention par produit scalaire mis à l'échelle (SDPA) au sein de `torch.nn.functional`. Cette fonction englobe plusieurs implémentations qui peuvent être appliquées en fonction des entrées et du matériel utilisé. Consultez la [documentation officielle](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) ou la page [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) pour plus d'informations.

SDPA est utilisé par défaut pour `torch>=2.1.1` lorsqu’une implémentation est disponible, mais vous pouvez également définir `attn_implementation="sdpa"` dans `from_pretrained()` pour demander explicitement l’utilisation de SDPA.

```python
from transformers import VivitModel

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

Pour obtenir les accélérations optimales, nous recommandons de charger le modèle en demi-précision (par exemple `torch.float16` ou `torch.bfloat16`).

Sur un benchmark local (A100-40GB, PyTorch 2.3.0, OS Ubuntu 22.04) avec `float32` et le modèle `google/vivit-b-16x2-kinetics400`, nous avons observé les accélérations suivantes lors de l’inférence.

### Entraînement

|   num_training_steps |   batch_size |   est cuda |   Accélération (%) |   Mémoire pic Eager (Mo) |   mémoire pic sdpa (Mo) |   Économie de mémoire (%) |
|---------------------:|-------------:|----------:|--------------:|----------------------:|---------------------:|-----------------:|
|                  100 |            1 |      True |         7.122 |               2575.28 |              5932.54 |           130.364 |

### Inférence

|   num_batches |   batch_size |   est cuda |   est la moitié |   Accélération (%) |   Mémoire eager (Mo) |   Mémoire BT (Mo) |   Mémoire économisée (%) |
|---------------|--------------|-----------|-----------|---------------|------------------|---------------|-----------------|
|            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')
```

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

**Paramètres :**

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `224`) : La taille (résolution) de chaque image.

num_frames (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de frames dans chaque vidéo.

tubelet_size (`list[int]`, *facultatif*, par défaut `[2, 16, 16]`) : La taille (résolution) de chaque tubelet.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu_fast`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.

pooler_output_size (`int`, *facultatif*) : Dimension de la couche pooler. Si None, la valeur par défaut est `hidden_size`.

pooler_act (`str`, *facultatif*, valeur par défaut `"tanh"`) : La fonction d'activation utilisée par le pooler.

Ceci est la classe de configuration destinée à stocker la configuration d'un VivitModel. Elle est utilisée pour instancier un modèle Vivit en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/vivit-b-16x2-kinetics400](https://huggingface.co/google/vivit-b-16x2-kinetics400)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

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

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

**Paramètres :**

do_resize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner les dimensions (hauteur, largeur) de l'image à la `size` spécifiée. Peut être remplacé par le paramètre `do_resize` dans la méthode `preprocess`.

size (`dict[str, int]` *facultatif*, par défaut `{"shortest_edge" : 256}`) : Taille de l'image de sortie après redimensionnement. Le plus petit côté de l'image sera redimensionné à `size["shortest_edge"]` tout en conservant le ratio d'aspect de l'image d'origine. Peut être remplacé par `size` dans la méthode `preprocess`.

resample (`PILImageResampling`, *facultatif*, valeur par défaut `Resampling.BILINEAR`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Peut être remplacé par le paramètre `resample` de la méthode `preprocess`.

do_center_crop (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image sur la `crop_size` spécifiée. Peut être remplacé par le paramètre `do_center_crop` de la méthode `preprocess`.

crop_size (`dict[str, int]`, *facultatif*, par défaut `{"height" : 224, "width": 224}`) : Taille de l'image après application du recadrage central. Peut être remplacé par le paramètre `crop_size` dans la méthode `preprocess`.

do_rescale (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image selon l'échelle spécifiée `rescale_factor`. Peut être remplacé par le paramètre `do_rescale` dans la méthode `preprocess`.

rescale_factor (`int` ou `float`, *facultatif*, valeur par défaut `1/127.5`) : Définit le facteur d'échelle à utiliser lors du rééchelonnement de l'image. Peut être remplacé par le paramètre `rescale_factor` de la méthode `preprocess`.

offset (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre l'image à l'échelle dans les deux directions, négative et positive. Peut être remplacé par `offset` dans la méthode `preprocess`.

do_normalize (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut normaliser l'image. Peut être remplacé par le paramètre `do_normalize` de la méthode `preprocess`.

image_mean (`float` ou `list[float]`, *facultatif*, par défaut `IMAGENET_STANDARD_MEAN`) : Moyenne à utiliser pour normaliser l'image. Il s'agit d'un float ou d'une liste de floats dont la longueur correspond au nombre de canaux de l'image. Peut être remplacé par le paramètre `image_mean` de la méthode `preprocess`.

image_std (`float` ou `list[float]`, *facultatif*, par défaut `IMAGENET_STANDARD_STD`) : Écart-type à utiliser pour normaliser l'image. Il s'agit d'un float ou d'une liste de floats dont la longueur correspond au nombre de canaux de l'image. Peut être remplacé par le paramètre `image_std` de la méthode `preprocess`.

Construit un processeur d’image Vivit.

#### prétraiter[[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)
```

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

**Paramètres :**

videos (`ImageInput`) : Images vidéo à prétraiter. Attend une seule image vidéo ou un lot d'images vidéo dont les valeurs de pixels vont de 0 à 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_resize (`bool`, *facultatif*, par défaut `self.do_resize`) : Indique s'il faut redimensionner l'image.

size (`dict[str, int]`, *facultatif*, par défaut `self.size`) : Taille de l'image après application du redimensionnement.

resample (`PILImageResampling`, *facultatif*, par défaut `self.resample`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'enum `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_center_crop (`bool`, *facultatif*, valeur par défaut `self.do_centre_crop`) : Indique s'il faut effectuer un recadrage centré de l'image.

crop_size (`dict[str, int]`, *facultatif*, par défaut `self.crop_size`) : Taille de l'image après application du recadrage central.

do_rescale (`bool`, *facultatif*, par défaut `self.do_rescale`) : Indique s'il faut rééchelonner les valeurs de l'image entre `[-1 - 1]` si `offset` est `True`, `[0, 1]` sinon.

rescale_factor (`float`, *facultatif*, par défaut `self.rescale_factor`) : Facteur de remise à l'échelle à appliquer à l'image si `do_rescale` est défini sur `True`.

offset (`bool`, *facultatif*, valeur par défaut `self.offset`) : Indique s'il faut mettre l'image à l'échelle dans les deux directions, négative et positive.

do_normalize (`bool`, *facultatif*, par défaut `self.do_normalize`) : Indique s'il faut normaliser l'image.

image_mean (`float` ou `list[float]`, *facultatif*, par défaut `self.image_mean`) : Moyenne de l'image.

image_std (`float` ou `list[float]`, *facultatif*, par défaut `self.image_std`) : Écart-type de l'image.

return_tensors (`str` ou `TensorType`, *facultatif*) : Le type de tenseurs à retourner. Peut être l'un des éléments suivants : - Non défini : Retourne une liste de `np.ndarray`. - `TensorType.PYTORCH` ou `'pt'` : Retourne un lot de type `torch.Tensor`. - `TensorType.NUMPY` ou `'np'` : Retourne un lot de type `np.ndarray`.

data_format (`ChannelDimension` ou `str`, *facultatif*, par défaut `ChannelDimension.FIRST`) : Le format de la dimension des canaux pour l'image de sortie. Peut être l'un des éléments suivants : - `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `ChannelDimension.LAST` : image au format (height, width, num_channels). - Non défini : utilise le format de la dimension des canaux déduit de l'image d'entrée.

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

Prétraitez une image ou un lot d'images.

## VivitVideoProcessor[[transformers.VivitVideoProcessor]]

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

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

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

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'shortest_edge' : 256}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00784313725490196`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

do_sample_frames (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement.

fps (`Annotated[int | float | None, None]`, *kwargs*) : Nombre de cibles à échantillonner par seconde lorsque `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.VideosKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Construit un processeur vidéo VivitVideoProcessor.

#### prétraiter[[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'>)
```

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

**Paramètres :**

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]]]`) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels vont de 0 à 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

do_sample_frames (`bool`, *kwargs*, *facultatif*) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement.

fps (`Annotated[int | float | None, None]`, *kwargs*) : Nombre de cibles à échantillonner par seconde lorsque `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *facultatif*) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

## VivitModel[[transformers.VivitModel]]

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

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

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

**Paramètres :**

config ([VivitConfig](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling

Le modèle Vivit brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [VivitImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitImageProcessor). Voir [VivitImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [VivitImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitImageProcessor) pour le traitement des images).

interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([VivitConfig](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitConfig)) et les entrées.

La méthode forward de [VivitModel](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

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

**Paramètres :**

config ([VivitConfig](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle Transformer ViViT avec une tête de classification vidéo au sommet (une couche linéaire au-dessus de l'état caché final du jeton [CLS]), par exemple pour Kinetics-400.

Notez qu’il est possible d’affiner ViT sur des images de résolution supérieure à celles utilisées pour son entraînement, en définissant `interpolate_pos_encoding` sur `True` dans le forward du modèle. Cela permet d’interpoler les embeddings de position pré-entraînés à la résolution supérieure.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [VivitImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitImageProcessor). Voir [VivitImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [VivitImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitImageProcessor) pour le traitement des images).

labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés.

**Retourne :** [ImageClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) ou `tuple(torch.Tensor)`

Un [ImageClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([VivitConfig](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitConfig)) et les entrées.

La méthode forward de [VivitForVideoClassification](/docs/transformers/v5.23.0/fr/model_doc/vivit#transformers.VivitForVideoClassification) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1).
- **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque étape) de forme `(batch_size, sequence_length, hidden_size)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, patch_size, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

