# Pyramid Vision Transformer V2 (PVTv2)

## 概述

PVTv2 模型由 Wenhai Wang、Enze Xie、Xiang Li、Deng-Ping Fan、Kaitao Song、Ding Liang、Tong Lu、Ping Luo 和 Ling Shao 在 [PVT v2: Improved Baselines with Pyramid Vision Transformer](https://huggingface.co/papers/2106.13797) 中提出。作为 PVT 的改进变体，它摒弃了位置嵌入，转而依赖通过零填充和重叠块嵌入编码的位置信息。这种对位置嵌入的摒弃简化了架构，并使得无需进行插值即可在任意分辨率下运行推理。

PVTv2 编码器结构已成功部署，在语义分割的 [Segformer](https://huggingface.co/papers/2105.15203)、单目深度估计的 [GLPN](https://huggingface.co/papers/2201.07436) 以及全景分割的 [Panoptic Segformer](https://huggingface.co/papers/2109.03814) 中均取得了最先进的性能分数。

PVTv2 属于[分层 Transformer](https://natecibik.medium.com/the-rise-of-vision-transformers-f623c980419f)模型家族，该家族对 Transformer 层进行了调整，以生成多尺度特征图。与 Vision Transformer（[ViT](https://huggingface.co/papers/2010.11929)）的列式结构不同，后者会丢失细粒度细节，而多尺度特征图能够保留这些细节，并有助于提升密集预测任务的性能。在 PVTv2 中，这一目标是通过在每个编码器层中使用重叠核的 2D 卷积来生成图像块 token 实现的。

分层 Transformer 的多尺度特性使其能够轻松替换大型架构中传统的计算机视觉骨干模型，例如 ResNet。Segformer 和 Panoptic Segformer 均表明，使用 PVTv2 作为骨干网络的配置，其性能始终优于使用同等规模 ResNet 骨干网络的配置。

PVTv2 的另一项强大功能是自注意力层中的复杂度降低机制，称为空间缩减注意力（Spatial Reduction Attention，SRA）。它使用 2D 卷积层将隐藏状态投影到更小的分辨率，然后再用查询对其进行注意力计算，从而将自注意力的 $O(n^2)$ 复杂度提升至 $O(n^2/R)$，其中 $R$ 为空间缩减比率（`sr_ratio`，即 2D 卷积中的核大小和步长）。

SRA 在 PVT 中被引入，并且是 PVTv2 中默认使用的注意力复杂度降低方法。然而，PVTv2 还引入了使用与图像尺寸相关的线性复杂度自注意力机制的选项，他们将其称为“Linear SRA”。该方法使用平均池化将隐藏状态缩减为固定大小，该大小与其原始分辨率无关（尽管这本质上比常规 SRA 更具损失性）。通过在 PVTv2Config 中将 `linear_attention` 设置为 `True`，可以启用此选项。

### 论文的摘要

*Transformer 最近在计算机视觉领域取得了令人鼓舞的进展。在这项工作中，我们通过引入三种设计来改进原始的 Pyramid Vision Transformer (PVT v1)，从而提出了新的基线模型，这三种设计包括：(1) 线性复杂度注意力层，(2) 重叠的 patch 嵌入，以及 (3) 卷积前馈网络。通过这些修改，PVT v2 将 PVT v1 的计算复杂度降低至线性，并在分类、检测和分割等基础视觉任务上取得了显著的性能提升。值得注意的是，所提出的 PVT v2 取得了与 Swin Transformer 等近期工作相当或更优的性能。我们希望这项工作能够推动计算机视觉领域最先进的 Transformer 研究。代码可在 https://github.com/whai362/PVT 获取。*

该模型由 [FoamoftheSea](https://huggingface.co/FoamoftheSea) 贡献。原始代码可在[此处](https://github.com/whai362/PVT)找到。

## 使用技巧

- [PVTv2](https://huggingface.co/papers/2106.13797) 是一种分层 Transformer 模型，在图像分类及其他多项任务中均展现出卓越的性能。它被用作 [Segformer](https://huggingface.co/papers/2105.15203) 中语义分割、[GLPN](https://huggingface.co/papers/2201.07436) 中单目深度估计以及 [Panoptic Segformer](https://huggingface.co/papers/2109.03814) 中全景分割的骨干网络，其性能始终优于类似的 ResNet 配置。
- 像 PVTv2 这样的分层 Transformer 通过在编码器中融入卷积神经网络（CNN）的设计元素，在图像数据上实现了比纯 Transformer 架构更高的数据和参数效率。这种架构兼得两者之长：在保留 [transformers](https://huggingface.co/papers/1706.03762) 自注意力机制所带来的动态数据响应和全局关系建模优势的同时，将 CNN 的平移等变性和局部性等有用的归纳偏置注入网络。
- PVTv2 使用重叠的 patch 嵌入来创建多尺度特征图，并通过零填充和深度可分离卷积将位置信息注入其中。
- 为了降低注意力层的复杂度，PVTv2 使用步长 2D 卷积（SRA）或固定大小的平均池化（Linear SRA）对隐藏状态进行空间降采样。尽管 Linear SRA 本质上会丢失更多信息，但它能以与图像尺寸呈线性关系的复杂度提供出色的性能。要在自注意力层中使用 Linear SRA，请在 `PvtV2Config` 中设置 `linear_attention=True`。
- [PvtV2Model](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Model) 是分层 Transformer 编码器（在文献中也常被称为 Mix Transformer 或 MiT）。[PvtV2ForImageClassification](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) 在其上方添加了一个简单的分类器头，以执行图像分类任务。`PvtV2Backbone` 可以与 [AutoBackbone](/docs/transformers/v5.23.0/zh/main_classes/backbones#transformers.AutoBackbone) 系统配合使用，应用于 Deformable DETR 等更大的架构中。
- 所有模型尺寸的 ImageNet 预训练权重都可以在 [hub](https://huggingface.co/models?other=pvt_v2) 上找到。

 使用 `AutoModelForImageClassification` 加载您所需尺寸的预训练检查点，是开始使用 PVTv2 的最佳方式：

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

要将 PVTv2 用作 DeformableDETR 等更复杂架构的骨干网络，您可以使用 AutoBackbone（由于您正在替换预训练模型中的骨干网络，且其以随机权重初始化，因此该模型需要微调）：

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

[PVTv2](https://github.com/whai362/PVT/tree/v2) 在 ImageNet-1K 上按模型大小（B0-B5）的性能：

| 方法           | 大小 | Acc@1 | #参数（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)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/configuration_pvt_v2.py#L27)

**参数：**

image_size (`Union[int, list[int], tuple[int, int], dict]`，*可选*，默认为 `224`)：每张图片的尺寸（分辨率）。

num_channels (`int`，*可选*，默认为 `3`)：输入通道数。

num_encoder_blocks (`[int]`, *可选*, 默认为 4) : 编码器块的数量（即 Mix Transformer 编码器中的阶段数）。

depths (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(2, 2, 2, 2)`)：Transformer 中每一层的深度。

sr_ratios (`list[int]`，*可选*，默认为 `[8, 4, 2, 1]`)：每个编码器块中的空间缩减比例。

hidden_sizes (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(32, 64, 160, 256)`)：模型每个阶段的维度（隐藏层大小）。

patch_sizes (`list[int]`，*可选*，默认为 `[7, 3, 3, 3]`)：每个编码器块之前，用于重叠补丁嵌入的补丁大小。

strides (`list[int]`，*可选*，默认为 `[4, 2, 2, 2]`)：每个编码器块之前，用于重叠补丁嵌入的步长。

num_attention_heads (`list[int]`，*可选*，默认为 `[1, 2, 5, 8]`)：Transformer 编码器中每个块内每个注意力层的注意力头数量。

mlp_ratios (`list[int]`，*可选*，默认为 `[8, 8, 4, 4]`)：编码器块中 Mix FFNs 的隐藏层大小与输入层大小的比例。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

drop_path_rate (`Union[float, int]`，*可选*，默认为 `0.0`)：用于 patch 融合的 drop path 比率。

layer_norm_eps (`float`, *可选*, 默认为 `1e-06`) : 层归一化层使用的 epsilon。

qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。

linear_attention (`bool`，*可选*，默认为 `False`)：使用线性注意力复杂度。如果设置为 True，则忽略 `sr_ratio`，并在注意力层中使用平均池化而非步幅卷积进行降维。

这是用于存储 PvtV2Model 配置的类。它根据指定的参数实例化 Pvt V2 模型，并定义模型架构。使用默认值实例化配置将生成与 [OpenGVLab/pvt_v2_b0](https://huggingface.co/OpenGVLab/pvt_v2_b0) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

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

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L432)

**参数：**

config ([PvtV2Config](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Config))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Pvt-v2 模型，顶部带有图像分类头（在 [CLS] 标记的最终隐藏状态之上添加一个线性层），例如用于 ImageNet。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L447)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [PvtImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/pvt#transformers.PvtImageProcessor) 获取像素值。有关详细信息，请参阅 [PvtImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（`processor_class` 使用 [PvtImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/pvt#transformers.PvtImageProcessor) 处理图像）。

labels (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*) : 用于计算图像分类/回归损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。如果 `config.num_labels == 1`，则计算回归损失（均方损失）；如果 `config.num_labels > 1`，则计算分类损失（交叉熵）。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [ImageClassifierOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 或 `tuple(torch.Tensor)`

一个 [ImageClassifierOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PvtV2Config](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Config)）和输入。

[PvtV2ForImageClassification](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2ForImageClassification) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 分类损失（如果 config.num_labels==1，则为回归损失）。
- **logits**（形状为 `(batch_size, config.num_labels)` 的 `torch.Tensor`）-- 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个阶段输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每个阶段输出处的隐藏状态（也称为特征图）。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, patch_size, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

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

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L382)

**参数：**

config ([PvtV2Config](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Config))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

未附加任何特定头部的裸 Pvt V2 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pvt_v2/modeling_pvt_v2.py#L393)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [PvtImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/pvt#transformers.PvtImageProcessor) 获取像素值。有关详细信息，请参阅 [PvtImageProcessor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（`processor_class` 使用 [PvtImageProcessor](/docs/transformers/v5.23.0/zh/model_doc/pvt#transformers.PvtImageProcessor) 处理图像）。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [BaseModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PvtV2Config](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Config)）和输入。

[PvtV2Model](/docs/transformers/v5.23.0/zh/model_doc/pvt_v2#transformers.PvtV2Model) 的 forward 方法会重写 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

