【YOLOv5/v7改进系列】引入YOLOv8的C2f模块

已于 2024-06-09 01:37:42 修改
阅读量1k 收藏 12
点赞数 12
分类专栏： YOLO改进指南 文章标签： YOLO 目标检测 计算机视觉 人工智能 机器学习 python pytorch
于 2024-05-15 10:38:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/138872738
版权
一、导言

C2F模块也是YOLOv8中的一个特征融合模块。这个模块的作用是将不同尺度的特征图进行融合，以提高目标检测的准确性。C2F模块通过特征融合方式，如通道拼接（concat），结合ELAN（Efficient Lightweight Attention Network）轻量级注意力机制，增强了梯度流信息的传递，从而提高了模型的准确性和性能。这种模块通常被放置在主干网络的最后几个层级上，以获得既有高分辨率又有丰富语义信息的特征图。

代码定义了两个类，C2fBottleneck 和 C2f，它们是神经网络模块，主要用于构建卷积神经网络（CNN），特别是那些关注效率和性能的模型，如目标检测或图像分类网络。下面是对这两个类及其功能的详细分析：

C2fBottleneck 类

作用: C2fBottleneck 类实现了一个标准的瓶颈结构，这是ResNet和其他许多现代CNN架构中的关键组件。瓶颈层通过首先降维、然后执行卷积操作、最后升维回原来的通道数（或接近）来减少计算量，同时保持网络的表达能力。

特点:

  • 灵活性: 该模块接受多个参数，包括输入和输出通道数 (c1, c2)、是否包含shortcut连接 (shortcut)、组卷积的组数 (g)、卷积核大小 (k) 和扩张率 (e)，这使得它非常灵活，能够适应多种网络设计需求。
  • 高效: 使用了1x1卷积进行通道数的减少与增加，中间穿插一个或多个3x3卷积进行空间特征的学习，这种设计减少了计算复杂度。
  • 残差连接: 如果 shortcut=True 且输入输出通道数相等，会添加一个残差连接，有助于梯度传播，加速训练并可能提高模型性能。
C2f 类

作用: C2f 类建立在 C2fBottleneck 的基础上，实现了一个更复杂的结构，使用了多个瓶颈层，并在开始和结束时加入额外的1x1卷积层以调整通道数，形成了一个更为强大的构建块，常用于CSPNet（Cross Stage Partial Network）架构中，旨在进一步提升效率和准确性。

特点:

  • 多尺度特征融合: 通过将输入分割、经过一系列瓶颈层处理后再合并，实现了不同尺度特征的有效整合，这对于识别多层次的视觉特征非常重要。
  • 可扩展性: 参数 n 控制了内部瓶颈块的数量，允许根据需要调整网络深度。
  • 组卷积: 引入了组卷积参数 g，可以在保持计算资源可控的同时，增强模型的表征能力，尤其是在处理大输入通道数时。
  • 通道数调整: 利用膨胀因子 e 调整中间隐藏层的通道数，这是一种平衡计算成本和模型容量的有效方式。

总结: 代码展示了如何通过精心设计的模块化结构来构建高效的深度学习模型。C2fBottleneck 和 C2f 类不仅提高了模型的计算效率，还增强了其学习能力，特别是在处理视觉任务时，能够捕获更多样化的特征信息，从而提升整体的识别或检测性能。这样的设计策略对于资源受限环境下的应用尤其有价值。

二、准备工作

首先在YOLOv5/v7项目文件下的models文件夹下创建新的文件c2f.py

导入如下代码

class C2fBottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))


class C2f(nn.Module):
    # CSP Bottleneck with 2 convolutions
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(
            C2fBottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))

    def forward(self, x):
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

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

from models.c2f import *

并搜索def parse_model(d, ch)

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

如图绿色物块处，添加两个C2f即可。

三、YOLOv7-tiny改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov7-tiny-c2f.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, C2f, [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    525824  models.c2f.C2f                          [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: 278 layers, 6409228 parameters, 6409228 gradients, 13.5 GFLOPS

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

可以发现，同样位置添加较C3模型复杂度略高。

四、YOLOv5s改进工作

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

# Parameters
nc: 1  # 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, C3, [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, C2f, [1024, False]],  # 23 (P5/32-large)

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

运行


                 from  n    params  module                                  arguments                     
  0                -1  1      3520  models.common.Conv                      [3, 32, 6, 2, 2]              
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  2                -1  1     18816  models.common.C3                        [64, 64, 1]                   
  3                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  4                -1  2    115712  models.common.C3                        [128, 128, 2]                 
  5                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  6                -1  3    625152  models.common.C3                        [256, 256, 3]                 
  7                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]              
  8                -1  1   1182720  models.common.C3                        [512, 512, 1]                 
  9                -1  1    656896  models.common.SPPF                      [512, 512, 5]                 
 10                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]              
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 21                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1   1838080  models.c2f.C2f                          [512, 512, 1, False]          
 24      [17, 20, 23]  1     16182  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 266 layers, 7677686 parameters, 7677686 gradients, 16.5 GFLOPs

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

五、YOLOv5n改进工作

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

# Parameters
nc: 1  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # 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, 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, C2f, [1024, False]],  # 23 (P5/32-large)

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


                 from  n    params  module                                  arguments                     
  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              
  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                
  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   
  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   
  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 
  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 
  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 
 10                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 14                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     22912  models.common.C3                        [128, 64, 1, False]           
 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          
 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1    460288  models.c2f.C2f                          [256, 256, 1, False]          
 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [64, 128, 256]]

Model Summary: 266 layers, 1929110 parameters, 1929110 gradients, 4.4 GFLOPs

运行后打印如上代码说明改进成功。

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

拿下Nahida
关注
  • 12
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
YOLOv5/v7 引入 YOLOv8 的 C2f 模块
weixin_39818775的博客
05-26 693
YOLOv8 是 Ultralytics 团队于 2022 年 10 月发布的最新一代目标检测模型。YOLOv8 在 YOLOv7 的基础上进行了多项改进，包括引入 C2f 模块、改进 Path Aggregation Network (PAN) 结构、优化 Label Assigning 算法等。C2f 模块是 YOLOv8 中引入的主要创新之一。C2f 模块是一种轻量级的特征融合模块，可以有效提高模型的性能。
YOLOv8中的C2f的详细解读
AIOT魔法师
05-16 9248
所以每次都把y[-1]作为输入元素，迭代的结果每一次都追加在y的最后，所以每次y[-1]作为输入元素的值是上一次运行的结果，所以最后一个y[-1]是连续经过n个Bottleneck模块运算后的结果，这就是原理图，要知道Bottleneck输入输出通道数均为self.c，所以self.cv2 = Conv((2 + n)* self.c, c2, 1)中的输入通道数为(2 + n) *self.c，相信至此已经能看懂下面这个图了，图中的红色线不是特征融合的，它就是想表示Bottleneck有n个。
YOLO组件之C2f模块介绍
yueguang8的博客
05-08 5892
C2f模块在CSP Bottleneck结构中起到关键的作用，通过特征转换、分支处理和特征融合等操作，提取和转换输入数据的特征，生成更具表征能力的输出。这有助于提高网络的性能和表示能力，使得网络能够更好地适应复杂的数据任务。
YOLOv8之C2f模块——与YOLOv5的C3模块对比
热门推荐
python_plus的博客
02-26 3万+
YOLOv8的C2f模块与YOLOv5的C3模块对比
YOLOv8的c2f模块详解
weixin_43227262的博客
04-17 1万+
chunk(2,1)是指在维度1上将特征图分成2块。里面包含Bottleneck。啥也不说了，都在图里。
YOLOv8中的C2f模块
qq_45973897的博客
06-22 794
C2f块:首先由一个卷积块(Conv)组成，该卷积块接收输入特征图并生成中间特征图特征图拆分:生成的中间特征图被拆分成两部分，一部分直接传递到最终的Concat块，另一部分传递到多个Botleneck块进行进一步处理。Bottleneck块:输入到这些Botleneck块的特征图通过一系列的卷积、归一化和激活操作进行处理，最后生成的特征图会与直接传递的那部分特征图在Concat块进行拼接(Concat)。模型深度控制。
Yolov5 优化，包括Yolov8 c2f模块
jacke121的专栏
08-07 945
Yolov5/Yolov7加入Yolov8 c2f模块，涨点
YOLOV5 实战项目添加C2f模块：工具箱小型图像目标检测数据集
03-16
基于YOLOV5 对工具箱图像目标检测数据集的目标检测实战项目，包含代码、数据集、训练好的权重参数，经测试，代码可以直接使用 【数据集】分为1个类别：station 训练集datasets-images-train：132张图片和132个标签txt文件组成 测试集datasets-images-val：32张图片和32个标签txt文件组成 【yolov5】项目总大小：41MB 项目迭代了100个epoch，在runs目录下保存了训练结果，训练最好的精度map0.5=0.99，map0.5:0.95=0.79。训练过程中会生成验证集的混淆矩阵，PR曲线、F1曲线等等runs/detect目录下保存了网络推理训练集的全部结果，推理效果很好 关于yolov5训练脚本的参数介绍： https://blog.csdn.net/qq_44886601/category_12605353.html 训练代码：python train.py --cfg models/yolov5s-c2f.yaml
yolov5/v7 车牌数据集
11-17
在YOLOv5/v7中，"v7"可能指的是该模型的最新改进或优化版本，通常包括性能提升、更快的训练速度以及可能的精度改进。 数据集分为三个主要部分：train、test和valid。这些文件夹代表训练集、测试集和验证集，它们是...
可用于YOLOv5/v6/v7/v8训练的农作物杂草数据集
10-21
YOLOv5引入了更高效的训练策略和改进的网络结构，如Mosaic数据增强和Path Aggregation Network (PANet)。YOLOv6可能进一步提升了速度和精度，可能包括了最新的优化技术和架构创新。YOLOv7和v8则可能在前几代的基础上...
yolov5v7v8目标检测计数代码
02-28
这个是由微智启软件工作室改进的yolov5v7v8目标检测计数代码，可以统计检测到的类别数量进行统计，然后通过cv2显示到图片上。代码讲解可以参考csdn文档：http://t.csdnimg.cn/aQXlb
基于yolov5的戴口罩检测系统
06-02
Yolov5在前几代的基础上进行了优化，包括更高效的卷积网络结构、数据增强策略和损失函数的改进，从而提高了检测速度和精度。 数据集是训练模型的关键部分。在这个口罩检测系统中，开发者使用了特定的数据集，其中...
真实场景下煤矸石目标检测数据集，可直接用于YOLOv5/v6/v7/v8训练
03-18
真实场景下采集的煤矸石训练数据集：891...煤炭mAP@.5：0.896 矸石mAP@.5：0.811 煤炭和矸石的混合物mAP@.5：0.919 可见博客：https://blog.csdn.net/m0_51004308/article/details/136811369?spm=1001.2014.3001.5502
目标检测算法之YOLO（YOLOv8）
最新发布
weixin_52862386的博客
06-25 854
其中卷积模块是使用了类似于ELAN的CSPlayer_2conv，分类头采用了解耦结构并使用了anchor-free的方法，损失函数中引入了VFL损失，标签分配采取了类似于yolov6的TAL方法，训练策略是采用最后10个epoch关闭Mosaic数据增强的方式。DFL的思想是基于回归任务预测的唯一性导致模型难以精确的回归到目标值上，转而通过求概率分布的方式，使预测值在目标出取得较大的概率，从而实现一种通过类似于“模糊”定位的方式提高模型收敛的速度，同时提高检测模型的准确率。这里只分析VFL的损失值。
关于yolov8的一些模块
い天然呆的博客
02-06 2041
对于yolov8的c2f模块，就是上一层的输出被split成了两部分，一部分不动，另一部分经过conbnsilu提取特征在拼回去，结构图如下：onnx的netron图如下：(1)c2f(2)bottleneck对于yolov8的SPPF模块，就是上一层的输出进行convbnsilu卷积提取特征后，一部分拿去做池化，将不同层的池化特征与另一部分经过conbnsilu提取特征在拼回去，最后再进行特征提取，结构图如下：
YOLOV8改进：在c2f模块中的不同位置加入NAMAAttention注意力机制
m0_51530640的博客
04-08 3231
注意力机制是近年来研究的热点之一（Wang et al。[2017]，Hu等人[2018]，Park等人[2018]、Woo等人[2018]和Gao等人[199]）。它有助于深度神经网络抑制不太显著的像素或通道。许多先前的研究都侧重于通过注意操作捕捉显著特征（Zhang等人[2020]，Misra等人[2021年]）。这些方法成功地利用了来自不同维度特征的相互信息。然而，它们缺乏对权重的贡献因素的考虑，这能够进一步抑制不重要的通道或像素。受Liu等人的启发。
yolov7添加c2f
08-14
您好！对于将YOLOv7添加C2F（Context-to-Focus）模块，可以按照以下步骤进行： 1. 首先，您需要了解YOLOv7和C2F的基本原理和实现方式。YOLOv7是一种目标检测算法，而C2F是一种用于提取上下文信息的注意力机制模块。 2. 下载YOLOv7的代码和预训练权重。您可以在YOLOv7的官方代码库或GitHub上找到相应的资源。 3. 在YOLOv7的网络结构中添加C2F模块。根据C2F的实现方式，您需要在YOLOv7的网络中插入新的层或模块。具体的操作方法会根据您使用的深度学习框架而有所不同。 4. 根据您的需求，配置C2F模块的参数。C2F模块通常具有一些超参数，例如注意力头数、注意力权重等。您可以根据自己的需求进行调整。 5. 重新训练YOLOv7模型。在添加了C2F模块后，您需要使用新的数据集或继续使用原有数据集进行训练。根据您使用的深度学习框架，您可能需要调整训练过程中的一些设置。 6. 进行模型评估和推断。在训练完成后，您可以使用测试数据集对模型进行评估，并使用训练好的模型进行目标检测推断。 请注意，以上步骤仅提供了一般的指导，具体实现会根据您使用的YOLOv7的代码库和深度学习框架而有所不同。建议您参考相关文档和代码库中的详细说明，以确保正确地添加C2F模块到YOLOv7中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值