Swin Transformer模型解读（附源码+论文）

于 2025-02-27 10:00:00 发布
阅读量1.3k 收藏 13
点赞数 29
文章标签： transformer 深度学习 人工智能 pytorch 计算机视觉 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46677695/article/details/145886776
版权

Swin Transformer

论文链接：Swin Transformer: Hierarchical Vision Transformer using Shifted Windows

官方链接：Swin-Transformer

代码补充：Swin-Replenishment（因为官方给的代码我在win下单gpu运行会报错，所以我修改了一些代码使其能够运行）

总体流程

在深度学习的视觉任务中，都会先经过backbone提取图片的特征。优秀的backbone可以事半功倍。我学习过很多模型，它们用的backbone大部分都是ResNet（经典永不过时）。近几年也演化了一些新的backbone，比如EfficientNet（之前讲过，计算量较低且效果好）、VIT（之前讲过，基于Transformer的，不过计算量很大，后续有很多优化版本），而今天介绍的是Swin Transformer （据说效果吊打）。

在VIT中，会图像分割成固定大小的 Patch然后排成一个序列，然后通过计算全局自注意力，计算量巨大，遇到高分辨率图像直接跪下。其次，VIT采用固定的patch，因此无法适应多尺度特征。

Swin Transformer灵机一动，通过分层特征提取 和窗口自注意力机制 解决这些问题。分层特征提取如下图，在初始阶段将图片划分为很小的patch，然后逐步合并patch（相邻 Patch 合并，形成更大的感受野）。这样可以逐步降低分辨率，提取高层语义信息，同时减少计算量。

请添加图片描述

窗口自注意力机制 主要在Swin Transformer中，流程图如下，由Patch Embedding 、Swin Transformer Block 和 Patch Merging 组成。

请添加图片描述

Patch Embedding就是VIT里的核心步骤，将图片划分为固定大小的patch，然后通过一个卷积将每个 Patch 映射到固定维度的特征向量。假设输入的图像数据为(224,224,3)，通过一个卷积Conv2d(3,96,kernel_size(4,4),stride=(4,4))映射到一个序列(3136,96)。（注：96 是一个经验值，3136=224÷4×224÷4，kernel_size=patch_size，确保每个 Patch 的信息被映射到一个嵌入向量中，stride=patch_size，确保不重叠分割。）

Swin Transformer Block 是Swin Transformer里的核心步骤，如下图，它由W-MSA 和SW_MSA 组成。W表示窗口、SW表示滑动窗口。
请添加图片描述

首先对输入的特征图分成窗口，比如输入特征图(56,56,96)，窗口size为7，那么可以分成8×8个窗口，输出(64,7,7,96)。得到窗口后，计算每个窗口的注意力得分，那么就见到我们的老朋友qkv了。就是老规矩，先q@k，然后加上位置编码再@v，代码里详说，最终得到每个窗口的注意力得分。

这边就已经过完了W-MSA ，但是这个过程吧，窗口自己跟自己玩，不同窗口之间的一个关系没有体现出来。

问题：不同窗口之间的 token 无法直接通信，这限制了全局信息传播

| A  A  A | B  B  B | C  C  C |
| A  A  A | B  B  B | C  C  C |
| A  A  A | B  B  B | C  C  C |

因此作者后面又接了一个SW-MSA ，滑动窗口。让B参与A的窗口，C参与B的窗口，A参与C的窗口。但是这也有个问题啊，A和C之间并不是一个连续的位置关系。

问题：如果直接计算自注意力，模型可能会错误地学习跨窗口不连续的位置关系。

| A  A  B | B  B  C | C  C  A |
| A  A  B | B  B  C | C  C  A |
| A  A  B | B  B  C | C  C  A |

SW-MSA的流程如下图，本来四块窗口的通过滑动后被划分为了九个窗口。
请添加图片描述

图片位移后的结果如下。

请添加图片描述

计算时仍然按4个窗口计算，但是很显然除了左上那个4，其它三个窗口都存在不连续的位置关系。怎么办？那就不计算那些不连续的数据呗，用一个mask矩阵屏蔽原始窗口间的无效连接，如下图。
请添加图片描述

OK，Swin Transformer Block 部分结束 ，接下来进行Patch Merging 。Patch Merging就是进行一个下采样，而且画个图就能理解，过程非常简单，如下图。
请添加图片描述

对H和W维度进行建个采样后拼接在一起，每次操作后H和W减一半，C多一倍，如下图红色框。
请添加图片描述

代码

官网有很多例子可以用，如下图，学习的话可以选第一个图像分类任务做一下。
请添加图片描述

代码不讲基础的部分，直接进入models/swin_transformer.py讲网络模块。配置一下参数进入debug，configs下有很多网络配置，选一个自己喜欢的。–local_rank 0表示用单gpu，不过设不设置都无所谓，因为官方代码就不支持win单GPU运行，得自己改点代码才行。–data-path是自己数据的路径。

--cfg configs/swin/swin_tiny_patch4_window7_224.yaml
--batch-size 16
--local_rank 0
--data-path imagenet

SwinTransformer

首先呢，debug到SwinTransformer的forward_features方法。

def forward_features(self, x):  # (b,3,224,224)
    x = self.patch_embed(x)  # (b,3136,96)
    if self.ape:
        x = x + self.absolute_pos_embed
    x = self.pos_drop(x)

    for layer in self.layers:
        x = layer(x)

    x = self.norm(x)  # B L C (b,49,768)
    x = self.avgpool(x.transpose(1, 2))  # B C 1 (b,768,1)
    x = torch.flatten(x, 1)  # (b,768)
    return x

self.patch_embed没啥好说的，就是一个卷积将图片数据分patch然后排成一排，输入(b,3,224,224)输出(b,3136,96)。(注：3136=224÷4×224÷4，通道维度3转为96)
请添加图片描述

主要是下面的for循环，将经历W-MSA和SW-MSA。我们跳入SwinTransformerBlock的forward方法中。

W-MSA

代码中if self.shift_size > 0后面接的就是SW-MSA，else接的是W-MSA。

def forward(self, x):  # (b,3136,96)
    H, W = self.input_resolution
    B, L, C = x.shape
    assert L == H * W, "input feature has wrong size"

    shortcut = x
    x = self.norm1(x)
    x = x.view(B, H, W, C)  # (b,56,56,96)

    # cyclic shift
    if self.shift_size > 0:
        if not self.fused_window_process:
            # [[ 1,  2,  3,  4],                 [[ 6,  7,  8,  5],
            #  [ 5,  6,  7,  8],       ==>        [10, 11, 12,  9],
            #  [ 9, 10, 11, 12], shift_size = 1   [14, 15, 16, 13],
            #  [13, 14, 15, 16]]                  [ 2,  3,  4,  1]]
            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))  # 窗口滑动
            # partition windows
            x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
        else:
            x_windows = WindowProcess.apply(x, B, H, W, C, -self.shift_size, self.window_size)
    else:
        shifted_x = x
        # partition windows
        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, w_s, w_s, C (64×b,7,7,96)

    x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, w_s*w_s, C (64×b,49,96)

    # W-MSA/SW-MSA
    attn_windows = self.attn(x_windows, mask=self.attn_mask)  # nW*B, w_s*w_s, C (64×b,49,96)

    # merge windows
    attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)  # (64×b,7,7,96)

    # reverse cyclic shift
    if self.shift_size > 0:
        if not self.fused_window_process:
            shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))  # 窗口还原
        else:
            x = WindowProcessReverse.apply(attn_windows, B, H, W, C, self.shift_size, self.window_size)
    else:
        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C (b,56,56,96) 还原回去
        x = shifted_x
    x = x.view(B, H * W, C)  # (b,3136,96)
    x = shortcut + self.drop_path(x)

    # FFN
    x = x + self.drop_path(self.mlp(self.norm2(x)))

    return x

输入的size为(b,3136,96)，经过标准化后重新view为(b,56,56,96)。（注：56×56=3136）。第一步是W-MSA，所以先执行else后的代码，window_partition会将图像划分窗口，具体进入函数看一下。

window_partition

def window_partition(x, window_size):
    B, H, W, C = x.shape
    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)  # (b,8,7,8,7,96)
    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)  # (64×b,7,7,96)
    return windows  # 将原来56×56的窗口划分为为7×7的，然后排成一排

默认窗口size为7，现在输入的图像是56×56的，按7×7的窗口将划分8×8块窗口，最终输出(64×b,7,7,96)。

=======================================================================

回到SwinTransformerBlock的forward继续。

将刚刚划分好的窗口先重新view一下为(64×b,49,96)，然后带入到self.attn计算注意力分数，我们进入attn方法中看一下怎么个事。

WindowAttention

进入WindowAttention的forward方法中。

def forward(self, x, mask=None):
    B_, N, C = x.shape
    qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)  # (3,64×b,3,49,32)
    q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)

    q = q * self.scale  # 缩放Q 防止点积结果过大，保持数值稳定
    attn = (q @ k.transpose(-2, -1))  # k:(49,32)->(32,49) q·k->(49,49)

    relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(  # 位置编码
        self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
    relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
    attn = attn + relative_position_bias.unsqueeze(0)  # (64×b,3,49,49)

    if mask is not None:
        nW = mask.shape[0]
        attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
        attn = attn.view(-1, self.num_heads, N, N)
        attn = self.softmax(attn)
    else:
        attn = self.softmax(attn)

    attn = self.attn_drop(attn)

    x = (attn @ v).transpose(1, 2).reshape(B_, N, C)  # (b,3,49,49)·(b,3,49,32)->(b,3,49,32)->(b,49,3,32)->(b,49,96)
    x = self.proj(x)
    x = self.proj_drop(x)
    return x

现在输入的维度为(64×b,49,96)。这里qkv矩阵是直接通过一个线性变换self.qkv得到，self.num_heads注意力头默认为3，得到输出(3,64×b,3,49,32)。（注：3为qkv三个矩阵，3为注意力头，49=7×7窗口大小，32=96÷3每个head特征）

然后分别通过qkv[0], qkv[1], qkv[2]取得qkv的矩阵。下面开始计算注意力分数。

self.scale是为了缩放q ，防止点积结果过大，保持数值稳定。然后与k点积，点积前将k转置一下，得到atten(64×b,3,49,49)。relative_position_bias是位置编码，这个就是套死公式，然后atten加上这个位置编码。现在还在W-MSA阶段，所以没有mask，直接对attn进行softmax。atten与v的转置点积，reshape得到(b,49,96)，最后经过一个线性变换self.proj完成！

======================================================================

回到SwinTransformerBlock的forward继续。

将刚刚得到的重新view一下为(64×b,7,7,96)。window_reverse是将图像数据的size还原回原来的样子(64×b,7,7,96)->(b,56,56,96)。得到的结果view成(b,3136,96)，最后做点线性变换做残差得到最终结果。

SW-MSA

W-MSA部分算是结束了，紧接着进入SW-MSA模块，重复的地方就不说了。还是在SwinTransformerBlock的forward方法中，这次将执行if self.shift_size > 0后的代码。

shift_size默认值为3，torch.roll就是用来窗口滑动的。我画了个图来理解它，加入shift_size为1的情况，它的效果如下图。

请添加图片描述

接下来不一样的点在计算注意力机制模块，WindowAttention的forward方法中。

if mask is not None:
    nW = mask.shape[0]
    attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
    attn = attn.view(-1, self.num_heads, N, N)
    attn = self.softmax(attn)

这里的attn还加了一个mask矩阵，mask矩阵是怎么来的呢。

H, W = self.input_resolution
img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
h_slices = (slice(0, -self.window_size),
            slice(-self.window_size, -self.shift_size),
            slice(-self.shift_size, None))
w_slices = (slice(0, -self.window_size),
            slice(-self.window_size, -self.shift_size),
            slice(-self.shift_size, None))
cnt = 0
for h in h_slices:
    for w in w_slices:
        img_mask[:, h, w, :] = cnt
        cnt += 1

mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))

先创建一个全零的掩码张量img_mask，shape为 (1, H, W, 1)，用来存储窗口索引。h_slices和w_slices是用来划分区域的切片（其实我没看懂，只是大概知道是干啥的）。cnt为不同的窗口区域编号，然后按刚刚的切片填充不同的索引值，用来区分不同区域。这样，相同窗口的像素会有相同的cnt值，不同窗口的像素值不同。将img_mask按7×7进行窗口划分为mask_windows，展平，计算像素间的差值矩阵，相同窗口内的元素差值为 0，不同窗口之间的差值不为 0。不同窗口的填充-100，相同的填充0。

因此atten加上mask矩阵，对于连续窗口的token不做变化，而对于不连续窗口的token加上-100，经过softmax近似忽略。

做完这些之后要进入下采样了。

PatchMerging

跳到PatchMerging的forward方法中看看怎么个事。

def forward(self, x):
    H, W = self.input_resolution
    B, L, C = x.shape
    assert L == H * W, "input feature has wrong size"
    assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."

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

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

    x = self.norm(x)
    x = self.reduction(x)

    return x

代码简洁明了，非常清晰。按H和W每隔一个像素点取值，然后拼接在一起。标准化后再经过一个线性变换，结束！输出(b,784,192)。（注：784=56÷2×56÷2，即H和W都减半。C一开始叠了4倍，后面经过self.reduction减半了，所以192=96×4÷2）

======================================================================

后面再重复几次，每次HW减半，C两倍，over！

小西几哦
关注
【YOLO系列】YOLOv5超详细解读（源码详解＋入门实践＋改进）
路人贾的博客
03-03 20万+
一文带你详细了解YOLOv5（含YOLO系列论文讲解+源码详解+入门实践+算法改进）
Swin Transformer论文总结
weixin_44485421的博客
08-16 1148
和PVT思想类似，提出了一种包含滑窗操作，具有层级设计的Swin Transformer。将注意力计算限制在一个窗口中，一方面能引入CNN卷积操作的局部性，另一方面能节省计算量。
swin transformer解读
qq_31473155的博客
07-09 2245
原文 论文链接：Swin Transformer: Hierarchical Vision Transformer using Shifted Windows 源码地址：https://github.com/microsoft/Swin-Transformer 引言 目前Transformer应用到图像领域主要有两大挑战： 视觉实体变化大，在不同场景下视觉Transformer性能未必很好。即目标尺寸多变。不像NLP任务中token大小基本相同，目标检测中的目标尺寸不一，用单层级的模型很难有好的效果。 图
【CV学习笔记】Swin Transformer
Rex大居
03-29 8004
1、前言 相对于Vision transform，Swim transformer进一步促进了transformer在视觉领域的应用，本次记录的代码依旧是参考paddle的0基础入门transformer pallle基础transformer课 2、学习内容 Swim Transformer在paddle的课程中已经讲的很细致了，本次记录主要是针对其中的代码实现，同时 也推荐霹雳吧啦Wz的视频。 2.1 Swim Transformer网络结构 Swim Transformer网络结构如下图所示 其中e
论文阅读 - Video Swin Transformer
热门推荐
zjuPeco的博客
02-14 1万+
video swin transformer解读
常见的Transformer变体介绍
weixin_63670364的博客
08-24 4550
当谈到深度学习领域的重要里程碑时，Transformer模型无疑是一个不可忽视的巨大飞跃。最初由Vaswani等人于2017年提出，Transformer原本是为了处理自然语言处理任务而设计的，但其独特的架构和强大的能力很快吸引了其他领域的关注，其中之一就是视觉领域。Transformer模型之所以在视觉领域引起关注，部分原因在于其自注意力机制的独特设计。这种机制允许模型在处理序列数据时能够同时考虑不同位置之间的关系，无论是文本中的单词还是图像中的像素。
论文：Swin Transformer
cztAI的博客
06-29 1376
Swin Transformer: Hierarchical Vision Transformer using Shifted Windows 论文：https://arxiv.org/abs/2103.14030 代码：语义分割、图像分类、目标检测
【Transformer 论文精读】……Swin Transformer……(Hierarchical Vision Transformer using Shifted Windows)
深度不学习！！的博客
06-10 1946
论文用的是2021 8月17日的版本。Swin Transformer是ICCV 2021的最佳论文，这一篇论文是继Vit之后的Transformer在CV领域的巅峰之作。在paperwithcode上可以看到，SwinV2版本已经将coco数据集的精确度刷到了63.1%，而卷积系列还在50%+。Swin很可能引领之后的CV领域。这是基于Vit的一篇论文，可以看一下我之前的Vit阅读笔记：作者在摘要中说他提出了一个Swin Transformer的模型，可以当backbone。之前在Vit的结尾，Vit的作
Swin-Transformer论文笔记
weixin_47656519的博客
12-13 558
本文介绍了一种新的视觉 Transformer，称为 Swin Transformer，它可以作为计算机视觉的通用主干。将 Transformer 从语言应用到视觉的挑战来自两个领域之间的差异，例如视觉实体规模的巨大变化以及与文本中的文字相比图像中像素的高分辨率。为了解决这些差异，我们提出了一种分层 Transformer，其表示是使用 Shifted 窗口计算的。移位窗口方案通过将自注意力计算限制在非重叠的本地窗口同时还允许跨窗口连接来提高效率。这种分层架构可以灵活地在各种比例下进行建模。
【论文精读 02】Swin Transformer
weixin_42322991的博客
08-11 3235
将 Transformer 直接从 NLP 应用到 Vision 是有挑战的，挑战主要来自两个方面，一个是尺度上的问题（例如对于一张街景的图，里面有大大小小的行人和车，对于同样一个语义的行人或车，具有不同的尺寸，这种现象在NLP当中没有），第二个问题就 resolution 太大了，如果我们要以像素点作为基本单位，序列的长度就变得高不可攀，所有的方法都是为了减少序列的长度。​ 本文作者提出。...
论文阅读：CVPR2021 | Swin Transformer: Hierarchical Vision Transformer using Shifted Windows
qq_17614495的博客
04-21 2535
文章目录前言一、Introduction二、使用步骤1.引入库2.读入数据总结 前言 本文提出了一种新的视觉Transformer，称为Swin Transformer，它可以很好地作为计算机视觉的通用主干。将Transformer从语言转换为视觉的挑战来自这两个领域之间的差异，例如视觉实体的大小差异很大，图像中的像素与文本中的文字相比分辨率较高。为了解决这些差异，我们提出了一种分层转换器，其表示是通过移位窗口来计算的。移位窗口方案通过将自注意计算限制到非重叠的局部窗口，同时还允许跨窗口连接，带来了更高的
预训练模型swin-large-patch4-window12-384-22kto1k.pth
11-12
swin transformer 预训练模型swin_large_patch4_window12_384_22kto1k.pth
预训练swin-large-patch4-window7-224-22kto1k.pth
11-12
swin Transformer 预训练模型参数 swin_large_patch4_window7_224_22kto1k.pth
Transformer实战-系列教程7：SwinTransformer 算法原理 1
最新发布
机器学习与软件工程
02-05 1633
Transformer实战-系列教程7：SwinTransformer 源码解读1
YOLOv5改进系列（19）——替换主干网络之Swin TransformerV1（参数量更小的ViT模型）
路人贾的博客
08-08 3717
YOLOv5改进，替换主干网络之Swin TransformerV1，参数量更小的ViT模型！
论文阅读笔记《Swin Transformer: Hierarchical Vision Transformer using Shifted Windows》
qq_39346945的博客
02-07 958
论文阅读笔记《Swin Transformer: Hierarchical Vision Transformer using Shifted Windows》
《Swin Transformer Hierarchical Vision Transformer using Shifted Windows》论文超详细解读（翻译＋精读）
路人贾的博客
08-07 5990
《Swin Transformer Hierarchical Vision Transformer using Shifted Windows》论文超详细解读（翻译＋精读）
Swin Transformer: Hierarchical Vision Transformer using Shifted Windows论文阅读
Q1u1NG的博客
03-30 5940
Swin Transformer: Hierarchical Vision Transformer using Shifted Windows论文阅读摘要介绍相关工作方法整个架构基于self-attention的shifted window架构变种实验消融实验 paper:https://arxiv.org/pdf/2103.14030v1.pdf code: https://github.com/microsoft/Swin-Transformer 摘要 采用transformer来做计算机视觉任务有两个
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值