add serving and cmd for paddlehub2.0

demo/colorization/README.md

@@ -2,9 +2,15 @@
 
 本示例将展示如何使用PaddleHub对预训练模型进行finetune并完成预测任务。
 
+## 命令行预测
+
+```
+$ hub run user_guided_colorization --input_path "/PATH/TO/IMAGE"
+```
+
 ## 如何开始Fine-tune
 
-在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用user_guided_colorization模型对[Canvas](../../docs/reference/dataset.md#class-hubdatasetsCanvas)等数据集进行Fine-tune。
+在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用user_guided_colorization模型对[Canvas](../../docs/reference/datasets.md#class-hubdatasetsCanvas)等数据集进行Fine-tune。
 
 ## 代码步骤
 
@@ -14,11 +20,12 @@
 ```python
 import paddlehub.vision.transforms as T
 
-transform = T.Compose([T.Resize((176, 176), interpolation='NEAREST'),
+transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'),
+                       T.RandomPaddingCrop(crop_size=176),
                        T.RGB2LAB()], to_rgb=True)
 ```
 
-`transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+`transforms`数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
 **NOTE:** 要将`T.Compose`中`to_rgb`设定为True.
 
@@ -27,9 +34,8 @@ transform = T.Compose([T.Resize((176, 176), interpolation='NEAREST'),
 from paddlehub.datasets import Canvas
 
 color_set = Canvas(transform=transform, mode='train')
-
 ```
-* `transforms`: 数据预处理方式。
+* `transform`: 数据预处理方式。
 * `mode`: 选择数据模式，可选项有 `train`, `test` 默认为`train`。
 
 数据集的准备代码可以参考 [canvas.py](../../paddlehub/datasets/canvas.py)。`hub.datasets.Canvas()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
@@ -37,19 +43,19 @@ color_set = Canvas(transform=transform, mode='train')
 ### Step3: 加载预训练模型
 
 ```python
-model = hub.Module(name='user_guided_colorization', classification=True, prob=1, num_point=None, load_checkpoint=None)
+model = hub.Module(name='user_guided_colorization', load_checkpoint=None)
+model.set_config(classification=True, prob=1)
 ```
-* `name`: 选择预训练模型的名字。
-* `classification`: 着色任务分为两阶段训练,第一阶段`classification`设定为True, 用于不加着色块网络的训练，第二阶段`classification`设定为False,用于输入图像加入着色块的训练。
-* `prob`: 不加着色块的概率，默认值为1，即不加着色块
-* `num_point`: 着色块的数量，默认为None.
+* `name`:加载模型的名字。
 * `load_checkpoint`: 是否加载自己训练的模型，若为None，则加载提供的模型默认参数。
+* `classification`: 着色模型分两部分训练，开始阶段`classification`设置为True, 用于浅层网络训练。训练后期将`classification`设置为False, 用于训练网络的输出层。
+* `prob`: 每张输入图不加一个先验彩色块的概率，默认为1，即不加入先验彩色块。例如，当`prob`设定为0.9时，一张图上有两个先验彩色块的概率为(1-0.9)*(1-0.9)*0.9=0.009.
 
 ### Step4: 选择优化策略和运行配置
 
 ```python
 optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt')
+trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt_cls_1')
 trainer.train(color_set, epochs=201, batch_size=25, eval_dataset=color_set, log_interval=10, save_interval=10)
 ```
 
@@ -93,7 +99,8 @@ import paddlehub as hub
 
 if __name__ == '__main__':
     model = hub.Module(name='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
-    result = model.predict(images='house.png', visualization=True, save_path='result')
+    model.set_config(prob=0.1)
+    result = model.predict(images=['house.png'])
 ```
 
 参数配置正确后，请执行脚本`python predict.py`， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
@@ -101,6 +108,66 @@ if __name__ == '__main__':
 **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。若想获取油画风着色效果，请下载参数文件[油画着色](https://paddlehub.bj.bcebos.com/dygraph/models/canvas_rc.pdparams)
 
 **Args**
-* `images`:原始图像路径；
+* `images`:原始图像路径或者BGR格式图片；
 * `visualization`: 是否可视化，默认为True；
 * `save_path`: 保存结果的路径，默认为'result'。
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线着色任务服务。
+
+### Step1: 启动PaddleHub Serving
+
+运行启动命令：
+
+```shell
+$ hub serving start -m user_guided_colorization
+```
+
+这样就完成了一个着色任务服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+### Step2: 发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+import numpy as np
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+# 发送HTTP请求
+org_im = cv2.imread('/PATH/TO/IMAGE')
+data = {'images':[cv2_to_base64(org_im)]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/user_guided_colorization"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+data = base64_to_cv2(r.json()["results"]['data'][0]['fake_reg'])
+cv2.imwrite('color.png', data)
+
+```
+
+### 查看代码
+
+https://github.com/richzhang/colorization-pytorch
+
+### 依赖
+
+paddlepaddle >= 2.0.0rc
+
+paddlehub >= 2.0.0

demo/colorization/predict.py

@@ -2,5 +2,6 @@ import paddle
 import paddlehub as hub
 
 if __name__ == '__main__':
-    model = hub.Module(name='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT', prob=0.01)
-    result = model.predict(images='house.png')
+    model = hub.Module(name='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
+    model.set_config(prob=0.1)
+    result = model.predict(images=['house.png'])
\ No newline at end of file

demo/colorization/train.py

@@ -6,12 +6,19 @@ from paddlehub.datasets import Canvas
 
 if __name__ == '__main__':
 
-    model = hub.Module(name='user_guided_colorization', classification=True, prob=1)
     transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'),
                            T.RandomPaddingCrop(crop_size=176),
                            T.RGB2LAB()], to_rgb=True)
 
     color_set = Canvas(transform=transform, mode='train')
+    model = hub.Module(name='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
+
+    model.set_config(classification=True, prob=1)
     optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
-    trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt')
+    trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt_cls_1')
     trainer.train(color_set, epochs=201, batch_size=25, eval_dataset=color_set, log_interval=10, save_interval=10)
+
+    model.set_config(classification=False, prob=0.125)
+    optimizer = paddle.optimizer.Adam(learning_rate=0.00001, parameters=model.parameters())
+    trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt_reg_1')
+    trainer.train(color_set, epochs=101, batch_size=25, eval_dataset=color_set, log_interval=10, save_interval=10)

demo/image_classification/README.md

@@ -2,9 +2,15 @@
 
 本示例将展示如何使用PaddleHub对预训练模型进行finetune并完成预测任务。
 
+## 命令行预测
+
+```shell
+$ hub run resnet50_vd_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
+```
+
 ## 如何开始Fine-tune
 
-在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用resnet50_vd_imagenet_ssld对[Flowers](../../docs/reference/dataset.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
+在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用resnet50_vd_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
 ## 代码步骤
 
@@ -14,7 +20,10 @@
 ```python
 import paddlehub.vision.transforms as T
 
-transforms = T.Compose([T.Resize((224, 224)), T.Normalize()])
+transforms = T.Compose([T.Resize((256, 256)), 
+                        T.CenterCrop(224), 
+                        T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])], 
+                        to_rgb=True)
 ```
 
 `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
@@ -27,6 +36,7 @@ flowers = Flowers(transforms)
 
 flowers_validate = Flowers(transforms, mode='val')
 ```
+
 * `transforms`: 数据预处理方式。
 * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
@@ -39,16 +49,16 @@ flowers_validate = Flowers(transforms, mode='val')
 module = hub.Module(name="resnet50_vd_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
 ```
 * `name`: 选择预训练模型的名字。
-* `class_dim`: 设置最终输出分类类别。
+* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
 PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
-目前部分模型还没有完全升级到2.0版本，敬请期待。
 
 如果想尝试efficientnet模型，只需要更换Module中的`name`参数即可.
 ```python
 # 更换name参数即可无缝切换efficientnet模型, 代码示例如下
 module = hub.Module(name="efficientnetb7_imagenet")
 ```
+**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
 
 ### Step4: 选择优化策略和运行配置
 
@@ -69,6 +79,7 @@ Paddle2.0-rc提供了多种优化器选择，如`SGD`, `Adam`, `Adamax`等，详
 * `parameters`: 待优化模型参数。
 
 #### 运行配置
+
 `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
 * `model`: 被优化模型；
@@ -99,10 +110,69 @@ import paddlehub as hub
 
 if __name__ == '__main__':
 
-    model = hub.Module(name='mobilenet_v2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint=/PATH/TO/CHECKPOINT)
-    result = model.predict('flower.jpg')
+    model = hub.Module(name='resnet50_vd_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
+    result = model.predict(['flower.jpg'])
 ```
 
 参数配置正确后，请执行脚本`python predict.py`， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
 
 **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线分类任务服务。
+
+### Step1: 启动PaddleHub Serving
+
+运行启动命令：
+
+```shell
+$ hub serving start -m resnet50_vd_imagenet_ssld
+```
+
+这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+### Step2: 发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+import numpy as np
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+# 发送HTTP请求
+org_im = cv2.imread('/PATH/TO/IMAGE')
+
+data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/resnet50_vd_imagenet_ssld"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+data =r.json()["results"]['data']
+```
+
+### 查看代码
+
+https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification
+
+### 依赖
+
+paddlepaddle >= 2.0.0rc
+
+paddlehub >= 2.0.0

demo/image_classification/predict.py

@@ -5,5 +5,5 @@ if __name__ == '__main__':
     model = hub.Module(
         name='resnet50_vd_imagenet_ssld',
         label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-        load_checkpoint=None)
-    result = model.predict('flower.jpg')
+        oad_checkpoint='/PATH/TO/CHECKPOINT')
+    result = model.predict(['flower.jpg'])

demo/image_classification/train.py

@@ -5,7 +5,11 @@ from paddlehub.finetune.trainer import Trainer
 from paddlehub.datasets import Flowers
 
 if __name__ == '__main__':
-    transforms = T.Compose([T.Resize((224, 224)), T.Normalize()])
+    transforms = T.Compose([T.Resize((256, 256)), 
+                            T.CenterCrop(224), 
+                            T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])], 
+                            to_rgb=True)
+                            
     flowers = Flowers(transforms)
     flowers_validate = Flowers(transforms, mode='val')
     model = hub.Module(name='resnet50_vd_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint=None)

demo/style_transfer/README.md

@@ -2,9 +2,15 @@
 
 本示例将展示如何使用PaddleHub对预训练模型进行finetune并完成预测任务。
 
+## 命令行预测
+
+```
+$ hub run msgnet --input_path "/PATH/TO/ORIGIN/IMAGE" --style_path "/PATH/TO/STYLE/IMAGE"
+```
+
 ## 如何开始Fine-tune
 
-在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/dataset.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。
+在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用msgnet模型对[MiniCOCO](../../docs/reference/datasets.md#class-hubdatasetsMiniCOCO)等数据集进行Fine-tune。
 
 ## 代码步骤
 
@@ -23,7 +29,7 @@ transform = T.Compose([T.Resize((256, 256), interpolation='LINEAR')])
 ```python
 from paddlehub.datasets.minicoco import MiniCOCO
 
-color_set = MiniCOCO(transform=transform, mode='train')
+styledata = MiniCOCO(transform=transform, mode='train')
 
 ```
 * `transforms`: 数据预处理方式。
@@ -49,13 +55,7 @@ trainer.train(styledata, epochs=101, batch_size=4, eval_dataset=styledata, log_i
 
 #### 优化策略
 
-Paddle2.0-rc提供了多种优化器选择，如`SGD`, `Adam`, `Adamax`等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
-
-其中`PolynomialDecay`:
-
-* `learning_rate`: 初始学习率，数据类型为Python float；
-* `power`: 多项式的幂，默认值为1.0；
-* `decay_steps`: 衰减步数。必须是正整数，该参数确定衰减周期。
+Paddle2.0rc提供了多种优化器选择，如`SGD`, `Adam`, `Adamax`等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
 
 其中`Adam`:
 
@@ -92,16 +92,76 @@ import paddle
 import paddlehub as hub
 
 if __name__ == '__main__':
-    model = hub.Module(name='msgnet', load_checkpoint=/PATH/TO/CHECKPOINT)
-    result = model.predict(origin="venice-boat.jpg", style="candy.jpg", visualization=True, save_path ='result')
+    model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT")
+    result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
 ```
 
 参数配置正确后，请执行脚本`python predict.py`， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
 
 **Args**
-* `origin`:原始图像路径；
+* `origin`:原始图像路径或BGR格式图片；
 * `style`: 风格图像路径；
 * `visualization`: 是否可视化，默认为True；
-* `save_path`: 保存结果的路径，默认为'result'。
+* `save_path`: 保存结果的路径，默认保存路径为'style_tranfer'。
 
 **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
+
+## 服务部署
+
+PaddleHub Serving可以部署一个在线风格迁移服务。
+
+### Step1: 启动PaddleHub Serving
+
+运行启动命令：
+
+```shell
+$ hub serving start -m msgnet
+```
+
+这样就完成了一个风格迁移服务化API的部署，默认端口号为8866。
+
+**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+### Step2: 发送预测请求
+
+配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+```python
+import requests
+import json
+import cv2
+import base64
+
+import numpy as np
+
+
+def cv2_to_base64(image):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+def base64_to_cv2(b64str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
+
+# 发送HTTP请求
+org_im = cv2.imread('/PATH/TO/ORIGIN/IMAGE')
+style_im = cv2.imread('/PATH/TO/STYLE/IMAGE')
+data = {'images':[[cv2_to_base64(org_im)], cv2_to_base64(style_im)]}
+headers = {"Content-type": "application/json"}
+url = "http://127.0.0.1:8866/predict/msgnet"
+r = requests.post(url=url, headers=headers, data=json.dumps(data))
+data = base64_to_cv2(r.json()["results"]['data'][0])
+cv2.imwrite('style.png', data)
+```
+
+### 查看代码
+
+https://github.com/zhanghang1989/PyTorch-Multi-Style-Transfer
+
+### 依赖
+
+paddlepaddle >= 2.0.0rc
+
+paddlehub >= 2.0.0

demo/style_transfer/predict.py

@@ -2,5 +2,5 @@ import paddle
 import paddlehub as hub
 
 if __name__ == '__main__':
-    model = hub.Module(name='msgnet', load_checkpoint='/PATH/TO/CHECKPOINT')
-    result = model.predict("venice-boat.jpg", "candy.jpg")
+    model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT")
+    result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
\ No newline at end of file

demo/style_transfer/train.py

@@ -9,7 +9,6 @@ if __name__ == "__main__":
     model = hub.Module(name='msgnet')
     transform = T.Compose([T.Resize((256, 256), interpolation='LINEAR')])
     styledata = MiniCOCO(transform)
-    scheduler = paddle.optimizer.lr.PolynomialDecay(learning_rate=0.001, power=0.9, decay_steps=100)
-    optimizer = paddle.optimizer.Adam(learning_rate=scheduler, parameters=model.parameters())
+    optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
     trainer = Trainer(model, optimizer, checkpoint_dir='test_style_ckpt')
-    trainer.train(styledata, epochs=101, batch_size=4, eval_dataset=styledata, log_interval=10, save_interval=10)
+    trainer.train(styledata, epochs=101, batch_size=4, eval_dataset=styledata, log_interval=10, save_interval=10)
\ No newline at end of file

docs/reference/vision.md

@@ -6,7 +6,7 @@ hub.vision.transforms.Compose(
     to_rgb: bool = False)
 ```
 
-Compose preprocessing operators for obtaining prepocessed data. The shape of input image for all operations is [H, W, C], where H is the image height, W is the image width, and C is the number of image channels.
+Compose preprocessing operators for obtaining prepocessed data. The shape of input image for all operations is [H, W, C], where `H` is the image height, `W` is the image width, and `C` is the number of image channels.
 
 **Args**
 * transforms(callmethod) : The method of preprocess images.

docs/tutorial/how_to_load_data.md

@@ -15,7 +15,7 @@
   ├─test_list.txt：测试集数据列表
   ├─validate_list.txt：验证集数据列表
   ├─label_list.txt：标签列表
-  └─……
+  └─...
 ```
 训练/验证/测试集的数据列表文件的格式如下
 ```
@@ -55,7 +55,6 @@ dandelion
 from paddlehub.datasets import Flowers
 
 flowers = Flowers(transforms)
-
 flowers_validate = Flowers(transforms, mode='val')
 ```
 * `transforms`: 数据预处理方式。
@@ -89,7 +88,7 @@ flowers_validate = Flowers(transforms, mode='val')
 ```
 
 示例：
-PaddleHub为用户提供了用于着色的数据集`Canvas数据集`， 它由1193张莫奈风格和400张梵高风格的图像组成，以[Canvas数据集](../reference/dataset.md)为示例，train文件夹内容如下:
+PaddleHub为用户提供了用于着色的数据集`Canvas数据集`， 它由1193张莫奈风格和400张梵高风格的图像组成，以[Canvas数据集](../reference/datasets.md)为示例，train文件夹内容如下:
 
 ```
 ├─train：训练集数据
@@ -115,39 +114,39 @@ color_set = Canvas(transforms, mode='train')
 * `transforms`: 数据预处理方式。
 * `mode`: 选择数据模式，可选项有 `train`, `test`, 默认为`train`。
 
-## 二、风格迁移数据集
+## 三、风格迁移数据集
 
 利用PaddleHub进行风格迁移任务使用自定义数据时，需要切分数据集，将数据集切分为训练集和测试集。 
 
 ### 数据准备
 
-需要将准备用于风格迁移训练和测试的彩色图像分成训练集数据和测试集数据。
+需要将准备用于风格迁移的彩色图像分成训练集和测试集数据。
 
 ```
 ├─data: 数据目录
   ├─train：训练集数据
       |-图片文件夹1
       |-图片文件夹2
-      |-……
+      |-...
       |-图片1
       |-图片2
-      |-……
+      |-...
 
   ├─test：测试集数据
     |-图片文件夹1
     |-图片文件夹2
-    |-……
+    |-...
     |-图片1
     |-图片2
-    |-……
+    |-...
   |- 21styles
     ｜-图片1
     ｜-图片2
-  └─……
+  └─...
 ```
 
 示例：
-PaddleHub为用户提供了用于风格迁移的数据集`Minicoco数据集`, 训练集数据和测试集数据来源于COCO2014， 其中训练集有2001张图片，测试集有200张图片。 `21styles`文件夹下存放着21张不同风格的图片，用户可以根据自己的需求更换不同风格的图片。以[Minicoco数据集](../reference/dataset.md)为示例，train文件夹内容如下:
+PaddleHub为用户提供了用于风格迁移的数据集`MiniCOCO数据集`, 训练集数据和测试集数据来源于COCO2014， 其中训练集有2001张图片，测试集有200张图片。 `21styles`文件夹下存放着21张不同风格的图片，用户可以根据自己的需求更换不同风格的图片。以[MiniCOCO数据集](../reference/datasets.md)为示例，train文件夹内容如下:
 
 ```
 ├─train：训练集数据
@@ -167,7 +166,7 @@ PaddleHub为用户提供了用于风格迁移的数据集`Minicoco数据集`,
 
 ### 数据集加载
 
-数据集的准备代码可以参考 [minicoco.py](../../paddlehub/datasets/minicoco.py)。`hub.datasets.Minicoco()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。具体使用如下：
+数据集的准备代码可以参考 [minicoco.py](../../paddlehub/datasets/minicoco.py)。`hub.datasets.MiniCOCO()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。具体使用如下：
 
 ```python
 from paddlehub.datasets import MiniCOCO

modules/image/classification/resnet50_vd_imagenet_ssld/label_list.txt

+tench
+goldfish
+great white shark
+tiger shark
+hammerhead
+electric ray
+stingray
+cock
+hen
+ostrich
+brambling
+goldfinch
+house finch
+junco
+indigo bunting
+robin
+bulbul
+jay
+magpie
+chickadee
+water ouzel
+kite
+bald eagle
+vulture
+great grey owl
+European fire salamander
+common newt
+eft
+spotted salamander
+axolotl
+bullfrog
+tree frog
+tailed frog
+loggerhead
+leatherback turtle
+mud turtle
+terrapin
+box turtle
+banded gecko
+common iguana
+American chameleon
+whiptail
+agama
+frilled lizard
+alligator lizard
+Gila monster
+green lizard
+African chameleon
+Komodo dragon
+African crocodile
+American alligator
+triceratops
+thunder snake
+ringneck snake
+hognose snake
+green snake
+king snake
+garter snake
+water snake
+vine snake
+night snake
+boa constrictor
+rock python
+Indian cobra
+green mamba
+sea snake
+horned viper
+diamondback
+sidewinder
+trilobite
+harvestman
+scorpion
+black and gold garden spider
+barn spider
+garden spider
+black widow
+tarantula
+wolf spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse
+prairie chicken
+peacock
+quail
+partridge
+African grey
+macaw
+sulphur-crested cockatoo
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser
+goose
+black swan
+tusker
+echidna
+platypus
+wallaby
+koala
+wombat
+jellyfish
+sea anemone
+brain coral
+flatworm
+nematode
+conch
+snail
+slug
+sea slug
+chiton
+chambered nautilus
+Dungeness crab
+rock crab
+fiddler crab
+king crab
+American lobster
+spiny lobster
+crayfish
+hermit crab
+isopod
+white stork
+black stork
+spoonbill
+flamingo
+little blue heron
+American egret
+bittern
+crane
+limpkin
+European gallinule
+American coot
+bustard
+ruddy turnstone
+red-backed sandpiper
+redshank
+dowitcher
+oystercatcher
+pelican
+king penguin
+albatross
+grey whale
+killer whale
+dugong
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog
+Pekinese
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound
+basset
+beagle
+bloodhound
+bluetick
+black-and-tan coonhound
+Walker hound
+English foxhound
+redbone
+borzoi
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound
+Norwegian elkhound
+otterhound
+Saluki
+Scottish deerhound
+Weimaraner
+Staffordshire bullterrier
+American Staffordshire terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier
+Airedale
+cairn
+Australian terrier
+Dandie Dinmont
+Boston bull
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier
+Tibetan terrier
+silky terrier
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla
+English setter
+Irish setter
+Gordon setter
+Brittany spaniel
+clumber
+English springer
+Welsh springer spaniel
+cocker spaniel
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog
+Shetland sheepdog
+collie
+Border collie
+Bouvier des Flandres
+Rottweiler
+German shepherd
+Doberman
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard
+Eskimo dog
+malamute
+Siberian husky
+dalmatian
+affenpinscher
+basenji
+pug
+Leonberg
+Newfoundland
+Great Pyrenees
+Samoyed
+Pomeranian
+chow
+keeshond
+Brabancon griffon
+Pembroke
+Cardigan
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf
+white wolf
+red wolf
+coyote
+dingo
+dhole
+African hunting dog
+hyena
+red fox
+kit fox
+Arctic fox
+grey fox
+tabby
+tiger cat
+Persian cat
+Siamese cat
+Egyptian cat
+cougar
+lynx
+leopard
+snow leopard
+jaguar
+lion
+tiger
+cheetah
+brown bear
+American black bear
+ice bear
+sloth bear
+mongoose
+meerkat
+tiger beetle
+ladybug
+ground beetle
+long-horned beetle
+leaf beetle
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant
+grasshopper
+cricket
+walking stick
+cockroach
+mantis
+cicada
+leafhopper
+lacewing
+dragonfly
+damselfly
+admiral
+ringlet
+monarch
+cabbage butterfly
+sulphur butterfly
+lycaenid
+starfish
+sea urchin
+sea cucumber
+wood rabbit
+hare
+Angora
+hamster
+porcupine
+fox squirrel
+marmot
+beaver
+guinea pig
+sorrel
+zebra
+hog
+wild boar
+warthog
+hippopotamus
+ox
+water buffalo
+bison
+ram
+bighorn
+ibex
+hartebeest
+impala
+gazelle
+Arabian camel
+llama
+weasel
+mink
+polecat
+black-footed ferret
+otter
+skunk
+badger
+armadillo
+three-toed sloth
+orangutan
+gorilla
+chimpanzee
+gibbon
+siamang
+guenon
+patas
+baboon
+macaque
+langur
+colobus
+proboscis monkey
+marmoset
+capuchin
+howler monkey
+titi
+spider monkey
+squirrel monkey
+Madagascar cat
+indri
+Indian elephant
+African elephant
+lesser panda
+giant panda
+barracouta
+eel
+coho
+rock beauty
+anemone fish
+sturgeon
+gar
+lionfish
+puffer
+abacus
+abaya
+academic gown
+accordion
+acoustic guitar
+aircraft carrier
+airliner
+airship
+altar
+ambulance
+amphibian
+analog clock
+apiary
+apron
+ashcan
+assault rifle
+backpack
+bakery
+balance beam
+balloon
+ballpoint
+Band Aid
+banjo
+bannister
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel
+barrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap
+bath towel
+bathtub
+beach wagon
+beacon
+beaker
+bearskin
+beer bottle
+beer glass
+bell cote
+bib
+bicycle-built-for-two
+bikini
+binder
+binoculars
+birdhouse
+boathouse
+bobsled
+bolo tie
+bonnet
+bookcase
+bookshop
+bottlecap
+bow
+bow tie
+brass
+brassiere
+breakwater
+breastplate
+broom
+bucket
+buckle
+bulletproof vest
+bullet train
+butcher shop
+cab
+caldron
+candle
+cannon
+canoe
+can opener
+cardigan
+car mirror
+carousel
+carpenters kit
+carton
+car wheel
+cash machine
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello
+cellular telephone
+chain
+chainlink fence
+chain mail
+chain saw
+chest
+chiffonier
+chime
+china cabinet
+Christmas stocking
+church
+cinema
+cleaver
+cliff dwelling
+cloak
+clog
+cocktail shaker
+coffee mug
+coffeepot
+coil
+combination lock
+computer keyboard
+confectionery
+container ship
+convertible
+corkscrew
+cornet
+cowboy boot
+cowboy hat
+cradle
+crane
+crash helmet
+crate
+crib
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam
+desk
+desktop computer
+dial telephone
+diaper
+digital clock
+digital watch
+dining table
+dishrag
+dishwasher
+disk brake
+dock
+dogsled
+dome
+doormat
+drilling platform
+drum
+drumstick
+dumbbell
+Dutch oven
+electric fan
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa
+file
+fireboat
+fire engine
+fire screen
+flagpole
+flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn
+frying pan
+fur coat
+garbage truck
+gasmask
+gas pump
+goblet
+go-kart
+golf ball
+golfcart
+gondola
+gong
+gown
+grand piano
+greenhouse
+grille
+grocery store
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower
+hand-held computer
+handkerchief
+hard disc
+harmonica
+harp
+harvester
+hatchet
+holster
+home theater
+honeycomb
+hook
+hoopskirt
+horizontal bar
+horse cart
+hourglass
+iPod
+iron
+jack-o-lantern
+jean
+jeep
+jersey
+jigsaw puzzle
+jinrikisha
+joystick
+kimono
+knee pad
+knot
+lab coat
+ladle
+lampshade
+laptop
+lawn mower
+lens cap
+letter opener
+library
+lifeboat
+lighter
+limousine
+liner
+lipstick
+Loafer
+lotion
+loudspeaker
+loupe
+lumbermill
+magnetic compass
+mailbag
+mailbox
+maillot
+maillot
+manhole cover
+maraca
+marimba
+mask
+matchstick
+maypole
+maze
+measuring cup
+medicine chest
+megalith
+microphone
+microwave
+military uniform
+milk can
+minibus
+miniskirt
+minivan
+missile
+mitten
+mixing bowl
+mobile home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter
+mountain bike
+mountain tent
+mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook
+obelisk
+oboe
+ocarina
+odometer
+oil filter
+organ
+oscilloscope
+overskirt
+oxcart
+oxygen mask
+packet
+paddle
+paddlewheel
+padlock
+paintbrush
+pajama
+palace
+panpipe
+paper towel
+parachute
+parallel bars
+park bench
+parking meter
+passenger car
+patio
+pay-phone
+pedestal
+pencil box
+pencil sharpener
+perfume
+Petri dish
+photocopier
+pick
+pickelhaube
+picket fence
+pickup
+pier
+piggy bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate
+pitcher
+plane
+planetarium
+plastic bag
+plate rack
+plow
+plunger
+Polaroid camera
+pole
+police van
+poncho
+pool table
+pop bottle
+pot
+potters wheel
+power drill
+prayer rug
+printer
+prison
+projectile
+projector
+puck
+punching bag
+purse
+quill
+quilt
+racer
+racket
+radiator
+radio
+radio telescope
+rain barrel
+recreational vehicle
+reel
+reflex camera
+refrigerator
+remote control
+restaurant
+revolver
+rifle
+rocking chair
+rotisserie
+rubber eraser
+rugby ball
+rule
+running shoe
+safe
+safety pin
+saltshaker
+sandal
+sarong
+sax
+scabbard
+scale
+school bus
+schooner
+scoreboard
+screen
+screw
+screwdriver
+seat belt
+sewing machine
+shield
+shoe shop
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule
+sliding door
+slot
+snorkel
+snowmobile
+snowplow
+soap dispenser
+soccer ball
+sock
+solar dish
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web
+spindle
+sports car
+spotlight
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch
+stove
+strainer
+streetcar
+stretcher
+studio couch
+stupa
+submarine
+suit
+sundial
+sunglass
+sunglasses
+sunscreen
+suspension bridge
+swab
+sweatshirt
+swimming trunks
+swing
+switch
+syringe
+table lamp
+tank
+tape player
+teapot
+teddy
+television
+tennis ball
+thatch
+theater curtain
+thimble
+thresher
+throne
+tile roof
+toaster
+tobacco shop
+toilet seat
+torch
+totem pole
+tow truck
+toyshop
+tractor
+trailer truck
+tray
+trench coat
+tricycle
+trimaran
+tripod
+triumphal arch
+trolleybus
+trombone
+tub
+turnstile
+typewriter keyboard
+umbrella
+unicycle
+upright
+vacuum
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin
+volleyball
+waffle iron
+wall clock
+wallet
+wardrobe
+warplane
+washbasin
+washer
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool
+worm fence
+wreck
+yawl
+yurt
+web site
+comic book
+crossword puzzle
+street sign
+traffic light
+book jacket
+menu
+plate
+guacamole
+consomme
+hot pot
+trifle
+ice cream
+ice lolly
+French loaf
+bagel
+pretzel
+cheeseburger
+hotdog
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini
+spaghetti squash
+acorn squash
+butternut squash
+cucumber
+artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple
+banana
+jackfruit
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce
+dough
+meat loaf
+pizza
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff
+coral reef
+geyser
+lakeside
+promontory
+sandbar
+seashore
+valley
+volcano
+ballplayer
+groom
+scuba diver
+rapeseed
+daisy
+yellow ladys slipper
+corn
+acorn
+hip
+buckeye
+coral fungus
+agaric
+gyromitra
+stinkhorn
+earthstar
+hen-of-the-woods
+bolete
+ear
+toilet tissue
\ No newline at end of file

modules/image/classification/resnet50_vd_imagenet_ssld/module.py

@@ -182,12 +182,22 @@ class BasicBlock(nn.Layer):
 class ResNet50_vd(nn.Layer):
     """ResNet50_vd model."""
 
-    def __init__(self, label_list: list, load_checkpoint: str = None):
+    def __init__(self, label_list: list = None, load_checkpoint: str = None):
         super(ResNet50_vd, self).__init__()
 
         self.layers = 50
-        self.labels = label_list
-        class_dim = len(self.labels)
+        if label_list is not None:
+            self.labels = label_list
+            class_dim = len(self.labels)
+        else:
+            label_list = []
+            label_file = os.path.join(self.directory, 'label_list.txt')
+            files = open(label_file)
+            for line in files.readlines():  
+                line=line.strip('\n') 
+                label_list.append(line)
+            self.labels = label_list
+            class_dim = len(self.labels)
         depth = [3, 4, 6, 3]
         num_channels = [64, 256, 512, 1024]
         num_filters = [64, 128, 256, 512]
@@ -227,18 +237,18 @@ class ResNet50_vd(nn.Layer):
             bias_attr=ParamAttr(name="fc_0.b_0"))
 
         if load_checkpoint is not None:
-            model_dict = paddle.load(load_checkpoint)[0]
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(load_checkpoint)[0]
+            self.set_dict(self.model_dict)
             print("load custom checkpoint success")
 
         else:
             checkpoint = os.path.join(self.directory, 'resnet50_vd_ssld.pdparams')
-            model_dict = paddle.load(checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(checkpoint)
+            self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
             
     def transforms(self, images: Union[str, np.ndarray]):
-        transforms = T.Compose([T.Resize((224, 224)), T.Normalize()])
+        transforms = T.Compose([T.Resize((256, 256)), T.CenterCrop(224), T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])], to_rgb=True)
         return transforms(images)
 
     def forward(self, inputs: paddle.Tensor):
@@ -251,4 +261,4 @@ class ResNet50_vd(nn.Layer):
         feature = self.pool2d_avg(y)
         y = paddle.reshape(feature, shape=[-1, self.pool2d_avg_channels])
         y = self.out(y)
-        return y, feature
+        return y, feature
\ No newline at end of file

modules/image/colorization/user_guided_colorization/data_feed.py

@@ -130,4 +130,4 @@ class ColorizePreprocess:
         data['real_B_enc'] = paddle.to_tensor(data['real_B_enc'].astype(np.int64))
         data['hint_B'] = paddle.to_tensor(data['hint_B'].astype(np.float32))
         data['mask_B'] = paddle.to_tensor(data['mask_B'].astype(np.float32))
-        return data
+        return data
\ No newline at end of file

modules/image/colorization/user_guided_colorization/module.py

@@ -37,18 +37,14 @@ class UserGuidedColorization(nn.Layer):
 
     Args:
         use_tanh (bool): Whether to use tanh as final activation function.
-        classification (bool): Whether to switch classification branch for optimization.
         load_checkpoint (str): Pretrained checkpoint path.
 
     """
 
-    def __init__(self, use_tanh: bool = True, classification: bool = True, load_checkpoint: str = None,
-                 ab_thresh: float = 0., prob: float = 1., num_point: int = None):
+    def __init__(self, use_tanh: bool = True, load_checkpoint: str = None):
         super(UserGuidedColorization, self).__init__()
         self.input_nc = 4
         self.output_nc = 2
-        self.classification = classification
-        self.pre_func = ColorizePreprocess(ab_thresh=ab_thresh, p=prob, points=num_point)
         # Conv1
         model1 = (
             Conv2D(self.input_nc, 64, 3, 1, 1),
@@ -169,20 +165,26 @@ class UserGuidedColorization(nn.Layer):
         self.model_class = nn.Sequential(*model_class)
         self.model_out = nn.Sequential(*model_out)
 
+        self.set_config()
+
         if load_checkpoint is not None:
-            model_dict = paddle.load(load_checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(load_checkpoint)
+            self.set_dict(self.model_dict)
             print("load custom checkpoint success")
         else:
             checkpoint = os.path.join(self.directory, 'user_guided.pdparams')
-            model_dict = paddle.load(checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(checkpoint)
+            self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
 
     def transforms(self, images: str) -> callable:
  
         transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'), T.RGB2LAB()], to_rgb=True)
         return transform(images)
+    
+    def set_config(self, classification: bool = True, prob: float = 1., num_point: int = None):
+        self.classification = classification
+        self.pre_func = ColorizePreprocess(ab_thresh=0., p=prob, points=num_point)
 
     def preprocess(self, inputs: paddle.Tensor):
         output = self.pre_func(inputs)

modules/image/keypoint_detection/openpose_body_estimation/module.py

@@ -13,17 +13,21 @@
 # limitations under the License.
 
 import os
+import time
 import copy
+import base64
+import argparse
+from typing import Union
 from collections import OrderedDict
 
 import cv2
 import paddle
 import paddle.nn as nn
 import numpy as np
-from paddlehub.transforms.module import moduleinfo
-import paddlehub.transforms.transforms as T
+from paddlehub.module.module import moduleinfo, runnable, serving
+import paddlehub.vision.transforms as T
 import openpose_body_estimation.processor as P
-    
+
 
 @moduleinfo(
     name="openpose_body_estimation",
@@ -39,10 +43,9 @@ class BodyPoseModel(nn.Layer):
 
     Args:
         load_checkpoint(str): Checkpoint save path, default is None.
-        visualization (bool): Whether to save the estimation result. Default is True.
     """
 
-    def __init__(self, load_checkpoint: str = None, visualization: bool = True):
+    def __init__(self, load_checkpoint: str = None):
         super(BodyPoseModel, self).__init__()
 
         self.resize_func = P.ResizeScaling()
@@ -53,7 +56,6 @@ class BodyPoseModel(nn.Layer):
         self.get_connection = P.Connection()
         self.get_candidate = P.Candidate()
         self.draw_pose = P.DrawPose()
-        self.visualization = visualization
 
         no_relu_layers = ['conv5_5_CPM_L1', 'conv5_5_CPM_L2', 'Mconv7_stage2_L1', \
                           'Mconv7_stage2_L2', 'Mconv7_stage3_L1', 'Mconv7_stage3_L2', \
@@ -116,14 +118,14 @@ class BodyPoseModel(nn.Layer):
         self.model6_2 = blocks['block6_2']
 
         if load_checkpoint is not None:
-            model_dict = paddle.load(load_checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(load_checkpoint)
+            self.set_dict(self.model_dict)
             print("load custom checkpoint success")
 
         else:
             checkpoint = os.path.join(self.directory, 'openpose_body.pdparams')
-            model_dict = paddle.load(checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(checkpoint)
+            self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
 
     def make_layers(self, block: dict, no_relu_layers: list):
@@ -177,9 +179,13 @@ class BodyPoseModel(nn.Layer):
 
         return out6_1, out6_2
 
-    def predict(self, img_path: str, save_path: str = "result"):
+    def predict(self, img: Union[str, np.ndarray], save_path: str = "openpose_body", visualization: bool = True):
         self.eval()
-        orgImg = cv2.imread(img_path)
+        self.visualization = visualization
+        if isinstance(img, str):
+            orgImg = cv2.imread(img)
+        else:
+            orgImg = img
         data, imageToTest_padded, pad = self.transform(orgImg)
         Mconv7_stage6_L1, Mconv7_stage6_L2 = self.forward(paddle.to_tensor(data))
         Mconv7_stage6_L1 = Mconv7_stage6_L1.numpy()
@@ -192,11 +198,81 @@ class BodyPoseModel(nn.Layer):
         connection_all, special_k = self.get_connection(all_peaks, paf_avg, orgImg)
         candidate, subset = self.get_candidate(all_peaks, connection_all, special_k)
 
+        canvas = copy.deepcopy(orgImg)
+        canvas = self.draw_pose(canvas, candidate, subset)
         if self.visualization:
-            canvas = copy.deepcopy(orgImg)
-            canvas = self.draw_pose(canvas, candidate, subset)
             if not os.path.exists(save_path):
                 os.mkdir(save_path)
-            save_path = os.path.join(save_path, img_path.rsplit("/", 1)[-1])
+            img_name = str(time.time()) + '.png'
+            save_path = os.path.join(save_path, img_name)
             cv2.imwrite(save_path, canvas)
-        return candidate, subset
+            
+        results = {
+            'candidate': candidate,
+            'subset': subset,
+            'data': canvas}
+
+        return results
+
+    @serving
+    def serving_method(self, images: list, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [P.base64_to_cv2(image) for image in images]
+        results = self.predict(img=images_decode[0], **kwargs)
+        final={}
+        final['candidate'] = P.cv2_to_base64(results['candidate'])
+        final['subset'] = P.cv2_to_base64(results['subset'])
+        final['data'] = P.cv2_to_base64(results['data'])
+        
+        return final
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.predict(
+            img=args.input_path,
+            save_path=args.output_dir,
+            visualization=args.visualization)
+
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+
+        self.arg_config_group.add_argument(
+            '--output_dir',
+            type=str,
+            default='openpose_body',
+            help="The directory to save output images.")
+        self.arg_config_group.add_argument(
+            '--visualization',
+            type=bool,
+            default=True,
+            help="whether to save output as images.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
\ No newline at end of file

modules/image/keypoint_detection/openpose_body_estimation/processor.py

+import os
+import base64
 import math
 from typing import Callable
 
@@ -328,3 +330,15 @@ class ResizeScaling:
         scale = scale_search * self.target / img.shape[0]
         resize_img = cv2.resize(img, (0, 0), fx=scale, fy=scale, interpolation=self.interpolation)
         return resize_img
+
+
+def cv2_to_base64(image: np.ndarray):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+def base64_to_cv2(b64str: str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data
\ No newline at end of file

modules/image/keypoint_detection/openpose_hands_estimation/module.py

@@ -13,7 +13,11 @@
 # limitations under the License.
 
 import os
+import base64
 import copy
+import time
+import argparse
+from typing import Union
 from collections import OrderedDict
 
 import cv2
@@ -23,7 +27,7 @@ import paddle.nn as nn
 import paddlehub as hub
 from skimage.measure import label
 from scipy.ndimage.filters import gaussian_filter
-from paddlehub.module.module import moduleinfo
+from paddlehub.module.module import moduleinfo, runnable, serving
 import paddlehub.vision.transforms as T
 
 import openpose_hands_estimation.processor as P
@@ -43,12 +47,10 @@ class HandPoseModel(nn.Layer):
 
     Args:
         load_checkpoint(str): Checkpoint save path, default is None.
-        visualization (bool): Whether to save the estimation result. Default is True.
     """
 
-    def __init__(self, load_checkpoint: str = None, visualization: bool = True):
+    def __init__(self, load_checkpoint: str = None):
         super(HandPoseModel, self).__init__()
-        self.visualization = visualization
         
         self.norm_func = T.Normalize(std=[1, 1, 1])
         self.resize_func = P.ResizeScaling()
@@ -98,15 +100,16 @@ class HandPoseModel(nn.Layer):
         self.model6 = blocks['block6']
 
         if load_checkpoint is not None:
-            model_dict = paddle.load(load_checkpoint)[0]
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(load_checkpoint)[0]
+            self.set_dict(self.model_dict)
             print("load custom checkpoint success")
 
         else:
             checkpoint = os.path.join(self.directory, 'openpose_hand.pdparams')
-            model_dict = paddle.load(checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(checkpoint)
+            self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
+        self.body_model = None
 
     def make_layers(self, block: dict, no_relu_layers: list):
         layers = []
@@ -139,7 +142,6 @@ class HandPoseModel(nn.Layer):
 
     def hand_estimation(self, handimg: np.ndarray, scale_search: list):
         heatmap_avg = np.zeros((handimg.shape[0], handimg.shape[1], 22))
-
         for scale in scale_search:
             process = self.resize_func(handimg, scale)
             imageToTest_padded, pad = self.pad_func(process)
@@ -168,14 +170,20 @@ class HandPoseModel(nn.Layer):
 
         return np.array(all_peaks)
 
-    def predict(self, img_path: str, save_path: str = 'result', scale: list = [0.5, 1.0, 1.5, 2.0]):
+    def predict(self, img: Union[str, np.ndarray], save_path: str = 'openpose_hand', scale: list = [0.5, 1.0, 1.5, 2.0], visualization: bool = True):
         self.eval()
-        self.body_model = hub.Module(name='openpose_body_estimation')
-        self.body_model.eval()
-        org_img = cv2.imread(img_path)
+        self.visualization = visualization
+        if isinstance(img, str):
+            org_img = cv2.imread(img)
+        else:
+            org_img = img
+            
+        if not self.body_model:
+            self.body_model = hub.Module(name='openpose_body_estimation')
+            self.body_model.eval()
 
-        candidate, subset = self.body_model.predict(img_path)
-        hands_list = self.hand_detect(candidate, subset, org_img)
+        body_result = self.body_model.predict(org_img)
+        hands_list = self.hand_detect(body_result['candidate'], body_result['subset'], org_img)
 
         all_hand_peaks = []
 
@@ -184,13 +192,85 @@ class HandPoseModel(nn.Layer):
             peaks[:, 0] = np.where(peaks[:, 0] == 0, peaks[:, 0], peaks[:, 0] + x)
             peaks[:, 1] = np.where(peaks[:, 1] == 0, peaks[:, 1], peaks[:, 1] + y)
             all_hand_peaks.append(peaks)
-
+        canvas = copy.deepcopy(org_img)
+        canvas = self.draw_pose(canvas, body_result['candidate'], body_result['subset'],)
+        canvas = self.draw_hand(canvas, all_hand_peaks)
         if self.visualization:
-            canvas = copy.deepcopy(org_img)
-            canvas = self.draw_pose(canvas, candidate, subset)
-            canvas = self.draw_hand(canvas, all_hand_peaks)
             if not os.path.exists(save_path):
                 os.mkdir(save_path)
-            save_path = os.path.join(save_path, img_path.rsplit("/", 1)[-1])
+            img_name = str(time.time()) + '.png'
+            save_path = os.path.join(save_path, img_name)
             cv2.imwrite(save_path, canvas)
-        return all_hand_peaks
\ No newline at end of file
+            
+        results = {
+            'all_hand_peaks': all_hand_peaks,
+            'data': canvas}
+
+        return results
+
+    @serving
+    def serving_method(self, images: list, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [P.base64_to_cv2(image) for image in images]
+        results = self.predict(img=images_decode[0], **kwargs)
+        final={}
+        final['all_hand_peaks']=[peak.tolist() for peak in results['all_hand_peaks']]
+        final['data'] = P.cv2_to_base64(results['data'])
+        return final
+    
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.predict(
+            img=args.input_path,
+            save_path=args.output_dir,
+            scale=args.scale,
+            visualization=args.visualization)
+
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+
+        self.arg_config_group.add_argument(
+            '--output_dir',
+            type=str,
+            default='openpose_hand',
+            help="The directory to save output images.")
+        self.arg_config_group.add_argument(
+            '--scale',
+            type=list,
+            default=[0.5, 1.0, 1.5, 2.0],
+            help="The search scale for openpose hands model.")
+        self.arg_config_group.add_argument(
+            '--visualization',
+            type=bool,
+            default=True,
+            help="whether to save output as images.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
\ No newline at end of file

modules/image/keypoint_detection/openpose_hands_estimation/processor.py

+import os
 import math
+import base64
 from typing import Callable
 
 import cv2
@@ -230,7 +232,6 @@ class ResizeScaling:
         resize_img = cv2.resize(img, (0, 0), fx=scale, fy=scale, interpolation=self.interpolation)
         return resize_img
     
-    
 def npmax(array: np.ndarray):
     """Get max value and index."""
     arrayindex = array.argmax(1)
@@ -238,3 +239,15 @@ def npmax(array: np.ndarray):
     i = arrayvalue.argmax()
     j = arrayindex[i]
     return i, j
+
+
+def cv2_to_base64(image: np.ndarray):
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
+
+
+def base64_to_cv2(b64str: str):
+    data = base64.b64decode(b64str.encode('utf8'))
+    data = np.fromstring(data, np.uint8)
+    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    return data

modules/image/style_transfer/msgnet/module.py

 import os
+import argparse
 
 import paddle
 import paddle.nn as nn
@@ -305,8 +306,8 @@ class MSGNet(nn.Layer):
         self.model = nn.Sequential(*model)
 
         if load_checkpoint is not None:
-            model_dict = paddle.load(load_checkpoint)
-            self.set_dict(model_dict)
+            self.model_dict = paddle.load(load_checkpoint)
+            self.set_dict(self.model_dict)
             print("load custom checkpoint success")
 
         else:
@@ -319,6 +320,7 @@ class MSGNet(nn.Layer):
                     model_dict[name] = paddle.zeros(shape=model_dict[name].shape, dtype='float32')
                     model_dict[key] = paddle.ones(shape=model_dict[key].shape, dtype='float32')
             self.set_dict(model_dict)
+            self.model_dict = model_dict
             print("load pretrained checkpoint success")
 
         self._vgg = None

paddlehub/module/cv_module.py

@@ -15,7 +15,9 @@
 
 import time
 import os
-from typing import List
+import base64
+import argparse
+from typing import List, Union
 from collections import OrderedDict
 
 import cv2
@@ -28,8 +30,8 @@ from PIL import Image
 import paddlehub.vision.transforms as T
 import paddlehub.vision.functional as Func
 from paddlehub.vision import utils
-from paddlehub.module.module import serving, RunModule
-from paddlehub.utils.utils import base64_to_cv2
+from paddlehub.module.module import serving, RunModule, runnable
+from paddlehub.utils.utils import base64_to_cv2, cv2_to_base64
 
 
 class ImageServing(object):
@@ -70,40 +72,112 @@ class ImageClassifierModule(RunModule, ImageServing):
         labels = paddle.unsqueeze(batch[1], axis=-1)
 
         preds, feature = self(images)
-        
+    
         loss, _ = F.softmax_with_cross_entropy(preds, labels, return_softmax=True, axis=1)
         loss = paddle.mean(loss)
         acc = paddle.metric.accuracy(preds, labels)
         return {'loss': loss, 'metrics': {'acc': acc}}
 
-    def predict(self, images: List[np.ndarray], top_k: int = 1) -> List[dict]:
+    def predict(self, images: List[np.ndarray], batch_size: int = 1, top_k: int = 1) -> List[dict]:
         '''
         Predict images
 
         Args:
             images(list[numpy.ndarray]) : Images to be predicted, consist of np.ndarray in bgr format.
+            batch_size(int) : Batch size for prediciton.
             top_k(int) : Output top k result of each image.
 
         Returns:
             results(list[dict]) : The prediction result of each input image
         '''
-        images = self.transforms(images)
-        if len(images.shape) == 3:
-            images = images[np.newaxis, :]
-        preds, feature = self(paddle.to_tensor(images))
-        preds = F.softmax(preds, axis=1).numpy()
-        pred_idxs = np.argsort(preds)[::-1][:, :top_k]
+        self.eval()
         res = []
+        total_num = len(images)
+        loop_num = int(np.ceil(total_num / batch_size))
+ 
+        for iter_id in range(loop_num):
+            batch_data = []
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    image = self.transforms(images[handle_id + image_id])
+                    batch_data.append(image)
+                except:
+                    pass
+            batch_image = np.array(batch_data)
+            preds, feature = self(paddle.to_tensor(batch_image))
+            preds = F.softmax(preds, axis=1).numpy()
+            pred_idxs = np.argsort(preds)[:, ::-1][:, :top_k]
+            
+            for i, pred in enumerate(pred_idxs):
+                res_dict = {}
+                for k in pred:
+                    class_name = self.labels[int(k)]
+                    res_dict[class_name] = preds[i][k]
+                     
+                res.append(res_dict)   
 
-        for i, pred in enumerate(pred_idxs):
-            res_dict = {}
-            for k in pred:
-                class_name = self.labels[int(k)]
-                res_dict[class_name] = preds[i][k]
-            res.append(res_dict)
         return res
 
+    @serving
+    def serving_method(self, images: list, top_k: int, **kwargs):
+        """
+        Run as a service.
+        """
+        top_k = int(top_k)
+        images_decode = [base64_to_cv2(image) for image in images]
+        resdicts = self.predict(images=images_decode, top_k=top_k,**kwargs)
+        final={}
+        for resdict in resdicts:
+            for key, value in resdict.items():
+                resdict[key] = float(value)
+        final['data'] = resdicts
+        return final
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.predict(
+            images=[args.input_path],
+            top_k=args.top_k)
 
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+
+        self.arg_config_group.add_argument(
+            '--top_k',
+            type=int,
+            default=1,
+            help="top_k classification result.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+
+       
 class ImageColorizeModule(RunModule, ImageServing):
     def training_step(self, batch: int, batch_idx: int) -> dict:
         '''
@@ -138,60 +212,135 @@ class ImageColorizeModule(RunModule, ImageServing):
         loss_G_L1_reg = paddle.sum(paddle.abs(img['B'] - out_reg), axis=1, keepdim=True)
         loss_G_L1_reg = paddle.mean(loss_G_L1_reg)
         loss = loss_ce + loss_G_L1_reg
-
         return {'loss': loss}
 
-    def predict(self, images: str, visualization: bool = True, save_path: str = 'result'):
+    def predict(self, images: list, visualization: bool = True, batch_size: int = 1, save_path: str = 'colorization'):
         '''
         Colorize images
 
         Args:
-            images(str|np.ndarray) : Images path or BGR image to be colorized.
+            images(list[str|np.ndarray]) : Images path or BGR image to be colorized.
             visualization(bool): Whether to save colorized images.
+            batch_size(int): Batch size for prediciton.
             save_path(str) : Path to save colorized images.
 
         Returns:
-            results(list[dict]) : The prediction result of each input image
+            res(list[dict]) : The prediction result of each input image
         '''
         self.eval()
         lab2rgb = T.LAB2RGB()
+        res = []
+        total_num = len(images)
+        loop_num = int(np.ceil(total_num / batch_size))
+        for iter_id in range(loop_num):
+            batch_data = []
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    image = self.transforms(images[handle_id + image_id])
+                    batch_data.append(image)
+                except:
+                    pass
+            batch_data = np.array(batch_data)
+            im = self.preprocess(batch_data)
+            out_class, out_reg = self(im['A'], im['hint_B'], im['mask_B'])
+
+            visual_ret = OrderedDict()
+            for i in range(im['A'].shape[0]):
+                gray = lab2rgb(np.concatenate((im['A'].numpy(), np.zeros(im['B'].shape)), axis=1))[i]
+                gray = np.clip(np.transpose(gray, (1, 2, 0)), 0, 1) * 255
+                visual_ret['gray'] = gray.astype(np.uint8)
+                hint = lab2rgb(np.concatenate((im['A'].numpy(), im['hint_B'].numpy()), axis=1))[i]
+                hint = np.clip(np.transpose(hint, (1, 2, 0)), 0, 1) * 255
+                visual_ret['hint'] = hint.astype(np.uint8)
+                real = lab2rgb(np.concatenate((im['A'].numpy(), im['B'].numpy()), axis=1))[i]
+                real = np.clip(np.transpose(real, (1, 2, 0)), 0, 1) * 255
+                visual_ret['real'] = real.astype(np.uint8)
+                fake = lab2rgb(np.concatenate((im['A'].numpy(), out_reg.numpy()), axis=1))[i]
+                fake = np.clip(np.transpose(fake, (1, 2, 0)), 0, 1) * 255
+                visual_ret['fake_reg'] = fake.astype(np.uint8)
+
+                if visualization:
+                    if isinstance(images[handle_id + i], str):
+                        org_img = cv2.imread(images[handle_id + i]).astype('float32')
+                    else:
+                        org_img = images[handle_id + i]
+                    h, w, c = org_img.shape
+                    fake_name = "fake_" + str(time.time()) + ".png"
+                    if not os.path.exists(save_path):
+                        os.mkdir(save_path)
+                    fake_path = os.path.join(save_path, fake_name)
+                    visual_gray = Image.fromarray(visual_ret['fake_reg'])
+                    visual_gray = visual_gray.resize((w, h), Image.BILINEAR)
+                    visual_gray.save(fake_path)
+
+                res.append(visual_ret)
+        return res
 
-        if isinstance(images, str):
-            images = cv2.imread(images).astype('float32')
-
-        im = self.transforms(images)
-        im = im[np.newaxis, :, :, :]
-        im = self.preprocess(im)
-        out_class, out_reg = self(im['A'], im['hint_B'], im['mask_B'])
-
-        result = []
-        visual_ret = OrderedDict()
-        for i in range(im['A'].shape[0]):
-            gray = lab2rgb(np.concatenate((im['A'].numpy(), np.zeros(im['B'].shape)), axis=1))[i]
-            gray = np.clip(np.transpose(gray, (1, 2, 0)), 0, 1) * 255
-            visual_ret['gray'] = gray.astype(np.uint8)
-            hint = lab2rgb(np.concatenate((im['A'].numpy(), im['hint_B'].numpy()), axis=1))[i]
-            hint = np.clip(np.transpose(hint, (1, 2, 0)), 0, 1) * 255
-            visual_ret['hint'] = hint.astype(np.uint8)
-            real = lab2rgb(np.concatenate((im['A'].numpy(), im['B'].numpy()), axis=1))[i]
-            real = np.clip(np.transpose(real, (1, 2, 0)), 0, 1) * 255
-            visual_ret['real'] = real.astype(np.uint8)
-            fake = lab2rgb(np.concatenate((im['A'].numpy(), out_reg.numpy()), axis=1))[i]
-            fake = np.clip(np.transpose(fake, (1, 2, 0)), 0, 1) * 255
-            visual_ret['fake_reg'] = fake.astype(np.uint8)
-
-            if visualization:
-                h, w, c = images.shape
-                fake_name = "fake_" + str(time.time()) + ".png"
-                if not os.path.exists(save_path):
-                    os.mkdir(save_path)
-                fake_path = os.path.join(save_path, fake_name)
-                visual_gray = Image.fromarray(visual_ret['fake_reg'])
-                visual_gray = visual_gray.resize((w, h), Image.BILINEAR)
-                visual_gray.save(fake_path)
-
-            result.append(visual_ret)
-        return result
+    @serving
+    def serving_method(self, images: list, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images]
+        visual = self.predict(images=images_decode, **kwargs)
+        final={}
+        for i, visual_ret in enumerate(visual):
+            h, w, c = images_decode[i].shape
+            for key, value in visual_ret.items():
+                value = cv2.resize(cv2.cvtColor(value,cv2.COLOR_RGB2BGR), (w, h), cv2.INTER_NEAREST)
+                visual_ret[key] = cv2_to_base64(value)
+        final['data'] = visual
+        return final
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.predict(
+            images=[args.input_path],
+            visualization=args.visualization,
+            save_path=args.output_dir)
+
+        return results
+
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+
+        self.arg_config_group.add_argument(
+            '--output_dir',
+            type=str,
+            default='colorization',
+            help="save visualization result.")
+        self.arg_config_group.add_argument(
+            '--visualization',
+            type=bool,
+            default=True,
+            help="whether to save output as images.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
 
 
 class Yolov3Module(RunModule, ImageServing):
@@ -370,35 +519,114 @@ class StyleTransferModule(RunModule, ImageServing):
 
         return {'loss': loss, 'metrics': {'content gap': content_loss, 'style gap': style_loss}}
 
-    def predict(self, origin: str, style: str, visualization: bool = True, save_path: str = 'result'):
+    def predict(self, origin: list, style: Union[str, np.ndarray], batch_size: int = 1, visualization: bool = True, save_path: str = 'style_tranfer'):
         '''
         Colorize images
 
         Args:
-            origin(str|np.array): Content image path or BGR image.
+            origin(list[str|np.array]): Content image path or BGR image.
             style(str|np.array): Style image path or BGR image.
+            batch_size(int): Batch size for prediciton.
             visualization(bool): Whether to save colorized images.
             save_path(str) : Path to save colorized images.
 
         Returns:
-            output(np.ndarray) : The style transformed images with bgr mode.
+            output(list[np.ndarray]) : The style transformed images with bgr mode.
         '''
         self.eval()
-
-        content = paddle.to_tensor(self.transform(origin).astype('float32'))
         style = paddle.to_tensor(self.transform(style).astype('float32'))
-        content = content.unsqueeze(0)
         style = style.unsqueeze(0)
 
-        self.setTarget(style)
-        output = self(content)
-        output = paddle.clip(output[0].transpose((1, 2, 0)), 0, 255).numpy()
+        res = []
+        total_num = len(origin)
+        loop_num = int(np.ceil(total_num / batch_size))
+        for iter_id in range(loop_num):
+            batch_data = []
+            handle_id = iter_id * batch_size
+            for image_id in range(batch_size):
+                try:
+                    image = self.transform(origin[handle_id + image_id])
+                    batch_data.append(image.astype('float32'))
+                except:
+                    pass
+
+            batch_image = np.array(batch_data)    
+            content = paddle.to_tensor(batch_image)
+
+            self.setTarget(style)
+            output = self(content)
+            for num in range(batch_size):
+                out = paddle.clip(output[num].transpose((1, 2, 0)), 0, 255).numpy().astype(np.uint8)
+                res.append(out)
+                if visualization:
+                    style_name = "style_" + str(time.time()) + ".png"
+                    if not os.path.exists(save_path):
+                        os.mkdir(save_path)
+                    path = os.path.join(save_path, style_name)
+                    cv2.imwrite(path, out)
+        return res
 
-        if visualization:
-            output = output.astype(np.uint8)
-            style_name = "style_" + str(time.time()) + ".png"
-            if not os.path.exists(save_path):
-                os.mkdir(save_path)
-            path = os.path.join(save_path, style_name)
-            cv2.imwrite(path, output)
-        return output
+    @serving
+    def serving_method(self, images: list, **kwargs):
+        """
+        Run as a service.
+        """
+        images_decode = [base64_to_cv2(image) for image in images[0]]
+        style_decode = base64_to_cv2(images[1])
+        results = self.predict(origin=images_decode, style=style_decode, **kwargs)
+        final={}
+        final['data'] = [cv2_to_base64(result) for result in results]
+        return final
+
+    @runnable
+    def run_cmd(self, argvs: list):
+        """
+        Run as a command.
+        """
+        self.parser = argparse.ArgumentParser(
+            description="Run the {} module.".format(self.name),
+            prog='hub run {}'.format(self.name),
+            usage='%(prog)s',
+            add_help=True)
+        self.arg_input_group = self.parser.add_argument_group(
+            title="Input options", description="Input data. Required")
+        self.arg_config_group = self.parser.add_argument_group(
+            title="Config options",
+            description=
+            "Run configuration for controlling module behavior, not required.")
+        self.add_module_config_arg()
+        self.add_module_input_arg()
+        args = self.parser.parse_args(argvs)
+        results = self.predict(
+            origin=[args.input_path],
+            style=args.style_path,
+            save_path=args.output_dir,
+            visualization=args.visualization)
+
+        return results
+        
+    def add_module_config_arg(self):
+        """
+        Add the command config options.
+        """
+
+        self.arg_config_group.add_argument(
+            '--output_dir',
+            type=str,
+            default='style_tranfer',
+            help="The directory to save output images.")
+
+        self.arg_config_group.add_argument(
+            '--visualization',
+            type=bool,
+            default=True,
+            help="whether to save output as images.")
+
+    def add_module_input_arg(self):
+        """
+        Add the command input options.
+        """
+        self.arg_input_group.add_argument(
+            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument(
+            '--style_path', type=str, help="path to style image.")
\ No newline at end of file

paddlehub/module/module.py

@@ -66,6 +66,17 @@ def serving(func: Callable) -> Callable:
 class RunModule(object):
     '''The base class of PaddleHub Module, users can inherit this class to implement to realize custom class.'''
 
+    def __init__(self, *args, **kwargs):
+        # Avoid module being initialized multiple times
+        if '_is_initialize' in self.__dict__ and self._is_initialize:
+            return
+
+        super(RunModule, self).__init__()
+        _run_func_name = self._get_func_name(self.__class__, _module_runnable_func)
+        self._run_func = getattr(self, _run_func_name) if _run_func_name else None
+        self._serving_func_name = self._get_func_name(self.__class__, _module_serving_func)
+        self._is_initialize = True
+
     def _get_func_name(self, current_cls: Generic, module_func_dict: dict) -> Optional[str]:
         mod = current_cls.__module__ + '.' + current_cls.__name__
         if mod in module_func_dict:
@@ -73,7 +84,9 @@ class RunModule(object):
             return _func_name
         elif current_cls.__bases__:
             for base_class in current_cls.__bases__:
-                return self._get_func_name(base_class, module_func_dict)
+                base_run_func = self._get_func_name(base_class, module_func_dict)
+                if base_run_func:
+                    return base_run_func
         else:
             return None
 
@@ -120,7 +133,7 @@ class RunModule(object):
         `hub run` command.
         '''
         return True if self._run_func else False
-
+      
     @property
     def serving_func_name(self):
         return self._get_func_name(self.__class__, _module_serving_func)
@@ -330,4 +343,4 @@ def moduleinfo(name: str,
         wrap_cls._hook_by_hub = True
         return wrap_cls
 
-    return _wrapper
+    return _wrapper
\ No newline at end of file

paddlehub/utils/utils.py

@@ -154,6 +154,9 @@ def seconds_to_hms(seconds: int) -> str:
     hms_str = '{:0>2}:{:0>2}:{:0>2}'.format(h, m, s)
     return hms_str
 
+def cv2_to_base64(image: np.ndarray) -> str:
+    data = cv2.imencode('.jpg', image)[1]
+    return base64.b64encode(data.tostring()).decode('utf8')
 
 def base64_to_cv2(b64str: str) -> np.ndarray:
     '''Convert a string in base64 format to cv2 data'''