add English readme

modules/image/classification/DriverStatusRecognition/README_en.md

+# DriverStatusRecognition
+
+|Module Name|DriverStatusRecognition|
+| :--- | :---: |
+|Category|image classification|
+|Network|MobileNetV3_small_ssld|
+|Dataset|分心司机检测Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|6MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 驾驶员状态识别（DriverStatusRecognition），该模型可挖掘出人在疲劳状态下的表情特征，然后将这些定性的表情特征进行量化，提取出面部特征点及特征指标作为判断依据，再结合实验数据总结出基于这些Parameters的识别方法，最后输入获取到的状态数据进行识别和判断.该PaddleHub Module支持API预测及命令行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+  - paddlex >= 1.3.7
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install DriverStatusRecognition
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+- ### 3、在线体验
+  [AI Studio 快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1649513)
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run DriverStatusRecognition --input_path /PATH/TO/IMAGE
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="DriverStatusRecognition")
+    images = [cv2.imread('/PATH/TO/IMAGE')]
+    results = classifier.predict(images=images)
+    for result in results:
+        print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images：list类型，待检测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install DriverStatusRecognition==1.0.0
+    ```

modules/image/classification/SnakeIdentification/README_en.md

+# SnakeIdentification
+
+|Module Name|SnakeIdentification|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet50_vd_ssld|
+|Dataset|蛇种Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|84MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 蛇种识别（SnakeIdentification），该模型可准确识别蛇的种类，并精准判断蛇的毒性.该PaddleHub Module支持API预测及命令行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+  - paddlex >= 1.3.7
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install SnakeIdentification
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+- ### 3、在线体验
+  [AI Studio 快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1646951)
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run SnakeIdentification --input_path /PATH/TO/IMAGE
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="SnakeIdentification")
+    images = [cv2.imread('/PATH/TO/IMAGE')]
+    results = classifier.predict(images=images)
+    for result in results:
+        print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images：list类型，待检测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install SnakeIdentification==1.0.0
+    ```

modules/image/classification/alexnet_imagenet/README_en.md

+# alexnet_imagenet
+
+|Module Name|alexnet_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|AlexNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|234MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - AlexNet是图像分类中的经典模型.模型由Alex Krizhevsky于2012年提出，并在2012年ILSVRC比赛中夺得冠军.该PaddleHub Module结构为AlexNet，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install alexnet_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run alexnet_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="alexnet_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install alexnet_imagenet==1.0.0
+    ```

modules/image/classification/darknet53_imagenet/README_en.md

+# darknet53_imagenet
+
+|Module Name|darknet53_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DarkNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|160MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DarkNet 是由 Joseph Redmon 提出的图像分类模型，并应用于Yolov3 中作为 Backbone 来完成特征提取.该网络采用连续的 3*3 和 1*1 卷积进行连接，并像ResNet 一样有ShortCut连接.该 PaddleHub Module 基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install darknet53_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run darknet53_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="darknet53_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install darknet53_imagenet==1.0.0
+    ```

modules/image/classification/densenet121_imagenet/README_en.md

+# densenet121_imagenet
+
+|Module Name|densenet121_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DenseNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|34MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接.对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入.DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了Parameters量.该PaddleHub Module结构为 DenseNet121，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install densenet121_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run densenet121_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="densenet121_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install densenet121_imagenet==1.0.0
+    ```

modules/image/classification/densenet161_imagenet/README_en.md

+# densenet161_imagenet
+
+|Module Name|densenet161_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DenseNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|114MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接.对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入.DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了Parameters量.该PaddleHub Module结构为 DenseNet161，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install densenet161_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run densenet161_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="densenet161_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install densenet161_imagenet==1.0.0
+    ```

modules/image/classification/densenet169_imagenet/README_en.md

+# densenet169_imagenet
+
+|Module Name|densenet169_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DenseNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|59MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接.对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入.DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了Parameters量.该PaddleHub Module结构为 DenseNet169，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install densenet169_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run densenet169_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="densenet169_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install densenet169_imagenet==1.0.0
+    ```

modules/image/classification/densenet201_imagenet/README_en.md

+# densenet201_imagenet
+
+|Module Name|densenet201_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DenseNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|82MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接.对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入.DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了Parameters量.该PaddleHub Module结构为 DenseNet201，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install densenet201_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run densenet201_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="densenet201_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install densenet201_imagenet==1.0.0
+    ```

modules/image/classification/densenet264_imagenet/README_en.md

+# densenet264_imagenet
+
+|Module Name|densenet264_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DenseNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|135MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接.对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入.DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了Parameters量.该PaddleHub Module结构为 DenseNet264，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install densenet264_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run densenet264_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="densenet264_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install densenet264_imagenet==1.0.0
+    ```

modules/image/classification/dpn107_imagenet/README_en.md

+# dpn107_imagenet
+
+|Module Name|dpn107_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DPN|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|335MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想.该PaddleHub Module结构为 DPN107，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install dpn107_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run dpn107_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="dpn107_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install dpn107_imagenet==1.0.0
+    ```

modules/image/classification/dpn131_imagenet/README_en.md

+# dpn131_imagenet
+
+|Module Name|dpn131_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DPN|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|306MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想.该PaddleHub Module结构为 DPN98，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install dpn131_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run dpn131_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="dpn131_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install dpn131_imagenet==1.0.0
+    ```

modules/image/classification/dpn68_imagenet/README_en.md

+# dpn68_imagenet
+
+|Module Name|dpn68_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DPN|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|50MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想.该PaddleHub Module结构为 DPN68，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install dpn68_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run dpn68_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="dpn68_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install dpn68_imagenet==1.0.0
+    ```

modules/image/classification/dpn92_imagenet/README_en.md

+# dpn92_imagenet
+
+|Module Name|dpn92_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DPN|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|146MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想.该PaddleHub Module结构为 DPN92，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install dpn92_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run dpn92_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="dpn92_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install dpn92_imagenet==1.0.0
+    ```

modules/image/classification/dpn98_imagenet/README_en.md

+# dpn98_imagenet
+
+|Module Name|dpn98_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|DPN|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|238MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想.该PaddleHub Module结构为 DPN98，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install dpn98_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run dpn98_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="dpn98_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install dpn98_imagenet==1.0.0
+    ```

modules/image/classification/efficientnetb0_imagenet/README_en.md

+# efficientnetb0_imagenet
+
+|Module Name|efficientnetb0_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|22MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB0, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb0_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb0_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb0_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb0_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb0_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb0_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb0_small_imagenet/README_en.md

+# efficientnetb0_small_imagenet
+
+|Module Name|efficientnetb0_small_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|20MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB0, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb0_small_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb0_small_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb0_small_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb0_small_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb0_small_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install efficientnetb0_small_imagenet==1.0.0
+    ```

modules/image/classification/efficientnetb1_imagenet/README_en.md

+# efficientnetb1_imagenet
+
+|Module Name|efficientnetb1_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|33MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB1, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb1_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb1_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb1_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb1_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb1_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb1_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb2_imagenet/README_en.md

+# efficientnetb2_imagenet
+
+|Module Name|efficientnetb2_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|38MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB2, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb2_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb2_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb2_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb2_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb2_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb2_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb3_imagenet/README_en.md

+# efficientnetb3_imagenet
+
+|Module Name|efficientnetb3_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|51MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB3, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb3_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb3_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb3_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb3_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb3_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb3_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb4_imagenet/README_en.md

+# efficientnetb4_imagenet
+
+|Module Name|efficientnetb4_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|77MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB4, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb4_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb4_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb4_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb4_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb4_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb4_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb5_imagenet/README_en.md

+# efficientnetb5_imagenet
+
+|Module Name|efficientnetb5_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|121MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB5, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb5_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb5_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb5_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb5_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb5_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb5_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb6_imagenet/README_en.md

+# efficientnetb6_imagenet
+
+|Module Name|efficientnetb6_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|170MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB6, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb6_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb6_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb6_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb6_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb6_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb6_imagenet==1.1.0
+    ```

modules/image/classification/efficientnetb7_imagenet/README_en.md

+# efficientnetb7_imagenet
+
+|Module Name|efficientnetb7_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|EfficientNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|260MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - EfficientNet is a light-weight model proposed by google, which consists of MBConv, and takes advantage of squeeze-and-excitation operation. This module is based on EfficientNetB7, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install efficientnetb7_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run efficientnetb7_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="efficientnetb7_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m efficientnetb7_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/efficientnetb7_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Improve the prediction performance and users' experience
+  - ```shell
+    $ hub install efficientnetb7_imagenet==1.1.0
+    ```

modules/image/classification/fix_resnext101_32x48d_wsl_imagenet/README_en.md

+# fix_resnext101_32x48d_wsl_imagenet
+
+|Module Name|fix_resnext101_32x48d_wsl_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|3.1GB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt 是由 UC San Diego 和 Facebook AI 研究所于2017年提出的图像分类模型，模型沿袭了 VGG/ResNets 的堆叠思想，并采用 split-transform-merge 策略来增加网络的分支数.该 PaddleHub Module 在包含数十亿张社交媒体图片的数据集上进行弱监督训练，并使用ImageNet-2012数据集finetune，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install fix_resnext101_32x48d_wsl_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run fix_resnext101_32x48d_wsl_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="fix_resnext101_32x48d_wsl_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m fix_resnext101_32x48d_wsl_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/fix_resnext101_32x48d_wsl_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install fix_resnext101_32x48d_wsl_imagenet==1.0.0
+    ```

modules/image/classification/food_classification/README_en.md

+# food_classification
+
+|Module Name|food_classification|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet50_vd_ssld|
+|Dataset|美食Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|91MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 美食分类（food_classification），该模型可识别苹果派，小排骨，烤面包，牛肉馅饼，牛肉鞑靼.该PaddleHub Module支持API预测及命令行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+  - paddlex >= 1.3.7
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install food_classification
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run food_classification --input_path /PATH/TO/IMAGE
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="food_classification")
+    images = [cv2.imread('/PATH/TO/IMAGE')]
+    results = classifier.predict(images=images)
+    for result in results:
+        print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images：list类型，待检测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - category_id (int): 类别的id；
+        - category（str）: 类别;
+        - score（float）: 准确率
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install food_classification==1.0.0
+    ```

modules/image/classification/googlenet_imagenet/README_en.md

+# googlenet_imagenet
+
+|Module Name|googlenet_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|GoogleNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|28MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - GoogleNet是图像分类中的经典模型.由Christian Szegedy等人在2014年提出，并获得了2014年ILSVRC竞赛冠军.该PaddleHub Module结构为GoogleNet，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install googlenet_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run googlenet_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="googlenet_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install googlenet_imagenet==1.0.0
+    ```

modules/image/classification/inception_v4_imagenet/README_en.md

+# inception_v4_imagenet
+
+|Module Name|inception_v4_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Inception_V4|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|167MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Inception 结构最初由 GoogLeNet 引入，因此 GoogLeNet 也被称为 Inception-v1，通过在 Inception-v1 的基础上引入Batch Normalization、分解、残差连接等技术，设计出了Inception-v4.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install inception_v4_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run inception_v4_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="inception_v4_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install inception_v4_imagenet==1.0.0
+    ```

modules/image/classification/marine_biometrics/README_en.md

+# marine_biometrics
+
+|Module Name|marine_biometrics|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet50_vd_ssld|
+|Dataset|Fish4Knowledge|
+|Fine-tuning supported or not|No|
+|Module Size|84MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 海洋生物识别（marine_biometrics），该模型可准确识别鱼的种类.该PaddleHub Module支持API预测及命令行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install marine_biometrics
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run marine_biometrics --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="marine_biometrics")
+    images = [cv2.imread('/PATH/TO/IMAGE')]
+    results = classifier.predict(images=images)
+    for result in results:
+        print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images：list类型，待检测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install marine_biometrics==1.0.0
+    ```

modules/image/classification/mobilenet_v2_animals/README_en.md

+# mobilenet_v2_animals
+
+|Module Name|mobilenet_v2_animals|
+| :--- | :---: |
+|Category|image classification|
+|Network|MobileNet_v2|
+|Dataset|百度自建动物Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|50MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNet V2 是一个轻量化的卷积神经网络，它在 MobileNet 的基础上，做了 Inverted Residuals 和 Linear bottlenecks 这两大改进.该 PaddleHub Module 是在百度自建动物数据集上训练得到的，可用于图像分类和特征提取，当前已支持7978种动物的分类识别.模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf).
+
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v2_animals
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v2_animals --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```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'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m mobilenet_v2_animals
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    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 prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install mobilenet_v2_animals==1.0.0
+    ```

modules/image/classification/mobilenet_v2_dishes/README_en.md

+# mobilenet_v2_dishes
+
+|Module Name|mobilenet_v2_dishes|
+| :--- | :---: |
+|Category|image classification|
+|Network|MobileNet_v2|
+|Dataset|百度自建菜品Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|52MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNet V2 是一个轻量化的卷积神经网络，它在 MobileNet 的基础上，做了 Inverted Residuals 和 Linear bottlenecks 这两大改进.该 PaddleHub Module 是在百度自建菜品数据集上训练得到的，可用于图像分类和特征提取，当前已支持8416种菜品的分类识别.
+
+<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" width = "800"  hspace='10'/> <br />
+</p>
+
+  - 更多详情参考：[MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/pdf/1801.04381.pdf)
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v2_dishes
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v2_dishes --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```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'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m mobilenet_v2_dishes
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    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 prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install mobilenet_v2_dishes==1.0.0
+    ```

modules/image/classification/mobilenet_v2_imagenet/README_en.md

+# mobilenet_v2_imagenet
+
+|Module Name|mobilenet_v2_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Mobilenet_v2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|15MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNet V2是Mark Sandler, Andrew Howard等人在2018年提出的一个图像分类模型，该系列模型（MobileNet）是为移动和嵌入式设备提出的高效模型，在模型Parameters较少的情况下仍然保持了较高的分类准确率.该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v2_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v2_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="mobilenet_v2_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+
+  Fix the problem of encoding in python2
+
+  - ```shell
+    $ hub install mobilenet_v2_imagenet==1.0.1
+    ```

modules/image/classification/mobilenet_v2_imagenet_ssld/README_en.md

+# mobilenet_v2_imagenet_ssld
+
+|Module Name|mobilenet_v2_imagenet_ssld|
+| :--- | :---: |
+|Category|image classification|
+|Network|Mobilenet_v2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|15MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNet V2是Mark Sandler, Andrew Howard等人在2018年提出的一个图像分类模型，该系列模型（MobileNet）是为移动和嵌入式设备提出的高效模型，在模型Parameters较少的情况下仍然保持了较高的分类准确率.该PaddleHub Module基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v2_imagenet_ssld
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v2_imagenet_ssld --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```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'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m mobilenet_v2_imagenet_ssld
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    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 prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install mobilenet_v2_imagenet_ssld==1.0.0
+    ```

modules/image/classification/mobilenet_v3_large_imagenet_ssld/README_en.md

+# mobilenet_v3_large_imagenet_ssld
+
+|Module Name|mobilenet_v3_large_imagenet_ssld|
+| :--- | :---: |
+|Category|image classification|
+|Network|Mobilenet_v3_large|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|23MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNetV3是Google在2019年发布的新模型，作者通过结合NAS与NetAdapt进行搜索得到该网络结构，提供了Large和Small两个版本，分别适用于对资源不同要求的情况.对比于MobileNetV2，新的模型在速度和精度方面均有提升.该PaddleHubModule的模型结构为MobileNetV3 Large，基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v3_large_imagenet_ssld
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v3_large_imagenet_ssld --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="mobilenet_v3_large_imagenet_ssld")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m mobilenet_v3_large_imagenet_ssld
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/mobilenet_v3_large_imagenet_ssld"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install mobilenet_v3_large_imagenet_ssld==1.0.0
+    ```

modules/image/classification/mobilenet_v3_small_imagenet_ssld/README_en.md

+# mobilenet_v3_small_imagenet_ssld
+
+|Module Name|mobilenet_v3_small_imagenet_ssld|
+| :--- | :---: |
+|Category|image classification|
+|Network|Mobilenet_v3_Small|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|13MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - MobileNetV3是Google在2019年发布的新模型，作者通过结合NAS与NetAdapt进行搜索得到该网络结构，提供了Large和Small两个版本，分别适用于对资源不同要求的情况.对比于MobileNetV2，新的模型在速度和精度方面均有提升.该PaddleHubModule的模型结构为MobileNetV3 Small，基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install mobilenet_v3_small_imagenet_ssld
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run mobilenet_v3_small_imagenet_ssld --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="mobilenet_v3_small_imagenet_ssld")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m mobilenet_v3_small_imagenet_ssld
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/mobilenet_v3_small_imagenet_ssld"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install mobilenet_v3_small_imagenet_ssld==1.0.0
+    ```

modules/image/classification/nasnet_imagenet/README_en.md

+# nasnet_imagenet
+
+|Module Name|nasnet_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|NASNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|345MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - NASNet是Google通过AutoML自动训练出来的图像分类模型.该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install nasnet_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run nasnet_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="nasnet_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+
+  Fix the problem of encoding in python2
+  - ```shell
+    $ hub install nasnet_imagenet==1.0.1
+    ```

modules/image/classification/pnasnet_imagenet/README_en.md

+# pnasnet_imagenet
+
+|Module Name|pnasnet_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|PNASNet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|333MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - PNASNet是Google通过AutoML自动训练出来的图像分类模型.该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pnasnet_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pnasnet_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="pnasnet_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+
+  Fix the problem of encoding in python2
+  - ```shell
+    $ hub install pnasnet_imagenet==1.0.1
+    ```

modules/image/classification/res2net101_vd_26w_4s_imagenet/README_en.md

+# res2net101_vd_26w_4s_imagenet
+
+|Module Name|res2net101_vd_26w_4s_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Res2Net|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|179MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可以和现有其他优秀模块轻松整合，在不增加计算负载量的情况下，在ImageNet、CIFAR-100等数据集上的测试性能超过了ResNet.Res2Net结构简单，性能优越，进一步探索了CNN在更细粒度级别的多尺度表示能力. 该 PaddleHub Module 使用 ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install res2net101_vd_26w_4s_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run res2net101_vd_26w_4s_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="res2net101_vd_26w_4s_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m res2net101_vd_26w_4s_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/res2net101_vd_26w_4s_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install res2net101_vd_26w_4s_imagenet==1.0.0
+    ```

modules/image/classification/resnet18_vd_imagenet/README_en.md

+# resnet18_vd_imagenet
+
+|Module Name|resnet18_vd_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet_vd|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|46MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet系列模型是图像分类领域的重要模型之一，模型中提出的残差单元有效地解决了深度网络训练困难的问题，通过增加模型的深度提升了模型的准确率，ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种.该PaddleHub Module结构为ResNet_vd，基于ImageNet-2012数据集训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet18_vd_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet18_vd_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet18_vd_imagenet")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m resnet18_vd_imagenet
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/resnet18_vd_imagenet"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnet18_vd_imagenet==1.0.0
+    ```

modules/image/classification/resnet50_vd_10w/README_en.md

+# resnet50_vd_10w
+
+|Module Name|resnet50_vd_10w|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet_vd|
+|Dataset|百度自建Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|92MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet系列模型是图像分类领域的重要模型之一，模型中提出的残差单元有效地解决了深度网络训练困难的问题，通过增加模型的深度提升了模型的准确率，ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种.该PaddleHub Module结构为ResNet_vd，使用百度自研的基于10万种类别、4千多万的有标签数据进行训练，接受输入图片大小为224 x 224 x 3，支持finetune.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet50_vd_10w
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet50_vd_10w")
+    input_dict, output_dict, program = classifier.context(trainable=True)
+    ```
+
+- ### 2、API
+
+  - ```python
+    def context(trainable=True, pretrained=True)
+    ```
+    - **Parameters**
+      - trainable (bool): 计算图的Parameters是否为可训练的；<br/>
+      - pretrained (bool): 是否加载默认的预训练模型.
+
+    - **Return**
+      - inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；<br/>
+      - outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+        - classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+        - feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量.
+      - context\_prog(fluid.Program): 计算图，用于迁移学习.
+
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - **Parameters**
+      - dirname: 存在模型的目录名称；<br/>
+      - model_filename: 模型文件名称，默认为\_\_model\_\_; <br/>
+      - params_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效); <br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+
+
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnet50_vd_10w==1.0.0
+    ```

modules/image/classification/resnet50_vd_dishes/README_en.md

+# resnet50_vd_dishes
+
+|Module Name|resnet50_vd_dishes|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet50_vd|
+|Dataset|百度自建菜品Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|158MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet-vd是ResNet原始结构的变种，可用于图像分类和特征提取.该 PaddleHub Module 采用百度自建菜品数据集训练得到，支持8416种菜品的分类识别.
+
+<p align="center">
+<img src="http://bj.bcebos.com/ibox-thumbnail98/77fa9b7003e4665867855b2b65216519?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A05%3A10Z%2F1800%2F%2F1df0ecb4a52adefeae240c9e2189e8032560333e399b3187ef1a76e4ffa5f19f" width = "800"  hspace='10'/> <br />
+</p>
+
+  - 更多详情参考：[Bag of Tricks for Image Classification with Convolutional Neural Networks](https://arxiv.org/pdf/1812.01187.pdf)
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet50_vd_dishes
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet50_vd_dishes --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet50_vd_dishes")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m resnet50_vd_dishes
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/resnet50_vd_dishes"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnet50_vd_dishes==1.0.0
+    ```

modules/image/classification/resnet50_vd_wildanimals/README_en.md

+# resnet50_vd_wildanimals
+
+|Module Name|resnet50_vd_wildanimals|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet_vd|
+|Dataset|IFAW 自建野生动物Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|92MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种，可用于图像分类和特征提取.该 PaddleHub Module 采用百度自建野生动物数据集训练得到，支持'象牙制品','象牙', '大象', '虎皮', '老虎', '虎牙/虎爪/虎骨', '穿山甲甲片', '穿山甲', '穿山甲爪子', '其他' 这十个标签的识别.模型的详情可参考[论文](https://arxiv.org/pdf/1812.01187.pdf).
+
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet50_vd_wildanimals
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet50_vd_wildanimals --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet50_vd_wildanimals")
+    result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+
+  - ```python
+    def classification(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       top_k=1):
+    ```
+    - classification API.
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - top\_k (int): return the first k results
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of image classification.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m resnet50_vd_wildanimals
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/resnet50_vd_wildanimals"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install resnet50_vd_wildanimals==1.0.0
+    ```

modules/image/classification/resnet_v2_101_imagenet/README_en.md

+# resnet_v2_101_imagenet
+
+|Module Name|resnet_v2_101_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet V2 101|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|173MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet proposed a residual unit to solve the problem of training an extremely deep network, and improved the prediction accuracy of models. This module is based on ResNet101, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet_v2_101_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet_v2_101_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet_v2_101_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+  Fix the problem of encoding in python2
+  - ```shell
+    $ hub install resnet_v2_101_imagenet==1.0.1
+    ```

modules/image/classification/resnet_v2_152_imagenet/README_en.md

+# resnet_v2_152_imagenet
+
+|Module Name|resnet_v2_152_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet V2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|234MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet proposed a residual unit to solve the problem of training an extremely deep network, and improved the prediction accuracy of models. This module is based on ResNet152, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet_v2_152_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet_v2_152_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet_v2_152_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+  Fix the problem of encoding in python2
+  - ```shell
+    $ hub install resnet_v2_152_imagenet==1.0.1
+    ```

modules/image/classification/resnet_v2_18_imagenet/README_en.md

+# resnet_v2_18_imagenet
+
+|Module Name|resnet_v2_18_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet V2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|46MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+  - ResNet proposed a residual unit to solve the problem of training an extremely deep network, and improved the prediction accuracy of models. This module is based on ResNet18, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet_v2_18_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet_v2_18_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet_v2_18_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnet_v2_18_imagenet==1.0.0
+    ```

modules/image/classification/resnet_v2_34_imagenet/README_en.md

+# resnet_v2_34_imagenet
+
+|Module Name|resnet_v2_34_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet V2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|85MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet proposed a residual unit to solve the problem of training an extremely deep network, and improved the prediction accuracy of models. This module is based on ResNet34, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet_v2_34_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet_v2_34_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet_v2_34_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnet_v2_34_imagenet==1.0.0
+    ```

modules/image/classification/resnet_v2_50_imagenet/README_en.md

+# resnet_v2_50_imagenet
+
+|Module Name|resnet_v2_50_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNet V2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|99MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNet proposed a residual unit to solve the problem of training an extremely deep network, and improved the prediction accuracy of models. This module is based on ResNet50, trained on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnet_v2_50_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnet_v2_50_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnet_v2_50_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+  Fix the problem of encoding in python2
+  - ```shell
+    $ hub install resnet_v2_50_imagenet==1.0.1
+    ```

modules/image/classification/resnext101_32x16d_wsl/README_en.md

+# resnext101_32x16d_wsl
+
+|Module Name|resnext101_32x16d_wsl|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_wsl|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|744MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 由于人工标注的数据集在规模上已经接近其函数极限，Facebook 的研发人员采用了一种独特的迁移学习研究，通过使用 hashtag 作为标注，在包含数十亿张社交媒体图片的数据集上进行训练，这为大规模训练转向弱监督学习(Weakly Supervised Learning) 取得了重大突破.在 ImageNet 图像识别基准上，ResNeXt101_32x16d_wsl 的 Top-1 达到了 84.24% 的准确率.该 PaddleHub Module结构为 ResNeXt101_32x16d_wsl，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_32x16d_wsl
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_32x16d_wsl --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_32x16d_wsl")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_32x16d_wsl==1.0.0
+    ```

modules/image/classification/resnext101_32x32d_wsl/README_en.md

+# resnext101_32x32d_wsl
+
+|Module Name|resnext101_32x32d_wsl|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_wsl|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|1.8GB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 由于人工标注的数据集在规模上已经接近其函数极限，Facebook 的研发人员采用了一种独特的迁移学习研究，通过使用 hashtag 作为标注，在包含数十亿张社交媒体图片的数据集上进行训练，这为大规模训练转向弱监督学习(Weakly Supervised Learning) 取得了重大突破.在 ImageNet 图像识别基准上，ResNeXt101_32x32d_wsl 的 Top-1 达到了 84.97% 的准确率.该 PaddleHub Module结构为 ResNeXt101_32x32d_wsl，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_32x32d_wsl
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_32x32d_wsl --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_32x32d_wsl")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_32x32d_wsl==1.0.0
+    ```

modules/image/classification/resnext101_32x48d_wsl/README_en.md

+# resnext101_32x48d_wsl
+
+|Module Name|resnext101_32x48d_wsl|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_wsl|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|342MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 由于人工标注的数据集在规模上已经接近其函数极限，Facebook 的研发人员采用了一种独特的迁移学习研究，通过使用 hashtag 作为标注，在包含数十亿张社交媒体图片的数据集上进行训练，这为大规模训练转向弱监督学习(Weakly Supervised Learning) 取得了重大突破.在 ImageNet 图像识别基准上，ResNeXt101_32x48d_wsl 的 Top-1 达到了 85.4% 的准确率.该 PaddleHub Module结构为 ResNeXt101_32x48d_wsl，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_32x48d_wsl
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_32x48d_wsl --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_32x48d_wsl")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_32x48d_wsl==1.0.0
+    ```

modules/image/classification/resnext101_32x4d_imagenet/README_en.md

+# resnext101_32x4d_imagenet
+
+|Module Name|resnext101_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|172MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext101_32x4d, which denotes 101 layers ，32 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext101_32x8d_wsl/README_en.md

+# resnext101_32x8d_wsl
+
+|Module Name|resnext101_32x8d_wsl|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_wsl|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|317MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 由于人工标注的数据集在规模上已经接近其函数极限，Facebook 的研发人员采用了一种独特的迁移学习研究，通过使用 hashtag 作为标注，在包含数十亿张社交媒体图片的数据集上进行训练，这为大规模训练转向弱监督学习(Weakly Supervised Learning) 取得了重大突破.在 ImageNet 图像识别基准上，ResNeXt101_32x8d_wsl 的 Top-1 达到了 82.55% 的准确率.该 PaddleHub Module结构为 ResNeXt101_32x8d_wsl，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_32x8d_wsl
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_32x8d_wsl --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_32x8d_wsl")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_32x8d_wsl==1.0.0
+    ```

modules/image/classification/resnext101_64x4d_imagenet/README_en.md

+# resnext101_64x4d_imagenet
+
+|Module Name|resnext101_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|322MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext101_64x4d, which denotes 101 layers ，64 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext101_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext101_vd_32x4d_imagenet/README_en.md

+# resnext101_vd_32x4d_imagenet
+
+|Module Name|resnext101_vd_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|172MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext101_vd_32x4d, which denotes 101 layers ，32 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_vd_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_vd_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_vd_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install resnext101_vd_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext101_vd_64x4d_imagenet/README_en.md

+# resnext101_vd_64x4d_imagenet
+
+|Module Name|resnext101_vd_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_vd|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|172MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext101_vd_64x4d_imagenet, which denotes 101 layers ，64 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext101_vd_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext101_vd_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext101_vd_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install resnext101_vd_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext152_32x4d_imagenet/README_en.md

+# resnext152_32x4d_imagenet
+
+|Module Name|resnext152_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|233MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext152_32x4d_imagenet, which denotes 152 layers ，32 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext152_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext152_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext152_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext152_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext152_64x4d_imagenet/README_en.md

+# resnext152_64x4d_imagenet
+
+|Module Name|resnext152_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|444MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext152_64x4d_imagenet, which denotes 152 layers ，64 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext152_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext152_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext152_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext152_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext152_vd_64x4d_imagenet/README_en.md

+# resnext152_vd_64x4d_imagenet
+
+|Module Name|resnext152_vd_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_vd|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|444MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext152_vd_64x4d_imagenet, which denotes 152 layers ，64 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext152_vd_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext152_vd_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext152_vd_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext152_vd_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext50_32x4d_imagenet/README_en.md

+# resnext50_32x4d_imagenet
+
+|Module Name|resnext50_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|97MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext50_32x4d, which denotes 50 layers ，32 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext50_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext50_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext50_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext50_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext50_64x4d_imagenet/README_en.md

+# resnext50_64x4d_imagenet
+
+|Module Name|resnext50_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|174MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext50_64x4d_imagenet, which denotes 50 layers ，60 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext50_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext50_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext50_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext50_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext50_vd_32x4d_imagenet/README_en.md

+# resnext50_vd_32x4d_imagenet
+
+|Module Name|resnext50_vd_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_vd|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|98MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext50_vd_32x4d, which denotes 50 layers ，32 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext50_vd_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext50_vd_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext50_vd_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install resnext50_vd_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/resnext50_vd_64x4d_imagenet/README_en.md

+# resnext50_vd_64x4d_imagenet
+
+|Module Name|resnext50_vd_64x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ResNeXt_vd|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|175MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ResNeXt is proposed by UC San Diego and Facebook AI Research in 2017. This module is based on resnext50_vd_64x4d_imagenet, which denotes 50 layers ，64 branches，and the number of input and output branch channels is 4 in the network. It is weak-supervised trained on billions of socail images, finetuned on ImageNet-2012 dataset, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install resnext50_vd_64x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run resnext50_vd_64x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="resnext50_vd_64x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install resnext50_vd_64x4d_imagenet==1.0.0
+    ```

modules/image/classification/se_resnet18_vd_imagenet/README_en.md

+## 命令行预测
+
+```
+hub run se_resnet18_vd_imagenet --input_path "/PATH/TO/IMAGE"
+```
+
+## API
+
+```python
+def get_expected_image_width()
+```
+
+返回预处理的图片宽度，也就是224。
+
+```python
+def get_expected_image_height()
+```
+
+返回预处理的图片高度，也就是224。
+
+```python
+def get_pretrained_images_mean()
+```
+
+返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
+
+```python
+def get_pretrained_images_std()
+```
+
+返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。
+
+
+```python
+def context(trainable=True, pretrained=True)
+```
+
+**参数**
+
+* trainable (bool): 计算图的参数是否为可训练的；
+* pretrained (bool): 是否加载默认的预训练模型。
+
+**返回**
+
+* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；
+* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
+    * classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
+    * feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
+* context\_prog(fluid.Program): 计算图，用于迁移学习。
+
+```python
+def 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="se_resnet18_vd_imagenet")
+
+result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
+# or
+# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
+```
+
+## Server Deployment
+
+PaddleHub Serving可以部署一个在线图像识别服务。
+
+## 第一步：启动PaddleHub Serving
+
+运行启动命令：
+```shell
+$ hub serving start -m se_resnet18_vd_imagenet
+```
+
+这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+
+## 第二步：发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+# Send an HTTP request
+data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/se_resnet18_vd_imagenet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+# print prediction results
+print(r.json()["results"])
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/PaddleClas
+
+### 依赖
+
+paddlepaddle >= 1.6.2
+
+paddlehub >= 1.6.0

modules/image/classification/se_resnext101_32x4d_imagenet/README_en.md

+# se_resnext101_32x4d_imagenet
+
+|Module Name|se_resnext101_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|SE_ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|191MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Squeeze-and-Excitation Networks是由Momenta在2017年提出的一种图像分类结构.该结构通过对特征通道间的相关性进行建模，把重要的特征进行强化来提升准确率.SE_ResNeXt基于ResNeXt模型添加了SE Block，并获得了2017 ILSVR竞赛的冠军.该PaddleHub Module结构为SE_ResNeXt101_32x4d，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install se_resnext101_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run se_resnext101_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="se_resnext101_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install se_resnext101_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/se_resnext50_32x4d_imagenet/README_en.md

+# se_resnext50_32x4d_imagenet
+
+|Module Name|se_resnext50_32x4d_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|SE_ResNeXt|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|107MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Squeeze-and-Excitation Networks是由Momenta在2017年提出的一种图像分类结构.该结构通过对特征通道间的相关性进行建模，把重要的特征进行强化来提升准确率.SE_ResNeXt基于ResNeXt模型添加了SE Block，并获得了2017 ILSVR竞赛的冠军.该PaddleHub Module结构为SE_ResNeXt50_32x4d，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install se_resnext50_32x4d_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run se_resnext50_32x4d_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="se_resnext50_32x4d_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install se_resnext50_32x4d_imagenet==1.0.0
+    ```

modules/image/classification/shufflenet_v2_imagenet/README_en.md

+# shufflenet_v2_imagenet
+
+|Module Name|shufflenet_v2_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|ShuffleNet V2|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|11MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - ShuffleNet V2是由旷视科技在2018年提出的轻量级图像分类模型，该模型通过pointwise group convolution和channel shuffle两种方式，在保持精度的同时大大降低了模型的计算量.该PaddleHub Module结构为ShuffleNet V2，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install shufflenet_v2_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run shufflenet_v2_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="shufflenet_v2_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install shufflenet_v2_imagenet==1.0.0
+    ```

modules/image/classification/spinalnet_res101_gemstone/README_en.md

+# spinalnet_res101_gemstone
+
+|Module Name|spinalnet_res101_gemstone|
+| :--- | :---: |
+|Category|image classification|
+|Network|resnet101|
+|Dataset|gemstone|
+|Fine-tuning supported or not|No|
+|Module Size|246MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 使用PaddleHub的SpinalNet预训练模型进行宝石识别或finetune并完成宝石的预测任务.
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install spinalnet_res101_gemstone
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run spinalnet_res101_gemstone --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="spinalnet_res101_gemstone")
+    result = classifier.predict(['/PATH/TO/IMAGE'])
+    print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images: list类型，待预测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install spinalnet_res101_gemstone==1.0.0
+    ```

modules/image/classification/spinalnet_res50_gemstone/README_en.md

+# spinalnet_res50_gemstone
+
+|Module Name|spinalnet_res50_gemstone|
+| :--- | :---: |
+|Category|image classification|
+|Network|resnet50|
+|Dataset|gemstone|
+|Fine-tuning supported or not|No|
+|Module Size|137MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 使用PaddleHub的SpinalNet预训练模型进行宝石识别或finetune并完成宝石的预测任务.
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install spinalnet_res50_gemstone
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run spinalnet_res50_gemstone --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="spinalnet_res50_gemstone")
+    result = classifier.predict(['/PATH/TO/IMAGE'])
+    print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images: list类型，待预测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install spinalnet_res50_gemstone==1.0.0
+    ```

modules/image/classification/spinalnet_vgg16_gemstone/README_en.md

+# spinalnet_vgg16_gemstone
+
+|Module Name|spinalnet_vgg16_gemstone|
+| :--- | :---: |
+|Category|image classification|
+|Network|vgg16|
+|Dataset|gemstone|
+|Fine-tuning supported or not|No|
+|Module Size|1.5GB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - 使用PaddleHub的SpinalNet预训练模型进行宝石识别或finetune并完成宝石的预测任务.
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install spinalnet_vgg16_gemstone
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run spinalnet_vgg16_gemstone --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="spinalnet_vgg16_gemstone")
+    result = classifier.predict(['/PATH/TO/IMAGE'])
+    print(result)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def predict(images)
+    ```
+    - classification API.
+    - **Parameters**
+      - images: list类型，待预测的图像.
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install spinalnet_vgg16_gemstone==1.0.0
+    ```

modules/image/classification/vgg11_imagenet/README_en.md

+# vgg11_imagenet
+
+|Module Name|vgg11_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|VGG|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|507MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - VGG is a serial of models for image classification proposed by university of Oxford and DeepMind. The serial models demonstrate 'the deeper the network is, the better the performance is'. And VGG is used for feature extraction as the backbone by most image classification tasks. This module is based on VGG11, trained on ImageNet-2012, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install vgg11_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run vgg11_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="vgg11_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install vgg11_imagenet==1.0.0
+    ```

modules/image/classification/vgg13_imagenet/README_en.md

+# vgg13_imagenet
+
+|Module Name|vgg13_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|VGG|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|508MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - VGG is a serial of models for image classification proposed by university of Oxford and DeepMind. The serial models demonstrate 'the deeper the network is, the better the performance is'. And VGG is used for feature extraction as the backbone by most image classification tasks. This module is based on VGG13, trained on ImageNet-2012, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install vgg13_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run vgg13_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="vgg13_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install vgg13_imagenet==1.0.0
+    ```

modules/image/classification/vgg16_imagenet/README_en.md

+# vgg16_imagenet
+
+|Module Name|vgg16_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|VGG|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|528MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - VGG is a serial of models for image classification proposed by university of Oxford and DeepMind. The serial models demonstrate 'the deeper the network is, the better the performance is'. And VGG is used for feature extraction as the backbone by most image classification tasks. This module is based on VGG16, trained on ImageNet-2012, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install vgg16_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run vgg16_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="vgg16_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install vgg16_imagenet==1.0.0
+    ```

modules/image/classification/vgg19_imagenet/README_en.md

+# vgg19_imagenet
+
+|Module Name|vgg19_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|vgg19_imagenet|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|549MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+  - VGG is a serial of models for image classification proposed by university of Oxford and DeepMind. The serial models demonstrate 'the deeper the network is, the better the performance is'. And VGG is used for feature extraction as the backbone by most image classification tasks. This module is based on VGG19, trained on ImageNet-2012, and can predict an image of size 224*224*3.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install vgg19_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run vgg19_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="vgg19_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install vgg19_imagenet==1.0.0
+    ```

modules/image/classification/xception41_imagenet/README_en.md

+# xception41_imagenet
+
+|Module Name|xception41_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Xception|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Xception 全称为 Extreme Inception，是 Google 于 2016年提出的 Inception V3 的改进模型.Xception 采用了深度可分离卷积(depthwise separable convolution) 来替换原来 Inception V3 中的卷积操作，整体的网络结构是带有残差连接的深度可分离卷积层的线性堆叠.该PaddleHub Module结构为Xception41，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install xception41_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run xception41_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="xception41_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install xception41_imagenet==1.0.0
+    ```

modules/image/classification/xception65_imagenet/README_en.md

+# xception65_imagenet
+
+|Module Name|xception65_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Xception|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|140MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Xception 全称为 Extreme Inception，是 Google 于 2016年提出的 Inception V3 的改进模型.Xception 采用了深度可分离卷积(depthwise separable convolution) 来替换原来 Inception V3 中的卷积操作，整体的网络结构是带有残差连接的深度可分离卷积层的线性堆叠.该PaddleHub Module结构为Xception65，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install xception65_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run xception65_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="xception65_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install xception65_imagenet==1.0.0
+    ```

modules/image/classification/xception71_imagenet/README_en.md

+# xception71_imagenet
+
+|Module Name|xception71_imagenet|
+| :--- | :---: |
+|Category|image classification|
+|Network|Xception|
+|Dataset|ImageNet-2012|
+|Fine-tuning supported or not|No|
+|Module Size|147MB|
+|Latest update date|-|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+
+
+- ### Module Introduction
+
+  - Xception 全称为 Extreme Inception，是 Google 于 2016年提出的 Inception V3 的改进模型.Xception 采用了深度可分离卷积(depthwise separable convolution) 来替换原来 Inception V3 中的卷积操作，整体的网络结构是带有残差连接的深度可分离卷积层的线性堆叠.该PaddleHub Module结构为Xception71，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.4.0  
+
+  - paddlehub >= 1.0.0  | [How to install PaddleHub]()
+
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install xception71_imagenet
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run xception71_imagenet --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、预测Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    classifier = hub.Module(name="xception71_imagenet")
+    test_img_path = "/PATH/TO/IMAGE"
+    input_dict = {"image": [test_img_path]}
+    result = classifier.classification(data=input_dict)
+    ```
+
+- ### 3、API
+
+  - ```python
+    def classification(data)
+    ```
+    - classification API.
+    - **Parameters**
+      - data (dict): key is "image", value is a list of image paths
+
+    - **Return**
+      - result(list[dict]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install xception71_imagenet==1.0.0
+    ```

modules/image/depth_estimation/MiDaS_Large/README_en.md

+# MiDaS_Large
+
+|Module Name|MiDaS_Large|
+| :--- | :---: |
+|Category|depth estimation|
+|Network|-|
+|Dataset|3D Movies, WSVD, ReDWeb, MegaDepth|
+|Fine-tuning supported or not|No|
+|Module Size|399MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://img-blog.csdnimg.cn/20201227112600975.jpg"  width='70%' hspace='10'/> <br />
+    </p>
+
+
+- ### Module Introduction
+
+  - MiDas_Large module is used for monocular depth estimation.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.0   | [How to install PaddleHub]()  
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install MiDaS_Large
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    model = hub.Module(name="MiDaS_Large")
+    result = model.depth_estimation(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = model.depth_estimation(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 2、API
+
+  - ```python
+    def depth_estimation(images=None,
+                    paths=None,
+                    batch_size=1,
+                    output_dir='output',
+                    visualization=False):
+    ```
+
+    - depth estimation API.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+      - res (list\[numpy.ndarray\]): depth data，ndarray.shape 为 \[H, W\]
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install MiDaS_Large==1.0.0
+    ```

modules/image/face_detection/pyramidbox_face_detection/README_en.md

+# pyramidbox_face_detection
+
+|Module Name|pyramidbox_face_detection|
+| :--- | :---: |
+|Category|face detection|
+|Network|PyramidBox|
+|Dataset|WIDER FACEDataset|
+|Fine-tuning supported or not|No|
+|Module Size|220MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+
+- ### Module Introduction
+
+  - PyramidBox是一种基于SSD的单阶段人脸检测器，它利用上下文信息解决困难人脸的检测问题.PyramidBox在六个尺度的特征图上进行不同层级的预测.该工作主要包括以下模块：LFPN、PyramidAnchors、CPM、Data-anchor-sampling.该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pyramidbox_face_detection
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pyramidbox_face_detection --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    face_detector = hub.Module(name="pyramidbox_face_detection")
+    result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       use_gpu=False,
+                       output_dir='detection_result',
+                       visualization=False,  
+                       score_thresh=0.15)
+    ```
+
+    - 检测输入图片中的所有人脸位置.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+      - score_thresh (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m pyramidbox_face_detection
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/pyramidbox_face_detection"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.0
+
+  Fix the problem of reading numpy
+  - ```shell
+    $ hub install pyramidbox_face_detection==1.1.0
+    ```

modules/image/face_detection/pyramidbox_lite_mobile/README_en.md

+# pyramidbox_lite_mobile
+
+|Module Name|pyramidbox_lite_mobile|
+| :--- | :---: |
+|Category|face detection|
+|Network|PyramidBox|
+|Dataset|WIDER FACEDataset + 百度自采人脸Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|7.3MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性.该PaddleHub Module是针对于移动端优化过的模型，适合部署于移动端或者边缘检测等算力受限的设备上，并基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于人脸检测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pyramidbox_lite_mobile
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pyramidbox_lite_mobile --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    face_detector = hub.Module(name="pyramidbox_lite_mobile")
+    result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       use_gpu=False,
+                       output_dir='detection_result',
+                       visualization=False,
+                       shrink=0.5,
+                       confs_threshold=0.6)
+    ```
+
+    - 检测输入图片中的所有人脸位置.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+      - shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m pyramidbox_lite_mobile
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.2.0
+
+  - ```shell
+    $ hub install pyramidbox_lite_mobile==1.2.0
+    ```

modules/image/face_detection/pyramidbox_lite_mobile_mask/README_en.md

+# pyramidbox_lite_mobile_mask
+
+|Module Name|pyramidbox_lite_mobile_mask|
+| :--- | :---: |
+|Category|face detection|
+|Network|PyramidBox|
+|Dataset|WIDER FACEDataset + 百度自采人脸Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|1.2MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131603304-690a2e3b-9f24-42f6-9297-a12ada884191.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性.该PaddleHub Module是针对于移动端优化过的模型，适合部署于移动端或者边缘检测等算力受限的设备上，并基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于检测人脸是否佩戴口罩.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pyramidbox_lite_mobile_mask
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pyramidbox_lite_mobile_mask --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    mask_detector = hub.Module(name="pyramidbox_lite_mobile_mask")
+    result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def __init__(face_detector_module=None)
+    ```
+
+    - **Parameters**
+
+      - face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_mobile.
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       visualization=False,
+                       output_dir='detection_result',
+                       use_multi_scale=False,
+                       shrink=0.5,
+                       confs_threshold=0.6)
+    ```
+
+    - 识别输入图片中的所有的人脸，并判断有无戴口罩.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - visualization (bool): Whether to save the results as picture files;
+      - output_dir (str): save path of images;
+      - use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；<br/>
+      - shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+
+  - ```python
+    def set_face_detector_module(face_detector_module)
+    ```
+    - 设置口罩检测模型中进行人脸检测的底座模型.
+    - **Parameters**
+
+      - face\_detector\_module (class): 人脸检测模型.
+
+  - ```python
+    def get_face_detector_module()
+    ```
+    - 获取口罩检测模型中进行人脸检测的底座模型.
+    - **Return**
+
+      - 当前模型使用的人脸检测模型
+
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m pyramidbox_lite_mobile_mask
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile_mask"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+## V.Paddle Lite部署
+- ### 通过python执行以下代码，保存模型
+  - ```python
+    import paddlehub as hub
+    pyramidbox_lite_mobile_mask = hub.Module(name="pyramidbox_lite_mobile_mask")
+
+    # 将模型保存在test_program文件夹之中
+    pyramidbox_lite_mobile_mask.save_inference_model(dirname="test_program")
+    ```
+    通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
+
+- ### 进行模型转换
+  - 从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
+
+- ### 模型通过Paddle Lite进行部署
+  - 参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.3.0
+  - ```shell
+    $ hub install pyramidbox_lite_mobile_mask==1.3.0
+    ```

modules/image/face_detection/pyramidbox_lite_server/README_en.md

+# pyramidbox_lite_server
+
+|Module Name|pyramidbox_lite_server|
+| :--- | :---: |
+|Category|face detection|
+|Network|PyramidBox|
+|Dataset|WIDER FACEDataset + 百度自采人脸Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|8MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性.该PaddleHub Module基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于人脸检测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pyramidbox_lite_server
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pyramidbox_lite_server --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    face_detector = hub.Module(name="pyramidbox_lite_server")
+    result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       use_gpu=False,
+                       output_dir='detection_result',
+                       visualization=False,  
+                       shrink=0.5,
+                       confs_threshold=0.6)
+    ```
+
+    - 检测输入图片中的所有人脸位置.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+      - shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m pyramidbox_lite_server
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.2.0
+
+  Fix the problem of reading numpy
+  - ```shell
+    $ hub install pyramidbox_lite_server==1.2.0
+    ```

modules/image/face_detection/pyramidbox_lite_server_mask/README_en.md

+# pyramidbox_lite_server_mask
+
+|Module Name|pyramidbox_lite_server_mask|
+| :--- | :---: |
+|Category|face detection|
+|Network|PyramidBox|
+|Dataset|WIDER FACEDataset + 百度自采人脸Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|1.2MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131603304-690a2e3b-9f24-42f6-9297-a12ada884191.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性.该PaddleHub Module基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于检测人脸是否佩戴口罩.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install pyramidbox_lite_server_mask
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run pyramidbox_lite_server_mask --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    mask_detector = hub.Module(name="pyramidbox_lite_server_mask")
+    result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def __init__(face_detector_module=None)
+    ```
+
+    - **Parameters**
+
+      - face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_server.
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       batch_size=1,
+                       use_gpu=False,
+                       visualization=False,
+                       output_dir='detection_result',
+                       use_multi_scale=False,
+                       shrink=0.5,
+                       confs_threshold=0.6)
+    ```
+
+    - 识别输入图片中的所有的人脸，并判断有无戴口罩.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - visualization (bool): Whether to save the results as picture files;
+      - output_dir (str): save path of images;
+      - use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；<br/>
+      - shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+
+  - ```python
+    def set_face_detector_module(face_detector_module)
+    ```
+    - 设置口罩检测模型中进行人脸检测的底座模型.
+    - **Parameters**
+
+      - face\_detector\_module (class): 人脸检测模型.
+
+  - ```python
+    def get_face_detector_module()
+    ```
+    - 获取口罩检测模型中进行人脸检测的底座模型.
+    - **Return**
+
+      - 当前模型使用的人脸检测模型
+
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m pyramidbox_lite_server_mask
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server_mask"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+## V.Paddle Lite部署
+- ### 通过python执行以下代码，保存模型
+  - ```python
+    import paddlehub as hub
+    pyramidbox_lite_server_mask = hub.Module(name="pyramidbox_lite_server_mask")
+
+    # 将模型保存在test_program文件夹之中
+    pyramidbox_lite_server_mask.save_inference_model(dirname="test_program")
+    ```
+    通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
+
+- ### 进行模型转换
+  - 从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
+
+- ### 模型通过Paddle Lite进行部署
+  - 参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.3.1
+  - ```shell
+    $ hub install pyramidbox_lite_server_mask==1.3.1
+    ```

modules/image/face_detection/ultra_light_fast_generic_face_detector_1mb_320/README_en.md

+# ultra_light_fast_generic_face_detector_1mb_320
+
+|Module Name|ultra_light_fast_generic_face_detector_1mb_320|
+| :--- | :---: |
+|Category|face detection|
+|Network|Ultra-Light-Fast-Generic-Face-Detector-1MB|
+|Dataset|WIDER FACEDataset|
+|Fine-tuning supported or not|No|
+|Module Size|2.6MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131604811-bce29c3f-66f7-45cb-a388-d739368bfeb9.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - Ultra-Light-Fast-Generic-Face-Detector-1MB是针对边缘计算设备或低算力设备(如用ARM推理)设计的实时超轻量级通用人脸检测模型，可以在低算力设备中如用ARM进行实时的通用场景的人脸检测推理.该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测，在预测时会将图片输入缩放为320 * 240.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install ultra_light_fast_generic_face_detector_1mb_320
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run ultra_light_fast_generic_face_detector_1mb_320 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_320")
+    result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       batch\_size=1,
+                       use_gpu=False,
+                       output_dir='face_detector_640_predict_output',
+                       visualization=False,
+                       confs_threshold=0.5)
+    ```
+
+    - 检测输入图片中的所有人脸位置.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m ultra_light_fast_generic_face_detector_1mb_320
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_320"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.2
+  - ```shell
+    $ hub install ultra_light_fast_generic_face_detector_1mb_320==1.1.2
+    ```

modules/image/face_detection/ultra_light_fast_generic_face_detector_1mb_640/README_en.md

+# ultra_light_fast_generic_face_detector_1mb_640
+
+|Module Name|ultra_light_fast_generic_face_detector_1mb_640|
+| :--- | :---: |
+|Category|face detection|
+|Network|Ultra-Light-Fast-Generic-Face-Detector-1MB|
+|Dataset|WIDER FACEDataset|
+|Fine-tuning supported or not|No|
+|Module Size|2.9MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/131604811-bce29c3f-66f7-45cb-a388-d739368bfeb9.jpg"   width='50%' hspace='10'/>
+    <br />
+    </p>
+
+- ### Module Introduction
+
+  - Ultra-Light-Fast-Generic-Face-Detector-1MB是针对边缘计算设备或低算力设备(如用ARM推理)设计的实时超轻量级通用人脸检测模型，可以在低算力设备中如用ARM进行实时的通用场景的人脸检测推理.该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测，在预测时会将图片输入缩放为640 * 480.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install ultra_light_fast_generic_face_detector_1mb_640
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run ultra_light_fast_generic_face_detector_1mb_640 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_640")
+    result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def face_detection(images=None,
+                       paths=None,
+                       batch\_size=1,
+                       use_gpu=False,
+                       output_dir='face_detector_640_predict_output',
+                       visualization=False,
+                       confs_threshold=0.5)
+    ```
+
+    - 检测输入图片中的所有人脸位置.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - paths (list[str]): image path;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - visualization (bool): Whether to save the results as picture files;
+      - confs\_threshold (float): 置信度的阈值.
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - path (str): 原输入图片的路径
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of face detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m ultra_light_fast_generic_face_detector_1mb_640
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_640"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.2
+  - ```shell
+    $ hub install ultra_light_fast_generic_face_detector_1mb_640==1.1.2
+    ```

modules/image/object_detection/faster_rcnn_resnet50_coco2017/README_en.md

+# faster_rcnn_resnet50_coco2017
+
+|Module Name|faster_rcnn_resnet50_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|faster_rcnn|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|131MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131504887-d024c7e5-fc09-4d6b-92b8-4d0c965949d0.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+
+- ### Module Introduction
+
+  - Faster_RCNN是两阶段目标检测器，对图像生成候选区域、提取特征、判别特征类别并修正候选框位置.Faster_RCNN整体网络可以分为4部分，一是ResNet-50作为基础卷积层，二是区域生成网络，三是Rol Align，四是检测层.Faster_RCNN是在MS-COCO数据集上预训练的模型.目前仅提供预测功能.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install faster_rcnn_resnet50_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run faster_rcnn_resnet50_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="faster_rcnn_resnet50_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m faster_rcnn_resnet50_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/faster_rcnn_resnet50_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.1.0
+
+  First release
+
+* 1.1.1
+
+  Fix the problem of reading numpy
+  - ```shell
+    $ hub install faster_rcnn_resnet50_coco2017==1.1.1
+    ```

modules/image/object_detection/faster_rcnn_resnet50_fpn_coco2017/README_en.md

+# faster_rcnn_resnet50_fpn_coco2017
+
+|Module Name|faster_rcnn_resnet50_fpn_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|faster_rcnn|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|161MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131504887-d024c7e5-fc09-4d6b-92b8-4d0c965949d0.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - Faster_RCNN是两阶段目标检测器，对图像生成候选区域、提取特征、判别特征类别并修正候选框位置.Faster_RCNN整体网络可以分为4个部分，一是ResNet-50作为基础卷积层，二是区域生成网络，三是Rol Align，四是检测层.Faster_RCNN是在MS-COCO数据集上预训练的模型.目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install faster_rcnn_resnet50_fpn_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run faster_rcnn_resnet50_fpn_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="faster_rcnn_resnet50_fpn_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m faster_rcnn_resnet50_fpn_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/faster_rcnn_resnet50_fpn_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.1
+
+  Fix the problem of reading numpy
+  - ```shell
+    $ hub install faster_rcnn_resnet50_fpn_coco2017==1.0.1
+    ```

modules/image/object_detection/faster_rcnn_resnet50_fpn_venus/README_en.md

+# faster_rcnn_resnet50_fpn_venus
+
+|Module Name|faster_rcnn_resnet50_fpn_venus|
+| :--- | :---: |
+|Category|object detection|
+|Network|faster_rcnn|
+|Dataset|百度自建Dataset|
+|Fine-tuning supported or not|Yes|
+|Module Size|317MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Module Introduction
+
+  - Faster_RCNN是两阶段目标检测器，对图像生成候选区域、提取特征、判别特征类别并修正候选框位置.Faster_RCNN整体网络可以分为4个部分，一是ResNet-50作为基础卷积层，二是区域生成网络，三是Rol Align，四是检测层.该PaddleHub Module是由800+tag,170w图片，1000w+检测框训练的大规模通用检测模型，在8个数据集上MAP平均提升2.06%，iou=0.5的准确率平均提升1.78%.对比于其他通用检测模型，使用该Module进行finetune，可以更快收敛，达到较优效果.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()  
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install faster_rcnn_resnet50_fpn_venus
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、API
+
+  - ```python
+    def context(num_classes=81,
+                trainable=True,
+                pretrained=True,
+                phase='train')
+    ```
+
+    - 提取特征，用于迁移学习.
+
+    - **Parameters**
+      - num\_classes (int): 类别数；<br/>
+      - trainable (bool): Parameters是否可训练；<br/>
+      - pretrained (bool): 是否加载预训练模型；<br/>
+      - get\_prediction (bool): 可选值为 'train'/'predict'，'train' 用于训练，'predict' 用于预测.
+
+    - **Return**
+      - inputs (dict): 模型的输入，相应的取值为：
+        当phase为'train'时，包含：
+          - image (Variable): 图像变量
+          - im\_size (Variable): 图像的尺寸
+          - im\_info (Variable): 图像缩放信息
+          - gt\_class (Variable): 检测框类别
+          - gt\_box (Variable): 检测框坐标
+          - is\_crowd (Variable): 单个框内是否包含多个物体
+        当 phase 为 'predict'时，包含：
+          - image (Variable): 图像变量
+          - im\_size (Variable): 图像的尺寸
+          - im\_info (Variable): 图像缩放信息
+      - outputs (dict): 模型的输出，响应的取值为：
+        当 phase 为 'train'时，包含：
+          - head_features (Variable): 所提取的特征
+          - rpn\_cls\_loss (Variable): 检测框分类损失
+          - rpn\_reg\_loss (Variable): 检测框回归损失
+          - generate\_proposal\_labels (Variable): 图像信息
+        当 phase 为 'predict'时，包含：
+          - head_features (Variable): 所提取的特征
+          - rois (Variable): 提取的roi
+          - bbox\_out (Variable): 预测结果
+      - context\_prog (Program): 用于迁移学习的 Program
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install faster_rcnn_resnet50_fpn_venus==1.0.0
+    ```

modules/image/object_detection/ssd_mobilenet_v1_pascal/README_en.md

+# ssd_mobilenet_v1_pascal
+
+|Module Name|ssd_mobilenet_v1_pascal|
+| :--- | :---: |
+|Category|object detection|
+|Network|SSD|
+|Dataset|PASCAL VOC|
+|Fine-tuning supported or not|No|
+|Module Size|24MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131504887-d024c7e5-fc09-4d6b-92b8-4d0c965949d0.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - Single Shot MultiBox Detector (SSD) 是一种单阶段的目标检测器.与两阶段的检测方法不同，单阶段目标检测并不进行区域推荐，而是直接从特征图回归出目标的边界框和分类概率.SSD 运用了这种单阶段检测的思想，并且对其进行改进：在不同尺度的特征图上检测对应尺度的目标.该PaddleHub Module的基网络为MobileNet-v1模型，在Pascal数据集上预训练得到，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install ssd_mobilenet_v1_pascal
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run ssd_mobilenet_v1_pascal --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="ssd_mobilenet_v1_pascal")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True,
+                         )
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m ssd_mobilenet_v1_pascal
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/ssd_mobilenet_v1_pascal"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install ssd_mobilenet_v1_pascal==1.1.2
+    ```

modules/image/object_detection/ssd_vgg16_512_coco2017/README_en.md

+# ssd_vgg16_512_coco2017
+
+|Module Name|ssd_vgg16_512_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|SSD|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|139MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131506781-b4ecb77b-5ab1-4795-88da-5f547f7f7f9c.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - Single Shot MultiBox Detector (SSD) 是一种单阶段的目标检测器.与两阶段的检测方法不同，单阶段目标检测并不进行区域推荐，而是直接从特征图回归出目标的边界框和分类概率.SSD 运用了这种单阶段检测的思想，并且对其进行改进：在不同尺度的特征图上检测对应尺度的目标.该PaddleHub Module的基网络为VGG16模型，在Pascal数据集上预训练得到，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install ssd_vgg16_512_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run ssd_vgg16_512_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="ssd_vgg16_512_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m ssd_vgg16_512_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/ssd_vgg16_512_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release  
+
+* 1.0.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install ssd_vgg16_512_coco2017==1.0.2
+    ```

modules/image/object_detection/yolov3_darknet53_coco2017/README_en.md

+# yolov3_darknet53_coco2017
+
+|Module Name|yolov3_darknet53_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|239MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131506781-b4ecb77b-5ab1-4795-88da-5f547f7f7f9c.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - YOLOv3是由Joseph Redmon和Ali Farhadi提出的单阶段检测器, 该检测器与达到同样精度的传统目标检测方法相比，推断速度能达到接近两倍. YOLOv3将输入图像划分格子，并对每个格子预测bounding box.YOLOv3的loss函数由三部分组成：Location误差，Confidence误差和分类误差.该PaddleHub Module预训练数据集为COCO2017，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_darknet53_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_darknet53_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="yolov3_darknet53_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_darknet53_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_darknet53_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.1.1
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_darknet53_coco2017==1.1.1
+    ```

modules/image/object_detection/yolov3_darknet53_pedestrian/README_en.md

+# yolov3_darknet53_pedestrian
+
+|Module Name|yolov3_darknet53_pedestrian|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|百度自建大规模行人Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|238MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131492636-714c697c-3275-4c8c-a83a-cf971a91ba98.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - 行人检测是计算机视觉技术中的目标检测问题，用于判断图像中是否存在行人并给予精确定位，定位结果用矩形框表示.行人检测技术有很强的使用价值，它可以与行人跟踪、行人重识别等技术结合，应用于汽车无人驾驶系统、智能视频监控、人体行为分析、客流统计系统、智能交通等领域.yolov3_darknet53_pedestrian Module的网络为YOLOv3, 其中backbone为DarkNet53, 采用百度自建大规模车辆数据集训练得到，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_darknet53_pedestrian
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_darknet53_pedestrian --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    pedestrian_detector = hub.Module(name="yolov3_darknet53_pedestrian")
+    result = pedestrian_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = pedestrian_detector.object_detection(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='yolov3_pedestrian_detect_output',
+                         score_thresh=0.2,
+                         visualization=True)  
+    ```
+
+    - 预测API，检测输入图片中的所有行人的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_darknet53_pedestrian
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_darknet53_pedestrian"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release  
+
+* 1.0.2
+
+   Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_darknet53_pedestrian==1.0.2
+    ```

modules/image/object_detection/yolov3_darknet53_vehicles/README_en.md

+# yolov3_darknet53_vehicles
+
+|Module Name|yolov3_darknet53_vehicles|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|百度自建大规模车辆Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|238MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131529643-70ee93fc-c9f3-40df-a981-901074683beb.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - 车辆检测是城市交通监控中非常重要并且具有挑战性的任务，该任务的难度在于对复杂场景中相对较小的车辆进行精准地定位和分类.该 PaddleHub Module 的网络为 YOLOv3, 其中 backbone 为 DarkNet53，采用百度自建大规模车辆数据集训练得到，支持car (汽车)、truck (卡车)、bus (公交车)、motorbike (摩托车)、tricycle (三轮车)等车型的识别.目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_darknet53_vehicles
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_darknet53_vehicles --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    vehicles_detector = hub.Module(name="yolov3_darknet53_vehicles")
+    result = vehicles_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = vehicles_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='yolov3_vehicles_detect_output',
+                         score_thresh=0.2,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有车辆的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_darknet53_vehicles
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_darknet53_vehicles"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_darknet53_vehicles==1.0.2
+    ```

modules/image/object_detection/yolov3_darknet53_venus/README_en.md

+# yolov3_darknet53_venus
+
+|Module Name|yolov3_darknet53_venus|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|百度自建Dataset|
+|Fine-tuning supported or not|Yes|
+|Module Size|501MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Module Introduction
+
+  - YOLOv3是由Joseph Redmon和Ali Farhadi提出的单阶段检测器, 该检测器与达到同样精度的传统目标检测方法相比，推断速度能达到接近两倍. YOLOv3将输入图像划分格子，并对每个格子预测bounding box.YOLOv3的loss函数由三部分组成：Location误差，Confidence误差和分类误差.该PaddleHub Module是由800+tag,170w图片，1000w+检测框训练的大规模通用检测模型，在8个数据集上MAP平均提升5.36%，iou=0.5的准确率提升4.53%.对比于其他通用检测模型，使用该Module进行finetune，可以更快收敛，达到较优效果.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()  
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_darknet53_venus
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、API
+
+  - ```python
+    def context(trainable=True,
+                pretrained=True,
+                get_prediction=False)
+    ```
+
+    - 提取特征，用于迁移学习.
+
+    - **Parameters**
+
+      - trainable(bool): Parameters是否可训练；<br/>
+      - pretrained (bool): 是否加载预训练模型；<br/>
+      - get\_prediction (bool): 是否执行预测.
+
+    - **Return**
+      - inputs (dict): 模型的输入，keys 包括 'image', 'im\_size'，相应的取值为：
+        - image (Variable): 图像变量
+        - im\_size (Variable): 图片的尺寸
+      - outputs (dict): 模型的输出.如果 get\_prediction 为 False，输出 'head\_features'、'body\_features'，否则输出 'bbox\_out'
+      - context\_prog (Program): 用于迁移学习的 Program
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         score_thresh=0.5,
+                         visualization=True,
+                         output_dir='detection_result')
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+      - output_dir (str): save path of images;
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+
+
+## IV.Release Note
+
+* 1.0.0
+
+  First release
+  - ```shell
+    $ hub install yolov3_darknet53_venus==1.0.0
+    ```

modules/image/object_detection/yolov3_mobilenet_v1_coco2017/README_en.md

+# yolov3_mobilenet_v1_coco2017
+
+|Module Name|yolov3_mobilenet_v1_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|96MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131506781-b4ecb77b-5ab1-4795-88da-5f547f7f7f9c.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+
+- ### Module Introduction
+
+  - YOLOv3是由Joseph Redmon和Ali Farhadi提出的单阶段检测器, 该检测器与达到同样精度的传统目标检测方法相比，推断速度能达到接近两倍.YOLOv3将输入图像划分格子，并对每个格子预测bounding box.YOLOv3的loss函数由三部分组成：Location误差，Confidence误差和分类误差.该PaddleHub Module预训练数据集为COCO2017，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_mobilenet_v1_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_mobilenet_v1_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="yolov3_mobilenet_v1_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_mobilenet_v1_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_mobilenet_v1_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_mobilenet_v1_coco2017==1.0.2
+    ```

modules/image/object_detection/yolov3_resnet34_coco2017/README_en.md

+# yolov3_resnet34_coco2017
+
+|Module Name|yolov3_resnet34_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|164MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131506781-b4ecb77b-5ab1-4795-88da-5f547f7f7f9c.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - YOLOv3是由Joseph Redmon和Ali Farhadi提出的单阶段检测器, 该检测器与达到同样精度的传统目标检测方法相比，推断速度能达到接近两倍. YOLOv3将输入图像划分格子，并对每个格子预测bounding box.YOLOv3的loss函数由三部分组成：Location误差，Confidence误差和分类误差.该PaddleHub Module预训练数据集为COCO2017，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_resnet34_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_resnet34_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="yolov3_resnet34_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_resnet34_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_resnet34_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release  
+
+* 1.0.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_resnet34_coco2017==1.0.2
+    ```

modules/image/object_detection/yolov3_resnet50_vd_coco2017/README_en.md

+# yolov3_resnet50_vd_coco2017
+
+|Module Name|yolov3_resnet50_vd_coco2017|
+| :--- | :---: |
+|Category|object detection|
+|Network|YOLOv3|
+|Dataset|COCO2017|
+|Fine-tuning supported or not|No|
+|Module Size|178MB|
+|Latest update date|2021-03-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+     <p align="center">
+     <img src="https://user-images.githubusercontent.com/22424850/131506781-b4ecb77b-5ab1-4795-88da-5f547f7f7f9c.jpg"   width='50%' hspace='10'/>
+     <br />
+     </p>
+
+- ### Module Introduction
+
+  - YOLOv3是由Joseph Redmon和Ali Farhadi提出的单阶段检测器, 该检测器与达到同样精度的传统目标检测方法相比，推断速度能达到接近两倍. YOLOv3将输入图像划分格子，并对每个格子预测bounding box.YOLOv3的loss函数由三部分组成：Location误差，Confidence误差和分类误差.该PaddleHub Module预训练数据集为COCO2017，目前仅支持预测.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.6.2  
+
+  - paddlehub >= 1.6.0  | [How to install PaddleHub]()
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install yolov3_resnet50_vd_coco2017
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run yolov3_resnet50_vd_coco2017 --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    object_detector = hub.Module(name="yolov3_resnet50_vd_coco2017")
+    result = object_detector.object_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
+    # or
+    # result = object_detector.object_detection((paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def object_detection(paths=None,
+                         images=None,
+                         batch_size=1,
+                         use_gpu=False,
+                         output_dir='detection_result',
+                         score_thresh=0.5,
+                         visualization=True)
+    ```
+
+    - 预测API，检测输入图片中的所有目标的位置.
+
+    - **Parameters**
+
+      - paths (list[str]): image path;
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - batch_size (int): the size of batch;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - output_dir (str): save path of images;
+      - score\_thresh (float): 识别置信度的阈值；<br/>
+      - visualization (bool): Whether to save the results as picture files;
+
+      **NOTE:** choose one parameter to provide data from paths and images
+
+    - **Return**
+
+      - res (list\[dict\]): classication results, each element in the list is dict, key is the label name, and value is the corresponding probability
+        - data (list): 检测结果，list的每一个元素为 dict，各字段为:
+          - confidence (float): 识别的置信度
+          - label (str): 标签
+          - left (int): 边界框的左上角x坐标
+          - top (int): 边界框的左上角y坐标
+          - right (int): 边界框的右下角x坐标
+          - bottom (int): 边界框的右下角y坐标
+        - save\_path (str, optional): 识别结果的保存路径 (仅当visualization=True时存在)
+
+  - ```python
+    def save_inference_model(dirname,
+                             model_filename=None,
+                             params_filename=None,
+                             combined=True)
+    ```
+    - 将模型保存到指定路径.
+
+    - **Parameters**
+
+      - dirname: 存在模型的目录名称； <br/>
+      - model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
+      - params\_filename: Parameters文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
+      - combined: 是否将Parameters保存到统一的一个文件中.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m yolov3_resnet50_vd_coco2017
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/yolov3_resnet50_vd_coco2017"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+* 1.0.2
+
+  Fix the problem of reading numpy
+
+  - ```shell
+    $ hub install yolov3_resnet50_vd_coco2017==1.0.2
+    ```

modules/image/text_recognition/Vehicle_License_Plate_Recognition/README_en.md

+# Vehicle_License_Plate_Recognition
+
+|Module Name|Vehicle_License_Plate_Recognition|
+| :--- | :---: |
+|Category|text recognition|
+|Network|-|
+|Dataset|CCPD|
+|Fine-tuning supported or not|No|
+|Module Size|111MB|
+|Latest update date|2021-03-22|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://ai-studio-static-online.cdn.bcebos.com/35a3dab32ac948549de41afba7b51a5770d3f872d60b437d891f359a5cef8052"  width = "450" height = "300" hspace='10'/> <br />
+    </p>
+
+
+- ### Module Introduction
+
+  - Vehicle_License_Plate_Recognition is a module for licence plate recognition, trained on CCPD dataset. This model can detect the position of licence plate and recognize the contents.
+
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 2.0.0  
+
+  - paddlehub >= 2.0.4
+
+  - paddleocr >= 2.0.2  
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install Vehicle_License_Plate_Recognition
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    model = hub.Module(name="Vehicle_License_Plate_Recognition")
+    result = model.plate_recognition(images=[cv2.imread('/PATH/TO/IMAGE')])
+    ```
+
+- ### 2、API
+
+  - ```python
+    def plate_recognition(images)
+    ```
+
+    - Prediction API.
+
+    - **Parameters**
+
+      - images (list\[numpy.ndarray\]): image data, ndarray.shape is in the format [H, W, C], BGR;<br/>
+
+
+    - **Return**
+      - results(list(dict{'license', 'bbox'})): The list of recognition results, where each element is dict.
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of text recognition.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m Vehicle_License_Plate_Recognition
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/Vehicle_License_Plate_Recognition"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install Vehicle_License_Plate_Recognition==1.0.0
+    ```

modules/image/text_recognition/chinese_ocr_db_crnn_mobile/README_en.md

+# chinese_ocr_db_crnn_mobile
+
+| Module Name                  | chinese_ocr_db_crnn_mobile       |
+| ---------------------------- | -------------------------------- |
+| Category                     | image-text recognition           |
+| Network                      | Differentiable Binarization+RCNN |
+| Dataset                      | icdar2015                        |
+| Fine-tuning supported or not | No                               |
+| Module Size                  | 16M                              |
+| Latest update date           | 2021-02-26                       |
+| Data indicators              | -                                |
+
+## I. Basic Information
+
+- ### Application Effect Display
+
+  - [Online experience of OCR text recognition scenarios](https://www.paddlepaddle.org.cn/hub/scene/ocr)
+  - Sample results:
+
+[![img](https://user-images.githubusercontent.com/76040149/133097562-d8c9abd1-6c70-4d93-809f-fa4735764836.png)](https://user-images.githubusercontent.com/76040149/133097562-d8c9abd1-6c70-4d93-809f-fa4735764836.png)
+
+- ### Module Introduction
+
+  - chinese_ocr_db_crnn_mobile Module is used to identify Chinese characters in pictures. It first obtains the text box detected by [chinese_text_detection_db_mobile Module](), then identifies the Chinese characters and carries out angle classification to these text boxes. CRNN(Convolutional Recurrent Neural Network) is adopted as the final recognition algorithm. This Module is an ultra-lightweight Chinese OCR model that supports direct prediction.
+
+[![img](https://user-images.githubusercontent.com/76040149/133098254-7c642826-d6d7-4dd0-986e-371622337867.png)](https://user-images.githubusercontent.com/76040149/133098254-7c642826-d6d7-4dd0-986e-371622337867.png)
+
+- For more information, please refer to:[An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition](https://arxiv.org/pdf/1507.05717.pdf)
+
+## II. Installation
+
+- ### 1、Environmental Dependence
+
+  - paddlepaddle >= 1.7.2
+
+  - paddlehub >= 1.6.0   | [How to install PaddleHub]()
+
+  - shapely
+
+  - pyclipper
+
+  - ```
+    $ pip install shapely pyclipper
+    ```
+
+  - **This Module relies on the third-party libraries, shapely and pyclipper. Please install shapely and pyclipper before using this Module.**
+
+- ### 2、Installation
+
+  - ```
+    $ hub install chinese_ocr_db_crnn_mobile
+    ```
+
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III. Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```
+    $ hub run chinese_ocr_db_crnn_mobile --input_path "/PATH/TO/IMAGE"
+    ```
+
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction]()
+
+- ### 2、Prediction Code Example
+
+  - ```
+    import paddlehub as hub
+    import cv2
+
+    ocr = hub.Module(name="chinese_ocr_db_crnn_mobile", enable_mkldnn=True)       # MKLDNN acceleration is only available on CPU
+    result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
+
+    # or
+    # result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```
+    __init__(text_detector_module=None, enable_mkldnn=False)
+    ```
+
+    - Construct the Chinese OCRDBCRNN object
+    - **Parameters**
+      - text_detector_module(str): Name of text detection module in PaddleHub Module, if set to None, [chinese_text_detection_db_mobile Module]() will be used by default. It serves to detect the text in the picture.
+      - enable_mkldnn(bool): Whether to enable MKLDNN for CPU computing acceleration. This parameter is valid only when the CPU is running. The default is False.
+
+  - ```
+    def recognize_text(images=[],
+                        paths=[],
+                        use_gpu=False,
+                        output_dir='ocr_result',
+                        visualization=False,
+                        box_thresh=0.5,
+                        text_thresh=0.5,
+                        angle_classification_thresh=0.9)
+    ```
+
+    - Prediction API, detecting the position of all Chinese text in the input image.
+    - **Parameter**
+      - paths (list[str]): image path
+      - images (list[numpy.ndarray]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - box_thresh (float): The confidence threshold for text box detection;
+      - text_thresh (float): The confidence threshold for Chinese text recognition;
+      - angle_classification_thresh(float): The confidence threshold for text angle classification
+      - visualization (bool): Whether to save the recognition results as picture files;
+      - output_dir (str): save path of images, ocr_result by default.
+    - **Return**
+      - res (list[dict]): The list of recognition results, where each element is dict and each field is:
+        - data (list[dict]): recognition results, each element in the list is dict and each field is:
+          - text(str): Recognized texts
+          - confidence(float): The confidence of the results
+          - text_box_position(list): The pixel coordinates of the text box in the original picture, a 4*2 matrix representing the coordinates of the lower left, lower right, upper right and upper left vertices of the text box in turn, data is [] if there's no result
+        - save_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+
+## IV. Server Deployment
+
+- PaddleHub Serving can deploy an online service of object detection.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command:
+
+  - ```
+    $ hub serving start -m chinese_ocr_db_crnn_mobile
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```
+    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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/chinese_ocr_db_crnn_mobile"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+## V. Release Note
+
+- 1.0.0
+
+  First release
+
+- 1.0.1
+
+  Fix the problem of model call failure using online service
+
+- 1.0.2
+
+  Support CPU computing acceleration based on MKLDNN
+
+- 1.1.0
+
+  Adopt an ultra-lightweight three-stage model (text box detection - angle classification - text recognition) to identify texts in images.
+
+- 1.1.1
+
+  Support recognition of spaces in texts.
+
+- 1.1.2
+
+  Fix an issue that only 30 fields can be detected.
+
+  - ```
+    $ hub install chinese_ocr_db_crnn_mobile==1.1.2
+    ```

modules/image/text_recognition/german_ocr_db_crnn_mobile/README_en.md

+# german_ocr_db_crnn_mobile
+
+|Module Name|german_ocr_db_crnn_mobile|
+| :--- | :---: |
+|Category|text recognition|
+|Network|Differentiable Binarization+CRNN|
+|Dataset|icdar2015Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|3.8MB|
+|Latest update date|2021-02-26|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/133761772-8c47f25f-0d95-45b4-8075-867dbbd14c86.jpg"  width="80%" hspace='10'/> <br />
+    </p>
+
+- ### Module Introduction
+  - german_ocr_db_crnn_mobile Module is used to identify Germany characters in pictures. It first obtains the text box detected by [chinese_text_detection_db_mobile Module](), then identifies the Germany characters and carries out angle classification to these text boxes. CRNN(Convolutional Recurrent Neural Network) is adopted as the final recognition algorithm. This Module is an ultra-lightweight Germany OCR model that supports direct prediction.
+
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.8.0  
+
+  - paddlehub >= 1.8.0   | [How to install PaddleHub]()
+
+  - shapely
+
+  - pyclipper
+
+  - ```shell
+    $ pip install shapely pyclipper
+    ```
+  - **This Module relies on the third-party libraries, shapely and pyclipper. Please install shapely and pyclipper before using this Module.**
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install german_ocr_db_crnn_mobile
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run german_ocr_db_crnn_mobile --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    ocr = hub.Module(name="german_ocr_db_crnn_mobile", enable_mkldnn=True)       # MKLDNN acceleration is only available on CPU
+    result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
+
+    # or
+    # result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def __init__(text_detector_module=None, enable_mkldnn=False)
+    ```
+    - Construct the GenmanOCRDBCRNNMobile object
+    - **Parameters**
+      - text_detector_module(str): Name of text detection module in PaddleHub Module, if set to None, [chinese_text_detection_db_mobile Module]() will be used by default. It serves to detect the text in the picture.
+      - enable_mkldnn(bool): Whether to enable MKLDNN for CPU computing acceleration. This parameter is valid only when the CPU is running. The default is False.
+
+  - ```python
+    def recognize_text(images=[],
+                       paths=[],
+                       use_gpu=False,
+                       output_dir='ocr_result',
+                       visualization=False,
+                       box_thresh=0.5,
+                       text_thresh=0.5,
+                       angle_classification_thresh=0.9)
+    ```
+
+    - Prediction API, detecting the position of all Germany text in the input image.
+
+    - **Parameter**
+      - paths (list[str]): image path
+      - images (list[numpy.ndarray]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - box_thresh (float): The confidence threshold for text box detection;
+      - text_thresh (float): The confidence threshold for Germany text recognition;
+      - angle_classification_thresh(float): The confidence threshold for text angle classification
+      - visualization (bool): Whether to save the recognition results as picture files;
+      - output_dir (str): save path of images, ocr_result by default.
+    - **Return**
+      - res (list[dict]): The list of recognition results, where each element is dict and each field is:
+        - data (list[dict]): recognition results, each element in the list is dict and each field is:
+          - text(str): Recognized texts
+          - confidence(float): The confidence of the results
+          - text_box_position(list): The pixel coordinates of the text box in the original picture, a 4*2 matrix representing the coordinates of the lower left, lower right, upper right and upper left vertices of the text box in turn, data is [] if there's no result
+        - save_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of text recognition.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m german_ocr_db_crnn_mobile
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/german_ocr_db_crnn_mobile"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install german_ocr_db_crnn_mobile==1.0.0
+    ```

modules/image/text_recognition/japan_ocr_db_crnn_mobile/README_en.md

+# japan_ocr_db_crnn_mobile
+
+|Module Name|japan_ocr_db_crnn_mobile|
+| :--- | :---: |
+|Category|text recognition|
+|Network|Differentiable Binarization+CRNN|
+|Dataset|icdar2015Dataset|
+|Fine-tuning supported or not|No|
+|Module Size|8MB|
+|Latest update date|2021-04-15|
+|Data indicators|-|
+
+
+## I.Basic Information
+
+- ### Application Effect Display
+  - Sample results：
+    <p align="center">
+    <img src="https://user-images.githubusercontent.com/22424850/133761650-91f24c1e-f437-47b1-8cfb-a074e7150ff5.jpg" width='80%' hspace='10'/> <br />
+    </p>
+
+- ### Module Introduction
+
+  - japan_ocr_db_crnn_mobile Module is used to identify Japanese characters in pictures. It first obtains the text box detected by [chinese_text_detection_db_mobile Module](), then identifies the Japanese characters and carries out angle classification to these text boxes. CRNN(Convolutional Recurrent Neural Network) is adopted as the final recognition algorithm. This Module is an ultra-lightweight Japanese OCR model that supports direct prediction.
+## II.Installation
+
+- ### 1、Environmental Dependence  
+
+  - paddlepaddle >= 1.8.0  
+
+  - paddlehub >= 1.8.0    | [How to install PaddleHub]()
+
+  - shapely
+
+  - pyclipper
+
+  - ```shell
+    $ pip install shapely pyclipper
+    ```
+  - **This Module relies on the third-party libraries, shapely and pyclipper. Please install shapely and pyclipper before using this Module.**
+
+- ### 2、Installation
+
+  - ```shell
+    $ hub install japan_ocr_db_crnn_mobile
+    ```
+  - In case of any problems during installation, please refer to: [Windows_Quickstart]() | [Linux_Quickstart]() | [Mac_Quickstart]()
+
+
+## III.Module API Prediction
+
+- ### 1、Command line Prediction
+
+  - ```shell
+    $ hub run japan_ocr_db_crnn_mobile --input_path "/PATH/TO/IMAGE"
+    ```
+  - If you want to call the Hub module through the command line, please refer to: [PaddleHub Command Line Instruction](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
+
+- ### 2、Prediction Code Example
+
+  - ```python
+    import paddlehub as hub
+    import cv2
+
+    ocr = hub.Module(name="japan_ocr_db_crnn_mobile", enable_mkldnn=True)    # MKLDNN acceleration is only available on CPU
+    result = ocr.recognize_text(images=[cv2.imread('/PATH/TO/IMAGE')])
+
+    # or
+    # result = ocr.recognize_text(paths=['/PATH/TO/IMAGE'])
+    ```
+
+- ### 3、API
+
+  - ```python
+    def __init__(text_detector_module=None, enable_mkldnn=False)
+    ```
+    - Construct the JapanOCRDBCRNNMobile object
+    - **Parameters**
+      - text_detector_module(str): Name of text detection module in PaddleHub Module, if set to None, [chinese_text_detection_db_mobile Module]() will be used by default. It serves to detect the text in the picture.
+      - enable_mkldnn(bool): Whether to enable MKLDNN for CPU computing acceleration. This parameter is valid only when the CPU is running. The default is False.
+
+  - ```python
+    def recognize_text(images=[],
+                       paths=[],
+                       use_gpu=False,
+                       output_dir='ocr_result',
+                       visualization=False,
+                       box_thresh=0.5,
+                       text_thresh=0.5,
+                       angle_classification_thresh=0.9)
+    ```
+
+    - Prediction API, detecting the position of all Japanese text in the input image.
+    - **Parameter**
+      - paths (list[str]): image path
+      - images (list[numpy.ndarray]): image data, ndarray.shape is in the format [H, W, C], BGR;
+      - use_gpu (bool): use GPU or not; **set the CUDA_VISIBLE_DEVICES environment variable first if you are using GPU**
+      - box_thresh (float): The confidence threshold for text box detection;
+      - text_thresh (float): The confidence threshold for Japanese text recognition;
+      - angle_classification_thresh(float): The confidence threshold for text angle classification
+      - visualization (bool): Whether to save the recognition results as picture files;
+      - output_dir (str): save path of images, ocr_result by default.
+    - **Return**
+      - res (list[dict]): The list of recognition results, where each element is dict and each field is:
+        - data (list[dict]): recognition results, each element in the list is dict and each field is:
+          - text(str): Recognized texts
+          - confidence(float): The confidence of the results
+          - text_box_position(list): The pixel coordinates of the text box in the original picture, a 4*2 matrix representing the coordinates of the lower left, lower right, upper right and upper left vertices of the text box in turn, data is [] if there's no result
+        - save_path (str, optional): Save path of the result, save_path is '' if no image is saved.
+
+
+
+## IV.Server Deployment
+
+- PaddleHub Serving can deploy an online service of text recognition.
+
+- ### Step 1: Start PaddleHub Serving
+
+  - Run the startup command：
+  - ```shell
+    $ hub serving start -m japan_ocr_db_crnn_mobile
+    ```
+
+  - The servitization API is now deployed and the default port number is 8866.
+
+  - **NOTE:**  If GPU is used for prediction, set CUDA_VISIBLE_DEVICES environment variable before the service, otherwise it need not be set.
+
+- ### Step 2: Send a predictive request
+
+  - With a configured server, use the following lines of code to send the prediction request and obtain the result
+
+  - ```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')
+
+    # Send an HTTP request
+    data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+    headers = {"Content-type": "application/json"}
+    url = "http://127.0.0.1:8866/predict/japan_ocr_db_crnn_mobile"
+    r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+    # print prediction results
+    print(r.json()["results"])
+    ```
+
+
+## V.Release Note
+
+* 1.0.0
+
+  First release
+
+  - ```shell
+    $ hub install japan_ocr_db_crnn_mobile==1.0.0
+    ```