# Pyramid Vision Transformer V2 (PVTv2)

## Tổng quan

Mô hình PVTv2 được đề xuất trong [PVT v2: Improved Baselines with Pyramid Vision Transformer](https://huggingface.co/papers/2106.13797) của Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo và Ling Shao. Là một biến thể cải tiến của PVT, nó từ bỏ các vector nhúng vị trí, thay vào đó dựa vào thông tin vị trí được mã hóa thông qua zero-padding và các vector nhúng patch chồng lấn. Việc không phụ thuộc vào vector nhúng vị trí giúp đơn giản hóa kiến trúc và cho phép chạy suy luận ở bất kỳ độ phân giải nào mà không cần nội suy chúng.

Cấu trúc encoder PVTv2 đã được triển khai thành công để đạt được điểm số tiên tiến nhất trong [Segformer](https://huggingface.co/papers/2105.15203) cho phân đoạn ngữ nghĩa, [GLPN](https://huggingface.co/papers/2201.07436) cho độ sâu đơn mục và [Panoptic Segformer](https://huggingface.co/papers/2109.03814) cho phân đoạn toàn cảnh.

PVTv2 thuộc về một họ các mô hình được gọi là [hierarchical transformers](https://natecibik.medium.com/the-rise-of-vision-transformers-f623c980419f) , trong đó các lớp transformer được điều chỉnh để tạo ra các bản đồ đặc trưng đa tỷ lệ. Khác với cấu trúc cột của Vision Transformer ([ViT](https://huggingface.co/papers/2010.11929)) vốn làm mất đi chi tiết tinh vi, các bản đồ đặc trưng đa tỷ lệ được biết đến là giúp bảo toàn chi tiết này và hỗ trợ hiệu suất trong các tác vụ dự đoán dày đặc. Trong trường hợp của PVTv2, điều này được thực hiện bằng cách tạo ra các token patch ảnh sử dụng tích chập 2D với các kernel chồng lấn ở mỗi lớp encoder.

Các đặc trưng đa tỷ lệ của transformer phân cấp cho phép chúng dễ dàng thay thế các mô hình backbone thị giác máy tính truyền thống như ResNet trong các kiến trúc lớn hơn. Cả Segformer và Panoptic Segformer đều cho thấy các cấu hình sử dụng PVTv2 làm backbone luôn vượt trội hơn so với các cấu hình sử dụng backbone ResNet có kích thước tương đương.

Một tính năng mạnh mẽ khác của PVTv2 là việc giảm độ phức tạp trong các lớp self-attention, được gọi là Spatial Reduction Attention (SRA), sử dụng các lớp 2D convolution để chiếu các hidden states xuống độ phân giải nhỏ hơn trước khi thực hiện attention với các query, cải thiện độ phức tạp $O(n^2)$ của self-attention thành $O(n^2/R)$, trong đó $R$ là tỷ lệ giảm không gian (`sr_ratio`, hay còn gọi là kích thước kernel và stride trong 2D convolution).

SRA được giới thiệu trong PVT và là phương pháp giảm độ phức tạp của attention mặc định được sử dụng trong PVTv2. Tuy nhiên, PVTv2 cũng giới thiệu tùy chọn sử dụng cơ chế self-attention với độ phức tạp tuyến tính liên quan đến kích thước ảnh, được họ gọi là "Linear SRA". Phương pháp này sử dụng average pooling để giảm các hidden states xuống một kích thước cố định, không phụ thuộc vào độ phân giải ban đầu của chúng (mặc dù điều này vốn dĩ gây mất mát nhiều hơn so với SRA thông thường). Tùy chọn này có thể được bật bằng cách đặt `linear_attention` thành `True` trong PVTv2Config.

### Tóm tắt từ bài báo

*Gần đây, Transformer đã đạt được những tiến bộ đáng khích lệ trong thị giác máy tính. Trong công trình này, chúng tôi đề xuất các baseline mới bằng cách cải tiến Pyramid Vision Transformer (PVT v1) gốc thông qua việc thêm ba thiết kế, bao gồm (1) lớp attention có độ phức tạp tuyến tính, (2) nhúng patch chồng lấn, và (3) mạng feed-forward dạng convolution. Với những thay đổi này, PVT v2 giảm độ phức tạp tính toán của PVT v1 xuống mức tuyến tính và đạt được những cải thiện đáng kể trên các tác vụ thị giác cơ bản như phân loại, phát hiện và phân đoạn. Đáng chú ý, PVT v2 được đề xuất đạt hiệu suất tương đương hoặc tốt hơn so với các công trình gần đây như Swin Transformer. Chúng tôi hy vọng công trình này sẽ thúc đẩy các nghiên cứu Transformer tiên tiến trong lĩnh vực thị giác máy tính. Mã nguồn có sẵn tại https://github.com/whai362/PVT.*

Mô hình này được đóng góp bởi [FoamoftheSea](https://huggingface.co/FoamoftheSea). Mã gốc có thể được tìm thấy [tại đây](https://github.com/whai362/PVT).

## Mẹo sử dụng

- [PVTv2](https://huggingface.co/papers/2106.13797) là một mô hình transformer phân cấp đã chứng minh hiệu suất mạnh mẽ trong phân loại ảnh và nhiều tác vụ khác, được sử dụng làm backbone cho phân đoạn ngữ nghĩa trong [Segformer](https://huggingface.co/papers/2105.15203), ước lượng độ sâu đơn mục trong [GLPN](https://huggingface.co/papers/2201.07436) và phân đoạn toàn cảnh trong [Panoptic Segformer](https://huggingface.co/papers/2109.03814), liên tục cho thấy hiệu suất cao hơn so với các cấu hình ResNet tương tự.
- Các transformer phân cấp như PVTv2 đạt hiệu quả dữ liệu và tham số vượt trội trên dữ liệu ảnh so với các kiến trúc transformer thuần túy bằng cách tích hợp các yếu tố thiết kế của mạng nơ-ron tích chập (CNN) vào bộ mã hóa của chúng. Điều này tạo ra một kiến trúc kết hợp ưu điểm của cả hai, đưa các thiên kiến cảm ứng hữu ích của CNN như tính tương đương dịch chuyển và tính cục bộ vào mạng, đồng thời vẫn tận dụng được các lợi ích về phản ứng động với dữ liệu và mô hình hóa quan hệ toàn cục do cơ chế tự chú ý của [transformers](https://huggingface.co/papers/1706.03762) mang lại.
- PVTv2 sử dụng nhúng patch chồng lấn để tạo ra các bản đồ đặc trưng đa tỷ lệ, sau đó được bổ sung thông tin vị trí bằng cách đệm không và tích chập theo chiều sâu.
- Để giảm độ phức tạp trong các lớp attention, PVTv2 thực hiện giảm không gian trên các trạng thái ẩn bằng cách sử dụng hoặc là tích chập 2D có bước nhảy (SRA) hoặc là pooling trung bình kích thước cố định (Linear SRA). Mặc dù bản chất có tính mất mát cao hơn, Linear SRA mang lại hiệu suất ấn tượng với độ phức tạp tuyến tính theo kích thước ảnh. Để sử dụng Linear SRA trong các lớp self-attention, hãy đặt `linear_attention=True` trong `PvtV2Config`.
- [PvtV2Model](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Model) là bộ mã hóa transformer phân cấp (thường được gọi là Mix Transformer hoặc MiT trong tài liệu). [PvtV2ForImageClassification](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) thêm một đầu phân loại đơn giản phía trên để thực hiện Phân loại ảnh. `PvtV2Backbone` có thể được sử dụng với hệ thống [AutoBackbone](/docs/transformers/main/vi/main_classes/backbones#transformers.AutoBackbone) trong các kiến trúc lớn hơn như Deformable DETR.
- Trọng số được huấn luyện trước trên ImageNet cho tất cả các kích thước mô hình có thể được tìm thấy trên [hub](https://huggingface.co/models?other=pvt_v2).

 Cách tốt nhất để bắt đầu với PVTv2 là tải checkpoint được huấn luyện trước với kích thước bạn chọn bằng cách sử dụng `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"]))
```

Để sử dụng PVTv2 làm backbone cho các kiến trúc phức tạp hơn như DeformableDETR, bạn có thể dùng AutoBackbone (mô hình này sẽ cần fine-tuning vì bạn đang thay thế backbone trong mô hình đã được huấn luyện trước và nó được khởi tạo với trọng số ngẫu nhiên):

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

Hiệu suất của [PVTv2](https://github.com/whai362/PVT/tree/v2) trên ImageNet-1K theo kích thước mô hình (B0-B5):

| Phương pháp           | Kích thước | Acc@1 | #Số tham số (triệu) |
|------------------|:----:|:-----:|:-----------:|
| 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)
```

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

**Tham số:**

image_size (`Union[int, list[int], tuple[int, int], dict]`, *tùy chọn*, mặc định là `224`) : Kích thước (độ phân giải) của mỗi hình ảnh.

num_channels (`int`, *tuỳ chọn*, mặc định là `3`) : Số lượng kênh đầu vào.

num_encoder_blocks (`[int]`, *tuỳ chọn*, mặc định là 4) : Số lượng khối encoder (tức là các giai đoạn trong encoder của Mix Transformer).

depths (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(2, 2, 2, 2)`) : Độ sâu của từng lớp trong Transformer.

sr_ratios (`list[int]`, *optional*, mặc định là `[8, 4, 2, 1]`) : Tỷ lệ giảm không gian trong mỗi khối encoder.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(32, 64, 160, 256)`) : Độ lớn chiều (hidden size) ở mỗi giai đoạn của mô hình.

patch_sizes (`list[int]`, *tuỳ chọn*, mặc định là `[7, 3, 3, 3]`) : Kích thước patch cho việc nhúng patch chồng lấn trước mỗi khối encoder.

strides (`list[int]`, *tuỳ chọn*, mặc định là `[4, 2, 2, 2]`) : Stride cho việc nhúng patch chồng lấn trước mỗi khối encoder.

num_attention_heads (`list[int]`, *tuỳ chọn*, mặc định là `[1, 2, 5, 8]`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong mỗi khối của bộ mã hóa Transformer.

mlp_ratios (`list[int]`, *tuỳ chọn*, mặc định là `[8, 8, 4, 4]`) : Tỷ lệ kích thước của lớp ẩn so với kích thước của lớp đầu vào của các Mix FFNs trong các khối encoder.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

hidden_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler.

attention_probs_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

drop_path_rate (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ drop path cho việc hợp nhất patch.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

qkv_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm bias vào queries, keys và values hay không.

linear_attention (`bool`, *tùy chọn*, mặc định là `False`) : Sử dụng độ phức tạp attention tuyến tính. Nếu đặt thành True, `sr_ratio` sẽ bị bỏ qua và average pooling được sử dụng để giảm chiều trong các lớp attention thay vì strided convolution.

Đây là lớp cấu hình để lưu trữ cấu hình của một PvtV2Model. Nó được sử dụng để khởi tạo một mô hình Pvt V2 theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [OpenGVLab/pvt_v2_b0](https://huggingface.co/OpenGVLab/pvt_v2_b0)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

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

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

**Tham số:**

config ([PvtV2Config](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Config)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Model transformer Pvt-v2 với đầu phân loại hình ảnh phía trên (một lớp tuyến tính phía trên trạng thái ẩn cuối cùng của token [CLS]) ví dụ cho ImageNet.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [PvtImageProcessor](/docs/transformers/main/vi/model_doc/pvt#transformers.PvtImageProcessor). Xem [PvtImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [PvtImageProcessor](/docs/transformers/main/vi/model_doc/pvt#transformers.PvtImageProcessor) để xử lý ảnh).

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** [ImageClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) hoặc `tuple(torch.Tensor)`

Một [ImageClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PvtV2Config](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Config)) và đầu vào.

Phương thức forward của [PvtV2ForImageClassification](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss phân loại (hoặc hồi quy nếu config.num_labels==1).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi giai đoạn) có hình dạng `(batch_size, sequence_length, hidden_size)`. Hidden-states (còn gọi là feature maps) của mô hình tại đầu ra của mỗi giai đoạn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, patch_size, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

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

**Tham số:**

config ([PvtV2Config](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Config)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Pvt V2 thuần túy, xuất ra các hidden-state thô mà không có bất kỳ head cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng [PvtImageProcessor](/docs/transformers/main/vi/model_doc/pvt#transformers.PvtImageProcessor). Xem [PvtImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [PvtImageProcessor](/docs/transformers/main/vi/model_doc/pvt#transformers.PvtImageProcessor) để xử lý ảnh).

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([PvtV2Config](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Config)) và đầu vào.

Phương thức forward của [PvtV2Model](/docs/transformers/main/vi/model_doc/pvt_v2#transformers.PvtV2Model) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.