YOLOv5：修改backbone为ACMIX

news/2024/7/9 22:30:27 标签: YOLO, 目标检测, 深度学习, 人工智能

YOLOv5：修改backbone为ACMIX

  • 前言
  • 前提条件
  • 相关介绍
  • ACMIX
    • YOLOv5修改backbone为ACMIX
      • 修改common.py
      • 修改yolo.py
      • 修改yolov5.yaml配置
  • 参考

在这里插入图片描述

前言

  • 记录在YOLOv5修改backbone操作，方便自己查阅。
  • 由于本人水平有限，难免出现错漏，敬请批评改正。
  • 更多精彩内容，可点击进入YOLO系列专栏、自然语言处理
    专栏或我的个人主页查看
  • 基于DETR的人脸伪装检测
  • YOLOv7训练自己的数据集（口罩检测）
  • YOLOv8训练自己的数据集（足球检测）
  • YOLOv5：TensorRT加速YOLOv5模型推理
  • YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
  • 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
  • YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
  • YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
  • Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
  • YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
  • 使用Kaggle GPU资源免费体验Stable Diffusion开源项目

前提条件

  • 熟悉Python

相关介绍

  • Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
  • PyTorch 是一个深度学习框架，封装好了很多网络和深度学习相关的工具方便我们调用，而不用我们一个个去单独写了。它分为 CPU 和 GPU 版本，其他框架还有 TensorFlow、Caffe 等。PyTorch 是由 Facebook 人工智能研究院（FAIR）基于 Torch 推出的，它是一个基于 Python 的可续计算包，提供两个高级功能：1、具有强大的 GPU 加速的张量计算（如 NumPy）；2、构建深度神经网络时的自动微分机制。
  • YOLOv5是一种单阶段目标检测算法，该算法在YOLOv4的基础上添加了一些新的改进思路，使其速度与精度都得到了极大的性能提升。它是一个在COCO数据集上预训练的物体检测架构和模型系列，代表了Ultralytics对未来视觉AI方法的开源研究，其中包含了经过数千小时的研究和开发而形成的经验教训和最佳实践。

ACMIX

  • ACMIX是清华大学等机构提出的一种新范式，将卷积和自注意力融合在一起。
  • ACMIX的主要优点是性能和速度的全面提升。它通过将卷积和自注意力的第一阶段进行共享，减少了计算复杂度。
  • 具体来说，ACMIX将卷积和自注意力拆分成两个阶段，然后通过共享特征转换操作，将它们结合在一起。这样做的好处是，ACMIX既享有自注意力和卷积的优点，又具有最小的计算开销。
  • ACMIX的性能已在图像识别、分割任务和目标检测任务等多个领域得到验证。在图像识别任务中，ACMIX在ResNet、SAN、PVT和Swin-Transformer等基础模型上取得了持续改进的结果。在分割任务和目标检测任务中，ACMIX也取得了令人满意的性能。
  • ACMIX还具有较快的推理速度，消融试验结果表明，ACMIX的性能和速度提升主要来自于卷积和自注意力的共享特征转换操作。
  • 总的来说，ACMIX是一种性能和速度全面提升的新范式，它将卷积和自注意力的优点结合在一起，具有广泛的应用前景。
  • 论文地址：https://arxiv.org/abs/2111.14556
  • 官方源代码地址：https://github.com/LeapLabTHU/ACmix
    在这里插入图片描述
    在这里插入图片描述
  • 有兴趣可查阅论文和官方源代码地址。

YOLOv5backboneACMIX_47">YOLOv5修改backbone为ACMIX

修改common.py

将以下代码，添加进common.py。

###################### ACMIX ##########################
def position(H, W, is_cuda=True):
    if is_cuda:
        loc_w = torch.linspace(-1.0, 1.0, W).cuda().unsqueeze(0).repeat(H, 1)
        loc_h = torch.linspace(-1.0, 1.0, H).cuda().unsqueeze(1).repeat(1, W)
    else:
        loc_w = torch.linspace(-1.0, 1.0, W).unsqueeze(0).repeat(H, 1)
        loc_h = torch.linspace(-1.0, 1.0, H).unsqueeze(1).repeat(1, W)
    loc = torch.cat([loc_w.unsqueeze(0), loc_h.unsqueeze(0)], 0).unsqueeze(0)
    return loc


def stride(x, stride):
    b, c, h, w = x.shape
    return x[:, :, ::stride, ::stride]


def init_rate_half(tensor):
    if tensor is not None:
        tensor.data.fill_(0.5)


def init_rate_0(tensor):
    if tensor is not None:
        tensor.data.fill_(0.)


class ACmix(nn.Module):
    def __init__(self, in_planes, out_planes, kernel_att=7, head=4, kernel_conv=3, stride=1, dilation=1):
        super(ACmix, self).__init__()
        self.in_planes = in_planes
        self.out_planes = out_planes
        self.head = head
        self.kernel_att = kernel_att
        self.kernel_conv = kernel_conv
        self.stride = stride
        self.dilation = dilation
        self.rate1 = torch.nn.Parameter(torch.Tensor(1))
        self.rate2 = torch.nn.Parameter(torch.Tensor(1))
        self.head_dim = self.out_planes // self.head

        self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
        self.conv2 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
        self.conv3 = nn.Conv2d(in_planes, out_planes, kernel_size=1)
        self.conv_p = nn.Conv2d(2, self.head_dim, kernel_size=1)

        self.padding_att = (self.dilation * (self.kernel_att - 1) + 1) // 2
        self.pad_att = torch.nn.ReflectionPad2d(self.padding_att)
        self.unfold = nn.Unfold(kernel_size=self.kernel_att, padding=0, stride=self.stride)
        self.softmax = torch.nn.Softmax(dim=1)

        self.fc = nn.Conv2d(3 * self.head, self.kernel_conv * self.kernel_conv, kernel_size=1, bias=False)
        self.dep_conv = nn.Conv2d(self.kernel_conv * self.kernel_conv * self.head_dim, out_planes,
                                  kernel_size=self.kernel_conv, bias=True, groups=self.head_dim, padding=1,
                                  stride=stride)

        self.reset_parameters()

    def reset_parameters(self):
        init_rate_half(self.rate1)
        init_rate_half(self.rate2)
        kernel = torch.zeros(self.kernel_conv * self.kernel_conv, self.kernel_conv, self.kernel_conv)
        for i in range(self.kernel_conv * self.kernel_conv):
            kernel[i, i // self.kernel_conv, i % self.kernel_conv] = 1.
        kernel = kernel.squeeze(0).repeat(self.out_planes, 1, 1, 1)
        self.dep_conv.weight = nn.Parameter(data=kernel, requires_grad=True)
        self.dep_conv.bias = init_rate_0(self.dep_conv.bias)

    def forward(self, x):
        q, k, v = self.conv1(x), self.conv2(x), self.conv3(x)
        scaling = float(self.head_dim) ** -0.5
        b, c, h, w = q.shape
        h_out, w_out = h // self.stride, w // self.stride

        # ### att
        # ## positional encoding
        pe = self.conv_p(position(h, w, x.is_cuda))

        q_att = q.view(b * self.head, self.head_dim, h, w) * scaling
        k_att = k.view(b * self.head, self.head_dim, h, w)
        v_att = v.view(b * self.head, self.head_dim, h, w)

        if self.stride > 1:
            q_att = stride(q_att, self.stride)
            q_pe = stride(pe, self.stride)
        else:
            q_pe = pe

        unfold_k = self.unfold(self.pad_att(k_att)).view(b * self.head, self.head_dim,
                                                         self.kernel_att * self.kernel_att, h_out,
                                                         w_out)  # b*head, head_dim, k_att^2, h_out, w_out
        unfold_rpe = self.unfold(self.pad_att(pe)).view(1, self.head_dim, self.kernel_att * self.kernel_att, h_out,
                                                        w_out)  # 1, head_dim, k_att^2, h_out, w_out

        att = (q_att.unsqueeze(2) * (unfold_k + q_pe.unsqueeze(2) - unfold_rpe)).sum(
            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)
        att = self.softmax(att)

        out_att = self.unfold(self.pad_att(v_att)).view(b * self.head, self.head_dim, self.kernel_att * self.kernel_att,
                                                        h_out, w_out)
        out_att = (att.unsqueeze(1) * out_att).sum(2).view(b, self.out_planes, h_out, w_out)

        ## conv
        f_all = self.fc(torch.cat(
            [q.view(b, self.head, self.head_dim, h * w), k.view(b, self.head, self.head_dim, h * w),
             v.view(b, self.head, self.head_dim, h * w)], 1))
        f_conv = f_all.permute(0, 2, 1, 3).reshape(x.shape[0], -1, x.shape[-2], x.shape[-1])

        out_conv = self.dep_conv(f_conv)

        return self.rate1 * out_att + self.rate2 * out_conv
###################### ACMIX ##########################

修改yolo.py

		elif m in [ACmix]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)
            args = [c1, c2, *args[1:]]

在这里插入图片描述

修改yolov5.yaml配置

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # 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, ACmix, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [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, Conv, [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)
  ]

在这里插入图片描述

参考

[1] Xuran Pan, Chunjiang Ge, Rui Lu, Shiji Song, Guanfu Chen, Zeyi Huang, Gao Huang. On the Integration of Self-Attention and Convolution. 2022
[2] https://arxiv.org/abs/2111.14556
[3] https://github.com/LeapLabTHU/ACmix
[4] https://github.com/ultralytics/yolov5.git

  • 由于本人水平有限，难免出现错漏，敬请批评改正。
  • 更多精彩内容，可点击进入YOLO系列专栏、自然语言处理
    专栏或我的个人主页查看
  • 基于DETR的人脸伪装检测
  • YOLOv7训练自己的数据集（口罩检测）
  • YOLOv8训练自己的数据集（足球检测）
  • YOLOv5：TensorRT加速YOLOv5模型推理
  • YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
  • 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
  • YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
  • YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
  • Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
  • YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
  • 使用Kaggle GPU资源免费体验Stable Diffusion开源项目

http://www.niftyadmin.cn/n/5046857.html

相关文章

Ctfshow web入门 代码审计篇 web301-web310 详细题解 全

Ctfshow web入门 代码审计篇 web301-web310 详细题解 全

CTFshow 代码审计 web301 下载的附件的目录结构如下： 开题后界面，看见输入框，感觉是sql。 大概浏览一遍源码，我们可以发现在checklogin.php文件中有无过滤的SQL语句，SQL注入没得跑了。 这题SQL注入有三种做法。 方法一…
阅读更多...
华为多路径软件UltraPath

华为多路径软件UltraPath

检查多路径是否安装。 # rpm -qa|grep UltraPath命令查看多路径软件是否安装 查看UltraPath软件版本 # upadmin show version 查看物理路径状态。 #upadmin show path 查看虚拟磁盘信息。 #upadmin show vlun 查看逻辑路径状态。 #upadmin show vlun 查看多路径配置。 #upa…
阅读更多...
C++ -- 类型转换

C++ -- 类型转换

目录 C语言中的类型转换 为什么C需要四种类型转换 C 类型转换 static_cast reinterpret_cast const_cast 添加关键字 volatile dynamic_cast 补充 RTTI 总结 C语言中的类型转换 在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型…
阅读更多...
浅谈为什么多态只能是指针或引用

浅谈为什么多态只能是指针或引用

其实在很早之前，我一直没有注意到这个问题，直到今天碰见了一道题，顺便前面的博客中，继承写到，子类中不包含父类，子类只是继承了父类的成员变量和函数，由这一点，引发了我对切片以及赋…
阅读更多...
PHP8的类与对象的基本操作之类常量-PHP8知识详解

PHP8的类与对象的基本操作之类常量-PHP8知识详解

php 8引入了一种新的特性，称为类常量（class Constants）。类常量是在类中定义的常量，类似于全局常量，但作用域仅限于定义它们的类。 在PHP 8中，类常量的作用域被限制在定义它们的类中。这意味着只有类的成员…
阅读更多...
【刷题笔记9.24】LeetCode：只出现一次的数字

【刷题笔记9.24】LeetCode：只出现一次的数字

LeetCode：只出现一次的数字 一、题目描述 给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使…
阅读更多...
C/C++好题分享--代码题

C/C++好题分享--代码题

2-1排序子序列 int main() {int n;cin >> n;// 注意这里多给了一个值&#xff0c;是处理越界的情况的比较&#xff0c;具体参考上面的解题思路vector<int> a;a.resize(n 1);//这里有个坑&#xff0c;这个题越界了牛客测不出来&#xff0c;给n,并且不写a[n] 0;不会…
阅读更多...
Windows 上下载并提取 Wikipedia

Windows 上下载并提取 Wikipedia

下载资源 很久以前看过了 Wikipedia 是支持 dump 的&#xff0c;不得不说真是造福人类的壮举。我其实也用不到这个&#xff0c;但是看见不少人是用来做 NLP 语料训练的。不过最近我也想尝试一些新的东西&#xff08;我就是单纯想要这个文本数据&#xff09;&#xff0c;所以就…
阅读更多...
最新文章

Copyright @ 2022~2023