【YOLOv5/v7改进系列】引入PConv——轻量快速的卷积块

已于 2024-06-25 01:29:04 修改
阅读量4.3k 收藏 58
点赞数 43
分类专栏： YOLO改进指南 文章标签： python 人工智能 开发语言 YOLO 目标检测 计算机视觉 dnn
于 2024-06-25 01:17:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/139902234
版权

一、导言

《奔跑吧，别走：追求更高的FLOPS以实现更快的神经网络》，主要探讨了如何设计快速且高效的神经网络模型。文章指出，尽管许多研究致力于减少浮点运算次数(FLOPs)来提升模型速度，但FLOPs的减少并不直接等同于延迟的降低。作者发现，问题的核心在于较低的每秒浮点运算次数(FLOPS)，这主要是由于操作过程中频繁的内存访问，尤其是深度卷积(DWConv)带来的影响。

创新点

  1. 提出部分卷积(Partial Convolution, PConv)：针对现有网络中由于增加网络宽度以补偿精度下降而导致的内存访问增加问题，该文提出了部分卷积(PConv)。PConv通过仅在输入通道的部分上应用滤波器，同时减少了冗余计算和内存访问，从而更高效地提取空间特征。

  2. 构建FasterNet系列模型：基于PConv，文章进一步设计了名为FasterNet的新家族神经网络，这些网络在多种设备上实现了显著的运行速度提升，同时保持了在不同视觉任务上的准确性。例如，FasterNet-T0相比MobileViT-XXS在GPU、CPU和ARM处理器上分别快2.8倍、3.3倍和2.4倍，且准确率更高。大型的FasterNet-L在保持与Swin-B相当的高精度（83.5%）的同时，GPU上的推理吞吐量提高了36%，CPU上的计算时间节省了37%。

优点
  • 针对性优化：通过关注并解决深度卷积导致的内存访问效率问题，论文提出的PConv能更有效地利用硬件资源。
  • 广泛适用性：FasterNet模型在不同尺寸和应用场景下均展现出卓越性能，从轻量级到大型模型均有覆盖。
  • 代码开放：提供了开源代码，便于学术界和工业界复现研究结果，促进技术传播和进一步创新。
结论

本文通过提出部分卷积(PConv)这一新颖操作以及构建FasterNet模型系列，为追求高性能与低延迟的神经网络设计提供了一个创新思路。它不仅在理论层面分析了当前模型速度瓶颈，还在实践层面展示了显著的性能提升，具有重要的研究价值和实际应用潜力。未来工作可进一步探索PConv与其他优化技术的集成，以及在更多任务和平台上的表现。

二、准备工作

首先在YOLOv5/v7的models文件夹下新建文件pconv.py，导入如下代码

from models.common import *


"""
https://arxiv.org/abs/2303.03667
<<Run, Don't Walk: Chasing Higher FLOPS for Faster Neural Networks>>
"""

from torch import Tensor


class PConv(nn.Module):
    def __init__(self,
                 in_channels,
                 kernel_size=3,
                 n_div: int = 4,
                 forward: str = 'split_cat'):
        super(PConv, self).__init__()
        assert in_channels > 4, "in_channels should > 4, but got {} instead.".format(in_channels)
        self.dim_conv = in_channels // n_div
        self.dim_untouched = in_channels - self.dim_conv

        self.conv = nn.Conv2d(in_channels=self.dim_conv,
                              out_channels=self.dim_conv,
                              kernel_size=kernel_size,
                              stride=1,
                              padding=(kernel_size - 1) // 2,
                              bias=False)

        if forward == 'slicing':
            self.forward = self.forward_slicing

        elif forward == 'split_cat':
            self.forward = self.forward_split_cat

        else:
            raise NotImplementedError("forward method: {} is not implemented.".format(forward))

    def forward_slicing(self, x: Tensor) -> Tensor:
        x[:, :self.dim_conv, :, :] = self.conv(x[:, :self.dim_conv, :, :])

        return x

    def forward_split_cat(self, x: Tensor) -> Tensor:
        x1, x2 = torch.split(x, [self.dim_conv, self.dim_untouched], dim=1)
        x1 = self.conv(x1)
        x = torch.cat((x1, x2), dim=1)

        return x

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

from models.pconv import PConv

并搜索def parse_model(d, ch)

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

        elif m is PConv:
            c1 = ch[f]
            args = [c1, *args[0:]]

三、YOLOv7-tiny改进工作

完成二后，在YOLOv7项目文件下的models文件夹下创建新的文件yolov7-tiny-pconv.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, v7tiny_SPP, [256]], # 29
  
   [-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)]],  # 39
  
   [-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)]],  # 49
   
   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 39], 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)]],  # 57
   
   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 29], 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, PConv, [3, 4, 'split_cat']],
   [-1, 1, PConv, [3, 4, 'split_cat']],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 65
      
   [49, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [57, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [65, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[66, 67, 68], 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    657408  models.common.v7tiny_SPP                [512, 256]                    
 30                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 32                21  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 33          [-1, -2]  1         0  models.common.Concat                    [1]                           
 34                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 35                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 37                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 39                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 40                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 41                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 42                14  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 43          [-1, -2]  1         0  models.common.Concat                    [1]                           
 44                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 45                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 47                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 49                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 50                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 51          [-1, 39]  1         0  models.common.Concat                    [1]                           
 52                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 56  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 57                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 58                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 59          [-1, 29]  1         0  models.common.Concat                    [1]                           
 60                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 61                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 62                -1  1      9216  models.pconv.PConv                      [128, 3, 4, 'split_cat']      
 63                -1  1      9216  models.pconv.PConv                      [128, 3, 4, 'split_cat']      
 64  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 65                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 66                49  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 67                57  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 68                65  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 69      [66, 67, 68]  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: 256 layers, 5737996 parameters, 5737996 gradients, 13.0 GFLOPS

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

四、YOLOv5s改进工作

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

# 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, 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, PConv, [3, 4, 'split_cat']], # add

   [[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    147456  models.pconv.PConv                      [512, 3, 4, 'split_cat']      
 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: 249 layers, 5987062 parameters, 5987062 gradients, 15.1 GFLOPs

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

五、YOLOv5n改进工作

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

# Parameters
nc: 80  # 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, PConv, [3, 4, 'split_cat']], # add

   [[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     36864  models.pconv.PConv                      [256, 3, 4, 'split_cat']      
 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: 249 layers, 1505686 parameters, 1505686 gradients, 4.0 GFLOPs

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

六、注意事项

一般来说，PConv只适用于替换YOLO网络中3x3、步调为1的卷积，如

本文只是作为一个示例更改，实际更改需根据自己的需求与实际情况进行替换。

对于本文存在疑问的地方欢迎评论区讨论，也欢迎读者训练后或发现问题进行反馈以便我持续更新该文章！

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

YOLOv12改进策略【卷积层】| CVPR-2023 部分卷积 PConv 轻量化卷积，降低内存占用
Limiiiing的博客
03-12 448
本文记录的是利用优化的目标检测方法研究。深度可分离卷积可以减少FLOPs，但会导致更高的内存访问，引起延迟并减慢整体计算。部分卷积利用逐点卷积处理通道冗余，减少模型计算量和内存访问量。Run, Don’t Walk: Chasing Higher FLOPS for Faster Neural Networks及其改进的实现代码如下： 四、创新模块 4.1 改进点⭐ 模块改进方法：直接加入（第五节讲解添加步骤）。模块加入如下：模块改进方法：基于的（第五节讲解添加步骤）。第二种改进方法是对中的进行改进，并将
YOLOv8改进 | 卷积模块 | 减少冗余计算和内存访问的PConv【CVPR2023】
kay_545
07-02 2682
yolov8，pconv，yolov8改进
【第3篇】FasterNet(CVPR2023)：基于部分卷积PConv，打造更快精度更高更具成本效益的神经网络！
最新发布
weixin_38647644的博客
04-29 1032
本文介绍FasterNet（CVPR2023, 由香港科技大学出品），一种基于部分卷积网络PConv的新网络，模型的动机在于减少计算冗余和内存访问提升更快的速度同时，保持更高的精度。PConv通过仅对特征中的部分通道应用常规卷积，有效地降低了FLOPs，提高了计算效率。实验结果显示，FasterNet在GPU、CPU和ARM处理器上均表现出优于MobileViT的性能，同时保持了高精度。
(即插即用模块-Convolution部分) 二、(CVPR 2023) PConv 部分卷积
wei582636312的博客
12-02 2795
论文中指出现有网络虽然可以通过降低 FLOPs 来提高速度，但 FLOPs 并不等于实际计算速度，因为内存访问也占用了大量时间。在此之前。深度可分离卷积 (DWConv) 虽然降低了 FLOPs，但增加了内存访问次数，导致计算速度反而下降。因此，需要一种新的算子，既能降低 FLOPs，又能保持较高的计算速度。所以论文提出一种部分卷积（Partial Convolution），PConv 利用特征图中的冗余信息，只对部分输入通道进行卷积操作，而保留其他通道不变。这样可以减少计算冗余和内存访问次数，从而提高计算
部分卷积PConv代码详解
m0_73085157的博客
07-02 4775
`torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)`将输入张量`x`分割为两个张量：`x1`具有`self.dim_conv3`个通道（将进行卷积），`x2`具有`self.dim_untouched`个通道（不进行卷积）。- 根据`forward`的值，将`self.forward`方法设置为`self.forward_slicing`或`self.forward_split_cat`。它接受一个输入张量`x`并应用部分卷积操作。
PConv_in_tf:'使用部分卷积对不规则Kong进行图像修补'的第一个tensorflow主实例，使用tensorflow完全实现，而无需修改源代码-tensorflow source code
03-24
PConv_in_tf “使用部分卷积对不规则Kong进行图像修补”第一个tensorflow主实例，使用tensorflow完全实现，而无需修改源代码。 部分转化 使用curr_bin_mask表示当前二进制文件的掩码； conved_mask表示二进制掩码的卷积结果，对应于文本中的sum（M）； new_bin_mask表示卷积后的新二进制掩码，更新规则为： （（conved_mask == 0）== 0） 因此，局部卷积的计算如下： Pconv（x）=（Conv（x * curr_bin_mask）*隐蔽掩码+ b）* new_bin_mask 如文本中所述，使用新掩码的操作是为了确保无效输入为零。 网络结构 用局部卷积代替卷积 面膜生成 与原始版本不同，我使用opencv生成了一个掩码，并将无效零件输入设置为零。 为了确保面罩的不规则性而无填充，面罩部分中的单元数也是随机的，
YOLOv7改进：引入CVPR2023最新之作：Pconv，实现有效涨点
2201_76125261的博客
10-05 662
为了设计快速神经网络，许多工作都集中在减少浮点运算（FLOP）的数量上。然而，我们观察到FLOP的这种减少不一定会导致延迟的类似程度的减少。这主要源于每秒低浮点运算（FLOPS）效率低下。为了实现更快的网络，我们重新访问了流行的运算符，并证明了如此低的FLOPS主要是由于运算符的频繁内存访问，尤其是深度卷积。因此，我们提出了一种新的部分卷积（PConv），通过同时减少冗余计算和内存访问，可以更有效地提取空间特征。
YoloV9实战与改进——专栏目录
m0_47867638的博客
05-20 1288
这里有一波Yolov9的升级大招，带你领略最新论文的精华！💥 什么注意力机制加持、卷积层大换血、Block设计革新、Backbone重磅升级、Head部分重塑，还有优化器全面升级，统统给你安排上了！真的是干货满满，让你有N种升级选择，总有一款适合你！我们还为你准备了专属QQ群，群里有大神答疑解惑，大家可以一起学习、一起进步！订阅后，输出你的订单号，马上就能入群嗨皮啦！订阅后，我可以手把手教你如何改进模型，并在论文中完美呈现！：目前已经更新了8篇，精彩内容源源不断，等你来探索！别犹豫了，赶快加入我们吧！
YoloV10——专栏目录
m0_47867638的博客
10-21 476
汲取最新论文精华，给你一整套YoloV10升级秘籍！包括但不限于：注意力加持、卷积大换血、Block革新、Backbone升级、Head重塑，还有优化器大换血！每篇都是干货，给你N种升级选择！：订阅后，独家资源等你解锁！实测数据集、详细代码和PDF教程，全部为你精心准备，只为你能更深入地学习和提升！还有专属QQ群等你加入，答疑解惑，一起进步！订阅后，输出订单号，即可入群！：已经更新23篇，精彩不断，持续更新中…记得订阅后，更多独家资源等你来拿！：质量为王，力求每篇都是精品！用心打造，只为更好的你！
【专栏目录】
热门推荐
m0_47867638的博客
07-16 1万+
本专栏是讲解如何改进Yolov8的专栏。改进方法采用了最新的论文提到的方法。改进的方法包括：增加注意力机制、更换卷积、更换block、更换backbone、更换head、更换优化器等；每篇文章提供了一种到N种改进方法。评测用的数据集是我自己标注的数据集，里面包含32种飞机。每种改进方法我都做了测评，并与官方的模型做对比。代码和PDF版本的文章，我在验证无误后会上传到百度网盘中，方便大家下载使用。这个专栏，求质不求量，争取尽心尽力打造精品专栏！！！！！
风车形卷积（PConv）详解及代码复现
hasakie的博客
01-20 2419
在实际应用中，PConv的特征提取过程可以与其他先进的卷积技术（如可变形卷积）结合使用，以进一步提升模型的性能和适应性。例如，可以在PConv的基础上引入可变形卷积，使卷积核能够根据目标的形状和位置进行更灵活的调整，从而更好地捕捉目标的特征。研究表明，采用这些优化方法的PConv模型在处理大规模图像数据时，能够实现数倍甚至数十倍的加速，同时保持与原始模型相当的性能。例如，在处理3D的血管、气管等复杂结构时，PConv能够动态调整卷积核和mask矩阵，更好地捕捉目标的空间特征。
基于部分卷积Pconv的图片修复
年轻即出发，
11-06 1万+
论文：Image Inpainting for Irregular Holes Using Partial Convolutions  Github： https://github.com/MathiasGruber/PConv-Keras https://github.com/deeppomf/DeepCreamPy#dependencies-for-running-the-code-yo...
pytorch代码实现之Partial Convolution (PConv卷积)
DM_zx的博客
09-11 6052
Partial Convolution (PConv卷积)
Yolov8小目标检测（15）：新的Partial卷积(PConv) ，减少冗余计算和内存访问 | CVPR2023 FasterNet
09-04 2812
PConv| 亲测在红外弱小目标检测涨点，map@0.5 从0.755提升至0.758，同时参数量param及计算量FLOPs都有降低
PConv的介绍
wangnvshibeib的博客
03-02 4992
在3D建模领域，PConv也展现出其处理不规则数据的能力。与传统的卷积操作相比，部分卷积并不是机械地对输入数据的所有部分应用相同的卷积核。相反，它根据数据的有效性，即数据点是否缺失或被损坏，来动态地决定卷积核的作用范围。对于那些有效的、非缺失的数据点，PConv会像常规的卷积操作一样应用卷积核。在实际应用中，数据缺失是一个常见的问题，尤其是在处理图像、时间序列或其他类型的数据时。总的来说，部分卷积通过其独特的数据处理方式和动态卷积核调整机制，为处理包含缺失数据的复杂任务提供了一种强大而有效的工具。
YOLOv7升级：引入CVPR2023最新技术Pconv，提升计算机视觉性能
QvisCs的博客
09-16 1424
综上所述，通过引入最新的CVPR2023会议中提出的Pconv技术，我们可以改进YOLOv7目标检测算法，提高计算机视觉任务的性能抱歉，我之前的回答有误。此外，我无法直接提供源代码。计算机视觉领域一直在不断发展和创新，为了提高目标检测算法的性能，我们可以结合最新的CVPR2023会议中提出的Pconv技术来改进YOLOv7算法。请注意，由于我无法提供关于CVPR2023的最新技术和具体实现细节，您可能需要参考相关的研究论文、代码库或其他资源，以获得关于Pconv在YOLOv7中的具体实现方法和源代码。
【第74篇】 FasterNet：CVPR2023年最新的网络，基于部分卷积PConv，性能远超MobileNet，MobileVit
AI浩
03-13 1万+
为了设计快速神经网络，许多工作都专注于减少浮点运算(FLOPs)的数量。然而，我们观察到这样的flop减少并不一定会导致类似水平的延迟减少。这主要源于低效的低浮点运算每秒(FLOPS)。为了实现更快的网络，我们重新考察了流行的运算符，并证明了这样低的FLOPS主要是由于运算符频繁的内存访问，特别是深度卷积。因此，我们提出了一种新的部分卷积(PConv)，通过同时减少冗余计算和内存访问，更有效地提取空间特征。
YOLO即插即用---PConv
llz19670的博客
11-06 2159
论文地址：2303.03667。
【读点论文】FalconNet: Factorization for the Light-weight ConvNets，分解1*1卷积，融合重参数化技巧，设计出新的轻量化卷积块
白水空空
12-28 1856
因此，我们进一步将元基本块简化为Meta Light Block（图a），它由两个PWConv层（扩展比为λ）和中间的单个空间算子层组成。用于高效轻量级模型的简化 Meta Light Block。还选择了一些相应实例化的基本块（例如IRB和FFN）来展示。
Pconv
03-24
<think>好的，我现在需要处理用户关于PConv图像修复技术的询问，用户提到了PyTorch实现和OpenCV应用。首先，我需要回忆PConv（Partial Convolution）的基本概念，这是来自论文《Image Inpainting for Irregular Holes Using Partial Convolutions》的技术，用于处理不规则孔的图像修复。用户可能已经看过示例中的引用，所以需要结合这些信息。 用户的问题集中在PyTorch实现和OpenCV应用上。首先，我要确定是否有现成的PyTorch实现。示例中提到的引用[^1]是Keras的非官方实现，但用户需要的是PyTorch。可能需要查找是否有类似的PyTorch项目，或者指导用户如何将Keras代码转换为PyTorch。另外，用户提到OpenCV应用，可能想知道如何将PConv与OpenCV结合使用，比如预处理或后处理步骤。 接下来，我需要确保回答符合系统级指令，特别是关于LaTeX格式和引用标注。在解释技术细节时，比如Partial Convolution的公式，需要使用正确的LaTeX格式，例如$M$表示掩码，$W$是卷积核，然后写出计算公式。这部分需要正确应用数学公式的规则，行内公式用$...$，独立公式用$$...$$。 然后，关于PyTorch实现，可能需要提供一个基本的代码框架，比如定义PartialConv2d类，继承自nn.Module，并实现前向传播。需要确保代码正确，比如如何处理掩码更新，以及如何计算有效像素区域。同时，需要指出这只是一个简化示例，实际项目可能需要更复杂的处理，比如多层网络结构和损失函数。 对于OpenCV的应用，用户可能想了解如何利用OpenCV进行图像处理来辅助PConv模型。例如，使用OpenCV读取图像、生成掩码，或者后处理修复后的图像。这部分需要给出具体的代码示例，比如用cv2.inpaint函数，但也要说明传统方法和基于深度学习的区别，避免混淆。 还需要生成相关问题，可能涉及PConv的理论基础、与传统方法的对比、训练数据的需求、实际应用中的挑战等。这些问题需要自然相关，帮助用户进一步探索。 最后，检查所有引用是否正确标注，确保引用的论文和项目地址准确无误。同时，保持回答结构清晰，分点说明，符合用户可见层的要求。</think>以下是关于PConv（Partial Convolution）图像修复技术的解析： ### PConv技术概念 Partial Convolution是一种针对图像修复任务的卷积操作，核心思想是**仅根据有效像素区域更新特征值**。其数学定义为： $$x' = \begin{cases} W^T (X \odot M) \frac{\text{sum}(1)}{\text{sum}(M)} + b, & \text{if sum}(M) > 0 \\ 0, & \text{otherwise} \end{cases}$$ 其中$M$是二进制掩码（1表示有效像素），$X$是输入特征，$W$和$b$是卷积参数[^2]。 ### PyTorch实现要点 ```python import torch import torch.nn as nn class PartialConv2d(nn.Conv2d): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.mask_updater = torch.ones(1, 1, self.kernel_size[0], self.kernel_size[1]) def forward(self, input, mask): with torch.no_grad(): updated_mask = F.conv2d(mask, self.mask_updater, bias=None, stride=self.stride, padding=self.padding) mask_ratio = (self.kernel_size[0] * self.kernel_size[1]) / (updated_mask + 1e-8) updated_mask = torch.clamp(updated_mask, 0, 1) mask_ratio = mask_ratio * updated_mask # 特征计算 raw_out = super().forward(input * mask) output = raw_out * mask_ratio if self.bias is None else raw_out * mask_ratio + self.bias.view(1,-1,1,1) return output, updated_mask ``` 此实现包含掩码更新机制和特征重归一化，实际应用中需要配合UNet等网络结构[^1]。 ### OpenCV相关应用 1. **预处理辅助**： ```python import cv2 # 生成初始掩码 mask = cv2.inRange(img_hsv, lower_red, upper_red) # 示例：检测红色标记区域 mask = cv2.dilate(mask, np.ones((5,5), np.uint8)) # 膨胀处理 ``` 2. **后处理优化**： ```python # 修复结果边缘融合 result = cv2.seamlessClone(pconv_output, origin_img, mask, center, cv2.NORMAL_CLONE) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拿下Nahida

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值