# Pyramid Vision Transformer V2 (PVTv2)

## Aperçu

Le modèle PVTv2 a été proposé dans [PVT v2: Improved Baselines with Pyramid Vision Transformer](https://huggingface.co/papers/2106.13797) par Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo et Ling Shao. En tant que variante améliorée de PVT, il renonce aux embeddings de position, s'appuyant à la place sur des informations positionnelles encodées par zéro-padding et des embeddings de patch chevauchants. Cette absence de dépendance aux embeddings de position simplifie l'architecture et permet d'exécuter l'inférence à n'importe quelle résolution sans avoir besoin de les interpoler.

La structure de l’encodeur PVTv2 a été déployée avec succès pour atteindre des scores de pointe dans [Segformer](https://huggingface.co/papers/2105.15203) pour la segmentation sémantique, [GLPN](https://huggingface.co/papers/2201.07436) pour la profondeur monoculaire et [Panoptic Segformer](https://huggingface.co/papers/2109.03814) pour la segmentation panoptique.

PVTv2 appartient à une famille de modèles appelés [transformers hiérarchiques](https://natecibik.medium.com/the-rise-of-vision-transformers-f623c980419f), qui adaptent les couches de transformer afin de générer des cartes de caractéristiques multi-échelles. Contrairement à la structure en colonnes du Vision Transformer ([ViT](https://huggingface.co/papers/2010.11929)), qui perd les détails fins, les cartes de caractéristiques multi-échelles sont connues pour préserver ces détails et améliorer les performances sur les tâches de prédiction dense. Dans le cas de PVTv2, cela est réalisé en générant des jetons de patches d'image à l'aide de convolutions 2D avec des noyaux superposés dans chaque couche d'encodeur.

Les caractéristiques multi-échelle des transformeurs hiérarchiques permettent de les substituer facilement aux modèles de tronc d’architecture de vision par ordinateur traditionnels, tels que ResNet, au sein d’architectures plus larges. Segformer et Panoptic Segformer ont tous deux démontré que les configurations utilisant PVTv2 comme tronc d’architecture surpassent systématiquement celles employant des tronc d’architecture ResNet de taille comparable.

Une autre fonctionnalité puissante de PVTv2 est la réduction de la complexité des couches d'auto-attention, appelée Spatial Reduction Attention (SRA). Elle utilise des couches de convolution 2D pour projeter les états cachés vers une résolution plus petite avant de les traiter avec les requêtes, ce qui améliore la complexité $O(n^2)$ de l'auto-attention en $O(n^2/R)$, où $R$ est le ratio de réduction spatiale (`sr_ratio`, c'est-à-dire la taille du noyau et le pas dans la convolution 2D).

SRA a été introduit dans PVT et constitue la méthode de réduction de la complexité de l’attention par défaut utilisée dans PVTv2. Toutefois, PVTv2 a également introduit l’option d’utiliser un mécanisme d’auto-attention dont la complexité est linéaire par rapport à la taille de l’image, qu’ils ont appelé « Linear SRA ». Cette méthode utilise le pooling moyen pour réduire les états cachés à une taille fixe, invariante par rapport à leur résolution d’origine (bien que cela soit intrinsèquement plus destructeur que le SRA classique). Cette option peut être activée en définissant `linear_attention` sur `True` dans PVTv2Config.

### Résumé de l'article

*Le Transformer a récemment fait preuve de progrès encourageants en vision par ordinateur. Dans ce travail, nous présentons de nouvelles références de base en améliorant le Pyramid Vision Transformer (PVT v1) d’origine à l’aide de trois conceptions, à savoir (1) une couche d’attention de complexité linéaire, (2) un encodage de patches superposés et (3) un réseau feed-forward convolutif. Grâce à ces modifications, PVT v2 réduit la complexité computationnelle de PVT v1 à une complexité linéaire et obtient des améliorations significatives sur des tâches fondamentales de vision telles que la classification, la détection et la segmentation. Notamment, le PVT v2 proposé atteint des performances comparables ou supérieures à celles de travaux récents tels que Swin Transformer. Nous espérons que ce travail facilitera la recherche de pointe sur les Transformers en vision par ordinateur. Le code est disponible à l’adresse https://github.com/whai362/PVT.*

Ce modèle a été contribué par [FoamoftheSea](https://huggingface.co/FoamoftheSea). Le code d'origine peut être trouvé [ici](https://github.com/whai362/PVT).

## Conseils d'utilisation

- [PVTv2](https://huggingface.co/papers/2106.13797) est un modèle transformer hiérarchique qui a démontré des performances puissantes en classification d’images et dans de nombreuses autres tâches. Il est utilisé comme colonne vertébrale pour la segmentation sémantique dans [Segformer](https://huggingface.co/papers/2105.15203), l’estimation de profondeur monoculaire dans [GLPN](https://huggingface.co/papers/2201.07436) et la segmentation panoptique dans [Panoptic Segformer](https://huggingface.co/papers/2109.03814), affichant systématiquement de meilleures performances que des configurations ResNet similaires.
- Les transformers hiérarchiques comme PVTv2 offrent une meilleure efficacité en données et en paramètres sur les données d’images par rapport aux architectures de transformers pures, en intégrant des éléments de conception des réseaux de neurones convolutifs (CNN) dans leurs encodeurs. Cela crée une architecture qui combine le meilleur des deux mondes, en injectant dans le réseau les biais inductifs utiles des CNN, tels que l’équivariance à la translation et la localité, tout en conservant les avantages de la réponse dynamique aux données et de la modélisation des relations globales offerts par le mécanisme d’auto-attention des [transformers](https://huggingface.co/papers/1706.03762).
- PVTv2 utilise des embeddings de patches superposés pour créer des cartes de caractéristiques multi-échelles, qui sont enrichies d'informations de localisation à l'aide de zéro-padding et de convolutions en profondeur.
- Pour réduire la complexité des couches d'attention, PVTv2 effectue une réduction spatiale sur les états cachés en utilisant soit une convolution 2D à pas (SRA), soit un pooling moyen de taille fixe (Linear SRA). Bien qu'intrinsèquement plus destructeur, le Linear SRA offre des performances impressionnantes avec une complexité linéaire par rapport à la taille de l'image. Pour utiliser le Linear SRA dans les couches d'auto-attention, définissez `linear_attention=True` dans `PvtV2Config`.
- [PvtV2Model](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Model) est l’encodeur transformer hiérarchique (souvent appelé Mix Transformer ou MiT dans la littérature). [PvtV2ForImageClassification](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) ajoute une tête de classification simple au sommet pour effectuer la classification d’images. `PvtV2Backbone` peut être utilisé avec le système [AutoBackbone](/docs/transformers/v5.23.0/fr/main_classes/backbones#transformers.AutoBackbone) dans des architectures plus grandes comme Deformable DETR.
- Les poids pré-entraînés sur ImageNet pour toutes les tailles de modèle sont disponibles sur le [hub](https://huggingface.co/models?other=pvt_v2).

 La meilleure façon de commencer avec PVTv2 est de charger le point de contrôle préentraîné de la taille de votre choix à l’aide de `AutoModelForImageClassification` :

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

from transformers import AutoImageProcessor, AutoModelForImageClassification

model = AutoModelForImageClassification.from_pretrained("OpenGVLab/pvt_v2_b0", device_map="auto")
image_processor = AutoImageProcessor.from_pretrained("OpenGVLab/pvt_v2_b0")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
processed = image_processor(image)
outputs = model(torch.tensor(processed["pixel_values"]))
```

Pour utiliser PVTv2 comme colonne vertébrale pour des architectures plus complexes comme DeformableDETR, vous pouvez utiliser AutoBackbone (ce modèle nécessiterait un fine-tuning, car vous remplacez la colonne vertébrale du modèle pré-entraîné et il est initialisé avec des poids aléatoires) :

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

from transformers import AutoConfig, AutoImageProcessor, AutoModelForObjectDetection

model = AutoModelForObjectDetection.from_config(
    config=AutoConfig.from_pretrained(
        "SenseTime/deformable-detr",
        backbone_config=AutoConfig.from_pretrained("OpenGVLab/pvt_v2_b5"),
    ),
)

image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
processed = image_processor(image)
outputs = model(torch.tensor(processed["pixel_values"]))
```

[PVTv2](https://github.com/whai362/PVT/tree/v2) : performances sur ImageNet-1K en fonction de la taille du modèle (B0-B5) :

| Méthode           | Taille | Acc@1 | #Paramètres (M) |
|------------------|:----:|:-----:|:-----------:|
| PVT-V2-B0        |  224 |  70.5 |     3.7     |
| PVT-V2-B1        |  224 |  78.7 |     14.0    |
| PVT-V2-B2-Linear |  224 |  82.1 |     22.6    |
| PVT-V2-B2        |  224 |  82.0 |     25.4    |
| PVT-V2-B3        |  224 |  83.1 |     45.2    |
| PVT-V2-B4        |  224 |  83.6 |     62.6    |
| PVT-V2-B5        |  224 |  83.8 |     82.0    |

## PvtV2Config[[transformers.PvtV2Config]]

#### transformers.PvtV2Config[[transformers.PvtV2Config]]

```python
transformers.PvtV2Config(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] | dict = 224, num_channels: int = 3, num_encoder_blocks: int = 4, depths: list[int] | tuple[int, ...] = (2, 2, 2, 2), sr_ratios: list[int] | tuple[int, ...] = (8, 4, 2, 1), hidden_sizes: list[int] | tuple[int, ...] = (32, 64, 160, 256), patch_sizes: list[int] | tuple[int, ...] = (7, 3, 3, 3), strides: list[int] | tuple[int, ...] = (4, 2, 2, 2), num_attention_heads: list[int] | tuple[int, ...] = (1, 2, 5, 8), mlp_ratios: list[int] | tuple[int, ...] = (8, 8, 4, 4), hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, drop_path_rate: float | int = 0.0, layer_norm_eps: float = 1e-06, qkv_bias: bool = True, linear_attention: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/configuration_pvt_v2.py#L27)

**Paramètres :**

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

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

num_encoder_blocks (`[int]`, *facultatif*, valeur par défaut : 4) : Le nombre de blocs d'encodeur (c'est-à-dire les étapes de l'encodeur Mix Transformer).

depths (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(2, 2, 2, 2)`) : Profondeur de chaque couche du Transformer.

sr_ratios (`list[int]`, *facultatif*, par défaut `[8, 4, 2, 1]`) : Ratios de réduction spatiale dans chaque bloc d'encodeur.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(32, 64, 160, 256)`) : Dimensionnalité (taille cachée) à chaque étape du modèle.

patch_sizes (`list[int]`, *facultatif*, par défaut `[7, 3, 3, 3]`) : Taille des patches pour l'encodage de patches chevauchants avant chaque bloc d'encodeur.

strides (`list[int]`, *facultatif*, par défaut `[4, 2, 2, 2]`) : Pas pour l'intégration de tuiles chevauchantes avant chaque bloc d'encodeur.

num_attention_heads (`list[int]`, *facultatif*, valeur par défaut `[1, 2, 5, 8]`) : Nombre de têtes d'attention pour chaque couche d'attention de chaque bloc de l'encodeur Transformer.

mlp_ratios (`list[int]`, *facultatif*, par défaut `[8, 8, 4, 4]`) : Ratio de la taille de la couche cachée par rapport à la taille de la couche d'entrée des Mix FFNs dans les blocs encodeur.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : 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.

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

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.

linear_attention (`bool`, *facultatif*, valeur par défaut `False`) : Utiliser une complexité d'attention linéaire. Si défini sur True, `sr_ratio` est ignoré et un average pooling est utilisé pour la réduction de dimensionnalité dans les couches d'attention plutôt qu'une convolution à pas.

Ceci est la classe de configuration destinée à stocker la configuration d'un PvtV2Model. Elle est utilisée pour instancier un modèle Pvt V2 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 [OpenGVLab/pvt_v2_b0](https://huggingface.co/OpenGVLab/pvt_v2_b0)

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 PvtV2Model, PvtV2Config

>>> # Initializing a pvt_v2_b0 style configuration
>>> configuration = PvtV2Config()

>>> # Initializing a model from the OpenGVLab/pvt_v2_b0 style configuration
>>> model = PvtV2Model(configuration)

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

## PvtForImageClassification[[transformers.PvtV2ForImageClassification]]

#### transformers.PvtV2ForImageClassification[[transformers.PvtV2ForImageClassification]]

```python
transformers.PvtV2ForImageClassification(config: PvtV2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L432)

**Paramètres :**

config ([PvtV2Config](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Config)) : 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 Pvt-v2 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/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.PvtV2ForImageClassification.forward]]

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

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

**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 [PvtImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/pvt#transformers.PvtImageProcessor). Voir [PvtImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [PvtImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/pvt#transformers.PvtImageProcessor) 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_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

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/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**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 ([PvtV2Config](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Config)) et les entrées.

La méthode forward de [PvtV2ForImageClassification](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) 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.

Exemple :

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("OpenGVLab/pvt_v2_b0")
>>> model = PvtV2ForImageClassification.from_pretrained("OpenGVLab/pvt_v2_b0")

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

## PvtModel[[transformers.PvtV2Model]]

#### transformers.PvtV2Model[[transformers.PvtV2Model]]

```python
transformers.PvtV2Model(config: PvtV2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L382)

**Paramètres :**

config ([PvtV2Config](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Config)) : 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.

Le modèle Pvt V2 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.PvtV2Model.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L393)

**Paramètres :**

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

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

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/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 ([PvtV2Config](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Config)) et les entrées.

La méthode forward du modèle [PvtV2Model](/docs/transformers/v5.23.0/fr/model_doc/pvt_v2#transformers.PvtV2Model) 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.
- **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.

