Ce modèle a été publié dans HF papers le 2021-06-25 et ajouté à Hugging Face Transformers le 2024-03-13.

Pyramid Vision Transformer V2 (PVTv2)

Aperçu

Le modèle PVTv2 a été proposé dans PVT v2: Improved Baselines with Pyramid Vision Transformer 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 pour la segmentation sémantique, GLPN pour la profondeur monoculaire et Panoptic Segformer pour la segmentation panoptique.

PVTv2 appartient à une famille de modèles appelés transformers hiérarchiques, 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), 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 du PVTv2 est la réduction de la complexité des couches d'auto-attention, appelée Spatial Reduction Attention (SRA), qui 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, améliorant ainsi la $O(n^2)$ complexité de l'auto-attention à $O(n^2/R)$, avec $R$ étant le ratio de réduction spatiale (sr_ratio, aussi appelé taille du noyau et pas dans la convolution 2D).

SRA a été introduit dans PVT et est la méthode de réduction de la complexité de l’attention par défaut utilisée dans PVTv2. Cependant, PVTv2 a également introduit l’option d’utiliser un mécanisme d’auto-attention avec une complexité linéaire liée à la taille de l’image, qu’ils ont appelé « Linear SRA ». Cette méthode utilise le average pooling 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 montré des 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 à 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. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

• PVTv2 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, l’estimation de profondeur monoculaire dans GLPN et la segmentation panoptique dans Panoptic Segformer, 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.

• 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 est l’encodeur transformer hiérarchique (souvent appelé Mix Transformer ou MiT dans la littérature). 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 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.

  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 :

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 qu'elle est initialisée avec des poids aléatoires) :

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 : performances sur ImageNet-1K en fonction de la taille du modèle (B0-B5) :

PvtV2Config

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

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