yolov5-7.0修改骨干网络Ghostnet\efficientnet_b0\MobileNetv3_small\ShuffleNetV2

已于 2024-03-06 14:17:21 修改
阅读量703 收藏 20
点赞数 4
分类专栏： 模型分享 文章标签： YOLO 人工智能 python 深度学习
于 2023-11-11 14:01:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45866058/article/details/134347370
版权

修改骨干网络主要需要添加模块到models/common.py文件中，在models/yolo.py文件夹中进行注册，修改models下面的yaml文件中的网络结构。

一、添加Ghostnet网络，替换Backbone

（yolov5-7.0的models/hu/yolov5s-ghost已经包含整体替换）:

class C3Ghost(C3):

    # C3 module with GhostBottleneck()

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):

        super().__init__(c1, c2, n, shortcut, g, e)

        c_ = int(c2 * e)  # hidden channels

        self.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n)))





class GhostConv(nn.Module):

    # Ghost Convolution https://github.com/huawei-noah/ghostnet

    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, groups

        super().__init__()

        c_ = c2 // 2  # hidden channels

        self.cv1 = Conv(c1, c_, k, s, None, g, act=act)

        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)



    def forward(self, x):

        y = self.cv1(x)

        return torch.cat((y, self.cv2(y)), 1)

class GhostBottleneck(nn.Module):

    # Ghost Bottleneck https://github.com/huawei-noah/ghostnet

    def __init__(self, c1, c2, k=3, s=1):  # ch_in, ch_out, kernel, stride

        super().__init__()

        c_ = c2 // 2

        self.conv = nn.Sequential(

            GhostConv(c1, c_, 1, 1),  # pw

            DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),  # dw

            GhostConv(c_, c2, 1, 1, act=False))  # pw-linear

        self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False), Conv(c1, c2, 1, 1,

                                                                            act=False)) if s == 2 else nn.Identity()



    def forward(self, x):

        return self.conv(x) + self.shortcut(x)

修改步骤：

1. common.py与yolo.py文件已经包含ghost相关模块的配置和引用；

2.yolov5s_Ghost_backnone.yaml文件配置

# YOLOv5 ��� by Ultralytics, AGPL-3.0 license



# 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, GhostConv, [128, 3, 2]],  # 1-P2/4

   [-1, 3, C3Ghost, [128]],

   [-1, 1, GhostConv, [256, 3, 2]],  # 3-P3/8

   [-1, 6, C3Ghost, [256]],

   [-1, 1, GhostConv, [512, 3, 2]],  # 5-P4/16

   [-1, 9, C3Ghost, [512]],

   [-1, 1, GhostConv, [1024, 3, 2]],  # 7-P5/32

   [-1, 3, C3Ghost, [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, C3, [1024, False]],  # 23 (P5/32-large)



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

  ]

二、添加efficientnet_b0网络

修改步骤：

1. common.py

# ---------------------------- efficientnet_b0 start -------------------------------



class effb0(nn.Module):

    def __init__(self, *args) -> None:

        super().__init__()

        model = models.efficientnet_b0(pretrained=True)

        modules = list(model.children())

        modules = modules[0][args[1]:args[2]]

        self.model = nn.Sequential(*modules)

    def forward(self, x):

        return self.model(x)



# ---------------------------- efficientnet_b0 end ---------------------------------

2. yolo.py文件

parse_model函数中添加

 elif m is effb0:    
              
            c2 = args[0]

3. yolov5s_efficientnet_b0.yaml文件配置

# YOLOv5 ��� by Ultralytics, GPL-3.0 license



# 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, effb0, [40,0,4]],  # 0

   [-1, 1, effb0, [112,4,6]],  # 1

   [-1, 1, effb0, [1280,6,9]],  # 2

   [-1, 1, SPPF, [1024, 5]],  # 3

  ]



# YOLOv5 v6.0 head

head:

  [[-1, 1, Conv, [512, 1, 1]],

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 1], 1, Concat, [1]],  # cat backbone P4

   [-1, 3, C3, [512, False]],  # 7



   [-1, 1, Conv, [256, 1, 1]],

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 0], 1, Concat, [1]],  # cat backbone P3

   [-1, 3, C3, [256, False]],  # 11 (P3/8-small)



   [-1, 1, Conv, [256, 3, 2]],

   [[-1, 7], 1, Concat, [1]],  # cat head P4

   [-1, 3, C3, [512, False]],  # 14 (P4/16-medium)



   [-1, 1, Conv, [512, 3, 2]],

   [[-1, 3], 1, Concat, [1]],  # cat head P5

   [-1, 3, C3, [1024, False]],  # 17 (P5/32-large)



   [[11, 14, 17], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)

  ]

三、添加MobileNetv3_small网络

修改步骤：

1. common.py

# ---------------------------- MobileBlock small start -------------------------------

# Mobilenetv3Small

class SeBlock(nn.Module):

    def __init__(self, in_channel, reduction=4):

        super().__init__()

        self.Squeeze = nn.AdaptiveAvgPool2d(1)



        self.Excitation = nn.Sequential()

        self.Excitation.add_module('FC1', nn.Conv2d(in_channel, in_channel // reduction, kernel_size=1))  # 1*1卷积与此效果相同

        self.Excitation.add_module('ReLU', nn.ReLU())

        self.Excitation.add_module('FC2', nn.Conv2d(in_channel // reduction, in_channel, kernel_size=1))

        self.Excitation.add_module('Sigmoid', nn.Sigmoid())



    def forward(self, x):

        y = self.Squeeze(x)

        ouput = self.Excitation(y)

        return x * (ouput.expand_as(x))





class Conv_BN_HSwish(nn.Module):

    """

    This equals to

    def conv_3x3_bn(inp, oup, stride):

        return nn.Sequential(

            nn.Conv2d(inp, oup, 3, stride, 1, bias=False),

            nn.BatchNorm2d(oup),

            h_swish()

        )

    """



    def __init__(self, c1, c2, stride):

        super(Conv_BN_HSwish, self).__init__()

        self.conv = nn.Conv2d(c1, c2, 3, stride, 1, bias=False)

        self.bn = nn.BatchNorm2d(c2)

        self.act = nn.Hardswish()



    def forward(self, x):

        return self.act(self.bn(self.conv(x)))





class MobileNetV3_InvertedResidual(nn.Module):

    def __init__(self, inp, oup, hidden_dim, kernel_size, stride, use_se, use_hs):

        super(MobileNetV3_InvertedResidual, self).__init__()

        assert stride in [1, 2]



        self.identity = stride == 1 and inp == oup



        if inp == hidden_dim:

            self.conv = nn.Sequential(

                # dw

                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim,

                          bias=False),

                nn.BatchNorm2d(hidden_dim),

                nn.Hardswish() if use_hs else nn.ReLU(),

                # Squeeze-and-Excite

                SeBlock(hidden_dim) if use_se else nn.Sequential(),

                # pw-linear

                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),

                nn.BatchNorm2d(oup),

            )

        else:

            self.conv = nn.Sequential(

                # pw

                nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),

                nn.BatchNorm2d(hidden_dim),

                nn.Hardswish() if use_hs else nn.ReLU(),

                # dw

                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim,

                          bias=False),

                nn.BatchNorm2d(hidden_dim),

                # Squeeze-and-Excite

                SeBlock(hidden_dim) if use_se else nn.Sequential(),

                nn.Hardswish() if use_hs else nn.ReLU(),

                # pw-linear

                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),

                nn.BatchNorm2d(oup),

            )



    def forward(self, x):

        y = self.conv(x)

        if self.identity:

            return x + y

        else:

            return y



# ---------------------------- MobileBlock end ---------------------------------

2. yolo.py文件

在parse_model函数中引入 Conv_BN_HSwish, MobileNetV3_InvertedResidual模块   

if m in {

                Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,     #cyz

                BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x,

                Conv_BN_HSwish, MobileNetV3_InvertedResidual,conv_bn_relu_maxpool, Shuffle_Block}

 3.  yolov5s_MobileNetv3_small.yaml文件配置

# YOLOv5 ��� by Ultralytics, GPL-3.0 license



# Parameters

nc: 1  # number of classes

depth_multiple: 1.0  # model depth multiple

width_multiple: 1.0  # 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



   # Mobilenetv3-small backbone

   # MobileNetV3_InvertedResidual [out_ch, hid_ch, k_s, stride, SE, HardSwish]

backbone:

  # [from, number, module, args]

  [[-1, 1, Conv_BN_HSwish, [16, 2]],                              # 0-p1/2

   [-1, 1, MobileNetV3_InvertedResidual, [16,  16, 3, 2, 1, 0]],  # 1-p2/4

   [-1, 1, MobileNetV3_InvertedResidual, [24,  72, 3, 2, 0, 0]],  # 2-p3/8

   [-1, 1, MobileNetV3_InvertedResidual, [24,  88, 3, 1, 0, 0]],  # 3

   [-1, 1, MobileNetV3_InvertedResidual, [40,  96, 5, 2, 1, 1]],  # 4-p4/16

   [-1, 1, MobileNetV3_InvertedResidual, [40, 240, 5, 1, 1, 1]],  # 5

   [-1, 1, MobileNetV3_InvertedResidual, [40, 240, 5, 1, 1, 1]],  # 6

   [-1, 1, MobileNetV3_InvertedResidual, [48, 120, 5, 1, 1, 1]],  # 7

   [-1, 1, MobileNetV3_InvertedResidual, [48, 144, 5, 1, 1, 1]],  # 8

   [-1, 1, MobileNetV3_InvertedResidual, [96, 288, 5, 2, 1, 1]],  # 9-p5/32

   [-1, 1, MobileNetV3_InvertedResidual, [96, 576, 5, 1, 1, 1]],  # 10

   [-1, 1, MobileNetV3_InvertedResidual, [96, 576, 5, 1, 1, 1]],  # 11

  ]



# YOLOv5 v6.0 head

head:

  [[-1, 1, Conv, [96, 1, 1]],  # 12

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 8], 1, Concat, [1]],  # cat backbone P4

   [-1, 3, C3, [144, False]],  # 15



   [-1, 1, Conv, [144, 1, 1]], # 16

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 3], 1, Concat, [1]],  # cat backbone P3

   [-1, 3, C3, [168, False]],  # 19 (P3/8-small)



   [-1, 1, Conv, [168, 3, 2]],

   [[-1, 16], 1, Concat, [1]], # cat head P4

   [-1, 3, C3, [312, False]],  # 22 (P4/16-medium)



   [-1, 1, Conv, [312, 3, 2]],

   [[-1, 12], 1, Concat, [1]], # cat head P5

   [-1, 3, C3, [408, False]],  # 25 (P5/32-large)



   [[19, 22, 25], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)

  ]

四、添加ShuffleNetV2网络

修改步骤：

1.common.py

# ---------------------------- ShuffleBlock start -------------------------------



# 通道重排，跨group信息交流

def channel_shuffle(x, groups):

    batchsize, num_channels, height, width = x.data.size()

    channels_per_group = num_channels // groups



    # reshape

    x = x.view(batchsize, groups,

               channels_per_group, height, width)



    x = torch.transpose(x, 1, 2).contiguous()



    # flatten

    x = x.view(batchsize, -1, height, width)



    return x





class conv_bn_relu_maxpool(nn.Module):

    def __init__(self, c1, c2):  # ch_in, ch_out

        super(conv_bn_relu_maxpool, self).__init__()

        self.conv = nn.Sequential(

            nn.Conv2d(c1, c2, kernel_size=3, stride=2, padding=1, bias=False),

            nn.BatchNorm2d(c2),

            nn.ReLU(inplace=True),

        )

        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)



    def forward(self, x):

        return self.maxpool(self.conv(x))





class Shuffle_Block(nn.Module):

    def __init__(self, inp, oup, stride):

        super(Shuffle_Block, self).__init__()



        if not (1 <= stride <= 3):

            raise ValueError('illegal stride value')

        self.stride = stride



        branch_features = oup // 2

        assert (self.stride != 1) or (inp == branch_features << 1)



        if self.stride > 1:

            self.branch1 = nn.Sequential(

                self.depthwise_conv(inp, inp, kernel_size=3, stride=self.stride, padding=1),

                nn.BatchNorm2d(inp),

                nn.Conv2d(inp, branch_features, kernel_size=1, stride=1, padding=0, bias=False),

                nn.BatchNorm2d(branch_features),

                nn.ReLU(inplace=True),

            )



        self.branch2 = nn.Sequential(

            nn.Conv2d(inp if (self.stride > 1) else branch_features,

                      branch_features, kernel_size=1, stride=1, padding=0, bias=False),

            nn.BatchNorm2d(branch_features),

            nn.ReLU(inplace=True),

            self.depthwise_conv(branch_features, branch_features, kernel_size=3, stride=self.stride, padding=1),

            nn.BatchNorm2d(branch_features),

            nn.Conv2d(branch_features, branch_features, kernel_size=1, stride=1, padding=0, bias=False),

            nn.BatchNorm2d(branch_features),

            nn.ReLU(inplace=True),

        )



    @staticmethod

    def depthwise_conv(i, o, kernel_size, stride=1, padding=0, bias=False):

        return nn.Conv2d(i, o, kernel_size, stride, padding, bias=bias, groups=i)



    def forward(self, x):

        if self.stride == 1:

            x1, x2 = x.chunk(2, dim=1)  # 按照维度1进行split

            out = torch.cat((x1, self.branch2(x2)), dim=1)

        else:

            out = torch.cat((self.branch1(x), self.branch2(x)), dim=1)



        out = channel_shuffle(out, 2)



        return out





# ---------------------------- ShuffleBlock end --------------------------------

2. yolo.py文件

在parse_model函数中引入 conv_bn_relu_maxpool, Shuffle_Block模块：

 if m in {

                Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,     #cyz

                BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x,

                Conv_BN_HSwish, MobileNetV3_InvertedResidual,conv_bn_relu_maxpool, Shuffle_Block}:

            c1, c2 = ch[f], args[0]

3. yolov5s_ShuffleNetV2.yaml文件配置

# YOLOv5 ��� by Ultralytics, GPL-3.0 license



# Parameters

nc: 20  # number of classes

depth_multiple: 1.0  # model depth multiple

width_multiple: 1.0  # 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]

  # Shuffle_Block: [out, stride]

  [[ -1, 1, conv_bn_relu_maxpool, [ 32 ] ], # 0-P2/4

   [ -1, 1, Shuffle_Block, [ 128, 2 ] ],  # 1-P3/8

   [ -1, 3, Shuffle_Block, [ 128, 1 ] ],  # 2

   [ -1, 1, Shuffle_Block, [ 256, 2 ] ],  # 3-P4/16

   [ -1, 7, Shuffle_Block, [ 256, 1 ] ],  # 4

   [ -1, 1, Shuffle_Block, [ 512, 2 ] ],  # 5-P5/32

   [ -1, 3, Shuffle_Block, [ 512, 1 ] ],  # 6

  ]



# YOLOv5 v6.0 head

head:

  [[-1, 1, Conv, [256, 1, 1]],

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 4], 1, Concat, [1]],  # cat backbone P4

   [-1, 1, C3, [256, False]],  # 10



   [-1, 1, Conv, [128, 1, 1]],

   [-1, 1, nn.Upsample, [None, 2, 'nearest']],

   [[-1, 2], 1, Concat, [1]],  # cat backbone P3

   [-1, 1, C3, [128, False]],  # 14 (P3/8-small)



   [-1, 1, Conv, [128, 3, 2]],

   [[-1, 11], 1, Concat, [1]],  # cat head P4

   [-1, 1, C3, [256, False]],  # 17 (P4/16-medium)



   [-1, 1, Conv, [256, 3, 2]],

   [[-1, 7], 1, Concat, [1]],  # cat head P5

   [-1, 1, C3, [512, False]],  # 20 (P5/32-large)



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

  ]

小舞O_o
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
YOLOv7升级换代：EfficientNet骨干网络助力更精准目标检测
学Java，找哪吒
05-08 8417
目标检测是计算机视觉中的重要研究方向，其应用广泛，例如自动驾驶、安防监控等。目前，基于深度学习的目标检测方法已经取得了很大进展，其中YOLO（You Only Look Once）系列模型以其快速且准确的特点备受关注。
【YOLOv8改进】 YOLOv8 更换骨干网络之GhostNetV2 长距离注意力机制增强廉价操作，构建更强端侧轻量型骨干 (论文笔记+引入代码)
前端路上有你有我！
02-19 4606
轻量级卷积神经网络（CNNs）专为移动设备上的应用而设计，具有更快的推理速度。卷积操作只能捕获窗口区域内的局部信息，这限制了性能的进一步提升。将自注意力引入到卷积中可以很好地捕获全局信息，但这将大大增加实际速度的负担。在本文中，我们提出了一种硬件友好的注意力机制（称为DFC注意力），然后为移动应用呈现了一个新的GhostNetV2架构。所提出的DFC注意力基于全连接层构建，不仅可以在常见硬件上快速执行，还能捕获长距离像素之间的依赖关系。
yolov5之修改骨干网络后预训练权重加载
Maggie_JK的博客
07-08 2601
根据观察我们发现，由于加入了分支结构（多了4层），原模型的层的序号是发生了挪位的，比如csd.keys()中'model.4.cv1.conv.weight'这个键的值应该对应加载给model.state_dict().keys()中的‘model.8.cv1.conv.weight'此时，预训练权重加载出现问题，从更改位置开始直到最后的预训练权重是加载不上的，因为网络更改后，预训练权重的键值对和模型的键值对对应不上。然后就可以用新写的csd正常加载预训练模型了。
Yolov5 v7.0目标检测——详细记录环境配置、自定义数据处理、模型训练与常用错误解决方法（数据集为河道漂浮物）
最新发布
知来者逆的博客
04-24 2200
详细记录yolov5训练过程与错误解决方法，使用的数据是河道漂浮物检测，提供完整的数据集和训练代码。
【项目二、蜂巢检测项目】二、模型改进：YOLOv5s-ShuffleNetV2
qq_38253797的博客
05-19 1万+
目录前言一、数据集 前言 马上要找工作了，想总结下自己做过的几个小项目。 之前以及总结过了我做的第一个项目：xxx病虫害检测项目，github源码地址：HuKai97/FFSSD-ResNet。CSDN讲解地址： 【项目一、xxx病虫害检测项目】1、SSD原理和源码分析 【项目一、xxx病虫害检测项目】2、网络结构尝试改进：Resnet50、SE、CBAM、Feature Fusion 【项目一、xxx病虫害检测项目】3、损失函数尝试：Focal loss 而这篇主要介绍我做的第二个项目，也是实验室项目
yolov5修改骨干网络-使用自己搭建的网络-以efficientnetv2为例
小白不白
12-15 5789
efficientnet则是通过NAS搜索，同时增加width、depth以及resolution，使网络结构达到最优。下表为EfficientNet-B0的网络框架（B1-B7就是在B0的基础上修改Resolution，Channels以及Layers），可以看出网络总共分成了9个Stage。第一个Stage是一个卷积核大小为3x3，stride为2的普通卷积层（包含BN和Swish激活函数）；
yolov5修改骨干网络-使用pytorch自带的网络-以Mobilenet和efficientnet为例
小白不白
12-14 3300
通过我们知道：yolov5.yaml中存放的是我们模型构建参数，具体构建过程在yolo.py中的parse_model函数，通过循环遍历yolov5.yaml给的参数，去寻找网络名称，并将args的参数传入网络，下面先用pytorch自带的mobile网络进行修改并替换原有yolov5网络。
【目标检测】YOLOv5：修改自己的网络结构
兴趣使然的创作者
04-15 4926
YOLOv5从登堂到入室
YOLOv8/YOLOv7/YOLOv5系列算法改进[NO.14]主干网络C3替换为轻量化网络Ghostnet
m0_70388905的博客
07-06 1万+
​前 言：作为当前先进的深度学习目标检测算法YOLOv5，已经集合了大量的trick，但是还是有提高和改进的空间，针对具体应用场景下的检测难点，可以不同的改进方法。此后的系列文章，将重点对YOLOv5的如何改进进行详细的介绍，目的是为了给那些搞科研的同学需要创新点或者搞工程项目的朋友需要达到更好的效果提供自己的微薄帮助和参考。解决问题：YOLOv5主干特征提取网络采用C3结构，带来较大的参数量，检测速度较慢，应用受限，在某些真实的应用场景如移动或者嵌入式设备，如此大而复杂的模型时难以被应用的。...
主干网络篇 | YOLOv5/v7 更换主干网络之 ShuffleNetv2 | 高效CNN架构设计的实用指南
热门推荐
YOLOv8项目贡献者
08-01 1万+
YOLOv5/v7 更换主干网络之 ShuffleNetv2
yolov5-7.0源码 yolov5-7.0-codeset.zip
04-22
yolov5-7.0源码 yolov5-7.0-codeset.zip； yolov5-7.0源码 yolov5-7.0-codeset.zip； yolov5-7.0源码 yolov5-7.0-codeset.zip； yolov5-7.0源码 yolov5-7.0-codeset.zip； yolov5-7.0源码 yolov5-7.0-codeset.zip； ...
yolov5-v7.0网络分类、检测和分割OpenCV C++部署demo
03-24
yolov5-v7.0网络分类、检测和分割OpenCV C++部署demo 对应https://blog.csdn.net/taifyang/article/details/128894598?spm=1001.2014.3001.5502
YOLOV5-7.0 官方预训练模型yolov5n-7.0.onnx
04-22
YOLOV5-7.0 官方预训练模型yolov5n-7.0.onnx
基于YOLOV5-7.0+DeepSort的目标追踪算法
10-30
基于DeepSORT算法和YOLOv5 7.0版本的目标跟踪实现。DeepSORT是一种强大的多目标跟踪算法，结合YOLOv5 7.0版本的目标检测能力，可以实现高效准确的实时目标跟踪。 基于 YOLOV5 和 DeepSort 的目标追踪算法是一种结合...
yolov5-7.0实例分割模型转onnx再转rknn，含各个阶段代码
08-22
yolov5-7.0实例分割模型转onnx再转rknn，含各个阶段代码。包括： （1）pt转onnx （2）onnx转rknn及推理 （3）rknn推理
主干网络篇 | YOLOv8 更换主干网络之 ShuffleNetv2 | 《ShuffleNet v2：高效卷积神经网络架构设计的实用指南》
YOLOv8项目贡献者
04-20 4766
YOLOv8 更换主干网络 ShuffleNetv2 手把手教程
YOLOv7、YOLOv7-tiny改进ShuffleNet V2主干系列：高效结合ShuffleNet V2主干网络，高效CNN架构设计的实用指南，打造强力检测器
包括YOLOv5、YOLOv7、YOLOv8等模型改进
05-01 2299
代码实践｜YOLOv7、YOLOv7-tiny改进ShuffleNet V2主干系列
主干网络篇 | YOLOv5/v7 更换骨干网络之 PP-LCNet | 轻量级CPU卷积神经网络
YOLOv8项目贡献者
01-02 8942
YOLOv5/v7 更换骨干网络之 PP-LCNet
yolov5-5.0版本和yolov5-7.0版本的差异
07-15
yolov5-5.0版本和yolov5-7.0版本是YOLO（You Only Look Once）目标检测算法的不同版本。它们之间的差异主要体现在以下几个方面： 1. 模型性能：yolov5-7.0版本相对于yolov5-5.0版本在目标检测性能上有所提升。通过更深的网络结构和更多的训练数据，yolov5-7.0版本可以更准确地检测和定位目标。 2. 网络结构：yolov5-7.0版本相对于yolov5-5.0版本在网络结构上进行了改进。它引入了更多的卷积层和特征融合模块，以提取更丰富的特征信息。 3. 模型大小：yolov5-7.0版本相对于yolov5-5.0版本在模型大小上有所增加。这是因为引入了更多的网络层和参数，以提高检测性能。 4. 训练策略：yolov5-7.0版本相对于yolov5-5.0版本在训练策略上进行了一些改进。例如，它采用了更复杂的数据增强技术和优化的损失函数，以提高模型的鲁棒性和泛化能力。 总的来说，yolov5-7.0版本相对于yolov5-5.0版本在目标检测性能上有所提升，并且引入了更多的网络层和参数，但同时也增加了模型的大小。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值