【YOLOv5/v7改进系列】替换骨干网络为MobileOne

已于 2024-05-13 12:09:20 修改
阅读量883 收藏 11
点赞数 15
分类专栏： YOLO改进指南 文章标签： YOLO 目标检测 计算机视觉 人工智能 机器学习
于 2024-05-12 15:02:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/138754980
版权

一、导言

提出了一种为移动设备设计的高效神经网络主干结构，称为MobileOne。传统的优化方法通常侧重于减少计算量（FLOPs）和参数数量来提升模型效率，但这些指标并不总能准确反映实际部署到移动设备上的延迟性能。因此，研究团队通过在移动设备上部署多个对移动友好的网络并进行深入分析，识别并解决了现代高效神经网络架构中的架构与优化瓶颈。

MobileOne的设计旨在提供超低延迟的同时保持高精度，其变体能够在iPhone 12上实现低于1毫秒的推理时间，同时在ImageNet数据集上达到75.9%的顶尖-1准确率。相比同类高效架构，MobileOne不仅在精度上达到了最先进的水平，而且运行速度更快，比如比MobileFormer快38倍，比EfficientNet在相近延迟下高出2.3%的顶尖-1准确率。

此外，MobileOne模型还展现了良好的泛化能力，不仅在图像分类任务上表现优异，还在目标检测和语义分割等任务上展现出显著的延迟降低和准确率提升。研究中还探讨了训练策略对模型性能的影响，发现MobileOne模型对随机种子的选择不敏感，且较少依赖正则化技术即可达到竞争力的精度。作者还研究了过参数化对于不同规模模型的效果，并发现对于小型变体而言，额外的过参数化分支能够带来更显著的性能提升。

  1. 低延迟优化：MobileOne架构专门针对移动设备进行了设计和优化，其变体能够在iPhone 12上实现低于1毫秒的推理时间，同时在ImageNet数据集上达到75.9%的Top-1精度，表明其在实际部署时具有极低的延迟。

  2. 性能超越：与当前高效的架构相比，MobileOne不仅在准确性方面达到了最先进的水平，而且在移动设备上的运行速度快得多。例如，它比MobileFormer快38倍，同时在ImageNet上的表现相当；比EfficientNet在相似延迟下高出2.3%的Top-1精度。

  3. 多任务适应性：MobileOne模型不仅在图像分类任务上表现出色，还泛化到了对象检测和语义分割等其他任务，在移动设备上实现了显著的延迟和精度改进。

  4. 训练策略和正则化：研究通过详尽实验分析了不同训练策略对模型性能的影响，发现MobileOne模型即使使用较少的正则化技术也能达到与竞争模型如EfficientNet、MobileNetV3-L和MixNet-S相匹敌的精度。此外，采用逐步学习和权重衰减策略能进一步提升某些模型的表现。

  5. 稳定性与随机种子敏感性：模型训练稳健，不同随机种子下的表现一致，证明了方法的可靠性和重现性。

  6. 微观架构设计：MobileOne的微观变体设计不单纯追求FLOPs的优化，而是通过选择参数量更小且使用适度过参数化的架构，以达到竞争力的精度，这为资源有限的环境提供了有效解决方案。

  7. 过参数化效果：研究表明，对于较小的模型变体，额外的过参数化分支带来了更多益处，有助于提高模型性能。

  8. 扩展到物体检测：在物体检测任务中，通过使用SSDLite模型进行训练，并采用余弦学习率调度结合预热策略，展示了MobileOne在实际应用中的多功能性和潜力。

综上所述，MobileOne是一个针对移动平台优化的深度学习模型，它在确保高性能的同时极大提高了推理速度，为移动设备上的实时AI应用提供了新的可能性。相关代码和模型已开源供研究者使用。

二、准备工作

首先在YOLOv5/v7项目文件下的models文件夹下创建新的文件mobileone.py

导入如下代码

from models.common import *
import copy as copy2
from typing import Optional, List, Tuple


class SEBlock(nn.Module):
    """ Squeeze and Excite module.
        https://arxiv.org/pdf/1709.01507.pdf
    """

    def __init__(self, in_channels: int, rd_ratio: float = 0.0625) -> None:
        """ Construct a Squeeze and Excite Module.
        :param in_channels: Number of input channels.
        :param rd_ratio: Input channel reduction ratio.
        """
        super(SEBlock, self).__init__()
        self.reduce = nn.Conv2d(in_channels=in_channels,out_channels=int(in_channels * rd_ratio), kernel_size=1, stride=1, bias=True)
        self.expand = nn.Conv2d(in_channels=int(in_channels * rd_ratio),out_channels=in_channels, kernel_size=1, stride=1, bias=True)

    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
        """ Apply forward pass. """
        b, c, h, w = inputs.size()
        x = F.avg_pool2d(inputs, kernel_size=[h, w])
        x = self.reduce(x)
        x = F.relu(x)
        x = self.expand(x)
        x = torch.sigmoid(x)
        x = x.view(-1, c, 1, 1)
        return inputs * x


class MobileOneBlock(nn.Module):
    """ MobileOne building block. https://arxiv.org/pdf/2206.04040.pdf
    """
    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int = 1,
                 padding: int = 0, dilation: int = 1, groups: int = 1, use_se: bool = False, num_conv_branches: int = 1, inference_mode: bool = False) -> None:
        """ Construct a MobileOneBlock module.
        :param in_channels: Number of channels in the input.
        :param out_channels: Number of channels produced by the block.
        :param kernel_size: Size of the convolution kernel.
        :param stride: Stride size.
        :param padding: Zero-padding size.
        :param dilation: Kernel dilation factor.
        :param groups: Group number.
        :param inference_mode: If True, instantiates model in inference mode.
        :param use_se: Whether to use SE-ReLU activations.
        :param num_conv_branches: Number of linear conv branches.
        """
        super(MobileOneBlock, self).__init__()
        self.inference_mode = inference_mode
        self.groups = groups
        self.stride = stride
        self.kernel_size = kernel_size
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.num_conv_branches = num_conv_branches  # 4

        # Check if SE-ReLU is requested
        if use_se:
            self.se = SEBlock(out_channels)
        else:
            self.se = nn.Identity()
        self.activation = nn.ReLU()

        if inference_mode:
            self.reparam_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,stride=stride, padding=padding, dilation=dilation, groups=groups, bias=True)
        else:
            # Re-parameterizable skip connection
            self.rbr_skip = nn.BatchNorm2d(num_features=in_channels) if out_channels == in_channels and stride == 1 else None   # BN skip

            # Re-parameterizable conv branches
            rbr_conv = list()
            for _ in range(self.num_conv_branches):
                rbr_conv.append(self._conv_bn(kernel_size=kernel_size, padding=padding))
            self.rbr_conv = nn.ModuleList(rbr_conv)

            # Re-parameterizable scale branch
            self.rbr_scale = None
            if kernel_size > 1:
                self.rbr_scale = self._conv_bn(kernel_size=1, padding=0)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """ Apply forward pass. """
        # Inference mode forward pass.
        if self.inference_mode:
            return self.activation(self.se(self.reparam_conv(x)))

        # Multi-branched train-time forward pass.
        # Skip branch output
        identity_out = 0
        if self.rbr_skip is not None:
            identity_out = self.rbr_skip(x)

        # Scale branch output
        scale_out = 0
        if self.rbr_scale is not None:
            scale_out = self.rbr_scale(x)

        # Other branches
        out = scale_out + identity_out
        for ix in range(self.num_conv_branches):
            out += self.rbr_conv[ix](x)

        return self.activation(self.se(out))

    def reparameterize(self):
        """ Following works like `RepVGG: Making VGG-style ConvNets Great Again` -
        https://arxiv.org/pdf/2101.03697.pdf. We re-parameterize multi-branched
        architecture used at training time to obtain a plain CNN-like structure
        for inference.
        """
        if self.inference_mode:
            return
        kernel, bias = self._get_kernel_bias()
        self.reparam_conv = nn.Conv2d(in_channels=self.rbr_conv[0].conv.in_channels,
                                      out_channels=self.rbr_conv[0].conv.out_channels,
                                      kernel_size=self.rbr_conv[0].conv.kernel_size,
                                      stride=self.rbr_conv[0].conv.stride,
                                      padding=self.rbr_conv[0].conv.padding,
                                      dilation=self.rbr_conv[0].conv.dilation,
                                      groups=self.rbr_conv[0].conv.groups,
                                      bias=True)
        self.reparam_conv.weight.data = kernel
        self.reparam_conv.bias.data = bias

        # Delete un-used branches
        for para in self.parameters():
            para.detach_()
        self.__delattr__('rbr_conv')
        self.__delattr__('rbr_scale')
        if hasattr(self, 'rbr_skip'):
            self.__delattr__('rbr_skip')

        self.inference_mode = True

    def _get_kernel_bias(self) -> Tuple[torch.Tensor, torch.Tensor]:
        """ Method to obtain re-parameterized kernel and bias.
        Reference: https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py#L83
        :return: Tuple of (kernel, bias) after fusing branches.
        """
        # get weights and bias of scale branch
        kernel_scale = 0
        bias_scale = 0
        if self.rbr_scale is not None:
            kernel_scale, bias_scale = self._fuse_bn_tensor(self.rbr_scale)
            # Pad scale branch kernel to match conv branch kernel size.
            pad = self.kernel_size // 2
            kernel_scale = torch.nn.functional.pad(kernel_scale, [pad, pad, pad, pad])

        # get weights and bias of skip branch
        kernel_identity = 0
        bias_identity = 0
        if self.rbr_skip is not None:
            kernel_identity, bias_identity = self._fuse_bn_tensor(self.rbr_skip)

        # get weights and bias of conv branches
        kernel_conv = 0
        bias_conv = 0
        for ix in range(self.num_conv_branches):
            _kernel, _bias = self._fuse_bn_tensor(self.rbr_conv[ix])
            kernel_conv += _kernel
            bias_conv += _bias

        kernel_final = kernel_conv + kernel_scale + kernel_identity
        bias_final = bias_conv + bias_scale + bias_identity
        return kernel_final, bias_final

    def _fuse_bn_tensor(self, branch) -> Tuple[torch.Tensor, torch.Tensor]:
        """ Method to fuse batchnorm layer with preceeding conv layer.
        Reference: https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py#L95

        :param branch:
        :return: Tuple of (kernel, bias) after fusing batchnorm.
        """
        if isinstance(branch, nn.Sequential):
            kernel = branch.conv.weight
            running_mean = branch.bn.running_mean
            running_var = branch.bn.running_var
            gamma = branch.bn.weight
            beta = branch.bn.bias
            eps = branch.bn.eps
        else:
            assert isinstance(branch, nn.BatchNorm2d)
            if not hasattr(self, 'id_tensor'):
                input_dim = self.in_channels // self.groups
                kernel_value = torch.zeros((self.in_channels, input_dim, self.kernel_size, self.kernel_size),
                                           dtype=branch.weight.dtype, device=branch.weight.device)
                for i in range(self.in_channels):
                    kernel_value[i, i % input_dim,self.kernel_size // 2, self.kernel_size // 2] = 1
                self.id_tensor = kernel_value
            kernel = self.id_tensor
            running_mean = branch.running_mean
            running_var = branch.running_var
            gamma = branch.weight
            beta = branch.bias
            eps = branch.eps
        std = (running_var + eps).sqrt()
        t = (gamma / std).reshape(-1, 1, 1, 1)
        return kernel * t, beta - running_mean * gamma / std

    def _conv_bn(self, kernel_size: int, padding: int) -> nn.Sequential:
        """ Helper method to construct conv-batchnorm layers.
        :param kernel_size: Size of the convolution kernel.
        :param padding: Zero-padding size.
        :return: Conv-BN module.
        """
        mod_list = nn.Sequential()
        mod_list.add_module('conv', nn.Conv2d(in_channels=self.in_channels,out_channels=self.out_channels,
                                              kernel_size=kernel_size, stride=self.stride, padding=padding, groups=self.groups, bias=False))
        mod_list.add_module('bn', nn.BatchNorm2d(num_features=self.out_channels))
        return mod_list

class MobileOne(nn.Module):
    """ MobileOne Model  https://arxiv.org/pdf/2206.04040.pdf """
    def __init__(self,
                 in_channels, out_channels,
                 num_blocks_per_stage = 2, num_conv_branches: int = 1,
                 use_se: bool = False, num_se: int = 0,
                 inference_mode: bool = False, ) -> None:
        """ Construct MobileOne model.
        :param num_blocks_per_stage: List of number of blocks per stage.
        :param num_classes: Number of classes in the dataset.
        :param width_multipliers: List of width multiplier for blocks in a stage.
        :param inference_mode: If True, instantiates model in inference mode.
        :param use_se: Whether to use SE-ReLU activations.
        :param num_conv_branches: Number of linear conv branches.
        """
        super().__init__()
        self.inference_mode = inference_mode
        self.use_se = use_se
        self.num_conv_branches = num_conv_branches

        self.stage = self._make_stage(in_channels, out_channels, num_blocks_per_stage, num_se_blocks= num_se if use_se else 0)


    def _make_stage(self, in_channels, out_channels,  num_blocks: int, num_se_blocks: int) -> nn.Sequential:
        """ Build a stage of MobileOne model.

        :param planes: Number of output channels.
        :param num_blocks: Number of blocks in this stage.
        :param num_se_blocks: Number of SE blocks in this stage.
        :return: A stage of MobileOne model.
        """
        # Get strides for all layers
        strides = [2] + [1]*(num_blocks-1)
        blocks = []
        for ix, stride in enumerate(strides):  # 用于训练几个blocks
            use_se = False
            if num_se_blocks > num_blocks:
                raise ValueError("Number of SE blocks cannot " "exceed number of layers.")
            if ix >= (num_blocks - num_se_blocks):
                use_se = True

            # Depthwise conv
            blocks.append(MobileOneBlock(in_channels=in_channels, out_channels=in_channels,
                                         kernel_size=3, stride=stride, padding=1, groups=in_channels,
                                         inference_mode=self.inference_mode, use_se=use_se, num_conv_branches=self.num_conv_branches))
            # Pointwise conv
            blocks.append(MobileOneBlock(in_channels=in_channels, out_channels=out_channels,
                                         kernel_size=1, stride=1, padding=0, groups=1,
                                         inference_mode=self.inference_mode, use_se=use_se, num_conv_branches=self.num_conv_branches))
            in_channels = out_channels
        return nn.Sequential(*blocks)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """ Apply forward pass. """
        x = self.stage(x)
        return x

def reparameterize_model(model: torch.nn.Module) -> nn.Module:
    """ Method returns a model where a multi-branched structure
        used in training is re-parameterized into a single branch
        for inference.

    :param model: MobileOne model in train mode.
    :return: MobileOne model in inference mode.
    """
    # Avoid editing original graph
    model = copy2.deepcopy(model)
    for module in model.modules():
        if hasattr(module, 'reparameterize'):
            module.reparameterize()
    return model

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

from models.mobileone import *

并搜索def parse_model(d, ch)

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

  elif m in [MobileOneBlock, MobileOne]:
            c1, c2 = ch[f], args[0]
            args = [c1, c2, *args[1:]]

三、YOLOv7-tiny改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov7-tiny-mobileone.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, MobileOneBlock, [48, 3, 2, 1]], # 0
   [-1, 1, MobileOne, [48, 2, 4, False, 0]], # 1
   [-1, 1, MobileOne, [128, 8, 4, False, 0]], # 2
   [-1, 1, MobileOne, [256, 10, 4, False, 0]], # 3
   [-1, 1, MobileOne, [512, 1, 4, False, 0]], # 4
  ]

# yolov7-tiny head
head:
  [[-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, SP, [5]],
   [-2, 1, SP, [9]],
   [-3, 1, SP, [13]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -7], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 13


   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [3, 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)]],  # 23

   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2], 1, Concat, [1]],                              # 27

   [-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)]],  # 33

   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 23], 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)]],  # 41

   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 13], 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, 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)]],  # 49

   [33, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [41, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [49, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]], # 52

   [[50,51,52], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]



                 from  n    params  module                                  arguments                     
  0                -1  1      1632  models.mobileone.MobileOneBlock         [3, 48, 3, 2, 1]              
  1                -1  1     24000  models.mobileone.MobileOne              [48, 48, 2, 4, False, 0]      
  2                -1  1    539472  models.mobileone.MobileOne              [48, 128, 8, 4, False, 0]     
  3                -1  1   2634368  models.mobileone.MobileOne              [128, 256, 10, 4, False, 0]   
  4                -1  1    540416  models.mobileone.MobileOne              [256, 512, 1, 4, False, 0]    
  5                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  6                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  7                -1  1         0  models.common.SP                        [5]                           
  8                -2  1         0  models.common.SP                        [9]                           
  9                -3  1         0  models.common.SP                        [13]                          
 10  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 11                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 12          [-1, -7]  1         0  models.common.Concat                    [1]                           
 13                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16                 3  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 17          [-1, -2]  1         0  models.common.Concat                    [1]                           
 18                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 19                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 20                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 21                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 22  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 23                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 24                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 25                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 26                 2  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 27          [-1, -2]  1         0  models.common.Concat                    [1]                           
 28                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 29                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 30                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 32  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 33                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 34                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 35          [-1, 23]  1         0  models.common.Concat                    [1]                           
 36                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 37                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 39                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 40  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 41                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 42                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 43          [-1, 13]  1         0  models.common.Concat                    [1]                           
 44                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 45                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 47                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 49                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 50                33  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 51                41  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 52                49  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53      [50, 51, 52]  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: 953 layers, 7290460 parameters, 7290460 gradients, 23.9 GFLOPS

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

四、YOLOv5n改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5n-mobileone.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, MobileOneBlock, [48, 3, 2, 1]], # 0
   [-1, 1, MobileOne, [48, 2, 4, False, 0]], # 1
   [-1, 1, MobileOne, [128, 8, 4, False, 0]], # 2
   [-1, 1, MobileOne, [256, 10, 4, False, 0]], # 3
   [-1, 1, MobileOne, [512, 1, 4, False, 0]], # 4
  ]

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

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

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 9], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 15 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 5], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 18 (P5/32-large)

   [[12, 15, 18], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1      1632  models.mobileone.MobileOneBlock         [3, 48, 3, 2, 1]              
  1                -1  1     24000  models.mobileone.MobileOne              [48, 48, 2, 4, False, 0]      
  2                -1  1    539472  models.mobileone.MobileOne              [48, 128, 8, 4, False, 0]     
  3                -1  1   2634368  models.mobileone.MobileOne              [128, 256, 10, 4, False, 0]   
  4                -1  1    540416  models.mobileone.MobileOne              [256, 512, 1, 4, False, 0]    
  5                -1  1     65792  models.common.Conv                      [512, 128, 1, 1]              
  6                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  7           [-1, 3]  1         0  models.common.Concat                    [1]                           
  8                -1  1    107264  models.common.C3                        [384, 128, 1, False]          
  9                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               
 10                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 11           [-1, 2]  1         0  models.common.Concat                    [1]                           
 12                -1  1     27008  models.common.C3                        [192, 64, 1, False]           
 13                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 14           [-1, 9]  1         0  models.common.Concat                    [1]                           
 15                -1  1     74496  models.common.C3                        [128, 128, 1, False]          
 16                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 17           [-1, 5]  1         0  models.common.Concat                    [1]                           
 18                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 19      [12, 15, 18]  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: 909 layers, 4512038 parameters, 4512038 gradients, 19.4 GFLOPs

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

五、YOLOv5s改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5s-vanillanet.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, MobileOneBlock, [48, 3, 2, 1]], # 0
   [-1, 1, MobileOne, [48, 2, 4, False, 0]], # 1
   [-1, 1, MobileOne, [128, 8, 4, False, 0]], # 2
   [-1, 1, MobileOne, [256, 10, 4, False, 0]], # 3
   [-1, 1, MobileOne, [512, 1, 4, False, 0]], # 4
  ]

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

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

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 9], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 15 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 5], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 18 (P5/32-large)

   [[12, 15, 18], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1      1632  models.mobileone.MobileOneBlock         [3, 48, 3, 2, 1]              
  1                -1  1     24000  models.mobileone.MobileOne              [48, 48, 2, 4, False, 0]      
  2                -1  1    539472  models.mobileone.MobileOne              [48, 128, 8, 4, False, 0]     
  3                -1  1   2634368  models.mobileone.MobileOne              [128, 256, 10, 4, False, 0]   
  4                -1  1    540416  models.mobileone.MobileOne              [256, 512, 1, 4, False, 0]    
  5                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]              
  6                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  7           [-1, 3]  1         0  models.common.Concat                    [1]                           
  8                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
  9                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 10                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 11           [-1, 2]  1         0  models.common.Concat                    [1]                           
 12                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 13                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 14           [-1, 9]  1         0  models.common.Concat                    [1]                           
 15                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 16                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 17           [-1, 5]  1         0  models.common.Concat                    [1]                           
 18                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 19      [12, 15, 18]  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: 909 layers, 6590758 parameters, 6590758 gradients, 23.4 GFLOPs

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

下一篇文章：【YOLOv5/v7改进系列】替换骨干网络为ShuffleNetv2

将会进行手把手的改进教学。

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

拿下Nahida
关注
  • 15
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[YOLOv7/YOLOv5系列算法改进NO.40]轻量化mobileone主干网络引入
m0_70388905的博客
10-27 8389
YOLOv5、v7改进之四十：轻量化mobileone主干网络引入。
YOLOv5：修改backbone为mobileone
09-20
1、官方源项目地址 ：https://github.com/ultralytics/yolov5 2、在yolov5-6.1中修改backbone为mobileone。 3、训练、测试、预测命令与官方版本一致。
改进YOLOv5/YOLOv7——魔改YOLOv5/YOLOv7提升检测精度（涨点必备）
热门推荐
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
04-10 5万+
🎄🎄魔改YOLOv5/YOLOv7目标检测算法——各位小伙伴可根据自身研究方向及专业领域自主搭配各类创新新颖且行之有效的网络结构，以此实现论文实验高效涨点。主要包括主干网络改进、轻量化网络、注意力机制、检测头部改进、空间金字塔池化、损失函数及NMS改进、视觉顶会创新点改进以及算法训练相关项目等等。
目标检测算法——YOLOv5/YOLOv7改进之结合MobileOne结构（高性能骨干|仅需1ms）
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
10-19 9147
目标检测算法——YOLOv5/YOLOv7改进之结合MobileOne结构。移动端仅需1ms的高性能骨干！
目标检测算法——YOLOv5/YOLOv7改进之结合GAMAttention
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
10-31 5921
论文题目：Global Attention Mechanism: Retain Information to Enhance Channel-Spatial Interactions作者设计一种减少信息缩减并放大全局维度交互特征的机制，采用了CBAM中的顺序通道-空间注意机制，并对子模块进行了重新设计，具体结构如下图所示。实验结果表明，GAM能够稳定地提高不同架构和深度的CNN的性能，具有良好的数据拓展能力和鲁棒性。
MobileOne实战：使用MobileOne实现图像分类任务.zip
11-30
随着YoloV6和YoloV7的使用，这种方式越来越流行，MobileOne，也是这种方式。MobileOne(≈MobileNetV1+RepVGG+训练Trick)是由Apple公司提出的一种基于iPhone12优化的超轻量型架构，在ImageNet数据集上以的速度取得了...
tensorrt c++ 推理项目
07-03
tensorrt c++ 推理示例项目，支持分类网络，比如alexnet，mobileone,skipnet等轻量级网络。 环境：win10 vs2017环境，cuda11.0，亲测成功。 tensorrt库版本： TensorRT-8.2.1.8.Windows10.x86_64.cuda-11.4.cudnn...
深度学习之基于YoloV5+LPRNet车牌识别系统
2301_79809972的博客
05-18 1084
一、项目背景与意义在智能交通管理系统中，车牌识别技术是一项至关重要的技术。随着车辆数量的不断增长和交通环境的日益复杂，对车牌进行准确、快速的识别已成为现代交通管理不可或缺的一部分。为了满足这一需求，本项目采用了先进的YOLOv5和LPRNet算法，结合深度学习技术，开发了一套高效的车牌识别系统。二、技术原理该系统基于深度学习和目标检测技术，整合了YOLOv5目标检测框架和LPRNet文本识别模型。YOLOv5算法在目标检测领域具有出色的性能，能够快速、准确地检测图像中的目标；
番外篇 | YOLOv8改进之更换主干网络MobileNetv3 + 添加CA注意力机制
突然好想你
05-21 321
MobileNetv3是一种轻量级网络，采用了深度可分离卷积等轻量化技术，具有较小的模型参数量和计算复杂度，适合在计算能力较弱的设备上运行。本节课就让我们结合论文来对YOLOv8进行组合改进（更换主干网络MobileNetv3 + 添加CA注意力机制），希望同学们学完本节课可以有所启迪！🌈
特征融合篇 | YOLOv8改进之引入多尺度特征融合iAFF，提升小目标检测能力
突然好想你
05-19 68
迭代注意力特征融合（Iterative Attentional Feature Fusion，iAFF）是一种用于图像分类的深度学习模型。它使用了多个不同的卷积神经网络（CNN）模型来提取图像特征，并通过迭代注意力机制将这些特征进行融合，以提高分类准确率。🌈
番外篇 | 复现HIC-YOLOv5，助力小目标物体的检测
突然好想你
05-19 223
在本文中提出了一种改进的YOLOv5算法：HIC-YOLOv5，用于小目标检测，具有更好的性能和较低的计算成本。🌈
YOLOv8改进 | 图像去噪篇 | 单阶段盲真实图像去噪网络RIDNet辅助YOLOv8图像去噪（全网独家首发）
Snu77的博客
05-20 1046
本文给大家带来的改进机制是单阶段盲真实图像去噪网络RIDNet，RIDNet（Real Image Denoising with Feature Attention）是一个用于真实图像去噪的卷积神经网络（CNN），旨在解决现有去噪方法在处理真实噪声图像时性能受限的问题。通过单阶段结构和特征注意机制，RIDNet在多种数据集上展示了其优越性，下面的图片为其效果图片包括和其它图像图像网络的对比图。欢迎大家订阅我的专栏一起学习YOLO！
PX4使用yolo仿真环境搭建
超维空间科技的博客
05-21 231
PX4 1.13.3已配置好PX4 ROS gazebo环境。
YOLOv9改进策略 | 图像去雾 | 利用图像去雾网络UnfogNet辅助YOLOv9进行图像去雾检测（全网独家首发）
Snu77的博客
05-20 837
本文给大家带来的改进机制是利用UnfogNet超轻量化图像去雾网络，我将该网络结合YOLOv9针对图像进行去雾检测（也适用于一些模糊场景），我将该网络结构和YOLOv9的网络进行结合同时该网络的结构的参数量非常的小，我们将其添加到模型里增加的计算量和参数量基本可以忽略不计这是非常难得的，因为其也算是一种图像增强算法，同时本文的内容不影响其它的模块改进可以作为工作量凑近大家的论文里，非常的适用，图像去雾检测为群友最近提出的需要的改进。欢迎大家订阅我的专栏一起学习YOLO！
深度学习之基于YoloV5人体打架异常行为识别
2301_79809972的博客
05-20 795
一、项目背景与意义随着社会的发展和科技的进步，对于公共场所的安全监控需求日益增加。尤其是在一些高人流量的场所，如学校、商场、车站等，打架斗殴等异常行为的发生可能会给人们的生命安全和财产带来威胁。因此，开发一种能够实时监测并识别打架斗殴等异常行为的技术显得尤为重要。基于YOLOv5的人体打架异常行为识别项目旨在利用深度学习技术，实现对人体打架等异常行为的快速、准确识别，为公共场所的安全监控提供有力支持。二、技术实现。
特征融合篇 | YOLOv8改进之引入轻量级跨尺度特征融合模块CCFM | 源自RT-DETR
最新发布
突然好想你
05-23 61
CCFM即为跨尺度特征融合模块。这个模块的作用是将不同尺度的特征通过融合操作整合起来，以增强模型对于尺度变化的适应性和对小尺度对象的检测能力。CCFM可以有效地整合细节特征和上下文信息，从而提高模型的整体性能。🌈
YOLOv5独家改进：mamba系列 | 视觉态空间（VSS）块结合C3二次创新，轻量级改进 | VMamba2024年最新成果
各专栏持续更新中，改进创新YOLO，适用v5、v7、v8、v9，订阅者私信添加本人微信！！！ By AI小怪兽
05-20 70
视觉态空间（VSS）块结合C3二次创新，轻量级改进
yolov5 用onnx推理支持按类别就行NMS
u012374012的专栏
05-20 853
self.names = ["face", "person","car","bicycle"] ##换成自己模型对应的类名即可。index = scores.argsort()[::-1] # 对检测框按照置信度进行从高到低的排序，并获取索引。对输入的图片进行目标检测，返回对应的类别的检测框,并可视化输出。x[:, :4]表示box（从二维看第0，1，2，3列）:param iou_thresh: IOU阈值。x[:, 5:6]表示类IDX（从二维看第5列）# 下面的操作为了安全，都是对索引处理。
YOLOV5替换MobileOne
09-07
根据引用和引用的信息，YOLOv5是一种目标检测算法，而MobileOne是一种基于iPhone12优化的超轻量级网络架构。虽然YOLOv5中没有直接提到替换MobileOne，但我们可以通过对YOLOv5的backbone进行修改来实现对MobileOne的替换。 具体来说，我们可以参考引用中关于MobileOne的描述，了解其主要特点和结构。然后，我们可以根据YOLOv5的backbone结构，在common.py文件中进行相应的修改，将MobileOne的架构替换为YOLOv5所需的backbone架构。 通过这样的修改，我们可以实现将MobileOne替换为YOLOv5的backbone，从而提升YOLOv5的性能和效果。同时，我们可以保留YOLOv5的目标检测特性，并在移动设备上获得更好的性能和精度。 总而言之，通过修改YOLOv5的backbone结构，我们可以实现对MobileOne的替换，并提升YOLOv5在移动设备上的目标检测性能。<span class="em">1</span><span class="em">2</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值