# Pyramid Vision Transformer V2 (PVTv2)

## Visão geral

O modelo PVTv2 foi proposto em [PVT v2: Improved Baselines with Pyramid Vision Transformer](https://huggingface.co/papers/2106.13797) 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](https://huggingface.co/papers/2105.15203) para segmentação semântica, no [GLPN](https://huggingface.co/papers/2201.07436) para profundidade monocular e no [Panoptic Segformer](https://huggingface.co/papers/2109.03814) para segmentação panótica.

O PVTv2 pertence a uma família de modelos chamados [transformers hierárquicos](https://natecibik.medium.com/the-rise-of-vision-transformers-f623c980419f), que realizam adaptações nas camadas de transformer para gerar mapas de recursos multiescala. Diferentemente da estrutura colunar do Vision Transformer ([ViT](https://huggingface.co/papers/2010.11929)), 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 atendê-los com as queries, melhorando a complexidade $O(n^2)$ da autoatenção para $O(n^2/R)$, com $R$ sendo a razão de redução espacial (`sr_ratio`, também conhecido 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 de atenção usado 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 ativada definindo `linear_attention` como `True` no PVTv2Config.

### Resumo do artigo

*Recentemente, o Transformer apresentou progressos promissores em visão computacional. Neste trabalho, apresentamos novas linhas de base ao melhorar o Pyramid Vision Transformer original (PVT v1) adicionando 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 ponta 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](https://huggingface.co/FoamoftheSea). O código original pode ser encontrado [aqui](https://github.com/whai362/PVT).

## Dicas de uso

- [PVTv2](https://huggingface.co/papers/2106.13797) é 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](https://huggingface.co/papers/2105.15203), estimativa de profundidade monocular em [GLPN](https://huggingface.co/papers/2201.07436) e segmentação panóptica em [Panoptic Segformer](https://huggingface.co/papers/2109.03814), 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](https://huggingface.co/papers/1706.03762).
- 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](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Model) é o codificador transformer hierárquico (que também é frequentemente chamado de Mix Transformer ou MiT na literatura). [PvtV2ForImageClassification](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) adiciona uma cabeça de classificador simples no topo para realizar Classificação de Imagens. `PvtV2Backbone` pode ser usado com o sistema [AutoBackbone](/docs/transformers/main/pt/main_classes/backbones#transformers.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](https://huggingface.co/models?other=pvt_v2).

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

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

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

Desempenho do [PVTv2](https://github.com/whai362/PVT/tree/v2) no ImageNet-1K por tamanho de modelo (B0-B5):

| Método           | Tamanho | Acc@1 | #Parâmetros (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)
```

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

**Parâmetros:**

image_size (`Union[int, list[int], tuple[int, int], dict]`, *opcional*, padrão `224`) : O tamanho (resolução) de cada imagem.

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

num_encoder_blocks (`[int]`, *opcional*, padrão 4) : O número de blocos do codificador (ou seja, os estágios no codificador do Mix Transformer).

depths (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(2, 2, 2, 2)`) : Profundidade de cada camada no Transformer.

sr_ratios (`list[int]`, *opcional*, padrão `[8, 4, 2, 1]`) : Razões de redução espacial em cada bloco do codificador.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(32, 64, 160, 256)`) : Dimensionalidade (tamanho oculto) em cada etapa do modelo.

patch_sizes (`list[int]`, *opcional*, padrão `[7, 3, 3, 3]`) : Tamanho do patch para a incorporação de patches sobrepostos antes de cada bloco do codificador.

strides (`list[int]`, *opcional*, padrão `[4, 2, 2, 2]`) : Stride para a incorporação de patches sobrepostos antes de cada bloco do codificador.

num_attention_heads (`list[int]`, *opcional*, padrão `[1, 2, 5, 8]`) : Número de cabeças de atenção para cada camada de atenção em cada bloco do codificador do Transformer.

mlp_ratios (`list[int]`, *opcional*, padrão `[8, 8, 4, 4]`) : Razão entre o tamanho da camada oculta e o tamanho da camada de entrada dos Mix FFNs nos blocos do codificador.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

linear_attention (`bool`, *opcional*, padrão `False`) : Usa complexidade de atenção linear. Se definido como True, `sr_ratio` é ignorado e o average pooling é usado para redução de dimensionalidade nas camadas de atenção, em vez de convolução com passo.

Esta é a classe de configuração para armazenar a configuração de um PvtV2Model. Ela é usada para instanciar um modelo Pvt V2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [OpenGVLab/pvt_v2_b0](https://huggingface.co/OpenGVLab/pvt_v2_b0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

config ([PvtV2Config](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo Pvt-v2 transformer com uma cabeça de classificação de imagem no topo (uma camada linear no topo do estado oculto final do token [CLS]), por exemplo, para ImageNet.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PvtImageProcessor](/docs/transformers/main/pt/model_doc/pvt#transformers.PvtImageProcessor). Veja [PvtImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [PvtImageProcessor](/docs/transformers/main/pt/model_doc/pvt#transformers.PvtImageProcessor) para processar imagens).

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [ImageClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) ou `tuple(torch.Tensor)`

Um [ImageClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([PvtV2Config](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Config)) e das entradas.

O método forward de [PvtV2ForImageClassification](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada estágio) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, patch_size, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

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

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

**Parâmetros:**

config ([PvtV2Config](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Pvt V2 puro, que produz estados ocultos brutos sem nenhum head específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PvtImageProcessor](/docs/transformers/main/pt/model_doc/pvt#transformers.PvtImageProcessor). Veja [PvtImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [PvtImageProcessor](/docs/transformers/main/pt/model_doc/pvt#transformers.PvtImageProcessor) para processar imagens).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([PvtV2Config](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Config)) e das entradas.

O método forward do [PvtV2Model](/docs/transformers/main/pt/model_doc/pvt_v2#transformers.PvtV2Model) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.