深圳幻海软件技术有限公司 欢迎您！
更多

改进YOLO：YOLOv5结合swin transformer

2023-02-28

self none attn
文章参考于芒果大神，在自己的数据集上跑了一下，改了一些出现的错误。一、配置yolov5_swin_transfomrer.yaml#Parametersnc:10#numberofclassesdepth_multiple:0.33#modeldepthmultiplewidth_multiple:

文章参考于芒果大神，在自己的数据集上跑了一下，改了一些出现的错误。

一、配置yolov5_swin_transfomrer.yaml

  1. # Parameters
  2. nc: 10  # number of classes
  3. depth_multiple: 0.33  # model depth multiple
  4. width_multiple: 0.50  # layer channel multiple
  5.  
  6.  
  7. anchors:
  8.   - [10,13, 16,30, 33,23]  # P3/8
  9.   - [30,61, 62,45, 59,119]  # P4/16
  10.   - [116,90, 156,198, 373,326]  # P5/32
  11.  
  12. # YOLOv5 v6.0 backbone by yoloair
  13. backbone:
  14.   # [from, number, module, args]
  15.   [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
  16.    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
  17.    [-1, 3, C3STR, [128]],
  18.    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
  19.    [-1, 6, C3STR, [256]],
  20.    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
  21.    [-1, 9, C3STR, [512]],
  22.    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
  23.    [-1, 3, C3STR, [1024]],  # 9 <--- ST2CSPB() Transformer module
  24.    [-1, 1, SPPF, [512, 512]],  # 9
  25.   ]
  26.  
  27. # YOLOv5 v6.0 head
  28. head:
  29.   [[-1, 1, Conv, [512, 1, 1]],
  30.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
  31.    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
  32.    [-1, 3, C3, [512, False]],  # 13
  33.  
  34.    [-1, 1, Conv, [256, 1, 1]],
  35.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
  36.    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
  37.    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
  38.  
  39.    [-1, 1, Conv, [256, 3, 2]],
  40.    [[-1, 14], 1, Concat, [1]],  # cat head P4
  41.    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
  42.  
  43.    [-1, 1, Conv, [512, 3, 2]],
  44.    [[-1, 10], 1, Concat, [1]],  # cat head P5
  45.    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
  46.  
  47.    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  48.   ]

二、配置common.py文件

在common.py中增加以下下代码：

  1. class SwinTransformerBlock(nn.Module):
  2.     def __init__(self, c1, c2, num_heads, num_layers, window_size=8):
  3.         super().__init__()
  4.         self.conv = None
  5.         if c1 != c2:
  6.             self.conv = Conv(c1, c2)
  7.  
  8.         # remove input_resolution
  9.         self.blocks = nn.Sequential(*[SwinTransformerLayer(dim=c2, num_heads=num_heads, window_size=window_size,
  10.                                  shift_size=0 if (i % 2 == 0) else window_size // 2) for i in range(num_layers)])
  11.  
  12.     def forward(self, x):
  13.         if self.conv is not None:
  14.             x = self.conv(x)
  15.         x = self.blocks(x)
  16.         return x
  17. class WindowAttention(nn.Module):
  18.  
  19.     def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
  20.  
  21.         super().__init__()
  22.         self.dim = dim
  23.         self.window_size = window_size  # Wh, Ww
  24.         self.num_heads = num_heads
  25.         head_dim = dim // num_heads
  26.         self.scale = qk_scale or head_dim ** -0.5
  27.  
  28.         # define a parameter table of relative position bias
  29.         self.relative_position_bias_table = nn.Parameter(
  30.             torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
  31.  
  32.         # get pair-wise relative position index for each token inside the window
  33.         coords_h = torch.arange(self.window_size[0])
  34.         coords_w = torch.arange(self.window_size[1])
  35.         coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
  36.         coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
  37.         relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
  38.         relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
  39.         relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
  40.         relative_coords[:, :, 1] += self.window_size[1] - 1
  41.         relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
  42.         relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
  43.         self.register_buffer("relative_position_index", relative_position_index)
  44.  
  45.         self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
  46.         self.attn_drop = nn.Dropout(attn_drop)
  47.         self.proj = nn.Linear(dim, dim)
  48.         self.proj_drop = nn.Dropout(proj_drop)
  49.  
  50.         nn.init.normal_(self.relative_position_bias_table, std=.02)
  51.         self.softmax = nn.Softmax(dim=-1)
  52.  
  53.     def forward(self, x, mask=None):
  54.  
  55.         B_, N, C = x.shape
  56.         qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
  57.         q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
  58.  
  59.         q = q * self.scale
  60.         attn = (q @ k.transpose(-2, -1))
  61.  
  62.         relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
  63.             self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
  64.         relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
  65.         attn = attn + relative_position_bias.unsqueeze(0)
  66.  
  67.         if mask is not None:
  68.             nW = mask.shape[0]
  69.             attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
  70.             attn = attn.view(-1, self.num_heads, N, N)
  71.             attn = self.softmax(attn)
  72.         else:
  73.             attn = self.softmax(attn)
  74.  
  75.         attn = self.attn_drop(attn)
  76.  
  77.         # print(attn.dtype, v.dtype)
  78.         try:
  79.             x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
  80.         except:
  81.             #print(attn.dtype, v.dtype)
  82.             x = (attn.half() @ v).transpose(1, 2).reshape(B_, N, C)
  83.         x = self.proj(x)
  84.         x = self.proj_drop(x)
  85.         return x
  86.  
  87. class Mlp(nn.Module):
  88.  
  89.     def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.SiLU, drop=0.):
  90.         super().__init__()
  91.         out_features = out_features or in_features
  92.         hidden_features = hidden_features or in_features
  93.         self.fc1 = nn.Linear(in_features, hidden_features)
  94.         self.act = act_layer()
  95.         self.fc2 = nn.Linear(hidden_features, out_features)
  96.         self.drop = nn.Dropout(drop)
  97.  
  98.     def forward(self, x):
  99.         x = self.fc1(x)
  100.         x = self.act(x)
  101.         x = self.drop(x)
  102.         x = self.fc2(x)
  103.         x = self.drop(x)
  104.         return x
  105.  
  106. class SwinTransformerLayer(nn.Module):
  107.  
  108.     def __init__(self, dim, num_heads, window_size=8, shift_size=0,
  109.                  mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
  110.                  act_layer=nn.SiLU, norm_layer=nn.LayerNorm):
  111.         super().__init__()
  112.         self.dim = dim
  113.         self.num_heads = num_heads
  114.         self.window_size = window_size
  115.         self.shift_size = shift_size
  116.         self.mlp_ratio = mlp_ratio
  117.         # if min(self.input_resolution) <= self.window_size:
  118.         #     # if window size is larger than input resolution, we don't partition windows
  119.         #     self.shift_size = 0
  120.         #     self.window_size = min(self.input_resolution)
  121.         assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
  122.  
  123.         self.norm1 = norm_layer(dim)
  124.         self.attn = WindowAttention(
  125.             dim, window_size=(self.window_size, self.window_size), num_heads=num_heads,
  126.             qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
  127.  
  128.         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
  129.         self.norm2 = norm_layer(dim)
  130.         mlp_hidden_dim = int(dim * mlp_ratio)
  131.         self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
  132.  
  133.     def create_mask(self, H, W):
  134.         # calculate attention mask for SW-MSA
  135.         img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
  136.         h_slices = (slice(0, -self.window_size),
  137.                     slice(-self.window_size, -self.shift_size),
  138.                     slice(-self.shift_size, None))
  139.         w_slices = (slice(0, -self.window_size),
  140.                     slice(-self.window_size, -self.shift_size),
  141.                     slice(-self.shift_size, None))
  142.         cnt = 0
  143.         for h in h_slices:
  144.             for w in w_slices:
  145.                 img_mask[:, h, w, :] = cnt
  146.                 cnt += 1
  147.  
  148.         mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
  149.         mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
  150.         attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
  151.         attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
  152.  
  153.         return attn_mask
  154.  
  155.     def forward(self, x):
  156.         # reshape x[b c h w] to x[b l c]
  157.         _, _, H_, W_ = x.shape
  158.  
  159.         Padding = False
  160.         if min(H_, W_) < self.window_size or H_ % self.window_size!=0 or W_ % self.window_size!=0:
  161.             Padding = True
  162.             # print(f'img_size {min(H_, W_)} is less than (or not divided by) window_size {self.window_size}, Padding.')
  163.             pad_r = (self.window_size - W_ % self.window_size) % self.window_size
  164.             pad_b = (self.window_size - H_ % self.window_size) % self.window_size
  165.             x = F.pad(x, (0, pad_r, 0, pad_b))
  166.  
  167.         # print('2', x.shape)
  168.         B, C, H, W = x.shape
  169.         L = H * W
  170.         x = x.permute(0, 2, 3, 1).contiguous().view(B, L, C)  # b, L, c
  171.  
  172.         # create mask from init to forward
  173.         if self.shift_size > 0:
  174.             attn_mask = self.create_mask(H, W).to(x.device)
  175.         else:
  176.             attn_mask = None
  177.  
  178.         shortcut = x
  179.         x = self.norm1(x)
  180.         x = x.view(B, H, W, C)
  181.  
  182.         # cyclic shift
  183.         if self.shift_size > 0:
  184.             shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
  185.         else:
  186.             shifted_x = x
  187.  
  188.         # partition windows
  189.         x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
  190.         x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
  191.  
  192.         # W-MSA/SW-MSA
  193.         attn_windows = self.attn(x_windows, mask=attn_mask)  # nW*B, window_size*window_size, C
  194.  
  195.         # merge windows
  196.         attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
  197.         shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
  198.  
  199.         # reverse cyclic shift
  200.         if self.shift_size > 0:
  201.             x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
  202.         else:
  203.             x = shifted_x
  204.         x = x.view(B, H * W, C)
  205.  
  206.         # FFN
  207.         x = shortcut + self.drop_path(x)
  208.         x = x + self.drop_path(self.mlp(self.norm2(x)))
  209.  
  210.         x = x.permute(0, 2, 1).contiguous().view(-1, C, H, W)  # b c h w
  211.  
  212.         if Padding:
  213.             x = x[:, :, :H_, :W_]  # reverse padding
  214.  
  215.         return x
  216.  
  217. class C3STR(C3):
  218.     # C3 module with SwinTransformerBlock()
  219.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
  220.         super().__init__(c1, c2, n, shortcut, g, e)
  221.         c_ = int(c2 * e)
  222.         num_heads = c_ // 32
  223.         self.m = SwinTransformerBlock(c_, c_, num_heads, n)
  224.

三、yolo.py文件配置

在parse_model(d, ch)函数中增加C3STR

四、train.py文件配置

在if __name__ == '__main__':中更改cfg

五、一些问题

1.NameError: name 'F' is not defined

在common.py中增加以下代码：

import torch.nn.functional as F

2.File "D:\Projects\yoloair-main\models\common.py", line 1519, in __init__
super().__init__(c1, c2, c2, n, shortcut, g, e)
TypeError: __init__() takes from 3 to 7 positional arguments but 8 were given

去掉一个c2。

3.NameError: name 'window_partition' is not defined

  1. def window_partition(x, window_size):
  2.     """
  3.     Args:
  4.         x: (B, H, W, C)
  5.         window_size (int): window size
  6.     Returns:
  7.         windows: (num_windows*B, window_size, window_size, C)
  8.     """
  9.     B, H, W, C = x.shape
  10.     x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
  11.     windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
  12.     return windows
  13.

4.NameError: name 'window_reverse' is not defined

  1. ef 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
  8.     Returns:
  9.         x: (B, H, W, C)
  10.     """
  11.     B = int(windows.shape[0] / (H * W / window_size / window_size))
  12.     x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
  13.     x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
  14.     return x

 

文章知识点与官方知识档案匹配，可进一步学习相关知识
Python入门技能树预备知识常用开发工具237925 人正在系统学习中
ACM基础(一)
国产数据库，又有好消息！