Este modelo foi publicado no HF papers em 2021-06-25 e contribuído para o Hugging Face Transformers em 2024-03-13.

Pyramid Vision Transformer V2 (PVTv2)

Visão geral

O modelo PVTv2 foi proposto em PVT v2: Improved Baselines with Pyramid Vision Transformer por Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo e Ling Shao. Como uma variante aprimorada do PVT, ele dispensa embeddings de posição, dependendo em vez disso de informações posicionais codificadas por meio de zero-padding e embeddings de patch sobrepostos. Essa ausência de dependência de embeddings de posição simplifica a arquitetura e permite executar inferência em qualquer resolução sem a necessidade de interpolá-los.

A estrutura do codificador PVTv2 foi implantada com sucesso para alcançar pontuações de estado da arte no Segformer para segmentação semântica, no GLPN para profundidade monocular e no Panoptic Segformer para segmentação panótica.

O PVTv2 pertence a uma família de modelos chamados transformers hierárquicos, que realizam adaptações nas camadas de transformer para gerar mapas de recursos multiescala. Diferentemente da estrutura colunar do Vision Transformer (ViT), que perde detalhes finos, os mapas de recursos multiescala são conhecidos por preservar esse detalhamento e contribuir para o desempenho em tarefas de predição densa. No caso do PVTv2, isso é alcançado gerando tokens de patches de imagem usando convolução 2D com kernels sobrepostos em cada camada do codificador.

Os recursos multiescala dos transformers hierárquicos permitem que eles sejam facilmente substituídos por modelos de backbone tradicionais de visão computacional, como o ResNet, em arquiteturas maiores. Tanto o Segformer quanto o Panoptic Segformer demonstraram que configurações que utilizam o PVTv2 como backbone superaram consistentemente aquelas com backbones ResNet de tamanho semelhante.

Outro recurso poderoso do PVTv2 é a redução de complexidade nas camadas de autoatenção, chamada Spatial Reduction Attention (SRA), que usa camadas de convolução 2D para projetar os estados ocultos para uma resolução menor antes de aplicá-los às queries, melhorando a $O(n^2)$ complexidade da autoatenção para $O(n^2/R)$, com $R$ sendo a razão de redução espacial (sr_ratio, também conhecida como tamanho do kernel e stride na convolução 2D).

O SRA foi introduzido no PVT e é o método padrão de redução da complexidade da atenção utilizado no PVTv2. No entanto, o PVTv2 também introduziu a opção de usar um mecanismo de autoatenção com complexidade linear relacionada ao tamanho da imagem, que eles chamaram de “Linear SRA”. Este método usa average pooling para reduzir os estados ocultos a um tamanho fixo que é invariante em relação à sua resolução original (embora isso seja inerentemente mais lossy do que o SRA regular). Essa opção pode ser habilitada definindo linear_attention como True no PVTv2Config.

Resumo do artigo

O Transformer tem apresentado recentemente progressos promissores em visão computacional. Neste trabalho, apresentamos novas linhas de base ao melhorar o Pyramid Vision Transformer original (PVT v1) com a adição de três designs, incluindo (1) camada de atenção de complexidade linear, (2) incorporação de patches sobrepostos e (3) rede feed-forward convolucional. Com essas modificações, o PVT v2 reduz a complexidade computacional do PVT v1 para linear e alcança melhorias significativas em tarefas fundamentais de visão, como classificação, detecção e segmentação. Notavelmente, o PVT v2 proposto alcança desempenho comparável ou superior ao de trabalhos recentes, como o Swin Transformer. Esperamos que este trabalho facilite pesquisas de estado da arte em Transformers para visão computacional. O código está disponível em https://github.com/whai362/PVT.

Este modelo foi contribuído por FoamoftheSea. O código original pode ser encontrado aqui.

Dicas de uso

• PVTv2 é um modelo transformer hierárquico que demonstrou desempenho poderoso em classificação de imagens e em diversas outras tarefas, sendo utilizado como backbone para segmentação semântica em Segformer, estimativa de profundidade monocular em GLPN e segmentação panóptica em Panoptic Segformer, apresentando consistentemente desempenho superior em comparação com configurações semelhantes de ResNet.

• Transformers hierárquicos, como o PVTv2, alcançam uma eficiência superior em dados e parâmetros em dados de imagem em comparação com arquiteturas puramente baseadas em transformers, ao incorporar elementos de design das redes neurais convolucionais (CNNs) em seus codificadores. Isso cria uma arquitetura que combina o melhor dos dois mundos, infundindo no network os vieses indutivos úteis das CNNs, como a equivariância de translação e a localidade, enquanto ainda aproveita os benefícios da resposta dinâmica aos dados e da modelagem de relações globais fornecidos pelo mecanismo de autoatenção dos transformers.

• O PVTv2 usa incorporações de patches sobrepostas para criar mapas de recursos multiescala, que são enriquecidos com informações de localização usando zero-padding e convoluções depth-wise.

• Para reduzir a complexidade nas camadas de atenção, o PVTv2 realiza uma redução espacial nos estados ocultos usando convolução 2D com passo (SRA) ou pooling de média de tamanho fixo (Linear SRA). Embora seja inerentemente mais lossy, o Linear SRA oferece um desempenho impressionante com complexidade linear em relação ao tamanho da imagem. Para usar o Linear SRA nas camadas de autoatenção, defina linear_attention=True no PvtV2Config.

• PvtV2Model é o codificador transformer hierárquico (que também é frequentemente chamado de Mix Transformer ou MiT na literatura). PvtV2ForImageClassification adiciona uma cabeça de classificador simples no topo para realizar Classificação de Imagens. PvtV2Backbone pode ser usado com o sistema AutoBackbone em arquiteturas maiores, como o Deformable DETR.

• Os pesos pré-treinados no ImageNet para todos os tamanhos de modelo podem ser encontrados no hub.

  A melhor maneira de começar com o PVTv2 é carregar o checkpoint pré-treinado com o tamanho de sua escolha usando 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"]))

Para usar o PVTv2 como backbone para arquiteturas mais complexas, como o DeformableDETR, você pode usar o AutoBackbone (esse modelo precisaria de fine-tuning, pois você está substituindo o backbone no modelo pré-treinado e ele é inicializado com pesos aleatórios):

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"]))

Desempenho do PVTv2 no ImageNet-1K por tamanho de modelo (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