Add hub modules

hubmodule/modules/demo/README.md

+# 如何编写一个PaddleHub Module
+
+## 模型基本信息
+
+我们准备编写一个用于做情感分析的PaddleHub Module，Module的基本信息如下：
+```yaml
+name: senta_test
+version: 1.0.0
+summary: This is a PaddleHub Module. Just for test.
+author: anonymous
+author_email:
+type: nlp/sentiment_analysis
+```
+
+Module存在一个接口sentiment_classify，用于接收传入文本，并给出文本的情感倾向（正面/负面），支持python接口调用和命令行调用。
+```python
+import paddlehub as hub
+
+senta_test = hub.Module(name="senta_test")
+senta_test.sentiment_classify(texts=["这部电影太差劲了"])
+```
+```cmd
+hub run senta_test --input_text 这部电影太差劲了
+```
+
+<br/>
+
+## 策略
+
+为了示例代码简单起见，我们使用一个非常简单的情感判断策略，当输入文本中带有词表中指定单词时，则判断文本倾向为负向，否则为正向
+
+<br/>
+
+## Module创建
+
+### step 1. 创建必要的目录与文件
+
+创建一个senta_test的目录，并在senta_test目录下分别创建__init__.py、module.py、processor.py、vocab.list，其中
+
+|文件名|用途|
+|-|-|
+|\_\_init\_\_.py|空文件|
+|module.py|主模块，提供Module的实现代码|
+|processor.py|辅助模块，提供词表加载的方法|
+|vocab.list|存放词表|
+
+```cmd
+➜  tree senta_test
+senta_test/
+├── vocab.list
+├── __init__.py
+├── module.py
+└── processor.py
+```
+### step 2. 实现辅助模块processor
+
+在processor.py中实现一个load_vocab接口用于读取词表
+```python
+def load_vocab(vocab_path):
+    with open(vocab_path) as file:
+        return file.read().split()
+```
+
+### step 3. 编写Module处理代码
+
+module.py文件为Module的入口代码所在，我们需要在其中实现预测逻辑。
+
+#### step 3_1. 引入必要的头文件
+```python
+import argparse
+import os
+
+import paddlehub as hub
+from paddlehub.module.module import runnable, moduleinfo
+
+from senta_test.processor import load_vocab
+```
+`注意`：当引用Module中模块时，需要输入全路径，如senta_test.processor
+#### step 3_2. 定义SentaTest类
+module.py中需要有一个继承了hub.Module的类存在，该类负责实现预测逻辑，并使用moduleinfo填写基本信息。当使用hub.Module(name="senta_test")加载Module时，PaddleHub会自动创建SentaTest的对象并返回。
+```python
+@moduleinfo(
+    name="senta_test",
+    version="1.0.0",
+    summary="This is a PaddleHub Module. Just for test.",
+    author="anonymous",
+    author_email="",
+    type="nlp/sentiment_analysis",
+)
+class SentaTest(hub.Module):
+    ...
+```
+#### step 3_3. 执行必要的初始化
+```python
+def _initialize(self):
+    # add arg parser
+    self.parser = argparse.ArgumentParser(
+        description="Run the senta_test module.",
+        prog='hub run senta_test',
+        usage='%(prog)s',
+        add_help=True)
+    self.parser.add_argument(
+        '--input_text', type=str, default=None, help="text to predict")
+
+    # load word dict
+    vocab_path = os.path.join(self.directory, "vocab.list")
+    self.vocab = load_vocab(vocab_path)
+```
+`注意`：执行类的初始化不能使用默认的__init__接口，而是应该重载实现_initialize接口。对象默认内置了directory属性，可以直接获取到Module所在路径
+#### step 3_4. 完善预测逻辑
+```python
+def sentiment_classify(self, texts):
+    results = []
+    for text in texts:
+        sentiment = "positive"
+        for word in self.vocab:
+            if word in text:
+                sentiment = "negative"
+                break
+        results.append({"text":text, "sentiment":sentiment})
+
+    return results
+```
+#### step 3_5. 支持命令行调用
+如果希望Module可以支持命令行调用，则需要提供一个经过runnable修饰的接口，接口负责解析传入数据并进行预测，将结果返回。
+
+如果不需要提供命令行预测功能，则可以不实现该接口，PaddleHub在用命令行执行时，会自动发现该Module不支持命令行方式，并给出提示。
+```python
+@runnable
+def run_cmd(self, argvs):
+    args = self.parser.parse_args(argvs)
+    texts = [args.input_text]
+    return self.sentiment_classify(texts)
+```
+#### step 3_6. 支持serving调用
+
+TODO
+
+### 完整代码
+
+* [module.py](./senta_test/module.py)
+
+* [processor.py](./senta_test/module.py)
+
+<br/>
+
+## 测试步骤
+
+完成Module编写后，我们可以通过以下方式测试该Module
+
+### 调用方法1
+
+将Module安装到本机中，再通过Hub.Module(name=...)加载
+```shell
+hub install senta_test
+```
+
+```python
+import paddlehub as hub
+
+senta_test = hub.Module(name="senta_test")
+senta_test.sentiment_classify(texts=["这部电影太差劲了"])
+```
+
+### 调用方法2
+
+直接通过Hub.Module(directory=...)加载
+```python
+import paddlehub as hub
+
+senta_test = hub.Module(directory="senta_test/")
+senta_test.sentiment_classify(texts=["这部电影太差劲了"])
+```
+
+### 调用方法3
+将senta_test作为路径加到环境变量中，直接加载SentaTest对象
+```shell
+export PYTHONPATH=senta_test:$PYTHONPATH
+```
+
+```python
+from senta_test.module import SentaTest
+
+SentaTest.sentiment_classify(texts=["这部电影太差劲了"])
+```
+
+### 调用方法4
+将Module安装到本机中，再通过hub run运行
+```shell
+hub install senta_test
+hub run senta_test --input_text "这部电影太差劲了"
+```

hubmodule/modules/demo/senta_test/module.py

+import argparse
+import os
+
+import paddlehub as hub
+from paddlehub.module.module import runnable, moduleinfo
+
+from senta_test.processor import load_vocab
+
+
+@moduleinfo(
+    name="senta_test",
+    version="1.0.0",
+    summary="This is a PaddleHub Module. Just for test.",
+    author="anonymous",
+    author_email="",
+    type="nlp/sentiment_analysis",
+)
+class SentaTest(hub.Module):
+    def _initialize(self):
+        # add arg parser
+        self.parser = argparse.ArgumentParser(
+            description="Run the senta_test module.",
+            prog='hub run senta_test',
+            usage='%(prog)s',
+            add_help=True)
+        self.parser.add_argument(
+            '--input_text', type=str, default=None, help="text to predict")
+
+        # load word dict
+        vocab_path = os.path.join(self.directory, "vocab.list")
+        self.vocab = load_vocab(vocab_path)
+
+    def sentiment_classify(self, texts):
+        results = []
+        for text in texts:
+            sentiment = "positive"
+            for word in self.vocab:
+                if word in text:
+                    sentiment = "negative"
+                    break
+            results.append({"text": text, "sentiment": sentiment})
+
+        return results
+
+    @runnable
+    def run_cmd(self, argvs):
+        args = self.parser.parse_args(argvs)
+        texts = [args.input_text]
+        return self.sentiment_classify(texts)

hubmodule/modules/demo/senta_test/processor.py

+def load_vocab(vocab_path):
+    with open(vocab_path) as file:
+        return file.read().split()

hubmodule/modules/demo/senta_test/vocab.list

+糟糕
+差劲
+浪费

hubmodule/modules/demo/test.py

+import paddlehub as hub
+
+senta_test = hub.Module(directory="senta_test")
+print(senta_test.sentiment_classify(["这部电影太糟糕了", "这部电影太棒了"]))

hubmodule/modules/image/classification/darknet53_imagenet/darknet.py

+# coding=utf-8
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import six
+import math
+
+from paddle import fluid
+from paddle.fluid.param_attr import ParamAttr
+from paddle.fluid.regularizer import L2Decay
+
+__all__ = ['DarkNet']
+
+
+class DarkNet(object):
+    """DarkNet, see https://pjreddie.com/darknet/yolo/
+    Args:
+        depth (int): network depth, currently only darknet 53 is supported
+        norm_type (str): normalization type, 'bn' and 'sync_bn' are supported
+        norm_decay (float): weight decay for normalization layer weights
+        get_prediction (bool): whether to get prediction
+        class_dim (int): number of class while classification
+    """
+
+    def __init__(self,
+                 depth=53,
+                 norm_type='sync_bn',
+                 norm_decay=0.,
+                 weight_prefix_name='',
+                 get_prediction=False,
+                 class_dim=1000):
+        assert depth in [53], "unsupported depth value"
+        self.depth = depth
+        self.norm_type = norm_type
+        self.norm_decay = norm_decay
+        self.depth_cfg = {53: ([1, 2, 8, 8, 4], self.basicblock)}
+        self.prefix_name = weight_prefix_name
+        self.class_dim = class_dim
+        self.get_prediction = get_prediction
+
+    def _conv_norm(self,
+                   input,
+                   ch_out,
+                   filter_size,
+                   stride,
+                   padding,
+                   act='leaky',
+                   name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=ch_out,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            act=None,
+            param_attr=ParamAttr(name=name + ".conv.weights"),
+            bias_attr=False)
+
+        bn_name = name + ".bn"
+        bn_param_attr = ParamAttr(
+            regularizer=L2Decay(float(self.norm_decay)),
+            name=bn_name + '.scale')
+        bn_bias_attr = ParamAttr(
+            regularizer=L2Decay(float(self.norm_decay)),
+            name=bn_name + '.offset')
+
+        out = fluid.layers.batch_norm(
+            input=conv,
+            act=None,
+            param_attr=bn_param_attr,
+            bias_attr=bn_bias_attr,
+            moving_mean_name=bn_name + '.mean',
+            moving_variance_name=bn_name + '.var')
+
+        # leaky relu here has `alpha` as 0.1, can not be set by
+        # `act` param in fluid.layers.batch_norm above.
+        if act == 'leaky':
+            out = fluid.layers.leaky_relu(x=out, alpha=0.1)
+
+        return out
+
+    def _downsample(self,
+                    input,
+                    ch_out,
+                    filter_size=3,
+                    stride=2,
+                    padding=1,
+                    name=None):
+        return self._conv_norm(
+            input,
+            ch_out=ch_out,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            name=name)
+
+    def basicblock(self, input, ch_out, name=None):
+        conv1 = self._conv_norm(
+            input,
+            ch_out=ch_out,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            name=name + ".0")
+        conv2 = self._conv_norm(
+            conv1,
+            ch_out=ch_out * 2,
+            filter_size=3,
+            stride=1,
+            padding=1,
+            name=name + ".1")
+        out = fluid.layers.elementwise_add(x=input, y=conv2, act=None)
+        return out
+
+    def layer_warp(self, block_func, input, ch_out, count, name=None):
+        out = block_func(input, ch_out=ch_out, name='{}.0'.format(name))
+        for j in six.moves.xrange(1, count):
+            out = block_func(out, ch_out=ch_out, name='{}.{}'.format(name, j))
+        return out
+
+    def __call__(self, input):
+        """Get the backbone of DarkNet, that is output for the 5 stages.
+
+        :param input: Variable of input image
+        :type input: Variable
+        :Returns: The last variables of each stage.
+        """
+        stages, block_func = self.depth_cfg[self.depth]
+        stages = stages[0:5]
+        conv = self._conv_norm(
+            input=input,
+            ch_out=32,
+            filter_size=3,
+            stride=1,
+            padding=1,
+            name=self.prefix_name + "yolo_input")
+        downsample_ = self._downsample(
+            input=conv,
+            ch_out=conv.shape[1] * 2,
+            name=self.prefix_name + "yolo_input.downsample")
+        blocks = []
+        for i, stage in enumerate(stages):
+            block = self.layer_warp(
+                block_func=block_func,
+                input=downsample_,
+                ch_out=32 * 2**i,
+                count=stage,
+                name=self.prefix_name + "stage.{}".format(i))
+            blocks.append(block)
+            if i < len(stages) - 1:  # do not downsaple in the last stage
+                downsample_ = self._downsample(
+                    input=block,
+                    ch_out=block.shape[1] * 2,
+                    name=self.prefix_name + "stage.{}.downsample".format(i))
+        if self.get_prediction:
+            pool = fluid.layers.pool2d(
+                input=block, pool_type='avg', global_pooling=True)
+            stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
+            out = fluid.layers.fc(
+                input=pool,
+                size=self.class_dim,
+                param_attr=ParamAttr(
+                    initializer=fluid.initializer.Uniform(-stdv, stdv),
+                    name='fc_weights'),
+                bias_attr=ParamAttr(name='fc_offset'))
+            out = fluid.layers.softmax(out)
+            return out
+        else:
+            return blocks

hubmodule/modules/image/classification/darknet53_imagenet/data_feed.py

+# coding=utf-8
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os
+from collections import OrderedDict
+
+import cv2
+import numpy as np
+from PIL import Image, ImageEnhance
+from paddle import fluid
+
+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 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def test_reader(paths=None, images=None):
+    """data generator
+    :param paths: path to images.
+    :type paths: list, each element is a str
+    :param images: data of images, [N, H, W, C]
+    :type images: numpy.ndarray
+    """
+    img_list = []
+    if paths:
+        for img_path in paths:
+            assert os.path.isfile(
+                img_path), "The {} isn't a valid file path.".format(img_path)
+            img = Image.open(img_path)
+            #img = cv2.imread(img_path)
+            img_list.append(img)
+    if images is not None:
+        for img in images:
+            img_list.append(Image.fromarray(np.uint8(img)))
+    for im in img_list:
+        im = process_image(im)
+        yield im

hubmodule/modules/image/classification/darknet53_imagenet/module.py

+import os
+import ast
+import argparse
+
+import numpy as np
+import paddle.fluid as fluid
+import paddlehub as hub
+from paddlehub.module.module import moduleinfo, runnable
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.common.paddle_helper import add_vars_prefix
+from paddlehub.io.parser import txt_parser
+
+from darknet53_imagenet.darknet import DarkNet
+from darknet53_imagenet.processor import load_label_info
+from darknet53_imagenet.data_feed import test_reader
+
+
+@moduleinfo(
+    name="darknet53_imagenet",
+    version="1.1.0",
+    type="cv/classification",
+    summary=
+    "DarkNet53 is a image classfication model trained with ImageNet-2012 dataset.",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com")
+class DarkNet53(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "darknet53_model")
+        self.label_names = load_label_info(
+            os.path.join(self.directory, "label_file.txt"))
+        self.infer_prog = None
+        self.pred_out = None
+        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=500, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                input_image=None,
+                trainable=True,
+                pretrained=True,
+                param_prefix='',
+                get_prediction=False):
+        """Distill the Head Features, so as to perform transfer learning.
+
+        :param input_image: image tensor.
+        :type input_image: <class 'paddle.fluid.framework.Variable'>
+        :param trainable: whether to set parameters trainable.
+        :type trainable: bool
+        :param pretrained: whether to load default pretrained model.
+        :type pretrained: bool
+        :param param_prefix: the prefix of parameters in yolo_head and backbone
+        :type param_prefix: str
+        :param get_prediction: whether to get prediction,
+            if True, outputs is {'bbox_out': bbox_out},
+            if False, outputs is {'head_features': head_features}.
+        :type get_prediction: bool
+        """
+        context_prog = input_image.block.program if input_image else fluid.Program(
+        )
+        startup_program = fluid.Program()
+        with fluid.program_guard(context_prog, startup_program):
+            image = input_image if input_image else fluid.data(
+                name='image',
+                shape=[-1, 3, 224, 224],
+                dtype='float32',
+                lod_level=0)
+            backbone = DarkNet(get_prediction=get_prediction)
+            out = backbone(image)
+            inputs = {'image': image}
+            if get_prediction:
+                outputs = {'pred_out': out}
+            else:
+                outputs = {'body_feats': out}
+
+            place = fluid.CPUPlace()
+            exe = fluid.Executor(place)
+            if pretrained:
+
+                def _if_exist(var):
+                    return os.path.exists(
+                        os.path.join(self.default_pretrained_model_path,
+                                     var.name))
+
+                if not param_prefix:
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        main_program=context_prog,
+                        predicate=_if_exist)
+            else:
+                exe.run(startup_program)
+            return inputs, outputs, context_prog
+
+    def classification(self,
+                       paths=None,
+                       images=None,
+                       use_gpu=False,
+                       batch_size=1,
+                       top_k=2):
+        """API of Classification.
+        :param paths: the path of images.
+        :type paths: list, each element is correspond to the path of an image.
+        :param images: data of images, [N, H, W, C]
+        :type images: numpy.ndarray
+        :param use_gpu: whether to use gpu or not.
+        :type use_gpu: bool
+        :param batch_size: batch size.
+        :type batch_size: int
+        :param top_k : top k
+        :type top_k : int
+        """
+        if self.infer_prog is None:
+            inputs, outputs, self.infer_prog = self.context(
+                trainable=False, pretrained=True, get_prediction=True)
+            self.infer_prog = self.infer_prog.clone(for_test=True)
+            self.pred_out = outputs['pred_out']
+        place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
+        exe = fluid.Executor(place)
+        all_images = []
+        paths = paths if paths else []
+        for yield_data in test_reader(paths, images):
+            all_images.append(yield_data)
+
+        images_num = len(all_images)
+        loop_num = int(np.ceil(images_num / batch_size))
+
+        res_list = []
+        top_k = max(min(top_k, 1000), 1)
+        for iter_id in range(loop_num):
+            batch_data = []
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_images[handle_id + image_id])
+                except:
+                    pass
+            batch_data = np.array(batch_data).astype('float32')
+            data_tensor = PaddleTensor(batch_data.copy())
+            if use_gpu:
+                result = self.gpu_predictor.run([data_tensor])
+            else:
+                result = self.cpu_predictor.run([data_tensor])
+            for i, res in enumerate(result[0].as_ndarray()):
+                res_dict = {}
+                pred_label = np.argsort(res)[::-1][:top_k]
+                for k in pred_label:
+                    class_name = self.label_names[int(k)].split(',')[0]
+                    max_prob = res[k]
+                    res_dict[class_name] = max_prob
+                res_list.append(res_dict)
+        return res_list
+
+    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=int,
+            default=1,
+            help="batch size for prediction")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, default=None, help="input data")
+
+        self.arg_input_group.add_argument(
+            '--input_file',
+            type=str,
+            default=None,
+            help="file contain input data")
+
+    def check_input_data(self, args):
+        input_data = []
+        if args.input_path:
+            input_data = [args.input_path]
+        elif args.input_file:
+            if not os.path.exists(args.input_file):
+                raise RuntimeError("File %s is not exist." % args.input_file)
+            else:
+                input_data = txt_parser.parse(args.input_file, use_strip=True)
+        return input_data
+
+    @runnable
+    def run_cmd(self, argvs):
+        self.parser = argparse.ArgumentParser(
+            description="Run the {}".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)
+        input_data = self.check_input_data(args)
+        if len(input_data) == 0:
+            self.parser.print_help()
+            exit(1)
+        else:
+            for image_path in input_data:
+                if not os.path.exists(image_path):
+                    raise RuntimeError(
+                        "File %s or %s is not exist." % image_path)
+        return self.classification(
+            paths=input_data, use_gpu=args.use_gpu, batch_size=args.batch_size)

hubmodule/modules/image/classification/darknet53_imagenet/processor.py

+# coding=utf-8
+def load_label_info(file_path):
+    with open(file_path, 'r') as fr:
+        return fr.read().split("\n")[:-1]

hubmodule/modules/image/classification/mobilenet_v1_imagenet/data_feed.py

+# coding=utf-8
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os
+from collections import OrderedDict
+
+import numpy as np
+import cv2
+from PIL import Image, ImageEnhance
+from paddle import fluid
+
+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 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+    return img
+
+
+def test_reader(paths=None, images=None):
+    """data generator
+    :param paths: path to images.
+    :type paths: list, each element is a str
+    :param images: data of images, [N, H, W, C]
+    :type images: numpy.ndarray
+    """
+    img_list = []
+    if paths:
+        for img_path in paths:
+            assert os.path.isfile(
+                img_path), "The {} isn't a valid file path.".format(img_path)
+            img = Image.open(img_path)
+            #img = cv2.imread(img_path)
+            img_list.append(img)
+    if images is not None:
+        for img in images:
+            img_list.append(Image.fromarray(np.uint8(img)))
+    for im in img_list:
+        im = process_image(im)
+        yield im

hubmodule/modules/image/classification/mobilenet_v1_imagenet/mobilenet_v1.py

+# coding=utf-8
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from paddle import fluid
+from paddle.fluid.param_attr import ParamAttr
+from paddle.fluid.regularizer import L2Decay
+
+__all__ = ['MobileNet']
+
+
+class MobileNet(object):
+    """
+    MobileNet v1, see https://arxiv.org/abs/1704.04861
+
+    Args:
+        norm_type (str): normalization type, 'bn' and 'sync_bn' are supported
+        norm_decay (float): weight decay for normalization layer weights
+        conv_group_scale (int): scaling factor for convolution groups
+        with_extra_blocks (bool): if extra blocks should be added
+        extra_block_filters (list): number of filter for each extra block
+        class_dim (int): number of class while classification
+        yolo_v3 (bool): whether to output layers which yolo_v3 needs
+    """
+    __shared__ = ['norm_type', 'weight_prefix_name']
+
+    def __init__(self,
+                 norm_type='bn',
+                 norm_decay=0.,
+                 conv_group_scale=1,
+                 conv_learning_rate=1.0,
+                 with_extra_blocks=False,
+                 extra_block_filters=[[256, 512], [128, 256], [128, 256],
+                                      [64, 128]],
+                 weight_prefix_name='',
+                 class_dim=1000,
+                 yolo_v3=False):
+        self.norm_type = norm_type
+        self.norm_decay = norm_decay
+        self.conv_group_scale = conv_group_scale
+        self.conv_learning_rate = conv_learning_rate
+        self.with_extra_blocks = with_extra_blocks
+        self.extra_block_filters = extra_block_filters
+        self.prefix_name = weight_prefix_name
+        self.class_dim = class_dim
+        self.yolo_v3 = yolo_v3
+
+    def _conv_norm(self,
+                   input,
+                   filter_size,
+                   num_filters,
+                   stride,
+                   padding,
+                   num_groups=1,
+                   act='relu',
+                   use_cudnn=True,
+                   name=None):
+        parameter_attr = ParamAttr(
+            learning_rate=self.conv_learning_rate,
+            initializer=fluid.initializer.MSRA(),
+            name=name + "_weights")
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=parameter_attr,
+            bias_attr=False)
+
+        bn_name = name + "_bn"
+        norm_decay = self.norm_decay
+        bn_param_attr = ParamAttr(
+            regularizer=L2Decay(norm_decay), name=bn_name + '_scale')
+        bn_bias_attr = ParamAttr(
+            regularizer=L2Decay(norm_decay), name=bn_name + '_offset')
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=bn_param_attr,
+            bias_attr=bn_bias_attr,
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def depthwise_separable(self,
+                            input,
+                            num_filters1,
+                            num_filters2,
+                            num_groups,
+                            stride,
+                            scale,
+                            name=None):
+        depthwise_conv = self._conv_norm(
+            input=input,
+            filter_size=3,
+            num_filters=int(num_filters1 * scale),
+            stride=stride,
+            padding=1,
+            num_groups=int(num_groups * scale),
+            use_cudnn=False,
+            name=name + "_dw")
+
+        pointwise_conv = self._conv_norm(
+            input=depthwise_conv,
+            filter_size=1,
+            num_filters=int(num_filters2 * scale),
+            stride=1,
+            padding=0,
+            name=name + "_sep")
+        return pointwise_conv
+
+    def _extra_block(self,
+                     input,
+                     num_filters1,
+                     num_filters2,
+                     num_groups,
+                     stride,
+                     name=None):
+        pointwise_conv = self._conv_norm(
+            input=input,
+            filter_size=1,
+            num_filters=int(num_filters1),
+            stride=1,
+            num_groups=int(num_groups),
+            padding=0,
+            name=name + "_extra1")
+        normal_conv = self._conv_norm(
+            input=pointwise_conv,
+            filter_size=3,
+            num_filters=int(num_filters2),
+            stride=2,
+            num_groups=int(num_groups),
+            padding=1,
+            name=name + "_extra2")
+        return normal_conv
+
+    def __call__(self, input):
+        scale = self.conv_group_scale
+        blocks = []
+        # input 1/1
+        out = self._conv_norm(
+            input, 3, int(32 * scale), 2, 1, name=self.prefix_name + "conv1")
+        # 1/2
+        out = self.depthwise_separable(
+            out, 32, 64, 32, 1, scale, name=self.prefix_name + "conv2_1")
+        out = self.depthwise_separable(
+            out, 64, 128, 64, 2, scale, name=self.prefix_name + "conv2_2")
+        # 1/4
+        out = self.depthwise_separable(
+            out, 128, 128, 128, 1, scale, name=self.prefix_name + "conv3_1")
+        out = self.depthwise_separable(
+            out, 128, 256, 128, 2, scale, name=self.prefix_name + "conv3_2")
+        # 1/8
+        blocks.append(out)
+        out = self.depthwise_separable(
+            out, 256, 256, 256, 1, scale, name=self.prefix_name + "conv4_1")
+        out = self.depthwise_separable(
+            out, 256, 512, 256, 2, scale, name=self.prefix_name + "conv4_2")
+        # 1/16
+        blocks.append(out)
+        for i in range(5):
+            out = self.depthwise_separable(
+                out,
+                512,
+                512,
+                512,
+                1,
+                scale,
+                name=self.prefix_name + "conv5_" + str(i + 1))
+        module11 = out
+
+        out = self.depthwise_separable(
+            out, 512, 1024, 512, 2, scale, name=self.prefix_name + "conv5_6")
+        # 1/32
+        out = self.depthwise_separable(
+            out, 1024, 1024, 1024, 1, scale, name=self.prefix_name + "conv6")
+        module13 = out
+        blocks.append(out)
+        if self.yolo_v3:
+            return blocks
+        if not self.with_extra_blocks:
+            out = fluid.layers.pool2d(
+                input=out, pool_type='avg', global_pooling=True)
+            out = fluid.layers.fc(
+                input=out,
+                size=self.class_dim,
+                param_attr=ParamAttr(
+                    initializer=fluid.initializer.MSRA(), name="fc7_weights"),
+                bias_attr=ParamAttr(name="fc7_offset"))
+            out = fluid.layers.softmax(out)
+            blocks.append(out)
+            return blocks
+
+        num_filters = self.extra_block_filters
+        module14 = self._extra_block(module13, num_filters[0][0],
+                                     num_filters[0][1], 1, 2,
+                                     self.prefix_name + "conv7_1")
+        module15 = self._extra_block(module14, num_filters[1][0],
+                                     num_filters[1][1], 1, 2,
+                                     self.prefix_name + "conv7_2")
+        module16 = self._extra_block(module15, num_filters[2][0],
+                                     num_filters[2][1], 1, 2,
+                                     self.prefix_name + "conv7_3")
+        module17 = self._extra_block(module16, num_filters[3][0],
+                                     num_filters[3][1], 1, 2,
+                                     self.prefix_name + "conv7_4")
+        return module11, module13, module14, module15, module16, module17

hubmodule/modules/image/classification/mobilenet_v1_imagenet/module.py

+# coding=utf-8
+import os
+import ast
+import argparse
+
+import numpy as np
+import paddlehub as hub
+import paddle.fluid as fluid
+from paddlehub.module.module import moduleinfo, runnable
+from paddle.fluid.core import PaddleTensor, AnalysisConfig, create_paddle_predictor
+from paddlehub.common.paddle_helper import add_vars_prefix
+from paddlehub.io.parser import txt_parser
+
+from mobilenet_v1_imagenet.mobilenet_v1 import MobileNet
+from mobilenet_v1_imagenet.processor import load_label_info
+from mobilenet_v1_imagenet.data_feed import test_reader
+
+
+@moduleinfo(
+    name="mobilenet_v1_imagenet",
+    version="1.1.0",
+    type="cv/classification",
+    summary=
+    "MobileNet is a image classfication model trained with ImageNet-2012 dataset.",
+    author="paddlepaddle",
+    author_email="paddle-dev@baidu.com")
+class MobuleNetV1(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "mobilenet_v1_model")
+        self.label_names = load_label_info(
+            os.path.join(self.directory, "label_file.txt"))
+        self.infer_prog = None
+        self.pred_out = None
+        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=500, device_id=0)
+            self.gpu_predictor = create_paddle_predictor(gpu_config)
+
+    def context(self,
+                input_image=None,
+                trainable=True,
+                pretrained=True,
+                param_prefix='',
+                get_prediction=False,
+                yolo_v3=False):
+        """Distill the Head Features, so as to perform transfer learning.
+
+        :param input_image: image tensor.
+        :type input_image: <class 'paddle.fluid.framework.Variable'>
+        :param trainable: whether to set parameters trainable.
+        :type trainable: bool
+        :param pretrained: whether to load default pretrained model.
+        :type pretrained: bool
+        :param param_prefix: the prefix of parameters in yolo_head and backbone
+        :type param_prefix: str
+        :param get_prediction: whether to get prediction,
+            if True, outputs is {'bbox_out': bbox_out},
+            if False, outputs is {'head_features': head_features}.
+        :type get_prediction: bool
+        :param yolo_v3: whether to output layers which yolo_v3 needs
+        :type yolo_v3: bool
+        """
+        context_prog = input_image.block.program if input_image else fluid.Program(
+        )
+        startup_program = fluid.Program()
+        with fluid.program_guard(context_prog, startup_program):
+            image = input_image if input_image else fluid.data(
+                name='image',
+                shape=[-1, 3, 224, 224],
+                dtype='float32',
+                lod_level=0)
+            backbone = MobileNet(
+                norm_decay=0.,
+                conv_group_scale=1,
+                conv_learning_rate=0.1,
+                extra_block_filters=[[256, 512], [128, 256], [128, 256],
+                                     [64, 128]],
+                with_extra_blocks=not get_prediction,
+                yolo_v3=yolo_v3)
+            out = backbone(image)
+
+            inputs = {'image': image}
+            if get_prediction:
+                outputs = {'pred_out': out[-1]}
+            else:
+                outputs = {'body_feats': out}
+
+            place = fluid.CPUPlace()
+            exe = fluid.Executor(place)
+            if pretrained:
+
+                def _if_exist(var):
+                    return os.path.exists(
+                        os.path.join(self.default_pretrained_model_path,
+                                     var.name))
+
+                if not param_prefix:
+                    fluid.io.load_vars(
+                        exe,
+                        self.default_pretrained_model_path,
+                        main_program=context_prog,
+                        predicate=_if_exist)
+            else:
+                exe.run(startup_program)
+            return inputs, outputs, context_prog
+
+    def classification(self,
+                       paths=None,
+                       images=None,
+                       use_gpu=False,
+                       batch_size=1,
+                       top_k=1):
+        """API of Classification.
+        :param paths: the path of images.
+        :type paths: list, each element is correspond to the path of an image.
+        :param images: data of images, [N, H, W, C]
+        :type images: numpy.ndarray
+        :param use_gpu: whether to use gpu or not.
+        :type use_gpu: bool
+        :param batch_size: bathc size.
+        :type batch_size: int
+        :param top_k: result of top k
+        :type top_k: int
+        """
+        if self.infer_prog is None:
+            inputs, outputs, self.infer_prog = self.context(
+                trainable=False, pretrained=True, get_prediction=True)
+            self.infer_prog = self.infer_prog.clone(for_test=True)
+            self.pred_out = outputs['pred_out']
+
+        place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
+        exe = fluid.Executor(place)
+        all_images = []
+        paths = paths if paths else []
+        for yield_data in test_reader(paths, images):
+            all_images.append(yield_data)
+
+        images_num = len(all_images)
+        loop_num = int(np.ceil(images_num / batch_size))
+        res_list = []
+        top_k = max(min(top_k, 1000), 1)
+        for iter_id in range(loop_num):
+            batch_data = []
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    batch_data.append(all_images[handle_id + image_id])
+                except:
+                    pass
+            batch_data = np.array(batch_data).astype('float32')
+            data_tensor = PaddleTensor(batch_data.copy())
+            if use_gpu:
+                result = self.gpu_predictor.run([data_tensor])
+            else:
+                result = self.cpu_predictor.run([data_tensor])
+            for i, res in enumerate(result[0].as_ndarray()):
+                res_dict = {}
+                pred_label = np.argsort(res)[::-1][:top_k]
+                for k in pred_label:
+                    class_name = self.label_names[int(k)].split(',')[0]
+                    max_prob = res[k]
+                    res_dict[class_name] = max_prob
+                res_list.append(res_dict)
+        return res_list
+
+    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=int,
+            default=1,
+            help="batch size for prediction")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, default=None, help="input data")
+
+        self.arg_input_group.add_argument(
+            '--input_file',
+            type=str,
+            default=None,
+            help="file contain input data")
+
+    def check_input_data(self, args):
+        input_data = []
+        if args.input_path:
+            input_data = [args.input_path]
+        elif args.input_file:
+            if not os.path.exists(args.input_file):
+                raise RuntimeError("File %s is not exist." % args.input_file)
+            else:
+                input_data = txt_parser.parse(args.input_file, use_strip=True)
+        return input_data
+
+    @runnable
+    def run_cmd(self, argvs):
+        self.parser = argparse.ArgumentParser(
+            description="Run the {}".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)
+        input_data = self.check_input_data(args)
+        if len(input_data) == 0:
+            self.parser.print_help()
+            exit(1)
+        else:
+            for image_path in input_data:
+                if not os.path.exists(image_path):
+                    raise RuntimeError(
+                        "File %s or %s is not exist." % image_path)
+        return self.classification(
+            paths=input_data, use_gpu=args.use_gpu, batch_size=args.batch_size)

hubmodule/modules/image/classification/mobilenet_v1_imagenet/processor.py

+# coding=utf-8
+def load_label_info(file_path):
+    with open(file_path, 'r') as fr:
+        return fr.read().split("\n")[:-1]

hubmodule/modules/image/classification/mobilenet_v2_animals/README.md

+```shell
+$ hub install mobilenet_v2_animals==1.0.0
+```
+
+<p align="center">
+<img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea"  hspace='5' width=800/> <br /> MobileNet 系列的网络结构
+</p>
+
+模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf)
+
+## 命令行预测
+
+```
+hub run mobilenet_v2_animals --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 classification(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="mobilenet_v2_animals")
+
+result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线动物识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m mobilenet_v2_animals
+```
+
+这样就完成了一个在线动物识别服务化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/mobilenet_v2_animals"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification)
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0

hubmodule/modules/image/classification/mobilenet_v2_animals/data_feed.py

+# coding=utf-8
+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

hubmodule/modules/image/classification/mobilenet_v2_animals/mobilenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV2']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class MobileNetV2():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000, scale=1.0):
+
+        bottleneck_params_list = [
+            (1, 16, 1, 1),
+            (6, 24, 2, 2),
+            (6, 32, 3, 2),
+            (6, 64, 4, 2),
+            (6, 96, 3, 1),
+            (6, 160, 3, 2),
+            (6, 320, 1, 1),
+        ]
+
+        #conv1
+        input = self.conv_bn_layer(
+            input,
+            num_filters=int(32 * scale),
+            filter_size=3,
+            stride=2,
+            padding=1,
+            if_act=True,
+            name='conv1_1')
+
+        # bottleneck sequences
+        i = 1
+        in_c = int(32 * scale)
+        for layer_setting in bottleneck_params_list:
+            t, c, n, s = layer_setting
+            i += 1
+            input = self.invresi_blocks(
+                input=input,
+                in_c=in_c,
+                t=t,
+                c=int(c * scale),
+                n=n,
+                s=s,
+                name='conv' + str(i))
+            in_c = int(c * scale)
+        #last_conv
+        input = self.conv_bn_layer(
+            input=input,
+            num_filters=int(1280 * scale) if scale > 1.0 else 1280,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            if_act=True,
+            name='conv9')
+
+        input = fluid.layers.pool2d(
+            input=input,
+            pool_size=7,
+            pool_stride=1,
+            pool_type='avg',
+            global_pooling=True)
+
+        output = fluid.layers.fc(
+            input=input,
+            size=class_dim,
+            param_attr=ParamAttr(name='fc10_weights'),
+            bias_attr=ParamAttr(name='fc10_offset'))
+        return output, input
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      channels=None,
+                      num_groups=1,
+                      if_act=True,
+                      name=None,
+                      use_cudnn=True):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        bn = fluid.layers.batch_norm(
+            input=conv,
+            param_attr=ParamAttr(name=bn_name + "_scale"),
+            bias_attr=ParamAttr(name=bn_name + "_offset"),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+        if if_act:
+            return fluid.layers.relu6(bn)
+        else:
+            return bn
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+    def inverted_residual_unit(self,
+                               input,
+                               num_in_filter,
+                               num_filters,
+                               ifshortcut,
+                               stride,
+                               filter_size,
+                               padding,
+                               expansion_factor,
+                               name=None):
+        num_expfilter = int(round(num_in_filter * expansion_factor))
+
+        channel_expand = self.conv_bn_layer(
+            input=input,
+            num_filters=num_expfilter,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True,
+            name=name + '_expand')
+
+        bottleneck_conv = self.conv_bn_layer(
+            input=channel_expand,
+            num_filters=num_expfilter,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            num_groups=num_expfilter,
+            if_act=True,
+            name=name + '_dwise',
+            use_cudnn=False)
+
+        linear_out = self.conv_bn_layer(
+            input=bottleneck_conv,
+            num_filters=num_filters,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=False,
+            name=name + '_linear')
+        if ifshortcut:
+            out = self.shortcut(input=input, data_residual=linear_out)
+            return out
+        else:
+            return linear_out
+
+    def invresi_blocks(self, input, in_c, t, c, n, s, name=None):
+        first_block = self.inverted_residual_unit(
+            input=input,
+            num_in_filter=in_c,
+            num_filters=c,
+            ifshortcut=False,
+            stride=s,
+            filter_size=3,
+            padding=1,
+            expansion_factor=t,
+            name=name + '_1')
+
+        last_residual_block = first_block
+        last_c = c
+
+        for i in range(1, n):
+            last_residual_block = self.inverted_residual_unit(
+                input=last_residual_block,
+                num_in_filter=last_c,
+                num_filters=c,
+                ifshortcut=True,
+                stride=1,
+                filter_size=3,
+                padding=1,
+                expansion_factor=t,
+                name=name + '_' + str(i + 1))
+        return last_residual_block

hubmodule/modules/image/classification/mobilenet_v2_animals/module.py

+# coding=utf-8
+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 mobilenet_v2_animals.processor import postprocess, base64_to_cv2
+from mobilenet_v2_animals.data_feed import reader
+from mobilenet_v2_animals.mobilenet_v2 import MobileNetV2
+
+
+@moduleinfo(
+    name="mobilenet_v2_animals",
+    type="CV/image_classification",
+    author="baidu-vis",
+    author_email="",
+    summary=
+    "Mobilenet_V2 is a image classfication model, this module is trained with Baidu's self-built animals dataset.",
+    version="1.0.0")
+class MobileNetV2Animals(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "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._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):
+        """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.
+        """
+        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")
+                mobile_net = MobileNetV2()
+                output, feature_map = mobile_net.net(
+                    input=image, class_dim=len(self.label_list), scale=1.0)
+
+                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 classification(self,
+                       images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (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.
+        """
+        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.classification(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.classification(
+            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.")

hubmodule/modules/image/classification/mobilenet_v2_animals/processor.py

+# coding=utf-8
+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]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output

hubmodule/modules/image/classification/mobilenet_v2_dishes/README.md

+```shell
+$ hub install mobilenet_v2_dishes==1.0.0
+```
+
+<p align="center">
+<img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea"  hspace='5' width=800/> <br /> MobileNet 系列的网络结构
+</p>
+
+模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf)
+
+## 命令行预测
+
+```
+hub run mobilenet_v2_dishes --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 classification(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="mobilenet_v2_dishes")
+
+result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个菜品分类的在线服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m mobilenet_v2_dishes
+```
+
+这样就完成了一个菜品分类的在线服务的部署，默认端口号为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/mobilenet_v2_dishes"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification)
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0

hubmodule/modules/image/classification/mobilenet_v2_dishes/data_feed.py

+# coding=utf-8
+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

hubmodule/modules/image/classification/mobilenet_v2_dishes/mobilenet_v2.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV2']
+
+train_parameters = {
+    "input_size": [3, 224, 224],
+    "input_mean": [0.485, 0.456, 0.406],
+    "input_std": [0.229, 0.224, 0.225],
+    "learning_strategy": {
+        "name": "piecewise_decay",
+        "batch_size": 256,
+        "epochs": [30, 60, 90],
+        "steps": [0.1, 0.01, 0.001, 0.0001]
+    }
+}
+
+
+class MobileNetV2():
+    def __init__(self):
+        self.params = train_parameters
+
+    def net(self, input, class_dim=1000, scale=1.0):
+
+        bottleneck_params_list = [
+            (1, 16, 1, 1),
+            (6, 24, 2, 2),
+            (6, 32, 3, 2),
+            (6, 64, 4, 2),
+            (6, 96, 3, 1),
+            (6, 160, 3, 2),
+            (6, 320, 1, 1),
+        ]
+
+        #conv1
+        input = self.conv_bn_layer(
+            input,
+            num_filters=int(32 * scale),
+            filter_size=3,
+            stride=2,
+            padding=1,
+            if_act=True,
+            name='conv1_1')
+
+        # bottleneck sequences
+        i = 1
+        in_c = int(32 * scale)
+        for layer_setting in bottleneck_params_list:
+            t, c, n, s = layer_setting
+            i += 1
+            input = self.invresi_blocks(
+                input=input,
+                in_c=in_c,
+                t=t,
+                c=int(c * scale),
+                n=n,
+                s=s,
+                name='conv' + str(i))
+            in_c = int(c * scale)
+        #last_conv
+        input = self.conv_bn_layer(
+            input=input,
+            num_filters=int(1280 * scale) if scale > 1.0 else 1280,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            if_act=True,
+            name='conv9')
+
+        input = fluid.layers.pool2d(
+            input=input,
+            pool_size=7,
+            pool_stride=1,
+            pool_type='avg',
+            global_pooling=True)
+
+        output = fluid.layers.fc(
+            input=input,
+            size=class_dim,
+            param_attr=ParamAttr(name='fc10_weights'),
+            bias_attr=ParamAttr(name='fc10_offset'))
+        return output, input
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      channels=None,
+                      num_groups=1,
+                      if_act=True,
+                      name=None,
+                      use_cudnn=True):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        bn = fluid.layers.batch_norm(
+            input=conv,
+            param_attr=ParamAttr(name=bn_name + "_scale"),
+            bias_attr=ParamAttr(name=bn_name + "_offset"),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+        if if_act:
+            return fluid.layers.relu6(bn)
+        else:
+            return bn
+
+    def shortcut(self, input, data_residual):
+        return fluid.layers.elementwise_add(input, data_residual)
+
+    def inverted_residual_unit(self,
+                               input,
+                               num_in_filter,
+                               num_filters,
+                               ifshortcut,
+                               stride,
+                               filter_size,
+                               padding,
+                               expansion_factor,
+                               name=None):
+        num_expfilter = int(round(num_in_filter * expansion_factor))
+
+        channel_expand = self.conv_bn_layer(
+            input=input,
+            num_filters=num_expfilter,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True,
+            name=name + '_expand')
+
+        bottleneck_conv = self.conv_bn_layer(
+            input=channel_expand,
+            num_filters=num_expfilter,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            num_groups=num_expfilter,
+            if_act=True,
+            name=name + '_dwise',
+            use_cudnn=False)
+
+        linear_out = self.conv_bn_layer(
+            input=bottleneck_conv,
+            num_filters=num_filters,
+            filter_size=1,
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=False,
+            name=name + '_linear')
+        if ifshortcut:
+            out = self.shortcut(input=input, data_residual=linear_out)
+            return out
+        else:
+            return linear_out
+
+    def invresi_blocks(self, input, in_c, t, c, n, s, name=None):
+        first_block = self.inverted_residual_unit(
+            input=input,
+            num_in_filter=in_c,
+            num_filters=c,
+            ifshortcut=False,
+            stride=s,
+            filter_size=3,
+            padding=1,
+            expansion_factor=t,
+            name=name + '_1')
+
+        last_residual_block = first_block
+        last_c = c
+
+        for i in range(1, n):
+            last_residual_block = self.inverted_residual_unit(
+                input=last_residual_block,
+                num_in_filter=last_c,
+                num_filters=c,
+                ifshortcut=True,
+                stride=1,
+                filter_size=3,
+                padding=1,
+                expansion_factor=t,
+                name=name + '_' + str(i + 1))
+        return last_residual_block

hubmodule/modules/image/classification/mobilenet_v2_dishes/module.py

+# coding=utf-8
+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 mobilenet_v2_dishes.processor import postprocess, base64_to_cv2
+from mobilenet_v2_dishes.data_feed import reader
+from mobilenet_v2_dishes.mobilenet_v2 import MobileNetV2
+
+
+@moduleinfo(
+    name="mobilenet_v2_dishes",
+    type="CV/image_classification",
+    author="baidu-vis",
+    author_email="",
+    summary=
+    "Mobilenet_V2 is a image classfication model, this module is trained with Baidu's self-built dishes dataset.",
+    version="1.0.0")
+class MobileNetV2Dishes(hub.Module):
+    def _initialize(self):
+        self.default_pretrained_model_path = os.path.join(
+            self.directory, "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._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):
+        """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.
+        """
+        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")
+                mobile_net = MobileNetV2()
+                output, feature_map = mobile_net.net(
+                    input=image, class_dim=len(self.label_list), scale=1.0)
+
+                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 classification(self,
+                       images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+        """
+        API for image classification.
+
+        Args:
+            images (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.
+        """
+        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.classification(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.classification(
+            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.")

hubmodule/modules/image/classification/mobilenet_v2_dishes/processor.py

+# coding=utf-8
+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]
+            output_i[label] = float(result_i[index])
+        output.append(output_i)
+    return output

hubmodule/modules/image/classification/mobilenet_v2_imagenet_ssld/README.md

+```shell
+$ hub install mobilenet_v2_imagenet_ssld==1.0.0
+```
+
+<p align="center">
+<img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea"  hspace='5' width=800/> <br /> MobileNet 系列的网络结构
+</p>
+
+模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf)
+
+## 命令行预测
+
+```
+hub run mobilenet_v2_imagenet_ssld --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 classification(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="mobilenet_v2_imagenet_ssld")
+
+result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+```
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线动物识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m mobilenet_v2_imagenet_ssld
+```
+
+这样就完成了一个在线动物识别服务化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/mobilenet_v2_imagenet_ssld"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# 打印预测结果
+print(r.json()["results"])
+```
+
+### 查看代码
+
+[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0