YOLOv5改进 | 主干网络 | 将backbone替换为MobileNetV4【小白必备教程+附完整代码】

已于 2024-10-17 17:21:28 修改
阅读量3.5k 收藏 61
点赞数 20
分类专栏： YOLOv5入门 + 改进涨点 文章标签： YOLO 人工智能 深度学习 目标检测 面试 python 网络
于 2024-08-08 11:53:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67647321/article/details/141022415
版权

 秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录： 《YOLOv5入门 + 改进涨点》专栏介绍 & 专栏目录 |目前已有60+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进

 本文介绍了最新一代的MobileNets，即MobileNetV4（MNv4），它具有针对移动设备的通用高效架构设计。在其核心部分，我们引入了通用倒瓶颈（UIB）搜索块，这是一个统一且灵活的结构，它融合了倒瓶颈（IB）、ConvNext、前馈网络（FFN）以及一种新颖的额外深度wise（ExtraDW）变体。与UIB相结合，我们推出了专为移动加速器设计的Mobile MQA注意力块，文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址： YOLOv5改进+入门——持续更新各种有效涨点方法 点击即可跳转   

目录

1. 原理

2.  将MobileNetV4添加到YOLOv5中

2.1 MobileNetV4的代码实现

2.2 新增yaml文件

2.3 注册模块

2.4 替换函数

2.5 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理

论文地址：MobileNetV4 - Universal Models for the Mobile Ecosystem——点击即可跳转

官方代码:  MobileNetV4代码仓库——点击即可跳转

MobileNetV4 (MNv4) 是最新一代 MobileNets，旨在优化各种移动设备的性能。以下是其架构背后的关键原则和组件：

通用倒置瓶颈 (UIB)

  • 倒置瓶颈块：MobileNetV4 以倒置瓶颈 (IB) 块的成功为基础，这是之前 MobileNets 的核心功能。

  • 灵活性和统一性：UIB 结合了多种微架构，包括倒置瓶颈、ConvNext、前馈网络 (FFN) 和创新的额外深度 (ExtraDW) 变体。这种统一使其能够有效地处理不同类型的操作。

  • 可选深度卷积：UIB 包括可选深度卷积，可增强其混合空间和通道信息的计算效率和灵活性。

移动 MQA（移动量化注意力）

  • 效率：此注意力模块专门针对移动加速器进行了优化，与传统的多头注意力 (MHSA) 相比，推理速度显著提高了 39%。

  • 移动设备上的性能：移动 MQA 模块经过量身定制，可充分利用移动硬件的功能，确保更快的处理速度和更低的延迟。

神经架构搜索 (NAS)

  • 优化的搜索方案：MobileNetV4 引入了一种改进的 NAS 流程，其中包括一个两阶段方法：粗粒度搜索和细粒度搜索。此方法提高了搜索过程的效率和有效性，从而可以创建高性能模型。

  • 硬件感知：NAS 方法考虑了各种移动硬件平台的限制和功能，确保生成的模型针对各种设备进行了优化，从 CPU 到专用加速器，如 Apple Neural Engine 和 Google Pixel EdgeTPU。

蒸馏技术

  • 准确度增强：MobileNetV4 采用了一种新颖的蒸馏技术，该技术使用具有不同增强的混合数据集和平衡的类内数据。该技术提高了模型的泛化能力和准确性。

  • 性能：通过这种蒸馏技术增强的 MNv4-Hybrid-Large 模型在 ImageNet-1K 上实现了令人印象深刻的 87% 的准确率，在 Pixel 8 EdgeTPU 上的运行时间仅为 3.8 毫秒。

帕累托最优

  • 性能平衡：MobileNetV4 模型旨在在各种硬件平台上实现帕累托最优，这意味着它们在计算效率和准确性之间提供了最佳平衡。

  • 独立于硬件的效率：这些模型经过测试，证明在不同类型的硬件上表现良好，从 CPU 和 GPU 到 DSP 和专用加速器，使其用途广泛且适用性广泛。

设计考虑

  • 运算强度：MobileNetV4 的设计考虑了不同硬件的运算强度，平衡了计算负载和内存带宽，以最大限度地提高性能。

  • 层优化：MobileNetV4 的初始层设计为计算密集型，以提高模型容量和准确性，而最终层则专注于即使在高 RP（脊点）硬件上也能保持准确性。

总之，MobileNetV4 集成了先进的技术和创新，创建了一系列在各种移动设备上都高效准确的模型。其设计原则强调灵活性、硬件感知优化以及计算效率和模型性能之间的平衡。

2.  将MobileNetV4添加到YOLOv5中

2.1 MobileNetV4的代码实现

关键步骤一: 在yolov5/models/下新建mobilenetv2.py，并粘贴下面的代码

"""
Creates a MobileNetV4 Model as defined in:
Danfeng Qin, Chas Leichner, Manolis Delakis, Marco Fornoni, Shixin Luo, Fan Yang, Weijun Wang, Colby Banbury, Chengxi Ye, Berkin Akin, Vaibhav Aggarwal, Tenghui Zhu, Daniele Moro, Andrew Howard. (2024).
MobileNetV4 - Universal Models for the Mobile Ecosystem
arXiv preprint arXiv:2404.10518.
"""

from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union

import torch
import torch.nn as nn


MNV4ConvSmall_BLOCK_SPECS = {
    "conv0": {
        "block_name": "convbn",
        "num_blocks": 1,
        "block_specs": [
            [3, 32, 3, 2]
        ]
    },
    "layer1": {
        "block_name": "convbn",
        "num_blocks": 2,
        "block_specs": [
            [32, 32, 3, 2],
            [32, 32, 1, 1]
        ]
    },
    "layer2": {
        "block_name": "convbn",
        "num_blocks": 2,
        "block_specs": [
            [32, 96, 3, 2],
            [96, 64, 1, 1]
        ]
    },
    "layer3": {
        "block_name": "uib",
        "num_blocks": 6,
        "block_specs": [
            [64, 96, 5, 5, True, 2, 3],
            [96, 96, 0, 3, True, 1, 2],
            [96, 96, 0, 3, True, 1, 2],
            [96, 96, 0, 3, True, 1, 2],
            [96, 96, 0, 3, True, 1, 2],
            [96, 96, 3, 0, True, 1, 4],
        ]
    },
    "layer4": {
        "block_name": "uib",
        "num_blocks": 6,
        "block_specs": [
            [96,  128, 3, 3, True, 2, 6],
            [128, 128, 5, 5, True, 1, 4],
            [128, 128, 0, 5, True, 1, 4],
            [128, 128, 0, 5, True, 1, 3],
            [128, 128, 0, 3, True, 1, 4],
            [128, 128, 0, 3, True, 1, 4],
        ]
    },  
    "layer5": {
        "block_name": "convbn",
        "num_blocks": 2,
        "block_specs": [
            [128, 960, 1, 1],
            [960, 1280, 1, 1]
        ]
    }
}

MNV4ConvMedium_BLOCK_SPECS = {
    "conv0": {
        "block_name": "convbn",
        "num_blocks": 1,
        "block_specs": [
            [3, 32, 3, 2]
        ]
    },
    "layer1": {
        "block_name": "fused_ib",
        "num_blocks": 1,
        "block_specs": [
            [32, 48, 2, 4.0, True]
        ]
    },
    "layer2": {
        "block_name": "uib",
        "num_blocks": 2,
        "block_specs": [
            [48, 80, 3, 5, True, 2, 4],
            [80, 80, 3, 3, True, 1, 2]
        ]
    },
    "layer3": {
        "block_name": "uib",
        "num_blocks": 8,
        "block_specs": [
            [80,  160, 3, 5, True, 2, 6],
            [160, 160, 3, 3, True, 1, 4],
            [160, 160, 3, 3, True, 1, 4],
            [160, 160, 3, 5, True, 1, 4],
            [160, 160, 3, 3, True, 1, 4],
            [160, 160, 3, 0, True, 1, 4],
            [160, 160, 0, 0, True, 1, 2],
            [160, 160, 3, 0, True, 1, 4]
        ]
    },
    "layer4": {
        "block_name": "uib",
        "num_blocks": 11,
        "block_specs": [
            [160, 256, 5, 5, True, 2, 6],
            [256, 256, 5, 5, True, 1, 4],
            [256, 256, 3, 5, True, 1, 4],
            [256, 256, 3, 5, True, 1, 4],
            [256, 256, 0, 0, True, 1, 4],
            [256, 256, 3, 0, True, 1, 4],
            [256, 256, 3, 5, True, 1, 2],
            [256, 256, 5, 5, True, 1, 4],
            [256, 256, 0, 0, True, 1, 4],
            [256, 256, 0, 0, True, 1, 4],
            [256, 256, 5, 0, True, 1, 2]
        ]
    },  
    "layer5": {
        "block_name": "convbn",
        "num_blocks": 2,
        "block_specs": [
            [256, 960, 1, 1],
            [960, 1280, 1, 1]
        ]
    }
}

MNV4ConvLarge_BLOCK_SPECS = {
    "conv0": {
        "block_name": "convbn",
        "num_blocks": 1,
        "block_specs": [
            [3, 24, 3, 2]
        ]
    },
    "layer1": {
        "block_name": "fused_ib",
        "num_blocks": 1,
        "block_specs": [
            [24, 48, 2, 4.0, True]
        ]
    },
    "layer2": {
        "block_name": "uib",
        "num_blocks": 2,
        "block_specs": [
            [48, 96, 3, 5, True, 2, 4],
            [96, 96, 3, 3, True, 1, 4]
        ]
    },
    "layer3": {
        "block_name": "uib",
        "num_blocks": 11,
        "block_specs": [
            [96,  192, 3, 5, True, 2, 4],
            [192, 192, 3, 3, True, 1, 4],
            [192, 192, 3, 3, True, 1, 4],
            [192, 192, 3, 3, True, 1, 4],
            [192, 192, 3, 5, True, 1, 4],
            [192, 192, 5, 3, True, 1, 4],
            [192, 192, 5, 3, True, 1, 4],
            [192, 192, 5, 3, True, 1, 4],
            [192, 192, 5, 3, True, 1, 4],
            [192, 192, 5, 3, True, 1, 4],
            [192, 192, 3, 0, True, 1, 4]
        ]
    },
    "layer4": {
        "block_name": "uib",
        "num_blocks": 13,
        "block_specs": [
            [192, 512, 5, 5, True, 2, 4],
            [512, 512, 5, 5, True, 1, 4],
            [512, 512, 5, 5, True, 1, 4],
            [512, 512, 5, 5, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4],
            [512, 512, 5, 3, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4],
            [512, 512, 5, 3, True, 1, 4],
            [512, 512, 5, 5, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4],
            [512, 512, 5, 0, True, 1, 4]
        ]
    },  
    "layer5": {
        "block_name": "convbn",
        "num_blocks": 2,
        "block_specs": [
            [512, 960, 1, 1],
            [960, 1280, 1, 1]
        ]
    }
}

MNV4HybridConvMedium_BLOCK_SPECS = {

}

MNV4HybridConvLarge_BLOCK_SPECS = {

}

MODEL_SPECS = {
    "MobileNetV4ConvSmall": MNV4ConvSmall_BLOCK_SPECS,
    "MobileNetV4ConvMedium": MNV4ConvMedium_BLOCK_SPECS,
    "MobileNetV4ConvLarge": MNV4ConvLarge_BLOCK_SPECS,
    "MobileNetV4HybridMedium": MNV4HybridConvMedium_BLOCK_SPECS,
    "MobileNetV4HybridLarge": MNV4HybridConvLarge_BLOCK_SPECS,
}

def make_divisible(
        value: float,
        divisor: int,
        min_value: Optional[float] = None,
        round_down_protect: bool = True,
    ) -> int:
    """
    This function is copied from here 
    "https://github.com/tensorflow/models/blob/master/official/vision/modeling/layers/nn_layers.py"
    
    This is to ensure that all layers have channels that are divisible by 8.

    Args:
        value: A `float` of original value.
        divisor: An `int` of the divisor that need to be checked upon.
        min_value: A `float` of  minimum value threshold.
        round_down_protect: A `bool` indicating whether round down more than 10%
        will be allowed.

    Returns:
        The adjusted value in `int` that is divisible against divisor.
    """
    if min_value is None:
        min_value = divisor
    new_value = max(min_value, int(value + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if round_down_protect and new_value < 0.9 * value:
        new_value += divisor
    return int(new_value)

def conv_2d(inp, oup, kernel_size=3, stride=1, groups=1, bias=False, norm=True, act=True):
    conv = nn.Sequential()
    padding = (kernel_size - 1) // 2
    conv.add_module('conv', nn.Conv2d(inp, oup, kernel_size, stride, padding, bias=bias, groups=groups))
    if norm:
        conv.add_module('BatchNorm2d', nn.BatchNorm2d(oup))
    if act:
        conv.add_module('Activation', nn.ReLU6())
    return conv

class InvertedResidual(nn.Module):
    def __init__(self, inp, oup, stride, expand_ratio, act=False):
        super(InvertedResidual, self).__init__()
        self.stride = stride
        assert stride in [1, 2]
        hidden_dim = int(round(inp * expand_ratio))
        self.block = nn.Sequential()
        if expand_ratio != 1:
            self.block.add_module('exp_1x1', conv_2d(inp, hidden_dim, kernel_size=1, stride=1))
        self.block.add_module('conv_3x3', conv_2d(hidden_dim, hidden_dim, kernel_size=3, stride=stride, groups=hidden_dim))
        self.block.add_module('red_1x1', conv_2d(hidden_dim, oup, kernel_size=1, stride=1, act=act))
        self.use_res_connect = self.stride == 1 and inp == oup

    def forward(self, x):
        if self.use_res_connect:
            return x + self.block(x)
        else:
            return self.block(x)

class UniversalInvertedBottleneckBlock(nn.Module):
    def __init__(self, 
            inp, 
            oup, 
            start_dw_kernel_size, 
            middle_dw_kernel_size, 
            middle_dw_downsample,
            stride,
            expand_ratio
        ):
        super().__init__()
        # Starting depthwise conv.
        self.start_dw_kernel_size = start_dw_kernel_size
        if self.start_dw_kernel_size:            
            stride_ = stride if not middle_dw_downsample else 1
            self._start_dw_ = conv_2d(inp, inp, kernel_size=start_dw_kernel_size, stride=stride_, groups=inp, act=False)
        # Expansion with 1x1 convs.
        expand_filters = make_divisible(inp * expand_ratio, 8)
        self._expand_conv = conv_2d(inp, expand_filters, kernel_size=1)
        # Middle depthwise conv.
        self.middle_dw_kernel_size = middle_dw_kernel_size
        if self.middle_dw_kernel_size:
            stride_ = stride if middle_dw_downsample else 1
            self._middle_dw = conv_2d(expand_filters, expand_filters, kernel_size=middle_dw_kernel_size, stride=stride_, groups=expand_filters)
        # Projection with 1x1 convs.
        self._proj_conv = conv_2d(expand_filters, oup, kernel_size=1, stride=1, act=False)
        
        # Ending depthwise conv.
        # this not used
        # _end_dw_kernel_size = 0
        # self._end_dw = conv_2d(oup, oup, kernel_size=_end_dw_kernel_size, stride=stride, groups=inp, act=False)
        
    def forward(self, x):
        if self.start_dw_kernel_size:
            x = self._start_dw_(x)
            # print("_start_dw_", x.shape)
        x = self._expand_conv(x)
        # print("_expand_conv", x.shape)
        if self.middle_dw_kernel_size:
            x = self._middle_dw(x)
            # print("_middle_dw", x.shape)
        x = self._proj_conv(x)
        # print("_proj_conv", x.shape)
        return x

def build_blocks(layer_spec):
    if not layer_spec.get('block_name'):
        return nn.Sequential()
    block_names = layer_spec['block_name']
    layers = nn.Sequential()
    if block_names == "convbn":
        schema_ = ['inp', 'oup', 'kernel_size', 'stride']
        args = {}
        for i in range(layer_spec['num_blocks']):
            args = dict(zip(schema_, layer_spec['block_specs'][i]))
            layers.add_module(f"convbn_{i}", conv_2d(**args))
    elif block_names == "uib":
        schema_ =  ['inp', 'oup', 'start_dw_kernel_size', 'middle_dw_kernel_size', 'middle_dw_downsample', 'stride', 'expand_ratio']
        args = {}
        for i in range(layer_spec['num_blocks']):
            args = dict(zip(schema_, layer_spec['block_specs'][i]))
            layers.add_module(f"uib_{i}", UniversalInvertedBottleneckBlock(**args))
    elif block_names == "fused_ib":
        schema_ = ['inp', 'oup', 'stride', 'expand_ratio', 'act']
        args = {}
        for i in range(layer_spec['num_blocks']):
            args = dict(zip(schema_, layer_spec['block_specs'][i]))
            layers.add_module(f"fused_ib_{i}", InvertedResidual(**args))
    else:
        raise NotImplementedError
    return layers


class MobileNetV4(nn.Module):
    def __init__(self, model):
        # MobileNetV4ConvSmall  MobileNetV4ConvMedium  MobileNetV4ConvLarge
        # MobileNetV4HybridMedium  MobileNetV4HybridLarge
        """Params to initiate MobilenNetV4
        Args:
            model : support 5 types of models as indicated in 
            "https://github.com/tensorflow/models/blob/master/official/vision/modeling/backbones/mobilenet.py"        
        """
        super().__init__()
        assert model in MODEL_SPECS.keys()
        self.model = model
        self.spec = MODEL_SPECS[self.model]
       
        # conv0
        self.conv0 = build_blocks(self.spec['conv0'])
        # layer1
        self.layer1 = build_blocks(self.spec['layer1'])
        # layer2
        self.layer2 = build_blocks(self.spec['layer2'])
        # layer3
        self.layer3 = build_blocks(self.spec['layer3'])
        # layer4
        self.layer4 = build_blocks(self.spec['layer4'])
        # layer5   
        self.layer5 = build_blocks(self.spec['layer5'])
        self.features = nn.ModuleList([self.conv0, self.layer1, self.layer2, self.layer3, self.layer4, self.layer5])     
        self.channel = [i.size(1) for i in self.forward(torch.randn(1, 3, 640, 640))]
        
    def forward(self, x):
        input_size = x.size(2)
        scale = [4, 8, 16, 32]
        features = [None, None, None, None]
        for f in self.features:
            x = f(x)
            if input_size // x.size(2) in scale:
                features[scale.index(input_size // x.size(2))] = x
        return features

def MobileNetV4ConvSmall():
    model = MobileNetV4('MobileNetV4ConvSmall')
    return model

def MobileNetV4ConvMedium():
    model = MobileNetV4('MobileNetV4ConvMedium')
    return model

def MobileNetV4ConvLarge():
    model = MobileNetV4('MobileNetV4ConvLarge')
    return model

def MobileNetV4HybridMedium():
    model = MobileNetV4('MobileNetV4HybridMedium')
    return model

def MobileNetV4HybridLarge():
    model = MobileNetV4('MobileNetV4HybridLarge')
    return model

 MobileNetV4处理图像的主要步骤可以概括为以下几个关键阶段：

1. 图像预处理

在输入模型之前，图像会经过一些预处理步骤，这通常包括：

  • 缩放：将图像调整到指定的输入大小（如224x224）。

  • 归一化：对图像像素值进行归一化处理，使其值在特定范围内（如0到1或-1到1）。

2. 初始卷积层

图像首先通过一个标准卷积层，该层具有较大的卷积核（如3x3或5x5），用于捕捉低级别的特征，例如边缘和纹理。这一层通常是计算密集型的，以便在早期捕获更多的信息。

3. 倒瓶颈块（Inverted Bottleneck Block）

在MobileNetV4中，倒瓶颈块（IB块）是核心组件之一。每个倒瓶颈块包含以下子步骤：

  • 扩展卷积：首先使用1x1卷积扩展特征图的通道数。

  • 深度可分离卷积：然后使用深度可分离卷积（Depthwise Separable Convolution）在空间维度上进行卷积操作。

  • 压缩卷积：最后通过1x1卷积将通道数压缩回去。

4. 通用倒瓶颈块（Universal Inverted Bottleneck, UIB）

MobileNetV4引入了UIB，这种块可以灵活地调整，以适应不同的计算需求：

  • 标准倒瓶颈：与传统倒瓶颈类似，但增加了更多的灵活性。

  • ConvNext变体：结合了现代卷积架构的优点。

  • 前馈网络（FFN）：适用于需要更多非线性变换的场景。

  • 额外深度可分离卷积（ExtraDW）：用于提高计算效率和特征提取能力。

5. Mobile MQA注意力块

这个模块是优化后的注意力机制，专门设计用于移动设备：

  • 注意力计算：对特征图进行加权操作，以增强重要特征并抑制不重要的部分。

  • 快速推理：该模块在硬件加速器上实现了快速的推理速度，提高了整体的处理效率。

6. 全局平均池化

在最后的卷积层之后，模型会对特征图进行全局平均池化（Global Average Pooling），将特征图转化为固定长度的向量。这一步骤通过取每个特征图的平均值，将空间维度消除，仅保留通道维度的信息。

7. 全连接层和分类层

最后，通过全连接层（Fully Connected Layer）和Softmax分类层，将特征向量转换为最终的分类结果。

通过上述步骤，MobileNetV4能够高效地处理和分类输入图像，特别适用于资源受限的移动设备上，同时保证了较高的精度和性能。

2.2 新增yaml文件

关键步骤二：在下/yolov5/models下新建文件 yolov5_MobileNetv4.yaml并将下面代码复制进去

  •  目标检测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, MobileNetV4ConvSmall, []],#4
   [-1, 1, SPPF, [1024, 5]],  # 5
  ]

# 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]],  # 9

   [-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]],  # 13 (P3/8-small)

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

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

   [[13, 16, 19], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]
  • 语义分割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, MobileNetV4ConvSmall, []],#4
   [-1, 1, SPPF, [1024, 5]],  # 5
  ]

# 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]],  # 9

   [-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]],  # 13 (P3/8-small)

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

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

   [[13, 16, 19], 1, Segment, [nc, anchors, 32, 256]], # Detect(P3, P4, P5)
  ]

温馨提示：本文只是对yolov5基础上添加模块，如果要对yolov5n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。 

# YOLOv5n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
 
# YOLOv5s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
 
# YOLOv5l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
 
# YOLOv5m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
 
# YOLOv5x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple

2.3 注册模块

关键步骤三：在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)

    is_backbone = False
    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
        try:
            t = m
            m = eval(m) if isinstance(m, str) else m  # eval strings
        except:
            pass
        for j, a in enumerate(args):
            with contextlib.suppress(NameError):
                try:
                    args[j] = eval(a) if isinstance(a, str) else a  # eval strings
                except:
                    args[j] = a

        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}:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]
            if m in {BottleneckCSP, C3, C3TR, C3Ghost, C3x}:
                args.insert(2, n)  # number of repeats
                n = 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, Segment}:
            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)
            if m is Segment:
                args[3] = make_divisible(args[3] * gw, 8)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        elif isinstance(m, str): 
            t = m
            m = timm.create_model(m, pretrained=args[0], features_only=True)
            c2 = m.feature_info.channels()
        elif m in {MobileNetV4ConvSmall}:
            m = m(*args)
            c2 = m.channel
        else:
            c2 = ch[f]
        if isinstance(c2, list):
            is_backbone = True
            m_ = m
            m_.backbone = True
        else:
            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 + 4 if is_backbone else 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 + 4 if is_backbone else i) for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
        layers.append(m_)
        if i == 0:
            ch = []
        if isinstance(c2, list):
            ch.extend(c2)
            for _ in range(5 - len(ch)):
                ch.insert(0, 0)
        else:
            ch.append(c2)
    return nn.Sequential(*layers), sorted(save)

2.4 替换函数

关键步骤四：在yolo.py的_forward_once函数替换为下面的函数

    def _forward_once(self, x, profile=False, visualize=False):
        y, dt = [], []  # outputs
        for m in self.model:
            if m.f != -1:  # if not from previous layer
                x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
            if profile:
                self._profile_one_layer(m, x, dt)
            if hasattr(m, 'backbone'):
                x = m(x)
                for _ in range(5 - len(x)):
                    x.insert(0, None)
                for i_idx, i in enumerate(x):
                    if i_idx in self.save:
                        y.append(i)
                    else:
                        y.append(None)
                x = x[-1]
            else:
                x = m(x)  # run
                y.append(x if m.i in self.save else None)  # save output
            if visualize:
                feature_visualization(x, m.type, m.i, save_dir=visualize)
        return x

2.5 执行程序

在train.py中，将cfg的参数路径设置为yolov5_MobileNetv4.yaml的路径

建议大家写绝对路径，确保一定能找到  

🚀运行程序，如果出现下面的内容则说明添加成功🚀 

                  from n   params  module                                   arguments
  0                -1  1   2493024  MobileNetV4ConvSmall                    []
  1                -1  1   3443968  models.common.SPPF                      [1280, 1024, 5]
  2                -1  1    525312  models.common.Conv                      [1024, 512, 1, 1]
  3                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
  4           [-1, 3]  1         0  models.common.Concat                    [1]
  5                -1  3   2544640  models.common.C3                        [608, 512, 3, False]
  6                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]
  7                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
  8           [-1, 2]  1         0  models.common.Concat                    [1]
  9                -1  3    641536  models.common.C3                        [320, 256, 3, False]
 10                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]
 11          [-1, 10]  1         0  models.common.Concat                    [1]
 12                -1  3   2495488  models.common.C3                        [512, 512, 3, False]
 13                -1  1   2360320  models.common.Conv                      [512, 512, 3, 2]
 14           [-1, 5]  1         0  models.common.Concat                    [1]
 15                -1  3  10496000  models.common.C3                        [1536, 1024, 3, False]        
 16      [13, 16, 19]  1    457725  Detect                                  [80, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [256, 512, 1024]]
YOLOv5_mobilenetv4 summary: 350 layers, 26179933 parameters, 26179933 gradients, 58.1 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1ghCwJh4egmA24ELLC-m44w?pwd=5ws3

 提取码: 5ws3

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的GFLOPs

img​

改进后的GFLOPs

​

5. 进阶

可以结合损失函数或者卷积模块进行多重改进

YOLOv5改进 | 损失函数 | EIoU、SIoU、WIoU、DIoU、FocuSIoU等多种损失函数——点击即可跳转

6. 总结

MobileNetV4（MNv4）是最新一代的MobileNet，其核心原理在于实现了跨各种移动设备的高效性能。它引入了通用倒瓶颈（UIB）搜索块，这是一种统一且灵活的结构，结合了倒瓶颈、ConvNext、前馈网络（FFN）和新的额外深度可分离卷积（ExtraDW）变体。与此同时，MobileNetV4还推出了专为移动加速器优化的Mobile MQA注意力块，提高了39%的推理速度。通过改进的神经架构搜索（NAS）方法，MobileNetV4显著提高了搜索效率，创建了在CPU、DSP、GPU以及专用加速器（如Apple Neural Engine和Google Pixel EdgeTPU）上表现优异的模型。此外，MobileNetV4还采用了一种新的蒸馏技术，进一步提高了模型的准确性。整体上，MobileNetV4通过整合UIB、Mobile MQA和改进的NAS方法，成功打造出一系列在移动设备上表现最优的模型，兼顾计算效率和精度，实现了在多种硬件平台上的帕累托最优性能。

YOLOv8改进 | 主干网络 | 将backbone替换为MobileNetV4【小白必备教程+附完整代码】
kay_545
08-07 2519
yolov8，mobileNetv4，yolov8改进
YOLOv5轻量化改进 | backbone | 结合MobileNetV4（包含多个结构和使用方式）
qq_44224801的博客
08-03 1012
YOLOv5轻量化改进 | backbone | 结合MobileNetV4（包含多个结构和使用方式）
yolo系列理论补充（v4、v5、x）和瑞芯微
Jormungand123的博客
03-23 2904
最近快要复试了，没怎么搞毕设，那就顺带补充补充理论知识，以后也用得上。 基本为搬运，主要写给自己看的。 ​​​​​​神经网络学习小记录60——Pytorch GhostNet模型的复现详解_Bubbliiiing的博客-CSDN博客​​​​​​ GhostNet-YOLOv4 首先学习基于pytorch的GhostNet-YOLOv4 由2020年华为新出的一个轻量级网络——GhostNet 使用ghost模块，代替普通3×3卷积（对比mobilenet v1使用深度可分离卷积代替普通3×3卷积
【YOLOv8】YOLOv8改进系列（11）----替换主干网络之MobileNetV4
最新发布
熬夜秃顶中......
03-31 2256
YOLOv8改进系列（11）----替换主干网络之MobileNetV4
YOLOv10改进 | 主干篇 | YOLOv10引入MobileNetV4
tsg6698的博客
06-16 2265
在其核心，我们引入了通用倒瓶颈（UIB）搜索块，这是一种统一且灵活的结构，融合了倒瓶颈（IB）、ConvNext、前馈网络（FFN）和新颖的额外深度（ExtraDW）变体。Mobile MQA是MNv4的另一个关键组件，这是一个为移动加速器量身定制的注意力块，提供了超过39%的推理加速。到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv10改进有效涨点专栏，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~
YOLOv8改进策略|MobileNetv4替换主干网络
m0_61698839的博客
07-08 9401
yolov8的改进策略分享|采用mobilenetv4对yolov8的主干网络进行替换
YOLOv8改进 | 主干篇 | 2024.5全新的移动端网络MobileNetV4改进YOLOv8（含MobileNetV4全部版本改进）
Snu77的博客
05-08 8536
本文给大家带来的改进机制是MobileNetV4，MobileNetV4是一种高度优化的神经网络架构，专为移动设备设计。它最新的改动总结主要有两点，采用了通用反向瓶颈（UIB）和针对移动加速器优化的Mobile MQA注意力模块（一种全新的注意力机制）。这些创新有助于在不牺牲准确性的情况下，显著提高推理速度和计算效率。MobileNetV4作为一种移动端的网络，其实它的论文中主要是配合蒸馏技术进行改进，大家可以搭配本专栏的蒸馏进行二次创新涨点。
YOLO11改进 | 主干网络 | 将backbone替换为MobileNetV4【小白必备教程+附完整代码】
kay_545
10-24 2374
yolo11改进，yolo11，MobileNetV4
YOLOv8改进有效系列目录 | 包含卷积、主干、检测头、注意力机制、Neck上百种创新机制
热门推荐
Snu77的博客
12-30 15万+
Hello，各位读者们好，本专栏自开设两个月以来已经更新改进教程120+余篇其中包含C2f、主干、检测头、注意力机制、Neck多种结构上创新，也有损失函数和一些细节点上的创新，订阅本专栏以后你不仅可以收获跟专栏的阅读权限，同时可以进Qq群，里面包含集成我所有创新的YOLO最新目录，和我本人录制的视频讲解教程，如果你想要在YOLOv8系列收获一篇论文，我相信订阅本专栏后你一定会有所收获~YOLOv8改进有效系列目录。
YOLOv11改进有效涨点专栏目录 | 含卷积、主干、注意力机制、Neck、检测头、损失函数、二次创新C2PSA/C3k2等各种网络结构改进
Snu77的博客
11-05 4万+
Hello，各位读者们好.本文为最新YOLOv11有效涨点专栏目录，YOLOv11以及发布了一个月左右，这个过程中我也是给大家整理了许多的机制，其中包含了C3k2、主干（均支持根据yolov11训练的版本进行二次缩放，全系列都能轻量化）、检测头、注意力机制、Neck多种结构上创新，也有损失函数和一些细节点上的创新。
《YOLOv5入门 + 改进涨点》专栏介绍 & 专栏目录 |目前已有80+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进
kay_545
06-17 6442
本专栏是博主精心设计的专门为了提升检测效果，希望改进YOLOv5并发表论文的同学们而设计。专栏的内容紧跟学术届的热点更新最新内容，紧跟YOLOv5的官方项目的实时更新。本专栏的内容是基于YOLOv5-6.1的版本进行改进专栏聚焦前沿方法，本专栏的改进，适用于目标检测任务。且改进后的算法使用于多种场景，包括但不限于。
flexible-yolov5:具有更多主干（resnet，shufflenet，moblienet）的更具可读性和灵活性的yolov5
03-26
flexible-yolov5 基于 。 原始的Yolo V5是一个了不起的项目。 对于专业人士而言，理解和修改其代码应该不难。 我不是专家。 当我想对网络进行一些更改时，这并不是一件容易的事，例如添加分支和尝试其他骨干网。 也许会有像我这样的人，所以我将yolov5模型拆分为{主干，脖子，头部}，以方便各种模块的操作并支持更多的主干。基本上，我只更改了模型，而没有更改架构，培训和测试yolov5。 因此，如果原始代码被更新，则更新该代码也非常方便。 目录 [培训与测试]（＃培训与测试） 特征 重组骨干，脖子，头部等模型结构，可以灵活方便地修改网络 更多主干，mobilenetV3，shufflenetV2，resnet18、50、101等 先决条件 请参阅requirements.txt 入门 数据集准备 以yolov5格式制作数据。 您可以使用utils / make_yolov5
爆改YOLOv8|使用MobileNetV4替换yolov8的Backbone
weixin_43986124的博客
09-12 5562
MobileNetV4，yolov8改进backbone, yolov8改进， 即插即用
YOLOv8改进，YOLOv8改进主干网络为MobileNetV4(2024独家首发，助力涨点)
在职AI算法工程师，擅长计算机视觉，YOLO目标检测、分割等，擅长web、pyqt界面可视化，好内容持续更新中，来这里跟大家一起学习，共同进步
09-07 1737
MobileNetV4具有面向移动设备的通用高效架构设计。其核心是我们引入的通用倒置瓶颈（Universal Inverted Bottleneck，UIB）搜索块，这是一种统一且灵活的结构，融合了倒置瓶颈（IB）、ConvNext、前馈网络（FFN）和一种新型的额外深度卷积（ExtraDW）变体。论文地址论文地址本文在YOLOv8中的主干网络替换成MobileNetV4，代码已经整理好了，跟着文章复制粘贴，即可直接运行。
MobileNetV4——移动生态系统的通用模型
AI浩
04-26 3070
论文链接：https://arxiv.org/pdf/2404.10518我们推出了最新一代的MobileNets，称为MobileNetV4（MNv4），其特点是为移动设备提供普遍高效的架构设计。在核心部分，我们引入了通用倒置瓶颈（UIB）搜索块，这是一种统一且灵活的结构，融合了倒置瓶颈（IB）、ConvNext、前馈网络（FFN）以及新型Extra Depthwise（ExtraDW）变体。
YOLOv8独家改进：backbone改进 | 轻量化之王MobileNetV4 开源 | Top-1 精度 87%，手机推理速度 3.8ms，原地起飞！
05-09 2501
轻量化之王MobileNetV4 开源 | Top-1 精度 87%，手机推理速度 3.8ms，原地起飞！
yolov8改进/更换mobilenetv4
cfk12的博客
08-16 1704
我真是服了这个网页的专栏精选，啥汤姆的都要米，看一个要米，再看一个也要米。我直接自己改，改完我分享一波。
YOLOv5主干网络改进之MobileNeXt
QvisCs的博客
09-20 214
MobileNeXt是由微软研究院提出的一种高效的卷积神经网络结构，它在保持模型轻量级的同时，能够获得较高的性能。为了进一步提升YOLOv5的性能，我们可以考虑将其主干网络替换为MobileNeXt，这是一种轻量级的计算机视觉网络。在本文中，我们将详细介绍使用MobileNeXt作为YOLOv5主干网络的改进方法，并提供相应的源代码。上述代码定义了MobileNeXt网络结构，其中InvertedResidualBlock是MobileNeXt的基本构建块，而MobileNeXt则是整个网络的定义。
YOLOv10改进 | 主干替换篇 | YOLOv10 更换主干Backbone之MobileNetV4(轻量化主干网络结构-2024年最新的移动端网络)
qq_45972324的博客
09-09 874
我们推出了最新一代的 MobileNet，称为 MobileNetV4 （MNv4），具有适用于移动设备的通用高效架构设计。我们的核心是引入了通用反向瓶颈 （UIB） 搜索块，这是一种统一且灵活的结构，它融合了反向瓶颈 （IB）、ConvNext、前馈网络 （FFN） 和新颖的 Extra Depthwise （ExtraDW） 变体。除了 UIB，我们还推出了 Mobile MQA，这是一个为移动加速器量身定制的注意力块，可提供 39% 的显著加速。
评论 41
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

kay_545

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

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

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

打赏作者

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

抵扣说明：

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

余额充值