MicroNet：一种轻量级神经网络架构

最新推荐文章于 2024-01-27 11:01:48 发布
最新推荐文章于 2024-01-27 11:01:48 发布
阅读量1.3k 收藏 10
点赞数 2
分类专栏： 机器学习 文章标签： 神经网络 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KPer_Yang/article/details/126561412
版权

MicroNet：一种轻量级神经网络架构

模型效果：

一个比mobilenet更轻量级的神经网络架构，效果：

在这里插入图片描述

模型架构：

代码架构如下，其实代码已经开源，模型架构就没有什么用了。直接看代码就一目了然。

在这里插入图片描述

代码实现：

引用自：liyunsheng13/micronet (github.com)


import torch
import torch.nn as nn
import torch.nn.functional as F

import backbone.activation as activation
import backbone.microconfig as microcfg


import math
import pdb

__all__ = ['MicroNet', 'micronet']

TAU = 20
#####################################################################3
# part 1: functions
#####################################################################3

def _make_divisible(v, divisor, min_value=None):
    """
    This function is taken from the original tf repo.
    It ensures that all layers have a channel number that is divisible by 8
    It can be seen here:
    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    :param v:
    :param divisor:
    :param min_value:
    :return:
    """
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6


class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

def conv_3x3_bn(inp, oup, stride, dilation=1):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 3, stride, 1, bias=False, dilation=dilation),
        nn.BatchNorm2d(oup),
        nn.ReLU6(inplace=True)
    )

def conv_1x1_bn(inp, oup):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
        nn.BatchNorm2d(oup),
        nn.ReLU6(inplace=True)
    )

def gcd(a, b):
    a, b = (a, b) if a >= b else (b, a)
    while b:
        a, b = b, a%b
    return a

#####################################################################3
# part 2: modules
#####################################################################3

class MaxGroupPooling(nn.Module):
    def __init__(self, channel_per_group=2):
        super(MaxGroupPooling, self).__init__()
        self.channel_per_group = channel_per_group

    def forward(self, x):
        if self.channel_per_group == 1:
            return x
        # max op
        b, c, h, w = x.size()

        # reshape
        y = x.view(b, c // self.channel_per_group, -1, h, w)
        out, _ = torch.max(y, dim=2)
        return out

class SwishLinear(nn.Module):
    def __init__(self, inp, oup):
        super(SwishLinear, self).__init__()
        self.linear = nn.Sequential(
            nn.Linear(inp, oup),
            nn.BatchNorm1d(oup),
            h_swish()
        )

    def forward(self, x):
        return self.linear(x)

class StemLayer(nn.Module):
    def __init__(self, inp, oup, stride, dilation=1, mode='default', groups=(4,4)):
        super(StemLayer, self).__init__()

        self.exp = 1 if mode == 'default' else 2
        g1, g2 = groups 
        if mode == 'default':
            self.stem = nn.Sequential(
                nn.Conv2d(inp, oup*self.exp, 3, stride, 1, bias=False, dilation=dilation),
                nn.BatchNorm2d(oup*self.exp),
                nn.ReLU6(inplace=True) if self.exp == 1 else MaxGroupPooling(self.exp)
            )
        elif mode == 'spatialsepsf':
            self.stem = nn.Sequential(
                SpatialSepConvSF(inp, groups, 3, stride),
                MaxGroupPooling(2) if g1*g2==2*oup else nn.ReLU6(inplace=True)
            )
        else: 
            raise ValueError('Undefined stem layer')
           
    def forward(self, x):
        out = self.stem(x)    
        return out

class GroupConv(nn.Module):
    def __init__(self, inp, oup, groups=2):
        super(GroupConv, self).__init__()
        self.inp = inp
        self.oup = oup
        self.groups = groups
        print ('inp: %d, oup:%d, g:%d' %(inp, oup, self.groups[0]))
        self.conv = nn.Sequential(
            nn.Conv2d(inp, oup, 1, 1, 0, bias=False, groups=self.groups[0]),
            nn.BatchNorm2d(oup)
        )

    def forward(self, x):
        x = self.conv(x)
        return x

class ChannelShuffle(nn.Module):
    def __init__(self, groups):
        super(ChannelShuffle, self).__init__()
        self.groups = groups

    def forward(self, x):
        b, c, h, w = x.size()

        channels_per_group = c // self.groups

        # reshape
        x = x.view(b, self.groups, channels_per_group, h, w)

        x = torch.transpose(x, 1, 2).contiguous()
        out = x.view(b, -1, h, w)

        return out

class ChannelShuffle2(nn.Module):
    def __init__(self, groups):
        super(ChannelShuffle2, self).__init__()
        self.groups = groups

    def forward(self, x):
        b, c, h, w = x.size()

        channels_per_group = c // self.groups

        # reshape
        x = x.view(b, self.groups, channels_per_group, h, w)

        x = torch.transpose(x, 1, 2).contiguous()
        out = x.view(b, -1, h, w)

        return out

######################################################################3
# part 3: new block
#####################################################################3

class SpatialSepConvSF(nn.Module):
    def __init__(self, inp, oups, kernel_size, stride):
        super(SpatialSepConvSF, self).__init__()

        oup1, oup2 = oups
        self.conv = nn.Sequential(
            nn.Conv2d(inp, oup1,
                (kernel_size, 1),
                (stride, 1),
                (kernel_size//2, 0),
                bias=False, groups=1
            ),
            nn.BatchNorm2d(oup1),
            nn.Conv2d(oup1, oup1*oup2,
                (1, kernel_size),
                (1, stride),
                (0, kernel_size//2),
                bias=False, groups=oup1
            ),
            nn.BatchNorm2d(oup1*oup2),
            ChannelShuffle(oup1),
        )

    def forward(self, x):
        out = self.conv(x)
        return out

class DepthConv(nn.Module):
    def __init__(self, inp, oup, kernel_size, stride):
        super(DepthConv, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(inp, oup, kernel_size, stride, kernel_size//2, bias=False, groups=inp),
            nn.BatchNorm2d(oup)
        )

    def forward(self, x):
        out = self.conv(x)
        return out

class DepthSpatialSepConv(nn.Module):
    def __init__(self, inp, expand, kernel_size, stride):
        super(DepthSpatialSepConv, self).__init__()

        exp1, exp2 = expand

        hidden_dim = inp*exp1
        oup = inp*exp1*exp2
        
        self.conv = nn.Sequential(
            nn.Conv2d(inp, inp*exp1, 
                (kernel_size, 1), 
                (stride, 1), 
                (kernel_size//2, 0), 
                bias=False, groups=inp
            ),
            nn.BatchNorm2d(inp*exp1),
            nn.Conv2d(hidden_dim, oup,
                (1, kernel_size),
                (1, stride),
                (0, kernel_size//2),
                bias=False, groups=hidden_dim
            ),
            nn.BatchNorm2d(oup)
        )

    def forward(self, x):
        out = self.conv(x)
        return out

def get_pointwise_conv(mode, inp, oup, hiddendim, groups):

    if mode == 'group':
        return GroupConv(inp, oup, groups)
    elif mode == '1x1':
        return nn.Sequential(
                    nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
                    nn.BatchNorm2d(oup)
                )
    else:
        return None
 
class DYMicroBlock(nn.Module):
    def __init__(self, inp, oup, kernel_size=3, stride=1, ch_exp=(2, 2), ch_per_group=4, groups_1x1=(1, 1), depthsep=True, shuffle=False, pointwise='fft', activation_cfg=None):
        super(DYMicroBlock, self).__init__()

        print(activation_cfg.dy)

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

        y1, y2, y3 = activation_cfg.dy
        act = activation_cfg.MODULE
        act_max = activation_cfg.ACT_MAX
        act_bias = activation_cfg.LINEARSE_BIAS
        act_reduction = activation_cfg.REDUCTION * activation_cfg.ratio
        init_a = activation_cfg.INIT_A
        init_b = activation_cfg.INIT_B
        init_ab3 = activation_cfg.INIT_A_BLOCK3

        t1 = ch_exp
        gs1 = ch_per_group
        hidden_fft, g1, g2 = groups_1x1

        hidden_dim1 = inp * t1[0]
        hidden_dim2 = inp * t1[0] * t1[1]

        if gs1[0] == 0:
            self.layers = nn.Sequential(
                DepthSpatialSepConv(inp, t1, kernel_size, stride),
                activation.get_act_layer(
                    hidden_dim2,
                    hidden_dim2,
                    mode=act,
                    act_max=act_max,
                    act_relu=True if y2 == 2 else False,
                    act_bias=act_bias,
                    init_a=init_a,
                    reduction=act_reduction,
                    init_b=init_b,
                    g = gs1,
                    expansion = False
                ) if y2 > 0 else nn.ReLU6(inplace=True),
                ChannelShuffle(gs1[1]) if shuffle else nn.Sequential(),
                ChannelShuffle2(hidden_dim2//2) if shuffle and y2 !=0 else nn.Sequential(),
                get_pointwise_conv(pointwise, hidden_dim2, oup, hidden_fft, (g1, g2)),
                activation.get_act_layer(
                    oup,
                    oup,
                    mode=act,
                    act_max=act_max,
                    act_relu=False,
                    act_bias=act_bias,
                    init_a=[init_ab3[0], 0.0],
                    reduction=act_reduction//2,
                    init_b=[init_ab3[1], 0.0],
                    g = (g1, g2),
                    expansion = False
                ) if y3 > 0 else nn.Sequential(),
                ChannelShuffle(g2) if shuffle else nn.Sequential(),
                ChannelShuffle2(oup//2) if shuffle and oup%2 == 0  and y3!=0 else nn.Sequential(),
            )
        elif g2 == 0:
            self.layers = nn.Sequential(
                get_pointwise_conv(pointwise, inp, hidden_dim2, hidden_dim1, gs1),
                activation.get_act_layer(
                    hidden_dim2,
                    hidden_dim2,
                    mode=act,
                    act_max=act_max,
                    act_relu=False,
                    act_bias=act_bias,
                    init_a=[init_ab3[0], 0.0],
                    reduction=act_reduction,
                    init_b=[init_ab3[1], 0.0],
                    g = gs1,
                    expansion = False
                ) if y3 > 0 else nn.Sequential(),

            )

        else:
            self.layers = nn.Sequential(
                get_pointwise_conv(pointwise, inp, hidden_dim2, hidden_dim1, gs1),
                activation.get_act_layer(
                    hidden_dim2,
                    hidden_dim2,
                    mode=act,
                    act_max=act_max,
                    act_relu=True if y1 == 2 else False,
                    act_bias=act_bias,
                    init_a=init_a,
                    reduction=act_reduction,
                    init_b=init_b,
                    g = gs1,
                    expansion = False
                ) if y1 > 0 else nn.ReLU6(inplace=True),
                ChannelShuffle(gs1[1]) if shuffle else nn.Sequential(),
                DepthSpatialSepConv(hidden_dim2, (1, 1), kernel_size, stride) if depthsep else
                DepthConv(hidden_dim2, hidden_dim2, kernel_size, stride),
                nn.Sequential(),
                activation.get_act_layer(
                    hidden_dim2,
                    hidden_dim2,
                    mode=act,
                    act_max=act_max,
                    act_relu=True if y2 == 2 else False,
                    act_bias=act_bias,
                    init_a=init_a,
                    reduction=act_reduction,
                    init_b=init_b,
                    g = gs1,
                    expansion = True
                ) if y2 > 0 else nn.ReLU6(inplace=True),
                ChannelShuffle2(hidden_dim2//4) if shuffle and y1!=0 and y2 !=0 else nn.Sequential() if y1==0 and y2==0 else ChannelShuffle2(hidden_dim2//2),
                get_pointwise_conv(pointwise, hidden_dim2, oup, hidden_fft, (g1, g2)), #FFTConv
                activation.get_act_layer(
                    oup,
                    oup,
                    mode=act,
                    act_max=act_max,
                    act_relu=False,
                    act_bias=act_bias,
                    init_a=[init_ab3[0], 0.0],
                    reduction=act_reduction//2 if oup < hidden_dim2 else act_reduction,
                    init_b=[init_ab3[1], 0.0],
                    g = (g1, g2),
                    expansion = False
                ) if y3 > 0 else nn.Sequential(),
                ChannelShuffle(g2) if shuffle else nn.Sequential(),
                ChannelShuffle2(oup//2) if shuffle and y3!=0 else nn.Sequential(),
            )

    def forward(self, x):
        identity = x
        out = self.layers(x)

        if self.identity:
            out = out + identity

        return out

###########################################################################

class MicroNet(nn.Module):
    def __init__(self, cfg, input_size=224, num_classes=1000, teacher=False):
        super(MicroNet, self).__init__()

        mode = cfg.MODEL.MICRONETS.NET_CONFIG
        self.cfgs = microcfg.get_micronet_config(mode)

        block = eval(cfg.MODEL.MICRONETS.BLOCK)
        stem_mode = cfg.MODEL.MICRONETS.STEM_MODE
        stem_ch = cfg.MODEL.MICRONETS.STEM_CH
        stem_dilation = cfg.MODEL.MICRONETS.STEM_DILATION
        stem_groups = cfg.MODEL.MICRONETS.STEM_GROUPS
        out_ch = cfg.MODEL.MICRONETS.OUT_CH
        depthsep = cfg.MODEL.MICRONETS.DEPTHSEP
        shuffle = cfg.MODEL.MICRONETS.SHUFFLE
        pointwise = cfg.MODEL.MICRONETS.POINTWISE
        dropout_rate = cfg.MODEL.MICRONETS.DROPOUT

        act_max = cfg.MODEL.ACTIVATION.ACT_MAX
        act_bias = cfg.MODEL.ACTIVATION.LINEARSE_BIAS
        activation_cfg= cfg.MODEL.ACTIVATION

        # building first layer
        assert input_size % 32 == 0
        input_channel = stem_ch
        layers = [StemLayer(
                    3, input_channel,
                    stride=2, 
                    dilation=stem_dilation, 
                    mode=stem_mode,
                    groups=stem_groups
                )]

        for idx, val in enumerate(self.cfgs):
            s, n, c, ks, c1, c2, g1, g2, c3, g3, g4, y1, y2, y3, r = val

            t1 = (c1, c2)
            gs1 = (g1, g2)
            gs2 = (c3, g3, g4)
            activation_cfg.dy = [y1, y2, y3]
            activation_cfg.ratio = r

            output_channel = c
            layers.append(block(input_channel, output_channel,
                kernel_size=ks, 
                stride=s, 
                ch_exp=t1, 
                ch_per_group=gs1, 
                groups_1x1=gs2,
                depthsep = depthsep,
                shuffle = shuffle,
                pointwise = pointwise,
                activation_cfg=activation_cfg,
            ))
            input_channel = output_channel
            for i in range(1, n):
                layers.append(block(input_channel, output_channel, 
                    kernel_size=ks, 
                    stride=1, 
                    ch_exp=t1, 
                    ch_per_group=gs1, 
                    groups_1x1=gs2,
                    depthsep = depthsep,
                    shuffle = shuffle,
                    pointwise = pointwise,
                    activation_cfg=activation_cfg,
                ))
                input_channel = output_channel
        self.features = nn.Sequential(*layers)


        self.avgpool = nn.Sequential(
            nn.ReLU6(inplace=True),
            nn.AdaptiveAvgPool2d((1, 1)),
            h_swish()
        ) 

        # building last several layers
        output_channel = out_ch
         
        self.classifier = nn.Sequential(
            SwishLinear(input_channel, output_channel),
            nn.Dropout(dropout_rate),
            SwishLinear(output_channel, num_classes)
        )
        self._initialize_weights()
           
    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)

        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                n = m.weight.size(1)
                m.weight.data.normal_(0, 0.01)
                if m.bias is not None:
                    m.bias.data.zero_()

def micronet(**kwargs):
    """
    Constructs a MicroNet model
    """
    return MicroNet(**kwargs)

参考：

[2108.05894] MicroNet: Improving Image Recognition with Extremely Low FLOPs (arxiv.org)

KPer_Yang
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
micronet:micronet，一个模型压缩和部署库。 压缩
05-11
micronet "目前在深度学习领域分类两个派别，一派为学院派，研究强大、复杂的模型网络和实验方法，为了追求更高的性能；另一派为工程派，旨在将算法更稳定、高效的落地在硬件平台上，效率是其追求的目标。复杂的模型固然具有更好的性能，但是高额的存储空间、计算资源消耗是使其难以有效的应用在各硬件平台上的重要原因。所以，深度神经网络日益增长的规模为深度学习在移动端的部署带来了巨大的挑战，深度学习模型压缩与部署成为了学术界和工业界都重点关注的研究领域之一" 项目简介 micronet, a model compression and deploy lib. 压缩 量化：High-Bit(>2b): QAT, PTQ, QAFT; Low-Bit(≤2b)/Ternary and Binary: QAT 剪枝：正常、规整、分组卷积结构剪枝 针对特征(A)二值量化的BN融合(训练量化后，BN参数 —>
轻量级神经网络架构综述,神经网络设计与实现
aifans_bert的博客
09-04 300
那里是隐私的储藏地点。他们不仅是可以识别计策的，还是具有分辨计策的能力的，因此必须留心别进入他们的世界，以免变得面目全非。而最后，输出层生成最终结果，每个输出单元会对应到某一种特定的分类，为网络送给外部系统的结果值，，整个网络由调整链接强度的程序来达成学习的目的。单元以层的方式组，每一层的每个神经元和前一层、后-层的神经元连接，共分为输入层、输出层和隐藏层，三层连接形成一-个神经网络。神经的联系来源于突触，但是这是复杂的，因此不要把他们变的简单化，因为这将把神经变的难以显现。他们没有真正的思考，而是计算。
深度学习论文: MicroNet: Improving Image Recognition with Extremely Low FLOPs及其PyTorch实现
mingo_敏
08-18 1173
深度学习论文: MicroNet: Improving Image Recognition with Extremely Low FLOPs及其PyTorch实现 MicroNet: Improving Image Recognition with Extremely Low FLOPs PDF: https://arxiv.org/pdf/2108.05894.pdf 1 概述 MicroNet的提出主要的遵循以下两个设计原则： 降低网络节点（神经元）之间的连通性而不降低网络的宽度 使用更复杂的非线性激
micronet，一个模型压缩和部署库。-Python开发
05-25
micronet, a model compression and deploy lib. compression: 1、quantization: quantization-aware-training(QAT), High-Bit(>2b)(DoReFa/Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference)、Low-Bit(≤2b)/Ternary and Binary(TWN/BNN/XNOR-Net); post-training-quantization(PTQ), 8-bit(tensorrt); micronet "目前在深度学习领域分类两个派别，一派为学院派，研究强大、复杂的模型网络和实验方法，为了追求更高的性能；另一派为工程派，旨在将算法更稳定、高效的落地在硬件平台上，效率是其追求的目标。复杂的模型固然具有更好的性能，但是高额的存储空间、计算资源消耗是使其难以有效的应用在各硬件平台上的重要原因。所以，深度神经网络日益增长的规模为深度学
轻量级网络MicroNet--低FLOPs的实现：卷积与激活函数的改进
panghuzhenbang的博客
05-18 968
论文地址： 《MicroNet: Towards Image Recognition with Extremely Low FLOPs》 亮点 卷积：稀疏连通性，避免了网络宽度的大幅度缩减； 激活函数：动态激活函数，减轻了网络深度缩减。 问题 这篇论文旨在以极低的计算成本解决性能大幅下降的问题，移动嵌入式设备通常具有较低的性能，因此要在边缘设备上部署深度学习模型，就要求网络模型具有较低计算量，但是低开销的网络通常性能表现不会很好。 高效CNN架构的最新进展成功地将ImageNet分类的计算成本
MicroNet实战：使用MicroNet实现图像分类
06-11
本文通过对植物幼苗分类的实际例子来感受一下MicroNet模型的效果。模型来自官方，我自己写了train和test部分。从得分情况来看，这个模型非常的优秀，我选择用的MicroNet-M3模型，大小仅有6M，但是ACC在95%左右，成绩...
neurips-micronet:[JMLR 2020] NeurIPS 2019 MicroNet挑战高效语言建模，冠军
05-08
MicroNet：MIT-HAN-Lab小组 消息 我们的工作已被PMLR接受！ ; 。 Hanrui和Zhongxia在温哥华NeurIPS 2019上发表了关于挑战的（始于26:17）。 介绍 该代码库提供了用于提交给PMLR的代码，配置和命令，以表示我们在上...
Epitech.MicroNet：适用于iOS和Android上Epitech内部网的.Net Xamarin客户端
02-06
Epitech MicroNet 美国东部时间的MicroNet联合国的iOS客户端Android版等德permettantaccéderà 。 C＃和其他语言的开发都采用了 （Monotouch基础）框架，并在此基础上添加了代码。 该代码利用Xamarin的抽象形式。...
MicronetToNMEA:Micronet到NMEA
03-20
MicronetToNMEA是一个Arduino项目，旨在将Raymarine无线网络“ Micronet”中的数据转换为我们的笔记本电脑和平板电脑软件易于使用的标准NMEA0183流。 该项目需要以下硬件： 装有Raymarine无线系统的船。 （不是严格...
【目标检测】|MicroNet
qq_35608277的博客
06-03 1403
低秩近似分解卷积以及超强激活函数 论文地址：https://arxiv.org/abs/2011.12289 论文提出应对极低计算量场景的轻量级网络MicroNet，包含两个核心思路Micro-Factorized convolution和Dynamic Shift-Max， 1.Design Principles 要想实现低FLOPs，主要是要限制网络宽度（通道数）和网络深度（网络层数）。 如果把一个卷积层抽象为一个图，那么该层输入和输出中间的连接边，可以用卷积核的参数量来衡量。 因此作者定义了卷积层连通
【量化学习3】Micronet代码学习
最新发布
Ashley_huo的专栏
01-27 500
浮点数和矩阵的量化已经学完，下面要考虑，在神经网络的操作：卷积、reRU、FC，量化究竟是如何执行的。参考Micronet代码，我们来看看。
【第42篇】MicroNet：以极低的 FLOP 实现图像识别
AI浩
06-09 855
在本文中，我们介绍了 MicroNet，它是一种高效的卷积神经网络，使用极低的计算成本（例如 ImageNet 分类上的 6 个 MFLOP）。这种低成本网络在边缘设备上是非常需要的，但通常会遭受显着的性能下降。我们基于两个设计原则处理极低的 FLOP：（a）通过降低节点连接性来避免网络宽度的减少，以及（b）通过在每层引入更复杂的非线性来补偿网络深度的减少。首先，我们提出微因子卷积将逐点和深度卷积分解为低秩矩阵，以便在通道数和输入/输出连接之间取得良好的折衷。其次，我们提出了一个名为 Dynamic Shi
MicroNet实战：使用MicroNet实现图像分类（一）
AI浩
06-10 2226
本文通过对植物幼苗分类的实际例子来感受一下MicroNet模型的效果。模型来自官方，我自己写了train和test部分。从得分情况来看，这个模型非常的优秀，我选择用的MicroNet-M3模型，大小仅有6M，但是ACC在95%左右，成绩非常惊艳！！！这篇文章从实战的角度手把手带领大家完成训练和测试。通过这篇文章能让你学到：使用pip就行，命令： 2、安装yacs yacs的作者大名鼎鼎的Ross Girshick，faster-rcnn的作者。github地址：https://github.com/rbg
加州大学与微软提出MicroNet，比MobileNetv3更小更快的网络
迈微AI研习社 · 号主
08-19 1008
今天跟大家分享的论文是MicroNet，它是一种高效的卷积神经网络具有极低的计算成本。在边缘设备上非常需要这样的低成本网络，但是通常会遭受明显的性能下降。
MicroNet实战：使用MicroNet实现图像分类（二）
AI浩
06-16 1194
本次训练采用的参数是M3的配置参数，详细的配置参数在utils/defaults.py文件，参数如下： 训练 完成上面的步骤后，就开始train脚本的编写，新建train.py. 设置全局参数 设置学习率、BatchSize、epoch等参数，判断环境中是否存在GPU，如果没有则使用CPU。建议使用GPU，CPU太慢了。 设置存放权重文件的文件夹，如果文件夹存在删除再建立。接下来，查看全局参数：数据处理比较简单，加入了Cutout、做了Resize和归一化，定义Mixup函数。这里注意下Resize的大小，
MicroNets：更小更快更好的MicroNet，三大CV任务都秒杀MobileNetV3
我爱计算机视觉
08-17 3388
关注公众号，发现CV技术之美▊写在前面本文旨在以极低的计算成本解决性能大幅下降的问题。作者发现有两个因素是可以有效提高精度的，分别是：稀疏连通性和动态激活函数。前者避免了网络宽度的大幅度...
MicroNet: Improving Image Recognition with Extremely Low FLOPs--Yunsheng Li
xu.hyj
09-15 1085
本文重点解决在极低FLOPs条件下设计准确率更高的网络，通过Micro-Factorized Convolution在保证节点连接性条件下减低计算量，通过Dynamic Shift-Max激活函数加强通道间的联系，改善非线性，以弥补网络不能太深所带来的缺陷。 通过实验看出MicroNet比MobileNetV3等轻量化网络不经拥有更低的FLOPs，而且在精度上的提升非常巨大。
MicroNet: 低秩近似分解卷积以及超强激活函数，碾压MobileNet | 2020新文分析
晓飞的算法工程笔记
04-11 2845
论文提出应对极低计算量场景的轻量级网络MicroNet，包含两个核心思路Micro-Factorized convolution和Dynamic Shift-Max，Micro-Factorized convolution通过低秩近似将原卷积分解成多个小卷积，保持输入输出的连接性并降低连接数，Dynamic Shift-Max通过动态的组间特征融合增加节点的连接以及提升非线性，弥补网络深度减少带来的性能降低。从实验结果来看，MicroNet的性能十分强劲   来源：晓飞的算法工程笔记 公众号 论文: M.
安装micronet遇到的问题及解决
TycoonL的博客
03-20 382
micronet是一个模型压缩和部署库，python3.7环境下安装micronet遇到的问题及解决
micronet实战 使用micronet实现图像分类
07-08
### 回答1： Micronet是一种轻量级神经网络架构，它专为移动和嵌入式设备设计，具有高效的计算和内存需求以及良好的图像分类性能。 使用Micronet实现图像分类，首先需要使用合适的数据集进行训练。选择适合应用场景的数据集，并标注好每张图像对应的类别标签。然后，根据网络结构设计合适的神经网络模型。 Micronet提供了一些常见的轻量级神经网络模型，如Micronet-A、Micronet-B等，可以根据实际需求选择合适的模型。接下来，使用选定的Micronet模型搭建神经网络，并加载已标注好的数据集。通过对数据集进行训练，神经网络模型将逐渐学习到图像分类的特征。 训练过程中，可以使用一些优化算法进行网络参数的更新，如随机梯度下降（SGD）等。同时，可以使用一些数据增强技术增加数据集的多样性，提升模型的泛化能力。 训练完成后，可以使用测试数据集对模型进行评估，计算准确率、精确率、召回率等指标来评估模型的性能表现。 最后，将训练好的模型部署到实际应用中，输入待分类的图像数据，通过进行前向推理，即向前传播图像的特征，最终得到图像的分类结果。 总之，使用Micronet实战图像分类，需要进行模型选择、数据集准备、模型训练、模型评估和模型部署等步骤。通过合理选择模型和适当的数据处理方法，可以实现高效准确的图像分类任务。 ### 回答2： Micronet是一种轻量级的神经网络架构，它在计算和参数数量上具有出色的效率。使用Micronet实战，我们可以实现图像分类任务。 首先，我们需要准备一个标记好的图像分类数据集，例如包含多个类别的图像样本集合。然后，我们可以使用Python编程语言和深度学习框架如TensorFlow或PyTorch来构建Micronet模型。 在构建Micronet模型的过程中，我们可以使用一些轻量级的神经网络层，例如深度可分离卷积、批标准化和全局平均池化等操作。这些层的组合可以实现较少的计算和参数数量，并在保持良好性能的同时大大减少模型大小和计算成本。 当模型构建完成后，我们可以开始训练。在训练过程中，我们可以使用编程框架提供的优化算法，如随机梯度下降（SGD）或Adam，来调整模型参数以最小化损失函数。同时，我们还可以使用数据增强技术来扩充训练数据集，如随机裁剪、水平翻转和旋转等，以提高模型的鲁棒性和泛化能力。 训练完成后，我们可以使用测试集来评估模型的性能。通常可以使用准确率、精确率、召回率和F1分数等指标来评估模型的分类效果。 总结来说，使用Micronet实战实现图像分类涉及数据集准备、模型构建、训练和评估等步骤。通过构建轻量级、高效的神经网络模型，我们可以在保持较高分类性能的同时减少模型的计算和参数数量，进而在资源受限的环境下提供可行的解决方案。 ### 回答3： Micronet是一个用于轻量级图像分类任务的模型开发工具。在实际使用中，可以按照以下步骤使用Micronet实现图像分类。 首先，我们需要收集并准备训练数据集。一个好的数据集是成功进行图像分类任务的基础，所以我们需要确保数据集包含不同类别的图像样本，并且每个图像都有正确的标签。 接下来，我们可以使用Micronet提供的一些预训练模型作为基本模型，也可以根据任务需求自定义一个新的模型。预训练模型可以通过模型的名称或者选择一个预定义的模型结构进行加载。 然后，我们可以使用Micronet提供的API来编写代码，定义我们的模型架构。我们可以使用不同的层来构建我们的模型，包括卷积、池化和全连接层。 接着，我们需要将数据集加载到我们的代码中，并进行数据预处理。数据预处理可以包括图像增强、数据标准化等操作，以提高模型的准确度和鲁棒性。 在训练之前，我们需要定义损失函数和优化器。我们可以选择适合图像分类任务的损失函数，如交叉熵损失函数，并选择适合我们的模型和数据集的优化器，如随机梯度下降法（SGD）。 然后，我们可以通过训练我们的模型来优化模型参数。训练可以由多个epoch组成，每个epoch中，我们将训练集分批次输入到模型中，并根据定义的损失函数和优化器对模型进行更新。 最后，我们可以在测试集上评估我们的模型的性能。我们可以使用准确率、精确率、召回率等指标来评估模型对图像分类任务的表现。 通过以上步骤，我们可以使用Micronet实现图像分类任务。通过不断优化我们的模型和数据集，我们可以提高模型的准确度和鲁棒性，从而实现更好地图像分类结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

KPer_Yang

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

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

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

打赏作者

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

抵扣说明：

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

余额充值