Swin transformer详解

 

---

目录

摘要

一、介绍

二、原理

2.1 整体架构

2.1.1 Architecture 

2.1.2 Swin Transformer Block

2.2 基于移位窗口的自注意力

2.2.1 非重叠局部窗口中的自注意力

2.2.2 在连续块中的移位窗口划分      

2.2.3 便于移位配置的高效批计算

2.2.4 相对位置偏置

2.3 架构变体 

三、源码

3.1 Swin Transformer

3.2 Patch Embedding

3.3 Patch Merging

3.4 Window Partition

3.5 Window Reverse

3.6 MLP

3.7 Window Attention (W-MSA Module) ☆

3.8 Swin Transformer Block ☆

3.8.1 Shift Window Attention

3.8.2 Attention Mask

3.9 Basic Layer

---

• 论文：https://arxiv.org/pdf/2103.14030.pdf
• 代码：GitHub - microsoft/Swin-Transformer: This is an official implementation for "Swin Transformer: Hierarchical Vision Transformer using Shifted Windows".
• timm：https://hub.fastgit.org/rwightman/pytorch-image-models/blob/master/timm/models/swin_transformer.py

---

摘要

        本文介绍了一种称为 Swin Transformer 的新视觉 Transformer，它可以作为 CV 的通用主干。将 Transformer 从语言适应到视觉方面的挑战来自 两个域之间的差异，例如视觉实体的规模以及相比于文本单词的高分辨率图像像素的巨大差异。为解决这些差异，我们提出了一种 层次化 (hierarchical) Transformer，其表示是用 移位窗口 (Shifted Windows) 计算的。移位窗口方案通过 将自注意力计算限制在不重叠的局部窗口的同时，还允许跨窗口连接来提高效率。这种分层架构具有在各种尺度上建模的灵活性，并且 相对于图像大小具有线性计算复杂度。Swin Transformer 的这些特性使其与广泛的视觉任务兼容，包括图像分类（ImageNet-1K 的 87.3 top-1 Acc）和 密集预测任务，例如 目标检测（COCO test dev 的 58.7 box AP 和 51.1 mask AP）和语义分割（ADE20K val 的 53.5 mIoU）。它的性能在 COCO 上以 +2.7 box AP 和 +2.6 mask AP 以及在 ADE20K 上 +3.2 mIoU 的大幅度超越了 SOTA 技术，证明了基于 Transformer 的模型作为视觉主干的潜力。分层设计和移位窗口方法也证明了其对全 MLP 架构是有益的。

---

一、介绍

        CV 建模一直由 CNN 主导。从 AlexNet 和它在图像分类挑战上的革命性性能开始，CNN 架构已通过更大规模的、更广泛的连接和更复杂的卷积形式变得越来越强大。随着 CNNs 作为各种视觉任务的主干网络，这些架构的进步促进了性能的提升，并广泛地带动了整个领域的发展。另一方面，在 NLP 中，网络架构的发展已采取了一条不同的道路，即时至今日流行的架构是 Transformer。为序列建模和转换任务而设计的 Transformer，因其注意力机制对数据中的长程依赖性进行建模而闻名。它在语言领域的巨大成功使研究人员研究了它对计算机视觉的适应性，最近它在某些任务上展示了良好的结果，特别是图像分类和联合视觉-语言建模。本文试图扩大 Transformer 的适用性，使它可以作为 CV 的通用主干，正如其在 NLP 和 CNNs 在 CV 中一样。我们注意到将其在语言领域的高性能迁移到视觉领域的显著挑战，而这可用 两种模态之间的差异 来解释。

        其中一种差异涉及尺度 (scale)。与在语言 Transformer 中作为处理的基本元素的 word token 不同，视觉元素在尺度 (scale) 上可以存在很大差异，这是一个在目标检测等任务中受到关注的问题。在现有的基于 Transformer 的模型中，token 的尺度 (scale) 都是固定的，这是一种不适合这些视觉应用的性质。另一个差异是，图像中的像素分辨率比文本段落中的文字要高得多。存在许多视觉任务 ，如语义分割，需在像素级别上进行密集预测，这对于高分辨率图像上的 Transformer 而言是难以处理的，因为其 自注意力的计算复杂度是关于图像大小的二次方。

图 1

        为克服这些问题，Swin Transformer 构造了层次化特征图，且关于图像大小具有线性计算复杂度。如图 1 (a) 所示，Swin Transformer 通过 从小尺寸 patch (灰色轮廓) 开始，逐渐在更深的 Transformer 层中合并相邻 patch，从而构造出一个层次化表示 (hierarchical representation)。通过这些层次化特征图，Swin Transformer 模型可方便地利用先进技术进行密集预测，例如特征金字塔网络 (FPN) 或 U-Net。线性计算复杂度是通过在图像分区的非重叠窗口内，局部地计算自注意力来实现的 (红色轮廓) (而非在整张图像的所有 patch 上进行)。每个窗口中的 patch 数量是固定的，因此复杂度与图像大小成线性关系。这些优点使 Swin Transformer 适合作为各种视觉任务的通用主干，与之前基于 Transformer 的架构形成对比，后者产生单一分辨率的特征图并具有二次复杂度。

图 2

        Swin Transformer 的一个关键设计元素是它 在连续自注意力层之间的窗口分区的移位 (shift)，如图 2 所示。移位窗口桥接了前一层的窗口，提供二者之间的连接，显着增强建模能力 (见表 4)。这种策略对于现实世界的延迟也是有效的：一个局部窗口内的所有 query patch 共享相同的 key 集合，这有助于硬件中的内存访问。相比之下，早期的 基于滑动 (sliding) 窗口的自注意力方法 由于 不同 query 像素具有不同的 key 集合 而在通用硬件上受到低延迟的影响。我们的实验表明，所提出的移位窗口方法的延迟比滑动窗口方法低得多，而建模能力相似 (见表 5 / 6)。移位窗口方法也被证明对全 MLP 架构有益。 

        所提出的 Swin Transformer 在图像分类、目标检测和语义分割的识别任务上取得了强大的性能。它在三个任务上以相似的延迟显着优于 ViT / DeiT 和 ResNe(X)t 模型。 我们相信，跨 CV 和 NP 的统一架构可以使这两个领域受益，因为它将促进视觉和文本信号的联合建模，并且可以更深入地共享来自两个领域的建模知识。我们希望 Swin Transformer 在各种视觉问题上的强大表现能够在社区中更深入地推动这种信念，并鼓励视觉和语言信号的统一建模。

---

二、原理

2.1 整体架构

2.1.1 Architecture 

图 3

        图 3 展示了 Swin Transformer 架构概览 (tiny 版 SwinT)。它首先通过 Patch 拆分模块 (Patch Partition) (同 ViT) 将输入的 H×W×3𝐻×𝑊×3 的 RGB 图像拆分为非重叠等尺寸的 N×(P2×3)𝑁×(𝑃2×3) patch。每个 P2×3𝑃2×3 patch 都被视为一个 patch token，共拆分出 N𝑁 个 (即 Transformer 的有效输入序列长度)。

        更具体地，用 P2=4×4𝑃2=4×4 大小且通道数 C=3𝐶=3 的 patch，故各 patch 展平后的特征维度为 P×P×C=4×4×3=48𝑃×𝑃×𝐶=4×4×3=48，共有 N=H4×W4=HW16𝑁=𝐻4×𝑊4=𝐻𝑊16 个 patch tokens。换言之，每张 H×W×3𝐻×𝑊×3 的图片被处理为了 H4×W4𝐻4×𝑊4 个图片 patches，每个 patch 被展平为 4848 维的 token 向量 (类似 ViT 的 Flattened Patches)，整体上是一个展平 (flatten) 的 N×(P2×3)=(H4×W4)×48𝑁×(𝑃2×3)=(𝐻4×𝑊4)×48 维 2D2𝐷 patch 序列。

        线性嵌入层 (Linear Embedding) (即全连接层) 则将此时维度为 (H4×W4)×48(𝐻4×𝑊4)×48 的张量投影到任意维度 C𝐶，得到维度为 (H4×W4)×C(𝐻4×𝑊4)×𝐶 的 Linear Embedding。

        随后，这些 patch tokens (此时已为 Linear Embedding) 被馈入若干具有改进自注意力的 Swin Transformer blocks。首个 Swin Transformer block 保持输入输出 tokens 数恒为 H4×W4𝐻4×𝑊4 不变，且与 线性嵌入层 共同被指定为 Stage 1 (如图 3 的第一个虚线框所示)。

        为产生一个 层次化表示 (Hierarchical Representation)，随着网络的加深，tokens 数逐渐通过 Patch 合并层 (Patch Meraging) 被减少。首个 Patch 合并层拼接了每组 2×22×2 相邻 patch，则 patch token 数变为原来的 1414，即 H8×W8𝐻8×𝑊8，而 patch token 的维度则扩大 44 倍，即 4C4𝐶。然后，对 4C4𝐶 维的 patch 拼接特征使用了一个线性层，将输出维度降为 2C2𝐶。然后使用 Swin Transformer blocks 进行特征转换，其分辨率保持 H8×W8𝐻8×𝑊8不变。首个 Patch 合并层 和 该特征转换 Swin Transformer block 被指定为 Stage 2 (如图 3 的第二个虚线框所示)。重复 2 次与 Stage 2 相同过程，则分别指定为 Stage 3 和 Stage 4 (如图 3 的第三、四个虚线框所示)。输出分辨率 /  patch token 数 则分别为 H16×W16𝐻16×𝑊16 和 H32×W32𝐻32×𝑊32。每个 Stage 都会改变张量的维度，从而形成一种层次化的表征。由此，该架构可方便地替换现有的各种视觉任务的主干网络。

2.1.2 Swin Transformer Block

W-MSA: 规则窗口 MSA    -    SW-MSA: 移位窗口 MSA

        Swin Transformer 相比于 Transformer block (例如 ViT)，将 标准多头自注意力模块 (MSA) 替换为 基于移位窗口的多头自注意力模块 (W-MSA / SW-MSA) 且保持其他部分不变 (描述于 3.2 节)。如图 3(b) 或上图所示，一个 Swin Transformer block 由一个 基于移位窗口的 MSA 模块 构成，且后接一个夹有 GeLU 非线性在中间的 2 层 MLP。LayerNorm (LN) 层被应用于每个 MSA 模块和每个 MLP 前，且一个 残差连接 被应用于每个模块后。

---

2.2 基于移位窗口的自注意力

        标准的 Transformer 架构及其对图像分类的适应版本都执行 全局自注意力，其计算了每个 token 与其他所有 tokens 之间的关系 (Attention Map)。全局自注意力计算 具有 相对于 token 数的二次计算复杂度 O(N2D)𝑂(𝑁2𝐷) (N𝑁 为 token 数 / 序列长度，D𝐷 为 token 向量长度 / 嵌入维度)，使之不适用于许多需大量 tokens 的 密集预测 / 高分辨率图像表示 等 高计算量视觉问题。

         O(MSA) 或 O(MHA) 的计算：

         当 n>>d𝑛>>𝑑 时，O(MHA)=O(n2d)𝑂(𝑀𝐻𝐴)=𝑂(𝑛2𝑑)，或者说 O(MSA)=O(N2D)𝑂(𝑀𝑆𝐴)=𝑂(𝑁2𝐷)

2.2.1 非重叠局部窗口中的自注意力

        为高效建模，我们提出 在非重叠的局部窗口中计算自注意力，取代全局自注意力。以不重叠的方式均匀地划分图像得到各个窗口。已知 D = 2C，则设 每个非重叠局部窗口都包含 N = M × M 个 patch tokens，则 基于具有 N = h × w 个 patch tokens 的图像窗口的 MSA 模块 和 基于非重叠局部窗口的 W-MSA 模块 的计算复杂度分别是：

        其中，MSA 关于 patch token 数 h×wℎ×𝑤 具有 二次复杂度 (共 hwℎ𝑤 个 patch tokens，每个 patch token 在全局计算 hwℎ𝑤 次)。W-MSA 则当 M𝑀 固定时 (默认设为 77) 具有 线性复杂度  (共 hwℎ𝑤 个 patch tokens，每个 patch token 在各自的局部窗口内计算 M2𝑀2 次)。巨大的 h×wℎ×𝑤 对 全局自注意力 计算而言是难以承受的，而 基于窗口的自注意力 (W_MSA) 则具有良好的扩展性。

2.2.2 在连续块中的移位窗口划分      

        基于窗口的自注意力模块 (W-MSA) 虽将计算复杂度从二次降为线性，但跨窗口之间交流与联系的匮乏将限制其建模表征能力。为引入跨窗口的联系且同时保持非重叠窗口的计算效率，我们提出一个 移位窗口划分方法，该方法在连续 Swin Transformer blocks 中的两种划分/分区配置间交替。

图 2

        如图 2 所示，首个模块使用一个规则的窗口划分策略，从左上角像素开始，将 8×88×8 特征图均匀划分为 2×22×2 个大小为 4×44×4 的窗口 (此时局部窗口尺寸为 M=4𝑀=4，如红色框所示)。然后，下个模块采用自前一层移位的窗口配置，即令规则划分窗口向左上 循环移位 (⌊M2⌋⌊𝑀2⌋, ⌊M2⌋⌊𝑀2⌋) 个像素，如上图的红色框位置变化所示。

        通过采用移位窗口划分方法，如上图的 两个连续 Swin Transformer Blocks 的计算可表示为：

        其中， z^lz^𝑙 和 zlz𝑙 分别表示第 l𝑙 个 block 的 (S)W-MSA 模块输出特征 和 MLP 模块输出特征 (如图 3 (b) 所示)。

        移位窗口划分方法引入了先前层非重叠相邻窗口间的联系，且对图像分类、目标检测和语义分割很有效，如表 4 所示。

2.2.3 便于移位配置的高效批计算

         一个关于移位窗口划分的问题是，从 ⌈hM⌉×⌈wM⌉⌈ℎ𝑀⌉×⌈𝑤𝑀⌉ 到 (⌈hM⌉+1)×(⌈wM⌉+1)(⌈ℎ𝑀⌉+1)×(⌈𝑤𝑀⌉+1) 不但会产生更多窗口，而且有些窗口尺寸将小于 M×M𝑀×𝑀。一个朴素的解决方法是，将更小的窗口填充至 M×M𝑀×𝑀，且在计算注意力时屏蔽掉填充值。当规则划分的窗口数很少时，即 2×22×2，由该朴素方法所带来的计算量增长是相当可观的 (2×2→3×32×2→3×3 大 2.25 倍)。

        此处，我们提出了一种更有效的批计算方法，其 循环向左上方移位，如图 4 所示。在这种移位后，批窗口可由特征图中不相邻的子窗口组成，因此 使用屏蔽机制将自注意计算限制在每个子窗口内。通过循环移位，批处理窗口的数仍与规则分区的窗口数相同 (如规则划分时是 44 个窗口，向左上角循环移位后仍是 44 个窗口，如上图的 A，B，C，D 所示)。因此，该方法是高效的，其低延迟率如表 5 所示。

        经过了循环移位的方法，一个窗口可包含来自不同窗口的内容。因此，要采用 masked MSA 机制将自注意力计算限制在各子窗口内。最后通过逆循环移位方法将每个窗口的自注意力结果返回。例如，一个 99 窗口的图解如下所示：

        按子窗口划分即可得到 5 号子窗口的自注意力的结果，但直接计算会使得 5 号 / 6 号 / 4 号子窗口的自注意力计算混在一起，类似的混算还包括 5 号 / 8 号 / 2 号子窗口 和  9 号 / 7 号 / 3 号 / 1 号子窗口的纵向或横向等。所以需采用 masked MSA 机制：先正常计算自注意力，再进行 mask 操作将不需要的注意力图置 0，从而将自注意力计算限制在各子窗口内。

         例如， 6 号 / 4 号子窗口共由 4 个 patch 构成一个正方形区域，如下所示，故应计算出 4×4 注意力图。

        为避免各不同的子窗口注意力计算发生混叠，合适的注意力图应如下所示：

         从而，合适的 mask 应如下所示：

         再例如，9 号 / 7 号 / 3 号 / 1 号子窗口共由 4 个 patch 构成一个正方形区域，如下所示：

         同理，合适的 mask 应如下所示：

2.2.4 相对位置偏置

        在计算自注意力时，我们在计算相似度的过程中对每个 head 加入 相对位置偏置 B∈RM2×M2𝐵∈𝑅𝑀2×𝑀2，如下所示：

        其中，Q,K,V∈RM2,d𝑄,𝐾,𝑉∈𝑅𝑀2,𝑑 分别为 Query，Key 和 Value 矩阵，d𝑑 为 Query / Key 维度，M2𝑀2 为 (局部) 窗口内的 patches 数。因为沿各轴的相对位置均处于 [−M+1,M−1][−𝑀+1,𝑀−1] 范围内，我们参数化一个更小尺寸的偏置矩阵 B^∈R(2M−1)×(2M−1)𝐵^∈𝑅(2𝑀−1)×(2𝑀−1)，且 B𝐵 中的值均取自 B^𝐵^。

        如表 4 的实验表明，使用该 相对位置偏置 的效果显著优于 不使用位置偏置 或 使用绝对位置嵌入。进一步向输入添加绝对位置嵌入会略微降低性能，因此在我们的实现中没有采用。 

        此外，预训练中学习到的相对位置偏置 也可用于 通过双三次插值 初始化具有不同窗口大小的微调模型。

---

2.3 架构变体 

        我们构造的基础模型 Swin-B 具有类似于 ViT-B/DeiT-B 的模型大小和计算复杂度。我们也引入了 Swin-T，Swin-S 和 Swin-L，其模型大小和计算复杂度分别是 Swin-B 的 0.25×0.25×，0.5×0.5× 和 2×2×。注意到，Swin-T 和 Swin-S 的复杂度分别与 ResNet-50 (DeiT-S) 和 ResNet-101 相似。每种架构的窗口尺寸均默认设为 M=7𝑀=7。对于所有实验，每个 head 的 Query 维度 d=32𝑑=32，且每个 MLP 的扩展层为 α=4𝛼=4。每种架构的各 Stage 层数如下：

        其中，C𝐶 是 Stage 1 的隐藏层通道数。用于 ImageNet 图像分类的各模型变体的模型大小、理论计算复杂度 (FLOPs) 和 吞吐量 (throughput) 如表 1 所示。

表 1：ImageNet 图像分类性能对比

表 7：模型架构细节

---

三、源码

        Code：GitHub - microsoft/Swin-Transformer: This is an official implementation for "Swin Transformer: Hierarchical Vision Transformer using Shifted Windows".

3.1 Swin Transformer

        先入为主地展示 Swin Transformer 的整体架构。

1. class SwinTransformer(nn.Module):

2. r""" Swin Transformer

3. A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -

4. https://arxiv.org/pdf/2103.14030

5. Args:

6. img_size (int | tuple(int)): Input image size. Default 224

7. patch_size (int | tuple(int)): Patch size. Default: 4

8. in_chans (int): Number of input image channels. Default: 3

9. num_classes (int): Number of classes for classification head. Default: 1000

10. embed_dim (int): Patch embedding dimension. Default: 96

11. depths (tuple(int)): Depth of each Swin Transformer layer.

12. num_heads (tuple(int)): Number of attention heads in different layers.

13. window_size (int): Window size. Default: 7

14. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4

15. qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True

16. qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None

17. drop_rate (float): Dropout rate. Default: 0

18. attn_drop_rate (float): Attention dropout rate. Default: 0

19. drop_path_rate (float): Stochastic depth rate. Default: 0.1

20. norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.

21. ape (bool): If True, add absolute position embedding to the patch embedding. Default: False

22. patch_norm (bool): If True, add normalization after patch embedding. Default: True

23. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False

24. """

26. def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,

27. embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],

28. window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,

29. drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,

30. norm_layer=nn.LayerNorm, ape=False, patch_norm=True,

31. use_checkpoint=False, **kwargs):

32. super().__init__()

34. self.num_classes = num_classes

35. self.num_layers = len(depths)

36. self.embed_dim = embed_dim

37. self.ape = ape

38. self.patch_norm = patch_norm

39. self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))

40. self.mlp_ratio = mlp_ratio

42. # split image into non-overlapping patches

43. self.patch_embed = PatchEmbed(

44. img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,

45. norm_layer=norm_layer if self.patch_norm else None)

46. num_patches = self.patch_embed.num_patches

47. patches_resolution = self.patch_embed.patches_resolution

48. self.patches_resolution = patches_resolution

50. # absolute position embedding

51. if self.ape:

52. self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))

53. trunc_normal_(self.absolute_pos_embed, std=.02)

55. self.pos_drop = nn.Dropout(p=drop_rate)

57. # stochastic depth

58. dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule

60. # build layers

61. self.layers = nn.ModuleList()

62. for i_layer in range(self.num_layers):

63. layer = BasicLayer(dim=int(embed_dim * 2 ** i_layer),

64. input_resolution=(patches_resolution[0] // (2 ** i_layer),

65. patches_resolution[1] // (2 ** i_layer)),

66. depth=depths[i_layer],

67. num_heads=num_heads[i_layer],

68. window_size=window_size,

69. mlp_ratio=self.mlp_ratio,

70. qkv_bias=qkv_bias, qk_scale=qk_scale,

71. drop=drop_rate, attn_drop=attn_drop_rate,

72. drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],

73. norm_layer=norm_layer,

74. downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,

75. use_checkpoint=use_checkpoint)

76. self.layers.append(layer)

78. self.norm = norm_layer(self.num_features)

79. self.avgpool = nn.AdaptiveAvgPool1d(1)

80. self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()

82. self.apply(self._init_weights)

84. def _init_weights(self, m):

85. if isinstance(m, nn.Linear):

86. trunc_normal_(m.weight, std=.02)

87. if isinstance(m, nn.Linear) and m.bias is not None:

88. nn.init.constant_(m.bias, 0)

89. elif isinstance(m, nn.LayerNorm):

90. nn.init.constant_(m.bias, 0)

91. nn.init.constant_(m.weight, 1.0)

93. @torch.jit.ignore

94. def no_weight_decay(self):

95. return {'absolute_pos_embed'}

97. @torch.jit.ignore

98. def no_weight_decay_keywords(self):

99. return {'relative_position_bias_table'}

101. def forward_features(self, x):

102. x = self.patch_embed(x)

103. if self.ape:

104. x = x + self.absolute_pos_embed

105. x = self.pos_drop(x)

107. for layer in self.layers:

108. x = layer(x)

110. x = self.norm(x) # B L C

111. x = self.avgpool(x.transpose(1, 2)) # B C 1

112. x = torch.flatten(x, 1)

113. return x

115. def forward(self, x):

116. x = self.forward_features(x)

117. x = self.head(x)

118. return x

120. def flops(self):

121. flops = 0

122. flops += self.patch_embed.flops()

123. for i, layer in enumerate(self.layers):

124. flops += layer.flops()

125. flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)

126. flops += self.num_features * self.num_classes

127. return flops

---

3.2 Patch Embedding

        将图片输入 Swin Transformer Block 前，需将图片划分成若干 patch tokens 并投影为嵌入向量。更具体地，将输入原始图片划分成一个个 patch_size * patch_size 大小的 patch token，然后投影嵌入。可通过将 2D 卷积层的 stride 和 kernel_size 的大小设为 patch_size，并将输出通道数设为 embed_dim 来实现投影嵌入。最后，展平并置换维度。

1. class PatchEmbed(nn.Module):

2. r""" Image to Patch Embedding

3. Args:

4. img_size (int): Image size. Default: 224.

5. patch_size (int): Patch token size. Default: 4.

6. in_chans (int): Number of input image channels. Default: 3.

7. embed_dim (int): Number of linear projection output channels. Default: 96.

8. norm_layer (nn.Module, optional): Normalization layer. Default: None

9. """

11. def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):

12. super().__init__()

13. img_size = to_2tuple(img_size)

14. patch_size = to_2tuple(patch_size)

15. patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]

16. self.img_size = img_size

17. self.patch_size = patch_size

18. self.patches_resolution = patches_resolution

19. self.num_patches = patches_resolution[0] * patches_resolution[1]

21. self.in_chans = in_chans

22. self.embed_dim = embed_dim

24. self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) # 输入嵌入投影

25. if norm_layer is not None:

26. self.norm = norm_layer(embed_dim)

27. else:

28. self.norm = None

30. def forward(self, x):

31. '''

32. # 以默认参数为例 # 输入 (B, C, H, W) = (B, 3, 224, 224)

33. x = self.proj(x) # 输出 (B, 96, 224/4, 224/4) = (B, 96, 56, 56)

34. x = torch.flatten(x, 2) # H W 维展平, 输出 (B, 96, 56*56)

35. x = torch.transpose(x, 1, 2) # C 维放最后, 输出 (B, 56*56, 96)

36. '''

37. B, C, H, W = x.shape

38. # FIXME look at relaxing size constraints

39. assert H == self.img_size[0] and W == self.img_size[1], \

40. f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."

41. x = self.proj(x).flatten(2).transpose(1, 2) # shape = (B, P_h*P_w, C)

42. if self.norm is not None:

43. x = self.norm(x)

44. return x

46. def flops(self):

47. Ho, Wo = self.patches_resolution

48. flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])

49. if self.norm is not None:

50. flops += Ho * Wo * self.embed_dim

51. return flops

---

3.3 Patch Merging

        在每个 Stage 前下采样缩小分辨率并减半通道数，从而形成层次化设计并降低运算量 (类似 Pixel Shuffle)。示意图及实现：

1. class PatchMerging(nn.Module):

2. r""" Patch Merging Layer.

3. Args:

4. input_resolution (tuple[int]): Resolution of input feature.

5. dim (int): Number of input channels.

6. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm

7. """

9. def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):

10. super().__init__()

11. self.input_resolution = input_resolution

12. self.dim = dim

13. self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)

14. self.norm = norm_layer(4 * dim)

16. def forward(self, x):

17. """

18. x: B, H*W, C

19. """

20. H, W = self.input_resolution

21. B, L, C = x.shape

22. assert L == H * W, "input feature has wrong size"

23. assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."

25. # reshape

26. x = x.view(B, H, W, C)

28. # 在行、列方向以 stride = 2 等间隔抽样, 实现分辨率 1/2 下采样

29. x0 = x[:, 0::2, 0::2, :] # shape = (B, H/2, W/2, C)

30. x1 = x[:, 1::2, 0::2, :] # shape = (B, H/2, W/2, C)

31. x2 = x[:, 0::2, 1::2, :] # shape = (B, H/2, W/2, C)

32. x3 = x[:, 1::2, 1::2, :] # shape = (B, H/2, W/2, C)

34. # 拼接 使通道数加倍

35. x = torch.cat([x0, x1, x2, x3], -1) # shape = (B, H/2, W/2, 4*C)

36. x = x.view(B, -1, 4 * C) # shape = (B, H*W/4, 4*C)

38. # FC 使通道数减半

39. x = self.norm(x)

40. x = self.reduction(x) # shape = (B, H*W/4, 2*C)

42. return x

44. def extra_repr(self) -> str:

45. return f"input_resolution={self.input_resolution}, dim={self.dim}"

47. def flops(self):

48. H, W = self.input_resolution

49. flops = H * W * self.dim

50. flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim

51. return flops

---

3.4 Window Partition

        将 shape = (B,H,W,C)(𝐵,𝐻,𝑊,𝐶) 的输入张量 reshape 为 shape = (B×HM×WM,M,M,C)(𝐵×𝐻𝑀×𝑊𝑀,𝑀,𝑀,𝐶) 的窗口张量。其中 M𝑀 即为窗口大小。由此，得到 N=B×HM×WM𝑁=𝐵×𝐻𝑀×𝑊𝑀 个 shape = (M,M,C)(𝑀,𝑀,𝐶) 的窗口。该函数将用于 Window Attention。

1. def window_partition(x, window_size):

2. """

3. Args:

4. x: (B, H, W, C)

5. window_size (int): window size

7. Returns:

8. windows: (num_windows*B, window_size, window_size, C)

9. """

11. B, H, W, C = x.shape

12. x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)

13. windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)

14. return windows

---

3.5 Window Reverse

        即窗口划分的逆过程，将 shape = (B×HM×WM,M,M,C)(𝐵×𝐻𝑀×𝑊𝑀,𝑀,𝑀,𝐶) 的窗口张量 reshape 回 shape = (B,H,W,C)(𝐵,𝐻,𝑊,𝐶) 的张量。该函数将用于 Window Attention。

1. def window_reverse(windows, window_size, H, W):

2. """

3. Args:

4. windows: (num_windows*B, window_size, window_size, C)

5. window_size (int): Window size

6. H (int): Height of image

7. W (int): Width of image

9. Returns:

10. x: (B, H, W, C)

11. """

13. B = int(windows.shape[0] / (H * W / window_size / window_size))

14. x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)

15. x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)

16. return x

---

3.6 MLP

        使用 GELU 激活函数 + Dropout 的两层 FCs。

1. class Mlp(nn.Module):

2. def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):

3. super().__init__()

4. out_features = out_features or in_features

5. hidden_features = hidden_features or in_features

6. self.fc1 = nn.Linear(in_features, hidden_features)

7. self.act = act_layer()

8. self.fc2 = nn.Linear(hidden_features, out_features)

9. self.drop = nn.Dropout(drop)

11. def forward(self, x):

12. x = self.fc1(x)

13. x = self.act(x)

14. x = self.drop(x)

15. x = self.fc2(x)

16. x = self.drop(x)

17. return x

---

3.7 Window Attention (W-MSA Module) ☆

        一方面，在局部窗口 而非全局图像内 计算自注意力 可将计算复杂度由二次降为线性。

        另一方面，在计算原 Attention 的 Query 和 Key 时，加入 相对位置编码 B𝐵 可改善性能。

        更具体地，首先由 Query 和 Key 相乘得到 Attention Map，shape = (numWindows*B, num_heads, window_size*window_size, window_size*window_size)。对于 Attention Map，以不同像素点作为原点，则各像素点位置/坐标随之不同。

        由于 每个非重叠局部窗口都包含 N = M × M 个 patch tokens，以 window_size = M = 2 为例，分别以 左上角像素点 和 右上角像素点 为原点的相对位置编码如下所示 (坐标系轴向同矩阵坐标)：

         其次，使用 torch.arange 生成等距的行方向和列方向索引，再用 torch.meshgrid 生成网格坐标索引。

        仍以 window_size = M = 2 为例，生成网格 grid 坐标：

1. coords_h = torch.arange(self.window_size[0])

2. coords_w = torch.arange(self.window_size[1])

3. coords = torch.meshgrid([coords_h, coords_w]) # -> 2*(wh, ww)

4. """

5. (tensor([[0, 0],

6. [1, 1]]),

7. tensor([[0, 1],

8. [0, 1]]))

9. """

         堆叠并展开为 2D 向量：

1. coords = torch.stack(coords) # 2, Wh, Ww

2. coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww

3. """

4. tensor([[0, 0, 1, 1],

5. [0, 1, 0, 1]])

6. """

         分别在第 1 和 2 维处插入新维度，并利用广播机制做减法，得到 shape = (2, wh*ww, wh*ww) 的张量：

1. relative_coords_first = coords_flatten[:, :, None] # 2, wh*ww, 1

2. relative_coords_second = coords_flatten[:, None, :] # 2, 1, wh*ww

3. relative_coords = relative_coords_first - relative_coords_second # 2, wh*ww, wh*ww

        由于相减得到的索引是从负数开始的，故加上偏移量使之从 0 开始：

1. relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2

2. relative_coords[:, :, 0] += self.window_size[0] - 1

3. relative_coords[:, :, 1] += self.window_size[1] - 1

        接着，需要将其展开成 1D 偏移量。

        对于诸如第 0 行上 (1, 2) 和 (2, 1) 这两个不同的坐标 (x, y)，通过将 (x, y) 坐标求和得到 1D 偏移量 x+y 时，二者所表示的 相对于原点的偏移量却是相等的 (1+2 = 2+1 = 3)：

可见第 0 行的原始偏移量 x+y 分别为 2、3、3、4，不同的位置却具有相同的偏移量，降低了相对区分度/差异度

         为避免这种 偏移量相等 的错误对应情况，还需对坐标 (准确地说是 x 坐标) 进行 乘法变换 (offset multiply)，以提高区分度：

relative_coords[:, :, 0] *= (2 * self.window_size[1] - 1)  # 每个 x 坐标乘 (2 * 2 - 1) = 3

对 x 坐标实施乘法变换得到 (x', y)，再重新计算得到具有差异度的各坐标位置的偏移量 x'+y

         接着在最后一维上求和 x+y，展开成一个 1D 坐标 (相对位置索引)，并注册为一个不参与网络学习的变量 relative_position_index，其作用是 根据最终的相对位置索引 找到对应的可学习的相对位置编码：

1. relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww

2. self.register_buffer("relative_position_index", relative_position_index)

         完整代码如下所示：

1. class WindowAttention(nn.Module):

2. r""" Window based multi-head self attention (W-MSA) module with relative position bias.

3. It supports both of shifted and non-shifted window.

5. Args:

6. dim (int): Number of input channels.

7. window_size (tuple[int]): The height and width of the window.

8. num_heads (int): Number of attention heads.

9. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True

10. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set

11. attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0

12. proj_drop (float, optional): Dropout ratio of output. Default: 0.0

13. """

15. def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):

16. super().__init__()

18. self.dim = dim

19. self.window_size = window_size # Wh, Ww

20. self.num_heads = num_heads

21. head_dim = dim // num_heads

22. self.scale = qk_scale or head_dim ** -0.5

24. # define a parameter table of relative position bias

25. self.relative_position_bias_table = nn.Parameter(

26. torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2*Wh-1 * 2*Ww-1, nH

28. # get pair-wise relative position index for each token inside the window

29. coords_h = torch.arange(self.window_size[0]) # 局部窗口高度方向坐标

30. coords_w = torch.arange(self.window_size[1]) # 局部窗口宽度方向坐标

31. # 局部窗口坐标网格

32. coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww

33. coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww

34. # 相对位置

35. relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww

36. relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2

37. relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0

38. relative_coords[:, :, 1] += self.window_size[1] - 1

39. relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1

40. relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww

41. self.register_buffer("relative_position_index", relative_position_index)

43. self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)

44. self.attn_drop = nn.Dropout(attn_drop)

45. self.proj = nn.Linear(dim, dim)

46. self.proj_drop = nn.Dropout(proj_drop)

48. trunc_normal_(self.relative_position_bias_table, std=.02)

49. self.softmax = nn.Softmax(dim=-1)

51. def forward(self, x, mask=None):

52. """

53. Args:

54. x: input features with shape of (num_windows*B, N, C)

55. mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None

56. """

58. B_, N, C = x.shape

59. qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)

60. # Query, Key, Value

61. q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)

62. # Query 放缩

63. q = q * self.scale

64. # Query * Key

65. attn = (q @ k.transpose(-2, -1)) # @ 表示矩阵-向量乘法

67. # 相对位置偏置 B

68. relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(

69. self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH

70. relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww

72. # Attention Map = Softmax(Q * K / √d + B)

73. attn = attn + relative_position_bias.unsqueeze(0)

74. # 局部窗口 attention map mask + Softmax

75. if mask is not None:

76. nW = mask.shape[0]

77. attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)

78. attn = attn.view(-1, self.num_heads, N, N)

79. attn = self.softmax(attn) # 最终的 Attention Map

80. else:

81. attn = self.softmax(attn) # 最终的 Attention Map

83. attn = self.attn_drop(attn)

84. # Attention Map * V

85. x = (attn @ v).transpose(1, 2).reshape(B_, N, C) # @ 表示矩阵-向量乘法

87. # 线性投影 FC

88. x = self.proj(x)

89. x = self.proj_drop(x)

91. return x

93. def extra_repr(self) -> str:

94. ### 用于输出 print 结果

95. return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'

97. def flops(self, N):

98. ### calculate flops for 1 window with token length of N

99. flops = 0

100. # qkv = self.qkv(x)

101. flops += N * self.dim * 3 * self.dim

102. # attn = (q @ k.transpose(-2, -1))

103. flops += self.num_heads * N * (self.dim // self.num_heads) * N

104. # x = (attn @ v)

105. flops += self.num_heads * N * N * (self.dim // self.num_heads)

106. # x = self.proj(x)

107. flops += N * self.dim * self.dim

108. return flops

        一个不错的整体流程示意图：

相对位置编码矩阵：每一列 代表 每一个坐标在所有坐标 “眼中” 的相对位置

        主要 shape 变化注释:

1. class WindowAttention(nn.Module):

2. r""" Window based multi-head self attention (W-MSA) module with relative position bias.

3. It supports both of shifted and non-shifted window.

5. Args:

6. dim (int): Number of input channels.

7. window_size (tuple[int]): The height and width of the window.

8. num_heads (int): Number of attention heads.

9. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True

10. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set

11. attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0

12. proj_drop (float, optional): Dropout ratio of output. Default: 0.0

13. """

15. def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):

17. super().__init__()

18. self.dim = dim

19. self.window_size = window_size # 通常默认 wh = ww = w = 4

20. self.num_heads = num_heads # MHA 的头数

21. head_dim = dim // num_heads # dim 平均分给每个 head

22. self.scale = qk_scale or head_dim ** -0.5 # MHA 内的 scale 分母: 自定义的 qk_scale 或 根号 d

24. # define a parameter table of relative position bias

25. self.relative_position_bias_table = nn.Parameter(

26. torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # (2*wh-1 * 2*ww-1, num_heads)

28. # get pair-wise relative position index for each token inside the window

29. coords_h = torch.arange(self.window_size[0]) # wh

30. coords_w = torch.arange(self.window_size[1]) # ww

31. coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # (2, wh, ww)

32. coords_flatten = torch.flatten(coords, 1) # (2, wh*ww)

33. relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # (2, wh*ww, wh*ww)

34. relative_coords = relative_coords.permute(1, 2, 0).contiguous() # (wh*ww, wh*ww, 2)

35. relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0

36. relative_coords[:, :, 1] += self.window_size[1] - 1

37. relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1

38. relative_position_index = relative_coords.sum(-1) # (wh*ww, wh*ww)

39. self.register_buffer("relative_position_index", relative_position_index)

41. self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)

42. self.attn_drop = nn.Dropout(attn_drop)

43. self.proj = nn.Linear(dim, dim)

44. self.proj_drop = nn.Dropout(proj_drop)

46. trunc_normal_(self.relative_position_bias_table, std=.02)

47. self.softmax = nn.Softmax(dim=-1)

49. def forward(self, x, mask=None):

50. """

51. Args:

52. x: input features with shape of (num_windows*B, N, C)

53. mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None

54. """

55. # 默认 N = wh*ww = w*w = 16

56. # 默认 num_windows = (H*W)//(wh*ww) = (H*W)//16

57. # 默认 C = 3

59. # (num_windows*B, N, C) = (num_windows*B, wh*ww, C)

60. B_, N, C = x.shape

62. # (num_windows*B, N, C, num_heads, C//num_heads) -> (C, num_windows*B, num_heads, wh*ww, C//num_heads)

63. qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)

65. # (num_windows*B, num_heads, wh*ww, C//num_heads)

66. q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)

68. # (num_windows*B, num_heads, wh*ww, C//num_heads)

69. q = q * self.scale

71. # (num_windows*B, num_heads, wh*ww, C//num_heads) * (num_windows*B, num_heads, C//num_heads, wh*ww) = (num_windows*B, num_heads, wh*ww, wh*ww)

72. attn = (q @ k.transpose(-2, -1))

74. # (wh*ww, wh*ww, num_heads)

75. relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(

76. self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)

78. # (num_heads, wh*ww, wh*ww)

79. relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()

81. # (num_heads, wh*ww, wh*ww) -> (1, num_heads, wh*ww, wh*ww) -> (num_windows*B, num_heads, wh*ww, wh*ww)

82. attn = attn + relative_position_bias.unsqueeze(0) #

84. if mask is not None:

85. nW = mask.shape[0]

86. attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)

87. attn = attn.view(-1, self.num_heads, N, N)

88. attn = self.softmax(attn)

89. else:

90. attn = self.softmax(attn)

92. # (num_windows*B, num_heads, wh*ww, wh*ww)

93. attn = self.attn_drop(attn)

95. # (num_windows*B, num_heads, wh*ww, wh*ww) * (num_windows*B, num_heads, wh*ww, C//num_heads) = (num_windows*B, num_heads, wh*ww, C//num_heads)

96. # (num_windows*B, num_heads, wh*ww, C//num_heads) -> (num_windows*B, wh*ww, num_heads, C//num_heads) -> (num_windows*B, wh*ww, C) = (N*B, wh*ww, C)

97. x = (attn @ v).transpose(1, 2).reshape(B_, N, C)

99. x = self.proj(x)

100. x = self.proj_drop(x)

102. return x

104. def extra_repr(self) -> str:

105. return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'

107. def flops(self, N):

108. # calculate flops for 1 window with token length of N

109. flops = 0

110. # qkv = self.qkv(x)

111. flops += N * self.dim * 3 * self.dim

112. # attn = (q @ k.transpose(-2, -1))

113. flops += self.num_heads * N * (self.dim // self.num_heads) * N

114. # x = (attn @ v)

115. flops += self.num_heads * N * N * (self.dim // self.num_heads)

116. # x = self.proj(x)

117. flops += N * self.dim * self.dim

118. return flops

120. [点击并拖拽以移动]

123. ​

        主要 shape 变化演示:

1. import torch

2. import torch.nn as nn

5. # 以 4×4 窗口大小为例

6. window_size = (4, 4)

8. coords_h = torch.arange(window_size[0]) # wh

9. coords_w = torch.arange(window_size[1]) # ww

10. coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # (2, wh, ww)

11. coords, coords.shape

1. (tensor([[[0, 0, 0, 0],

2. [1, 1, 1, 1],

3. [2, 2, 2, 2],

4. [3, 3, 3, 3]],

6. [[0, 1, 2, 3],

7. [0, 1, 2, 3],

8. [0, 1, 2, 3],

9. [0, 1, 2, 3]]]),

10. torch.Size([2, 4, 4]))

1. coords_flatten = torch.flatten(coords, 1) # (2, wh*ww)

2. coords_flatten, coords_flatten.shape

1. (tensor([[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3],

2. [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]]),

3. torch.Size([2, 16]))

1. relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # (2, wh*ww, wh*ww)

2. relative_coords, relative_coords.shape

1. (tensor([[[ 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2, -3, -3, -3, -3],

2. [ 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2, -3, -3, -3, -3],

3. [ 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2, -3, -3, -3, -3],

4. [ 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2, -3, -3, -3, -3],

5. [ 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2],

6. [ 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2],

7. [ 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2],

8. [ 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1, -2, -2, -2, -2],

9. [ 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1],

10. [ 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1],

11. [ 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1],

12. [ 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, -1, -1, -1, -1],

13. [ 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0],

14. [ 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0],

15. [ 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0],

16. [ 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0]],

18. [[ 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3],

19. [ 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2],

20. [ 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1],

21. [ 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0],

22. [ 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3],

23. [ 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2],

24. [ 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1],

25. [ 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0],

26. [ 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3],

27. [ 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2],

28. [ 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1],

29. [ 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0],

30. [ 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3, 0, -1, -2, -3],

31. [ 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2, 1, 0, -1, -2],

32. [ 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1, 2, 1, 0, -1],

33. [ 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0]]]),

34. torch.Size([2, 16, 16]))

1. # (x, y) 格式显示 横、纵坐标

2. relative_coords = relative_coords.permute(1, 2, 0).contiguous() # (wh*ww, wh*ww, 2)

3. relative_coords, relative_coords.shape

1. (tensor([[[ 0, 0],

2. [ 0, -1],

3. [ 0, -2],

4. [ 0, -3],

5. [-1, 0],

6. [-1, -1],

7. [-1, -2],

8. [-1, -3],

9. [-2, 0],

10. [-2, -1],

11. [-2, -2],

12. [-2, -3],

13. [-3, 0],

14. [-3, -1],

15. [-3, -2],

16. [-3, -3]],

18. [[ 0, 1],

19. [ 0, 0],

20. [ 0, -1],

21. [ 0, -2],

22. [-1, 1],

23. [-1, 0],

24. [-1, -1],

25. [-1, -2],

26. [-2, 1],

27. [-2, 0],

28. [-2, -1],

29. [-2, -2],

30. [-3, 1],

31. [-3, 0],

32. [-3, -1],

33. [-3, -2]],

35. [[ 0, 2],

36. [ 0, 1],

37. [ 0, 0],

38. [ 0, -1],

39. [-1, 2],

40. [-1, 1],

41. [-1, 0],

42. [-1, -1],

43. [-2, 2],

44. [-2, 1],

45. [-2, 0],

46. [-2, -1],

47. [-3, 2],

48. [-3, 1],

49. [-3, 0],

50. [-3, -1]],

52. [[ 0, 3],

53. [ 0, 2],

54. [ 0, 1],

55. [ 0, 0],

56. [-1, 3],

57. [-1, 2],

58. [-1, 1],

59. [-1, 0],

60. [-2, 3],

61. [-2, 2],

62. [-2, 1],

63. [-2, 0],

64. [-3, 3],

65. [-3, 2],

66. [-3, 1],

67. [-3, 0]],

69. [[ 1, 0],

70. [ 1, -1],

71. [ 1, -2],

72. [ 1, -3],

73. [ 0, 0],

74. [ 0, -1],

75. [ 0, -2],

76. [ 0, -3],

77. [-1, 0],

78. [-1, -1],

79. [-1, -2],

80. [-1, -3],

81. [-2, 0],

82. [-2, -1],

83. [-2, -2],

84. [-2, -3]],

86. [[ 1, 1],

87. [ 1, 0],

88. [ 1, -1],

89. [ 1, -2],

90. [ 0, 1],

91. [ 0, 0],

92. [ 0, -1],

93. [ 0, -2],

94. [-1, 1],

95. [-1, 0],

96. [-1, -1],

97. [-1, -2],

98. [-2, 1],

99. [-2, 0],

100. [-2, -1],

101. [-2, -2]],

103. [[ 1, 2],

104. [ 1, 1],

105. [ 1, 0],

106. [ 1, -1],

107. [ 0, 2],

108. [ 0, 1],

109. [ 0, 0],

110. [ 0, -1],

111. [-1, 2],

112. [-1, 1],

113. [-1, 0],

114. [-1, -1],

115. [-2, 2],

116. [-2, 1],

117. [-2, 0],

118. [-2, -1]],

120. [[ 1, 3],

121. [ 1, 2],

122. [ 1, 1],

123. [ 1, 0],

124. [ 0, 3],

125. [ 0, 2],

126. [ 0, 1],

127. [ 0, 0],

128. [-1, 3],

129. [-1, 2],

130. [-1, 1],

131. [-1, 0],

132. [-2, 3],

133. [-2, 2],

134. [-2, 1],

135. [-2, 0]],

137. [[ 2, 0],

138. [ 2, -1],

139. [ 2, -2],

140. [ 2, -3],

141. [ 1, 0],

142. [ 1, -1],

143. [ 1, -2],

144. [ 1, -3],

145. [ 0, 0],

146. [ 0, -1],

147. [ 0, -2],

148. [ 0, -3],

149. [-1, 0],

150. [-1, -1],

151. [-1, -2],

152. [-1, -3]],

154. [[ 2, 1],

155. [ 2, 0],

156. [ 2, -1],

157. [ 2, -2],

158. [ 1, 1],

159. [ 1, 0],

160. [ 1, -1],

161. [ 1, -2],

162. [ 0, 1],

163. [ 0, 0],

164. [ 0, -1],

165. [ 0, -2],

166. [-1, 1],

167. [-1, 0],

168. [-1, -1],

169. [-1, -2]],

171. [[ 2, 2],

172. [ 2, 1],

173. [ 2, 0],

174. [ 2, -1],

175. [ 1, 2],

176. [ 1, 1],

177. [ 1, 0],

178. [ 1, -1],

179. [ 0, 2],

180. [ 0, 1],

181. [ 0, 0],

182. [ 0, -1],

183. [-1, 2],

184. [-1, 1],

185. [-1, 0],

186. [-1, -1]],

188. [[ 2, 3],

189. [ 2, 2],

190. [ 2, 1],

191. [ 2, 0],

192. [ 1, 3],

193. [ 1, 2],

194. [ 1, 1],

195. [ 1, 0],

196. [ 0, 3],

197. [ 0, 2],

198. [ 0, 1],

199. [ 0, 0],

200. [-1, 3],

201. [-1, 2],

202. [-1, 1],

203. [-1, 0]],

205. [[ 3, 0],

206. [ 3, -1],

207. [ 3, -2],

208. [ 3, -3],

209. [ 2, 0],

210. [ 2, -1],

211. [ 2, -2],

212. [ 2, -3],

213. [ 1, 0],

214. [ 1, -1],

215. [ 1, -2],

216. [ 1, -3],

217. [ 0, 0],

218. [ 0, -1],

219. [ 0, -2],

220. [ 0, -3]],

222. [[ 3, 1],

223. [ 3, 0],

224. [ 3, -1],

225. [ 3, -2],

226. [ 2, 1],

227. [ 2, 0],

228. [ 2, -1],

229. [ 2, -2],

230. [ 1, 1],

231. [ 1, 0],

232. [ 1, -1],

233. [ 1, -2],

234. [ 0, 1],

235. [ 0, 0],

236. [ 0, -1],

237. [ 0, -2]],

239. [[ 3, 2],

240. [ 3, 1],

241. [ 3, 0],

242. [ 3, -1],

243. [ 2, 2],

244. [ 2, 1],

245. [ 2, 0],

246. [ 2, -1],

247. [ 1, 2],

248. [ 1, 1],

249. [ 1, 0],

250. [ 1, -1],

251. [ 0, 2],

252. [ 0, 1],

253. [ 0, 0],

254. [ 0, -1]],

256. [[ 3, 3],

257. [ 3, 2],

258. [ 3, 1],

259. [ 3, 0],

260. [ 2, 3],

261. [ 2, 2],

262. [ 2, 1],

263. [ 2, 0],

264. [ 1, 3],

265. [ 1, 2],

266. [ 1, 1],

267. [ 1, 0],

268. [ 0, 3],

269. [ 0, 2],

270. [ 0, 1],

271. [ 0, 0]]]),

272. torch.Size([16, 16, 2]))

1. # 横坐标加性偏移 (+= 3)

2. relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0

3. relative_coords

1. tensor([[[ 3, 0],

2. [ 3, -1],

3. [ 3, -2],

4. [ 3, -3],

5. [ 2, 0],

6. [ 2, -1],

7. [ 2, -2],

8. [ 2, -3],

9. [ 1, 0],

10. [ 1, -1],

11. [ 1, -2],

12. [ 1, -3],

13. [ 0, 0],

14. [ 0, -1],

15. [ 0, -2],

16. [ 0, -3]],

18. [[ 3, 1],

19. [ 3, 0],

20. [ 3, -1],

21. [ 3, -2],

22. [ 2, 1],

23. [ 2, 0],

24. [ 2, -1],

25. [ 2, -2],

26. [ 1, 1],

27. [ 1, 0],

28. [ 1, -1],

29. [ 1, -2],

30. [ 0, 1],

31. [ 0, 0],

32. [ 0, -1],

33. [ 0, -2]],

35. [[ 3, 2],

36. [ 3, 1],

37. [ 3, 0],

38. [ 3, -1],

39. [ 2, 2],

40. [ 2, 1],

41. [ 2, 0],

42. [ 2, -1],

43. [ 1, 2],

44. [ 1, 1],

45. [ 1, 0],

46. [ 1, -1],

47. [ 0, 2],

48. [ 0, 1],

49. [ 0, 0],

50. [ 0, -1]],

52. [[ 3, 3],

53. [ 3, 2],

54. [ 3, 1],

55. [ 3, 0],

56. [ 2, 3],

57. [ 2, 2],

58. [ 2, 1],

59. [ 2, 0],

60. [ 1, 3],

61. [ 1, 2],

62. [ 1, 1],

63. [ 1, 0],

64. [ 0, 3],

65. [ 0, 2],

66. [ 0, 1],

67. [ 0, 0]],

69. [[ 4, 0],

70. [ 4, -1],

71. [ 4, -2],

72. [ 4, -3],

73. [ 3, 0],

74. [ 3, -1],

75. [ 3, -2],

76. [ 3, -3],

77. [ 2, 0],

78. [ 2, -1],

79. [ 2, -2],

80. [ 2, -3],

81. [ 1, 0],

82. [ 1, -1],

83. [ 1, -2],

84. [ 1, -3]],

86. [[ 4, 1],

87. [ 4, 0],

88. [ 4, -1],

89. [ 4, -2],

90. [ 3, 1],

91. [ 3, 0],

92. [ 3, -1],

93. [ 3, -2],

94. [ 2, 1],

95. [ 2, 0],

96. [ 2, -1],

97. [ 2, -2],

98. [ 1, 1],

99. [ 1, 0],

100. [ 1, -1],

101. [ 1, -2]],

103. [[ 4, 2],

104. [ 4, 1],

105. [ 4, 0],

106. [ 4, -1],

107. [ 3, 2],

108. [ 3, 1],

109. [ 3, 0],

110. [ 3, -1],

111. [ 2, 2],

112. [ 2, 1],

113. [ 2, 0],

114. [ 2, -1],

115. [ 1, 2],

116. [ 1, 1],

117. [ 1, 0],

118. [ 1, -1]],

120. [[ 4, 3],

121. [ 4, 2],

122. [ 4, 1],

123. [ 4, 0],

124. [ 3, 3],

125. [ 3, 2],

126. [ 3, 1],

127. [ 3, 0],

128. [ 2, 3],

129. [ 2, 2],

130. [ 2, 1],

131. [ 2, 0],

132. [ 1, 3],

133. [ 1, 2],

134. [ 1, 1],

135. [ 1, 0]],

137. [[ 5, 0],

138. [ 5, -1],

139. [ 5, -2],

140. [ 5, -3],

141. [ 4, 0],

142. [ 4, -1],

143. [ 4, -2],

144. [ 4, -3],

145. [ 3, 0],

146. [ 3, -1],

147. [ 3, -2],

148. [ 3, -3],

149. [ 2, 0],

150. [ 2, -1],

151. [ 2, -2],

152. [ 2, -3]],

154. [[ 5, 1],

155. [ 5, 0],

156. [ 5, -1],

157. [ 5, -2],

158. [ 4, 1],

159. [ 4, 0],

160. [ 4, -1],

161. [ 4, -2],

162. [ 3, 1],

163. [ 3, 0],

164. [ 3, -1],

165. [ 3, -2],

166. [ 2, 1],

167. [ 2, 0],

168. [ 2, -1],

169. [ 2, -2]],

171. [[ 5, 2],

172. [ 5, 1],

173. [ 5, 0],

174. [ 5, -1],

175. [ 4, 2],

176. [ 4, 1],

177. [ 4, 0],

178. [ 4, -1],

179. [ 3, 2],

180. [ 3, 1],

181. [ 3, 0],

182. [ 3, -1],

183. [ 2, 2],

184. [ 2, 1],

185. [ 2, 0],

186. [ 2, -1]],

188. [[ 5, 3],

189. [ 5, 2],

190. [ 5, 1],

191. [ 5, 0],

192. [ 4, 3],

193. [ 4, 2],

194. [ 4, 1],

195. [ 4, 0],

196. [ 3, 3],

197. [ 3, 2],

198. [ 3, 1],

199. [ 3, 0],

200. [ 2, 3],

201. [ 2, 2],

202. [ 2, 1],

203. [ 2, 0]],

205. [[ 6, 0],

206. [ 6, -1],

207. [ 6, -2],

208. [ 6, -3],

209. [ 5, 0],

210. [ 5, -1],

211. [ 5, -2],

212. [ 5, -3],

213. [ 4, 0],

214. [ 4, -1],

215. [ 4, -2],

216. [ 4, -3],

217. [ 3, 0],

218. [ 3, -1],

219. [ 3, -2],

220. [ 3, -3]],

222. [[ 6, 1],

223. [ 6, 0],

224. [ 6, -1],

225. [ 6, -2],

226. [ 5, 1],

227. [ 5, 0],

228. [ 5, -1],

229. [ 5, -2],

230. [ 4, 1],

231. [ 4, 0],

232. [ 4, -1],

233. [ 4, -2],

234. [ 3, 1],

235. [ 3, 0],

236. [ 3, -1],

237. [ 3, -2]],

239. [[ 6, 2],

240. [ 6, 1],

241. [ 6, 0],

242. [ 6, -1],

243. [ 5, 2],

244. [ 5, 1],

245. [ 5, 0],

246. [ 5, -1],

247. [ 4, 2],

248. [ 4, 1],

249. [ 4, 0],

250. [ 4, -1],

251. [ 3, 2],

252. [ 3, 1],

253. [ 3, 0],

254. [ 3, -1]],

256. [[ 6, 3],

257. [ 6, 2],

258. [ 6, 1],

259. [ 6, 0],

260. [ 5, 3],

261. [ 5, 2],

262. [ 5, 1],

263. [ 5, 0],

264. [ 4, 3],

265. [ 4, 2],

266. [ 4, 1],

267. [ 4, 0],

268. [ 3, 3],

269. [ 3, 2],

270. [ 3, 1],

271. [ 3, 0]]])

1. # 纵坐标加性偏移 (+= 3)

2. relative_coords[:, :, 1] += window_size[1] - 1

3. relative_coords

1. tensor([[[3, 3],

2. [3, 2],

3. [3, 1],

4. [3, 0],

5. [2, 3],

6. [2, 2],

7. [2, 1],

8. [2, 0],

9. [1, 3],

10. [1, 2],

11. [1, 1],

12. [1, 0],

13. [0, 3],

14. [0, 2],

15. [0, 1],

16. [0, 0]],

18. [[3, 4],

19. [3, 3],

20. [3, 2],

21. [3, 1],

22. [2, 4],

23. [2, 3],

24. [2, 2],

25. [2, 1],

26. [1, 4],

27. [1, 3],

28. [1, 2],

29. [1, 1],

30. [0, 4],

31. [0, 3],

32. [0, 2],

33. [0, 1]],

35. [[3, 5],

36. [3, 4],

37. [3, 3],

38. [3, 2],

39. [2, 5],

40. [2, 4],

41. [2, 3],

42. [2, 2],

43. [1, 5],

44. [1, 4],

45. [1, 3],

46. [1, 2],

47. [0, 5],

48. [0, 4],

49. [0, 3],

50. [0, 2]],

52. [[3, 6],

53. [3, 5],

54. [3, 4],

55. [3, 3],

56. [2, 6],

57. [2, 5],

58. [2, 4],

59. [2, 3],

60. [1, 6],

61. [1, 5],

62. [1, 4],

63. [1, 3],

64. [0, 6],

65. [0, 5],

66. [0, 4],

67. [0, 3]],

69. [[4, 3],

70. [4, 2],

71. [4, 1],

72. [4, 0],

73. [3, 3],

74. [3, 2],

75. [3, 1],

76. [3, 0],

77. [2, 3],

78. [2, 2],

79. [2, 1],

80. [2, 0],

81. [1, 3],

82. [1, 2],

83. [1, 1],

84. [1, 0]],

86. [[4, 4],

87. [4, 3],

88. [4, 2],

89. [4, 1],

90. [3, 4],

91. [3, 3],

92. [3, 2],

93. [3, 1],

94. [2, 4],

95. [2, 3],

96. [2, 2],

97. [2, 1],

98. [1, 4],

99. [1, 3],

100. [1, 2],

101. [1, 1]],

103. [[4, 5],

104. [4, 4],

105. [4, 3],

106. [4, 2],

107. [3, 5],

108. [3, 4],

109. [3, 3],

110. [3, 2],

111. [2, 5],

112. [2, 4],

113. [2, 3],

114. [2, 2],

115. [1, 5],

116. [1, 4],

117. [1, 3],

118. [1, 2]],

120. [[4, 6],

121. [4, 5],

122. [4, 4],

123. [4, 3],

124. [3, 6],

125. [3, 5],

126. [3, 4],

127. [3, 3],

128. [2, 6],

129. [2, 5],

130. [2, 4],

131. [2, 3],

132. [1, 6],

133. [1, 5],

134. [1, 4],

135. [1, 3]],

137. [[5, 3],

138. [5, 2],

139. [5, 1],

140. [5, 0],

141. [4, 3],

142. [4, 2],

143. [4, 1],

144. [4, 0],

145. [3, 3],

146. [3, 2],

147. [3, 1],

148. [3, 0],

149. [2, 3],

150. [2, 2],

151. [2, 1],

152. [2, 0]],

154. [[5, 4],

155. [5, 3],

156. [5, 2],

157. [5, 1],

158. [4, 4],

159. [4, 3],

160. [4, 2],

161. [4, 1],

162. [3, 4],

163. [3, 3],

164. [3, 2],

165. [3, 1],

166. [2, 4],

167. [2, 3],

168. [2, 2],

169. [2, 1]],

171. [[5, 5],

172. [5, 4],

173. [5, 3],

174. [5, 2],

175. [4, 5],

176. [4, 4],

177. [4, 3],

178. [4, 2],

179. [3, 5],

180. [3, 4],

181. [3, 3],

182. [3, 2],

183. [2, 5],

184. [2, 4],

185. [2, 3],

186. [2, 2]],

188. [[5, 6],

189. [5, 5],

190. [5, 4],

191. [5, 3],

192. [4, 6],

193. [4, 5],

194. [4, 4],

195. [4, 3],

196. [3, 6],

197. [3, 5],

198. [3, 4],

199. [3, 3],

200. [2, 6],

201. [2, 5],

202. [2, 4],

203. [2, 3]],

205. [[6, 3],

206. [6, 2],

207. [6, 1],

208. [6, 0],

209. [5, 3],

210. [5, 2],

211. [5, 1],

212. [5, 0],

213. [4, 3],

214. [4, 2],

215. [4, 1],

216. [4, 0],

217. [3, 3],

218. [3, 2],

219. [3, 1],

220. [3, 0]],

222. [[6, 4],

223. [6, 3],

224. [6, 2],

225. [6, 1],

226. [5, 4],

227. [5, 3],

228. [5, 2],

229. [5, 1],

230. [4, 4],

231. [4, 3],

232. [4, 2],

233. [4, 1],

234. [3, 4],

235. [3, 3],

236. [3, 2],

237. [3, 1]],

239. [[6, 5],

240. [6, 4],

241. [6, 3],

242. [6, 2],

243. [5, 5],

244. [5, 4],

245. [5, 3],

246. [5, 2],

247. [4, 5],

248. [4, 4],

249. [4, 3],

250. [4, 2],

251. [3, 5],

252. [3, 4],

253. [3, 3],

254. [3, 2]],

256. [[6, 6],

257. [6, 5],

258. [6, 4],

259. [6, 3],

260. [5, 6],

261. [5, 5],

262. [5, 4],

263. [5, 3],

264. [4, 6],

265. [4, 5],

266. [4, 4],

267. [4, 3],

268. [3, 6],

269. [3, 5],

270. [3, 4],

271. [3, 3]]])

1. # 横坐标乘性变换 (*= 7)

2. relative_coords[:, :, 0] *= 2 * window_size[1] - 1

3. relative_coords

1. tensor([[[21, 3],

2. [21, 2],

3. [21, 1],

4. [21, 0],

5. [14, 3],

6. [14, 2],

7. [14, 1],

8. [14, 0],

9. [ 7, 3],

10. [ 7, 2],

11. [ 7, 1],

12. [ 7, 0],

13. [ 0, 3],

14. [ 0, 2],

15. [ 0, 1],

16. [ 0, 0]],

18. [[21, 4],

19. [21, 3],

20. [21, 2],

21. [21, 1],

22. [14, 4],

23. [14, 3],

24. [14, 2],

25. [14, 1],

26. [ 7, 4],

27. [ 7, 3],

28. [ 7, 2],

29. [ 7, 1],

30. [ 0, 4],

31. [ 0, 3],

32. [ 0, 2],

33. [ 0, 1]],

35. [[21, 5],

36. [21, 4],

37. [21, 3],

38. [21, 2],

39. [14, 5],

40. [14, 4],

41. [14, 3],

42. [14, 2],

43. [ 7, 5],

44. [ 7, 4],

45. [ 7, 3],

46. [ 7, 2],

47. [ 0, 5],

48. [ 0, 4],

49. [ 0, 3],

50. [ 0, 2]],

52. [[21, 6],

53. [21, 5],

54. [21, 4],

55. [21, 3],

56. [14, 6],

57. [14, 5],

58. [14, 4],

59. [14, 3],

60. [ 7, 6],

61. [ 7, 5],

62. [ 7, 4],

63. [ 7, 3],

64. [ 0, 6],

65. [ 0, 5],

66. [ 0, 4],

67. [ 0, 3]],

69. [[28, 3],

70. [28, 2],

71. [28, 1],

72. [28, 0],

73. [21, 3],

74. [21, 2],

75. [21, 1],

76. [21, 0],

77. [14, 3],

78. [14, 2],

79. [14, 1],

80. [14, 0],

81. [ 7, 3],

82. [ 7, 2],

83. [ 7, 1],

84. [ 7, 0]],

86. [[28, 4],

87. [28, 3],

88. [28, 2],

89. [28, 1],

90. [21, 4],

91. [21, 3],

92. [21, 2],

93. [21, 1],

94. [14, 4],

95. [14, 3],

96. [14, 2],

97. [14, 1],

98. [ 7, 4],

99. [ 7, 3],

100. [ 7, 2],

101. [ 7, 1]],

103. [[28, 5],

104. [28, 4],

105. [28, 3],

106. [28, 2],

107. [21, 5],

108. [21, 4],

109. [21, 3],

110. [21, 2],

111. [14, 5],

112. [14, 4],

113. [14, 3],

114. [14, 2],

115. [ 7, 5],

116. [ 7, 4],

117. [ 7, 3],

118. [ 7, 2]],

120. [[28, 6],

121. [28, 5],

122. [28, 4],

123. [28, 3],

124. [21, 6],

125. [21, 5],

126. [21, 4],

127. [21, 3],

128. [14, 6],

129. [14, 5],

130. [14, 4],

131. [14, 3],

132. [ 7, 6],

133. [ 7, 5],

134. [ 7, 4],

135. [ 7, 3]],

137. [[35, 3],

138. [35, 2],

139. [35, 1],

140. [35, 0],

141. [28, 3],

142. [28, 2],

143. [28, 1],

144. [28, 0],

145. [21, 3],

146. [21, 2],

147. [21, 1],

148. [21, 0],

149. [14, 3],

150. [14, 2],

151. [14, 1],

152. [14, 0]],

154. [[35, 4],

155. [35, 3],

156. [35, 2],

157. [35, 1],

158. [28, 4],

159. [28, 3],

160. [28, 2],

161. [28, 1],

162. [21, 4],

163. [21, 3],

164. [21, 2],

165. [21, 1],

166. [14, 4],

167. [14, 3],

168. [14, 2],

169. [14, 1]],

171. [[35, 5],

172. [35, 4],

173. [35, 3],

174. [35, 2],

175. [28, 5],

176. [28, 4],

177. [28, 3],

178. [28, 2],

179. [21, 5],

180. [21, 4],

181. [21, 3],

182. [21, 2],

183. [14, 5],

184. [14, 4],

185. [14, 3],

186. [14, 2]],

188. [[35, 6],

189. [35, 5],

190. [35, 4],

191. [35, 3],

192. [28, 6],

193. [28, 5],

194. [28, 4],

195. [28, 3],

196. [21, 6],

197. [21, 5],

198. [21, 4],

199. [21, 3],

200. [14, 6],

201. [14, 5],

202. [14, 4],

203. [14, 3]],

205. [[42, 3],

206. [42, 2],

207. [42, 1],

208. [42, 0],

209. [35, 3],

210. [35, 2],

211. [35, 1],

212. [35, 0],

213. [28, 3],

214. [28, 2],

215. [28, 1],

216. [28, 0],

217. [21, 3],

218. [21, 2],

219. [21, 1],

220. [21, 0]],

222. [[42, 4],

223. [42, 3],

224. [42, 2],

225. [42, 1],

226. [35, 4],

227. [35, 3],

228. [35, 2],

229. [35, 1],

230. [28, 4],

231. [28, 3],

232. [28, 2],

233. [28, 1],

234. [21, 4],

235. [21, 3],

236. [21, 2],

237. [21, 1]],

239. [[42, 5],

240. [42, 4],

241. [42, 3],

242. [42, 2],

243. [35, 5],

244. [35, 4],

245. [35, 3],

246. [35, 2],

247. [28, 5],

248. [28, 4],

249. [28, 3],

250. [28, 2],

251. [21, 5],

252. [21, 4],

253. [21, 3],

254. [21, 2]],

256. [[42, 6],

257. [42, 5],

258. [42, 4],

259. [42, 3],

260. [35, 6],

261. [35, 5],

262. [35, 4],

263. [35, 3],

264. [28, 6],

265. [28, 5],

266. [28, 4],

267. [28, 3],

268. [21, 6],

269. [21, 5],

270. [21, 4],

271. [21, 3]]])

1. # 计算 1D 偏移量 (x+y)

2. relative_position_index = relative_coords.sum(-1) # (wh*ww, wh*ww)

3. relative_position_index, relative_position_index.shape

5. # 可见偏移量大小沿主对角线垂直方向扩散、分布

6. # 16 列与 4×4 个坐标位置一一对应

1. (tensor([[24, 23, 22, 21, 17, 16, 15, 14, 10, 9, 8, 7, 3, 2, 1, 0],

2. [25, 24, 23, 22, 18, 17, 16, 15, 11, 10, 9, 8, 4, 3, 2, 1],

3. [26, 25, 24, 23, 19, 18, 17, 16, 12, 11, 10, 9, 5, 4, 3, 2],

4. [27, 26, 25, 24, 20, 19, 18, 17, 13, 12, 11, 10, 6, 5, 4, 3],

5. [31, 30, 29, 28, 24, 23, 22, 21, 17, 16, 15, 14, 10, 9, 8, 7],

6. [32, 31, 30, 29, 25, 24, 23, 22, 18, 17, 16, 15, 11, 10, 9, 8],

7. [33, 32, 31, 30, 26, 25, 24, 23, 19, 18, 17, 16, 12, 11, 10, 9],

8. [34, 33, 32, 31, 27, 26, 25, 24, 20, 19, 18, 17, 13, 12, 11, 10],

9. [38, 37, 36, 35, 31, 30, 29, 28, 24, 23, 22, 21, 17, 16, 15, 14],

10. [39, 38, 37, 36, 32, 31, 30, 29, 25, 24, 23, 22, 18, 17, 16, 15],

11. [40, 39, 38, 37, 33, 32, 31, 30, 26, 25, 24, 23, 19, 18, 17, 16],

12. [41, 40, 39, 38, 34, 33, 32, 31, 27, 26, 25, 24, 20, 19, 18, 17],

13. [45, 44, 43, 42, 38, 37, 36, 35, 31, 30, 29, 28, 24, 23, 22, 21],

14. [46, 45, 44, 43, 39, 38, 37, 36, 32, 31, 30, 29, 25, 24, 23, 22],

15. [47, 46, 45, 44, 40, 39, 38, 37, 33, 32, 31, 30, 26, 25, 24, 23],

16. [48, 47, 46, 45, 41, 40, 39, 38, 34, 33, 32, 31, 27, 26, 25, 24]]),

17. torch.Size([16, 16]))

1. # 设 MHA 的 heads 数为 3

2. num_heads = 3

4. relative_position_bias_table = nn.Parameter(

5. torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))

6. relative_position_bias_table, relative_position_bias_table.shape

1. (Parameter containing:

2. tensor([[0., 0., 0.],

3. [0., 0., 0.],

4. [0., 0., 0.],

5. [0., 0., 0.],

6. [0., 0., 0.],

7. [0., 0., 0.],

8. [0., 0., 0.],

9. [0., 0., 0.],

10. [0., 0., 0.],

11. [0., 0., 0.],

12. [0., 0., 0.],

13. [0., 0., 0.],

14. [0., 0., 0.],

15. [0., 0., 0.],

16. [0., 0., 0.],

17. [0., 0., 0.],

18. [0., 0., 0.],

19. [0., 0., 0.],

20. [0., 0., 0.],

21. [0., 0., 0.],

22. [0., 0., 0.],

23. [0., 0., 0.],

24. [0., 0., 0.],

25. [0., 0., 0.],

26. [0., 0., 0.],

27. [0., 0., 0.],

28. [0., 0., 0.],

29. [0., 0., 0.],

30. [0., 0., 0.],

31. [0., 0., 0.],

32. [0., 0., 0.],

33. [0., 0., 0.],

34. [0., 0., 0.],

35. [0., 0., 0.],

36. [0., 0., 0.],

37. [0., 0., 0.],

38. [0., 0., 0.],

39. [0., 0., 0.],

40. [0., 0., 0.],

41. [0., 0., 0.],

42. [0., 0., 0.],

43. [0., 0., 0.],

44. [0., 0., 0.],

45. [0., 0., 0.],

46. [0., 0., 0.],

47. [0., 0., 0.],

48. [0., 0., 0.],

49. [0., 0., 0.],

50. [0., 0., 0.]], requires_grad=True),

51. torch.Size([49, 3]))

1. relative_position_bias = relative_position_bias_table[relative_position_index.view(-1)].view(

2. window_size[0] * window_size[1], window_size[0] * window_size[1], -1)

4. relative_position_bias, relative_position_bias.shape

1. (tensor([[[0., 0., 0.],

2. [0., 0., 0.],

3. [0., 0., 0.],

4. [0., 0., 0.],

5. [0., 0., 0.],

6. [0., 0., 0.],

7. [0., 0., 0.],

8. [0., 0., 0.],

9. [0., 0., 0.],

10. [0., 0., 0.],

11. [0., 0., 0.],

12. [0., 0., 0.],

13. [0., 0., 0.],

14. [0., 0., 0.],

15. [0., 0., 0.],

16. [0., 0., 0.]],

18. [[0., 0., 0.],

19. [0., 0., 0.],

20. [0., 0., 0.],

21. [0., 0., 0.],

22. [0., 0., 0.],

23. [0., 0., 0.],

24. [0., 0., 0.],

25. [0., 0., 0.],

26. [0., 0., 0.],

27. [0., 0., 0.],

28. [0., 0., 0.],

29. [0., 0., 0.],

30. [0., 0., 0.],

31. [0., 0., 0.],

32. [0., 0., 0.],

33. [0., 0., 0.]],

35. [[0., 0., 0.],

36. [0., 0., 0.],

37. [0., 0., 0.],

38. [0., 0., 0.],

39. [0., 0., 0.],

40. [0., 0., 0.],

41. [0., 0., 0.],

42. [0., 0., 0.],

43. [0., 0., 0.],

44. [0., 0., 0.],

45. [0., 0., 0.],

46. [0., 0., 0.],

47. [0., 0., 0.],

48. [0., 0., 0.],

49. [0., 0., 0.],

50. [0., 0., 0.]],

52. [[0., 0., 0.],

53. [0., 0., 0.],

54. [0., 0., 0.],

55. [0., 0., 0.],

56. [0., 0., 0.],

57. [0., 0., 0.],

58. [0., 0., 0.],

59. [0., 0., 0.],

60. [0., 0., 0.],

61. [0., 0., 0.],

62. [0., 0., 0.],

63. [0., 0., 0.],

64. [0., 0., 0.],

65. [0., 0., 0.],

66. [0., 0., 0.],

67. [0., 0., 0.]],

69. [[0., 0., 0.],

70. [0., 0., 0.],

71. [0., 0., 0.],

72. [0., 0., 0.],

73. [0., 0., 0.],

74. [0., 0., 0.],

75. [0., 0., 0.],

76. [0., 0., 0.],

77. [0., 0., 0.],

78. [0., 0., 0.],

79. [0., 0., 0.],

80. [0., 0., 0.],

81. [0., 0., 0.],

82. [0., 0., 0.],

83. [0., 0., 0.],

84. [0., 0., 0.]],

86. [[0., 0., 0.],

87. [0., 0., 0.],

88. [0., 0., 0.],

89. [0., 0., 0.],

90. [0., 0., 0.],

91. [0., 0., 0.],

92. [0., 0., 0.],

93. [0., 0., 0.],

94. [0., 0., 0.],

95. [0., 0., 0.],

96. [0., 0., 0.],

97. [0., 0., 0.],

98. [0., 0., 0.],

99. [0., 0., 0.],

100. [0., 0., 0.],

101. [0., 0., 0.]],

103. [[0., 0., 0.],

104. [0., 0., 0.],

105. [0., 0., 0.],

106. [0., 0., 0.],

107. [0., 0., 0.],

108. [0., 0., 0.],

109. [0., 0., 0.],

110. [0., 0., 0.],

111. [0., 0., 0.],

112. [0., 0., 0.],

113. [0., 0., 0.],

114. [0., 0., 0.],

115. [0., 0., 0.],

116. [0., 0., 0.],

117. [0., 0., 0.],

118. [0., 0., 0.]],

120. [[0., 0., 0.],

121. [0., 0., 0.],

122. [0., 0., 0.],

123. [0., 0., 0.],

124. [0., 0., 0.],

125. [0., 0., 0.],

126. [0., 0., 0.],

127. [0., 0., 0.],

128. [0., 0., 0.],

129. [0., 0., 0.],

130. [0., 0., 0.],

131. [0., 0., 0.],

132. [0., 0., 0.],

133. [0., 0., 0.],

134. [0., 0., 0.],

135. [0., 0., 0.]],

137. [[0., 0., 0.],

138. [0., 0., 0.],

139. [0., 0., 0.],

140. [0., 0., 0.],

141. [0., 0., 0.],

142. [0., 0., 0.],

143. [0., 0., 0.],

144. [0., 0., 0.],

145. [0., 0., 0.],

146. [0., 0., 0.],

147. [0., 0., 0.],

148. [0., 0., 0.],

149. [0., 0., 0.],

150. [0., 0., 0.],

151. [0., 0., 0.],

152. [0., 0., 0.]],

154. [[0., 0., 0.],

155. [0., 0., 0.],

156. [0., 0., 0.],

157. [0., 0., 0.],

158. [0., 0., 0.],

159. [0., 0., 0.],

160. [0., 0., 0.],

161. [0., 0., 0.],

162. [0., 0., 0.],

163. [0., 0., 0.],

164. [0., 0., 0.],

165. [0., 0., 0.],

166. [0., 0., 0.],

167. [0., 0., 0.],

168. [0., 0., 0.],

169. [0., 0., 0.]],

171. [[0., 0., 0.],

172. [0., 0., 0.],

173. [0., 0., 0.],

174. [0., 0., 0.],

175. [0., 0., 0.],

176. [0., 0., 0.],

177. [0., 0., 0.],

178. [0., 0., 0.],

179. [0., 0., 0.],

180. [0., 0., 0.],

181. [0., 0., 0.],

182. [0., 0., 0.],

183. [0., 0., 0.],

184. [0., 0., 0.],

185. [0., 0., 0.],

186. [0., 0., 0.]],

188. [[0., 0., 0.],

189. [0., 0., 0.],

190. [0., 0., 0.],

191. [0., 0., 0.],

192. [0., 0., 0.],

193. [0., 0., 0.],

194. [0., 0., 0.],

195. [0., 0., 0.],

196. [0., 0., 0.],

197. [0., 0., 0.],

198. [0., 0., 0.],

199. [0., 0., 0.],

200. [0., 0., 0.],

201. [0., 0., 0.],

202. [0., 0., 0.],

203. [0., 0., 0.]],

205. [[0., 0., 0.],

206. [0., 0., 0.],

207. [0., 0., 0.],

208. [0., 0., 0.],

209. [0., 0., 0.],

210. [0., 0., 0.],

211. [0., 0., 0.],

212. [0., 0., 0.],

213. [0., 0., 0.],

214. [0., 0., 0.],

215. [0., 0., 0.],

216. [0., 0., 0.],

217. [0., 0., 0.],

218. [0., 0., 0.],

219. [0., 0., 0.],

220. [0., 0., 0.]],

222. [[0., 0., 0.],

223. [0., 0., 0.],

224. [0., 0., 0.],

225. [0., 0., 0.],

226. [0., 0., 0.],

227. [0., 0., 0.],

228. [0., 0., 0.],

229. [0., 0., 0.],

230. [0., 0., 0.],

231. [0., 0., 0.],

232. [0., 0., 0.],

233. [0., 0., 0.],

234. [0., 0., 0.],

235. [0., 0., 0.],

236. [0., 0., 0.],

237. [0., 0., 0.]],

239. [[0., 0., 0.],

240. [0., 0., 0.],

241. [0., 0., 0.],

242. [0., 0., 0.],

243. [0., 0., 0.],

244. [0., 0., 0.],

245. [0., 0., 0.],

246. [0., 0., 0.],

247. [0., 0., 0.],

248. [0., 0., 0.],

249. [0., 0., 0.],

250. [0., 0., 0.],

251. [0., 0., 0.],

252. [0., 0., 0.],

253. [0., 0., 0.],

254. [0., 0., 0.]],

256. [[0., 0., 0.],

257. [0., 0., 0.],

258. [0., 0., 0.],

259. [0., 0., 0.],

260. [0., 0., 0.],

261. [0., 0., 0.],

262. [0., 0., 0.],

263. [0., 0., 0.],

264. [0., 0., 0.],

265. [0., 0., 0.],

266. [0., 0., 0.],

267. [0., 0., 0.],

268. [0., 0., 0.],

269. [0., 0., 0.],

270. [0., 0., 0.],

271. [0., 0., 0.]]], grad_fn=<ViewBackward>),

272. torch.Size([16, 16, 3]))

1. relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()

2. relative_position_bias, relative_position_bias.shape

1. (tensor([[[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

2. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

3. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

4. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

5. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

6. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

7. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

8. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

9. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

10. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

11. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

12. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

13. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

14. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

15. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

16. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],

18. [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

19. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

20. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

21. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

22. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

23. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

24. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

25. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

26. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

27. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

28. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

29. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

30. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

31. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

32. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

33. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],

35. [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

36. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

37. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

38. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

39. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

40. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

41. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

42. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

43. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

44. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

45. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

46. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

47. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

48. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

49. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

50. [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]],

51. grad_fn=<CopyBackwards>),

52. torch.Size([3, 16, 16]))

        以上基本展示了相对位置编码和偏置的生成过程。

---

3.8 Swin Transformer Block ☆

3.8.1 Shift Window Attention

        基本的 Attention (W-MSA) 是在每个窗口下计算的，为更好地 和其他窗口交互信息，Swin Transformer 还引入了 移位窗口 (Shifted Window) 操作。

        左边是无重叠的 Basic Window Attention，而右边则是将窗口进行次对角线方向移位的 Shift Window Attention。可见移位后的窗口包含了原相邻窗口的元素，但也随之引入了 Window 个数增多的问题 —— 窗口由 4 个变成了 9 个。

        实现时，通过对特征图移位，并给 Attention 设置 Mask 来间接实现 Shift Window Attention (SW-MSA)。从而，在保持原 Window 数不变的情况下，使最后的计算结果等价。

         在代码中，通过 torch.roll 对特征图移位，如下所示：

         若要执行 reverse cyclic shift 只需将参数 shifts 设为对应的正数。

3.8.2 Attention Mask

        通过合理设置 Mask，可使 Shifted Window Attention (SW-MSA) 在与 Basic Window Attention (W-MSA) 窗口个数相同的情况下，达到等价的计算结果。

        首先，对 Shift Window 后的每个窗口都赋予 index，并执行 roll 操作 (window_size=2, shift_size=1)，如下所示：

        在计算 Attention Map 时，希望 仅留下具有相同 index 的 Query 和 Key 的计算结果，而 忽略不同 index 的 Query 和 Key 的计算结果，如下所示：

        注意，Value 和 Query 的 shape 一致 (4×1)，以上方法计算的 shape = (4×4) 的 QK 乃至 Attention Map 与 Value 相乘时，依然能够得到正确位置的运算结果，即 (4×4) · (4×1) = (4×1)。

        而若要在原始的四个窗口下得到正确计算结果，则必须给 Attention Map 加入一个 Mask (如上图灰色 patch)，相关代码如下：

1. if self.shift_size > 0:

2. # calculate attention mask for SW-MSA

3. H, W = self.input_resolution

4. img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1

5. h_slices = (slice(0, -self.window_size),

6. slice(-self.window_size, -self.shift_size),

7. slice(-self.shift_size, None))

8. w_slices = (slice(0, -self.window_size),

9. slice(-self.window_size, -self.shift_size),

10. slice(-self.shift_size, None))

11. cnt = 0

12. for h in h_slices:

13. for w in w_slices:

14. img_mask[:, h, w, :] = cnt

15. cnt += 1

17. mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1

18. mask_windows = mask_windows.view(-1, self.window_size * self.window_size)

19. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)

20. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))

        以上图设置，使用上述代码将得到如下的 mask：

1. tensor([[[[[ 0., 0., 0., 0.],

2. [ 0., 0., 0., 0.],

3. [ 0., 0., 0., 0.],

4. [ 0., 0., 0., 0.]]],

7. [[[ 0., -100., 0., -100.],

8. [-100., 0., -100., 0.],

9. [ 0., -100., 0., -100.],

10. [-100., 0., -100., 0.]]],

13. [[[ 0., 0., -100., -100.],

14. [ 0., 0., -100., -100.],

15. [-100., -100., 0., 0.],

16. [-100., -100., 0., 0.]]],

19. [[[ 0., -100., -100., -100.],

20. [-100., 0., -100., -100.],

21. [-100., -100., 0., -100.],

22. [-100., -100., -100., 0.]]]]])

        在 Window Attention 模块的前向过程代码中，包含一段：

1. if mask is not None:

2. nW = mask.shape[0]

3. attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)

4. attn = attn.view(-1, self.num_heads, N, N)

5. attn = self.softmax(attn)

        其将值设为 -100 的 mask 直接加到 Attention Map 上，并在 reshape 后通过 Softmax 近似忽略之。

        最后是 Swin Transformer Block 示意图及其代码：

1. class SwinTransformerBlock(nn.Module):

2. r""" Swin Transformer Block.

3. Args:

4. dim (int): Number of input channels.

5. input_resolution (tuple[int]): Input resulotion.

6. num_heads (int): Number of attention heads.

7. window_size (int): Window size.

8. shift_size (int): Shift size for SW-MSA.

9. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.

10. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True

11. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.

12. drop (float, optional): Dropout rate. Default: 0.0

13. attn_drop (float, optional): Attention dropout rate. Default: 0.0

14. drop_path (float, optional): Stochastic depth rate. Default: 0.0

15. act_layer (nn.Module, optional): Activation layer. Default: nn.GELU

16. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm

17. """

19. def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,

20. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,

21. act_layer=nn.GELU, norm_layer=nn.LayerNorm):

22. super().__init__()

23. self.dim = dim

24. self.input_resolution = input_resolution

25. self.num_heads = num_heads

26. self.window_size = window_size

27. self.shift_size = shift_size

28. self.mlp_ratio = mlp_ratio

29. if min(self.input_resolution) <= self.window_size:

30. # if window size is larger than input resolution, we don't partition windows

31. self.shift_size = 0

32. self.window_size = min(self.input_resolution)

33. assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"

35. self.norm1 = norm_layer(dim)

36. self.attn = WindowAttention(

37. dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,

38. qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)

40. self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()

41. self.norm2 = norm_layer(dim)

42. mlp_hidden_dim = int(dim * mlp_ratio)

43. self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)

45. ##################### 循环移位局部窗口自注意力 #####################

46. if self.shift_size > 0:

47. # calculate attention mask for SW-MSA

48. H, W = self.input_resolution

49. img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1

50. h_slices = (slice(0, -self.window_size),

51. slice(-self.window_size, -self.shift_size),

52. slice(-self.shift_size, None))

53. w_slices = (slice(0, -self.window_size),

54. slice(-self.window_size, -self.shift_size),

55. slice(-self.shift_size, None))

56. cnt = 0

57. for h in h_slices:

58. for w in w_slices:

59. img_mask[:, h, w, :] = cnt

60. cnt += 1

62. mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1

63. mask_windows = mask_windows.view(-1, self.window_size * self.window_size)

64. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)

65. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))

66. else:

67. attn_mask = None

69. self.register_buffer("attn_mask", attn_mask)

71. def forward(self, x):

72. H, W = self.input_resolution

73. B, L, C = x.shape

74. assert L == H * W, "input feature has wrong size"

76. shortcut = x

77. x = self.norm1(x)

78. x = x.view(B, H, W, C)

80. # cyclic shift

81. if self.shift_size > 0:

82. shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))

83. else:

84. shifted_x = x

86. # partition windows

87. x_windows = window_partition(shifted_x, self.window_size) # nW*B, window_size, window_size, C

88. x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C

90. # W-MSA/SW-MSA

91. attn_windows = self.attn(x_windows, mask=self.attn_mask) # nW*B, window_size*window_size, C

93. # merge windows

94. attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)

95. shifted_x = window_reverse(attn_windows, self.window_size, H, W) # B H' W' C

97. # reverse cyclic shift

98. if self.shift_size > 0:

99. x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))

100. else:

101. x = shifted_x

102. x = x.view(B, H * W, C)

104. # FFN

105. x = shortcut + self.drop_path(x)

106. x = x + self.drop_path(self.mlp(self.norm2(x)))

108. return x

110. def extra_repr(self) -> str:

111. return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \

112. f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"

114. def flops(self):

115. flops = 0

116. H, W = self.input_resolution

117. # norm1

118. flops += self.dim * H * W

119. # W-MSA/SW-MSA

120. nW = H * W / self.window_size / self.window_size

121. flops += nW * self.attn.flops(self.window_size * self.window_size)

122. # mlp

123. flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio

124. # norm2

125. flops += self.dim * H * W

126. return flops

         举例模拟说明:

1. def window_partition(x, window_size):

2. """

3. Args:

4. x: (B, H, W, C)

5. window_size (int): window size - 通常默认 wh = ww = w = 4

7. Returns:

8. windows: (num_windows*B, window_size, window_size, C)

9. """

10. # (B, H, W, C) -> (B, H//wh, wh, W//ww, ww, C) -> (B, H//wh, W//ww, wh, ww, C) -> ((B*H*W)//(wh*ww), wh, ww, C)

11. B, H, W, C = x.shape

12. #print(x.shape)

13. x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)

14. #print(x.shape)

15. windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)

16. return windows # ((B*H*W)//(wh*ww), wh, ww, C) = (N, wh, ww, C)

19. def window_reverse(windows, window_size, H, W):

20. """

21. Args:

22. windows: (num_windows*B, window_size, window_size, C)

23. window_size (int): Window size - 通常默认 wh = ww = w = 4

24. H (int): Height of image

25. W (int): Width of image

27. Returns:

28. x: (B, H, W, C)

29. """

30. # ((B*H*W)//(wh*ww), w, w, C) -> (B, H//wh, W//ww, wh, ww, C) -> (B, H//wh, wh, W//ww, ww, C) -> (B, H, W, C)

31. B = int(windows.shape[0] / (H * W / window_size / window_size))

32. x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)

33. x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)

34. return x

1. batch_size = 1

2. num_channel = 3

3. input_resolution = (8, 8)

4. image = torch.rand(batch_size, num_channel, input_resolution[0], input_resolution[1])

5. image.shape

torch.Size([1, 3, 8, 8])

1. # local window 的 size 完全由 window_size 和 shift_size 两种长度的组合构成

2. window_size = 4

3. shift_size = window_size // 2 # 2

5. # calculate attention mask for SW-MSA

6. H, W = input_resolution

7. img_mask = torch.zeros((1, H, W, 1)) # (1, H, W, 1)

9. # local window index range

10. h_slices = (slice(0, -window_size),

11. slice(-window_size, -shift_size),

12. slice(-shift_size, None))

13. w_slices = (slice(0, -window_size),

14. slice(-window_size, -shift_size),

15. slice(-shift_size, None))

17. # 按 local window 标记 idx (即 cnt)

18. idx = 0

19. for h in h_slices:

20. for w in w_slices:

21. print(h, w, idx)

22. img_mask[:, h, w, :] = idx

23. idx += 1

25. print(f"num local windows: {idx}")

26. img_mask.shape, img_mask[0, ..., 0]

1. slice(0, -4, None) slice(0, -4, None) 0

2. slice(0, -4, None) slice(-4, -2, None) 1

3. slice(0, -4, None) slice(-2, None, None) 2

4. slice(-4, -2, None) slice(0, -4, None) 3

5. slice(-4, -2, None) slice(-4, -2, None) 4

6. slice(-4, -2, None) slice(-2, None, None) 5

7. slice(-2, None, None) slice(0, -4, None) 6

8. slice(-2, None, None) slice(-4, -2, None) 7

9. slice(-2, None, None) slice(-2, None, None) 8

10. num local windows: 9

12. (torch.Size([1, 8, 8, 1]),

13. tensor([[0., 0., 0., 0., 1., 1., 2., 2.],

14. [0., 0., 0., 0., 1., 1., 2., 2.],

15. [0., 0., 0., 0., 1., 1., 2., 2.],

16. [0., 0., 0., 0., 1., 1., 2., 2.],

17. [3., 3., 3., 3., 4., 4., 5., 5.],

18. [3., 3., 3., 3., 4., 4., 5., 5.],

19. [6., 6., 6., 6., 7., 7., 8., 8.],

20. [6., 6., 6., 6., 7., 7., 8., 8.]]))

1. # (1, 8, 8, 1) = (1, H, W, 1) = (B, H, W, C) -> ((B*H*W)//(wh*ww), wh, ww, C) = (N, wh, ww, C) = (4, 4, 4, 1)

2. mask_windows = window_partition(img_mask, window_size)

3. mask_windows.shape, mask_windows[..., 0]

1. (torch.Size([4, 4, 4, 1]),

2. tensor([[[0., 0., 0., 0.],

3. [0., 0., 0., 0.],

4. [0., 0., 0., 0.],

5. [0., 0., 0., 0.]],

7. [[1., 1., 2., 2.],

8. [1., 1., 2., 2.],

9. [1., 1., 2., 2.],

10. [1., 1., 2., 2.]],

12. [[3., 3., 3., 3.],

13. [3., 3., 3., 3.],

14. [6., 6., 6., 6.],

15. [6., 6., 6., 6.]],

17. [[4., 4., 5., 5.],

18. [4., 4., 5., 5.],

19. [7., 7., 8., 8.],

20. [7., 7., 8., 8.]]]))

1. mask_windows = mask_windows.view(-1, window_size * window_size)

2. mask_windows.shape, mask_windows

1. (torch.Size([4, 16]),

2. tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],

3. [1., 1., 2., 2., 1., 1., 2., 2., 1., 1., 2., 2., 1., 1., 2., 2.],

4. [3., 3., 3., 3., 3., 3., 3., 3., 6., 6., 6., 6., 6., 6., 6., 6.],

5. [4., 4., 5., 5., 4., 4., 5., 5., 7., 7., 8., 8., 7., 7., 8., 8.]]))

1. attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)

2. attn_mask.shape, attn_mask[..., 0]

1. (torch.Size([4, 4, 4, 4, 1]),

2. tensor([[[[ 0., 0., 0., 0.],

3. [ 0., 0., 0., 0.],

4. [ 0., 0., 0., 0.],

5. [ 0., 0., 0., 0.]],

7. [[ 0., 0., 0., 0.],

8. [ 0., 0., 0., 0.],

9. [ 0., 0., 0., 0.],

10. [ 0., 0., 0., 0.]],

12. [[ 0., 0., 0., 0.],

13. [ 0., 0., 0., 0.],

14. [ 0., 0., 0., 0.],

15. [ 0., 0., 0., 0.]],

17. [[ 0., 0., 0., 0.],

18. [ 0., 0., 0., 0.],

19. [ 0., 0., 0., 0.],

20. [ 0., 0., 0., 0.]]],

23. [[[ 0., 0., 0., 0.],

24. [ 0., 0., 0., 0.],

25. [ 0., 0., 0., 0.],

26. [ 0., 0., 0., 0.]],

28. [[ 0., 0., 0., 0.],

29. [ 0., 0., 0., 0.],

30. [ 0., 0., 0., 0.],

31. [ 0., 0., 0., 0.]],

33. [[ 0., 0., 0., 0.],

34. [ 0., 0., 0., 0.],

35. [ 0., 0., 0., 0.],

36. [ 0., 0., 0., 0.]],

38. [[ 0., 0., 0., 0.],

39. [ 0., 0., 0., 0.],

40. [ 0., 0., 0., 0.],

41. [ 0., 0., 0., 0.]]],

44. [[[ 0., 0., 0., 0.],

45. [ 0., 0., 0., 0.],

46. [ 3., 3., 3., 3.],

47. [ 3., 3., 3., 3.]],

49. [[ 0., 0., 0., 0.],

50. [ 0., 0., 0., 0.],

51. [ 3., 3., 3., 3.],

52. [ 3., 3., 3., 3.]],

54. [[-3., -3., -3., -3.],

55. [-3., -3., -3., -3.],

56. [ 0., 0., 0., 0.],

57. [ 0., 0., 0., 0.]],

59. [[-3., -3., -3., -3.],

60. [-3., -3., -3., -3.],

61. [ 0., 0., 0., 0.],

62. [ 0., 0., 0., 0.]]],

65. [[[ 0., 0., 0., 0.],

66. [ 0., 0., 0., 0.],

67. [ 3., 3., 3., 3.],

68. [ 3., 3., 3., 3.]],

70. [[ 0., 0., 0., 0.],

71. [ 0., 0., 0., 0.],

72. [ 3., 3., 3., 3.],

73. [ 3., 3., 3., 3.]],

75. [[-3., -3., -3., -3.],

76. [-3., -3., -3., -3.],

77. [ 0., 0., 0., 0.],

78. [ 0., 0., 0., 0.]],

80. [[-3., -3., -3., -3.],

81. [-3., -3., -3., -3.],

82. [ 0., 0., 0., 0.],

83. [ 0., 0., 0., 0.]]]]))

1. attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))

2. attn_mask.shape, attn_mask[..., 0]

1. (torch.Size([4, 4, 4, 4, 1]),

2. tensor([[[[ 0., 0., 0., 0.],

3. [ 0., 0., 0., 0.],

4. [ 0., 0., 0., 0.],

5. [ 0., 0., 0., 0.]],

7. [[ 0., 0., 0., 0.],

8. [ 0., 0., 0., 0.],

9. [ 0., 0., 0., 0.],

10. [ 0., 0., 0., 0.]],

12. [[ 0., 0., 0., 0.],

13. [ 0., 0., 0., 0.],

14. [ 0., 0., 0., 0.],

15. [ 0., 0., 0., 0.]],

17. [[ 0., 0., 0., 0.],

18. [ 0., 0., 0., 0.],

19. [ 0., 0., 0., 0.],

20. [ 0., 0., 0., 0.]]],

23. [[[ 0., 0., 0., 0.],

24. [ 0., 0., 0., 0.],

25. [ 0., 0., 0., 0.],

26. [ 0., 0., 0., 0.]],

28. [[ 0., 0., 0., 0.],

29. [ 0., 0., 0., 0.],

30. [ 0., 0., 0., 0.],

31. [ 0., 0., 0., 0.]],

33. [[ 0., 0., 0., 0.],

34. [ 0., 0., 0., 0.],

35. [ 0., 0., 0., 0.],

36. [ 0., 0., 0., 0.]],

38. [[ 0., 0., 0., 0.],

39. [ 0., 0., 0., 0.],

40. [ 0., 0., 0., 0.],

41. [ 0., 0., 0., 0.]]],

44. [[[ 0., 0., 0., 0.],

45. [ 0., 0., 0., 0.],

46. [-100., -100., -100., -100.],

47. [-100., -100., -100., -100.]],

49. [[ 0., 0., 0., 0.],

50. [ 0., 0., 0., 0.],

51. [-100., -100., -100., -100.],

52. [-100., -100., -100., -100.]],

54. [[-100., -100., -100., -100.],

55. [-100., -100., -100., -100.],

56. [ 0., 0., 0., 0.],

57. [ 0., 0., 0., 0.]],

59. [[-100., -100., -100., -100.],

60. [-100., -100., -100., -100.],

61. [ 0., 0., 0., 0.],

62. [ 0., 0., 0., 0.]]],

65. [[[ 0., 0., 0., 0.],

66. [ 0., 0., 0., 0.],

67. [-100., -100., -100., -100.],

68. [-100., -100., -100., -100.]],

70. [[ 0., 0., 0., 0.],

71. [ 0., 0., 0., 0.],

72. [-100., -100., -100., -100.],

73. [-100., -100., -100., -100.]],

75. [[-100., -100., -100., -100.],

76. [-100., -100., -100., -100.],

77. [ 0., 0., 0., 0.],

78. [ 0., 0., 0., 0.]],

80. [[-100., -100., -100., -100.],

81. [-100., -100., -100., -100.],

82. [ 0., 0., 0., 0.],

83. [ 0., 0., 0., 0.]]]]))

1. x = image.clone().permute(0, 2, 3, 1) # (B, H, W, C)

2. B, H, W, C = x.shape

3. x[0, 0, 0, 0] = 0. # 用于标记

4. x[0, -1, -1, -1] = 1. # 用于标记

5. x.shape, x[..., 0], x[..., 1], x[..., 2]

1. (torch.Size([1, 8, 8, 3]),

2. tensor([[[0.0000, 0.1060, 0.1015, 0.2196, 0.3544, 0.8485, 0.3509, 0.7353],

3. [0.3751, 0.5690, 0.9630, 0.1945, 0.8999, 0.4977, 0.8007, 0.1598],

4. [0.1991, 0.0081, 0.2861, 0.4539, 0.1620, 0.8776, 0.5298, 0.3748],

5. [0.8627, 0.0345, 0.2435, 0.7224, 0.9310, 0.8621, 0.4113, 0.8057],

6. [0.4686, 0.3372, 0.3429, 0.6660, 0.7115, 0.8560, 0.7055, 0.4709],

7. [0.5104, 0.2789, 0.8015, 0.8737, 0.6784, 0.6677, 0.8233, 0.6589],

8. [0.9013, 0.6980, 0.1548, 0.9066, 0.0334, 0.1617, 0.2747, 0.6150],

9. [0.6927, 0.0394, 0.4180, 0.0387, 0.4488, 0.1339, 0.3340, 0.6178]]]),

10. tensor([[[0.6409, 0.0384, 0.7775, 0.3550, 0.6754, 0.9210, 0.0923, 0.0691],

11. [0.7684, 0.0422, 0.1605, 0.9409, 0.0397, 0.7786, 0.8475, 0.8495],

12. [0.3684, 0.9283, 0.0569, 0.7790, 0.6074, 0.1229, 0.3138, 0.5926],

13. [0.1865, 0.5766, 0.2497, 0.2391, 0.4254, 0.7249, 0.3116, 0.1666],

14. [0.0800, 0.3956, 0.7351, 0.8919, 0.1177, 0.7949, 0.0028, 0.2635],

15. [0.9967, 0.1205, 0.1785, 0.0886, 0.8664, 0.8412, 0.1258, 0.4302],

16. [0.5620, 0.9326, 0.6767, 0.2432, 0.5963, 0.7276, 0.2273, 0.4879],

17. [0.9367, 0.9096, 0.8327, 0.1795, 0.0361, 0.7189, 0.9292, 0.3822]]]),

18. tensor([[[0.8273, 0.7008, 0.2891, 0.1136, 0.4981, 0.2119, 0.8096, 0.6342],

19. [0.0062, 0.8495, 0.1382, 0.8667, 0.2436, 0.6408, 0.0238, 0.4742],

20. [0.4363, 0.1852, 0.6110, 0.2923, 0.6231, 0.0668, 0.9430, 0.2830],

21. [0.5139, 0.5424, 0.3008, 0.5251, 0.3518, 0.0882, 0.3335, 0.7853],

22. [0.4835, 0.3571, 0.2530, 0.8452, 0.2010, 0.3866, 0.5673, 0.1172],

23. [0.4750, 0.7820, 0.4262, 0.4426, 0.4161, 0.1199, 0.0477, 0.4646],

24. [0.7525, 0.2686, 0.6829, 0.6753, 0.4345, 0.6609, 0.8414, 0.9140],

25. [0.4540, 0.7455, 0.4464, 0.6749, 0.9152, 0.6936, 0.7035, 1.0000]]]))

1. # 可见标记 0.0000 和 1.0000 都在自身所在的 channel 里向左上角循环位移了 shift_size = window_size // 2 = 2 个 pixels

2. shifted_x = torch.roll(x, shifts=(-shift_size, -shift_size), dims=(1, 2)) # (B, H, W, C)

3. shifted_x.shape, shifted_x[..., 0], shifted_x[..., 1], shifted_x[..., 2]

1. (torch.Size([1, 8, 8, 3]),

2. tensor([[[0.2861, 0.4539, 0.1620, 0.8776, 0.5298, 0.3748, 0.1991, 0.0081],

3. [0.2435, 0.7224, 0.9310, 0.8621, 0.4113, 0.8057, 0.8627, 0.0345],

4. [0.3429, 0.6660, 0.7115, 0.8560, 0.7055, 0.4709, 0.4686, 0.3372],

5. [0.8015, 0.8737, 0.6784, 0.6677, 0.8233, 0.6589, 0.5104, 0.2789],

6. [0.1548, 0.9066, 0.0334, 0.1617, 0.2747, 0.6150, 0.9013, 0.6980],

7. [0.4180, 0.0387, 0.4488, 0.1339, 0.3340, 0.6178, 0.6927, 0.0394],

8. [0.1015, 0.2196, 0.3544, 0.8485, 0.3509, 0.7353, 0.0000, 0.1060],

9. [0.9630, 0.1945, 0.8999, 0.4977, 0.8007, 0.1598, 0.3751, 0.5690]]]),

10. tensor([[[0.0569, 0.7790, 0.6074, 0.1229, 0.3138, 0.5926, 0.3684, 0.9283],

11. [0.2497, 0.2391, 0.4254, 0.7249, 0.3116, 0.1666, 0.1865, 0.5766],

12. [0.7351, 0.8919, 0.1177, 0.7949, 0.0028, 0.2635, 0.0800, 0.3956],

13. [0.1785, 0.0886, 0.8664, 0.8412, 0.1258, 0.4302, 0.9967, 0.1205],

14. [0.6767, 0.2432, 0.5963, 0.7276, 0.2273, 0.4879, 0.5620, 0.9326],

15. [0.8327, 0.1795, 0.0361, 0.7189, 0.9292, 0.3822, 0.9367, 0.9096],

16. [0.7775, 0.3550, 0.6754, 0.9210, 0.0923, 0.0691, 0.6409, 0.0384],

17. [0.1605, 0.9409, 0.0397, 0.7786, 0.8475, 0.8495, 0.7684, 0.0422]]]),

18. tensor([[[0.6110, 0.2923, 0.6231, 0.0668, 0.9430, 0.2830, 0.4363, 0.1852],

19. [0.3008, 0.5251, 0.3518, 0.0882, 0.3335, 0.7853, 0.5139, 0.5424],

20. [0.2530, 0.8452, 0.2010, 0.3866, 0.5673, 0.1172, 0.4835, 0.3571],

21. [0.4262, 0.4426, 0.4161, 0.1199, 0.0477, 0.4646, 0.4750, 0.7820],

22. [0.6829, 0.6753, 0.4345, 0.6609, 0.8414, 0.9140, 0.7525, 0.2686],

23. [0.4464, 0.6749, 0.9152, 0.6936, 0.7035, 1.0000, 0.4540, 0.7455],

24. [0.2891, 0.1136, 0.4981, 0.2119, 0.8096, 0.6342, 0.8273, 0.7008],

25. [0.1382, 0.8667, 0.2436, 0.6408, 0.0238, 0.4742, 0.0062, 0.8495]]]))

1. x_windows = window_partition(shifted_x, window_size) # (B*N, wh, ww, C) = (B*(H*W)//(wh*ww), wh, ww, C)

2. x_windows.shape, x_windows[..., 0], x_windows[..., 1], x_windows[..., 2]

1. (torch.Size([4, 4, 4, 3]),

2. tensor([[[0.2861, 0.4539, 0.1620, 0.8776],

3. [0.2435, 0.7224, 0.9310, 0.8621],

4. [0.3429, 0.6660, 0.7115, 0.8560],

5. [0.8015, 0.8737, 0.6784, 0.6677]],

7. [[0.5298, 0.3748, 0.1991, 0.0081],

8. [0.4113, 0.8057, 0.8627, 0.0345],

9. [0.7055, 0.4709, 0.4686, 0.3372],

10. [0.8233, 0.6589, 0.5104, 0.2789]],

12. [[0.1548, 0.9066, 0.0334, 0.1617],

13. [0.4180, 0.0387, 0.4488, 0.1339],

14. [0.1015, 0.2196, 0.3544, 0.8485],

15. [0.9630, 0.1945, 0.8999, 0.4977]],

17. [[0.2747, 0.6150, 0.9013, 0.6980],

18. [0.3340, 0.6178, 0.6927, 0.0394],

19. [0.3509, 0.7353, 0.0000, 0.1060],

20. [0.8007, 0.1598, 0.3751, 0.5690]]]),

21. tensor([[[0.0569, 0.7790, 0.6074, 0.1229],

22. [0.2497, 0.2391, 0.4254, 0.7249],

23. [0.7351, 0.8919, 0.1177, 0.7949],

24. [0.1785, 0.0886, 0.8664, 0.8412]],

26. [[0.3138, 0.5926, 0.3684, 0.9283],

27. [0.3116, 0.1666, 0.1865, 0.5766],

28. [0.0028, 0.2635, 0.0800, 0.3956],

29. [0.1258, 0.4302, 0.9967, 0.1205]],

31. [[0.6767, 0.2432, 0.5963, 0.7276],

32. [0.8327, 0.1795, 0.0361, 0.7189],

33. [0.7775, 0.3550, 0.6754, 0.9210],

34. [0.1605, 0.9409, 0.0397, 0.7786]],

36. [[0.2273, 0.4879, 0.5620, 0.9326],

37. [0.9292, 0.3822, 0.9367, 0.9096],

38. [0.0923, 0.0691, 0.6409, 0.0384],

39. [0.8475, 0.8495, 0.7684, 0.0422]]]),

40. tensor([[[0.6110, 0.2923, 0.6231, 0.0668],

41. [0.3008, 0.5251, 0.3518, 0.0882],

42. [0.2530, 0.8452, 0.2010, 0.3866],

43. [0.4262, 0.4426, 0.4161, 0.1199]],

45. [[0.9430, 0.2830, 0.4363, 0.1852],

46. [0.3335, 0.7853, 0.5139, 0.5424],

47. [0.5673, 0.1172, 0.4835, 0.3571],

48. [0.0477, 0.4646, 0.4750, 0.7820]],

50. [[0.6829, 0.6753, 0.4345, 0.6609],

51. [0.4464, 0.6749, 0.9152, 0.6936],

52. [0.2891, 0.1136, 0.4981, 0.2119],

53. [0.1382, 0.8667, 0.2436, 0.6408]],

55. [[0.8414, 0.9140, 0.7525, 0.2686],

56. [0.7035, 1.0000, 0.4540, 0.7455],

57. [0.8096, 0.6342, 0.8273, 0.7008],

58. [0.0238, 0.4742, 0.0062, 0.8495]]]))

1. x_windows = x_windows.view(-1, window_size * window_size, C) # (B*N, wh*ww, C) = (B*(H*W)//(wh*ww), wh*ww, C)

2. x_windows.shape, x_windows[..., 0], x_windows[..., 1], x_windows[..., 2]

1. (torch.Size([4, 16, 3]),

2. tensor([[0.2861, 0.4539, 0.1620, 0.8776, 0.2435, 0.7224, 0.9310, 0.8621, 0.3429,

3. 0.6660, 0.7115, 0.8560, 0.8015, 0.8737, 0.6784, 0.6677],

4. [0.5298, 0.3748, 0.1991, 0.0081, 0.4113, 0.8057, 0.8627, 0.0345, 0.7055,

5. 0.4709, 0.4686, 0.3372, 0.8233, 0.6589, 0.5104, 0.2789],

6. [0.1548, 0.9066, 0.0334, 0.1617, 0.4180, 0.0387, 0.4488, 0.1339, 0.1015,

7. 0.2196, 0.3544, 0.8485, 0.9630, 0.1945, 0.8999, 0.4977],

8. [0.2747, 0.6150, 0.9013, 0.6980, 0.3340, 0.6178, 0.6927, 0.0394, 0.3509,

9. 0.7353, 0.0000, 0.1060, 0.8007, 0.1598, 0.3751, 0.5690]]),

10. tensor([[0.0569, 0.7790, 0.6074, 0.1229, 0.2497, 0.2391, 0.4254, 0.7249, 0.7351,

11. 0.8919, 0.1177, 0.7949, 0.1785, 0.0886, 0.8664, 0.8412],

12. [0.3138, 0.5926, 0.3684, 0.9283, 0.3116, 0.1666, 0.1865, 0.5766, 0.0028,

13. 0.2635, 0.0800, 0.3956, 0.1258, 0.4302, 0.9967, 0.1205],

14. [0.6767, 0.2432, 0.5963, 0.7276, 0.8327, 0.1795, 0.0361, 0.7189, 0.7775,

15. 0.3550, 0.6754, 0.9210, 0.1605, 0.9409, 0.0397, 0.7786],

16. [0.2273, 0.4879, 0.5620, 0.9326, 0.9292, 0.3822, 0.9367, 0.9096, 0.0923,

17. 0.0691, 0.6409, 0.0384, 0.8475, 0.8495, 0.7684, 0.0422]]),

18. tensor([[0.6110, 0.2923, 0.6231, 0.0668, 0.3008, 0.5251, 0.3518, 0.0882, 0.2530,

19. 0.8452, 0.2010, 0.3866, 0.4262, 0.4426, 0.4161, 0.1199],

20. [0.9430, 0.2830, 0.4363, 0.1852, 0.3335, 0.7853, 0.5139, 0.5424, 0.5673,

21. 0.1172, 0.4835, 0.3571, 0.0477, 0.4646, 0.4750, 0.7820],

22. [0.6829, 0.6753, 0.4345, 0.6609, 0.4464, 0.6749, 0.9152, 0.6936, 0.2891,

23. 0.1136, 0.4981, 0.2119, 0.1382, 0.8667, 0.2436, 0.6408],

24. [0.8414, 0.9140, 0.7525, 0.2686, 0.7035, 1.0000, 0.4540, 0.7455, 0.8096,

25. 0.6342, 0.8273, 0.7008, 0.0238, 0.4742, 0.0062, 0.8495]]))

1. # W-MSA/SW-MSA

2. #attn_windows = self.attn(x_windows, mask=self.attn_mask) # 原操作 (B*N, wh*ww, C) = (B*(H*W)//(wh*ww), wh*ww, C)

3. attn_windows = x_windows.clone() # 仅用于示范

5. # merge windows

6. attn_windows = attn_windows.view(-1, window_size, window_size, C)

7. attn_windows.shape

torch.Size([4, 4, 4, 3])

1. # reverse cyclic shift

2. shifted_x = window_reverse(attn_windows, window_size, H, W)

3. shifted_x.shape, shifted_x[..., 0], shifted_x[..., 1], shifted_x[..., 2]

1. (torch.Size([1, 8, 8, 3]),

2. tensor([[[0.2861, 0.4539, 0.1620, 0.8776, 0.5298, 0.3748, 0.1991, 0.0081],

3. [0.2435, 0.7224, 0.9310, 0.8621, 0.4113, 0.8057, 0.8627, 0.0345],

4. [0.3429, 0.6660, 0.7115, 0.8560, 0.7055, 0.4709, 0.4686, 0.3372],

5. [0.8015, 0.8737, 0.6784, 0.6677, 0.8233, 0.6589, 0.5104, 0.2789],

6. [0.1548, 0.9066, 0.0334, 0.1617, 0.2747, 0.6150, 0.9013, 0.6980],

7. [0.4180, 0.0387, 0.4488, 0.1339, 0.3340, 0.6178, 0.6927, 0.0394],

8. [0.1015, 0.2196, 0.3544, 0.8485, 0.3509, 0.7353, 0.0000, 0.1060],

9. [0.9630, 0.1945, 0.8999, 0.4977, 0.8007, 0.1598, 0.3751, 0.5690]]]),

10. tensor([[[0.0569, 0.7790, 0.6074, 0.1229, 0.3138, 0.5926, 0.3684, 0.9283],

11. [0.2497, 0.2391, 0.4254, 0.7249, 0.3116, 0.1666, 0.1865, 0.5766],

12. [0.7351, 0.8919, 0.1177, 0.7949, 0.0028, 0.2635, 0.0800, 0.3956],

13. [0.1785, 0.0886, 0.8664, 0.8412, 0.1258, 0.4302, 0.9967, 0.1205],

14. [0.6767, 0.2432, 0.5963, 0.7276, 0.2273, 0.4879, 0.5620, 0.9326],

15. [0.8327, 0.1795, 0.0361, 0.7189, 0.9292, 0.3822, 0.9367, 0.9096],

16. [0.7775, 0.3550, 0.6754, 0.9210, 0.0923, 0.0691, 0.6409, 0.0384],

17. [0.1605, 0.9409, 0.0397, 0.7786, 0.8475, 0.8495, 0.7684, 0.0422]]]),

18. tensor([[[0.6110, 0.2923, 0.6231, 0.0668, 0.9430, 0.2830, 0.4363, 0.1852],

19. [0.3008, 0.5251, 0.3518, 0.0882, 0.3335, 0.7853, 0.5139, 0.5424],

20. [0.2530, 0.8452, 0.2010, 0.3866, 0.5673, 0.1172, 0.4835, 0.3571],

21. [0.4262, 0.4426, 0.4161, 0.1199, 0.0477, 0.4646, 0.4750, 0.7820],

22. [0.6829, 0.6753, 0.4345, 0.6609, 0.8414, 0.9140, 0.7525, 0.2686],

23. [0.4464, 0.6749, 0.9152, 0.6936, 0.7035, 1.0000, 0.4540, 0.7455],

24. [0.2891, 0.1136, 0.4981, 0.2119, 0.8096, 0.6342, 0.8273, 0.7008],

25. [0.1382, 0.8667, 0.2436, 0.6408, 0.0238, 0.4742, 0.0062, 0.8495]]]))

1. # 可见标记 0.0000 和 1.0000 都在自身所在的 channel 里向右下角循环位移了 shift_size = window_size // 2 = 2 个 pixels 回去了

2. x = torch.roll(shifted_x, shifts=(shift_size, shift_size), dims=(1, 2))

3. x.shape, x[..., 0], x[..., 1], x[..., 2]

1. (torch.Size([1, 8, 8, 3]),

2. tensor([[[0.0000, 0.1060, 0.1015, 0.2196, 0.3544, 0.8485, 0.3509, 0.7353],

3. [0.3751, 0.5690, 0.9630, 0.1945, 0.8999, 0.4977, 0.8007, 0.1598],

4. [0.1991, 0.0081, 0.2861, 0.4539, 0.1620, 0.8776, 0.5298, 0.3748],

5. [0.8627, 0.0345, 0.2435, 0.7224, 0.9310, 0.8621, 0.4113, 0.8057],

6. [0.4686, 0.3372, 0.3429, 0.6660, 0.7115, 0.8560, 0.7055, 0.4709],

7. [0.5104, 0.2789, 0.8015, 0.8737, 0.6784, 0.6677, 0.8233, 0.6589],

8. [0.9013, 0.6980, 0.1548, 0.9066, 0.0334, 0.1617, 0.2747, 0.6150],

9. [0.6927, 0.0394, 0.4180, 0.0387, 0.4488, 0.1339, 0.3340, 0.6178]]]),

10. tensor([[[0.6409, 0.0384, 0.7775, 0.3550, 0.6754, 0.9210, 0.0923, 0.0691],

11. [0.7684, 0.0422, 0.1605, 0.9409, 0.0397, 0.7786, 0.8475, 0.8495],

12. [0.3684, 0.9283, 0.0569, 0.7790, 0.6074, 0.1229, 0.3138, 0.5926],

13. [0.1865, 0.5766, 0.2497, 0.2391, 0.4254, 0.7249, 0.3116, 0.1666],

14. [0.0800, 0.3956, 0.7351, 0.8919, 0.1177, 0.7949, 0.0028, 0.2635],

15. [0.9967, 0.1205, 0.1785, 0.0886, 0.8664, 0.8412, 0.1258, 0.4302],

16. [0.5620, 0.9326, 0.6767, 0.2432, 0.5963, 0.7276, 0.2273, 0.4879],

17. [0.9367, 0.9096, 0.8327, 0.1795, 0.0361, 0.7189, 0.9292, 0.3822]]]),

18. tensor([[[0.8273, 0.7008, 0.2891, 0.1136, 0.4981, 0.2119, 0.8096, 0.6342],

19. [0.0062, 0.8495, 0.1382, 0.8667, 0.2436, 0.6408, 0.0238, 0.4742],

20. [0.4363, 0.1852, 0.6110, 0.2923, 0.6231, 0.0668, 0.9430, 0.2830],

21. [0.5139, 0.5424, 0.3008, 0.5251, 0.3518, 0.0882, 0.3335, 0.7853],

22. [0.4835, 0.3571, 0.2530, 0.8452, 0.2010, 0.3866, 0.5673, 0.1172],

23. [0.4750, 0.7820, 0.4262, 0.4426, 0.4161, 0.1199, 0.0477, 0.4646],

24. [0.7525, 0.2686, 0.6829, 0.6753, 0.4345, 0.6609, 0.8414, 0.9140],

25. [0.4540, 0.7455, 0.4464, 0.6749, 0.9152, 0.6936, 0.7035, 1.0000]]]))

1. x = x.view(B, H * W, C)

2. x.shape

torch.Size([1, 64, 3])

---

3.9 Basic Layer

        Basic Layer 即 Swin Transformer 的各 Stage，包含了若干 Swin Transformer Blocks 及 其他层。

        注意，一个 Stage 包含的 Swin Transformer Blocks 的个数必须是 偶数，因为需交替包含一个含有 Window Attention (W-MSA) 的 Layer 和含有 Shifted Window Attention (SW-MSA) 的 Layer。 

1. class BasicLayer(nn.Module):

2. """ A basic Swin Transformer layer for one stage.

3. Args:

4. dim (int): Number of input channels.

5. input_resolution (tuple[int]): Input resolution.

6. depth (int): Number of blocks.

7. num_heads (int): Number of attention heads.

8. window_size (int): Local window size.

9. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.

10. qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True

11. qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.

12. drop (float, optional): Dropout rate. Default: 0.0

13. attn_drop (float, optional): Attention dropout rate. Default: 0.0

14. drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0

15. norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm

16. downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None

17. use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.

18. """

19. def __init__(self, dim, input_resolution, depth, num_heads, window_size,

20. mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,

21. drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):

23. super().__init__()

24. self.dim = dim

25. self.input_resolution = input_resolution

26. self.depth = depth

27. self.use_checkpoint = use_checkpoint

29. # build blocks

30. self.blocks = nn.ModuleList([

31. SwinTransformerBlock(dim=dim, input_resolution=input_resolution,

32. num_heads=num_heads, window_size=window_size,

33. shift_size=0 if (i % 2 == 0) else window_size // 2,

34. mlp_ratio=mlp_ratio,

35. qkv_bias=qkv_bias, qk_scale=qk_scale,

36. drop=drop, attn_drop=attn_drop,

37. drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,

38. norm_layer=norm_layer)

39. for i in range(depth)])

41. # patch merging layer

42. if downsample is not None:

43. self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)

44. else:

45. self.downsample = None

47. def forward(self, x):

48. for blk in self.blocks:

49. if self.use_checkpoint:

50. x = checkpoint.checkpoint(blk, x)

51. else:

52. x = blk(x)

53. if self.downsample is not None:

54. x = self.downsample(x)

55. return x

57. def extra_repr(self) -> str:

58. return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"

60. def flops(self):

61. flops = 0

62. for blk in self.blocks:

63. flops += blk.flops()

64. if self.downsample is not None:

65. flops += self.downsample.flops()

66. return flops

原文链接：https://blog.csdn.net/qq_39478403/article/details/120042232