AI 助理
备案控制台
开发者社区 人工智能 文章 正文

轻量级网络——MobileNetV3

2022-11-12 548
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 轻量级网络——MobileNetV3

1.MobilenetV3的介绍

回顾MobilenetV1与MobilenetV2结构


  • MobilenetV1：

引入了深度可分离卷积作为传统卷积层的有效替代，大大减少计算量。深度可分离卷积通过将空间滤波与特征生成机制分离，有效地分解了传统卷积。深度可分离卷积由两个单独的层定义：用于空间滤波的轻量深度卷积和用于特征生成的较重的1x1卷积。


  • MobilenetV2：

引入线性瓶颈和倒置残差结构，以便通过利用问题的低秩性质来提高层结构的效率。


1.Linear Bottlenecks

Bottlenecks的最后把ReLU函数替换为Linear 线性函数，以防止ReLU破坏特征。


2.Inverted residuals

Bottlenecks 采用与resnet相反的设计方式，先扩张 -> 提取特征 -> 压缩。

image.png


  • MnasNet

建立在MobileNetV2结构上，通过在瓶颈结构中引入基于挤压和激励的轻量级注意模块。注意，与[18]中提出的基于ResNet的模块相比，挤压和激励模块集成在不同的位置。模块位于展开中的深度过滤器之后，以便注意应用于最大的表示。


MobilenetV3的亮点：


  • 更新了Block（bneck），加入了SE模块（squeeze and excitation）
  • 更新了激活函数，使用h-swish函数

MobilenetV3使用以上三种的不同层的组合作为构建块，以构建最有效的模型。图层也通过修改的swish非线性激活函数进行了升级。squeeze and excitation结构以及swish非线性函数都使用sigmoid，这对于定点算术的计算效率低下又难以维持精度，因此我们将其替换为hard sigmimage.pngoid。


现在其综合了以下四个特点：


  1. MobileNetV1的深度可分离卷积（depthwise separable convolutions）。
  2. MobileNetV2的具有线性瓶颈的逆残差结构(the inverted residual with linear bottleneck)。
  3. 轻量级的注意力模型。
  4. 利用h-swish代替swish函数。


2.MobilenetV3的结构

网络结构的主要改变

在网络的开头和结尾重新设计了计算昂贵的层。 引入了新的非线性h-swish，这是最近的swish非线性的改进版本，它计算速度更快，对量化更友好。


通过架构搜索找到模型后，我们会发现某些最后一层以及一些较早的层比其他层更昂贵。 我们建议对体系结构进行一些修改，以减少这些慢层的等待时间，同时保持准确性。 这些修改超出了当前搜索空间的范围。


1）尾部结构改变

当前基于MobileNetV2的倒置瓶颈结构和变体的模型使用1x1卷积作为最后一层，以便扩展到更高维度的特征空间。为了具有丰富的预测特征，这一层至关重要。 但是，这要付出额外的计算和延时。为了在保留高维特征的前提下减小延时，将平均池化前的层移除并用1*1卷积来计算特征图。特征生成层被移除后，先前用于瓶颈映射的层也不再需要了，这将为减少7ms的开销，在提速11%的同时减小了30m的操作数。

image.png


2）头部channel数量改变

当前的MobilenetV2开始使用32个 3 * 3的滤波器，作者发现使用h-swish激活函数相比于使用sigmoid和swish函数，可以在保持精度不减的情况下，将channel降低到16个，并且提速2ms。

给出MobilenetV2和MobilenetV3的结构如下，重点关注前面的通道数 32/16。


MobilenetV2

image.png

MoblenetV3-small

image.png


3）h-swish激活函数

swish非线性激活函数作为ReLU的替代，可以可以显着提高神经网络的准确性，其定义如下：

image.png

尽管这种非线性提高了准确性，但在嵌入式环境中却带来了非零成本，因为S型函数在移动设备上的计算成本更高。主要是计算、求导复杂，

对量化过程不友好。


改进的h-swish函数如下：

image.png


4）加入了注意力机制（SE模块）

image.png

主要的操作是针对输出的特征矩阵的每一个channel进行池化处理，所得到的向量个数就是channel的个数。然后再通过两个全连接层，得到我们输出的向量。其中，第一个全连接层的向量个数是channel个数的四分之一，然后第二个全连接层的输出与channel个数相同。而且，这两个全连接的所使用的的激活函数是不一样的。前一个使用的ReLu激活函数，后一个使用h-swish激活函数。


所得到的的这个向量可以理解为对刚刚输入的每一个channel分析出了一个权重关系。也就是如果他觉得比较重要的channel就会赋予一个比较大的权重，而如果是没有那么重要的channel就会赋予一个比较小的权重。


过程可以用下图来理解

image.png


3.MobilenetV3的性能统计

更准确，更高效，参数量更少，实时性更高

image.png

准确度也更高

image.png

模型的大小，可以看见MobileNetV3_Small版本要远比v1，v2的要小，但是准确度同样的会下降一点。

image.png


4.MobilenetV3的pytorch实现

给出了MobilenetV3-large 和MobilenetV3-small两个版本，分别针对高资源用例和低资源用例,结构如下图：


MobilenetV3-large

image.png

MobilenetV3-small

image.png

分析：

  • 第一列Input代表mobilenetV3每个特征层的shape变化；
  • 第二列Operator代表每次特征层即将经历的block结构，我们可以看到在MobileNetV3中，特征提取经过了许多的bneck结构；
  • 第三、四列分别代表了bneck内逆残差结构上升后的通道数、输入到bneck时特征层的通道数。
  • 第五列SE代表了是否在这一层引入注意力机制。
  • 第六列NL代表了激活函数的种类，HS代表h-swish，RE代表RELU。
  • 第七列s代表了每一次block结构所用的步长。


参考代码：


import torch
import torch.nn as nn
import torchvision
num_class = 5
# 定义h-swith激活函数
class HardSwish(nn.Module):
    def __init__(self, inplace=True):
        super(HardSwish, self).__init__()
        self.relu6 = nn.ReLU6(inplace)
    def forward(self, x):
        return x*self.relu6(x+3)/6
# DW卷积
def ConvBNActivation(in_channels,out_channels,kernel_size,stride,activate):
    # 通过设置padding达到当stride=2时，hw减半的效果。此时不与kernel_size有关，所实现的公式为: padding=(kernel_size-1)//2
    # 当kernel_size=3,padding=1时: stride=2 hw减半, stride=1 hw不变
    # 当kernel_size=5,padding=2时: stride=2 hw减半, stride=1 hw不变
    # 从而达到了使用 stride 来控制hw的效果， 不用去关心kernel_size的大小，控制单一变量
    return nn.Sequential(
            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, groups=in_channels),
            nn.BatchNorm2d(out_channels),
            nn.ReLU6(inplace=True) if activate == 'relu' else HardSwish()
        )
# PW卷积(接全连接层)
def Conv1x1BN(in_channels,out_channels):
    return nn.Sequential(
            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1),
            nn.BatchNorm2d(out_channels)
        )
# 普通的1x1卷积
def Conv1x1BNActivation(in_channels,out_channels,activate):
    return nn.Sequential(
            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU6(inplace=True) if activate == 'relu' else HardSwish()
        )
# 注意力机制(SE模块)
class SqueezeAndExcite(nn.Module):
    def __init__(self, in_channels, out_channels, se_kernel_size, divide=4):
        super(SqueezeAndExcite, self).__init__()
        mid_channels = in_channels // divide   # 维度变为原来的1/4
        # 将当前的channel平均池化成1
        self.pool = nn.AvgPool2d(kernel_size=se_kernel_size,stride=1)
        # 两个全连接层 最后输出每层channel的权值
        self.SEblock = nn.Sequential(
            nn.Linear(in_features=in_channels, out_features=mid_channels),
            nn.ReLU6(inplace=True),
            nn.Linear(in_features=mid_channels, out_features=out_channels),
            HardSwish(inplace=True),
        )
    def forward(self, x):
        b, c, h, w = x.size()
        out = self.pool(x)       # 不管当前的 h,w 为多少, 全部池化为1
        out = out.view(b, -1)    # 打平处理，与全连接层相连
        # 获取注意力机制后的权重
        out = self.SEblock(out)
        # out是每层channel的权重，需要扩维才能与原特征矩阵相乘
        out = out.view(b, c, 1, 1)  # 增维
        return out * x
class SEInvertedBottleneck(nn.Module):
    def __init__(self, in_channels, mid_channels, out_channels, kernel_size, stride, activate, use_se, se_kernel_size=1):
        super(SEInvertedBottleneck, self).__init__()
        self.stride = stride
        self.use_se = use_se
        self.in_channels = in_channels
        self.out_channels = out_channels
        # mid_channels = (in_channels * expansion_factor)
        # 普通1x1卷积升维操作
        self.conv = Conv1x1BNActivation(in_channels, mid_channels,activate)
        # DW卷积 维度不变，但可通过stride改变尺寸 groups=in_channels
        self.depth_conv = ConvBNActivation(mid_channels, mid_channels, kernel_size,stride,activate)
        # 注意力机制的使用判断
        if self.use_se:
            self.SEblock = SqueezeAndExcite(mid_channels, mid_channels, se_kernel_size)
        # PW卷积 降维操作
        self.point_conv = Conv1x1BNActivation(mid_channels, out_channels,activate)
        # shortcut的使用判断
        if self.stride == 1:
            self.shortcut = Conv1x1BN(in_channels, out_channels)
    def forward(self, x):
        # DW卷积
        out = self.depth_conv(self.conv(x))
        # 当 use_se=True 时使用注意力机制
        if self.use_se:
            out = self.SEblock(out)
        # PW卷积
        out = self.point_conv(out)
        # 残差操作
        # 第一种: 只看步长，步长相同shape不一样的输入输出使用1x1卷积使其相加
        # out = (out + self.shortcut(x)) if self.stride == 1 else out
        # 第二种: 同时满足步长与输入输出的channel, 不使用1x1卷积强行升维
        out = (out + x) if self.stride == 1 and self.in_channels == self.out_channels else out
        return out
class MobileNetV3(nn.Module):
    def __init__(self, num_classes=num_class, type='large'):
        super(MobileNetV3, self).__init__()
        self.type = type
        # 224x224x3 conv2d 3 -> 16 SE=False HS s=2
        self.first_conv = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(16),
            HardSwish(inplace=True),
        )
        # torch.Size([1, 16, 112, 112])
        # MobileNetV3_Large 网络结构
        if type=='large':
            self.large_bottleneck = nn.Sequential(
                # torch.Size([1, 16, 112, 112]) 16 -> 16 -> 16 SE=False RE s=1
                SEInvertedBottleneck(in_channels=16, mid_channels=16, out_channels=16, kernel_size=3, stride=1,activate='relu', use_se=False),
                # torch.Size([1, 16, 112, 112]) 16 -> 64 -> 24 SE=False RE s=2
                SEInvertedBottleneck(in_channels=16, mid_channels=64, out_channels=24, kernel_size=3, stride=2, activate='relu', use_se=False),
                # torch.Size([1, 24, 56, 56])   24 -> 72 -> 24 SE=False RE s=1
                SEInvertedBottleneck(in_channels=24, mid_channels=72, out_channels=24, kernel_size=3, stride=1, activate='relu', use_se=False),
                # torch.Size([1, 24, 56, 56])   24 -> 72 -> 40 SE=True RE s=2
                SEInvertedBottleneck(in_channels=24, mid_channels=72, out_channels=40, kernel_size=5, stride=2,activate='relu', use_se=True, se_kernel_size=28),
                # torch.Size([1, 40, 28, 28])   40 -> 120 -> 40 SE=True RE s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=120, out_channels=40, kernel_size=5, stride=1,activate='relu', use_se=True, se_kernel_size=28),
                # torch.Size([1, 40, 28, 28])   40 -> 120 -> 40 SE=True RE s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=120, out_channels=40, kernel_size=5, stride=1,activate='relu', use_se=True, se_kernel_size=28),
                # torch.Size([1, 40, 28, 28])   40 -> 240 -> 80 SE=False HS s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=240, out_channels=80, kernel_size=3, stride=1,activate='hswish', use_se=False),
                # torch.Size([1, 80, 28, 28])   80 -> 200 -> 80 SE=False HS s=1
                SEInvertedBottleneck(in_channels=80, mid_channels=200, out_channels=80, kernel_size=3, stride=1,activate='hswish', use_se=False),
                # torch.Size([1, 80, 28, 28])   80 -> 184 -> 80 SE=False HS s=2
                SEInvertedBottleneck(in_channels=80, mid_channels=184, out_channels=80, kernel_size=3, stride=2,activate='hswish', use_se=False),
                # torch.Size([1, 80, 14, 14])   80 -> 184 -> 80 SE=False HS s=1
                SEInvertedBottleneck(in_channels=80, mid_channels=184, out_channels=80, kernel_size=3, stride=1,activate='hswish', use_se=False),
                # torch.Size([1, 80, 14, 14])   80 -> 480 -> 112 SE=True HS s=1
                SEInvertedBottleneck(in_channels=80, mid_channels=480, out_channels=112, kernel_size=3, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 112, 14, 14])  112 -> 672 -> 112 SE=True HS s=1
                SEInvertedBottleneck(in_channels=112, mid_channels=672, out_channels=112, kernel_size=3, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 112, 14, 14])  112 -> 672 -> 160 SE=True HS s=2
                SEInvertedBottleneck(in_channels=112, mid_channels=672, out_channels=160, kernel_size=5, stride=2,activate='hswish', use_se=True,se_kernel_size=7),
                # torch.Size([1, 160, 7, 7])    160 -> 960 -> 160 SE=True HS s=1
                SEInvertedBottleneck(in_channels=160, mid_channels=960, out_channels=160, kernel_size=5, stride=1,activate='hswish', use_se=True,se_kernel_size=7),
                # torch.Size([1, 160, 7, 7])    160 -> 960 -> 160 SE=True HS s=1
                SEInvertedBottleneck(in_channels=160, mid_channels=960, out_channels=160, kernel_size=5, stride=1,activate='hswish', use_se=True,se_kernel_size=7),
            )
            # torch.Size([1, 160, 7, 7])
            # 相比MobileNetV2，尾部结构改变，,变得更加的高效
            self.large_last_stage = nn.Sequential(
                nn.Conv2d(in_channels=160, out_channels=960, kernel_size=1, stride=1),
                nn.BatchNorm2d(960),
                HardSwish(inplace=True),
                nn.AvgPool2d(kernel_size=7, stride=1),
                nn.Conv2d(in_channels=960, out_channels=1280, kernel_size=1, stride=1),
                HardSwish(inplace=True),
            )
        # MobileNetV3_Small 网络结构
        if type=='small':
            self.small_bottleneck = nn.Sequential(
                # torch.Size([1, 16, 112, 112]) 16 -> 16 -> 16 SE=False RE s=2
                SEInvertedBottleneck(in_channels=16, mid_channels=16, out_channels=16, kernel_size=3, stride=2,activate='relu', use_se=True, se_kernel_size=56),
                # torch.Size([1, 16, 56, 56])   16 -> 72 -> 24 SE=False RE s=2
                SEInvertedBottleneck(in_channels=16, mid_channels=72, out_channels=24, kernel_size=3, stride=2,activate='relu', use_se=False),
                # torch.Size([1, 24, 28, 28])   24 -> 88 -> 24 SE=False RE s=1
                SEInvertedBottleneck(in_channels=24, mid_channels=88, out_channels=24, kernel_size=3, stride=1,activate='relu', use_se=False),
                # torch.Size([1, 24, 28, 28])   24 -> 96 -> 40 SE=True RE s=2
                SEInvertedBottleneck(in_channels=24, mid_channels=96, out_channels=40, kernel_size=5, stride=2,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 40, 14, 14])   40 -> 240 -> 40 SE=True RE s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=240, out_channels=40, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 40, 14, 14])   40 -> 240 -> 40 SE=True RE s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=240, out_channels=40, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 40, 14, 14])   40 -> 120 -> 48 SE=True RE s=1
                SEInvertedBottleneck(in_channels=40, mid_channels=120, out_channels=48, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 48, 14, 14])   48 -> 144 -> 48 SE=True RE s=1
                SEInvertedBottleneck(in_channels=48, mid_channels=144, out_channels=48, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=14),
                # torch.Size([1, 48, 14, 14])   48 -> 288 -> 96 SE=True RE s=2
                SEInvertedBottleneck(in_channels=48, mid_channels=288, out_channels=96, kernel_size=5, stride=2,activate='hswish', use_se=True, se_kernel_size=7),
                # torch.Size([1, 96, 7, 7])     96 -> 576 -> 96 SE=True RE s=1
                SEInvertedBottleneck(in_channels=96, mid_channels=576, out_channels=96, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=7),
                # torch.Size([1, 96, 7, 7])     96 -> 576 -> 96 SE=True RE s=1
                SEInvertedBottleneck(in_channels=96, mid_channels=576, out_channels=96, kernel_size=5, stride=1,activate='hswish', use_se=True, se_kernel_size=7),
            )
            # torch.Size([1, 96, 7, 7])
            # 相比MobileNetV2，尾部结构改变，,变得更加的高效
            self.small_last_stage = nn.Sequential(
                nn.Conv2d(in_channels=96, out_channels=576, kernel_size=1, stride=1),
                nn.BatchNorm2d(576),
                HardSwish(inplace=True),
                nn.AvgPool2d(kernel_size=7, stride=1),
                nn.Conv2d(in_channels=576, out_channels=1280, kernel_size=1, stride=1),
                HardSwish(inplace=True),
            )
        self.classifier = nn.Linear(in_features=1280,out_features=num_classes)
        self.init_params()
    # 初始化权重
    def init_params(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.Linear):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
    def forward(self, x):
        x = self.first_conv(x)      # torch.Size([1, 16, 112, 112])
        if self.type == 'large':
            x = self.large_bottleneck(x)    # torch.Size([1, 160, 7, 7])
            x = self.large_last_stage(x)    # torch.Size([1, 1280, 1, 1])
        if self.type == 'small':
            x = self.small_bottleneck(x)    # torch.Size([1, 96, 7, 7])
            x = self.small_last_stage(x)  # torch.Size([1, 1280, 1, 1])
        x = x.view(x.size(0), -1)   # torch.Size([1, 1280])
        x = self.classifier(x)      # torch.Size([1, 5])
        return x
if __name__ == '__main__':
    # model = MobileNetV3(type='small')
    model = MobileNetV3(type='large')
    # print(model)
    input = torch.randn(1, 3, 224, 224)
    out = model(input)
    print(out.shape)
    torch.save(model.state_dict(), 'MobileNetV3_Large.mdl')


参考：

https://blog.csdn.net/c2250645962/article/details/105434036

https://blog.csdn.net/weixin_44791964/article/details/104068321


文章标签：
测试技术
机器学习/深度学习
算法框架/工具
PyTorch
关键词：
轻量级网络
网络轻量级
网络mobilenetv3
clichong
目录
相关文章
Snu77
|
5月前
|
机器学习/深度学习
YOLOv5改进 | 主干篇 | 轻量级网络ShuffleNetV1（附代码+修改教程）
YOLOv5改进 | 主干篇 | 轻量级网络ShuffleNetV1（附代码+修改教程）
Snu77
124 1
YOLO创新改进大师
|
5月前
|
机器学习/深度学习 计算机视觉 知识图谱
【YOLOv8改进】MobileViT 更换主干网络： 轻量级、通用且适合移动设备的视觉变压器 (论文笔记+引入代码)
MobileViT是针对移动设备的轻量级视觉Transformer网络，结合CNN的局部特征、Transformer的全局注意力和ViT的表示学习。在ImageNet-1k上，它以600万参数实现78.4%的top-1准确率，超越MobileNetv3和DeiT。MobileViT不仅适用于图像分类，还在目标检测等任务中表现出色，且优化简单，代码已开源。YOLOv8引入了MobileViT块，整合卷积和Transformer结构，提升模型性能。更多详情可参考相关专栏和链接。
YOLO创新改进大师
274 1
vohelon
|
2月前
|
数据采集 资源调度 JavaScript
Node.js 适合做高并发、I/O密集型项目、轻量级实时应用、前端构建工具、命令行工具以及网络爬虫和数据处理等项目
【8月更文挑战第4天】Node.js 适合做高并发、I/O密集型项目、轻量级实时应用、前端构建工具、命令行工具以及网络爬虫和数据处理等项目
vohelon
38 5
YOLO创新改进大师
|
3月前
|
机器学习/深度学习 计算机视觉 网络架构
【YOLOv8改进- Backbone主干】YOLOv8 更换主干网络之 PP-LCNet，轻量级CPU卷积神经网络，降低参数量
YOLO目标检测专栏介绍了PP-LCNet，一种基于MKLDNN加速的轻量级CPU网络，提升了模型在多任务中的性能。PP-LCNet利用H-Swish、大核卷积、SE模块和全局平均池化后的全连接层，实现低延迟下的高准确性。代码和预训练模型可在PaddlePaddle的PaddleClas找到。文章提供了网络结构、核心代码及性能提升的详细信息。更多实战案例和YOLO改进见相关链接。
YOLO创新改进大师
63 2
Snu77
|
5月前
|
机器学习/深度学习 测试技术 Ruby
YOLOv5改进 | 主干篇 | 反向残差块网络EMO一种轻量级的CNN架构（附完整代码 + 修改教程）
YOLOv5改进 | 主干篇 | 反向残差块网络EMO一种轻量级的CNN架构（附完整代码 + 修改教程）
Snu77
235 2
YOLO创新改进大师
|
4月前
|
机器学习/深度学习 计算机视觉 网络架构
【YOLOv8改进-卷积Conv】DualConv( Dual Convolutional)：用于轻量级深度神经网络的双卷积核
**摘要：** 我们提出DualConv，一种融合$3\times3$和$1\times1$卷积的轻量级DNN技术，适用于资源有限的系统。它通过组卷积结合两种卷积核，减少计算和参数量，同时增强准确性。在MobileNetV2上，参数减少54%，CIFAR-100精度仅降0.68%。在YOLOv3中，DualConv提升检测速度并增4.4%的PASCAL VOC准确性。论文及代码已开源。
YOLO创新改进大师
133 4
YOLO创新改进大师
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【YOLOv8改进 - 注意力机制】SimAM：轻量级注意力机制，解锁卷积神经网络新潜力
YOLO目标检测专栏介绍了SimAM，一种无参数的CNN注意力模块，基于神经科学理论优化能量函数，提升模型表现。SimAM通过计算3D注意力权重增强特征表示，无需额外参数。文章提供论文链接、Pytorch实现代码及详细配置，展示了如何在目标检测任务中应用该模块。
YOLO创新改进大师
274 1
长发和小虎牙
|
5月前
|
机器学习/深度学习 编解码 算法
YOLOv5改进 | 主干网络 | 将backbone替换为MobileNetV3【小白必备教程+附完整代码】
本文介绍了将YOLOv5的backbone替换为MobileNetV3以提升目标检测性能的教程。MobileNetV3采用倒残差结构、Squeeze-and-Excitation模块和Hard-Swish激活函数，实现更高性能和更低计算成本。文中提供了详细的代码实现，包括MobileNetV3的关键组件和YOLOv5的配置修改，便于读者实践。此外，还分享了完整代码链接和进一步的进阶策略，适合深度学习初学者和进阶者学习YOLO系列。
长发和小虎牙
416 7
小殊小殊
|
5月前
|
算法框架/工具
使用MobileNetV3的PSPNet网络结构
使用MobileNetV3的PSPNet网络结构
小殊小殊
33 1
我菜就爱学
|
5月前
|
机器学习/深度学习 算法 计算机视觉
【CVPR轻量级网络】- 追求更高的FLOPS(FasterNet)
【CVPR轻量级网络】- 追求更高的FLOPS(FasterNet)
我菜就爱学
248 2

热门文章

最新文章

  • 1
    揭秘2017双11背后的网络－双11的网络产品和技术概览
  • 2
    Haproxy的负载均衡、动静分离、状态监控、近期网络架构
  • 3
    Socket网络编程初探
  • 4
    网络钓鱼很“任性” 用户屡屡中招却为何
  • 5
    Akamai最新网络安全报告：DDoS攻击同比增125%
  • 6
    Machine Learning机器学习之贝叶斯网络(BayesianNetwork)
  • 7
    Docker网络、端口映射详解篇（三）
  • 8
    linux网络编程-----实现并发访问网站------
  • 9
    tcp wrapper网络服务的搭建和配置
  • 10
    Swift语言IOS8开发战记25 网络通信Get和Post方式
  • 1
    基于深度学习网络的鞋子种类识别matlab仿真
    475
  • 2
    【C 言专栏】C 语言实现网络通信程序
    156
  • 3
    【AI 生成式】生成对抗网络 （GAN） 的概念
    85
  • 4
    【AI 场景】如何应用人工智能来增强企业网络的网络安全？
    99
  • 5
    智能化运维：AIOps在未来网络管理中的应用与挑战
    274
  • 6
    网络安全与信息安全：防御前线的技术与意识
    38
  • 7
    BiTCN：基于卷积网络的多元时间序列预测
    205
  • 8
    网络防御前线：洞悉网络安全漏洞与加固信息防线
    66
  • 9
    网络防御的三重奏：漏洞管理、加密技术与安全意识提升
    44
  • 10
    网络安全与信息安全：防御前线的技术与意识
    45

    • 相关课程

    更多
  • TCP/IP 网络基础
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》

    • 相关电子书

    更多
  • Keynote：阿里云网络领域关键创新技术解读
  • 智慧光网络 关键技术应用实践和未来演进
  • 思科软件定义访问：实现基于业务意图的园区网络

    • 相关实验场景

    更多
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
  • 使用阿里云容器服务和容器网络文件系统搭建WordPress网站
    • 下一篇
    无影云桌面