神经网络学习小记录26——Keras EfficientNet模型的复现详解

客官°小女子只卖身不卖艺 2023-05-29 03:45 54阅读 0赞

神经网络学习小记录26——EfficientNet模型的复现详解

  • 学习前言
  • 什么是EfficientNet模型
    • EfficientNet模型的特点
    • EfficientNet网络的结构
  • EfficientNet网络部分实现代码
  • 图片预测

学习前言

2019年，谷歌新出EfficientNet，在其它网络的基础上，大幅度的缩小了参数的同时提高了预测准确度，简直太强了，我这样的强者也要跟着做下去！
在这里插入图片描述

什么是EfficientNet模型

2019年，谷歌新出EfficientNet，网络如其名，这个网络非常的有效率，怎么理解有效率这个词呢，我们从卷积神经网络的发展来看：
从最初的VGG16发展到如今的Xception，人们慢慢发现，提高神经网络的性能不仅仅在于堆叠层数，更重要的几点是：

1、网络要可以训练，可以收敛。
2、参数量要比较小，方便训练，提高速度。
3、创新神经网络的结构，学到更重要的东西。

而EfficientNet很好的做到了这一点，它利用更少的参数量（关系到训练、速度）得到最好的识别度（学到更重要的特点）。

EfficientNet模型的特点

EfficientNet模型具有很独特的特点，这个特点是参考其它优秀神经网络设计出来的。经典的神经网络特点如下：
1、利用残差神经网络增大神经网络的深度，通过更深的神经网络实现特征提取。
2、改变每一层提取的特征层数，实现更多层的特征提取，得到更多的特征，提升宽度。
3、通过增大输入图片的分辨率也可以使得网络可以学习与表达的东西更加丰富，有利于提高精确度。

EfficientNet就是将这三个特点结合起来，通过一起缩放baseline模型（MobileNet中就通过缩放α实现缩放模型，不同的α有不同的模型精度，α=1时为baseline模型；ResNet其实也是有一个baseline模型，在baseline的基础上通过改变图片的深度实现不同的模型实现），同时调整深度、宽度、输入图片的分辨率完成一个优秀的网络设计。

EfficientNet的效果如下：
在这里插入图片描述
在EfficientNet模型中，其使用一组固定的缩放系数统一缩放网络深度、宽度和分辨率。
假设想使用 2N倍的计算资源，我们可以简单的对网络深度扩大αN倍、宽度扩大βN 、图像尺寸扩大γN倍，这里的α,β,γ都是由原来的小模型上做微小的网格搜索决定的常量系数。
如图为EfficientNet的设计思路，从三个方面同时拓充网络的特性。
在这里插入图片描述

EfficientNet网络的结构

EfficientNet一共由Stem + 16个Blocks + Con2D + GlobalAveragePooling2D + Dense组成，其核心内容是16个Blocks，其它的结构与常规的卷积神经网络差距不大。
此时展示的是EfficientNet-B0也就是EfficientNet的baseline的结构：
在这里插入图片描述
其中每个Block的的参数如下：

  1. DEFAULT_BLOCKS_ARGS = [
  2.     {
  3.     'kernel_size': 3, 'repeats': 1, 'filters_in': 32, 'filters_out': 16,
  4.      'expand_ratio': 1, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25},
  5.     {
  6.     'kernel_size': 3, 'repeats': 2, 'filters_in': 16, 'filters_out': 24,
  7.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  8.     {
  9.     'kernel_size': 5, 'repeats': 2, 'filters_in': 24, 'filters_out': 40,
  10.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  11.     {
  12.     'kernel_size': 3, 'repeats': 3, 'filters_in': 40, 'filters_out': 80,
  13.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  14.     {
  15.     'kernel_size': 5, 'repeats': 3, 'filters_in': 80, 'filters_out': 112,
  16.      'expand_ratio': 6, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25},
  17.     {
  18.     'kernel_size': 5, 'repeats': 4, 'filters_in': 112, 'filters_out': 192,
  19.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  20.     {
  21.     'kernel_size': 3, 'repeats': 1, 'filters_in': 192, 'filters_out': 320,
  22.      'expand_ratio': 6, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25}
  23. ]

Efficientnet-B0由1个Stem+16个大Blocks堆叠构成，16个大Blocks可以分为1、2、2、3、3、4、1个Block。Block的通用结构如下，其总体的设计思路是Inverted residuals结构和残差结构，在3x3或者5x5网络结构前利用1x1卷积升维，在3x3或者5x5网络结构后增加了一个关于通道的注意力机制，最后利用1x1卷积降维后增加一个大残差边。
在这里插入图片描述
Block实现代码如下：

  1. def block(inputs, activation_fn=tf.nn.swish, drop_rate=0., name='',
  2.           filters_in=32, filters_out=16, kernel_size=3, strides=1,
  3.           expand_ratio=1, se_ratio=0., id_skip=True):
  5.     bn_axis = 3
  7.     # 升多少维度
  8.     filters = filters_in * expand_ratio
  10.     # 利用Inverted residuals
  11.     # part1 1x1升维度
  12.     if expand_ratio != 1:
  13.         x = layers.Conv2D(filters, 1,
  14.                           padding='same',
  15.                           use_bias=False,
  16.                           kernel_initializer=CONV_KERNEL_INITIALIZER,
  17.                           name=name + 'expand_conv')(inputs)
  18.         x = layers.BatchNormalization(axis=bn_axis, name=name + 'expand_bn')(x)
  19.         x = layers.Activation(activation_fn, name=name + 'expand_activation')(x)
  20.     else:
  21.         x = inputs
  23.     # padding
  24.     if strides == 2:
  25.         x = layers.ZeroPadding2D(padding=correct_pad(x, kernel_size),
  26.                                  name=name + 'dwconv_pad')(x)
  27.         conv_pad = 'valid'
  28.     else:
  29.         conv_pad = 'same'
  31.     # part2 利用3x3卷积对每一个channel进行卷积
  32.     x = layers.DepthwiseConv2D(kernel_size,
  33.                                strides=strides,
  34.                                padding=conv_pad,
  35.                                use_bias=False,
  36.                                depthwise_initializer=CONV_KERNEL_INITIALIZER,
  37.                                name=name + 'dwconv')(x)
  38.     x = layers.BatchNormalization(axis=bn_axis, name=name + 'bn')(x)
  39.     x = layers.Activation(activation_fn, name=name + 'activation')(x)
  41.     # 压缩后再放大,作为一个调整系数
  42.     if 0 < se_ratio <= 1:
  43.         filters_se = max(1, int(filters_in * se_ratio))
  44.         se = layers.GlobalAveragePooling2D(name=name + 'se_squeeze')(x)
  45.         se = layers.Reshape((1, 1, filters), name=name + 'se_reshape')(se)
  46.         se = layers.Conv2D(filters_se, 1,
  47.                            padding='same',
  48.                            activation=activation_fn,
  49.                            kernel_initializer=CONV_KERNEL_INITIALIZER,
  50.                            name=name + 'se_reduce')(se)
  51.         se = layers.Conv2D(filters, 1,
  52.                            padding='same',
  53.                            activation='sigmoid',
  54.                            kernel_initializer=CONV_KERNEL_INITIALIZER,
  55.                            name=name + 'se_expand')(se)
  56.         x = layers.multiply([x, se], name=name + 'se_excite')
  58.     # part3 利用1x1对特征层进行压缩
  59.     x = layers.Conv2D(filters_out, 1,
  60.                       padding='same',
  61.                       use_bias=False,
  62.                       kernel_initializer=CONV_KERNEL_INITIALIZER,
  63.                       name=name + 'project_conv')(x)
  64.     x = layers.BatchNormalization(axis=bn_axis, name=name + 'project_bn')(x)
  66.     # 实现残差神经网络
  67.     if (id_skip is True and strides == 1 and filters_in == filters_out):
  68.         if drop_rate > 0:
  69.             x = layers.Dropout(drop_rate,
  70.                                noise_shape=(None, 1, 1, 1),
  71.                                name=name + 'drop')(x)
  72.         x = layers.add([x, inputs], name=name + 'add')
  74.     return x

EfficientNet网络部分实现代码

  1. #-------------------------------------------------------------#
  2. #   EfficientNet的网络部分
  3. #-------------------------------------------------------------#
  4. from __future__ import absolute_import
  5. from __future__ import division
  6. from __future__ import print_function
  8. import os
  9. import math
  10. import tensorflow as tf
  11. import numpy as np
  12. from keras import layers
  13. from keras.models import Model
  14. from keras.applications import correct_pad
  15. from keras.applications import imagenet_utils
  16. from keras.applications.imagenet_utils import decode_predictions
  17. from keras.applications.imagenet_utils import _obtain_input_shape
  18. from keras.utils.data_utils import get_file
  19. from keras.preprocessing import image
  21. # 用于下载模型的默认参数
  22. BASE_WEIGHTS_PATH = (
  23.     'https://github.com/Callidior/keras-applications/'
  24.     'releases/download/efficientnet/')
  25. WEIGHTS_HASHES = {
  27.     'b0': ('e9e877068bd0af75e0a36691e03c072c',
  28.            '345255ed8048c2f22c793070a9c1a130'),
  29.     'b1': ('8f83b9aecab222a9a2480219843049a1',
  30.            'b20160ab7b79b7a92897fcb33d52cc61'),
  31.     'b2': ('b6185fdcd190285d516936c09dceeaa4',
  32.            'c6e46333e8cddfa702f4d8b8b6340d70'),
  33.     'b3': ('b2db0f8aac7c553657abb2cb46dcbfbb',
  34.            'e0cf8654fad9d3625190e30d70d0c17d'),
  35.     'b4': ('ab314d28135fe552e2f9312b31da6926',
  36.            'b46702e4754d2022d62897e0618edc7b'),
  37.     'b5': ('8d60b903aff50b09c6acf8eaba098e09',
  38.            '0a839ac36e46552a881f2975aaab442f'),
  39.     'b6': ('a967457886eac4f5ab44139bdd827920',
  40.            '375a35c17ef70d46f9c664b03b4437f2'),
  41.     'b7': ('e964fd6e26e9a4c144bcb811f2a10f20',
  42.            'd55674cc46b805f4382d18bc08ed43c1')
  43. }
  45. # 每个Blocks的参数
  46. DEFAULT_BLOCKS_ARGS = [
  47.     {
  48.     'kernel_size': 3, 'repeats': 1, 'filters_in': 32, 'filters_out': 16,
  49.      'expand_ratio': 1, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25},
  50.     {
  51.     'kernel_size': 3, 'repeats': 2, 'filters_in': 16, 'filters_out': 24,
  52.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  53.     {
  54.     'kernel_size': 5, 'repeats': 2, 'filters_in': 24, 'filters_out': 40,
  55.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  56.     {
  57.     'kernel_size': 3, 'repeats': 3, 'filters_in': 40, 'filters_out': 80,
  58.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  59.     {
  60.     'kernel_size': 5, 'repeats': 3, 'filters_in': 80, 'filters_out': 112,
  61.      'expand_ratio': 6, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25},
  62.     {
  63.     'kernel_size': 5, 'repeats': 4, 'filters_in': 112, 'filters_out': 192,
  64.      'expand_ratio': 6, 'id_skip': True, 'strides': 2, 'se_ratio': 0.25},
  65.     {
  66.     'kernel_size': 3, 'repeats': 1, 'filters_in': 192, 'filters_out': 320,
  67.      'expand_ratio': 6, 'id_skip': True, 'strides': 1, 'se_ratio': 0.25}
  68. ]
  70. # 两个Kernel的初始化器
  71. CONV_KERNEL_INITIALIZER = {
  73.     'class_name': 'VarianceScaling',
  74.     'config': {
  76.         'scale': 2.0,
  77.         'mode': 'fan_out',
  78.         'distribution': 'normal'
  79.     }
  80. }
  82. DENSE_KERNEL_INITIALIZER = {
  84.     'class_name': 'VarianceScaling',
  85.     'config': {
  87.         'scale': 1. / 3.,
  88.         'mode': 'fan_out',
  89.         'distribution': 'uniform'
  90.     }
  91. }
  94. def block(inputs, activation_fn=tf.nn.swish, drop_rate=0., name='',
  95.           filters_in=32, filters_out=16, kernel_size=3, strides=1,
  96.           expand_ratio=1, se_ratio=0., id_skip=True):
  98.     bn_axis = 3
  100.     # 升多少维度
  101.     filters = filters_in * expand_ratio
  103.     # 利用Inverted residuals
  104.     # part1 1x1升维度
  105.     if expand_ratio != 1:
  106.         x = layers.Conv2D(filters, 1,
  107.                           padding='same',
  108.                           use_bias=False,
  109.                           kernel_initializer=CONV_KERNEL_INITIALIZER,
  110.                           name=name + 'expand_conv')(inputs)
  111.         x = layers.BatchNormalization(axis=bn_axis, name=name + 'expand_bn')(x)
  112.         x = layers.Activation(activation_fn, name=name + 'expand_activation')(x)
  113.     else:
  114.         x = inputs
  116.     # padding
  117.     if strides == 2:
  118.         x = layers.ZeroPadding2D(padding=correct_pad(x, kernel_size),
  119.                                  name=name + 'dwconv_pad')(x)
  120.         conv_pad = 'valid'
  121.     else:
  122.         conv_pad = 'same'
  124.     # part2 利用3x3卷积对每一个channel进行卷积
  125.     x = layers.DepthwiseConv2D(kernel_size,
  126.                                strides=strides,
  127.                                padding=conv_pad,
  128.                                use_bias=False,
  129.                                depthwise_initializer=CONV_KERNEL_INITIALIZER,
  130.                                name=name + 'dwconv')(x)
  131.     x = layers.BatchNormalization(axis=bn_axis, name=name + 'bn')(x)
  132.     x = layers.Activation(activation_fn, name=name + 'activation')(x)
  134.     # 压缩后再放大,作为一个调整系数
  135.     if 0 < se_ratio <= 1:
  136.         filters_se = max(1, int(filters_in * se_ratio))
  137.         se = layers.GlobalAveragePooling2D(name=name + 'se_squeeze')(x)
  138.         se = layers.Reshape((1, 1, filters), name=name + 'se_reshape')(se)
  139.         se = layers.Conv2D(filters_se, 1,
  140.                            padding='same',
  141.                            activation=activation_fn,
  142.                            kernel_initializer=CONV_KERNEL_INITIALIZER,
  143.                            name=name + 'se_reduce')(se)
  144.         se = layers.Conv2D(filters, 1,
  145.                            padding='same',
  146.                            activation='sigmoid',
  147.                            kernel_initializer=CONV_KERNEL_INITIALIZER,
  148.                            name=name + 'se_expand')(se)
  149.         x = layers.multiply([x, se], name=name + 'se_excite')
  151.     # part3 利用1x1对特征层进行压缩
  152.     x = layers.Conv2D(filters_out, 1,
  153.                       padding='same',
  154.                       use_bias=False,
  155.                       kernel_initializer=CONV_KERNEL_INITIALIZER,
  156.                       name=name + 'project_conv')(x)
  157.     x = layers.BatchNormalization(axis=bn_axis, name=name + 'project_bn')(x)
  159.     # 实现残差神经网络
  160.     if (id_skip is True and strides == 1 and filters_in == filters_out):
  161.         if drop_rate > 0:
  162.             x = layers.Dropout(drop_rate,
  163.                                noise_shape=(None, 1, 1, 1),
  164.                                name=name + 'drop')(x)
  165.         x = layers.add([x, inputs], name=name + 'add')
  167.     return x
  170. def EfficientNet(width_coefficient,
  171.                  depth_coefficient,
  172.                  default_size,
  173.                  dropout_rate=0.2,
  174.                  drop_connect_rate=0.2,
  175.                  depth_divisor=8,
  176.                  activation_fn=tf.nn.swish,
  177.                  blocks_args=DEFAULT_BLOCKS_ARGS,
  178.                  model_name='efficientnet',
  179.                  weights='imagenet',
  180.                  input_tensor=None,
  181.                  input_shape=None,
  182.                  pooling=None,
  183.                  classes=1000,
  184.                  **kwargs):
  186.     input_shape = [416,416,3]
  187.     img_input = layers.Input(tensor=input_tensor, shape=input_shape)
  190.     bn_axis = 3 
  192.     # 保证filter的大小可以被8整除
  193.     def round_filters(filters, divisor=depth_divisor):
  194.         """Round number of filters based on depth multiplier."""
  195.         filters *= width_coefficient
  196.         new_filters = max(divisor, int(filters + divisor / 2) // divisor * divisor)
  197.         # Make sure that round down does not go down by more than 10%.
  198.         if new_filters < 0.9 * filters:
  199.             new_filters += divisor
  200.         return int(new_filters)
  202.     # 重复次数，取顶
  203.     def round_repeats(repeats):
  204.         return int(math.ceil(depth_coefficient * repeats))
  206.     # Build stem
  207.     x = img_input
  208.     x = layers.ZeroPadding2D(padding=correct_pad(x, 3),
  209.                              name='stem_conv_pad')(x)
  210.     x = layers.Conv2D(round_filters(32), 3,
  211.                       strides=2,
  212.                       padding='valid',
  213.                       use_bias=False,
  214.                       kernel_initializer=CONV_KERNEL_INITIALIZER,
  215.                       name='stem_conv')(x)
  216.     x = layers.BatchNormalization(axis=bn_axis, name='stem_bn')(x)
  217.     x = layers.Activation(activation_fn, name='stem_activation')(x)
  219.     # Build blocks
  220.     from copy import deepcopy
  222.     # 防止参数的改变
  223.     blocks_args = deepcopy(blocks_args)
  225.     b = 0
  226.     # 计算总的block的数量
  227.     blocks = float(sum(args['repeats'] for args in blocks_args))
  228.     for (i, args) in enumerate(blocks_args):
  229.         assert args['repeats'] > 0
  230.         args['filters_in'] = round_filters(args['filters_in'])
  231.         args['filters_out'] = round_filters(args['filters_out'])
  233.         for j in range(round_repeats(args.pop('repeats'))):
  234.             if j > 0:
  235.                 args['strides'] = 1
  236.                 args['filters_in'] = args['filters_out']
  237.             x = block(x, activation_fn, drop_connect_rate * b / blocks,
  238.                       name='block{}{}_'.format(i + 1, chr(j + 97)), **args)
  239.             b += 1
  241.     # 收尾工作
  242.     x = layers.Conv2D(round_filters(1280), 1,
  243.                       padding='same',
  244.                       use_bias=False,
  245.                       kernel_initializer=CONV_KERNEL_INITIALIZER,
  246.                       name='top_conv')(x)
  247.     x = layers.BatchNormalization(axis=bn_axis, name='top_bn')(x)
  248.     x = layers.Activation(activation_fn, name='top_activation')(x)
  250.     # 利用GlobalAveragePooling2D代替全连接层
  251.     x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
  252.     if dropout_rate > 0:
  253.         x = layers.Dropout(dropout_rate, name='top_dropout')(x)
  255.     x = layers.Dense(classes,
  256.                         activation='softmax',
  257.                         kernel_initializer=DENSE_KERNEL_INITIALIZER,
  258.                         name='probs')(x)
  260.     # 输入inputs
  261.     inputs = img_input
  263.     model = Model(inputs, x, name=model_name)
  265.     # Load weights.
  266.     if weights == 'imagenet':
  267.         file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5'
  268.         file_hash = WEIGHTS_HASHES[model_name[-2:]][0]
  269.         file_name = model_name + file_suff
  270.         weights_path = get_file(file_name,BASE_WEIGHTS_PATH + file_name,
  271.                                     cache_subdir='models',
  272.                                     file_hash=file_hash)
  273.         model.load_weights(weights_path)
  274.     elif weights is not None:
  275.         model.load_weights(weights)
  277.     return model
  280. def EfficientNetB0(weights='imagenet',
  281.                    input_tensor=None,
  282.                    input_shape=None,
  283.                    pooling=None,
  284.                    classes=1000,
  285.                    **kwargs):
  286.     return EfficientNet(1.0, 1.0, 224, 0.2,
  287.                         model_name='efficientnet-b0',
  288.                         weights=weights,
  289.                         input_tensor=input_tensor, input_shape=input_shape,
  290.                         pooling=pooling, classes=classes,
  291.                         **kwargs)
  294. def EfficientNetB1(weights='imagenet',
  295.                    input_tensor=None,
  296.                    input_shape=None,
  297.                    pooling=None,
  298.                    classes=1000,
  299.                    **kwargs):
  300.     return EfficientNet(1.0, 1.1, 240, 0.2,
  301.                         model_name='efficientnet-b1',
  302.                         weights=weights,
  303.                         input_tensor=input_tensor, input_shape=input_shape,
  304.                         pooling=pooling, classes=classes,
  305.                         **kwargs)
  308. def EfficientNetB2(weights='imagenet',
  309.                    input_tensor=None,
  310.                    input_shape=None,
  311.                    pooling=None,
  312.                    classes=1000,
  313.                    **kwargs):
  314.     return EfficientNet(1.1, 1.2, 260, 0.3,
  315.                         model_name='efficientnet-b2',
  316.                         weights=weights,
  317.                         input_tensor=input_tensor, input_shape=input_shape,
  318.                         pooling=pooling, classes=classes,
  319.                         **kwargs)
  322. def EfficientNetB3(weights='imagenet',
  323.                    input_tensor=None,
  324.                    input_shape=None,
  325.                    pooling=None,
  326.                    classes=1000,
  327.                    **kwargs):
  328.     return EfficientNet(1.2, 1.4, 300, 0.3,
  329.                         model_name='efficientnet-b3',
  330.                         weights=weights,
  331.                         input_tensor=input_tensor, input_shape=input_shape,
  332.                         pooling=pooling, classes=classes,
  333.                         **kwargs)
  336. def EfficientNetB4(weights='imagenet',
  337.                    input_tensor=None,
  338.                    input_shape=None,
  339.                    pooling=None,
  340.                    classes=1000,
  341.                    **kwargs):
  342.     return EfficientNet(1.4, 1.8, 380, 0.4,
  343.                         model_name='efficientnet-b4',
  344.                         weights=weights,
  345.                         input_tensor=input_tensor, input_shape=input_shape,
  346.                         pooling=pooling, classes=classes,
  347.                         **kwargs)
  350. def EfficientNetB5(weights='imagenet',
  351.                    input_tensor=None,
  352.                    input_shape=None,
  353.                    pooling=None,
  354.                    classes=1000,
  355.                    **kwargs):
  356.     return EfficientNet(1.6, 2.2, 456, 0.4,
  357.                         model_name='efficientnet-b5',
  358.                         weights=weights,
  359.                         input_tensor=input_tensor, input_shape=input_shape,
  360.                         pooling=pooling, classes=classes,
  361.                         **kwargs)
  364. def EfficientNetB6(weights='imagenet',
  365.                    input_tensor=None,
  366.                    input_shape=None,
  367.                    pooling=None,
  368.                    classes=1000,
  369.                    **kwargs):
  370.     return EfficientNet(1.8, 2.6, 528, 0.5,
  371.                         model_name='efficientnet-b6',
  372.                         weights=weights,
  373.                         input_tensor=input_tensor, input_shape=input_shape,
  374.                         pooling=pooling, classes=classes,
  375.                         **kwargs)
  378. def EfficientNetB7(weights='imagenet',
  379.                    input_tensor=None,
  380.                    input_shape=None,
  381.                    pooling=None,
  382.                    classes=1000,
  383.                    **kwargs):
  384.     return EfficientNet(2.0, 3.1, 600, 0.5,
  385.                         model_name='efficientnet-b7',
  386.                         weights=weights,
  387.                         input_tensor=input_tensor, input_shape=input_shape,
  388.                         pooling=pooling, classes=classes,
  389.                         **kwargs)

图片预测

建立网络后，可以用以下的代码进行预测。

  1. # 处理图片
  2. def preprocess_input(x):
  3.     x /= 255.
  4.     x -= 0.5
  5.     x *= 2.
  6.     return x
  8. if __name__ == '__main__':
  9.     model = EfficientNetB0()
  10.     model.summary()
  11.     img_path = 'elephant.jpg'
  12.     img = image.load_img(img_path, target_size=(224, 224))
  13.     x = image.img_to_array(img)
  14.     x = np.expand_dims(x, axis=0)
  15.     x = preprocess_input(x)
  16.     print('Input image shape:', x.shape)
  18.     preds = model.predict(x)
  19.     print(np.argmax(preds))
  20.     print('Predicted:', decode_predictions(preds, 1))

预测所需的已经训练好的EfficientNet模型会在运行时自动下载，下载后的模型位于C:\Users\Administrator.keras\models文件夹内。
通过函数EfficientNetB0，EfficientNetB1……EfficientNetB6，EfficientNetB7可以获得不同size的EfficientNet模型。














































































Top-1 Top-5 10-5 Size Stem
EfficientNet-B0 22.810 6.508 5.858 5.3M 4.0M
EfficientNet-B1 20.866 5.552 5.050 7.9M 6.6M
EfficientNet-B2 19.820 5.054 4.538 9.2M 7.8M
EfficientNet-B3 18.422 4.324 3.902 12.3M 10.8M
EfficientNet-B4 17.040 3.740 3.344 19.5M 17.7M
EfficientNet-B5 16.298 3.290 3.114 30.6M 28.5M
EfficientNet-B6 15.918 3.102 2.916 43.3M 41.0M
EfficientNet-B7 15.570 3.160 2.906 66.7M 64.1M

发表评论

表情：
评论列表 （有 0 条评论，54人围观）

还没有评论，来说两句吧...

相关阅读