yolov5将特征提取网络改为fasternet结构

最新推荐文章于 2024-01-16 02:31:32 发布
最新推荐文章于 2024-01-16 02:31:32 发布
阅读量375 收藏 8
点赞数
分类专栏： yolov5魔改 文章标签： YOLO python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acanab/article/details/132462046
版权

yolov5增加fasternet结构

论文地址：https://arxiv.org/abs/2303.03667
需要先安装timm
pip install timm
引入 DropPath
from timm.models.layers import DropPath

方案一：使用faster net backbone替换yolobackbone

创建网络配置文件：
yolov5-pconv.yaml

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
 
# Parameters
nc: 80  # number of classes
depth_multiple: 1  # model depth multiple
width_multiple: 1  # 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, PatchEmbed, [40, 4, 4, nn.BatchNorm2d]],  # 0-P1/4
   [-1, 1, BasicStage, [40, 1]],  # 1
   [-1, 1, PatchMerging, [80,2,2]],  # 2-P2/8
   [-1, 1, BasicStage, [80, 1]],  # 3
   [-1, 1, BasicStage, [80, 1]],  # 4
   [-1, 1, PatchMerging, [160,2,2]],  # 5
   [-1, 1, BasicStage, [160, 1]],  # 6
   [-1, 1, BasicStage, [160, 1]],  # 7
   [-1, 1, BasicStage, [160, 1]],  # 8
   [-1, 1, BasicStage, [160, 1]],  # 9
   [-1, 1, BasicStage, [160, 1]],  # 10
   [-1, 1, BasicStage, [160, 1]],  # 11
   [-1, 1, BasicStage, [160, 1]],  # 12
   [-1, 1, BasicStage, [160, 1]],  # 13
   [-1, 1, PatchMerging, [320,2,2]], # 14
   [-1, 1, BasicStage, [320, 1]], # 15
   [-1, 1, BasicStage, [320, 1]], # 16
   [-1, 1, SPPF, [320, 5]],  # 17
  ]
 
# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 13], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [256, False]],  # 21
 
   [-1, 1, Conv, [128, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [128, False]],  # 25 (P3/8-small)
 
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, 22], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [256, False]],  # 28 (P4/16-medium)
 
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 18], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [512, False]],  # 31 (P5/32-large)
 
   [[25, 28, 31], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

在models\common.py中添加：

class Partial_conv3(nn.Module):
    def __init__(self, dim, n_div, forward):
        super().__init__()
        self.dim_conv3 = dim // n_div
        self.dim_untouched = dim - self.dim_conv3
        self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False)
 
        if forward == 'slicing':
            self.forward = self.forward_slicing
        elif forward == 'split_cat':
            self.forward = self.forward_split_cat
        else:
            raise NotImplementedError
 
    def forward_slicing(self, x):
        # only for inference
        x = x.clone()  # !!! Keep the original input intact for the residual connection later
        x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :])
 
        return x
 
    def forward_split_cat(self, x):
        # for training/inference
        x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)
        x1 = self.partial_conv3(x1)
        x = torch.cat((x1, x2), 1)
        return x
 
 
class MLPBlock(nn.Module):
    def __init__(self,
                 dim,
                 n_div,
                 mlp_ratio,
                 drop_path,
                 layer_scale_init_value,
                 act_layer,
                 norm_layer,
                 pconv_fw_type
                 ):
 
        super().__init__()
        self.dim = dim
        self.mlp_ratio = mlp_ratio
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        self.n_div = n_div
 
        mlp_hidden_dim = int(dim * mlp_ratio)
 
        mlp_layer = [
            nn.Conv2d(dim, mlp_hidden_dim, 1, bias=False),
            norm_layer(mlp_hidden_dim),
            act_layer(),
            nn.Conv2d(mlp_hidden_dim, dim, 1, bias=False)
        ]
 
        self.mlp = nn.Sequential(*mlp_layer)
 
        self.spatial_mixing = Partial_conv3(
            dim,
            n_div,
            pconv_fw_type
        )
 
        if layer_scale_init_value > 0:
            self.layer_scale = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
            self.forward = self.forward_layer_scale
        else:
            self.forward = self.forward
 
    def forward(self, x):
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(self.mlp(x))
        return x
 
    def forward_layer_scale(self, x):
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(
            self.layer_scale.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
        return x
 
 
class BasicStage(nn.Module):
    def __init__(self,
                 dim,
                 depth=1,
                 n_div=4,
                 mlp_ratio=2,
                 # drop_path=[0.0],
                 layer_scale_init_value=0,
                 norm_layer=nn.BatchNorm2d,
                 act_layer=nn.ReLU,
                 pconv_fw_type='split_cat'
                 ):
        super().__init__()
        dpr = [x.item()
               for x in torch.linspace(0, 0.0, sum([1, 2, 8, 2]))]
        blocks_list = [
            MLPBlock(
                dim=dim,
                n_div=n_div,
                mlp_ratio=mlp_ratio,
                drop_path=dpr[i],
                layer_scale_init_value=layer_scale_init_value,
                norm_layer=norm_layer,
                act_layer=act_layer,
                pconv_fw_type=pconv_fw_type
            )
            for i in range(depth)
        ]
 
        self.blocks = nn.Sequential(*blocks_list)
 
    def forward(self, x):
        x = self.blocks(x)
        return x
 
 
class PatchEmbed(nn.Module):
 
    def __init__(self, in_chans, embed_dim, patch_size, patch_stride, norm_layer):
        super().__init__()
        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_stride, bias=False)
        if norm_layer is not None:
            self.norm = norm_layer(embed_dim)
        else:
            self.norm = nn.Identity()
 
    def forward(self, x):
        x = self.norm(self.proj(x))
        return x
 
    def fuseforward(self, x):
        x = self.proj(x)
        return x
 
 
class PatchMerging(nn.Module):
 
    def __init__(self, dim, out_dim, k, patch_stride2, norm_layer=nn.BatchNorm2d):
        super().__init__()
        self.reduction = nn.Conv2d(dim, out_dim, kernel_size=k, stride=patch_stride2, bias=False)
        if norm_layer is not None:
            self.norm = norm_layer(out_dim)
        else:
            self.norm = nn.Identity()
 
    def forward(self, x):
        x = self.norm(self.reduction(x))
        return x
 
    def fuseforward(self, x):
        x = self.reduction(x)
        return x

在yolo.py中的parse_model中做如下修改

def parse_model(d, ch):  # model_dict, input_channels(3)
    # Parse a YOLOv5 model.yaml dictionary
    LOGGER.info(f"\n{'':>3}{'from':>18}{'n':>3}{'params':>10}  {'module':<40}{'arguments':<30}")
    anchors, nc, gd, gw, act = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple'], d.get('activation')
    if act:
        Conv.default_act = eval(act)  # redefine default activation, i.e. Conv.default_act = nn.SiLU()
        LOGGER.info(f"{colorstr('activation:')} {act}")  # print
    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)
 
    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
        m = eval(m) if isinstance(m, str) else m  # eval strings
        for j, a in enumerate(args):
            with contextlib.suppress(NameError):
                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
 
        n = n_ = max(round(n * gd), 1) if n > 1 else n  # depth gain
        if m in {
            Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
            BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x, StemBlock,
            BlazeBlock, DoubleBlazeBlock, ShuffleV2Block, MobileBottleneck, InvertedResidual, ConvBNReLU,
            RepVGGBlock, SEBlock, RepBlock, SimCSPSPPF,BasicStage,PatchEmbed,PatchMerging}:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)
            if m == InvertedResidual:
                c2 = make_divisible(c2 * gw, 4 if gw == 0.1 else 8)
                
            args = [c1, c2, *args[1:]]
            if m in {BottleneckCSP, C3, C3TR, C3Ghost, C3x}:
                args.insert(2, n)  # number of repeats
                n = 1
            if m in {BasicStage}:
                args.pop(1)
 
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum(ch[x] for x in f)
        # TODO: channel, gw, gd
        elif m in {Detect}:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        else:
            c2 = ch[f]
 
        m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
        t = str(m)[8:-2].replace('__main__.', '')  # module type
        np = sum(x.numel() for x in m_.parameters())  # number params
        m_.i, m_.f, m_.type, m_.np = i, f, t, np  # attach index, 'from' index, type, number params
        LOGGER.info(f'{i:>3}{str(f):>18}{n_:>3}{np:10.0f}  {t:<40}{str(args):<30}')  # print
        save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
        layers.append(m_)
        if i == 0:
            ch = []
        ch.append(c2)
    return nn.Sequential(*layers), sorted(save)

在yolo.py中的BaseModel中的fuse函数做如下修改：

    def fuse(self):  # fuse model Conv2d() + BatchNorm2d() layers
        LOGGER.info('Fusing layers... ')
        for m in self.model.modules():
            if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'):
                m.conv = fuse_conv_and_bn(m.conv, m.bn)  # update conv
                delattr(m, 'bn')  # remove batchnorm
                m.forward = m.forward_fuse  # update forward
                
            if type(m) is PatchEmbed:
                m.proj = fuse_conv_and_bn(m.proj, m.norm)
                delattr(m, 'norm')  # remove batchnorm
                m.forward = m.fuseforward
            if type(m) is PatchMerging:
                m.reduction = fuse_conv_and_bn(m.reduction, m.norm)
                delattr(m, 'norm')  # remove batchnorm
                m.forward = m.fuseforward
            if type(m) is MLPBlock:
                if hasattr(m, 'mlp'):
                    re_mlp = nn.Sequential(
                        nn.Conv2d(m.mlp[0].in_channels, m.mlp[0].out_channels,
                                  kernel_size=m.mlp[0].kernel_size, stride=m.mlp[0].stride,
                                  padding=m.mlp[0].padding, groups=m.mlp[0].groups),
                        nn.ReLU(inplace=True),
                        nn.Conv2d(m.mlp[3].in_channels, m.mlp[3].out_channels,
                                  kernel_size=m.mlp[3].kernel_size, stride=m.mlp[3].stride,
                                  padding=m.mlp[3].padding, bias=False),
                    )
                    re_mlp[0] = fuse_conv_and_bn(m.mlp[0], m.mlp[1])
                    # delattr(m, 'se')
                    m.mlp = re_mlp

方案二： 用Pconv替换C3中的conv

配置文件：

# YOLOv5 🚀 by Ultralytics, GPL-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, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3_P, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3_P, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3_P, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3_P, [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_P, [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_P, [256, False]],  # 17 (P3/8-small)
 
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3_P, [512, False]],  # 20 (P4/16-medium)
 
   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3_P, [1024, False]],  # 23 (P5/32-large)
 
   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

在models\common.py中添加：

class Partial_conv3(nn.Module):
    def __init__(self, dim, n_div, forward):
        super().__init__()
        self.dim_conv3 = dim // n_div
        self.dim_untouched = dim - self.dim_conv3
        self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False)
 
        if forward == 'slicing':
            self.forward = self.forward_slicing
        elif forward == 'split_cat':
            self.forward = self.forward_split_cat
        else:
            raise NotImplementedError
 
    def forward_slicing(self, x):
        # only for inference
        x = x.clone()  # !!! Keep the original input intact for the residual connection later
        x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :])
        return x
 
    def forward_split_cat(self, x):
        # for training/inference
        x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)
        x1 = self.partial_conv3(x1)
        x = torch.cat((x1, x2), 1)
        return x
 
 
class MLPBlock(nn.Module):
    def __init__(self,
                 c1,
                 c2,
                 n_div=4,
                 mlp_ratio=2,
                 drop_path=0.1,
                 layer_scale_init_value=0.0,
                 pconv_fw_type='split_cat'
                 ):
        super().__init__()
        self.dim = c2
        self.mlp_ratio = mlp_ratio
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        self.n_div = n_div
 
        mlp_hidden_dim = int(c2 * mlp_ratio)
        mlp_layer = [
            Conv(c2, mlp_hidden_dim, 1),
            nn.Conv2d(mlp_hidden_dim, c2, 1, bias=False)
        ]
 
        self.mlp = nn.Sequential(*mlp_layer)
        self.spatial_mixing = Partial_conv3(c2, n_div, pconv_fw_type)
 
        if layer_scale_init_value > 0:
            self.layer_scale = nn.Parameter(layer_scale_init_value * torch.ones((c2)), requires_grad=True)
            self.forward = self.forward_layer_scale
        else:
            self.forward = self.forward
 
    def forward(self, x):
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(self.mlp(x))
        return x
 
    def forward_layer_scale(self, x):
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(
            self.layer_scale.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
        return x
 
 
class C3_P(C3):
    # C3 module with cross-convolutions
    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)
        self.m = nn.Sequential(*(MLPBlock(c_, c_) for _ in range(n)))

yolo.py中的parse_model中：

        if m in {
            Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
            BottleneckCSP, C3, C3TR, C3SPP, C3Ghost, nn.ConvTranspose2d, DWConvTranspose2d, C3x, StemBlock,
            BlazeBlock, DoubleBlazeBlock, ShuffleV2Block, MobileBottleneck, InvertedResidual, ConvBNReLU,
            RepVGGBlock, SEBlock, RepBlock, SimCSPSPPF, C3_P, SPPCSPC, RepConv}:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)
            if m == InvertedResidual:
                c2 = make_divisible(c2 * gw, 4 if gw == 0.1 else 8)
                
            args = [c1, c2, *args[1:]]
            if m in {BottleneckCSP, C3, C3TR, C3Ghost, C3x, C3_P}:
                args.insert(2, n)  # number of repeats
                n = 1
acanab
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
yolov5改进之Fasternet主干网络替换
qq_41920323的博客
05-12 4284
fasternet替换yolov5主干网络
YOLOv10改进 | 主干/Backbone篇 | 添加FasterNeT跑起来的主干网络（提高FPS和检测效率）
最新发布
Snu77的博客
07-12 1007
本文给大家带来的改进机制是FasterNet网络，将其用来替换我们的特征提取网络，其旨在提高计算速度而不牺牲准确性，特别是在视觉任务中。它通过一种称为部分卷积（PConv）的新技术来减少冗余计算和内存访问。这种方法使得FasterNet在多种设备上运行速度比其他网络快得多，同时在各种视觉任务中保持高准确率。经过我的实验该主干网络确实能够涨点在大中小三种物体检测上，大家可以在源代码中进行修改版本的使用。本文通过介绍其主要框架原理，然后教大家如何添加该网络结构到网络模型中。
YOLOv5引入FasterNet主干网络，目标检测速度提升明显
学Java，找哪吒
08-29 5795
目标检测是计算机视觉领域的重要任务，它在现实生活中有着广泛的应用，如自动驾驶、安防监控、人脸识别等。目标检测算法旨在从图像或视频中检测出感兴趣的目标，并确定其位置和类别。目标检测算法可以分为两个主要类别：基于区域的方法和单阶段方法。基于区域的方法（Region-based methods）先通过区域建议网络（Region Proposal Network，RPN）生成一组候选目标框，然后再对这些候选框进行分类和回归，以得到最终的目标检测结果。
Yolov5改进: Yolov5-FasterNet网络推理加速
@bangbang的博客
03-27 2895
FasterNet是CVPR 2023 新出来的网络，主要用来加速网络推理实现轻量化。作者重新审视了现有的操作符，特别是DWConv的计算速度——FLOPS。作者发现导致低FLOPS问题的主要原因是频繁的内存访问。然后，作者提出了PConv作为一种竞争性替代方案，它减少了计算冗余以及内存访问的数量。为了设计快速神经网络，许多工作都集中在减少浮点运算（FLOPs）的数量上。然而，作者观察到FLOPs的这种减少不一定会带来延迟的类似程度的减少。这主要源于每秒低浮点运算（FLOPS）效率低下。
yolov5增加fasternet结构
athrunsunny的博客
03-17 7067
在yolo.py中的parse_model中做如下修改。直接运行yolo.py可以看网络结构。
YOLOv5改进 | 主干篇 | FasterNeT跑起来的特征提取网络（提高FPS和检测效率）
Snu77的博客
01-08 1570
本文给大家带来的改进机制是FasterNet网络，将其用来替换我们的特征提取网络，其旨在提高计算速度而不牺牲准确性，特别是在视觉任务中。它通过一种称为部分卷积（PConv）的新技术来减少冗余计算和内存访问。这种方法使得FasterNet在多种设备上运行速度比其他网络快得多，同时在各种视觉任务中保持高准确率。经过我的实验该主干网络确实能够涨点在大中小三种物体检测上，同时该主干网络也提供多种版本，大家可以在源代码中进行修改版本的使用。本文通过介绍其主要框架原理，然后教大家如何添加该网络结构到网络模型中。
YOLOv8改进 | 主干篇 | EfficientViT高效的特征提取网络完爆MobileNet系列(轻量化网络结构)
Snu77的博客
01-16 3153
本文给大家带来的改进机制是主干网络，一个名字的特征提取网络(和之前发布的只是同名但不是同一个)，其基本原理是提升视觉变换器在高效处理高分辨率视觉任务的能力。它采用了创新的建筑模块设计包括三明治布局和级联群组注意力模块。其是一种高效率的特征提取网络训练速度非常快，推理速度也要比基础版本的要快，其效果完爆之前的MobileNetV3等轻量化网络模型。欢迎大家订阅本专栏，本专栏每周更新3-5篇最新机制，更有包含我所有改进的文件和交流群提供给大家。欢迎大家订阅我的专栏一起学习YOLO!
芒果YOLOv5改进01：主干Backbone篇：独创结构FasterNeXt，实测私有数据集mAP有效涨点，同时降低参数量｜为更快的神经网络追求更高的 FLOPS，参数量下降，超越其他轻量化模型
包括YOLOv5、YOLOv7、YOLOv8等模型改进
03-09 1万+
YOLOv5改进代码实践｜实测参数量计算量下降、FPS升高
改进YOLOv5：涨点必备 | 创新实用 | 轻量化骨干网络大一统，包含FastNet、ShuffleNet、mobileNet、Ghostnet等
qq_44224801的博客
04-29 3598
本文实现了YOLOv8结合各种轻量化骨干网络，实现一篇文章助你实现YOLOv8轻量化。本文不仅实现了YOLOv8结合各种骨干网络，并且给出的多种结合形式，如替换轻量化卷积PConv、替换轻量化Block以及替换轻量化骨干。
Yolov5/Yolov7改进CVPR2023 FasterNet远超ShuffleNet、MobileNet、MobileViT，引入PConv结构map涨点的同时进一步降低参数量
03-16 5098
Yolov5/Yolov7改进CVPR2023主干FasterNet PConv，​ 在yolov5 ​工业油污缺陷检测检测项目PConv map从0.740提升至0.764，涨点明显，博主多个数据集亲测有效，实现暴力涨点； ​
YOLOv5s替换BackBone为FasterNet-保姆级教学
JasonLm的博客
12-27 1822
思想：使用Timm库，Timm库包含了许多常见的卷积神经网络（CNN）架构，例如 MobileNet、GhostNet、ViT（Vision Transformer）等，并支持各种预训练权重。使用Timm库，你可以轻松地加载这些预训练的模型，并在自己的任务中进行微调或特征提取。用FasterBlock替换原本的C3Ghost。
又改YOLO | 项目如何改进YOLOv5？这篇告诉你如何修改让检测更快、更稳！！！
热门推荐
3D视觉工坊
12-20 1万+
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达作者丨ChaucerG来源丨集智书童交通标志检测对于无人驾驶系统来说是一项具有挑战性的任务，尤其是多尺度目标检测和检测的实时性问题。在...
YOLOv5/v7/v8改进实验（七）之使用timm更换YOLOv8模型主干网络Backbone篇
w94ghz的博客
10-18 2190
YOLOv5改进系列（10）——替换主干网络之GhostNet
路人贾的博客
06-17 4787
手把手教你学会YOLOv5替换主干网络之GhostNet
改进YOLOv5：MobileNEtv2、v3篇**涨点必备 | 创新实用 | 轻量化骨干网络大一统，包含FastNet、ShuffleNet、mobileNet、Ghostnet等
qq_44224801的博客
05-18 1327
​   轻量化MobileNEtv2、v3​   轻量化MobileNEtv2、v3。
基于Yolov5的工业油污缺陷检测，加入CVPR2023 BiFormer-BiLevelRoutingAttention和FasterNet-PConv提升检测精度
03-30 3318
yolov5的工业油污检测，通过cvpr2023 BiFormer: 基于动态稀疏注意力构建高效金字塔网络和FasterNet远超ShuffleNet、MobileNet、MobileViT，引入PConv结构map涨点，最终取得较好的涨点
YOLOv5改进：引入DenseNet思想打造密集连接模块，彻底提升目标检测性能
学Java，找哪吒
05-11 2838
目录一、密集连接模块的介绍1、密集连接的概念2、密集连接与残差连接的对比3、DenseNet的结构二、 YOLOv5中引入密集连接模块的原因1、密集连接模块对于目标检测的优势2、密集连接模块对目标检测性能的影响三、 YOLOv5中密集连接模块的具体实现1、使用DenseNet的基本单元DenseBlock作为密集连接模块的基本结构：2、在每个DenseBlock中，将每个卷积层的输出与之前所有卷积层的输出进行拼接，并作为下一个卷积层的输入：3、在每个DenseBlock之间添加一个Transition层，
【YOLOv8/YOLOv7/YOLOv5/YOLOv4/Faster-rcnn系列算法改进NO.61】结合最新的CVPR2023年Fasternet网络模块
m0_70388905的博客
03-21 2608
结合最新的CVPR2023年Fsternet
【CVPR2023】FasterNet：追逐更高FLOPS、更快的神经网络
m0_63642362的博客
05-27 3670
为了实现更快的网络，本文回顾了流行的操作，并证明如此低的FLOPS主要是由于操作频繁的内存访问，特别是深度卷积。 因此，本文提出了一种新的部分卷积——PConv
yolov5修改特征提取网络为transformer
03-25
A：将YOLOv5的特征提取网络改为Transformer可能会导致性能下降，并且可能需要重新训练网络。在YOLOv5中，特征提取器使用的是CSPDarknet53，在该网络中，特征提取使用了卷积层和池化层，而Transformer是基于注意力机制的，因此它的计算方式与卷积和池化不同。因此，将YOLOv5的特征提取器改为Transformer可能需要重新设计网络结构，并改变一些参数和超参数，以适应新的计算方式。这是一个非常复杂的任务，需要深入的专业知识和经验。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

acanab

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

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

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

打赏作者

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

抵扣说明：

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

余额充值