python神经网络ShuffleNetV2模型复现详解

2024-04-02 19:04:59 728人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录什么是ShuffleNetV2ShuffleNetV21、所用模块2、网络整体结构网络实现代码什么是ShuffleNetV2 据说ShuffleNetV2比Mobilenet还要

什么是ShuffleNetV2

据说ShuffleNetV2比Mobilenet还要厉害，我决定好好学一下

这篇是ECCV2018关于轻量级模型的文章。

目前大部分的轻量级模型在对比模型速度时用的指标是FLOPs，这个指标主要衡量的就是卷积层的乘法操作。

但是实际运用中会发现，同一个FLOPS的网络运算速度却不同，只用FLOPS去进行衡量的话并不能完全代表模型速度。

通过如下图所示对比，作者发现Elemwise/Data io等内存读写密集型操作也会极大的影响模型运算速度。

结合理论与实验作者提出了4条实用的指导原则：

1、卷积层的输入和输出特征通道数相等时Mac最小，此时模型速度最快。

2、过量使用组卷积会增加MAC。

3、网络碎片化会降低并行度。

4、不能忽略元素级操作，比如ReLU和Add，虽然它们的FLOPs较小，但是却需要较大的MAC。

ShuffleNetV2

1、所用模块

如图所示是ShuffleNetV2所常用的两个模块：

1、当Stride==1的时候，采用左边的模块，由于残差边没有卷积，因此宽高不变，主要用于加深网络层数。

2、当Stride==2的时候，采用右边的模块，由于残差边有卷积，因此宽高可变，主要用于压缩特征层的宽高，进行下采样。

模块实现代码如下：

def channel_split(x, name=''):
    # 输入进来的通道数
    in_channles = x.shape.as_list()[-1]
    ip = in_channles // 2
    # 对通道数进行分割
    c_hat = Lambda(lambda z: z[:, :, :, 0:ip], name='%s/sp%d_slice' % (name, 0))(x)
    c = Lambda(lambda z: z[:, :, :, ip:], name='%s/sp%d_slice' % (name, 1))(x)
    return c_hat, c
def channel_shuffle(x):
    height, width, channels = x.shape.as_list()[1:]
    channels_per_split = channels // 2
    # 通道交换
    x = K.reshape(x, [-1, height, width, 2, channels_per_split])
    x = K.permute_dimensions(x, (0,1,2,4,3))
    x = K.reshape(x, [-1, height, width, channels])
    return x
def shuffle_unit(inputs, out_channels, bottleneck_ratio, strides=2, stage=1, block=1):
    bn_axis = -1
    prefix = 'stage{}/block{}'.fORMat(stage, block)
    # [116, 232, 464]
    bottleneck_channels = int(out_channels * bottleneck_ratio/2)
    if strides < 2:
        c_hat, c = channel_split(inputs, '{}/spl'.format(prefix))
        inputs = c
    # [116, 232, 464]
    x = Conv2D(bottleneck_channels, kernel_size=(1,1), strides=1, padding='same', name='{}/1x1conv_1'.format(prefix))(inputs)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_1'.format(prefix))(x)
    x = Activation('relu', name='{}/relu_1x1conv_1'.format(prefix))(x)
    # 深度可分离卷积
    x = DepthwiseConv2D(kernel_size=3, strides=strides, padding='same', name='{}/3x3Dwconv'.format(prefix))(x)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_3x3dwconv'.format(prefix))(x)
    # [116, 232, 464]
    x = Conv2D(bottleneck_channels, kernel_size=1,strides=1,padding='same', name='{}/1x1conv_2'.format(prefix))(x)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_2'.format(prefix))(x)
    x = Activation('relu', name='{}/relu_1x1conv_2'.format(prefix))(x)
    # 当strides等于2的时候，残差边需要添加卷积
    if strides < 2:
        ret = Concatenate(axis=bn_axis, name='{}/concat_1'.format(prefix))([x, c_hat])
    else:
        s2 = DepthwiseConv2D(kernel_size=3, strides=2, padding='same', name='{}/3x3dwconv_2'.format(prefix))(inputs)
        s2 = BatchNormalization(axis=bn_axis, name='{}/bn_3x3dwconv_2'.format(prefix))(s2)
        s2 = Conv2D(bottleneck_channels, kernel_size=1,strides=1,padding='same', name='{}/1x1_conv_3'.format(prefix))(s2)
        s2 = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_3'.format(prefix))(s2)
        s2 = Activation('relu', name='{}/relu_1x1conv_3'.format(prefix))(s2)
        ret = Concatenate(axis=bn_axis, name='{}/concat_2'.format(prefix))([x, s2])
    ret = Lambda(channel_shuffle, name='{}/channel_shuffle'.format(prefix))(ret)
    return ret
def block(x, channel_map, bottleneck_ratio, repeat=1, stage=1):
    x = shuffle_unit(x, out_channels=channel_map[stage-1],
                      strides=2,bottleneck_ratio=bottleneck_ratio,stage=stage,block=1)
    for i in range(1, repeat+1):
        x = shuffle_unit(x, out_channels=channel_map[stage-1],strides=1,
                          bottleneck_ratio=bottleneck_ratio,stage=stage, block=(1+i))
    return x

2、网络整体结构

网络整体结构如图所示：

1、当输入进来的图片为224,224,3的时候，会经过一次卷积压缩+一次最大池化，此时网络的shape由224,224,3->112,112,24->56,56,24。

2、经过一次右边的ShuffleNet模块后进行三次左边的ShuffleNet模块。此时网络的shape由56,56,24->28,28,116。

3、经过一次右边的ShuffleNet模块后进行七次左边的ShuffleNet模块。此时网络的shape由28,28,116->14,14,232。

4、经过一次右边的ShuffleNet模块后进行三次左边的ShuffleNet模块。此时网络的shape由14,14,232->7,7,464。

5、卷积到1024，此时网络的shape由7,7,464->7,7,1024。

6、全局池化后，进行全连接，用于预测。

网络实现代码

ShuffleNetV2一共有4个scale，分别对应不同大小的ShuffleNetV2。

import numpy as np
from keras.utils import plot_model
from keras.layers import Input, Conv2D, MaxPool2D
from keras.layers import Activation, Add, Concatenate, Conv2D
from keras.layers import GlobalAveragePooling2D, Dense
from keras.layers import MaxPool2D,AveragePooling2D, BatchNormalization, Lambda, DepthwiseConv2D
from keras.models import Model
import keras.backend as K
import numpy as np
def channel_split(x, name=''):
    # 输入进来的通道数
    in_channles = x.shape.as_list()[-1]
    ip = in_channles // 2
    # 对通道数进行分割
    c_hat = Lambda(lambda z: z[:, :, :, 0:ip], name='%s/sp%d_slice' % (name, 0))(x)
    c = Lambda(lambda z: z[:, :, :, ip:], name='%s/sp%d_slice' % (name, 1))(x)
    return c_hat, c
def channel_shuffle(x):
    height, width, channels = x.shape.as_list()[1:]
    channels_per_split = channels // 2
    # 通道交换
    x = K.reshape(x, [-1, height, width, 2, channels_per_split])
    x = K.permute_dimensions(x, (0,1,2,4,3))
    x = K.reshape(x, [-1, height, width, channels])
    return x
def shuffle_unit(inputs, out_channels, bottleneck_ratio, strides=2, stage=1, block=1):
    bn_axis = -1
    prefix = 'stage{}/block{}'.format(stage, block)
    # [116, 232, 464]
    bottleneck_channels = int(out_channels * bottleneck_ratio/2)
    if strides < 2:
        c_hat, c = channel_split(inputs, '{}/spl'.format(prefix))
        inputs = c
    # [116, 232, 464]
    x = Conv2D(bottleneck_channels, kernel_size=(1,1), strides=1, padding='same', name='{}/1x1conv_1'.format(prefix))(inputs)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_1'.format(prefix))(x)
    x = Activation('relu', name='{}/relu_1x1conv_1'.format(prefix))(x)
    # 深度可分离卷积
    x = DepthwiseConv2D(kernel_size=3, strides=strides, padding='same', name='{}/3x3dwconv'.format(prefix))(x)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_3x3dwconv'.format(prefix))(x)
    # [116, 232, 464]
    x = Conv2D(bottleneck_channels, kernel_size=1,strides=1,padding='same', name='{}/1x1conv_2'.format(prefix))(x)
    x = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_2'.format(prefix))(x)
    x = Activation('relu', name='{}/relu_1x1conv_2'.format(prefix))(x)
    # 当strides等于2的时候，残差边需要添加卷积
    if strides < 2:
        ret = Concatenate(axis=bn_axis, name='{}/concat_1'.format(prefix))([x, c_hat])
    else:
        s2 = DepthwiseConv2D(kernel_size=3, strides=2, padding='same', name='{}/3x3dwconv_2'.format(prefix))(inputs)
        s2 = BatchNormalization(axis=bn_axis, name='{}/bn_3x3dwconv_2'.format(prefix))(s2)
        s2 = Conv2D(bottleneck_channels, kernel_size=1,strides=1,padding='same', name='{}/1x1_conv_3'.format(prefix))(s2)
        s2 = BatchNormalization(axis=bn_axis, name='{}/bn_1x1conv_3'.format(prefix))(s2)
        s2 = Activation('relu', name='{}/relu_1x1conv_3'.format(prefix))(s2)
        ret = Concatenate(axis=bn_axis, name='{}/concat_2'.format(prefix))([x, s2])
    ret = Lambda(channel_shuffle, name='{}/channel_shuffle'.format(prefix))(ret)
    return ret
def block(x, channel_map, bottleneck_ratio, repeat=1, stage=1):
    x = shuffle_unit(x, out_channels=channel_map[stage-1],
                      strides=2,bottleneck_ratio=bottleneck_ratio,stage=stage,block=1)
    for i in range(1, repeat+1):
        x = shuffle_unit(x, out_channels=channel_map[stage-1],strides=1,
                          bottleneck_ratio=bottleneck_ratio,stage=stage, block=(1+i))
    return x
def ShuffleNetV2(input_tensor=None,
                 pooling='max',
                 input_shape=(224,224,3),
                 num_shuffle_units=[3,7,3],
                 scale_factor=1,
                 bottleneck_ratio=1,
                 classes=1000):
    name = 'ShuffleNetV2_{}_{}_{}'.format(scale_factor, bottleneck_ratio, "".join([str(x) for x in num_shuffle_units]))
    out_dim_stage_two = {0.5:48, 1:116, 1.5:176, 2:244}
    out_channels_in_stage = np.array([1,1,2,4])
    out_channels_in_stage *= out_dim_stage_two[scale_factor]  #  calculate output channels for each stage
    out_channels_in_stage[0] = 24  # first stage has always 24 output channels
    out_channels_in_stage = out_channels_in_stage.astype(int)
    img_input = Input(shape=input_shape)
    x = Conv2D(filters=out_channels_in_stage[0], kernel_size=(3, 3), padding='same', use_bias=False, strides=(2, 2),
               activation='relu', name='conv1')(img_input)
    x = MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding='same', name='maxpool1')(x)
    for stage in range(len(num_shuffle_units)):
        repeat = num_shuffle_units[stage]
        x = block(x, out_channels_in_stage,
                   repeat=repeat,
                   bottleneck_ratio=bottleneck_ratio,
                   stage=stage + 2)
    if scale_factor!=2:
        x = Conv2D(1024, kernel_size=1, padding='same', strides=1, name='1x1conv5_out', activation='relu')(x)
    else:
        x = Conv2D(2048, kernel_size=1, padding='same', strides=1, name='1x1conv5_out', activation='relu')(x)
    x = GlobalAveragePooling2D(name='global_avg_pool')(x)
    x = Dense(classes, name='fc')(x)
    x = Activation('softmax', name='softmax')(x)
    inputs = img_input
    model = Model(inputs, x, name=name)
    return model
if __name__ == '__main__':
    import os
    os.environ['CUDA_VISIBLE_DEVICES'] = ''
    model = ShuffleNetV2(input_shape=(224, 224, 3),scale_factor=1)
    model.summary()

以上就是python神经网络ShuffleNetV2模型复现详解的详细内容，更多关于ShuffleNetV2模型复现的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: python神经网络ShuffleNetV2模型复现详解

本文链接: https://www.lsjlt.com/news/117761.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

python神经网络ShuffleNetV2模型复现详解

目录什么是ShuffleNetV2ShuffleNetV21、所用模块2、网络整体结构网络实现代码什么是ShuffleNetV2 据说ShuffleNetV2比Mobilenet还要...

99+

2022-11-11
python神经网络Xception模型复现详解

目录什么是Xception模型Xception网络部分实现代码图片预测Xception是继Inception后提出的对Inception v3的另一种改进，学一学总是好的什么是Xc...

99+

2022-11-11
python神经网络InceptionV3模型复现详解

目录学习前言什么是InceptionV3模型InceptionV3网络部分实现代码图片预测学习前言 Inception系列的结构和其它的前向神经网络的结构不太一样，每一层的内容不是直...

99+

2022-11-11
python神经网络Densenet模型复现详解

目录什么是DensenetDensenet1、Densenet的整体结构2、DenseBlock3、Transition Layer网络实现代码什么是Densenet 据说Dense...

99+

2022-11-11
python神经网络Inception ResnetV2模型复现详解

目录什么是Inception ResnetV2Inception-ResNetV2的网络结构1、Stem的结构：2、Inception-resnet-A的结构：3、Inception...

99+

2022-11-11
python神经网络MobileNetV2模型的复现详解

目录什么是MobileNetV2模型MobileNetV2网络部分实现代码图片预测什么是MobileNetV2模型 MobileNet它哥MobileNetV2也是很不错的呢 Mob...

99+

2022-11-11
python神经网络ResNet50模型的复现详解

目录什么是残差网络什么是ResNet50模型ResNet50网络部分实现代码图片预测什么是残差网络最近看yolo3里面讲到了残差网络，对这个网络结构很感兴趣，于是了解到这个网络结构...

99+

2022-11-11
python神经网络MobileNet模型的复现详解

目录什么是MobileNet模型MobileNet网络部分实现代码图片预测什么是MobileNet模型 MobileNet是一种轻量级网络，相比于其它结构网络，它不一定是最准的，但是...

99+

2022-11-11
python神经网络MobileNetV3 small模型的复现详解

目录什么是MobileNetV3large与small的区别MobileNetV3（small）的网络结构1、MobileNetV3（small）的整体结构2、MobileNetV3...

99+

2022-11-11
python神经网络MobileNetV3 large模型的复现详解

目录什么是MobileNetV3MobileNetV3（large）的网络结构1、MobileNetV3（large）的整体结构2、MobileNetV3特有的bneck结构网络实现...

99+

2022-11-11
python神经网络VGG16模型复现及其如何预测详解

目录什么是VGG16模型VGG网络部分实现代码图片预测学一些比较知名的模型对身体有好处噢！什么是VGG16模型 VGG是由Simonyan 和Zisserman在文献《Very D...

99+

2022-11-10
python神经网络Keras GhostNet模型的实现

目录什么是GhostNet模型GhostNet模型的实现思路1、Ghost Module2、Ghost Bottlenecks3、Ghostnet的构建GhostNet的代码构建1、...

99+

2022-11-11
PyTorch+PyG实现图神经网络经典模型目录

前言大家好，我是阿光。本专栏整理了《图神经网络代码实战》，内包含了不同图神经网络的相关代码实现（PyG以及自实现），理论与实践相结合，如GCN、GAT、GraphSAGE等经典图网络，每一个代码...

99+

2023-08-31

pytorch 神经网络 python 人工智能深度学习
python神经网络Batch Normalization底层原理详解

目录什么是Batch NormalizationBatch Normalization的计算公式Bn层的好处为什么要引入γ和β变量Bn层的代码实现什么是Batc...

99+

2022-11-11
python神经网络Keras实现LSTM及其参数量详解

目录什么是LSTM1、LSTM的结构2、LSTM独特的门结构3、LSTM参数量计算a、遗忘门b、输入门c、输出门d、全部参数量在Keras中实现LSTM实现代码什么是LSTM 1、L...

99+

2022-11-11
python神经网络slim常用函数训练保存模型

目录学习前言slim是什么slim常用函数1、slim = tf.contrib.slim2、slim.create_global_step3、slim.dataset.Datase...

99+

2022-11-10
python神经网络AlexNet分类模型训练猫狗数据集

目录什么是AlexNet模型训练前准备1、数据集处理2、创建Keras的AlexNet模型开始训练1、训练的主函数2、Keras数据生成器3、主训练函数全部代码训练结果最近在做实验室...

99+

2022-11-10
TensorFlow卷积神经网络AlexNet实现示例详解

2012年，Hinton的学生Alex Krizhevsky提出了深度卷积神经网络模型AlexNet，它可以算是LeNet的一种更深更宽的版本。AlexNet以显著的优势赢得了竞争激...

99+

2022-11-12
PyTorch实现卷积神经网络的搭建详解

目录PyTorch中实现卷积的重要基础函数1、nn.Conv2d:2、nn.MaxPool2d(kernel_size=2)3、nn.ReLU()4、x.view()全部代码PyTo...

99+

2022-11-11
Python深度学习pytorch神经网络Dropout应用详解解

目录扰动的鲁棒性实践中的dropout简洁实现扰动的鲁棒性在之前我们讨论权重衰减（L2正则化）时看到的那样，参数的范数也代表了一种有用的简单性度量。简单性的另一个有用...

99+

2022-11-12