【YOLOv7改进系列】引入YOLOv5的C3模块

已于 2024-06-06 21:47:14 修改
阅读量310 收藏 8
点赞数 5
分类专栏： YOLO改进指南 文章标签： YOLO 机器学习 目标检测 计算机视觉 人工智能
于 2024-05-14 21:31:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/138864574
版权

一、问题描述

在对YOLOv7做改进的时候，常常会遇到类似NameError: name 'C3' is not defined的报错，这是因为YOLOv7的common中没有加入C3模块。为此，运用本文可以添加C3模块。

二、C3模块导言

介绍了一种名为“集中-全面卷积”（Concentrated-Comprehensive Convolution，C3）的新模块，旨在创建轻量级的语义分割模型，同时保持高性能。C3模块通过解决将深度可分离卷积与膨胀卷积相结合时导致的信息损失问题，提高了模型效率。以下是C3模块及其应用的主要优点：

  1. 信息补偿机制：C3模块采用两阶段设计，首先使用深度方向的非对称卷积来收集并压缩相邻像素的信息，减轻由于膨胀卷积造成的局部信息丢失问题。这有助于提高模型的局部一致性。

  2. 计算效率提升：通过使用两个非对称卷积代替常规的深度卷积，特别是在高膨胀率下，显著降低了计算复杂度。对于N×N的核，分离卷积将每像素的计算复杂度从O(N^2)降低到2O(N)，有助于在嵌入式系统中实现高效运行。

  3. 感受野扩展：C3模块的第二阶段使用深度可分离的膨胀卷积，扩大了感受野，增强了全局一致性。之后通过1×1的逐点卷积进行跨通道操作，进一步整合信息，构建出适合分割任务的宽广感受野。

  4. 轻量化与高性能并存：实验结果显示，C3模块在保持Cityscapes数据集上原有准确度的同时，减少了模型的复杂度。对ESPNet模型的修改案例中，C3模块使得参数量减半，FLOPs降低35%，且性能提升约2%。

  5. 广泛适用性验证：C3模块被成功应用于多种分割框架（ESPNet、DRN、ERFNet、ENet），证明了其作为一种即插即用模块的灵活性和普遍适用性。

  6. 分类任务的拓展应用：除了语义分割，C3模块还被应用于ImageNet分类任务，展示出替换膨胀卷积并维持或提升性能的能力，进一步验证了其作为深度学习基本构建块的潜力。

总之，C3模块通过创新的结构设计，有效融合了深度可分离卷积和膨胀卷积的优点，实现了轻量化模型设计中的一个关键突破，同时保持了分割和分类任务的高性能表现。

三、C3代码描述

作用: C3 类设计用于提升模型的特征表达能力同时维持或减少计算成本，通过结合输入特征的两种不同路径处理结果，适合于各种视觉任务，尤其是对模型效率和性能有高要求的应用场景，如目标检测、图像识别等。

特点:

  1. 三卷积结构: 与名称相符，此模块包含三个主要的卷积操作 (cv1, cv2, cv3)。前两个用于分别独立处理输入特征，第三个用于合并前两个路径的输出。

  2. 特征分叉处理: 输入首先被分为两路，一路(cv1后的特征)通过一个序列化的Bottleneck结构(self.m)进行深层次特征提取，另一路(cv2)则直接通过1x1卷积进行简单的通道调整但保留原始空间信息。这种方式允许模型同时考虑深度特征表达和保持对原始输入特征的直接传递。

  3. CSP设计理念: 通过torch.cat操作将两条路径的输出在通道维度上拼接，既融合了深层特征也保留了浅层特征，实现了跨阶段的部分特征重用，有助于提高模型的泛化能力和效率。

  4. 灵活性: 通过参数n(Bottleneck块的数量)、shortcut(是否使用捷径连接)、g(组卷积的组数)和e(通道扩展比例)，提供了高度的自定义能力，可以根据具体任务需求调整模型的复杂度和性能。

总结: C3 类通过引入三卷积结构和改进的特征处理流程，进一步优化了CSPNet架构的设计思路，旨在平衡计算效率与模型表现。这种方法在处理复杂视觉任务时特别有用，既能深入挖掘特征细节，又能有效利用计算资源，是现代高效神经网络设计中的一个重要组件。

四、准备工作

首先在YOLOv7项目文件下的models文件夹下创建新的文件c3.py

导入如下代码

from models.common import *


class C3(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(2 * c_, c2, 1)  # act=FReLU(c2)
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

    def forward(self, x):
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))

其次在在YOLOv7项目文件下的models/yolo.py中在文件首部添加代码

from models.c3 import *

并搜索def parse_model(d, ch)

定位到如下行添加以下代码

        elif m in [C3]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not outputss
                c2 = make_divisible(c2 * gw, 8)
            args = [c1, c2, *args[1:]]
            if m in [C3]:
                args.insert(2, n)  # number of repeats
                n = 1
三、YOLOv7-tiny改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov7-tiny-c3.yaml，导入如下代码。

# parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple

# anchors
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

# yolov7-tiny backbone
backbone:
  # [from, number, module, args] c2, k=1, s=1, p=None, g=1, act=True
  [[-1, 1, Conv, [32, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 0-P1/2  
  
   [-1, 1, Conv, [64, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 1-P2/4    
   
   [-1, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 7
   
   [-1, 1, MP, []],  # 8-P3/8
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 14
   
   [-1, 1, MP, []],  # 15-P4/16
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 21
   
   [-1, 1, MP, []],  # 22-P5/32
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 28
  ]

# yolov7-tiny head
head:
  [[-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, SP, [5]],
   [-2, 1, SP, [9]],
   [-3, 1, SP, [13]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -7], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 37
  
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [21, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P4
   [[-1, -2], 1, Concat, [1]],
   
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 47
  
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [14, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P3
   [[-1, -2], 1, Concat, [1]],
   
   [-1, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 57
   
   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 47], 1, Concat, [1]],
   
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 65
   
   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 37], 1, Concat, [1]],
   
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, C3, [256, 1, 1]],  # 73
      
   [57, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [65, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [73, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[74,75,76], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1       928  models.common.Conv                      [3, 32, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  2                -1  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  3                -2  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  4                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  5                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  6  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
  7                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  8                -1  1         0  models.common.MP                        []                            
  9                -1  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 10                -2  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 11                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 12                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 13  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 15                -1  1         0  models.common.MP                        []                            
 16                -1  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 17                -2  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 19                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 20  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 21                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 22                -1  1         0  models.common.MP                        []                            
 23                -1  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 24                -2  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 25                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 26                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 27  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 28                -1  1    525312  models.common.Conv                      [1024, 512, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 29                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 30                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1         0  models.common.SP                        [5]                           
 32                -2  1         0  models.common.SP                        [9]                           
 33                -3  1         0  models.common.SP                        [13]                          
 34  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 35                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36          [-1, -7]  1         0  models.common.Concat                    [1]                           
 37                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 39                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 40                21  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 41          [-1, -2]  1         0  models.common.Concat                    [1]                           
 42                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 43                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 44                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 45                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 47                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 49                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 50                14  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 51          [-1, -2]  1         0  models.common.Concat                    [1]                           
 52                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 56  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 57                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 58                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 59          [-1, 47]  1         0  models.common.Concat                    [1]                           
 60                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 61                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 62                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 63                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 64  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 65                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 66                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 67          [-1, 37]  1         0  models.common.Concat                    [1]                           
 68                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 69                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 70                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 71                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 72  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 73                -1  1    361984  models.c3.C3                            [512, 256, 1, 1, 1]           
 74                57  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 75                65  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 76                73  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 77      [74, 75, 76]  1     17132  models.yolo.IDetect                     [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 282 layers, 6245388 parameters, 6245388 gradients, 13.4 GFLOPS

运行后若打印出如上文本代表改进成功。

除此之外，还可以将c3模块放在多个位置，本文仅是做一个参考。

更多文章产出中，主打简洁和准确，欢迎关注我，共同探讨！

拿下Nahida
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOv5/v7 引入 YOLOv8 的 C2f 模块
YOLOv8项目贡献者
01-23 1万+
基于快速、准确和易于使用的设计理念，使其成为
YOLOv5改进：在C3模块的不同位置添加BiFormer
m0_51530640的博客
04-15 2393
为了缓解多头自注意力()的可扩展性问题，先前的一些方法提出了不同的稀疏注意力机制，其中每个查询只关注少量的键值对，而非全部。为此，作者探索了一种动态的、查询感知的稀疏注意力机制，其关键思想是在粗糙区域级别过滤掉大部分不相关的键值对，以便只保留一小部分路由区域（这不就把冗余的信息干掉了吗老铁们）。其次，作者在这些路由区域的联合中应用细粒度的注意力。
YOLOv7改进主干系列：结合广泛使用且优秀的C3模块
包括YOLOv5、YOLOv7、YOLOv8等模型改进
09-29 7692
目标检测科研论文改进 | 包括Backbone、Neck、Head、注意力机制、IoU损失函数、NMS、Loss计算方式、自注意力机制、数据增强部分、激活函数
YOLOv5网络详解
热门推荐
霹雳吧啦Wz
03-20 22万+
在前面我们已经介绍过了YOLOv1~v4的网络的结构，今天接着上次的YOLOv4再来聊聊YOLOv5，如果还不了解YOLOv4的可以参考之前的博文。YOLOv5项目的作者是Glenn Jocher并不是原Darknet项目的作者Joseph Redmon。并且这个项目至今都没有发表过正式的论文。之前翻阅该项目的issue时，发现有很多人问过这个问题，有兴趣的可以翻翻这个issue #1333。作者当时也有说准备在2021年的12月1号之前发表，并承诺如果到时候没有发表就吃掉自己的帽子。...
YOLOv5改进-引入BiFPN
weixin_57130167的博客
05-02 6807
YOLOv5模型的Neck部分使用的是FPN+PAN结构，从neck特征融合入手，引入加权双向特征金字塔BiFPN来加强特征图的底层信息，使不同尺度的特征图进行信息融合，从而加强特征信息。
YOLOv5 Focus C3 各模块详解及代码实现
偶尔想看云飞的博客
11-03 4万+
关于yolov5的参数的讲解
YOLOV8/YOLOv7/YOLOv5改进:引入GAMAttention注意力机制
weixin_45303602的博客
08-13 1148
为了提高各种计算机视觉任务的性能，人们研究了各种注意机制。然而，以往的方法忽略了保留通道和空间方面的信息以增强跨维度交互的重要性。因此，我们提出了一种全局调度机制，通过减少信息缩减和放大全局交互表示来提高深度神经网络的性能。我们沿着卷积空间注意子模块引入了用于通道注意的多层感知器3D置换。GAMAttention注意力机制原理图对于ImageNet-1K，我们将图像预处理为224×224（He et al.[2016]）。
YOLOv5改进系列（7）——添加SimAM注意力机制
路人贾的博客
06-04 3824
手把手教你在YOLOv5中加入SimAM注意力机制，文内含两种方法，小白也能看懂！
tensorrtx 实现 yolov5 + dcnv2
03-20
将 yolov5x yaml backbone 前3层 conv 改成 dcnconv 参考 tensorrx yolov5 , 实现 tensorrt 推理。 backbone: # [from, number, module, args] [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 [-1, 1, DCN, [128, 3, ...
行人检测+改进yolov5s引入CoT模块+SIOU损失函数+在Crowdhuman大数据集上进行训练得到的模型pt文件
01-16
为了增强行人检测的能力，在原yolov5s的backbone特征提取部分将C3模块替换为CoT模块，用于增强Transformer结构，提高目标检测的性能。通过引入CoT模块，可以使得特征提取网络能够更好地利用输入特征图中位置之间的上...
yolov8深度解析及代码.zip
03-25
骨干网络和Neck部分：YOLOv8在骨干网络和Neck部分可能参考了YOLOv7 ELAN的设计思想，将YOLOv5的C3结构换成了梯度流更丰富的C2f结构。这种改进有助于提升模型的特征提取能力，从而进一步提高检测精度。 可变形卷积...
台湾永宏 C3/P5系列HMI 自由协议案例
11-06
适用HMI型号：永宏C3/P5系列触摸屏 自由通讯协议，以MODBUS协议为例介绍如何创建自定协议通讯方式，包含校验，数据读取等。
H5C3面试题.docx
03-29
H5C3面试题，不懂回来翻翻看
【YOLOv5/v7改进系列】引入Slimneck-GSConv
2401_84870184的博客
06-04 1007
文章还提出了一种设计范式“slim-neck”，即仅在模型的“neck”部分使用GSConv，而非整个模型。：特别是在“细颈”(slim-neck)设计范式中，GSConv被应用于模型的中间连接部分，即neck，这时特征图已经过初步处理，变得较为精简，且宽度和高度减小到最小，而通道数达到最大。综上所述，GSConv通过创新的结构设计为轻量级目标检测模型提供了新的解决方案，尤其在自动驾驶领域，它能够帮助模型在保持高效运行的同时，提高对小目标的检测精度，但其应用也需考虑模型复杂度增加和实现上的局限性。
【YOLO系列】YOLOv10论文超详细解读（翻译 ＋学习笔记）
最新发布
路人贾的博客
06-04 960
《YOLOv10: Real-Time End-to-End Object Detection》论文翻译＋超详细解读
YOLOv10环境搭建&推理测试
zzq1989_的专栏
06-03 733
此外，尽管作者在无需NMS的训练下使用一对一 Head 可以获得具有竞争力的端到端性能，但与使用NMS的一对多训练相比，仍然存在性能差距，特别是在小型模型中更为明显。例如，在YOLOv10-N和YOLOv10-S中，使用NMS的一对多训练的性能比无需NMS的训练分别高出1.0% AP和0.5% AP。此外，为了确保两个分支之间的和谐监督，作者创新性地提出了连贯匹配度量，这可以很好地减少理论上的监督差距，并带来性能的提升。2、作者提出了一种整体效率-精度驱动的模型设计策略，用于YOLO的模型架构。
华为昇腾310 yolov8自训练模型推理使用
weixin_42357472的博客
05-30 281
参考： https://gitee.com/cumt/ascend-yolov8-sample/tree/masterhttps://developer.huawei.com/consumer/cn/forum/topic/0203148227811150357https://blog.csdn.net/weixin_42357472/article/details/139322218源码下载 安装opencv： 安装acl/acl.h： https://gitee.com/ascend/samples/t
YoloV8改进策略：Block篇|基于FasterNet的Block改进|附结构图|性能和精度得到大幅度提高（独家原创）
m0_47867638的博客
05-29 138
【代码】YoloV8改进策略：Block篇|基于FasterNet的Block改进|附结构图|性能和精度得到大幅度提高（独家原创）
yolov5 c3模块改进
07-27
Yolov5 的 C3 模块是一种用于特征提取的模块，它在 Yolov4 的基础上进行了改进。C3 模块通过串联多个卷积层来提取特征，并且使用了一种类似于 Inception 模块的结构，以增加网络的感受野和特征表达能力。 如果你想...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值