# Pyramid Vision Transformer V2 (PVTv2)

## Ikhtisar

Model PVTv2 diusulkan dalam [PVT v2: Improved Baselines with Pyramid Vision Transformer](https://huggingface.co/papers/2106.13797) oleh Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, dan Ling Shao. Sebagai varian yang ditingkatkan dari PVT, model ini meninggalkan position embeddings dan mengandalkan informasi posisi yang dikodekan melalui zero-padding serta overlapping patch embeddings. Ketidaktergantungan pada position embeddings ini menyederhanakan arsitektur dan memungkinkan inferensi dijalankan pada resolusi apa pun tanpa perlu melakukan interpolasi.

Struktur encoder PVTv2 telah berhasil diimplementasikan untuk mencapai skor state-of-the-art pada [Segformer](https://huggingface.co/papers/2105.15203) untuk segmentasi semantik, [GLPN](https://huggingface.co/papers/2201.07436) untuk kedalaman monokular, dan [Panoptic Segformer](https://huggingface.co/papers/2109.03814) untuk segmentasi panoptik.

PVTv2 termasuk dalam keluarga model yang disebut [hierarchical transformers](https://natecibik.medium.com/the-rise-of-vision-transformers-f623c980419f) , yang melakukan adaptasi pada lapisan transformer untuk menghasilkan peta fitur multi-skala. Berbeda dengan struktur kolom Vision Transformer ([ViT](https://huggingface.co/papers/2010.11929)) yang kehilangan detail halus, peta fitur multi-skala dikenal mampu mempertahankan detail tersebut dan membantu kinerja pada tugas prediksi padat. Dalam kasus PVTv2, hal ini dicapai dengan menghasilkan token patch gambar menggunakan konvolusi 2D dengan kernel yang tumpang tindih di setiap lapisan encoder.

Fitur multi-skala dari transformer hierarkis memungkinkan model ini dengan mudah menggantikan model backbone computer vision tradisional yang umum digunakan, seperti ResNet, dalam arsitektur yang lebih besar. Baik Segformer maupun Panoptic Segformer menunjukkan bahwa konfigurasi yang menggunakan PVTv2 sebagai backbone secara konsisten melampaui kinerja konfigurasi dengan backbone ResNet yang berukuran serupa.

Fitur kuat lainnya dari PVTv2 adalah pengurangan kompleksitas pada lapisan self-attention yang disebut Spatial Reduction Attention (SRA), yang menggunakan lapisan konvolusi 2D untuk memproyeksikan hidden states ke resolusi yang lebih kecil sebelum diproses dengan queries, sehingga meningkatkan kompleksitas $O(n^2)$ dari self-attention menjadi $O(n^2/R)$, dengan $R$ sebagai rasio reduksi spasial (`sr_ratio`, yaitu ukuran kernel dan stride dalam konvolusi 2D).

SRA diperkenalkan dalam PVT, dan merupakan metode reduksi kompleksitas perhatian default yang digunakan dalam PVTv2. Namun, PVTv2 juga memperkenalkan opsi untuk menggunakan mekanisme self-attention dengan kompleksitas linear yang terkait dengan ukuran gambar, yang mereka sebut "Linear SRA". Metode ini menggunakan average pooling untuk mengurangi hidden states menjadi ukuran tetap yang tidak bergantung pada resolusi aslinya (meskipun ini secara inheren lebih lossy daripada SRA reguler). Opsi ini dapat diaktifkan dengan mengatur `linear_attention` menjadi `True` di PVTv2Config.

### Abstrak dari makalah

*Transformer baru-baru ini menunjukkan kemajuan yang menjanjikan dalam computer vision. Dalam karya ini, kami menyajikan baseline baru dengan meningkatkan Pyramid Vision Transformer (PVT v1) asli melalui penambahan tiga desain, yaitu (1) lapisan attention dengan kompleksitas linear, (2) patch embedding yang tumpang tindih, dan (3) jaringan feed-forward konvolusional. Dengan modifikasi ini, PVT v2 mengurangi kompleksitas komputasi PVT v1 menjadi linear dan mencapai peningkatan signifikan pada tugas-tugas vision fundamental seperti klasifikasi, deteksi, dan segmentasi. Secara khusus, PVT v2 yang diusulkan mencapai kinerja yang setara atau lebih baik dibandingkan karya-karya terbaru seperti Swin Transformer. Kami berharap karya ini akan memfasilitasi penelitian Transformer state-of-the-art dalam computer vision. Kode tersedia di https://github.com/whai362/PVT.*

Model ini disumbangkan oleh [FoamoftheSea](https://huggingface.co/FoamoftheSea). Kode aslinya dapat ditemukan [di sini](https://github.com/whai362/PVT).

## Tips penggunaan

- [PVTv2](https://huggingface.co/papers/2106.13797) adalah model transformer hierarkis yang telah menunjukkan kinerja yang kuat dalam klasifikasi citra dan berbagai tugas lainnya, digunakan sebagai backbone untuk segmentasi semantik di [Segformer](https://huggingface.co/papers/2105.15203), estimasi kedalaman monokular di [GLPN](https://huggingface.co/papers/2201.07436), dan segmentasi panoptik di [Panoptic Segformer](https://huggingface.co/papers/2109.03814), secara konsisten menunjukkan kinerja yang lebih tinggi dibandingkan konfigurasi ResNet yang serupa.
- Hierarchical transformers seperti PVTv2 mencapai efisiensi data dan parameter yang lebih unggul pada data gambar dibandingkan dengan arsitektur transformer murni, dengan mengintegrasikan elemen desain dari convolutional neural networks (CNN) ke dalam encoder mereka. Hal ini menciptakan arsitektur terbaik dari kedua dunia yang menyuntikkan bias induktif yang berguna dari CNN, seperti translation equivariance dan locality, ke dalam jaringan, sambil tetap menikmati manfaat dari respons data dinamis dan pemodelan hubungan global yang disediakan oleh mekanisme self-attention dari [transformers](https://huggingface.co/papers/1706.03762).
- PVTv2 menggunakan patch embeddings yang tumpang tindih untuk membuat peta fitur multi-skala, yang kemudian diberi informasi lokasi menggunakan zero-padding dan konvolusi depth-wise.
- Untuk mengurangi kompleksitas pada lapisan attention, PVTv2 melakukan reduksi spasial pada hidden states menggunakan strided 2D convolution (SRA) atau fixed-size average pooling (Linear SRA). Meskipun secara inheren lebih lossy, Linear SRA memberikan performa yang mengesankan dengan kompleksitas linear terhadap ukuran gambar. Untuk menggunakan Linear SRA pada lapisan self-attention, setel `linear_attention=True` di `PvtV2Config`.
- [PvtV2Model](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Model) adalah encoder transformer hierarkis (yang juga sering disebut sebagai Mix Transformer atau MiT dalam literatur). [PvtV2ForImageClassification](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) menambahkan kepala klasifikasi sederhana di atasnya untuk melakukan Image Classification. `PvtV2Backbone` dapat digunakan dengan sistem [AutoBackbone](/docs/transformers/main/id/main_classes/backbones#transformers.AutoBackbone) dalam arsitektur yang lebih besar seperti Deformable DETR.
- Bobot pretrained ImageNet untuk semua ukuran model dapat ditemukan di [hub](https://huggingface.co/models?other=pvt_v2).

 Cara terbaik untuk memulai dengan PVTv2 adalah dengan memuat checkpoint pretrained dengan ukuran yang Anda pilih menggunakan `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"]))
```

Untuk menggunakan PVTv2 sebagai backbone untuk arsitektur yang lebih kompleks seperti DeformableDETR, Anda dapat menggunakan AutoBackbone (model ini memerlukan fine-tuning karena Anda mengganti backbone pada model pretrained dan diinisialisasi dengan bobot acak):

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

Performa [PVTv2](https://github.com/whai362/PVT/tree/v2) pada ImageNet-1K berdasarkan ukuran model (B0-B5):

| Metode           | Ukuran | Acc@1 | #Parameter (Juta) |
|------------------|:----:|:-----:|:-----------:|
| 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)
```

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

**Parameter:**

image_size (`Union[int, list[int], tuple[int, int], dict]`, *opsional*, defaultnya `224`) : Ukuran (resolusi) dari setiap gambar.

num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input.

num_encoder_blocks (`[int]`, *opsional*, default 4) : Jumlah blok encoder (yaitu tahap dalam encoder Mix Transformer).

depths (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(2, 2, 2, 2)`) : Kedalaman setiap lapisan dalam Transformer.

sr_ratios (`list[int]`, *opsional*, default `[8, 4, 2, 1]`) : Rasio reduksi spasial di setiap blok encoder.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(32, 64, 160, 256)`) : Dimensi (ukuran tersembunyi) pada setiap tahap model.

patch_sizes (`list[int]`, *opsional*, defaultnya `[7, 3, 3, 3]`) : Ukuran patch untuk patch embedding yang tumpang tindih sebelum setiap blok encoder.

strides (`list[int]`, *opsional*, defaultnya `[4, 2, 2, 2]`) : Stride untuk patch embedding yang tumpang tindih sebelum setiap blok encoder.

num_attention_heads (`list[int]`, *opsional*, defaultnya `[1, 2, 5, 8]`) : Jumlah kepala perhatian untuk setiap lapisan perhatian di setiap blok dari encoder Transformer.

mlp_ratios (`list[int]`, *opsional*, defaultnya `[8, 8, 4, 4]`) : Rasio ukuran lapisan tersembunyi dibandingkan dengan ukuran lapisan input dari Mix FFNs dalam blok encoder.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

drop_path_rate (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Tingkat drop path untuk fusi patch.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

qkv_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan bias ke queries, keys, dan values.

linear_attention (`bool`, *opsional*, defaultnya `False`) : Gunakan kompleksitas atensi linear. Jika diatur ke True, `sr_ratio` diabaikan dan average pooling digunakan untuk reduksi dimensi di lapisan atensi alih-alih konvolusi strided.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi PvtV2Model. Kelas ini digunakan untuk membuat instans model Pvt V2 sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [OpenGVLab/pvt_v2_b0](https://huggingface.co/OpenGVLab/pvt_v2_b0)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

config ([PvtV2Config](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model transformer Pvt-v2 dengan kepala klasifikasi gambar di atasnya (lapisan linear di atas keadaan tersembunyi akhir dari token [CLS]) misalnya untuk ImageNet.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [PvtImageProcessor](/docs/transformers/main/id/model_doc/pvt#transformers.PvtImageProcessor). Lihat [PvtImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [PvtImageProcessor](/docs/transformers/main/id/model_doc/pvt#transformers.PvtImageProcessor) untuk memproses gambar).

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [ImageClassifierOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau `tuple(torch.Tensor)`

[ImageClassifierOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PvtV2Config](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Config)) dan input.

Metode forward dari [PvtV2ForImageClassification](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, patch_size, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

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

**Parameter:**

config ([PvtV2Config](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Pvt V2 polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [PvtImageProcessor](/docs/transformers/main/id/model_doc/pvt#transformers.PvtImageProcessor). Lihat [PvtImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [PvtImageProcessor](/docs/transformers/main/id/model_doc/pvt#transformers.PvtImageProcessor) untuk memproses gambar).

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PvtV2Config](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Config)) dan input.

Metode forward dari [PvtV2Model](/docs/transformers/main/id/model_doc/pvt_v2#transformers.PvtV2Model) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.