# Vision Transformer convolutif (CvT)

[Convolutional Vision Transformer (CvT)](https://huggingface.co/papers/2103.15808) est un modèle qui combine les atouts des réseaux de neurones convolutifs (CNN) et des Vision transformers pour les tâches de vision par ordinateur. Il introduit des couches convolutives dans l'architecture du vision transformer, lui permettant de capturer les motifs locaux dans les images tout en conservant le contexte global fourni par les mécanismes d'auto-attention.

Vous pouvez trouver tous les points de contrôle CvT sous l'organisation [Microsoft](https://huggingface.co/microsoft?search_models=cvt).

> [!TIP]
> Ce modèle a été contribué par [anujunj](https://huggingface.co/anugunj).
>
> Cliquez sur les modèles CvT dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer CvT à différentes tâches de vision par ordinateur.

L'exemple ci-dessous montre comment classifier une image avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) ou la classe [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipeline = pipeline(
    task="image-classification",
    model="microsoft/cvt-13",
    device=0
)
pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification

image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
model = AutoModelForImageClassification.from_pretrained(
    "microsoft/cvt-13",
    device_map="auto"
)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(image, return_tensors="pt").to(model.device)

with torch.no_grad():
  logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()

class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")
```

## Ressources

Reportez-vous à cette série de [notebooks](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/VisionTransformer) ViT pour des exemples d’inférence et de fine-tuning sur des jeux de données personnalisés. Remplacez `ViTFeatureExtractor` et [ViTForImageClassification](/docs/transformers/main/fr/model_doc/vit#transformers.ViTForImageClassification) dans ces notebooks par [AutoImageProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor) et [CvtForImageClassification](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtForImageClassification).

## CvtConfig[[transformers.CvtConfig]]

#### transformers.CvtConfig[[transformers.CvtConfig]]

```python
transformers.CvtConfig(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, num_channels: int = 3, patch_sizes: list[int] | tuple[int, ...] = (7, 3, 3), patch_stride: list[int] | tuple[int, ...] = (4, 2, 2), patch_padding: list[int] | tuple[int, ...] = (2, 1, 1), embed_dim: list[int] | tuple[int, ...] = (64, 192, 384), num_heads: list[int] | tuple[int, ...] = (1, 3, 6), depth: list[int] | tuple[int, ...] = (1, 2, 10), mlp_ratio: list[float] | tuple[float, ...] = (4.0, 4.0, 4.0), attention_drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0), drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0), drop_path_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.1), qkv_bias: list[bool] | tuple[bool, ...] = (True, True, True), cls_token: list[bool] | tuple[bool, ...] = (False, False, True), qkv_projection_method: list[str] | tuple[str, ...] = ('dw_bn', 'dw_bn', 'dw_bn'), kernel_qkv: list[int] | tuple[int, ...] = (3, 3, 3), padding_kv: list[int] | tuple[int, ...] = (1, 1, 1), stride_kv: list[int] | tuple[int, ...] = (2, 2, 2), padding_q: list[int] | tuple[int, ...] = (1, 1, 1), stride_q: list[int] | tuple[int, ...] = (1, 1, 1), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/configuration_cvt.py#L24)

**Paramètres :**

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

patch_sizes (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(7, 3, 3)`) : Taille des patches à chaque étape du modèle.

patch_stride (`list[int]`, *facultatif*, par défaut `[4, 2, 2]`) : La taille du pas de l'intégration de patch de chaque encodeur.

patch_padding (`list[int]`, *facultatif*, par défaut `[2, 1, 1]`) : La taille du padding de l'embedding de patch de chaque encodeur.

embed_dim (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(64, 192, 384)`) : Dimension des embeddings et des états cachés.

num_heads (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(1, 3, 6)`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

depth (`list[int]`, *facultatif*, par défaut `[1, 2, 10]`) : Le nombre de couches dans chaque bloc d'encodeur.

mlp_ratio (`Union[list[float], tuple[float, ...]]`, *facultatif*, valeur par défaut `(4.0, 4.0, 4.0)`) : Ratio de la dimension cachée du MLP par rapport à la dimension d'incorporation.

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

drop_rate (`list[float]`, *facultatif*, par défaut `[0.0, 0.0, 0.0]`) : Le taux de dropout pour les probabilités des embeddings de patch.

drop_path_rate (`Union[list[float], tuple[float, ...]]`, *facultatif*, valeur par défaut `(0.0, 0.0, 0.1)`) : Taux de drop path pour la fusion des patches.

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

cls_token (`list[bool]`, *facultatif*, par défaut `[False, False, True]`) : Indique s'il faut ou non ajouter un jeton de classification à la sortie de chacun des 3 derniers stades.

qkv_projection_method (`list[string]`, *facultatif*, valeur par défaut ["dw_bn", "dw_bn", "dw_bn"]`) : Méthode de projection pour la requête, la clé et la valeur. La valeur par défaut est des convolutions en profondeur avec normalisation par lot. Pour une projection linéaire, utilisez "avg".

kernel_qkv (`list[int]`, *facultatif*, par défaut `[3, 3, 3]`) : La taille du noyau pour la requête, la clé et la valeur dans la couche d'attention

padding_kv (`list[int]`, *facultatif*, valeur par défaut `[1, 1, 1]`) : La taille du padding pour les clés et les valeurs dans la couche d'attention

stride_kv (`list[int]`, *facultatif*, valeur par défaut `[2, 2, 2]`) : La taille du pas pour les clés et les valeurs dans la couche d'attention

padding_q (`list[int]`, *facultatif*, valeur par défaut `[1, 1, 1]`) : La taille du padding pour la requête dans la couche d'attention

stride_q (`list[int]`, *facultatif*, par défaut `[1, 1, 1]`) : La taille du pas pour la requête dans la couche 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-12`) : L'épsilon utilisé par les couches de normalisation par couche.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un CvtModel. Elle est utilisée pour instancier un modèle Cvt 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 [microsoft/cvt-13](https://huggingface.co/microsoft/cvt-13)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import CvtConfig, CvtModel

>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()

>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)

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

## CvtModel[[transformers.CvtModel]]

#### transformers.CvtModel[[transformers.CvtModel]]

```python
transformers.CvtModel(config: CvtConfig, add_pooling_layer = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L499)

**Paramètres :**

config ([CvtConfig](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtConfig)) : 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/main/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 Cvt 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/main/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.CvtModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L510)

**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 [ConvNextImageProcessor](/docs/transformers/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor) pour le traitement des images).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `BaseModelOutputWithCLSToken` ou `tuple(torch.Tensor)`

Un `BaseModelOutputWithCLSToken` 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 ([CvtConfig](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtConfig)) et les entrées.

La méthode forward de [CvtModel](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtModel) 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)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **cls_token_value** (`torch.Tensor` de forme `(batch_size, 1, hidden_size)`) -- Jeton de classification à la sortie de la dernière couche du modèle.
- **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.

## CvtForImageClassification[[transformers.CvtForImageClassification]]

#### transformers.CvtForImageClassification[[transformers.CvtForImageClassification]]

```python
transformers.CvtForImageClassification(config: CvtConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L549)

**Paramètres :**

config ([CvtConfig](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Cvt Transformeur de modèle avec une tête de classification d'images au sommet (une couche linéaire au-dessus de l'état caché final du jeton [CLS]), par exemple pour ImageNet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.CvtForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L564)

**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 [ConvNextImageProcessor](/docs/transformers/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor) 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).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [ImageClassifierOutputWithNoAttention](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) 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 ([CvtConfig](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtConfig)) et les entrées.

La méthode forward de [CvtForImageClassification](/docs/transformers/main/fr/model_doc/cvt#transformers.CvtForImageClassification) 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, num_channels, height, width)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

Exemple :

```python
>>> from transformers import AutoImageProcessor, CvtForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")

>>> inputs = image_processor(image, return_tensors="pt")

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

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