devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【RT-DETR有效改进】注意力与卷积的高效融合 | ACmix自注意力与卷积混合模型_acmix模型的主要改进机制可以分为以下两点:自注意力和卷积的整合和运算分解与重构

作者：花生_TL007 | 2024-04-06 10:33:32

赞

踩

acmix模型的主要改进机制可以分为以下两点:自注意力和卷积的整合和运算分解与重构

一、本文介绍

本文给大家带来的改进机制是ACmix自注意力机制的改进版本，它的核心思想是，传统卷积操作和自注意力模块的大部分计算都可以通过1x1的卷积来实现。ACmix首先使用1x1卷积对输入特征图进行投影，生成一组中间特征，然后根据不同的范式，即自注意力和卷积方式，分别重用和聚合这些中间特征。这样，ACmix既能利用自注意力的全局感知能力，又能通过卷积捕获局部特征，从而在保持较低计算成本的同时，提高模型的性能。本文改进是基于ResNet18、ResNet34、ResNet50、ResNet101，文章中均以提供，本专栏的改进内容全网独一份深度改进RT-DETR非那种无效Neck部分改进，同时本文的改进也支持主干上的即插即用，本文内容也支持PP-HGNetV2版本的修改。

专栏目录： RT-DETR改进有效系列目录 | 包含卷积、主干、RepC3、注意力机制、Neck上百种创新机制

专栏链接：RT-DETR剑指论文专栏，持续复现各种顶会内容——论文收割机RT-DETR 

目录

一、本文介绍

二、ACmix的框架原理

2.1 ACMix的基本原理 

2.1.1 自注意力和卷积的整合

2.1.2 运算分解与重构

三、ACmix的核心代码 

四、手把手教你添加ACmix

4.1 修改Basicclock/Bottleneck的教程

4.1.1 修改一

4.1.2 修改二 

4.2 修改主干上即插即用的教程

4.2.1 修改一（如果修改了4.1教程此步无需修改）

4.2.2 修改二 

4.2.3 修改三 

4.2.4 修改四 

五、ACmix的yaml文件

5.1 替换ResNet的yaml文件1(ResNet18版本)

5.2 替换ResNet的yaml文件1(ResNet50版本)

5.3 即插即用的yaml文件（HGNetV2版本）

六、成功运行记录 

6.1 ResNet18运行成功记录截图

​6.2 ResNet50运行成功记录截图

6.3 HGNetv2运行成功记录截图

七、全文总结 

二、ACmix的框架原理

​​

官方论文地址：官方论文地址

官方代码地址：官方代码地址

​​

2.1 ACMix的基本原理 

ACmix是一种混合模型，结合了自注意力机制和卷积运算的优势。它的核心思想是，传统卷积操作和自注意力模块的大部分计算都可以通过1x1的卷积来实现。ACmix首先使用1x1卷积对输入特征图进行投影，生成一组中间特征，然后根据不同的范式，即自注意力和卷积方式，分别重用和聚合这些中间特征。这样，ACmix既能利用自注意力的全局感知能力，又能通过卷积捕获局部特征，从而在保持较低计算成本的同时，提高模型的性能。

ACmix模型的主要改进机制可以分为以下两点：

1. 自注意力和卷积的整合：将自注意力和卷积技术融合，实现两者优势的结合。
2. 运算分解与重构：通过分解自注意力和卷积中的运算，重构为1×1卷积形式，提高了运算效率。

2.1.1 自注意力和卷积的整合

文章中指出，自注意力和卷积的整合通过以下方式实现：

特征分解：自注意力机制的查询（query）、键（key）、值（value）与卷积操作通过1x1卷积进行特征分解。
运算共享：卷积和自注意力共享相同的1x1卷积运算，减少了重复的计算量。
特征融合：在ACmix模型中，卷积和自注意力生成的特征通过求和操作进行融合，加强了模型的特征提取能力。
模块化设计：通过模块化设计，ACmix可以灵活地嵌入到不同的网络结构中，增强网络的表征能力。

​​

这张图片展示了ACmix中的主要概念，它比较了卷积、自注意力和ACmix各自的结构和计算复杂度。图中：

(a) 卷积：展示了标准卷积操作，包含一个K^2​的1x1卷积，表示卷积核大小和卷积操作的聚合。

(b) 自注意力：展示了自注意力机制，它包含三个头部的1x1卷积，代表多头注意力机制中每个头部的线性变换，以及自注意力聚合。

(c) ACmix（我们的方法）：结合了卷积和自注意力聚合，其中1x1卷积在两者之间共享，旨在减少计算开销并整合轻量级的聚合操作。

整体上，ACmix旨在通过共享计算资源（1x1卷积）并结合两种不同的聚合操作，以优化特征通道上的计算复杂度。

2.1.2 运算分解与重构

在ACmix中，运算分解与重构的概念是指将传统的卷积运算和自注意力运算拆分，并重新构建为更高效的形式。这主要通过以下步骤实现：

分解卷积和自注意力：将标准的卷积核分解成多个1×1卷积核，每个核处理不同的特征子集，同时将自注意力机制中的查询（query）、键（key）和值（value）的生成也转换为1×1卷积操作。
重构为混合模块：将分解后的卷积和自注意力运算重构成一个统一的混合模块，既包含了卷积的空间特征提取能力，也融入了自注意力的全局信息聚合功能。
提高运算效率：这种分解与重构的方法减少了冗余计算，提高了运算效率，同时降低了模型的复杂度。

​​

这张图片展示了ACmix提出的混合模块的结构。图示包含了：

(a) 卷积：3x3卷积通过1x1卷积的方式被分解，展示了特征图的转换过程。

(b)自注意力：输入特征先转换成查询（query）、键（key）和值（value），使用1x1卷积实现，并通过相似度匹配计算注意力权重。

(c) ACmix：结合了(a)和(b)的特点，在第一阶段使用三个1x1卷积对输入特征图进行投影，在第二阶段将两种路径得到的特征相加，作为最终输出。

右图显示了ACmix模块的流程，强调了两种机制的融合并提供了每个操作块的计算复杂度。

三、ACmix的核心代码 

该代码本身存在一个bug，会导致验证的时候报类型不匹配的错误，我将其进行了解决，这也是一个读者和我说的想要帮忙解决一下这个问题困扰了他很久。 

  1. import torch
  2. import torch.nn as nn
  3.  
  4. __all__ = ['ACmix', 'BasicBlock_ACmix', 'BottleNeck_ACmix']
  5.  
  6. def position(H, W, type, is_cuda=True):
  7.     if is_cuda:
  8.         loc_w = torch.linspace(-1.0, 1.0, W).cuda().unsqueeze(0).repeat(H, 1).to(type)
  9.         loc_h = torch.linspace(-1.0, 1.0, H).cuda().unsqueeze(1).repeat(1, W).to(type)
  10.     else:
  11.         loc_w = torch.linspace(-1.0, 1.0, W).unsqueeze(0).repeat(H, 1)
  12.         loc_h = torch.linspace(-1.0, 1.0, H).unsqueeze(1).repeat(1, W)
  13.     loc = torch.cat([loc_w.unsqueeze(0), loc_h.unsqueeze(0)], 0).unsqueeze(0)
  14.     return loc
  15.  
  16.  
  17. def stride(x, stride):
  18.     b, c, h, w = x.shape
  19.     return x[:, :, ::stride, ::stride]
  20.  
  21.  
  22. def init_rate_half(tensor):
  23.     if tensor is not None:
  24.         tensor.data.fill_(0.5)
  25.  
  26.  
  27. def init_rate_0(tensor):
  28.     if tensor is not None:
  29.         tensor.data.fill_(0.)
  30.  
  31.  
  32. class ACmix(nn.Module):
  33.     def __init__(self, in_planes, kernel_att=7, head=4, kernel_conv=3, stride=1, dilation=1):
  34.         super(ACmix, self).__init__()
  35.         out_planes = in_planes
  36.         self.in_planes = in_planes
  37.         self.out_planes = out_planes
  38.         self.head = head
  39.         self.kernel_att = kernel_att
  40.         self.kernel_conv = kernel_conv
  41.         self.stride = stride
  42.         self.dilation = dilation
  43.         self.rate1 = torch.nn.Parameter(torch.Tensor(1))
  44.         self.rate2 = torch.nn.Parameter(torch.Tensor(1))
  45.         self.head_dim = self.out_planes // self.head
  46.  
  47.         self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
  48.         self.conv2 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
  49.         self.conv3 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
  50.         self.conv_p = nn.Conv2d(2, self.head_dim, kernel_size=1)
  51.  
  52.         self.padding_att = (self.dilation * (self.kernel_att - 1) + 1) // 2
  53.         self.pad_att = torch.nn.ReflectionPad2d(self.padding_att)
  54.         self.unfold = nn.Unfold(kernel_size=self.kernel_att, padding=0, stride=self.stride)
  55.         self.softmax = torch.nn.Softmax(dim=1)
  56.  
  57.         self.fc = nn.Conv2d(3 * self.head, self.kernel_conv * self.kernel_conv, kernel_size=1, bias=False)
  58.         self.dep_conv = nn.Conv2d(self.kernel_conv * self.kernel_conv * self.head_dim, out_planes,
  59.                                   kernel_size=self.kernel_conv, bias=True, groups=self.head_dim, padding=1,
  60.                                   stride=stride)
  61.  
  62.         self.reset_parameters()
  63.  
  64.     def reset_parameters(self):
  65.         init_rate_half(self.rate1)
  66.         init_rate_half(self.rate2)
  67.         kernel = torch.zeros(self.kernel_conv * self.kernel_conv, self.kernel_conv, self.kernel_conv)
  68.         for i in range(self.kernel_conv * self.kernel_conv):
  69.             kernel[i, i // self.kernel_conv, i % self.kernel_conv] = 1.
  70.         kernel = kernel.squeeze(0).repeat(self.out_planes, 1, 1, 1)
  71.         self.dep_conv.weight = nn.Parameter(data=kernel, requires_grad=True)
  72.         self.dep_conv.bias = init_rate_0(self.dep_conv.bias)
  73.  
  74.     def forward(self, x):
  75.         q, k, v = self.conv1(x), self.conv2(x), self.conv3(x)
  76.         scaling = float(self.head_dim) ** -0.5
  77.         b, c, h, w = q.shape
  78.         h_out, w_out = h // self.stride, w // self.stride
  79.  
  80.         # ### att
  81.         # ## positional encoding
  82.         pe = self.conv_p(position(h, w, x.dtype, x.is_cuda))
  83.  
  84.         q_att = q.view(b * self.head, self.head_dim, h, w) * scaling
  85.         k_att = k.view(b * self.head, self.head_dim, h, w)
  86.         v_att = v.view(b * self.head, self.head_dim, h, w)
  87.  
  88.         if self.stride > 1:
  89.             q_att = stride(q_att, self.stride)
  90.             q_pe = stride(pe, self.stride)
  91.         else:
  92.             q_pe = pe
  93.  
  94.         unfold_k = self.unfold(self.pad_att(k_att)).view(b * self.head, self.head_dim,
  95.                                                          self.kernel_att * self.kernel_att, h_out,
  96.                                                          w_out)  # b*head, head_dim, k_att^2, h_out, w_out
  97.         unfold_rpe = self.unfold(self.pad_att(pe)).view(1, self.head_dim, self.kernel_att * self.kernel_att, h_out,
  98.                                                         w_out)  # 1, head_dim, k_att^2, h_out, w_out
  99.  
  100.         att = (q_att.unsqueeze(2) * (unfold_k + q_pe.unsqueeze(2) - unfold_rpe)).sum(
  101.             1)  # (b*head, head_dim, 1, h_out, w_out) * (b*head, head_dim, k_att^2, h_out, w_out) -> (b*head, k_att^2, h_out, w_out)
  102.         att = self.softmax(att)
  103.  
  104.         out_att = self.unfold(self.pad_att(v_att)).view(b * self.head, self.head_dim, self.kernel_att * self.kernel_att,
  105.                                                         h_out, w_out)
  106.         out_att = (att.unsqueeze(1) * out_att).sum(2).view(b, self.out_planes, h_out, w_out)
  107.  
  108.         ## conv
  109.         f_all = self.fc(torch.cat(
  110.             [q.view(b, self.head, self.head_dim, h * w), k.view(b, self.head, self.head_dim, h * w),
  111.              v.view(b, self.head, self.head_dim, h * w)], 1))
  112.         f_conv = f_all.permute(0, 2, 1, 3).reshape(x.shape[0], -1, x.shape[-2], x.shape[-1])
  113.  
  114.         out_conv = self.dep_conv(f_conv)
  115.  
  116.         return self.rate1 * out_att + self.rate2 * out_conv
  117.  
  118.  
  119.  
  120. from collections import OrderedDict
  121. import torch.nn.functional as F
  122.  
  123.  
  124. class ConvNormLayer(nn.Module):
  125.     def __init__(self,
  126.                  ch_in,
  127.                  ch_out,
  128.                  filter_size,
  129.                  stride,
  130.                  groups=1,
  131.                  act=None):
  132.         super(ConvNormLayer, self).__init__()
  133.         self.act = act
  134.         self.conv = nn.Conv2d(
  135.             in_channels=ch_in,
  136.             out_channels=ch_out,
  137.             kernel_size=filter_size,
  138.             stride=stride,
  139.             padding=(filter_size - 1) // 2,
  140.             groups=groups)
  141.  
  142.         self.norm = nn.BatchNorm2d(ch_out)
  143.  
  144.     def forward(self, inputs):
  145.         out = self.conv(inputs)
  146.         out = self.norm(out)
  147.         if self.act:
  148.             out = getattr(F, self.act)(out)
  149.         return out
  150.  
  151.  
  152.  
  153. class BasicBlock_ACmix(nn.Module):
  154.     expansion = 1
  155.  
  156.     def __init__(self,
  157.                  ch_in,
  158.                  ch_out,
  159.                  stride,
  160.                  shortcut,
  161.                  act='relu',
  162.                  variant='b',
  163.                  att=False):
  164.         super(BasicBlock_ACmix, self).__init__()
  165.         self.shortcut = shortcut
  166.         if not shortcut:
  167.             if variant == 'd' and stride == 2:
  168.                 self.short = nn.Sequential()
  169.                 self.short.add_sublayer(
  170.                     'pool',
  171.                     nn.AvgPool2d(
  172.                         kernel_size=2, stride=2, padding=0, ceil_mode=True))
  173.                 self.short.add_sublayer(
  174.                     'conv',
  175.                     ConvNormLayer(
  176.                         ch_in=ch_in,
  177.                         ch_out=ch_out,
  178.                         filter_size=1,
  179.                         stride=1))
  180.             else:
  181.                 self.short = ConvNormLayer(
  182.                     ch_in=ch_in,
  183.                     ch_out=ch_out,
  184.                     filter_size=1,
  185.                     stride=stride)
  186.  
  187.         self.branch2a = ConvNormLayer(
  188.             ch_in=ch_in,
  189.             ch_out=ch_out,
  190.             filter_size=3,
  191.             stride=stride,
  192.             act='relu')
  193.  
  194.         self.branch2b = ConvNormLayer(
  195.             ch_in=ch_out,
  196.             ch_out=ch_out,
  197.             filter_size=3,
  198.             stride=1,
  199.             act=None)
  200.  
  201.         self.att = att
  202.         if self.att:
  203.             self.se = ACmix(ch_out)
  204.  
  205.     def forward(self, inputs):
  206.         out = self.branch2a(inputs)
  207.         out = self.branch2b(out)
  208.  
  209.         if self.att:
  210.             out = self.se(out)
  211.  
  212.         if self.shortcut:
  213.             short = inputs
  214.         else:
  215.             short = self.short(inputs)
  216.  
  217.         out = out + short
  218.         out = F.relu(out)
  219.  
  220.         return out
  221.  
  222.  
  223. class BottleNeck_ACmix(nn.Module):
  224.     expansion = 4
  225.  
  226.     def __init__(self, ch_in, ch_out, stride, shortcut, act='relu', variant='d', att=False):
  227.         super().__init__()
  228.  
  229.         if variant == 'a':
  230.             stride1, stride2 = stride, 1
  231.         else:
  232.             stride1, stride2 = 1, stride
  233.  
  234.         width = ch_out
  235.  
  236.         self.branch2a = ConvNormLayer(ch_in, width, 1, stride1, act=act)
  237.         self.branch2b = ConvNormLayer(width, width, 3, stride2, act=act)
  238.         self.branch2c = ConvNormLayer(width, ch_out * self.expansion, 1, 1)
  239.  
  240.         self.shortcut = shortcut
  241.         if not shortcut:
  242.             if variant == 'd' and stride == 2:
  243.                 self.short = nn.Sequential(OrderedDict([
  244.                     ('pool', nn.AvgPool2d(2, 2, 0, ceil_mode=True)),
  245.                     ('conv', ConvNormLayer(ch_in, ch_out * self.expansion, 1, 1))
  246.                 ]))
  247.             else:
  248.                 self.short = ConvNormLayer(ch_in, ch_out * self.expansion, 1, stride)
  249.  
  250.         self.att = att
  251.         if self.att:
  252.             self.se = ACmix(ch_out * 4)
  253.  
  254.     def forward(self, x):
  255.         out = self.branch2a(x)
  256.         out = self.branch2b(out)
  257.         out = self.branch2c(out)
  258.  
  259.         if self.att:
  260.             out = self.se(out)
  261.  
  262.         if self.shortcut:
  263.             short = x
  264.         else:
  265.             short = self.short(x)
  266.  
  267.         out = out + short
  268.         out = F.relu(out)
  269.  
  270.         return out
  271.  
  272.

四、手把手教你添加ACmix

修改教程分两种，一种是替换修改ResNet中的Basicclock/Bottleneck模块的，一种是在主干上即插即用的修改教程，如果你只需要一种那么修改对应的就行，互相之间并不影响，需要注意的是即插即用的需要修改ResNet改进才行，链接如下：

ResNet文章地址：【RT-DETR改进涨点】ResNet18、34、50、101等多个版本移植到ultralytics仓库(RT-DETR官方一比一移植)

4.1 修改Basicclock/Bottleneck的教程

4.1.1 修改一

第一还是建立文件，我们找到如下ultralytics/nn/modules文件夹下建立一个目录名字呢就是'Addmodules'文件夹(用群内的文件的话已经有了无需新建)！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

​

4.1.2 修改二 

第二步此处需要注意，因为我这里默认大家修改了ResNet系列的模型了，同级目录下应该有一个ResNet.py的文件夹，我们这里需要找到我们'ultralytics/nn/Addmodules/ResNet.py'创建的ResNet的文件夹（默认大家已经创建了！！！）

​

我们只需要修改上面的两步即可，后面复制yaml文件进行运行即可了，修改方法大家只要仔细看是非常简单的。

4.2 修改主干上即插即用的教程

4.2.1 修改一（如果修改了4.1教程此步无需修改）

第一还是建立文件，我们找到如下ultralytics/nn/modules文件夹下建立一个目录名字呢就是'Addmodules'文件夹(用群内的文件的话已经有了无需新建)！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

​

​

4.2.2 修改二 

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'(用群内的文件的话已经有了无需新建)，然后在其内部导入我们的检测头如下图所示。

​

4.2.3 修改三 

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块(用群内的文件的话已经有了无需重新导入直接开始第四步即可)！

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

​

4.2.4 修改四 

按照我的添加在parse_model里添加即可。

​

  1.         elif m in {ACmix}:
  2.             c2 = ch[f]
  3.             args = [c2, *args]

到此就修改完成了，大家可以复制下面的yaml文件运行。

五、ACmix的yaml文件

5.1 替换ResNet的yaml文件1(ResNet18版本)

需要修改如下的ResNet主干才可以运行本文的改进机制 ！

 ResNet文章地址：【RT-DETR改进涨点】ResNet18、34、50、101等多个版本移植到ultralytics仓库(RT-DETR官方一比一移植)

  1. # Ultralytics YOLO 
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/371399?site
    推荐阅读
    相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。