SPP、SPPF 、 SimSPPF 、 ASPP、 SPPCSPC详解

news2024/10/7 20:32:11

分享自：https://blog.csdn.net/weixin_43694096/article/details/126354660

1. 原理

1.1 SPP（Spatial Pyramid Pooling）

SPP 模块是何凯大神在2015年的论文《Spatial Pyramid Pooling in Deep Convolution Networks for Visual Recognition》中提出来的.

SPP全称为空间金字塔池化结构，主要是为了解决两个问题

    1. 有效避免了对图像区域的裁剪、缩放操作导致的图像失真等问题。
    1. 解决了卷积神经网络对图相关重复特征提取的问题，大大提高了产生候选框的速度，且节省了计算成本
      在这里插入图片描述
      在这里插入图片描述
class SPP(nn.Module):
    # Spatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729
    def __init__(self, c1, c2, k=(5, 9, 13)):
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))

1.2 SPPF (Spatial Pyramid Pooling - Fast)

这个是Yolov5作者基于SPP提出的，速度较SPP快很多（2.5倍），所以叫做SPP-Fast

在这里插入图片描述

class SPPF(nn.Module):
    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))

1.3 SimSPPF(Simplified SPPF)

美团YOLOv6提出的模块，感觉和SPPF只差了一个激活函数，简单测试了一下，单个ConvBNReLU速度比ConvBNSiLU快18%
在这里插入图片描述

class SimConv(nn.Module):
    '''Normal Conv with ReLU activation'''
    def __init__(self, in_channels, out_channels, kernel_size, stride, groups=1, bias=False):
        super().__init__()
        padding = kernel_size // 2
        self.conv = nn.Conv2d(
            in_channels,
            out_channels,
            kernel_size=kernel_size,
            stride=stride,
            padding=padding,
            groups=groups,
            bias=bias,
        )
        self.bn = nn.BatchNorm2d(out_channels)
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        return self.act(self.conv(x))

class SimSPPF(nn.Module):
    '''Simplified SPPF with ReLU activation'''
    def __init__(self, in_channels, out_channels, kernel_size=5):
        super().__init__()
        c_ = in_channels // 2  # hidden channels
        self.cv1 = SimConv(in_channels, c_, 1, 1)
        self.cv2 = SimConv(c_ * 4, out_channels, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))

1.4 ASPP (Atrous Spatial Pyramid Pooling)

受到SPP的启发，语义分割模型DeepLabv2中提出了ASPP模块(空洞空间金字塔池化)，该模块使用具有不同采样率的多个并行空洞卷积·。为每个采样率提取的特征在单独的分支中进一步处理，并融合以生成最终的结果。该模块通过不同的空洞率构建不同的感受野的卷积核，用来获取多尺度物体信息，具体结构比较简单如下图所示：

在这里插入图片描述
ASPP 是在DeepLab中提出来的，在后续的DeepLab版本中对其做了改进，如加入BN层，加入深度可分离卷积等，但基本的思路还是没变。

# without BN version
class ASPP(nn.Module):
    def __init__(self, in_channel=512, out_channel=256):
        super(ASPP, self).__init__()
        self.mean = nn.AdaptiveAvgPool2d((1, 1))  # (1,1)means ouput_dim
        self.conv = nn.Conv2d(in_channel,out_channel, 1, 1)
        self.atrous_block1 = nn.Conv2d(in_channel, out_channel, 1, 1)
        self.atrous_block6 = nn.Conv2d(in_channel, out_channel, 3, 1, padding=6, dilation=6)
        self.atrous_block12 = nn.Conv2d(in_channel, out_channel, 3, 1, padding=12, dilation=12)
        self.atrous_block18 = nn.Conv2d(in_channel, out_channel, 3, 1, padding=18, dilation=18)
        self.conv_1x1_output = nn.Conv2d(out_channel * 5, out_channel, 1, 1)

    def forward(self, x):
        size = x.shape[2:]

        image_features = self.mean(x)
        image_features = self.conv(image_features)
        image_features = F.upsample(image_features, size=size, mode='bilinear')

        atrous_block1 = self.atrous_block1(x)
        atrous_block6 = self.atrous_block6(x)
        atrous_block12 = self.atrous_block12(x)
        atrous_block18 = self.atrous_block18(x)

        net = self.conv_1x1_output(torch.cat([image_features, atrous_block1, atrous_block6,
                                              atrous_block12, atrous_block18], dim=1))
        return net

1.5 RFB(Receptive Field Block)

RFB模块是在《ECCV2018:Receptive Field Block Net for Accurate and Fast Object Detection》一文中提出的，该文的出发点是模拟人类视觉的感受野从而加强网络的特征提取能力，在结构RFV借鉴了Inception的思想，主要是在Inception的基础上加入了空洞卷积，从而有效增大了感受野。

在这里插入图片描述
在这里插入图片描述
RFB和RFB-s的架构，RFB-s用于浅层人类视网膜主题图中模拟较小的pRF，使用具有较小内核的更多分支。

class BasicConv(nn.Module):

    def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True, bn=True):
        super(BasicConv, self).__init__()
        self.out_channels = out_planes
        if bn:
            self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=False)
            self.bn = nn.BatchNorm2d(out_planes, eps=1e-5, momentum=0.01, affine=True)
            self.relu = nn.ReLU(inplace=True) if relu else None
        else:
            self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=True)
            self.bn = None
            self.relu = nn.ReLU(inplace=True) if relu else None

    def forward(self, x):
        x = self.conv(x)
        if self.bn is not None:
            x = self.bn(x)
        if self.relu is not None:
            x = self.relu(x)
        return x


class BasicRFB(nn.Module):

    def __init__(self, in_planes, out_planes, stride=1, scale=0.1, map_reduce=8, vision=1, groups=1):
        super(BasicRFB, self).__init__()
        self.scale = scale
        self.out_channels = out_planes
        inter_planes = in_planes // map_reduce

        self.branch0 = nn.Sequential(
            BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
            BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups),
            BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 1, dilation=vision, relu=False, groups=groups)
        )
        self.branch1 = nn.Sequential(
            BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
            BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups),
            BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 2, dilation=vision + 2, relu=False, groups=groups)
        )
        self.branch2 = nn.Sequential(
            BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
            BasicConv(inter_planes, (inter_planes // 2) * 3, kernel_size=3, stride=1, padding=1, groups=groups),
            BasicConv((inter_planes // 2) * 3, 2 * inter_planes, kernel_size=3, stride=stride, padding=1, groups=groups),
            BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 4, dilation=vision + 4, relu=False, groups=groups)
        )

        self.ConvLinear = BasicConv(6 * inter_planes, out_planes, kernel_size=1, stride=1, relu=False)
        self.shortcut = BasicConv(in_planes, out_planes, kernel_size=1, stride=stride, relu=False)
        self.relu = nn.ReLU(inplace=False)

    def forward(self, x):
        x0 = self.branch0(x)
        x1 = self.branch1(x)
        x2 = self.branch2(x)

        out = torch.cat((x0, x1, x2), 1)
        out = self.ConvLinear(out)
        short = self.shortcut(x)
        out = out * self.scale + short
        out = self.relu(out)

        return out

1.6 SPPCSPC

该模块是YOLOv7中使用的SPP结构，表现优于SPPF，但参数量和计算量提升了很多。
在这里插入图片描述

class SPPCSPC(nn.Module):
    # CSP https://github.com/WongKinYiu/CrossStagePartialNetworks
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)):
        super(SPPCSPC, self).__init__()
        c_ = int(2 * c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(c_, c_, 3, 1)
        self.cv4 = Conv(c_, c_, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
        self.cv5 = Conv(4 * c_, c_, 1, 1)
        self.cv6 = Conv(c_, c_, 3, 1)
        self.cv7 = Conv(2 * c_, c2, 1, 1)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        y1 = self.cv6(self.cv5(torch.cat([x1] + [m(x1) for m in self.m], 1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

#分组SPPCSPC 分组后参数量和计算量与原本差距不大，不知道效果怎么样
class SPPCSPC_group(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)):
        super(SPPCSPC_group, self).__init__()
        c_ = int(2 * c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1, g=4)
        self.cv2 = Conv(c1, c_, 1, 1, g=4)
        self.cv3 = Conv(c_, c_, 3, 1, g=4)
        self.cv4 = Conv(c_, c_, 1, 1, g=4)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
        self.cv5 = Conv(4 * c_, c_, 1, 1, g=4)
        self.cv6 = Conv(c_, c_, 3, 1, g=4)
        self.cv7 = Conv(2 * c_, c2, 1, 1, g=4)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        y1 = self.cv6(self.cv5(torch.cat([x1] + [m(x1) for m in self.m], 1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

1.7 SPPFCSPC

借鉴了SPPF的思想将SPPCSPC优化了一下，得到了SPPFCSPC，在保持感受野不变的情况下获得速度提升；

目前这个结构被YOLOv6 3.0版本使用了，效果很不错，大家可以看YOLOv6 3.0的论文，里面有详细的实验结果。

在这里插入图片描述

class SPPFCSPC(nn.Module):
    
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=5):
        super(SPPFCSPC, self).__init__()
        c_ = int(2 * c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(c_, c_, 3, 1)
        self.cv4 = Conv(c_, c_, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
        self.cv5 = Conv(4 * c_, c_, 1, 1)
        self.cv6 = Conv(c_, c_, 3, 1)
        self.cv7 = Conv(2 * c_, c2, 1, 1)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        x2 = self.m(x1)
        x3 = self.m(x2)
        y1 = self.cv6(self.cv5(torch.cat((x1,x2,x3, self.m(x3)),1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

2. 参数量对比

这里以yolov5s.yaml中使用各个模型替换SPP模块

在这里插入图片描述

3. 改进方式

  • (1) ： 各个代码放入common.py中
  • (2): yolo.py中加入类名
  • (3): 修改配置文件

yolov5配置文件如下:

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# 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
   # [-1, 1, ASPP, [512]],  # 9
   # [-1, 1, SPP, [1024]],
   # [-1, 1, SimSPPF, [1024, 5]],
   # [-1, 1, BasicRFB, [1024]],
   # [-1, 1, SPPCSPC, [1024]],
   # [-1, 1, SPPFCSPC, [1024, 5]], # 🍀
  ]

4 Issue

Q Why use SPPCPC instead of SPPFCSPC
yolov5’s SPPF is much faster than SPP
why not try to replace SPPCSPC with SPPFCSPC:
在这里插入图片描述

A: Max pooling uses very few compution,if you programing well, above one could run three max pool layers in parallel, while below one must process thress max pool layers sequentially
By the way,you could replace SPPCSPC by SPPFCSPC at inference time if your hardware is fridndly to SPPFCSPC

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/767516.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

前端工程化第一章：webpack基础（上）

前端工程化第一章：webpack基础（上）

文章目录 1. 什么是webpack？2. webpack使用2.2. 前置知识2.1. 创建一个项目 3. webpack打包3.1. 创建一个webpack.config.js文件3.2. 入口（entry）3.2.1. webpack.config.js3.2.2. src/index.js3.2.3. package.json 3.3. 输出（outp…
阅读更多...
C++第三讲

C++第三讲

思维导图 手动封装一个顺序栈类（数据元素为整形），要求私有成员属性：堆区空间的指针，用于存放数据，和一个指向栈顶元素的变量 /* ---------------------------------author：YoungZorncreated on…
阅读更多...
nacos集群地址配置问题

nacos集群地址配置问题

#it is ip #example 127.0.0.1:8848 127.0.0.1:8849 127.0.0.1:8850 上面的配置可能存在配置失败的情况,可以采用下面的配置 127.0.0.1:8845 127.0.0.1.8846 127.0.0.1.8847 该配置在cluster.conf文件里面
阅读更多...
还在使用冒泡排序遍历数组?No No No 库函数qsort帮你搞定所有排序还不快学起来！

还在使用冒泡排序遍历数组?No No No 库函数qsort帮你搞定所有排序还不快学起来！

🎬 鸽芷咕：个人主页 🔥 个人专栏:《快速入门C语言》《C语言初阶篇》 ⛺️生活的理想，就是为了理想的生活! 文章目录 前言💬 库函数qsort的介绍💬 库函数qsort的参数介绍💭 参数一 (void* base)…
阅读更多...
Acwing.908 最大不相交区间数量(贪心)

Acwing.908 最大不相交区间数量(贪心)

题目 给定N个闭区间[ai,bi]，请你在数轴上选择若干区间，使得选中的区间之间互不相交（包括端点)。输出可选取区间的最大数量。 输入格式 第一行包含整数N，表示区间数。 接下来N行，每行包含两个整数ai , bi&#xff0c…
阅读更多...
【基于 GitLab 的 CI/CD 实践】03、GitLab Pipeline 实践（上）

【基于 GitLab 的 CI/CD 实践】03、GitLab Pipeline 实践（上）

目录 一、GitLab Pipeline 流水线语法有哪些？流水线参数列表 如何检查语法错误？流水线语法检测 二、Pipeline 基础语法 job script before_script after_script stages 未定义 stages ​定义 stages 控制 stage 运行顺序 .pre & .post …
阅读更多...
2010年中国生态系统服务空间数据集

2010年中国生态系统服务空间数据集

摘要 生态系统服务是生态系统形成并维持的人类赖以生存和发展的环境条件与效用，是测度自然生态系统保护价值的重要指标。采用科学方法模拟生态系统服务的空间分布对掌握当前我国生态本底状况，识别生态保护重要区，从而有效支持生态管理决策具…
阅读更多...
关于金融英语的翻译技巧，你了解多少呢

关于金融英语的翻译技巧，你了解多少呢

据了解，金融英语除了具备通用英语特点之外 ，还具备自己独特的特征，如专有名词多、专业术语量大、专业缩略词等。为了确保译文的准确性，翻译金融英语时要注意以下几点技巧。 一、专业术语坚持直译。金融翻译中涉及大量金融英语特有…
阅读更多...
day10_practice

day10_practice

用面向对象思想实现数据分析 1、设计类，完成数据封装 2、设计抽象类，定义文件读取相关功能，使用子类实现具体功能(由于两份文件格式不同) 3、读取文件，产生数据对象 4、计算每天销售额 5、绘图 一、数据封装类设计 ""…
阅读更多...
Python读取骑行fit文件

Python读取骑行fit文件

目录 故事背景安装输出有心率和无心率的数据为NO.fit文件增加心率数据并保存参考文献 故事背景 有一天，我使用wahoo码表骑行记录了一段没有心率带的数据，导出fit文件至电脑。上传至捷安特APP，结果说数据不完整，此时想用代码把心率…
阅读更多...
以结果为导向的网络安全需要全面的方法

以结果为导向的网络安全需要全面的方法

Positive Technologies 信息安全分析师 Fedor Chunizhekov 谈论了该地区不断变化的网络安全形势，并重点介绍了其 "中东网络安全威胁形势 "报告中影响中东地区的要点。他还强调，为了解决核心安全问题，我们需要采用一种全面的方法来实…
阅读更多...
安全性测试的测试点

安全性测试的测试点

安全性测试的测试点 1.跨网站脚本攻击 通过脚本语言的缺陷模拟合法用户，控制其账户，盗窃敏感数据 2.注入攻击 通过构造查询对数据库、LDAP和其他系统进行非法查询 3.恶意文件执行 在服务器上执行Shell 命令Execute，获取控制权 4.伪造跨…
阅读更多...
企业如何选择通配符SSL证书？

企业如何选择通配符SSL证书？

很多企业网站因为业务需要，在同一个主域名下通常会有多个子域名。在这种情况下申请SSL证书就要很慎重，既要考虑到网站安全需要，又要考虑经济实惠。因此 OV 型的通配符证书非常适合这类企业网站。 为什么要选择通配符SSL证书？ 通…
阅读更多...
（Linux）查看端口占用并关闭进程

（Linux）查看端口占用并关闭进程

端口 查看端口占用 查看端口占用netstat -anp | grep 端口号 → 列出所有端口netstat -tunlp |grep 3306 → 端口号netstat -tunlp |grep mysql → 进程名称netstat -tunlp |grep 29520 → 进程IDnetstat -tunlp | grep 3306-t: 显示 TCP 连接-u: 显示 UDP 连接-n: 显示数字…
阅读更多...
(linux) 查看日志文件

(linux) 查看日志文件

工作用常用 服务器查看日志cat opt/service/logs/logfile.log查看 logfile.log 日志文件tail -f -n -500 opt/service/logs/logfile.log动态查看日志vim opt/service/logs/file.logvi opt/service/logs/file.log可以快速查看日志第一行cat opt/service/logs/logfile.log | gre…
阅读更多...
idea 自定义类注释模板和方法模板，无警告

idea 自定义类注释模板和方法模板，无警告

背景：idea：IntelliJ IDEA 2023.1.3 (Ultimate Edition) 效果：（主要是没无参，不会换行） 类： /** * author sss* date ${DATE} on ${TIME}* desc $NAME*/# 完全复制上面的，删除这一行…
阅读更多...
grpc --- protoc生成的pb.go文件的位置

grpc --- protoc生成的pb.go文件的位置

目录 一、环境相关版本二、go_package配置为当前目录下三、go_package配置为指定目录四、结论 一、环境相关版本 go v1.20.5 protoc v4.24.0 protoc-gen-go v1.26.0protoc-gen-go版本过高时需要指定包名，即go_package 二、go_package配置为…
阅读更多...
JMeter：性能测试和压力测试工具

JMeter：性能测试和压力测试工具

JMeter简介 JMeter时Apache下基于java的一款性能测试和压力测试工具。它基于Java开发，可对HTTP服务器华人FTP服务器，甚至是数据库进行压力测试。作为一款专业的压测工具，JMeter功能强大，本片文章中仅简单介绍与本次压测相关的内容…
阅读更多...
【Ceph集群应用】CephFS文件系统之MDS接口详解

【Ceph集群应用】CephFS文件系统之MDS接口详解

CephFS文件系统之MDS接口详解 1.创建CephFS文件系统MDS接口1.1 创建cephfs1.2 基于内核的客户端挂载1.3 基于fuse工具方式的客户端挂载 接上文基于ceph-deploy部署Ceph集群详解 1.创建CephFS文件系统MDS接口 服务端操作 （1）在admin管理节点创建mds服务…
阅读更多...
【LocalSend】开源跨平台的局域网文件传输工具，支持IOS、Android、Mac、Windows、Linux

【LocalSend】开源跨平台的局域网文件传输工具，支持IOS、Android、Mac、Windows、Linux

工作前提条件：设备使用相同的局域网。 LocalSend is a cross-platform app that enables secure communication between devices using a REST API and HTTPS encryption. Unlike other messaging apps that rely on external servers, LocalSend doesn’t require …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023