【yolov5s中加入DCNv2（可变形卷积v2）】

最新推荐文章于 2024-04-23 16:58:51 发布
最新推荐文章于 2024-04-23 16:58:51 发布
阅读量5.7k 收藏 103
点赞数 13
分类专栏： 深度学习 文章标签： python 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42550418/article/details/128037557
版权

yolov5s中加入DCNv2（可变形卷积v2）

Requirement

torch>=1.8.1
torchvision>=0.9.1

实现步骤

1.测试环境是否满足要求

import torch
import torchvision.ops
from torch import nn
import math


class DCNv2(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=3,
                 stride=1,
                 padding=1):

        super(DCNv2, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        self.stride = stride if type(stride) == tuple else (stride, stride)
        self.padding = padding
        
        # init weight and bias
        self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels, kernel_size, kernel_size))
        self.bias = nn.Parameter(torch.Tensor(out_channels))

        # offset conv
        self.conv_offset_mask = nn.Conv2d(in_channels, 
                                          3 * kernel_size * kernel_size,
                                          kernel_size=kernel_size, 
                                          stride=stride,
                                          padding=self.padding, 
                                          bias=True)
        
        # init        
        self.reset_parameters()
        self._init_weight()


    def reset_parameters(self):
        n = self.in_channels * (self.kernel_size**2)
        stdv = 1. / math.sqrt(n)
        self.weight.data.uniform_(-stdv, stdv)
        self.bias.data.zero_()


    def _init_weight(self):
        # init offset_mask conv
        nn.init.constant_(self.conv_offset_mask.weight, 0.)
        nn.init.constant_(self.conv_offset_mask.bias, 0.)


    def forward(self, x):
        out = self.conv_offset_mask(x)
        o1, o2, mask = torch.chunk(out, 3, dim=1)
        offset = torch.cat((o1, o2), dim=1)
        mask = torch.sigmoid(mask)

        x = torchvision.ops.deform_conv2d(input=x, 
                                          offset=offset, 
                                          weight=self.weight, 
                                          bias=self.bias, 
                                          padding=self.padding,
                                          mask=mask,
                                          stride=self.stride)
        return x

model = nn.Sequential(
    DCNv2(3, 32, kernel_size=3, stride=1, padding=1),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(2, 2),
    DCNv2(32, 32, kernel_size=3, stride=1, padding=1),
    DCNv2(32, 64, kernel_size=3, stride=1, padding=1),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(2, 2),
    DCNv2(64, 64, kernel_size=3, stride=1, padding=1),
    DCNv2(64, 128, kernel_size=3, stride=1, padding=1),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(2, 2),
    DCNv2(128, 128, kernel_size=3, stride=1, padding=1),
    DCNv2(128, 256, kernel_size=3, stride=1, padding=1),
    nn.ReLU(inplace=True),
    nn.MaxPool2d(2, 2)
)
x = torch.randn(2, 3, 64, 64)
y = model(x)
print(x.size())
print(y.size())
"""
torch.Size([2, 3, 64, 64])
torch.Size([2, 256, 4, 4])
"""

如果能输出，则说明环境适配。

2.修改models/yolov5s.yaml

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
# 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]  
	- [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, DCNv2, [128, 3, 2]],  						# 1-P2/4
   [-1, 3, C3, [128]],									# 2	
   [-1, 1, DCNv2, [256, 3, 2]],  						# 3-P3/8
   [-1, 6, C3, [256]],									# 4
   [-1, 1, DCNv2, [512, 3, 2]],  						# 5-P4/16
   [-1, 9, C3, [512]],									# 6
   [-1, 1, DCNv2, [1024, 3, 2]],  						# 7-P5/32
   [-1, 3, C3, [1024]],									# 8
   [-1, 1, SPPF, [1024, 5]],  							# 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],							# 10
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],			# 11
   [[-1, 6], 1, Concat, [1]],  							# 12 cat backbone P4
   [-1, 3, C3, [512, False]],  							# 13

   [-1, 1, Conv, [256, 1, 1]],							# 14
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],			# 15
   [[-1, 4], 1, Concat, [1]],  							# 16 cat backbone P3
   [-1, 3, C3, [256, False]],  							# 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],							# 18
   [[-1, 14], 1, Concat, [1]],  						# 19 cat head P4
   [-1, 3, C3, [512, False]],  							# 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],							# 21
   [[-1, 10], 1, Concat, [1]],  						# 22 cat head P5
   [-1, 3, C3, [1024, False]],  						# 23 (P5/32-large)

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

3.修改models/common.py

# --------------------------DCNv2 start--------------------------
class DCNv2(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=3,
                 stride=1,
                 padding=1):

        super(DCNv2, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        self.stride = stride if type(stride) == tuple else (stride, stride)
        self.padding = padding
        
        # init weight and bias
        self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels, kernel_size, kernel_size))
        self.bias = nn.Parameter(torch.Tensor(out_channels))

        # offset conv
        self.conv_offset_mask = nn.Conv2d(in_channels, 
                                          3 * kernel_size * kernel_size,
                                          kernel_size=kernel_size, 
                                          stride=stride,
                                          padding=self.padding, 
                                          bias=True)
        
        # init        
        self.reset_parameters()
        self._init_weight()


    def reset_parameters(self):
        n = self.in_channels * (self.kernel_size**2)
        stdv = 1. / math.sqrt(n)
        self.weight.data.uniform_(-stdv, stdv)
        self.bias.data.zero_()


    def _init_weight(self):
        # init offset_mask conv
        nn.init.constant_(self.conv_offset_mask.weight, 0.)
        nn.init.constant_(self.conv_offset_mask.bias, 0.)


    def forward(self, x):
        out = self.conv_offset_mask(x)
        o1, o2, mask = torch.chunk(out, 3, dim=1)
        offset = torch.cat((o1, o2), dim=1)
        mask = torch.sigmoid(mask)

        x = torchvision.ops.deform_conv2d(input=x, 
                                          offset=offset, 
                                          weight=self.weight, 
                                          bias=self.bias, 
                                          padding=self.padding,
                                          mask=mask,
                                          stride=self.stride)
        return x
# ---------------------------DCNv2 end---------------------------

4.修改models/yolo.py

if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,BottleneckCSP, C3]:
#在列表加DCNv2
if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,BottleneckCSP, C3, DCNv2]:

完成以上操作后，在train.py中导入对应的yaml文件和确认参数，即可开始训练。

参考

【1】 https://blog.csdn.net/shuaijieer/article/details/126249088
【2】 https://github.com/yjh0410/PyTorch_DCNv2

just f
关注
  • 13
    点赞
  • 踩
  • 103
    收藏
    觉得还不错? 一键收藏
  • 29
    评论
专栏目录
优化改进YOLOv5算法之添加DCNv3模块，有效提升目标检测效果
qq_40716944的博客
11-05 1395
拿到文章之后先看了一眼在ImageNet1k上的结果，确实很高，超越了同等大小下的VAN、RepLKNet、ConvNext等先进的大核注意力CNN模型，同时也超过了Swin、DeiT3、CoAtNet等ViT模型。回顾自从Vision Transformer被提出之后，通过大量数据训练出的ViT大模型刷新了许多视觉任务的记录，这得益于ViT的MHSA机制能够建模长距离依赖，具有相当低的归纳偏置，从而能够在海量数据中学习到强大鲁棒的特征表达。
DCNv2-master.zip
06-30
支持pytorch1.7版本，不用做较大修改即可运行
Yolov8对接DCNV2
抓饭不吃皮牙子
11-22 365
在计算机视觉领域中，目标检测是一项重要的任务。Yolov8是一种非常流行的目标检测算法，而DCNV2（Dilated Convolutional Network V2）则是一种卷积神经网络，被广泛用于语义分割任务。本文将介绍如何将Yolov8与DCNV2相结合，实现目标检测和语义分割的联合任务。Yolov8是一种基于深度学习的目标检测算法，它通过将图像划分为不同大小的网格单元，在每个单元中预测目标的类别和边界框。Yolov8通过使用多个卷积层和池化层来提取特征，然后通过全连接层进行目标分类和边界框回归。
牵绳遛狗你我他文明家园每一天，助力共建文明社区，基于YOLOv6开发构建公共场景下未牵绳遛狗检测识别系统
Together_CZ的博客
01-05 875
牵绳遛狗你我他文明家园每一天，助力共建文明社区，基于YOLOv6开发构建公共场景下未牵绳遛狗检测识别系统
YOLOv5结构改进——dynamicRELU和可变形卷积(DCN)
smallbig12的博客
02-25 1925
红外图像检测
关于YOLOv5中neck部分引入DCNv2替换标准卷积
qq_44438961的博客
06-09 471
引入DCnv2会很轻松的加入YOLOV5的主干部分，但是在引入NEck部分后就会报错RuntimeError:类似与这种的。
[yolov5修改]在yolov5中加入可变形卷积模块
PLH19990227的博客
05-16 3251
在yolov5中加入可变形卷积（DeformableConvolution)，效果明显。
YOLOV5改进（DCN）
eagleflying_cau的博客
06-07 709
（False,True,True,True）可以看出其对DCN的使用和PP-YOLO类似就是后面三个卷积替换成DCN。（3）更换.yaml中backbone的C3。（四个block替换后三个block）（2）在models/yolo.py中的解析模型中增加C3_DCN。（1）将下方代码复制到models/commen.py中。（2）Cascade-RCNN中对DCN的使用。（1）PP-YOLO使用DCN的方法。可以看出只是将最后一层卷积换成DCN。（3）为什么要使用可变形卷积。
YOLOv5，YOLOv8改进-修改DCNv2
weixin_45303602的博客
08-10 1402
1. 概述Deep&Cross Network（DCN）[1]是由Google于2017年提出的用于计算CTR问题的方法，是对Wide&Deep[2]模型的进一步改进。线性模型无法学习到特征的交叉属性，需要大量的人工特征工程的介入，深度网络对于交叉特征的学习有着天然的优势，在Wide&Deep模型中，Deep侧已经是一个DNN模型，而Wide侧是一个线性模型LR，无法有效的学习到交叉特征。
论文及代码详解——可变形卷积（DCNv2）
zyw2002的博客
08-17 5607
DCNv2 是在DCNv1的基础上的改进版。理解DCNv2之前，建议先读。
yolov5 加入可形变卷积
weixin_43960370的博客
04-04 429
找到parse_model函数，把DCNConv加入进去。修改yolov5s.yaml文件。修改common.py 文件。运行下面命令查看网络结构。修改yolo.p文件。
pytorch版可变形卷积代码DCNv2.zip
04-09
pytorch版可变形卷积代码DCNv2，下载编译可直接使用，内附编译过程及详细使用方法。在Ubuntu环境下使用的。
Deformable-Convolution-V2-PyTorch:PyTorch中的可变形ConvNets V2（DCNv2）
04-13
PyTorch中的Deformable-ConvNets-V2 此存储库是的实现。 从原始移植。 有关完整框架，请参考此。 在可以找到基于mmdetection代码库的DCNv2的结果。 非常感谢强大而干净的框架。 master分支中的运算符与pytorch_v0.4.1兼容。 对于pytorch v1.0.0（由Jiajiai 实现）上的运算符，请参阅。 多亏了和mmlab的其他贡献者，DCNv2现在已基于该分支的主分支纳入正式的mmdetection回购中。 现在，它是使用新的cpp扩展api编写的，并且支持PyTorch 0.4.1和1.0，但速度和内存优化较小。 结果和模型可以在找到。 建造 sh make.sh 有关用法示例，请参见test.py和test_modulated.py 。 注意 此仓库提供了可变形的conv层，该层可在Deformable ConvNets
DCNv2ubuntu16.04下编译好的
11-12
可变形卷积dcnv2编译，ubuntu16.04下编译好的，cuda10.0，cudnn7.1.3，欢迎下载
DCNv2可变形卷积开发包
11-13
可变性卷积的思想很简单，就是讲原来固定形状的卷积核变成可变的。同时可以去我的github地址去下载：https://github.com/z1z9b89/DCNv2
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, ...
【编译程序介绍】
武帝为此的博客
04-22 1229
简单来说，编译程序是一个软件，它读取用某种编程语言编写的源代码，分析并转换成等效的、可执行的机器语言代码。这个过程涉及多个复杂的步骤，包括语法分析、语义分析、代码优化和代码生成等。
实现自定义注解、实现自定义幂等性注解
最新发布
qq_44721738的博客
04-23 629
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
【InternLM实战营---第五节课作业】
weixin_45609124的博客
04-22 807
LMDeploy环境配置及基础使用
yolov8+DCN
02-26
YOLOv8+DCN是一种目标检测算法结合了YOLOv8和DCN（Deformable Convolutional Networks）两个模型的特点。 YOLOv8是一种实时目标检测算法，它采用了单阶段的检测方法，将目标检测任务转化为一个回归问题。YOLOv8通过将输入图像划分为不同的网格单元，并在每个单元中预测目标的类别和位置信息。相比于传统的两阶段方法，YOLOv8具有更快的检测速度，但可能会牺牲一定的准确性。 DCN是一种改进的卷积操作，它通过引入可变形卷积核来提升模型对目标形变的适应能力。传统的卷积操作在感受野内只考虑了固定形状的卷积核，而DCN可以根据目标的形变情况自适应地调整卷积核的形状。这样可以更好地捕捉目标的细节信息，提高目标检测的准确性。 将YOLOv8和DCN结合起来，可以在保持较快检测速度的同时，提升目标检测算法对目标形变的适应能力。通过引入DCN模块，YOLOv8+DCN可以更好地处理目标的尺度变化、姿态变化等情况，提高目标检测的准确性和鲁棒性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值