YOLOv5改进 | 卷积模块 | SAConv可切换空洞卷积【全网独家】

kay_545

于 2024-07-05 20:38:17 发布

阅读量1k

点赞数 16

分类专栏： YOLOv5入门 + 改进涨点文章标签： YOLO 深度学习人工智能网络目标检测面试 yolov5改进

本文链接：https://blog.csdn.net/m0_67647321/article/details/140217005

版权

YOLOv5入门 + 改进涨点专栏收录该内容

55 篇文章 41 订阅

订阅专栏

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录： 《YOLOv5入门 + 改进涨点》专栏介绍 & 专栏目录 |目前已有40+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进

许多现代目标检测器通过使用“观察和思考两次”的机制展现了卓越的性能。我们在目标检测的主干设计中探讨了这种机制。在宏观层面上，提出了递归特征金字塔（Recursive Feature Pyramid），它将额外的反馈连接从特征金字塔网络整合到底向上的主干层中。在微观层面上，提出了可切换空洞卷积（Switchable Atrous Convolution），它用不同的空洞率对特征进行卷积，并使用切换函数收集结果。将它们结合起来就得到了DetectoRS，它显著提高了目标检测的性能。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

1. 原理

论文地址：DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolutio——点击即可跳转
官方代码：官方代码仓库——点击即可跳转

可切换空洞卷积 (SAC) 是一种复杂的卷积技术，用于增强深度学习模型的性能，特别是在对象检测和分割等任务中。以下是根据提供的文档对其主要原理的细分：

空洞卷积

空洞卷积，也称为扩张卷积，用于增加过滤器的视野，而不会增加参数数量或计算量。这是通过在连续的过滤器值之间引入零来实现的。插入这些零的速率称为空洞速率 ( r )。对于大小为 $( k \times k )$ 的过滤器，有效内核大小变为 ( k + (k-1)(r-1) )。这允许网络捕获多尺度信息，这对于检测不同大小的物体特别有用。

可切换空洞卷积 (SAC)

SAC 以空洞卷积为基础，引入了一种在卷积操作期间动态切换不同空洞率的机制。其核心思想是允许卷积层根据输入特征自适应地选择适当的空洞率。这种适应性有助于模型更好地处理同一图像中不同尺度的对象。

SAC 的组件

SAC 由三个主要组件组成：主 SAC 组件和两个附加在 SAC 组件之前和之后的全局上下文模块。

主 SAC 组件：这是实际发生可切换空洞卷积的核心部分。它涉及两个具有不同空洞率的卷积操作的加权组合。

SAC 的数学公式如下： $y = S(x) \cdot \text{Conv}(x, w, 1) + (1 - S(x)) \cdot \text{Conv}(x, w + \Delta w, r)$ 其中：

( x ) 是输入。
$( w )$ 和 $( w + \Delta w )$ 是卷积运算的权重。
( r ) 是空洞率。
$( S(x) )$ 是一个开关函数，实现为一个平均池化层，具有 5x5 内核，后跟一个 1x1 卷积层，确定两个卷积运算之间的平衡。
全局上下文模块：这些模块在 SAC 操作前后为特征添加了图像级上下文，增强了模型理解图像全局结构的能力。

SAC的优势

多尺度检测：通过动态切换不同的空洞率，SAC 使模型能够更好地检测各种尺寸的物体。
参数效率：SAC 在不增加额外参数的情况下增加了感受野，同时保持了计算效率。
适应性：切换功能允许卷积层根据输入进行适应，使模型更加灵活，能够处理不同的图像和物体尺度。

实现示例

骨干网络（例如 ResNet）中的每个 3x3 卷积层都转换为 SAC，然后执行具有不同空洞率的卷积的加权组合。

综上所述，可切换空洞卷积结合了空洞卷积和动态适应性的优点，增强了深度学习模型，提高了其处理不同物体尺度图像的能力，同时保持参数和计算方面的效率。

2. 将PConv添加到YOLOv5代码

2.1 PConv代码实现

关键步骤一：在/yolov5-6.1/models/下新建文件SAConv.py，并粘贴下面代码

*注：代码过程，只粘贴了部分代码。完整代码查看第三部分

class ConvAWS2d(nn.Conv2d):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size,
                 stride=1,
                 padding=0,
                 dilation=1,
                 groups=1,
                 bias=True):
        super().__init__(
            in_channels,
            out_channels,
            kernel_size,
            stride=stride,
            padding=padding,
            dilation=dilation,
            groups=groups,
            bias=bias)
        self.register_buffer('weight_gamma', torch.ones(self.out_channels, 1, 1, 1))
        self.register_buffer('weight_beta', torch.zeros(self.out_channels, 1, 1, 1))

    def _get_weight(self, weight):
        weight_mean = weight.mean(dim=1, keepdim=True).mean(dim=2,
                                                            keepdim=True).mean(dim=3, keepdim=True)
        weight = weight - weight_mean
        std = torch.sqrt(weight.view(weight.size(0), -1).var(dim=1) + 1e-5).view(-1, 1, 1, 1)
        weight = weight / std
        weight = self.weight_gamma * weight + self.weight_beta
        return weight

    def forward(self, x):
        weight = self._get_weight(self.weight)
        return super()._conv_forward(x, weight, None)

    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
                              missing_keys, unexpected_keys, error_msgs):
        self.weight_gamma.data.fill_(-1)
        super()._load_from_state_dict(state_dict, prefix, local_metadata, strict,
                                      missing_keys, unexpected_keys, error_msgs)
        if self.weight_gamma.data.mean() > 0:
            return
        weight = self.weight.data
        weight_mean = weight.data.mean(dim=1, keepdim=True).mean(dim=2,
                                                                 keepdim=True).mean(dim=3, keepdim=True)
        self.weight_beta.data.copy_(weight_mean)
        std = torch.sqrt(weight.view(weight.size(0), -1).var(dim=1) + 1e-5).view(-1, 1, 1, 1)
        self.weight_gamma.data.copy_(std)


class SAConv2d(ConvAWS2d):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size,
                 s=1,
                 p=None,
                 g=1,
                 d=1,
                 act=True,
                 bias=True):
        super().__init__(
            in_channels,
            out_channels,
            kernel_size,
            stride=s,
            padding=autopad(kernel_size, p),
            dilation=d,
            groups=g,
            bias=bias)
        self.switch = torch.nn.Conv2d(
            self.in_channels,
            1,
            kernel_size=1,
            stride=s,
            bias=True)
        self.switch.weight.data.fill_(0)
        self.switch.bias.data.fill_(1)
        self.weight_diff = torch.nn.Parameter(torch.Tensor(self.weight.size()))
        self.weight_diff.data.zero_()
        self.pre_context = torch.nn.Conv2d(
            self.in_channels,
            self.in_channels,
            kernel_size=1,
            bias=True)
        self.pre_context.weight.data.fill_(0)
        self.pre_context.bias.data.fill_(0)
        self.post_context = torch.nn.Conv2d(
            self.out_channels,
            self.out_channels,
            kernel_size=1,
            bias=True)
        self.post_context.weight.data.fill_(0)
        self.post_context.bias.data.fill_(0)

        self.bn = nn.BatchNorm2d(out_channels)
        self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())

    def forward(self, x):
        # pre-context
        avg_x = torch.nn.functional.adaptive_avg_pool2d(x, output_size=1)
        avg_x = self.pre_context(avg_x)
        avg_x = avg_x.expand_as(x)
        x = x + avg_x
        # switch
        avg_x = torch.nn.functional.pad(x, pad=(2, 2, 2, 2), mode="reflect")
        avg_x = torch.nn.functional.avg_pool2d(avg_x, kernel_size=5, stride=1, padding=0)
        switch = self.switch(avg_x)
        # sac
        weight = self._get_weight(self.weight)
        out_s = super()._conv_forward(x, weight, None)
        ori_p = self.padding
        ori_d = self.dilation
        self.padding = tuple(3 * p for p in self.padding)
        self.dilation = tuple(3 * d for d in self.dilation)
        weight = weight + self.weight_diff
        out_l = super()._conv_forward(x, weight, None)
        out = switch * out_s + (1 - switch) * out_l
        self.padding = ori_p
        self.dilation = ori_d
        # post-context
        avg_x = torch.nn.functional.adaptive_avg_pool2d(out, output_size=1)
        avg_x = self.post_context(avg_x)
        avg_x = avg_x.expand_as(out)
        out = out + avg_x
        return self.act(self.bn(out))

可切换空洞卷积 (SAconv) 通过动态调整卷积层中的空洞率来增强图像处理，从而实现更有效的多尺度特征提取。 SAconv 处理图像的主要工作流程概述：

SAconv 的主要工作流程

输入图像：该过程从输入到神经网络的输入图像开始。
初始卷积层：图像首先经过几个标准卷积层，提取边缘、纹理和基本形状等低级特征。这些层通常具有固定的内核大小和步长值。
可切换空洞卷积 (SAC) 模块：核心组件 SAC 模块取代了网络主干中的传统卷积层（例如 ResNet）。以下是 SAC 操作的详细分解：

特征提取：输入特征 ( x ) 首先通过两个不同的卷积操作进行处理，权重分别为 ( w ) 和 $( w + \Delta w )$ ，其中 $( \Delta w )$ 表示对权重的调整。这些卷积具有不同的空洞率，使它们能够捕获多个尺度的特征。
切换函数：切换函数 S(x) 确定两个卷积之间的平衡。它通常实现为具有 5x5 内核的平均池化层，后跟 1x1 卷积层。切换函数的输出是一组权重，用于平衡两个卷积的贡献。
加权组合： SAC 的最终输出是两个卷积的加权组合： $y = S(x) \cdot \text{Conv}(x, w, 1) + (1 - S(x)) \cdot \text{Conv}(x, w + \Delta w, r)$ 这里， $( \text{Conv}(x, w, 1) )$ 表示标准卷积， $( \text{Conv}(x, w + \Delta w, r) )$ 表示速率为 ( r ) 的空洞卷积。

全局上下文模块：在 SAC 模块之前和之后，使用全局上下文模块来合并图像级上下文。这些模块通常涉及全局平均池化和全连接层等操作，以捕获图像的整体结构。这有助于细化特征并为后续层提供更好的上下文。
中间层: SAC 模块和全局上下文模块的输出被馈送到网络的进一步层，其中可能包括额外的卷积、规范化和激活函数。这些层继续细化和处理 SAC 模块提取的特征。
输出层: 最后，处理后的特征到达输出层，生成所需的结果。这可能是分类标签、分割掩码或用于对象检测的边界框，具体取决于网络设计用于的任务。

工作流程说明

在提供的文档中，图 4 显示了集成到 ResNet 架构中的 SAC 模块的示例。在此图中，ResNet 主干中的每个 3x3 卷积层都被 SAC 模块替换。此修改允许网络根据输入特征动态调整其感受野，从而提高需要多尺度特征检测的任务的性能。

2.2 新增yaml文件

关键步骤二：在下/yolov5-6.1/models下新建文件 yolov5_SAConv.yaml并将下面代码复制进去

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, SAConv2d, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, SAConv2d, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

温馨提示：本文只是对yolov5l基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。

# YOLOv5n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
 
# YOLOv5s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
 
# YOLOv5l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
 
# YOLOv5m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
 
# YOLOv5x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple

2.3 注册模块

关键步骤三：在yolo.py中注册，先在上面导入函数，注册”SAConv",

from models.SAConv import *

在parse_model函数中注册SAConv

2.4 执行程序

在train.py中，将cfg的参数路径设置为yolov5_SAConv.yaml的路径

建议大家写绝对路径，确保一定能找到

🚀运行程序，如果出现下面的内容则说明添加成功🚀

3. 完整代码分享

https://pan.baidu.com/s/1GAnb6Qkd3XriyHDUyqZM3g?pwd=i1oo

提取码：i1oo

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的GFLOPs

改进后的GFLOPs

5. 进阶

和损失函数可能有意外的收获，这非常有趣，快去试试吧

6. 总结

可切换空洞卷积 (SAConv) 可动态调整卷积层中的空洞率，通过基于输入特征平衡其贡献的切换函数组合不同的空洞卷积，使网络能够更有效地捕获多尺度特征。这种适应性增强了网络检测不同大小物体的能力，并提高了物体检测和分割等任务的性能，而无需添加额外的参数。

kay_545

关注

16
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
YOLOv5改进 | 卷积模块 | SAConv可切换空洞卷积【全网独家】

yolov5改进，yolov5，yolov5创新，yolov5，SAConv
复制链接

扫一扫

专栏目录

YOLOv5改进 | 卷积模块 | SAConv可切换空洞卷积 【全网独家】

1. 原理

2. 将PConv添加到YOLOv5代码

2.1 PConv代码实现

2.2 新增yaml文件

2.3 注册模块

2.4 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

YOLOv5改进 | 卷积模块 | SAConv可切换空洞卷积【全网独家】