diff --git a/docs/tutorial/finetuned_model_to_module.md b/docs/tutorial/finetuned_model_to_module.md
index 853501e6dbd0b6b9372b01ac9a002510a131f01f..dff994b4d1d449e9319bf4af42c660a4edcaca93 100644
--- a/docs/tutorial/finetuned_model_to_module.md
+++ b/docs/tutorial/finetuned_model_to_module.md
@@ -192,7 +192,7 @@ def predict(self, data, return_result=False, accelerate_mode=True):
     prediction = []
     for batch_result in results:
         # get predict index
-        batch_result = np.argmax(batch_result, axis=2)[0]
+        batch_result = np.argmax(batch_result[0], axis=1)
         batch_result = batch_result.tolist()
         prediction += batch_result
     return prediction
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb0_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..992c00988a5935a26e920fcfd6e6cb2a8abfeb26
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb0_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+             paths=None,
+             batch_size=1,
+             use_gpu=False,
+             top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb0_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb0_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb0_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe9f09a253c053e8a9b2d9d700a2a9eb79ae317e
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb0_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb0_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..08af13fa0d9bcc264935fe4bf3aa7e66f4f2ae66
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/module.py
@@ -0,0 +1,330 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb0_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb0_imagenet.data_feed import reader
+from efficientnetb0_imagenet.efficientnet import EfficientNetB0
+
+
+@moduleinfo(
+    name="efficientnetb0_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB0 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB0ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb0_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase="train"):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b0 = EfficientNetB0(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b0.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b0 = EfficientNetB0ImageNet()
+    b0.context()
+    import cv2
+    test_image = [
+        cv2.imread(
+            '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+        )
+    ]
+    res = b0.classification(images=test_image)
+    print(res)
+    res = b0.classification(paths=[
+        '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+    ])
+    print(res)
+    res = b0.classification(images=test_image)
+    print(res)
+    res = b0.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb0_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb0_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb0_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/README.md
index 05ad2f7526f932f2e5f00ac654751c085dd212bd..3895a0b8e88b34daea9ed8653b078c9289769dee 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/README.md
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/README.md
@@ -49,7 +49,7 @@ def context(trainable=True, pretrained=True)
 * context\_prog(fluid.Program): 计算图，用于迁移学习。
 
 ```python
-def classification(images=None,
+def classify(images=None,
                    paths=None,
                    batch_size=1,
                    use_gpu=False,
@@ -92,9 +92,9 @@ import cv2
 
 classifier = hub.Module(name="efficientnetb0_small_imagenet")
 
-result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
 # or
-# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
 ```
 
 ## 服务部署
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..19a990dae200a46a79ab01a3ba41d114d8c7fc98 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/__init__.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/data_feed.py
index d5ffb5efe9fdfbd143b949892aa44d851e907b41..11181458f0b56dd9f84bc9e5d06a0b515db8f23a 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/data_feed.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/data_feed.py
@@ -1,4 +1,18 @@
-# coding=utf-8
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import os
 import time
 from collections import OrderedDict
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/efficientnet.py
index fe8ba7fdcd86bc7d7ba820dcc0a18f7a9f3f11d8..87e61d22657edd165aa70a4aeb89a8d78ba0db3c 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/efficientnet.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/efficientnet.py
@@ -1,3 +1,18 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
@@ -135,7 +150,6 @@ class EfficientNet():
             model_name, override_params)
         self._bn_mom = self._global_params.batch_norm_momentum
         self._bn_eps = self._global_params.batch_norm_epsilon
-        self.is_test = is_test
         self.padding_type = padding_type
         self.use_se = use_se
 
@@ -159,7 +173,7 @@ class EfficientNet():
         pool = fluid.layers.pool2d(
             input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
 
-        if self._global_params.dropout_rate:
+        if not is_test and self._global_params.dropout_rate:
             pool = fluid.layers.dropout(
                 pool,
                 self._global_params.dropout_rate,
@@ -335,7 +349,7 @@ class EfficientNet():
         input_filters, output_filters = block_args.input_filters, block_args.output_filters
         if id_skip and block_args.stride == 1 and input_filters == output_filters:
             if drop_connect_rate:
-                conv = self._drop_connect(conv, drop_connect_rate, self.is_test)
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
             conv = fluid.layers.elementwise_add(conv, inputs)
 
         return conv
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/layers.py
index a090ac4b174dc32385a68ddd712009db2439564b..00f792b577c4d89bbf5191950d9e29628d9b72ba 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/layers.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/layers.py
@@ -1,3 +1,18 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/module.py
index 393092cb385703f4b2c7fc93c99cb3804baeee2c..02af69ccf2e93fbdaf1461eae09cd40ef6bf17fd 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/module.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/module.py
@@ -1,4 +1,18 @@
-# coding=utf-8
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from __future__ import absolute_import
 from __future__ import division
 
@@ -26,14 +40,15 @@ from efficientnetb0_small_imagenet.efficientnet import EfficientNetB0_small
     summary=
     "EfficientNetB0 is a image classfication model, this module is trained with imagenet datasets.",
     version="1.0.0")
-class EfficientNetB0ImageNet(hub.Module):
+class EfficientNetB0SmallImageNet(hub.Module):
     def _initialize(self):
         self.default_pretrained_model_path = os.path.join(
-            self.directory, "efficientnetb0_small_imagenet_model")
+            self.directory, "efficientnetb0_small_imagenet_infer_model")
         label_file = os.path.join(self.directory, "label_list.txt")
         with open(label_file, 'r', encoding='utf-8') as file:
             self.label_list = file.read().split("\n")[:-1]
-        self.predictor_set = False
+        self.classification = self.classify
+        self._set_config()
 
     def get_expected_image_width(self):
         return 224
@@ -71,7 +86,11 @@ class EfficientNetB0ImageNet(hub.Module):
                 memory_pool_init_size_mb=1000, device_id=0)
             self.gpu_predictor = create_paddle_predictor(gpu_config)
 
-    def context(self, trainable=True, pretrained=True):
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
         """context for transfer learning.
 
         Args:
@@ -85,15 +104,27 @@ class EfficientNetB0ImageNet(hub.Module):
                 'feature_map', corresponding value is the result of the layer before the fully connected layer.
             context_prog (fluid.Program): program for transfer learning.
         """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
         context_prog = fluid.Program()
         startup_prog = fluid.Program()
         with fluid.program_guard(context_prog, startup_prog):
             with fluid.unique_name.guard():
                 image = fluid.layers.data(
                     name="image", shape=[3, 224, 224], dtype="float32")
-                efficientnet_b0 = EfficientNetB0_small()
+                efficientnet_b0 = EfficientNetB0_small(
+                    override_params=override_params)
                 output, feature_map = efficientnet_b0.net(
-                    input=image, class_dim=len(self.label_list))
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
 
                 name_prefix = '@HUB_{}@'.format(self.name)
                 inputs = {'image': name_prefix + image.name}
@@ -129,16 +160,6 @@ class EfficientNetB0ImageNet(hub.Module):
                         self.default_pretrained_model_path,
                         context_prog,
                         predicate=_if_exist)
-                    print(inputs.keys())
-
-                    fluid.io.save_inference_model(
-                        dirname=os.path.join(
-                            self.directory,
-                            'efficientnetb0_small_imagenet_model'),
-                        feeded_var_names=[name_prefix + 'image'],
-                        target_vars=list(outputs.values()),
-                        executor=exe,
-                        main_program=context_prog)
                 else:
                     exe.run(startup_prog)
                 # trainable
@@ -146,12 +167,12 @@ class EfficientNetB0ImageNet(hub.Module):
                     param.trainable = trainable
         return inputs, outputs, context_prog
 
-    def classification(self,
-                       images=None,
-                       paths=None,
-                       batch_size=1,
-                       use_gpu=False,
-                       top_k=1):
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
         """
         API for image classification.
 
@@ -165,10 +186,6 @@ class EfficientNetB0ImageNet(hub.Module):
         Returns:
             res (list[dict]): The classfication results.
         """
-        if not self.predictor_set:
-            self._set_config()
-            self.predictor_set = True
-
         if use_gpu:
             try:
                 _places = os.environ["CUDA_VISIBLE_DEVICES"]
@@ -236,7 +253,7 @@ class EfficientNetB0ImageNet(hub.Module):
         Run as a service.
         """
         images_decode = [base64_to_cv2(image) for image in images]
-        results = self.classification(images=images_decode, **kwargs)
+        results = self.classify(images=images_decode, **kwargs)
         return results
 
     @runnable
@@ -258,7 +275,7 @@ class EfficientNetB0ImageNet(hub.Module):
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.classification(
+        results = self.classify(
             paths=[args.input_path],
             batch_size=args.batch_size,
             use_gpu=args.use_gpu)
@@ -290,3 +307,18 @@ class EfficientNetB0ImageNet(hub.Module):
         """
         self.arg_input_group.add_argument(
             '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b0 = EfficientNetB0SmallImageNet()
+    b0.context()
+    import cv2
+    test_image = [cv2.imread('dog.jpeg')]
+    res = b0.classification(images=test_image)
+    print(res)
+    res = b0.classification(paths=['dog.jpeg'])
+    print(res)
+    res = b0.classification(images=test_image)
+    print(res)
+    res = b0.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/processor.py
index fa8cbb502312e6ef80697ab63b767d4077b3847b..12ccc9b286dad473e2ff02de86dd60eac928db5b 100644
--- a/hub_module/modules/image/classification/efficientnetb0_small_imagenet/processor.py
+++ b/hub_module/modules/image/classification/efficientnetb0_small_imagenet/processor.py
@@ -1,4 +1,18 @@
-# coding=utf-8
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb1_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb0e1a4bf56931b82be03f425773477bd309b210
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb1_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+                   paths=None,
+                   batch_size=1,
+                   use_gpu=False,
+                   top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb1_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb1_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb1_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..c357fa9c4aa2548b90e8cde1a9b92f93d3f8a6ca
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb1_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb1_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..d98c40e8775d7927a2e97814284fb9c83c5361de
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/module.py
@@ -0,0 +1,333 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb1_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb1_imagenet.data_feed import reader
+from efficientnetb1_imagenet.efficientnet import EfficientNetB1
+
+
+@moduleinfo(
+    name="efficientnetb1_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB1 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB1ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb1_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+
+        # It's compatibale with the usage of module's old_version.
+        self.classification = self.classify
+
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b1 = EfficientNetB1(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b1.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b1 = EfficientNetB1ImageNet()
+    b1.context()
+    import cv2
+    test_image = [
+        cv2.imread(
+            '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+        )
+    ]
+    res = b1.classification(images=test_image)
+    print(res)
+    res = b1.classification(paths=[
+        '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+    ])
+    print(res)
+    res = b1.classification(images=test_image)
+    print(res)
+    res = b1.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb1_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb1_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb1_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb2_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..eda1a22523df45570aaf0641e40eb0755d59d0e9
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb2_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+                   paths=None,
+                   batch_size=1,
+                   use_gpu=False,
+                   top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb2_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb2_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb2_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a9d08c28722654a4bab08aaff60f42016e836a6
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb2_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb2_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..8006b0e1013491a7e4f4fccab77aec7eefc5883c
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/module.py
@@ -0,0 +1,330 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb2_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb2_imagenet.data_feed import reader
+from efficientnetb2_imagenet.efficientnet import EfficientNetB2
+
+
+@moduleinfo(
+    name="efficientnetb2_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB2 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB2ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb2_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b2 = EfficientNetB2(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b2.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b2 = EfficientNetB2ImageNet()
+    b2.context()
+    import cv2
+    test_image = [
+        cv2.imread(
+            '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+        )
+    ]
+    res = b2.classification(images=test_image)
+    print(res)
+    res = b2.classification(paths=[
+        '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+    ])
+    print(res)
+    res = b2.classification(images=test_image)
+    print(res)
+    res = b2.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb2_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb2_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb2_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb3_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b6b94bbbc1f879cdd38871f04ef6907e29465026
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb3_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+                   paths=None,
+                   batch_size=1,
+                   use_gpu=False,
+                   top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb3_small_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb3_small_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb3_small_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..18ddf3c4e3bf31b07f90e0a570944d13232e60d8
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb3_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb3_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..42e0767fd40d0dfd6000b77fc4399b4f7953835b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/module.py
@@ -0,0 +1,330 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb3_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb3_imagenet.data_feed import reader
+from efficientnetb3_imagenet.efficientnet import EfficientNetB3
+
+
+@moduleinfo(
+    name="efficientnetb3_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB3 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB3ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb3_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b3 = EfficientNetB3(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b3.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b3 = EfficientNetB3ImageNet()
+    b3.context()
+    import cv2
+    test_image = [
+        cv2.imread(
+            '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+        )
+    ]
+    res = b3.classification(images=test_image)
+    print(res)
+    res = b3.classification(paths=[
+        '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+    ])
+    print(res)
+    res = b3.classification(images=test_image)
+    print(res)
+    res = b3.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb3_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb3_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb3_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb4_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..aded214a2ed1dcacf03e070d7a71b1c4e5fd4857
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb4_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+             paths=None,
+             batch_size=1,
+             use_gpu=False,
+             top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb4_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb4_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb4_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3684529d76468932f8e38ca5d3ed162a3df7016
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb4_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb4_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3a7c726278395c258a32031dcb730ee37928aaf
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/module.py
@@ -0,0 +1,330 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb4_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb4_imagenet.data_feed import reader
+from efficientnetb4_imagenet.efficientnet import EfficientNetB4
+
+
+@moduleinfo(
+    name="efficientnetb4_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB4 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB4ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb4_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b4 = EfficientNetB4(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b4.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b4 = EfficientNetB4ImageNet()
+    b4.context()
+    import cv2
+    test_image = [
+        cv2.imread(
+            '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+        )
+    ]
+    res = b4.classification(images=test_image)
+    print(res)
+    res = b4.classification(paths=[
+        '/mnt/zhangxuefei/program-paddle/PaddleHub/hub_module/tests/image_dataset/classification/animals/dog.jpeg'
+    ])
+    print(res)
+    res = b4.classification(images=test_image)
+    print(res)
+    res = b4.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb4_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb4_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb4_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb5_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..140e22c9c58cc9e950c427382c50b351df9fa26c
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb5_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+             paths=None,
+             batch_size=1,
+             use_gpu=False,
+             top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb5_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb5_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb5_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef49e9721152344548188be731aeaa986da78d66
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb5_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb5_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf9317e02105cefb96585f10a1fb75465d08bafd
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/module.py
@@ -0,0 +1,324 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb5_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb5_imagenet.data_feed import reader
+from efficientnetb5_imagenet.efficientnet import EfficientNetB5
+
+
+@moduleinfo(
+    name="efficientnetb5_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB5 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB5ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb5_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b5 = EfficientNetB5(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b5.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b5 = EfficientNetB5ImageNet()
+    b5.context()
+    import cv2
+    test_image = [cv2.imread('dog.jpeg')]
+    res = b5.classification(images=test_image)
+    print(res)
+    res = b5.classification(paths=['dog.jpeg'])
+    print(res)
+    res = b5.classification(images=test_image)
+    print(res)
+    res = b5.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb5_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb5_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb5_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb6_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..da687d106e90e171a97e192dc0650f4472c7687b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb6_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+             paths=None,
+             batch_size=1,
+             use_gpu=False,
+             top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb6_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb6_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb6_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e79f48c1635986afe5553c19ce93c6672724947a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb6_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb6_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..af1427f6bddd810e2f671c0222f25e249af88a2d
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/module.py
@@ -0,0 +1,324 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb6_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb6_imagenet.data_feed import reader
+from efficientnetb6_imagenet.efficientnet import EfficientNetB6
+
+
+@moduleinfo(
+    name="efficientnetb6_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB6 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB6ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb6_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b6 = EfficientNetB6(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b6.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b6 = EfficientNetB6ImageNet()
+    b6.context()
+    import cv2
+    test_image = [cv2.imread('dog.jpeg')]
+    res = b6.classification(images=test_image)
+    print(res)
+    res = b6.classification(paths=['dog.jpeg'])
+    print(res)
+    res = b6.classification(images=test_image)
+    print(res)
+    res = b6.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb6_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb6_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb6_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/README.md b/hub_module/modules/image/classification/efficientnetb7_imagenet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..75e9d3979ef945e63bb1600e913feabbade584e7
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/README.md
@@ -0,0 +1,149 @@
+## 命令行预测
+
+```
+hub run efficientnetb7_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def classify(images=None,
+             paths=None,
+             batch_size=1,
+             use_gpu=False,
+             top_k=1):
+```
+
+**参数**
+
+* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR；
+* paths (list\[str\]): 图片的路径；
+* batch\_size (int): batch 的大小；
+* use\_gpu (bool): 是否使用 GPU 来预测；
+* top\_k (int): 返回预测结果的前 k 个。
+
+**返回**
+
+res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
+
+```python
+def save_inference_model(dirname,
+                         model_filename=None,
+                         params_filename=None,
+                         combined=True)
+```
+
+将模型保存到指定路径。
+
+**参数**
+
+* dirname: 存在模型的目录名称
+* model\_filename: 模型文件名称，默认为\_\_model\_\_
+* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+* combined: 是否将参数保存到统一的一个文件中
+
+## 代码示例
+
+```python
+import paddlehub as hub
+import cv2
+
+classifier = hub.Module(name="efficientnetb7_imagenet")
+
+result = classifier.classify(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classify(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m efficientnetb7_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# 发送HTTP请求
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/efficientnetb7_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/__init__.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a990dae200a46a79ab01a3ba41d114d8c7fc98
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/__init__.py
@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/data_feed.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/data_feed.py
new file mode 100644
index 0000000000000000000000000000000000000000..11181458f0b56dd9f84bc9e5d06a0b515db8f23a
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/data_feed.py
@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import time
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image
+
+__all__ = ['reader']
+
+DATA_DIM = 224
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) / 2
+        h_start = (height - size) / 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def process_image(img):
+    img = resize_short(img, target_size=256)
+    img = crop_image(img, target_size=DATA_DIM, center=True)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def reader(images=None, paths=None):
+    """
+    Preprocess to yield image.
+
+    Args:
+        images (list[numpy.ndarray]): images data, shape of each is [H, W, C].
+        paths (list[str]): paths to images.
+
+    Yield:
+        each (collections.OrderedDict): info of original image, preprocessed image.
+    """
+    component = list()
+    if paths:
+        for im_path in paths:
+            each = OrderedDict()
+            assert os.path.isfile(
+                im_path), "The {} isn't a valid file path.".format(im_path)
+            each['org_im_path'] = im_path
+            each['org_im'] = Image.open(im_path)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+    if images is not None:
+        assert type(images), "images is a list."
+        for im in images:
+            each = OrderedDict()
+            each['org_im'] = Image.fromarray(im[:, :, ::-1])
+            each['org_im_path'] = 'ndarray_time={}'.format(
+                round(time.time(), 6) * 1e6)
+            each['org_im_width'], each['org_im_height'] = each['org_im'].size
+            component.append(each)
+
+    for element in component:
+        element['image'] = process_image(element['org_im'])
+        yield element
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/efficientnet.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/efficientnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..7024c8adb1804e2c4fe237610dee2e98231e50f0
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/efficientnet.py
@@ -0,0 +1,623 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import re
+import math
+import copy
+
+import paddle.fluid as fluid
+from efficientnetb7_imagenet.layers import conv2d, init_batch_norm_layer, init_fc_layer
+
+__all__ = [
+    'EfficientNet', 'EfficientNetB0_small', 'EfficientNetB0', 'EfficientNetB1',
+    'EfficientNetB2', 'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5',
+    'EfficientNetB6', 'EfficientNetB7'
+]
+
+GlobalParams = collections.namedtuple('GlobalParams', [
+    'batch_norm_momentum',
+    'batch_norm_epsilon',
+    'dropout_rate',
+    'num_classes',
+    'width_coefficient',
+    'depth_coefficient',
+    'depth_divisor',
+    'min_depth',
+    'drop_connect_rate',
+])
+
+BlockArgs = collections.namedtuple('BlockArgs', [
+    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio'
+])
+
+GlobalParams.__new__.__defaults__ = (None, ) * len(GlobalParams._fields)
+BlockArgs.__new__.__defaults__ = (None, ) * len(BlockArgs._fields)
+
+
+def efficientnet_params(model_name):
+    """ Map EfficientNet model name to parameter coefficients. """
+    params_dict = {
+        # Coefficients:   width,depth,resolution,dropout
+        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
+        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
+        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
+        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
+        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
+        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
+        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
+        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
+    }
+    return params_dict[model_name]
+
+
+def efficientnet(width_coefficient=None,
+                 depth_coefficient=None,
+                 dropout_rate=0.2,
+                 drop_connect_rate=0.2):
+    """ Get block arguments according to parameter and coefficients. """
+    blocks_args = [
+        'r1_k3_s11_e1_i32_o16_se0.25',
+        'r2_k3_s22_e6_i16_o24_se0.25',
+        'r2_k5_s22_e6_i24_o40_se0.25',
+        'r3_k3_s22_e6_i40_o80_se0.25',
+        'r3_k5_s11_e6_i80_o112_se0.25',
+        'r4_k5_s22_e6_i112_o192_se0.25',
+        'r1_k3_s11_e6_i192_o320_se0.25',
+    ]
+    blocks_args = BlockDecoder.decode(blocks_args)
+
+    global_params = GlobalParams(
+        batch_norm_momentum=0.99,
+        batch_norm_epsilon=1e-3,
+        dropout_rate=dropout_rate,
+        drop_connect_rate=drop_connect_rate,
+        num_classes=1000,
+        width_coefficient=width_coefficient,
+        depth_coefficient=depth_coefficient,
+        depth_divisor=8,
+        min_depth=None)
+
+    return blocks_args, global_params
+
+
+def get_model_params(model_name, override_params):
+    """ Get the block args and global params for a given model """
+    if model_name.startswith('efficientnet'):
+        w, d, _, p = efficientnet_params(model_name)
+        blocks_args, global_params = efficientnet(
+            width_coefficient=w, depth_coefficient=d, dropout_rate=p)
+    else:
+        raise NotImplementedError(
+            'model name is not pre-defined: %s' % model_name)
+    if override_params:
+        global_params = global_params._replace(**override_params)
+    return blocks_args, global_params
+
+
+def round_filters(filters, global_params):
+    """ Calculate and round number of filters based on depth multiplier. """
+    multiplier = global_params.width_coefficient
+    if not multiplier:
+        return filters
+    divisor = global_params.depth_divisor
+    min_depth = global_params.min_depth
+    filters *= multiplier
+    min_depth = min_depth or divisor
+    new_filters = max(min_depth,
+                      int(filters + divisor / 2) // divisor * divisor)
+    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
+        new_filters += divisor
+    return int(new_filters)
+
+
+def round_repeats(repeats, global_params):
+    """ Round number of filters based on depth multiplier. """
+    multiplier = global_params.depth_coefficient
+    if not multiplier:
+        return repeats
+    return int(math.ceil(multiplier * repeats))
+
+
+class EfficientNet():
+    def __init__(self,
+                 name='b0',
+                 padding_type='SAME',
+                 override_params=None,
+                 is_test=False,
+                 use_se=True):
+        valid_names = ['b' + str(i) for i in range(8)]
+        assert name in valid_names, 'efficient name should be in b0~b7'
+        model_name = 'efficientnet-' + name
+        self._blocks_args, self._global_params = get_model_params(
+            model_name, override_params)
+        self._bn_mom = self._global_params.batch_norm_momentum
+        self._bn_eps = self._global_params.batch_norm_epsilon
+        self.padding_type = padding_type
+        self.use_se = use_se
+
+    def net(self, input, class_dim=1000, is_test=False):
+
+        conv = self.extract_features(input, is_test=is_test)
+
+        out_channels = round_filters(1280, self._global_params)
+        conv = self.conv_bn_layer(
+            conv,
+            num_filters=out_channels,
+            filter_size=1,
+            bn_act='swish',
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            padding_type=self.padding_type,
+            name='',
+            conv_name='_conv_head',
+            bn_name='_bn1')
+
+        pool = fluid.layers.pool2d(
+            input=conv, pool_type='avg', global_pooling=True, use_cudnn=False)
+
+        if not is_test and self._global_params.dropout_rate:
+            pool = fluid.layers.dropout(
+                pool,
+                self._global_params.dropout_rate,
+                dropout_implementation='upscale_in_train')
+
+        param_attr, bias_attr = init_fc_layer(class_dim, '_fc')
+        out = fluid.layers.fc(
+            pool,
+            class_dim,
+            name='_fc',
+            param_attr=param_attr,
+            bias_attr=bias_attr)
+        return out, pool
+
+    def _drop_connect(self, inputs, prob, is_test):
+        if is_test:
+            return inputs
+        keep_prob = 1.0 - prob
+        random_tensor = keep_prob + fluid.layers.uniform_random_batch_size_like(
+            inputs, [-1, 1, 1, 1], min=0., max=1.)
+        binary_tensor = fluid.layers.floor(random_tensor)
+        output = inputs / keep_prob * binary_tensor
+        return output
+
+    def _expand_conv_norm(self, inputs, block_args, is_test, name=None):
+        # Expansion phase
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        if block_args.expand_ratio != 1:
+            conv = self.conv_bn_layer(
+                inputs,
+                num_filters=oup,
+                filter_size=1,
+                bn_act=None,
+                bn_mom=self._bn_mom,
+                bn_eps=self._bn_eps,
+                padding_type=self.padding_type,
+                name=name,
+                conv_name=name + '_expand_conv',
+                bn_name='_bn0')
+
+        return conv
+
+    def _depthwise_conv_norm(self, inputs, block_args, is_test, name=None):
+        k = block_args.kernel_size
+        s = block_args.stride
+        if isinstance(s, list) or isinstance(s, tuple):
+            s = s[0]
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=oup,
+            filter_size=k,
+            stride=s,
+            num_groups=oup,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            use_cudnn=False,
+            conv_name=name + '_depthwise_conv',
+            bn_name='_bn1')
+
+        return conv
+
+    def _project_conv_norm(self, inputs, block_args, is_test, name=None):
+        final_oup = block_args.output_filters
+        conv = self.conv_bn_layer(
+            inputs,
+            num_filters=final_oup,
+            filter_size=1,
+            bn_act=None,
+            padding_type=self.padding_type,
+            bn_mom=self._bn_mom,
+            bn_eps=self._bn_eps,
+            name=name,
+            conv_name=name + '_project_conv',
+            bn_name='_bn2')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride=1,
+                      num_groups=1,
+                      padding_type="SAME",
+                      conv_act=None,
+                      bn_act='swish',
+                      use_cudnn=True,
+                      use_bn=True,
+                      bn_mom=0.9,
+                      bn_eps=1e-05,
+                      use_bias=False,
+                      name=None,
+                      conv_name=None,
+                      bn_name=None):
+        conv = conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            groups=num_groups,
+            act=conv_act,
+            padding_type=padding_type,
+            use_cudnn=use_cudnn,
+            name=conv_name,
+            use_bias=use_bias)
+
+        if use_bn == False:
+            return conv
+        else:
+            bn_name = name + bn_name
+            param_attr, bias_attr = init_batch_norm_layer(bn_name)
+            return fluid.layers.batch_norm(
+                input=conv,
+                act=bn_act,
+                momentum=bn_mom,
+                epsilon=bn_eps,
+                name=bn_name,
+                moving_mean_name=bn_name + '_mean',
+                moving_variance_name=bn_name + '_variance',
+                param_attr=param_attr,
+                bias_attr=bias_attr)
+
+    def _conv_stem_norm(self, inputs, is_test):
+        out_channels = round_filters(32, self._global_params)
+        bn = self.conv_bn_layer(
+            inputs,
+            num_filters=out_channels,
+            filter_size=3,
+            stride=2,
+            bn_act=None,
+            bn_mom=self._bn_mom,
+            padding_type=self.padding_type,
+            bn_eps=self._bn_eps,
+            name='',
+            conv_name='_conv_stem',
+            bn_name='_bn0')
+
+        return bn
+
+    def mb_conv_block(self,
+                      inputs,
+                      block_args,
+                      is_test=False,
+                      drop_connect_rate=None,
+                      name=None):
+        # Expansion and Depthwise Convolution
+        oup = block_args.input_filters * block_args.expand_ratio  # number of output channels
+        has_se = self.use_se and (block_args.se_ratio is
+                                  not None) and (0 < block_args.se_ratio <= 1)
+        id_skip = block_args.id_skip  # skip connection and drop connect
+        conv = inputs
+        if block_args.expand_ratio != 1:
+            conv = fluid.layers.swish(
+                self._expand_conv_norm(conv, block_args, is_test, name))
+
+        conv = fluid.layers.swish(
+            self._depthwise_conv_norm(conv, block_args, is_test, name))
+
+        # Squeeze and Excitation
+        if has_se:
+            num_squeezed_channels = max(
+                1, int(block_args.input_filters * block_args.se_ratio))
+            conv = self.se_block(conv, num_squeezed_channels, oup, name)
+
+        conv = self._project_conv_norm(conv, block_args, is_test, name)
+
+        # Skip connection and drop connect
+        input_filters, output_filters = block_args.input_filters, block_args.output_filters
+        if id_skip and block_args.stride == 1 and input_filters == output_filters:
+            if drop_connect_rate:
+                conv = self._drop_connect(conv, drop_connect_rate, is_test)
+            conv = fluid.layers.elementwise_add(conv, inputs)
+
+        return conv
+
+    def se_block(self, inputs, num_squeezed_channels, oup, name):
+        x_squeezed = fluid.layers.pool2d(
+            input=inputs, pool_type='avg', global_pooling=True, use_cudnn=False)
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=num_squeezed_channels,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            act='swish',
+            name=name + '_se_reduce')
+        x_squeezed = conv2d(
+            x_squeezed,
+            num_filters=oup,
+            filter_size=1,
+            use_bias=True,
+            padding_type=self.padding_type,
+            name=name + '_se_expand')
+        se_out = inputs * fluid.layers.sigmoid(x_squeezed)
+        return se_out
+
+    def extract_features(self, inputs, is_test):
+        """ Returns output of the final convolution layer """
+
+        conv = fluid.layers.swish(self._conv_stem_norm(inputs, is_test=is_test))
+
+        block_args_copy = copy.deepcopy(self._blocks_args)
+        idx = 0
+        block_size = 0
+        for block_arg in block_args_copy:
+            block_arg = block_arg._replace(
+                input_filters=round_filters(block_arg.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_arg.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_arg.num_repeat,
+                                         self._global_params))
+            block_size += 1
+            for _ in range(block_arg.num_repeat - 1):
+                block_size += 1
+
+        for block_args in self._blocks_args:
+
+            # Update block input and output filters based on depth multiplier.
+            block_args = block_args._replace(
+                input_filters=round_filters(block_args.input_filters,
+                                            self._global_params),
+                output_filters=round_filters(block_args.output_filters,
+                                             self._global_params),
+                num_repeat=round_repeats(block_args.num_repeat,
+                                         self._global_params))
+
+            # The first block needs to take care of stride and filter size increase.
+            drop_connect_rate = self._global_params.drop_connect_rate
+            if drop_connect_rate:
+                drop_connect_rate *= float(idx) / block_size
+            conv = self.mb_conv_block(conv, block_args, is_test,
+                                      drop_connect_rate,
+                                      '_blocks.' + str(idx) + '.')
+
+            idx += 1
+            if block_args.num_repeat > 1:
+                block_args = block_args._replace(
+                    input_filters=block_args.output_filters, stride=1)
+            for _ in range(block_args.num_repeat - 1):
+                drop_connect_rate = self._global_params.drop_connect_rate
+                if drop_connect_rate:
+                    drop_connect_rate *= float(idx) / block_size
+                conv = self.mb_conv_block(conv, block_args, is_test,
+                                          drop_connect_rate,
+                                          '_blocks.' + str(idx) + '.')
+                idx += 1
+
+        return conv
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+
+class BlockDecoder(object):
+    """ Block Decoder for readability, straight from the official TensorFlow repository """
+
+    @staticmethod
+    def _decode_block_string(block_string):
+        """ Gets a block through a string notation of arguments. """
+        assert isinstance(block_string, str)
+
+        ops = block_string.split('_')
+        options = {}
+        for op in ops:
+            splits = re.split(r'(\d.*)', op)
+            if len(splits) >= 2:
+                key, value = splits[:2]
+                options[key] = value
+
+        # Check stride
+        assert (('s' in options and len(options['s']) == 1) or
+                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
+
+        return BlockArgs(
+            kernel_size=int(options['k']),
+            num_repeat=int(options['r']),
+            input_filters=int(options['i']),
+            output_filters=int(options['o']),
+            expand_ratio=int(options['e']),
+            id_skip=('noskip' not in block_string),
+            se_ratio=float(options['se']) if 'se' in options else None,
+            stride=[int(options['s'][0])])
+
+    @staticmethod
+    def _encode_block_string(block):
+        """Encodes a block to a string."""
+        args = [
+            'r%d' % block.num_repeat,
+            'k%d' % block.kernel_size,
+            's%d%d' % (block.strides[0], block.strides[1]),
+            'e%s' % block.expand_ratio,
+            'i%d' % block.input_filters,
+            'o%d' % block.output_filters
+        ]
+        if 0 < block.se_ratio <= 1:
+            args.append('se%s' % block.se_ratio)
+        if block.id_skip is False:
+            args.append('noskip')
+        return '_'.join(args)
+
+    @staticmethod
+    def decode(string_list):
+        """
+        Decodes a list of string notations to specify blocks inside the network.
+        :param string_list: a list of strings, each string is a notation of block
+        :return: a list of BlockArgs namedtuples of block args
+        """
+        assert isinstance(string_list, list)
+        blocks_args = []
+        for block_string in string_list:
+            blocks_args.append(BlockDecoder._decode_block_string(block_string))
+        return blocks_args
+
+    @staticmethod
+    def encode(blocks_args):
+        """
+        Encodes a list of BlockArgs to a list of strings.
+        :param blocks_args: a list of BlockArgs namedtuples of block args
+        :return: a list of strings, each string is a notation of block
+        """
+        block_strings = []
+        for block in blocks_args:
+            block_strings.append(BlockDecoder._encode_block_string(block))
+        return block_strings
+
+
+def EfficientNetB0_small(is_test=False,
+                         padding_type='SAME',
+                         override_params=None,
+                         use_se=False):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB0(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b0',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB1(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b1',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB2(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b2',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB3(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b3',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB4(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b4',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB5(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b5',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB6(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b6',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
+
+
+def EfficientNetB7(is_test=False,
+                   padding_type='SAME',
+                   override_params=None,
+                   use_se=True):
+    model = EfficientNet(
+        name='b7',
+        is_test=is_test,
+        padding_type=padding_type,
+        override_params=override_params,
+        use_se=use_se)
+    return model
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/label_list.txt b/hub_module/modules/image/classification/efficientnetb7_imagenet/label_list.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a509c007481d301e524e7b3c97561132dbfcc765
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/label_list.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/layers.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f792b577c4d89bbf5191950d9e29628d9b72ba
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/layers.py
@@ -0,0 +1,248 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import warnings
+
+import paddle.fluid as fluid
+
+
+def initial_type(name,
+                 input,
+                 op_type,
+                 fan_out,
+                 init="google",
+                 use_bias=False,
+                 filter_size=0,
+                 stddev=0.02):
+    if init == "kaiming":
+        if op_type == 'conv':
+            fan_in = input.shape[1] * filter_size * filter_size
+        elif op_type == 'deconv':
+            fan_in = fan_out * filter_size * filter_size
+        else:
+            if len(input.shape) > 2:
+                fan_in = input.shape[1] * input.shape[2] * input.shape[3]
+            else:
+                fan_in = input.shape[1]
+        bound = 1 / math.sqrt(fan_in)
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + '_offset',
+                initializer=fluid.initializer.Uniform(low=-bound, high=bound))
+        else:
+            bias_attr = False
+    elif init == 'google':
+        n = filter_size * filter_size * fan_out
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=math.sqrt(2.0 / n)))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+
+    else:
+        param_attr = fluid.ParamAttr(
+            name=name + "_weights",
+            initializer=fluid.initializer.NormalInitializer(
+                loc=0.0, scale=stddev))
+        if use_bias == True:
+            bias_attr = fluid.ParamAttr(
+                name=name + "_offset",
+                initializer=fluid.initializer.Constant(0.0))
+        else:
+            bias_attr = False
+    return param_attr, bias_attr
+
+
+def cal_padding(img_size, stride, filter_size, dilation=1):
+    """Calculate padding size."""
+    if img_size % stride == 0:
+        out_size = max(filter_size - stride, 0)
+    else:
+        out_size = max(filter_size - (img_size % stride), 0)
+    return out_size // 2, out_size - out_size // 2
+
+
+def init_batch_norm_layer(name="batch_norm"):
+    param_attr = fluid.ParamAttr(
+        name=name + '_scale', initializer=fluid.initializer.Constant(1.0))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def init_fc_layer(fout, name='fc'):
+    n = fout  # fan-out
+    init_range = 1.0 / math.sqrt(n)
+
+    param_attr = fluid.ParamAttr(
+        name=name + '_weights',
+        initializer=fluid.initializer.UniformInitializer(
+            low=-init_range, high=init_range))
+    bias_attr = fluid.ParamAttr(
+        name=name + '_offset',
+        initializer=fluid.initializer.Constant(value=0.0))
+    return param_attr, bias_attr
+
+
+def norm_layer(input, norm_type='batch_norm', name=None):
+    if norm_type == 'batch_norm':
+        param_attr = fluid.ParamAttr(
+            name=name + '_weights', initializer=fluid.initializer.Constant(1.0))
+        bias_attr = fluid.ParamAttr(
+            name=name + '_offset',
+            initializer=fluid.initializer.Constant(value=0.0))
+        return fluid.layers.batch_norm(
+            input,
+            param_attr=param_attr,
+            bias_attr=bias_attr,
+            moving_mean_name=name + '_mean',
+            moving_variance_name=name + '_variance')
+
+    elif norm_type == 'instance_norm':
+        helper = fluid.layer_helper.LayerHelper("instance_norm", **locals())
+        dtype = helper.input_dtype()
+        epsilon = 1e-5
+        mean = fluid.layers.reduce_mean(input, dim=[2, 3], keep_dim=True)
+        var = fluid.layers.reduce_mean(
+            fluid.layers.square(input - mean), dim=[2, 3], keep_dim=True)
+        if name is not None:
+            scale_name = name + "_scale"
+            offset_name = name + "_offset"
+        scale_param = fluid.ParamAttr(
+            name=scale_name,
+            initializer=fluid.initializer.Constant(1.0),
+            trainable=True)
+        offset_param = fluid.ParamAttr(
+            name=offset_name,
+            initializer=fluid.initializer.Constant(0.0),
+            trainable=True)
+        scale = helper.create_parameter(
+            attr=scale_param, shape=input.shape[1:2], dtype=dtype)
+        offset = helper.create_parameter(
+            attr=offset_param, shape=input.shape[1:2], dtype=dtype)
+
+        tmp = fluid.layers.elementwise_mul(x=(input - mean), y=scale, axis=1)
+        tmp = tmp / fluid.layers.sqrt(var + epsilon)
+        tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
+        return tmp
+    else:
+        raise NotImplementedError("norm tyoe: [%s] is not support" % norm_type)
+
+
+def conv2d(input,
+           num_filters=64,
+           filter_size=7,
+           stride=1,
+           stddev=0.02,
+           padding=0,
+           groups=None,
+           name="conv2d",
+           norm=None,
+           act=None,
+           relufactor=0.0,
+           use_bias=False,
+           padding_type=None,
+           initial="normal",
+           use_cudnn=True):
+
+    if padding != 0 and padding_type != None:
+        warnings.warn(
+            'padding value and padding type are set in the same time, and the final padding width and padding height are computed by padding_type'
+        )
+
+    param_attr, bias_attr = initial_type(
+        name=name,
+        input=input,
+        op_type='conv',
+        fan_out=num_filters,
+        init=initial,
+        use_bias=use_bias,
+        filter_size=filter_size,
+        stddev=stddev)
+
+    def get_padding(filter_size, stride=1, dilation=1):
+        padding = ((stride - 1) + dilation * (filter_size - 1)) // 2
+        return padding
+
+    need_crop = False
+    if padding_type == "SAME":
+        top_padding, bottom_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        left_padding, right_padding = cal_padding(input.shape[2], stride,
+                                                  filter_size)
+        height_padding = bottom_padding
+        width_padding = right_padding
+        if top_padding != bottom_padding or left_padding != right_padding:
+            height_padding = top_padding + stride
+            width_padding = left_padding + stride
+            need_crop = True
+        padding = [height_padding, width_padding]
+    elif padding_type == "VALID":
+        height_padding = 0
+        width_padding = 0
+        padding = [height_padding, width_padding]
+    elif padding_type == "DYNAMIC":
+        padding = get_padding(filter_size, stride)
+    else:
+        padding = padding
+
+    conv = fluid.layers.conv2d(
+        input,
+        num_filters,
+        filter_size,
+        groups=groups,
+        name=name,
+        stride=stride,
+        padding=padding,
+        use_cudnn=use_cudnn,
+        param_attr=param_attr,
+        bias_attr=bias_attr)
+
+    if need_crop:
+        conv = conv[:, :, 1:, 1:]
+
+    if norm is not None:
+        conv = norm_layer(input=conv, norm_type=norm, name=name + "_norm")
+    if act == 'relu':
+        conv = fluid.layers.relu(conv, name=name + '_relu')
+    elif act == 'leaky_relu':
+        conv = fluid.layers.leaky_relu(
+            conv, alpha=relufactor, name=name + '_leaky_relu')
+    elif act == 'tanh':
+        conv = fluid.layers.tanh(conv, name=name + '_tanh')
+    elif act == 'sigmoid':
+        conv = fluid.layers.sigmoid(conv, name=name + '_sigmoid')
+    elif act == 'swish':
+        conv = fluid.layers.swish(conv, name=name + '_swish')
+    elif act == None:
+        conv = conv
+    else:
+        raise NotImplementedError("activation: [%s] is not support" % act)
+
+    return conv
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/module.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..93432d42b04e0e718b508e9c23f58e3046299099
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/module.py
@@ -0,0 +1,324 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+
+import ast
+import argparse
+import os
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.module.module import moduleinfo, runnable, serving
+from paddlehub.common.paddle_helper import add_vars_prefix
+
+from efficientnetb7_imagenet.processor import postprocess, base64_to_cv2
+from efficientnetb7_imagenet.data_feed import reader
+from efficientnetb7_imagenet.efficientnet import EfficientNetB7
+
+
+@moduleinfo(
+    name="efficientnetb7_imagenet",
+    type="CV/image_classification",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com",
+    summary=
+    "EfficientNetB7 is a image classfication model, this module is trained with imagenet datasets.",
+    version="1.1.0")
+class EfficientNetB7ImageNet(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "efficientnetb7_imagenet_infer_model")
+        label_file = os.path.join(self.directory, "label_list.txt")
+        with open(label_file, 'r', encoding='utf-8') as file:
+            self.label_list = file.read().split("\n")[:-1]
+        self.classification = self.classify
+        self._set_config()
+
+    def get_expected_image_width(self):
+        return 224
+
+    def get_expected_image_height(self):
+        return 224
+
+    def get_pretrained_images_mean(self):
+        im_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3)
+        return im_mean
+
+    def get_pretrained_images_std(self):
+        im_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3)
+        return im_std
+
+    def _set_config(self):
+        """
+        predictor config setting
+        """
+        cpu_config = AnalysisConfig(self.default_pretrained_model_path)
+        cpu_config.disable_glog_info()
+        cpu_config.disable_gpu()
+        self.cpu_predictor = create_paddle_predictor(cpu_config)
+
+        try:
+            _places = os.environ["CUDA_VISIBLE_DEVICES"]
+            int(_places[0])
+            use_gpu = True
+        except:
+            use_gpu = False
+        if use_gpu:
+            gpu_config = AnalysisConfig(self.default_pretrained_model_path)
+            gpu_config.disable_glog_info()
+            gpu_config.enable_use_gpu(
+                memory_pool_init_size_mb=1000, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                trainable=True,
+                pretrained=True,
+                override_params=None,
+                phase='train'):
+        """context for transfer learning.
+
+        Args:
+            trainable (bool): Set parameters in program to be trainable.
+            pretrained (bool) : Whether to load pretrained model.
+
+        Returns:
+            inputs (dict): key is 'image', corresponding vaule is image tensor.
+            outputs (dict): key is :
+                'classification', corresponding value is the result of classification.
+                'feature_map', corresponding value is the result of the layer before the fully connected layer.
+            context_prog (fluid.Program): program for transfer learning.
+        """
+        if phase in ["dev", "test", "predict", "eval"]:
+            is_test = False
+        elif phase in ["train"]:
+            is_test = True
+        else:
+            raise ValueError(
+                "Phase %s is error, which must be one of train, dev, test, eval and predict."
+                % phase)
+
+        context_prog = fluid.Program()
+        startup_prog = fluid.Program()
+        with fluid.program_guard(context_prog, startup_prog):
+            with fluid.unique_name.guard():
+                image = fluid.layers.data(
+                    name="image", shape=[3, 224, 224], dtype="float32")
+                efficientnet_b7 = EfficientNetB7(
+                    override_params=override_params)
+                output, feature_map = efficientnet_b7.net(
+                    input=image,
+                    class_dim=len(self.label_list),
+                    is_test=is_test)
+
+                name_prefix = '@HUB_{}@'.format(self.name)
+                inputs = {'image': name_prefix + image.name}
+                outputs = {
+                    'classification': name_prefix + output.name,
+                    'feature_map': name_prefix + feature_map.name
+                }
+                add_vars_prefix(context_prog, name_prefix)
+                add_vars_prefix(startup_prog, name_prefix)
+                global_vars = context_prog.global_block().vars
+                inputs = {
+                    key: global_vars[value]
+                    for key, value in inputs.items()
+                }
+                outputs = {
+                    key: global_vars[value]
+                    for key, value in outputs.items()
+                }
+
+                place = fluid.CPUPlace()
+                exe = fluid.Executor(place)
+                # pretrained
+                if pretrained:
+
+                    def _if_exist(var):
+                        b = os.path.exists(
+                            os.path.join(self.default_pretrained_model_path,
+                                         var.name))
+                        return b
+
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        context_prog,
+                        predicate=_if_exist)
+                else:
+                    exe.run(startup_prog)
+                # trainable
+                for param in context_prog.global_block().iter_parameters():
+                    param.trainable = trainable
+        return inputs, outputs, context_prog
+
+    def classify(self,
+                 images=None,
+                 paths=None,
+                 batch_size=1,
+                 use_gpu=False,
+                 top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (list[numpy.ndarray]): data of images, shape of each is [H, W, C], color space must be BGR.
+            paths (list[str]): The paths of images.
+            batch_size (int): batch size.
+            use_gpu (bool): Whether to use gpu.
+            top_k (int): Return top k results.
+
+        Returns:
+            res (list[dict]): The classfication results.
+        """
+        if use_gpu:
+            try:
+                _places = os.environ["CUDA_VISIBLE_DEVICES"]
+                int(_places[0])
+            except:
+                raise RuntimeError(
+                    "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
+                )
+
+        all_data = list()
+        for yield_data in reader(images, paths):
+            all_data.append(yield_data)
+
+        total_num = len(all_data)
+        loop_num = int(np.ceil(total_num / batch_size))
+
+        res = list()
+        for iter_id in range(loop_num):
+            batch_data = list()
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_data[handle_id + image_id])
+                except:
+                    pass
+            # feed batch image
+            batch_image = np.array([data['image'] for data in batch_data])
+            batch_image = PaddleTensor(batch_image.copy())
+            predictor_output = self.gpu_predictor.run([
+                batch_image
+            ]) if use_gpu else self.cpu_predictor.run([batch_image])
+            out = postprocess(
+                data_out=predictor_output[0].as_ndarray(),
+                label_list=self.label_list,
+                top_k=top_k)
+            res += out
+        return res
+
+    def save_inference_model(self,
+                             dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True):
+        if combined:
+            model_filename = "__model__" if not model_filename else model_filename
+            params_filename = "__params__" if not params_filename else params_filename
+        place = fluid.CPUPlace()
+        exe = fluid.Executor(place)
+
+        program, feeded_var_names, target_vars = fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
+
+        fluid.io.save_inference_model(
+            dirname=dirname,
+            main_program=program,
+            executor=exe,
+            feeded_var_names=feeded_var_names,
+            target_vars=target_vars,
+            model_filename=model_filename,
+            params_filename=params_filename)
+
+    @serving
+    def serving_method(self, images, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        results = self.classify(images=images_decode, **kwargs)
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.classify(
+            paths=[args.input_path],
+            batch_size=args.batch_size,
+            use_gpu=args.use_gpu)
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+        self.arg_config_group.add_argument(
+            '--use_gpu',
+            type=ast.literal_eval,
+            default=False,
+            help="whether use GPU or not.")
+        self.arg_config_group.add_argument(
+            '--batch_size',
+            type=ast.literal_eval,
+            default=1,
+            help="batch size.")
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=ast.literal_eval,
+            default=1,
+            help="Return top k results.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+
+if __name__ == '__main__':
+    b7 = EfficientNetB7ImageNet()
+    b7.context()
+    import cv2
+    test_image = [cv2.imread('dog.jpeg')]
+    res = b7.classification(images=test_image)
+    print(res)
+    res = b7.classification(paths=['dog.jpeg'])
+    print(res)
+    res = b7.classification(images=test_image)
+    print(res)
+    res = b7.classify(images=test_image)
+    print(res)
diff --git a/hub_module/modules/image/classification/efficientnetb7_imagenet/processor.py b/hub_module/modules/image/classification/efficientnetb7_imagenet/processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..12ccc9b286dad473e2ff02de86dd60eac928db5b
--- /dev/null
+++ b/hub_module/modules/image/classification/efficientnetb7_imagenet/processor.py
@@ -0,0 +1,69 @@
+# -*- coding:utf-8 -*-
+# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import base64
+import cv2
+import os
+
+import numpy as np
+
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+
+def softmax(x):
+    orig_shape = x.shape
+    if len(x.shape) > 1:
+        tmp = np.max(x, axis=1)
+        x -= tmp.reshape((x.shape[0], 1))
+        x = np.exp(x)
+        tmp = np.sum(x, axis=1)
+        x /= tmp.reshape((x.shape[0], 1))
+    else:
+        tmp = np.max(x)
+        x -= tmp
+        x = np.exp(x)
+        tmp = np.sum(x)
+        x /= tmp
+    return x
+
+
+def postprocess(data_out, label_list, top_k):
+    """
+    Postprocess output of network, one image at a time.
+
+    Args:
+        data_out (numpy.ndarray): output data of network.
+        label_list (list): list of label.
+        top_k (int): Return top k results.
+    """
+    output = []
+    for result in data_out:
+        result_i = softmax(result)
+        output_i = {}
+        indexs = np.argsort(result_i)[::-1][0:top_k]
+        for index in indexs:
+            label = label_list[index].split(',')[0]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output
diff --git a/hub_module/scripts/configs/efficientnetb0_imagenet.yml b/hub_module/scripts/configs/efficientnetb0_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..87e18ea52b7c0a3c045b32b901e4910aeba4bdd7
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb0_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb0_imagenet
+dir: "modules/image/classification/efficientnetb0_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb0_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb0_small_imagenet.yml b/hub_module/scripts/configs/efficientnetb0_small_imagenet.yml
index f2d2d5f0a12b05d1add46632843c74ae627bf2a8..402cc05559730a73f6225acbf0ba567e190ecd87 100644
--- a/hub_module/scripts/configs/efficientnetb0_small_imagenet.yml
+++ b/hub_module/scripts/configs/efficientnetb0_small_imagenet.yml
@@ -4,6 +4,6 @@ exclude:
   - README.md
 resources:
   -
-    url: https://bj.bcebos.com/paddlehub/hub_dev/efficientnetb0_small_imagenet_model.tar.gz
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb0_small_imagenet_infer_model.tar.gz
     dest: .
     uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb1_imagenet.yml b/hub_module/scripts/configs/efficientnetb1_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..01744d8940ab8847374b6cf11eb85f93b3622cb5
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb1_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb1_imagenet
+dir: "modules/image/classification/efficientnetb1_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb1_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb2_imagenet.yml b/hub_module/scripts/configs/efficientnetb2_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a15b4b8481a4d546bd4c83c46ffef3a3549e8f90
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb2_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb2_imagenet
+dir: "modules/image/classification/efficientnetb2_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb2_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb3_imagenet.yml b/hub_module/scripts/configs/efficientnetb3_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..321dc4b2ac098b64d07d93c7b160f7a012a5d73c
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb3_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb3_imagenet
+dir: "modules/image/classification/efficientnetb3_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb3_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb4_imagenet.yml b/hub_module/scripts/configs/efficientnetb4_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..82f2590de1399341b59ddff097324e305e0e1430
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb4_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb4_imagenet
+dir: "modules/image/classification/efficientnetb4_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb4_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb5_imagenet.yml b/hub_module/scripts/configs/efficientnetb5_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8aac6b4b250331dbd59badfac31c66a8fa01b12d
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb5_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb5_imagenet
+dir: "modules/image/classification/efficientnetb5_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb5_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb6_imagenet.yml b/hub_module/scripts/configs/efficientnetb6_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a4482769aa187d4cbe138e8cc52f5f968ce39774
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb6_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb6_imagenet
+dir: "modules/image/classification/efficientnetb6_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb6_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/scripts/configs/efficientnetb7_imagenet.yml b/hub_module/scripts/configs/efficientnetb7_imagenet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6931c9fd9fcd7d0a856a8d01eccf0c605b98e64a
--- /dev/null
+++ b/hub_module/scripts/configs/efficientnetb7_imagenet.yml
@@ -0,0 +1,9 @@
+name: efficientnetb7_imagenet
+dir: "modules/image/classification/efficientnetb7_imagenet"
+exclude:
+  - README.md
+resources:
+  -
+    url: https://bj.bcebos.com/paddlehub/model/image/classification/efficientnetb7_imagenet_infer_model.tar.gz
+    dest: .
+    uncompress: True
diff --git a/hub_module/tests/unittests/test_efficientnetb0_imagenet.py b/hub_module/tests/unittests/test_efficientnetb0_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..abfa3f7f9e00794aba0913c64f7ebaf79ff430b1
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb0_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB0TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb0_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb0_small_imagenet.py b/hub_module/tests/unittests/test_efficientnetb0_small_imagenet.py
index 78acef129b85bd71c5e7832cf84af7777dc44cf0..3713b907a6aa8ddf40b7367037ea00e7ef4c929b 100644
--- a/hub_module/tests/unittests/test_efficientnetb0_small_imagenet.py
+++ b/hub_module/tests/unittests/test_efficientnetb0_small_imagenet.py
@@ -1,90 +1,64 @@
-# coding=utf-8
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 import os
-import unittest
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
 
 import cv2
 import numpy as np
-import paddle.fluid as fluid
 import paddlehub as hub
 
-pic_dir = '../image_dataset/classification/animals/'
-
-
-class TestEfficientnetB0SmallImagenet(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        """Prepare the environment once before execution of all tests.\n"""
-        self.classifier = hub.Module(name="efficientnetb0_small_imagenet")
-
-    @classmethod
-    def tearDownClass(self):
-        """clean up the environment after the execution of all tests.\n"""
-        self.classifier = None
 
+class EfficientNetB0SmallTestCase(TestCase):
     def setUp(self):
-        "Call setUp() to prepare environment\n"
-        self.test_prog = fluid.Program()
-
-    def tearDown(self):
-        "Call tearDown to restore environment.\n"
-        self.test_prog = None
+        self.module = hub.Module(name='efficientnetb0_small_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
 
-    def test_context(self):
-        self.classifier.context(pretrained=True)
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
 
-    def test_single_pic(self):
-        with fluid.program_guard(self.test_prog):
-            pics_path_list = [
-                os.path.join(pic_dir, f) for f in os.listdir(pic_dir)
-            ]
-            print('\n')
-            for pic_path in pics_path_list:
-                print(pic_path)
-                result = self.classifier.classification(
-                    paths=[pic_path], use_gpu=False)
-                print(result)
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
 
-    def test_batch(self):
-        with fluid.program_guard(self.test_prog):
-            pics_path_list = [
-                os.path.join(pic_dir, f) for f in os.listdir(pic_dir)
-            ]
-            print('\n')
-            result = self.classifier.classification(
-                paths=pics_path_list, batch_size=3, use_gpu=False, top_k=2)
-            print(result)
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
 
-    def test_ndarray(self):
-        with fluid.program_guard(self.test_prog):
-            pics_path_list = [
-                os.path.join(pic_dir, f) for f in os.listdir(pic_dir)
-            ]
-            pics_ndarray = list()
-            print('\n')
-            for pic_path in pics_path_list:
-                im = cv2.cvtColor(cv2.imread(pic_path), cv2.COLOR_BGR2RGB)
-                result = self.classifier.classification(
-                    images=[im], use_gpu=True, top_k=5)
-                print(result)
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
 
-    def test_save_inference_model(self):
-        with fluid.program_guard(self.test_prog):
-            self.classifier.save_inference_model(
-                dirname='efficientnetb0_small_imagenet_model',
-                model_filename='__model__',
-                combined=False)
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
 
 
-if __name__ == "__main__":
-    suite = unittest.TestSuite()
-    suite.addTest(TestEfficientnetB0SmallImagenet('test_context'))
-    suite.addTest(TestEfficientnetB0SmallImagenet('test_single_pic'))
-    suite.addTest(TestEfficientnetB0SmallImagenet('test_batch'))
-    suite.addTest(TestEfficientnetB0SmallImagenet('test_ndarray'))
-    suite.addTest(TestEfficientnetB0SmallImagenet('test_save_inference_model'))
-    runner = unittest.TextTestRunner(verbosity=2)
-    runner.run(suite)
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb1_imagenet.py b/hub_module/tests/unittests/test_efficientnetb1_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..7762019eb528737779fc2b268478a9f89f959100
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb1_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB1TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb1_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb2_imagenet.py b/hub_module/tests/unittests/test_efficientnetb2_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..2159f6791e3bc9244909acfb2659a43218124c24
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb2_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB2TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb2_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb3_imagenet.py b/hub_module/tests/unittests/test_efficientnetb3_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1bbce8cf01a33dd2a42c81025044c1b3e24c372
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb3_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB3TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb3_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb4_imagenet.py b/hub_module/tests/unittests/test_efficientnetb4_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..c321f39f215ef58dced3a99e188e4e6924c716ef
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb4_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB4TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb4_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb5_imagenet.py b/hub_module/tests/unittests/test_efficientnetb5_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..fab65efd843c34e4450c8f9f8ea42e22cf733b02
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb5_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB5TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb5_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb6_imagenet.py b/hub_module/tests/unittests/test_efficientnetb6_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fd407745c142995f395500cd8afa8e4b8ab91f9
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb6_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB6TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb6_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/hub_module/tests/unittests/test_efficientnetb7_imagenet.py b/hub_module/tests/unittests/test_efficientnetb7_imagenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..325b7bee35a7843826252e3ba1d308d26d48c68a
--- /dev/null
+++ b/hub_module/tests/unittests/test_efficientnetb7_imagenet.py
@@ -0,0 +1,64 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from unittest import TestCase, main
+os.environ['CUDA_VISIBLE_DEVICES'] = '1'
+
+import cv2
+import numpy as np
+import paddlehub as hub
+
+
+class EfficientNetB7TestCase(TestCase):
+    def setUp(self):
+        self.module = hub.Module(name='efficientnetb7_imagenet')
+        self.test_images = [
+            "../image_dataset/classification/animals/dog.jpeg",
+            "../image_dataset/keypoint_detection/girl2.jpg"
+        ]
+        self.true_mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3).tolist()
+        self.true_std = np.array([0.229, 0.224, 0.225]).reshape(1, 3).tolist()
+
+    def test_classifcation(self):
+        results_1 = self.module.classify(paths=self.test_images, use_gpu=True)
+        results_2 = self.module.classify(paths=self.test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_2[index].keys())
+            diff = list(res.values())[0] - list(results_2[index].values())[0]
+            self.assertTrue((diff < 1e-5))
+
+        test_images = [cv2.imread(img) for img in self.test_images]
+        results_3 = self.module.classify(images=test_images, use_gpu=False)
+        for index, res in enumerate(results_1):
+            self.assertTrue(res.keys(), results_3[index].keys())
+
+        results_4 = self.module.classify(
+            images=test_images, use_gpu=True, top_k=2)
+        for res in results_4:
+            self.assertEqual(len(res.keys()), 2)
+
+    def test_common_apis(self):
+        width = self.module.get_expected_image_width()
+        height = self.module.get_expected_image_height()
+        mean = self.module.get_pretrained_images_mean()
+        std = self.module.get_pretrained_images_std()
+
+        self.assertEqual(width, 224)
+        self.assertEqual(height, 224)
+        self.assertEqual(mean.tolist(), self.true_mean)
+        self.assertEqual(std.tolist(), self.true_std)
+
+
+if __name__ == '__main__':
+    main()