diff --git a/modules/image/Image_editing/colorization/user_guided_colorization/README.md b/modules/image/Image_editing/colorization/user_guided_colorization/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..390f04e1500e1d3d0ae1215f798bb9f7902f1fdc
--- /dev/null
+++ b/modules/image/Image_editing/colorization/user_guided_colorization/README.md
@@ -0,0 +1,204 @@
+# user_guided_colorization
+
+|模型名称|user_guided_colorization|
+| :--- | :---: |
+|类别|图像-图像编辑|
+|网络| Local and Global Hints Network |
+|数据集|ILSVRC 2012|
+|是否支持Fine-tuning|是|
+|模型大小|131MB|
+|指标|-|
+|最新更新日期|2021-02-26|
+
+
+## 一、模型基本信息
+
+- ### 模型介绍
+
+- ### 应用效果展示
+
+ - 样例结果示例(左为原图，右为效果图)：
+
+ 
+
+
+ - user_guided_colorization 是基于''Real-Time User-Guided Image Colorization with Learned Deep Priors"的着色模型，该模型利用预先提供的着色块对图像进行着色。
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 2.0.0
+
+ - paddlehub >= 2.0.0
+
+- ### 2、安装
+ - ```shell
+ $ hub install user_guided_colorization
+ ```
+
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+## 三、模型API预测
+
+- ### 1.命令行预测
+
+ ```shell
+ $ hub run user_guided_colorization --input_path "/PATH/TO/IMAGE"
+ ```
+- ### 2.预测代码示例
+
+ ```python
+ import paddle
+ import paddlehub as hub
+
+ if __name__ == '__main__':
+
+ model = hub.Module(name='user_guided_colorization')
+ model.set_config(prob=0.1)
+ result = model.predict(images=['/PATH/TO/IMAGE'])
+ ```
+- ### 3.如何开始Fine-tune
+
+ - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用user_guided_colorization模型对[Canvas](../../docs/reference/datasets.md#class-hubdatasetsCanvas)等数据集进行Fine-tune。
+
+ - 代码步骤
+
+ - Step1: 定义数据预处理方式
+ - ```python
+ import paddlehub.vision.transforms as T
+
+ transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'),
+ T.RandomPaddingCrop(crop_size=176),
+ T.RGB2LAB()], to_rgb=True)
+ ```
+
+ - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+
+ - Step2: 下载数据集并使用
+ - ```python
+ from paddlehub.datasets import Canvas
+
+ color_set = Canvas(transform=transform, mode='train')
+ ```
+
+ * `transforms`: 数据预处理方式。
+ * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
+
+ * `hub.datasets.Canvas()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
+
+
+ - Step3: 加载预训练模型
+
+ - ```python
+ model = hub.Module(name='user_guided_colorization', load_checkpoint=None)
+ model.set_config(classification=True, prob=1)
+ ```
+ * `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_cls_1')
+ trainer.train(color_set, epochs=201, batch_size=25, eval_dataset=color_set, log_interval=10, save_interval=10)
+ ```
+
+
+ - 运行配置
+
+ - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
+
+ * `model`: 被优化模型；
+ * `optimizer`: 优化器选择；
+ * `use_vdl`: 是否使用vdl可视化训练过程；
+ * `checkpoint_dir`: 保存模型参数的地址；
+ * `compare_metrics`: 保存最优模型的衡量指标；
+
+ - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
+
+ * `train_dataset`: 训练时所用的数据集；
+ * `epochs`: 训练轮数；
+ * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+ * `num_workers`: works的数量，默认为0；
+ * `eval_dataset`: 验证集；
+ * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+ * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
+
+ - 模型预测
+
+ - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
+
+ - ```python
+ import paddle
+ import paddlehub as hub
+
+ if __name__ == '__main__':
+ model = hub.Module(name='user_guided_colorization', load_checkpoint='/PATH/TO/CHECKPOINT')
+ model.set_config(prob=0.1)
+ result = model.predict(images=['house.png'])
+ ```
+
+
+ - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。若想获取油画风着色效果，请下载参数文件[油画着色](https://paddlehub.bj.bcebos.com/dygraph/models/canvas_rc.pdparams)
+
+## 四、服务部署
+
+- PaddleHub Serving可以部署一个在线着色任务服务。
+
+- ### 第一步：启动PaddleHub Serving
+
+ - 运行启动命令：
+
+ - ```shell
+ $ hub serving start -m user_guided_colorization
+ ```
+
+ - 这样就完成了一个着色任务服务化API的部署，默认端口号为8866。
+
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+- ### 第二步：发送预测请求
+
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+
+ ```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)
+ ```
+
+
+## 五、更新历史
+
+* 1.0.0
+
+ 初始发布
+
+
diff --git a/modules/image/Image_editing/super_resolution/dcscn/README.md b/modules/image/Image_editing/super_resolution/dcscn/README.md
index da9bfa44b9fdc496e52ac60f2c810c959fbf52eb..15722b2f2e03999f33597fc8f224d22b9a3d6334 100644
--- a/modules/image/Image_editing/super_resolution/dcscn/README.md
+++ b/modules/image/Image_editing/super_resolution/dcscn/README.md
@@ -1,134 +1,173 @@
-## 模型概述
+# dcscn
-DCSCN是基于Fast and Accurate Image Super Resolution by Deep CNN with Skip Connection and Network in Network设计的轻量化超分辨模型。该模型使用残差结构和跳连的方式构建网络来提取局部和全局特征，同时使用并行1*1的卷积网络学习细节特征提升模型性能。该模型提供的超分倍数为2倍。
-## 命令行预测
+|模型名称|dcscn|
+| :--- | :---: |
+|类别|图像-图像编辑|
+|网络|dcscn|
+|数据集|DIV2k|
+|是否支持Fine-tuning|否|
+|模型大小|260KB|
+|指标|PSNR37.63|
+|最新更新日期|2021-02-26|
-```
-$ hub run dcscn --input_path "/PATH/TO/IMAGE"
-```
+## 一、模型基本信息
-## API
+- ### 应用效果展示
+
+ - 样例结果示例(左为原图，右为效果图)：
+
+ 
+
-```python
-def reconstruct(self,
- images=None,
- paths=None,
- use_gpu=False,
- visualization=False,
- output_dir="dcscn_output")
-```
-预测API，用于图像超分辨率。
+- ### 模型介绍
-**参数**
+ - DCSCN是基于Fast and Accurate Image Super Resolution by Deep CNN with Skip Connection and Network in Network设计的轻量化超分辨模型。该模型使用残差结构和跳连的方式构建网络来提取局部和全局特征，同时使用并行1*1的卷积网络学习细节特征提升模型性能。该模型提供的超分倍数为2倍。
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
-* paths (list\[str\]): 图片的路径；
-* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
-* visualization (bool): 是否将识别结果保存为图片文件；
-* output\_dir (str): 图片的保存路径。
+ - 更多详情请参考：[dcscn](https://github.com/jiny2001/dcscn-super-resolution)
-**返回**
+## 二、安装
-* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
- * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
- * data (numpy.ndarray): 超分辨后图像。
+- ### 1、环境依赖
-```python
-def save_inference_model(self,
- dirname='dcscn_save_model',
- model_filename=None,
- params_filename=None,
- combined=False)
-```
+ - paddlepaddle >= 2.0.0
-将模型保存到指定路径。
+ - paddlehub >= 2.0.0
-**参数**
-* dirname: 存在模型的目录名称
-* model\_filename: 模型文件名称，默认为\_\_model\_\_
-* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
-* combined: 是否将参数保存到统一的一个文件中
+- ### 2、安装
+ - ```shell
+ $ hub install dcscn
+ ```
-## 代码示例
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
-```python
-import cv2
-import paddlehub as hub
+## 三、模型API预测
+- ### 1、命令行预测
-sr_model = hub.Module(name='dcscn')
-im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
-#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
-res = sr_model.reconstruct(images=[im], visualization=True)
-print(res[0]['data'])
-sr_model.save_inference_model()
-```
+ - ```
+ $ hub run dcscn --input_path "/PATH/TO/IMAGE"
+ ```
+- ### 2、预测代码示例
-## 服务部署
+ ```python
+ import cv2
+ import paddlehub as hub
-PaddleHub Serving可以部署一个图像超分的在线服务。
+ sr_model = hub.Module(name='dcscn')
+ im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+ #visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
+ res = sr_model.reconstruct(images=[im], visualization=True)
+ print(res[0]['data'])
+ sr_model.save_inference_model()
+ ```
-## 第一步：启动PaddleHub Serving
+- ### 3、API
-运行启动命令：
+ - ```python
+ def reconstruct(self,
+ images=None,
+ paths=None,
+ use_gpu=False,
+ visualization=False,
+ output_dir="dcscn_output")
+ ```
-```shell
-$ hub serving start -m dcscn
-```
+ - 预测API，用于图像超分辨率。
-这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
+ - **参数**
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+ * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
+ * paths (list\[str\]): 图片的路径；
+ * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
+ * visualization (bool): 是否将识别结果保存为图片文件；
+ * output\_dir (str): 图片的保存路径。
-## 第二步：发送预测请求
+ - **返回**
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path'， 'data'，对应的取值为：
+ * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
+ * data (numpy.ndarray): 超分辨后图像。
-```python
-import requests
-import json
-import base64
+ - ```python
+ def save_inference_model(self,
+ dirname='dcscn_save_model',
+ model_filename=None,
+ params_filename=None,
+ combined=False)
+ ```
-import cv2
-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请求
+ * dirname: 存在模型的目录名称
+ * model\_filename: 模型文件名称，默认为\_\_model\_\_
+ * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+ * combined: 是否将参数保存到统一的一个文件中
-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/dcscn"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-sr = np.expand_dims(cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY), axis=2)
-shape =sr.shape
-org_im = cv2.cvtColor(org_im, cv2.COLOR_BGR2YUV)
-uv = cv2.resize(org_im[...,1:], (shape[1], shape[0]), interpolation=cv2.INTER_CUBIC)
-combine_im = cv2.cvtColor(np.concatenate((sr, uv), axis=2), cv2.COLOR_YUV2BGR)
-cv2.imwrite('dcscn_X2.png', combine_im)
-print("save image as dcscn_X2.png")
-```
-### 查看代码
+## 四、服务部署
-https://github.com/jiny2001/dcscn-super-resolution
+- PaddleHub Serving可以部署一个图像超分的在线服务。
+- ### 第一步：启动PaddleHub Serving
+ - 运行启动命令：
-### 依赖
+ - ```shell
+ $ hub serving start -m dcscn
+ ```
-paddlepaddle >= 1.8.0
+ - 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
-paddlehub >= 1.7.1
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+ - ### 第二步：发送预测请求
+
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ ```python
+ import requests
+ import json
+ import base64
+
+ import cv2
+ 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/dcscn"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
+
+ sr = np.expand_dims(cv2.cvtColor(base64_to_cv2(r.json()["results"][0]['data']), cv2.COLOR_BGR2GRAY), axis=2)
+ shape =sr.shape
+ org_im = cv2.cvtColor(org_im, cv2.COLOR_BGR2YUV)
+ uv = cv2.resize(org_im[...,1:], (shape[1], shape[0]), interpolation=cv2.INTER_CUBIC)
+ combine_im = cv2.cvtColor(np.concatenate((sr, uv), axis=2), cv2.COLOR_YUV2BGR)
+ cv2.imwrite('dcscn_X2.png', combine_im)
+ print("save image as dcscn_X2.png")
+ ```
+
+
+## 五、更新历史
+
+
+* 1.0.0
+
+ 初始发布
diff --git a/modules/image/Image_editing/super_resolution/falsr_a/README.md b/modules/image/Image_editing/super_resolution/falsr_a/README.md
index 2981753ca3512962fc3a05c60df8ef2203e78323..f1b98a651387342bffb3397a3f4ada31cc61411d 100644
--- a/modules/image/Image_editing/super_resolution/falsr_a/README.md
+++ b/modules/image/Image_editing/super_resolution/falsr_a/README.md
@@ -1,126 +1,169 @@
-## 模型概述
+# falsr_a
-falsr_a是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
-## 命令行预测
+|模型名称|falsr_a|
+| :--- | :---: |
+|类别|图像-图像编辑|
+|网络|falsr_a|
+|数据集|DIV2k|
+|是否支持Fine-tuning|否|
+|模型大小|8.9MB|
+|指标|PSNR37.82|
+|最新更新日期|2021-02-26|
-```
-$ hub run falsr_a --input_path "/PATH/TO/IMAGE"
-```
+## 一、模型基本信息
-## API
+- ### 应用效果展示
+
+ - 样例结果示例(左为原图，右为效果图)：
+
+
+
-```python
-def reconstruct(self,
- images=None,
- paths=None,
- use_gpu=False,
- visualization=False,
- output_dir="falsr_a_output")
-```
-预测API，用于图像超分辨率。
+- ### 模型介绍
-**参数**
+ - falsr_a是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
-* paths (list\[str\]): 图片的路径；
-* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
-* visualization (bool): 是否将识别结果保存为图片文件；
-* output\_dir (str): 图片的保存路径。
+ - 更多详情请参考：[falsr_a](https://github.com/xiaomi-automl/FALSR)
-**返回**
+## 二、安装
-* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
- * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
- * data (numpy.ndarray): 超分辨后图像。
+- ### 1、环境依赖
-```python
-def save_inference_model(self,
- dirname='falsr_a_save_model',
- model_filename=None,
- params_filename=None,
- combined=False)
-```
+ - paddlepaddle >= 2.0.0
-将模型保存到指定路径。
+ - paddlehub >= 2.0.0
-**参数**
-* dirname: 存在模型的目录名称
-* model\_filename: 模型文件名称，默认为\_\_model\_\_
-* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
-* combined: 是否将参数保存到统一的一个文件中
+- ### 2、安装
+ - ```shell
+ $ hub install falsr_a
+ ```
-## 代码示例
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
-```python
-import cv2
-import paddlehub as hub
+## 三、模型API预测
+- ### 1、命令行预测
-sr_model = hub.Module(name='falsr_a')
-im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
-#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
-res = sr_model.reconstruct(images=[im], visualization=True)
-print(res[0]['data'])
-sr_model.save_inference_model()
-```
+ - ```
+ $ hub run falsr_a --input_path "/PATH/TO/IMAGE"
+ ```
+- ### 2、预测代码示例
-## 服务部署
+ ```python
+ import cv2
+ import paddlehub as hub
-PaddleHub Serving可以部署一个图像超分的在线服务。
+ sr_model = hub.Module(name='falsr_a')
+ im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+ #visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
+ res = sr_model.reconstruct(images=[im], visualization=True)
+ print(res[0]['data'])
+ sr_model.save_inference_model()
+ ```
-## 第一步：启动PaddleHub Serving
+- ### 3、API
-运行启动命令：
+ - ```python
+ def reconstruct(self,
+ images=None,
+ paths=None,
+ use_gpu=False,
+ visualization=False,
+ output_dir="falsr_a_output")
+ ```
-```shell
-$ hub serving start -m falsr_a
-```
+ - 预测API，用于图像超分辨率。
-这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
+ - **参数**
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+ * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
+ * paths (list\[str\]): 图片的路径；
+ * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
+ * visualization (bool): 是否将识别结果保存为图片文件；
+ * output\_dir (str): 图片的保存路径。
-## 第二步：发送预测请求
+ - **返回**
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
+ * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
+ * data (numpy.ndarray): 超分辨后图像。
-```python
-import requests
-import json
-import base64
+ - ```python
+ def save_inference_model(self,
+ dirname='falsr_a_save_model',
+ model_filename=None,
+ params_filename=None,
+ combined=False)
+ ```
-import cv2
-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/falsr_a"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-sr = base64_to_cv2(r.json()["results"][0]['data'])
-cv2.imwrite('falsr_a_X2.png', sr)
-print("save image as falsr_a_X2.png")
-```
-### 查看代码
+ * dirname: 存在模型的目录名称
+ * model\_filename: 模型文件名称，默认为\_\_model\_\_
+ * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+ * combined: 是否将参数保存到统一的一个文件中
-https://github.com/xiaomi-automl/FALSR
-### 依赖
+## 四、服务部署
+
+- PaddleHub Serving可以部署一个图像超分的在线服务。
+
+- ### 第一步：启动PaddleHub Serving
+
+ - 运行启动命令：
+
+ - ```shell
+ $ hub serving start -m falsr_a
+ ```
+
+ - 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
+
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+ - ### 第二步：发送预测请求
+
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ ```python
+ import requests
+ import json
+ import base64
+
+ import cv2
+ 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/falsr_a"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
+ sr = base64_to_cv2(r.json()["results"][0]['data'])
+ cv2.imwrite('falsr_a_X2.png', sr)
+ print("save image as falsr_a_X2.png")
+ ```
+
+
+## 五、更新历史
+
+
+* 1.0.0
+
+ 初始发布
-paddlepaddle >= 1.8.0
-paddlehub >= 1.7.1
diff --git a/modules/image/Image_editing/super_resolution/falsr_b/README.md b/modules/image/Image_editing/super_resolution/falsr_b/README.md
index f54f159d57e81c98d3d503da9bc68afd877ee796..b74a5f894791719d8d0b61ca666b395f318076a4 100644
--- a/modules/image/Image_editing/super_resolution/falsr_b/README.md
+++ b/modules/image/Image_editing/super_resolution/falsr_b/README.md
@@ -1,126 +1,170 @@
-## 模型概述
+# falsr_b
-falsr_b是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。falsr_b较falsr_a更轻量化。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
-## 命令行预测
+|模型名称|falsr_b|
+| :--- | :---: |
+|类别|图像-图像编辑|
+|网络|falsr_b|
+|数据集|DIV2k|
+|是否支持Fine-tuning|否|
+|模型大小|4MB|
+|指标|PSNR37.61|
+|最新更新日期|2021-02-26|
-```
-$ hub run falsr_b --input_path "/PATH/TO/IMAGE"
-```
+## 一、模型基本信息
-## API
+- ### 应用效果展示
+
+ - 样例结果示例(左为原图，右为效果图)：
+
+
+
-```python
-def reconstruct(self,
- images=None,
- paths=None,
- use_gpu=False,
- visualization=True,
- output_dir="falsr_b_output")
-```
-预测API，用于图像超分辨率。
+- ### 模型介绍
-**参数**
+ - falsr_b是基于Fast, Accurate and Lightweight Super-Resolution with Neural Architecture Search设计的轻量化超分辨模型。该模型使用多目标方法处理超分问题，同时使用基于混合控制器的弹性搜索策略来提升模型性能。该模型提供的超分倍数为2倍。
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
-* paths (list\[str\]): 图片的路径；
-* use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
-* visualization (bool): 是否将识别结果保存为图片文件；
-* output\_dir (str): 图片的保存路径。
+ - 更多详情请参考：[falsr_b](https://github.com/xiaomi-automl/FALSR)
-**返回**
+## 二、安装
-* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path', 'data'，对应的取值为：
- * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
- * data (numpy.ndarray): 超分辨后图像。
+- ### 1、环境依赖
-```python
-def save_inference_model(self,
- dirname='falsr_b_save_model',
- model_filename=None,
- params_filename=None,
- combined=False)
-```
+ - paddlepaddle >= 2.0.0
-将模型保存到指定路径。
+ - paddlehub >= 2.0.0
-**参数**
-* dirname: 存在模型的目录名称
-* model\_filename: 模型文件名称，默认为\_\_model\_\_
-* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
-* combined: 是否将参数保存到统一的一个文件中
+- ### 2、安装
+ - ```shell
+ $ hub install falsr_b
+ ```
-## 代码示例
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
-```python
-import cv2
-import paddlehub as hub
+## 三、模型API预测
+- ### 1、命令行预测
-sr_model = hub.Module(name='falsr_b')
-im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
-#visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
-res = sr_model.reconstruct(images=[im], visualization=True)
-print(res[0]['data'])
-sr_model.save_inference_model()
-```
+ - ```
+ $ hub run falsr_b --input_path "/PATH/TO/IMAGE"
+ ```
+- ### 2、预测代码示例
-## 服务部署
+ ```python
+ import cv2
+ import paddlehub as hub
-PaddleHub Serving可以部署一个图像超分的在线服务。
+ sr_model = hub.Module(name='falsr_b')
+ im = cv2.imread('/PATH/TO/IMAGE').astype('float32')
+ #visualization=True可以用于查看超分图片效果，可设置为False提升运行速度。
+ res = sr_model.reconstruct(images=[im], visualization=True)
+ print(res[0]['data'])
+ sr_model.save_inference_model()
+ ```
-## 第一步：启动PaddleHub Serving
+- ### 3、API
-运行启动命令：
+ - ```python
+ def reconstruct(self,
+ images=None,
+ paths=None,
+ use_gpu=False,
+ visualization=False,
+ output_dir="falsr_b_output")
+ ```
-```shell
-$ hub serving start -m falsr_b
-```
+ - 预测API，用于图像超分辨率。
-这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
+ - **参数**
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+ * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
+ * paths (list\[str\]): 图片的路径；
+ * use\_gpu (bool): 是否使用 GPU预测，如果使用GPU预测，则在预测之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置；
+ * visualization (bool): 是否将识别结果保存为图片文件；
+ * output\_dir (str): 图片的保存路径。
-## 第二步：发送预测请求
+ - **返回**
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ * res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 'save\_path'， 'data'，对应的取值为：
+ * save\_path (str, optional): 可视化图片的保存路径（仅当visualization=True时存在）；
+ * data (numpy.ndarray): 超分辨后图像。
-```python
-import requests
-import json
-import base64
+ - ```python
+ def save_inference_model(self,
+ dirname='falsr_b_save_model',
+ model_filename=None,
+ params_filename=None,
+ combined=False)
+ ```
-import cv2
-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/falsr_b"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-sr = base64_to_cv2(r.json()["results"][0]['data'])
-cv2.imwrite('falsr_b_X2.png', sr)
-print("save image as falsr_b_X2.png")
-```
+ * dirname: 存在模型的目录名称
+ * model\_filename: 模型文件名称，默认为\_\_model\_\_
+ * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
+ * combined: 是否将参数保存到统一的一个文件中
-### 查看代码
-https://github.com/xiaomi-automl/FALSR
-### 依赖
+## 四、服务部署
+
+- PaddleHub Serving可以部署一个图像超分的在线服务。
+
+- ### 第一步：启动PaddleHub Serving
+
+ - 运行启动命令：
+
+ - ```shell
+ $ hub serving start -m falsr_b
+ ```
+
+ - 这样就完成了一个超分任务的服务化API的部署，默认端口号为8866。
+
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+
+ - ### 第二步：发送预测请求
+
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ ```python
+ import requests
+ import json
+ import base64
+
+ import cv2
+ 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/falsr_b"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
+ sr = base64_to_cv2(r.json()["results"][0]['data'])
+ cv2.imwrite('falsr_b_X2.png', sr)
+ print("save image as falsr_b_X2.png")
+ ```
+
+
+## 五、更新历史
+
+
+* 1.0.0
+
+ 初始发布
+
-paddlepaddle >= 1.8.0
-paddlehub >= 1.7.1
diff --git a/modules/image/Image_gan/attgan_celeba/README.md b/modules/image/Image_gan/attgan_celeba/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9a7a211949a026093547542c845d4e182392f98
--- /dev/null
+++ b/modules/image/Image_gan/attgan_celeba/README.md
@@ -0,0 +1,105 @@
+# attgan_celeba
+
+|模型名称|attgan_celeba|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|AttGAN|
+|数据集|Celeba|
+|是否支持Fine-tuning|否|
+|模型大小|167MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
+
+
+## 一、模型基本信息
+
+- ### 应用效果展示
+ - 样例结果示例：
+
+
+ 
+ 图1. AttGAN的效果图(图片属性分别为：original image, Bald, Bangs, Black_Hair, Blond_Hair, Brown_Hair, Bushy_Eyebrows, Eyeglasses, Gender, Mouth_Slightly_Open, Mustache, No_Beard, Pale_Skin, Aged)
+
+
+
+- ### 模型介绍
+
+ - AttGAN 是一种生成对抗网络(Generative Adversarial Networks)，它利用分类损失和重构损失来保证改变特定的属性。该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 这十三种人脸属性转换。
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 1.5.2
+
+ - paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install attgan_celeba==1.0.0
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
+
+- ### 1、命令行预测
+
+ - ```shell
+ $ hub run attgan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute"
+ ```
+ - **参数**
+
+ - image ：指定图片路径。
+
+ - style 指定拟转换的属性，可选择 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 中的一种。
+
+
+
+- ### 2、预测代码示例
+
+ - ```python
+ import paddlehub as hub
+
+ attgan = hub.Module(name="attgan_celeba")
+
+ test_img_path = ["/PATH/TO/IMAGE"]
+ trans_attr = ["Bangs"]
+
+ # set input dict
+ input_dict = {"image": test_img_path, "style": trans_attr}
+
+ # execute predict and print the result
+ results = attgan.generate(data=input_dict)
+ print(results)
+ ```
+
+- ### 3、API
+
+ - ```python
+ def generate(data)
+ ```
+
+ - 风格转换API，用于图像生成。
+
+ - **参数**
+
+ - data： dict 类型，有以下字段
+ - image (list\[str\])： list中每个元素为待转换的图片路径。
+ - style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
+
+ - **返回**
+ - res (list\[str\]): 提示生成图片的保存路径。
+
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
+
+
diff --git a/modules/image/Image_gan/cyclegan_cityscapes/README.md b/modules/image/Image_gan/cyclegan_cityscapes/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a63efd9e92c93d8b65545dedac8c33a349549aec
--- /dev/null
+++ b/modules/image/Image_gan/cyclegan_cityscapes/README.md
@@ -0,0 +1,108 @@
+# cyclegan_cityscapes
+
+|模型名称|cyclegan_cityscapes|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|CycleGAN|
+|数据集|Cityscapes|
+|是否支持Fine-tuning|否|
+|模型大小|33MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
+
+
+## 一、模型基本信息
+
+- ### 应用效果展示
+ - 样例结果示例：
+
+
+ 
+
+ 输入图像
+
+ 
+
+ 输出图像
+
+
+
+
+- ### 模型介绍
+
+ - CycleGAN是生成对抗网络（Generative Adversarial Networks ）的一种，与传统的GAN只能单向生成图片不同，CycleGAN可以同时完成两个domain的图片进行相互转换。该PaddleHub Module使用Cityscapes数据集训练完成，支持图片从实景图转换为语义分割结果，也支持从语义分割结果转换为实景图。
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 1.4.0
+
+ - paddlehub >= 1.1.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install cyclegan_cityscapes==1.0.0
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
+
+- ### 1、命令行预测
+
+ - ```shell
+ $ hub run cyclegan_cityscapes --input_path "/PATH/TO/IMAGE"
+ ```
+ - **参数**
+
+ - input_path ：指定图片路径。
+
+
+
+- ### 2、预测代码示例
+
+ - ```python
+ import paddlehub as hub
+
+ cyclegan = hub.Module(name="cyclegan_cityscapes")
+
+ test_img_path = "/PATH/TO/IMAGE"
+
+ # set input dict
+ input_dict = {"image": [test_img_path]}
+
+ # execute predict and print the result
+ results = cyclegan.generate(data=input_dict)
+ print(results)
+ ```
+
+- ### 3、API
+
+ - ```python
+ def generate(data)
+ ```
+
+ - 风格转换API，用于图像生成。
+
+ - **参数**
+
+ - data： dict 类型，有以下字段:
+ - image (list\[str\])： list中每个元素为待转换的图片路径。
+
+ - **返回**
+ - res (list\[str\]): 每个元素为对应输入图片的预测结果。预测结果为dict类型，有以下字段：
+ - origin: 原输入图片路径.
+ - generated: 生成图片的路径。
+
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
+
diff --git a/modules/image/Image_gan/stargan_celeba/README.md b/modules/image/Image_gan/stargan_celeba/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5a160274dae031ae2824b93416eb1395b814770
--- /dev/null
+++ b/modules/image/Image_gan/stargan_celeba/README.md
@@ -0,0 +1,102 @@
+# stargan_celeba
+
+|模型名称|stargan_celeba|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|STGAN|
+|数据集|Celeba|
+|是否支持Fine-tuning|否|
+|模型大小|33MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
+
+
+## 一、模型基本信息
+
+- ### 应用效果展示
+ - 样例结果示例：
+
+
+ 
+ 图1. StarGAN的效果图 (属性分别为：origial image, Black_Hair, Blond_Hair, Brown_Hair, Male, Aged)
+
+
+
+- ### 模型介绍
+
+ - StarGAN 是为了解决跨多个域、多个数据集的训练而提出的生成对抗网络模型。单个 StarGAN 模型就可以实现多个风格域的转换。 该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged" 这六种人脸属性转换。
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 1.5.2
+
+ - paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install stargan_celeba==1.0.0
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
+
+- ### 1、命令行预测
+
+ - ```shell
+ $ hub run stargan_celeba --image "/PATH/TO/IMAGE" --style "target_attribute"
+ ```
+ - **参数**
+
+ - image ：指定图片路径。
+
+ - style 指定拟转换的属性，可选择 "Black_Hair", "Blond_Hair", "Brown_Hair", "Female", "Male", "Aged" 中的一个。
+
+
+- ### 2、预测代码示例
+
+ - ```python
+ import paddlehub as hub
+
+ stargan = hub.Module(name="stargan_celeba")
+ test_img_path = ["/PATH/TO/IMAGE"]
+ trans_attr = ["Blond_Hair"]
+
+ # set input dict
+ input_dict = {"image": test_img_path, "style": trans_attr}
+
+ # execute predict and print the result
+ results = stargan.generate(data=input_dict)
+ print(results)
+ ```
+
+- ### 3、API
+
+ - ```python
+ def generate(data)
+ ```
+
+ - 风格转换API，用于图像生成。
+
+ - **参数**
+
+ - data： dict 类型，有以下字段
+ - image (list\[str\])： list中每个元素为待转换的图片路径。
+ - style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
+
+ - **返回**
+ - res (list\[str\]): 提示生成图片的保存路径。
+
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
+
diff --git a/modules/image/Image_gan/stgan_celeba/README.md b/modules/image/Image_gan/stgan_celeba/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..52e22e019e5d576d41d58ddc53c4a51a7870e130
--- /dev/null
+++ b/modules/image/Image_gan/stgan_celeba/README.md
@@ -0,0 +1,106 @@
+# stgan_celeba
+
+|模型名称|stgan_celeba|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|STGAN|
+|数据集|Celeba|
+|是否支持Fine-tuning|否|
+|模型大小|287MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
+
+
+## 一、模型基本信息
+
+- ### 应用效果展示
+ - 样例结果示例：
+
+
+ 
+ STGAN的效果图(图片属性分别为：original image, Bald, Bangs, Black_Hair, Blond_Hair, Brown_Hair, Bushy_Eyebrows, Eyeglasses, Gender, Mouth_Slightly_Open, Mustache, No_Beard, Pale_Skin, Aged)
+
+
+
+- ### 模型介绍
+
+ - STGAN 以原属性和目标属性的差值作为输入，并创造性地提出了 STUs (Selective transfer units) 来选择和修改 encoder 的特征，从而改善了转换效果和处理能力。 该 PaddleHub Module 使用 Celeba 数据集训练完成，目前支持 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 这十三种人脸属性转换。
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 1.5.2
+
+ - paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install stgan_celeba==1.0.0
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
+
+- ### 1、命令行预测
+
+ - ```shell
+ $ hub run stgan_celeba --image "/PATH/TO/IMAGE" --info "original_attributes" --style "target_attribute"
+ ```
+ - **参数**
+
+ - image ：指定图片路径。
+
+ - info ：原图的属性，必须填写性别（ "Male" 或者 "Female"）。可选值有："Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 。比如输入图片是一个女孩，有着黑头发，那么就填写为 "Female,Black_Hair"。建议尽可能完整地填写原图具备的属性，比如一个黑发女孩还戴了眼镜，那么应填写为 "Female,Black_Hair,Eyeglasses"，否则有可能转换失败。
+
+ - style 指定拟转换的属性，可选择 "Bald", "Bangs", "Black_Hair", "Blond_Hair", "Brown_Hair", "Bushy_Eyebrows", "Eyeglasses", "Gender", "Mouth_Slightly_Open", "Mustache", "No_Beard", "Pale_Skin", "Aged" 中的一种。
+
+- ### 2、预测代码示例
+
+ - ```python
+ import paddlehub as hub
+
+ stgan = hub.Module(name="stgan_celeba")
+
+ test_img_path = ["/PATH/TO/IMAGE"]
+ org_info = ["Female,Black_Hair"]
+ trans_attr = ["Bangs"]
+
+ # set input dict
+ input_dict = {"image": test_img_path, "style": trans_attr, "info": org_info}
+
+ # execute predict and print the result
+ results = stgan.generate(data=input_dict)
+ print(results)
+ ```
+
+- ### 3、API
+
+ - ```python
+ def generate(data)
+ ```
+
+ - 风格转换API，用于图像生成。
+
+ - **参数**
+
+ - data： dict 类型，有以下字段
+ - image (list\[str\])： list中每个元素为待转换的图片路径。
+ - style (list\[str\])： list中每个元素为字符串，填写待转换的人脸属性。
+ - info (list\[str\])： 表示原图具备的人脸属性，填得越详细效果会越好，不同属性用逗号隔开。
+
+
+ - **返回**
+ - res (list\[str\]): 提示生成图片的保存路径。
+
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
diff --git a/modules/image/Image_gan/style_transfer/ID_Photo_GEN/README.md b/modules/image/Image_gan/style_transfer/ID_Photo_GEN/README.md
index 6707c477de171e19770d0aa5a0869ac6f4b81fa7..6957e9a03f1c2116263d37ac06e5dded42f1575e 100644
--- a/modules/image/Image_gan/style_transfer/ID_Photo_GEN/README.md
+++ b/modules/image/Image_gan/style_transfer/ID_Photo_GEN/README.md
@@ -1,48 +1,97 @@
-## 概述
-* 基于 face_landmark_localization 和 FCN_HRNet_W18_Face_Seg 模型实现的证件照生成模型，一键生成白底、红底和蓝底的人像照片
-
-## 效果展示
-
-
-## API
-```python
-def Photo_GEN(
- images=None,
- paths=None,
- batch_size=1,
- output_dir='output',
- visualization=False,
- use_gpu=False):
-```
-证件照生成 API
-
-**参数**
-* images (list[np.ndarray]) : 输入图像数据列表（BGR）
-* paths (list[str]) : 输入图像路径列表
-* batch_size (int) : 数据批大小
-* output_dir (str) : 可视化图像输出目录
-* visualization (bool) : 是否可视化
-* use_gpu (bool) : 是否使用 GPU 进行推理
-
-**返回**
-* results (list[dict{"write":np.ndarray,"blue":np.ndarray,"red":np.ndarray}]): 输出图像数据列表
-
-**代码示例**
-```python
-import cv2
-import paddlehub as hub
-
-model = hub.Module(name='ID_Photo_GEN')
-
-result = model.Photo_GEN(
- images=[cv2.imread('/PATH/TO/IMAGE')],
- paths=None,
- batch_size=1,
- output_dir='output',
- visualization=True,
- use_gpu=False)
-```
-
-## 依赖
-paddlepaddle >= 2.0.0rc0
-paddlehub >= 2.0.0b1
+# ID_Photo_GEN
+
+|模型名称|ID_Photo_GEN|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|HRNet_W18|
+|数据集|-|
+|是否支持Fine-tuning|否|
+|模型大小|28KB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
+
+
+## 一、模型基本信息
+
+- ### 应用效果展示
+ - 样例结果示例：
+
+ 
+
+
+
+- ### 模型介绍
+
+ - 基于face_landmark_localization和FCN_HRNet_W18_Face_Seg模型实现的证件照生成模型，一键生成白底、红底和蓝底的人像照片
+
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 2.0.0
+
+ - paddlehub >= 2.0.0
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install ID_Photo_GEN
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
+
+- ### 1、预测代码示例
+
+ - ```python
+ import cv2
+ import paddlehub as hub
+
+ model = hub.Module(name='ID_Photo_GEN')
+
+ result = model.Photo_GEN(
+ images=[cv2.imread('/PATH/TO/IMAGE')],
+ paths=None,
+ batch_size=1,
+ output_dir='output',
+ visualization=True,
+ use_gpu=False)
+ ```
+
+- ### 2、API
+
+ - ```python
+ def Photo_GEN(
+ images=None,
+ paths=None,
+ batch_size=1,
+ output_dir='output',
+ visualization=False,
+ use_gpu=False):
+ ```
+
+ - 证件照生成API
+
+ - **参数**
+ * images (list[np.ndarray]) : 输入图像数据列表（BGR）
+ * paths (list[str]) : 输入图像路径列表
+ * batch_size (int) : 数据批大小
+ * output_dir (str) : 可视化图像输出目录
+ * visualization (bool) : 是否可视化
+ * use_gpu (bool) : 是否使用 GPU 进行推理
+
+ **NOTE:** paths和images两个参数选择其一进行提供数据
+
+ - **返回**
+
+ * results (list[dict{"write":np.ndarray,"blue":np.ndarray,"red":np.ndarray}]): 输出图像数据列表
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
diff --git a/modules/image/Image_gan/style_transfer/UGATIT_83w/README.md b/modules/image/Image_gan/style_transfer/UGATIT_83w/README.md
index 493b8eaf78eaced6fd48a99783a19c3f7e0ac2d1..82bbf44afa06f2d03bb89f010d46a36ee5cf3b73 100644
--- a/modules/image/Image_gan/style_transfer/UGATIT_83w/README.md
+++ b/modules/image/Image_gan/style_transfer/UGATIT_83w/README.md
@@ -1,122 +1,141 @@
-## 模型概述
-UGATIT 图像风格转换模型
+# UGATIT_83w
-模型可将输入的人脸图像转换成动漫风格
+|模型名称|UGATIT_83w|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|U-GAT-IT|
+|数据集|selfie2anime|
+|是否支持Fine-tuning|否|
+|模型大小|41MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
-模型权重来自UGATIT-Paddle开源项目
-模型所使用的权重为genA2B_0835000
+## 一、模型基本信息
-模型详情请参考[UGATIT-Paddle开源项目](https://github.com/miraiwk/UGATIT-paddle)
+- ### 应用效果展示
+ - 样例结果示例(左为原图，右为效果图)：
+
+ 
+
-## 模型安装
-```shell
-$hub install UGATIT_83w
-```
+- ### 模型介绍
-## API 说明
+ - UGATIT 图像风格转换模型, 模型可将输入的人脸图像转换成动漫风格.
-```python
-def style_transfer(
- self,
- images=None,
- paths=None,
- batch_size=1,
- output_dir='output',
- visualization=False
-)
-```
-风格转换API，将输入的人脸图像转换成动漫风格。
+## 二、安装
-转换效果图如下：
+- ### 1、环境依赖
-
-
+ - paddlepaddle >= 1.8.2
-**参数**
+ - paddlehub >= 1.8.0
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
-* paths (list\[str\]): 图片的路径，默认为 None；
-* batch\_size (int): batch 的大小，默认设为 1；
-* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
-* output\_dir (str): 图片的保存路径，默认设为 output。
+- ### 2、安装
+ - ```shell
+ $ hub install UGATIT_83w
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
-**返回**
+- ### 1、预测代码示例
-* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。
+ - ```python
+ import cv2
+ import paddlehub as hub
+ # 模型加载
+ # use_gpu：是否使用GPU进行预测
+ model = hub.Module(name='UGATIT_83w', use_gpu=False)
-## 预测代码示例
+ # 模型预测
+ result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
-```python
-import cv2
-import paddlehub as hub
+ # or
+ # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
+ ```
-# 模型加载
-# use_gpu：是否使用GPU进行预测
-model = hub.Module('UGATIT_83w', use_gpu=False)
+- ### 2、API
-# 模型预测
-result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ - ```python
+ def style_transfer(
+ self,
+ images=None,
+ paths=None,
+ batch_size=1,
+ output_dir='output',
+ visualization=False
+ )
+ ```
-# or
-# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
-```
+ - 风格转换API，将输入的人脸图像转换成动漫风格。
-## 服务部署
+ - **参数**
+ * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
+ * paths (list\[str\]): 图片的路径，默认为 None；
+ * batch\_size (int): batch 的大小，默认设为 1；
+ * visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
+ * output\_dir (str): 图片的保存路径，默认设为 output
-PaddleHub Serving可以部署一个在线图像风格转换服务。
+ **NOTE:** paths和images两个参数选择其一进行提供数据
-## 第一步：启动PaddleHub Serving
+ - **返回**
-运行启动命令：
-```shell
-$ hub serving start -m UGATIT_w83
-```
+ - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
+
-这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+## 四、服务部署
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- PaddleHub Serving可以部署一个在线图像风格转换服务。
-## 第二步：发送预测请求
+- ### 第一步：启动PaddleHub Serving
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - 运行启动命令：
+
+ - ```shell
+ $ hub serving start -m UGATIT_83w
+ ```
-```python
-import requests
-import json
-import cv2
-import base64
+ - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
-def cv2_to_base64(image):
- data = cv2.imencode('.jpg', image)[1]
- return base64.b64encode(data.tostring()).decode('utf8')
+- ### 第二步：发送预测请求
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
-# 发送HTTP请求
-data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
-headers = {"Content-type": "application/json"}
-url = "http://127.0.0.1:8866/predict/UGATIT_w83"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
+ - ```python
+ import requests
+ import json
+ import cv2
+ import base64
-# 打印预测结果
-print(r.json()["results"])
-```
+ def cv2_to_base64(image):
+ data = cv2.imencode('.jpg', image)[1]
+ return base64.b64encode(data.tostring()).decode('utf8')
-## 模型相关信息
-### 模型代码
+ # 发送HTTP请求
+ data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+ headers = {"Content-type": "application/json"}
+ url = "http://127.0.0.1:8866/predict/UGATIT_83w"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
-https://github.com/miraiwk/UGATIT-paddle
+ # 打印预测结果
+ print(r.json()["results"])
+ ```
-### 依赖
-paddlepaddle >= 1.8.0
+## 五、更新历史
-paddlehub >= 1.8.0
+* 1.0.0
+
+ 初始发布
\ No newline at end of file
diff --git a/modules/image/Image_gan/style_transfer/UGATIT_92w/README.md b/modules/image/Image_gan/style_transfer/UGATIT_92w/README.md
index 084188af3a11d767dd7a8480dc63d1bdd4bead19..8108976faeaa9bccad1af206a9aa6a34115dffc0 100644
--- a/modules/image/Image_gan/style_transfer/UGATIT_92w/README.md
+++ b/modules/image/Image_gan/style_transfer/UGATIT_92w/README.md
@@ -1,122 +1,141 @@
-## 模型概述
-UGATIT 图像风格转换模型
+# UGATIT_92w
-模型可将输入的人脸图像转换成动漫风格
+|模型名称|UGATIT_92w|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|U-GAT-IT|
+|数据集|selfie2anime|
+|是否支持Fine-tuning|否|
+|模型大小|41MB|
+|最新更新日期|2021-02-26|
+|数据指标|-|
-模型权重来自UGATIT-Paddle开源项目
-模型所使用的权重为genA2B_0924000
+## 一、模型基本信息
-模型详情请参考[UGATIT-Paddle开源项目](https://github.com/miraiwk/UGATIT-paddle)
+- ### 应用效果展示
+ - 样例结果示例(左为原图，右为效果图)：
+
+ 
+
-## 模型安装
-```shell
-$hub install UGATIT_92w
-```
+- ### 模型介绍
-## API 说明
+ - UGATIT 图像风格转换模型, 模型可将输入的人脸图像转换成动漫风格.
-```python
-def style_transfer(
- self,
- images=None,
- paths=None,
- batch_size=1,
- output_dir='output',
- visualization=False
-)
-```
-风格转换API，将输入的人脸图像转换成动漫风格。
+## 二、安装
-转换效果图如下：
+- ### 1、环境依赖
-
-
+ - paddlepaddle >= 1.8.2
-**参数**
+ - paddlehub >= 1.8.0
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
-* paths (list\[str\]): 图片的路径，默认为 None；
-* batch\_size (int): batch 的大小，默认设为 1；
-* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
-* output\_dir (str): 图片的保存路径，默认设为 output。
+- ### 2、安装
+ - ```shell
+ $ hub install UGATIT_92w
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+
+## 三、模型API预测
-**返回**
+- ### 1、预测代码示例
-* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。
+ - ```python
+ import cv2
+ import paddlehub as hub
+ # 模型加载
+ # use_gpu：是否使用GPU进行预测
+ model = hub.Module(name='UGATIT_92w', use_gpu=False)
-## 预测代码示例
+ # 模型预测
+ result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
-```python
-import cv2
-import paddlehub as hub
+ # or
+ # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
+ ```
-# 模型加载
-# use_gpu：是否使用GPU进行预测
-model = hub.Module(name='UGATIT_92w', use_gpu=False)
+- ### 2、API
-# 模型预测
-result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ - ```python
+ def style_transfer(
+ self,
+ images=None,
+ paths=None,
+ batch_size=1,
+ output_dir='output',
+ visualization=False
+ )
+ ```
-# or
-# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
-```
+ - 风格转换API，将输入的人脸图像转换成动漫风格。
-## 服务部署
+ - **参数**
+ * images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
+ * paths (list\[str\]): 图片的路径，默认为 None；
+ * batch\_size (int): batch 的大小，默认设为 1；
+ * visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
+ * output\_dir (str): 图片的保存路径，默认设为 output
-PaddleHub Serving可以部署一个在线图像风格转换服务。
+ **NOTE:** paths和images两个参数选择其一进行提供数据
-## 第一步：启动PaddleHub Serving
+ - **返回**
-运行启动命令：
-```shell
-$ hub serving start -m UGATIT_92w
-```
+ - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
+
-这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+## 四、服务部署
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- PaddleHub Serving可以部署一个在线图像风格转换服务。
-## 第二步：发送预测请求
+- ### 第一步：启动PaddleHub Serving
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - 运行启动命令：
+
+ - ```shell
+ $ hub serving start -m UGATIT_92w
+ ```
-```python
-import requests
-import json
-import cv2
-import base64
+ - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
-def cv2_to_base64(image):
- data = cv2.imencode('.jpg', image)[1]
- return base64.b64encode(data.tostring()).decode('utf8')
+- ### 第二步：发送预测请求
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
-# 发送HTTP请求
-data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
-headers = {"Content-type": "application/json"}
-url = "http://127.0.0.1:8866/predict/UGATIT_92w"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
+ - ```python
+ import requests
+ import json
+ import cv2
+ import base64
-# 打印预测结果
-print(r.json()["results"])
-```
+ def cv2_to_base64(image):
+ data = cv2.imencode('.jpg', image)[1]
+ return base64.b64encode(data.tostring()).decode('utf8')
-## 模型相关信息
-### 模型代码
+ # 发送HTTP请求
+ data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+ headers = {"Content-type": "application/json"}
+ url = "http://127.0.0.1:8866/predict/UGATIT_92w"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
-https://github.com/miraiwk/UGATIT-paddle
+ # 打印预测结果
+ print(r.json()["results"])
+ ```
-### 依赖
-paddlepaddle >= 1.8.0
+## 五、更新历史
-paddlehub >= 1.8.0
+* 1.0.0
+
+ 初始发布
\ No newline at end of file
diff --git a/modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md b/modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md
index 50205f868b12c2abaadad3f21d9cea6eaa0542d4..6aac060d13ccca609d904c11ca14042b2a732e1e 100644
--- a/modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md
+++ b/modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md
@@ -1,125 +1,147 @@
-## 模型概述
-AnimeGAN V2 图像风格转换模型
+# animegan_v2_paprika_54
-模型可将输入的图像转换成Paprika风格
+|模型名称|animegan_v2_paprika_54|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|AnimeGAN|
+|数据集|The Wind Rises|
+|是否支持Fine-tuning|否|
+|模型大小|9.4MB|
+|最新更新日期|2021-07-30|
+|数据指标|-|
-模型权重转换自AnimeGAN V2官方开源项目
-模型所使用的权重为Paprika-54.ckpt
+## 一、模型基本信息
-模型详情请参考[AnimeGAN V2 开源项目](https://github.com/TachibanaYoshino/AnimeGANv2)
+- ### 应用效果展示
+ - 样例结果示例：
+
+ 
+
+ 输入图像
+
+ 
+
+ 输出图像
+
+
-## 模型安装
-```shell
-$hub install animegan_v2_paprika_54
-```
+- ### 模型介绍
-## API 说明
+ - AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成宫崎骏动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGAN)。
-```python
-def style_transfer(
- self,
- images=None,
- paths=None,
- output_dir='output',
- visualization=False,
- min_size=32,
- max_size=1024
-)
-```
-风格转换API，将输入的图片转换为漫画风格。
+## 二、安装
-转换效果图如下：
+- ### 1、环境依赖
-
-
+ - paddlepaddle >= 1.8.0
+ - paddlehub >= 1.8.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
-**参数**
+- ### 2、安装
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
-* paths (list\[str\]): 图片的路径，默认为 None；
-* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
-* output\_dir (str): 图片的保存路径，默认设为 output；
-* min\_size (int): 输入图片的短边最小尺寸，默认设为 32；
-* max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
+ - ```shell
+ $ hub install animegan_v2_paprika_54
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+## 三、模型API预测
-**返回**
+- ### 1、预测代码示例
-* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。
+ - ```python
+ import paddlehub as hub
+ import cv2
+ model = hub.Module(name="animegan_v2_paprika_54")
+ result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ # or
+ # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
+ ```
-## 预测代码示例
+- ### 2、API
-```python
-import cv2
-import paddlehub as hub
+ - ```python
+ def style_transfer(images=None,
+ paths=None,
+ output_dir='output',
+ visualization=False,
+ min_size=32,
+ max_size=1024)
+ ```
-# 模型加载
-# use_gpu：是否使用GPU进行预测
-model = hub.Module(name='animegan_v2_paprika_54', use_gpu=False)
+ - 风格转换API，将输入的图片转换为漫画风格。
-# 模型预测
-result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ - **参数**
-# or
-# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
-```
+ - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；
+ - paths (list\[str\]): 图片的路径；
+ - output\_dir (str): 图片的保存路径，默认设为 output；
+ - visualization (bool): 是否将识别结果保存为图片文件；
+ - min\_size (int): 输入图片的短边最小尺寸，默认设为 32；
+ - max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
-## 服务部署
+ **NOTE:** paths和images两个参数选择其一进行提供数据
-PaddleHub Serving可以部署一个在线图像风格转换服务。
+ - **返回**
+ - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
-## 第一步：启动PaddleHub Serving
-运行启动命令：
-```shell
-$ hub serving start -m animegan_v2_paprika_54
-```
+## 四、服务部署
-这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+- PaddleHub Serving可以部署一个在线图像风格转换服务。
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- ### 第一步：启动PaddleHub Serving
-## 第二步：发送预测请求
+ - 运行启动命令：
+ - ```shell
+ $ hub serving start -m animegan_v2_paprika_54
+ ```
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
-```python
-import requests
-import json
-import cv2
-import base64
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- ### 第二步：发送预测请求
-def cv2_to_base64(image):
- data = cv2.imencode('.jpg', image)[1]
- return base64.b64encode(data.tostring()).decode('utf8')
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - ```python
+ import requests
+ import json
+ import cv2
+ import base64
-# 发送HTTP请求
-data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
-headers = {"Content-type": "application/json"}
-url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_54"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-# 打印预测结果
-print(r.json()["results"])
-```
+ def cv2_to_base64(image):
+ data = cv2.imencode('.jpg', image)[1]
+ return base64.b64encode(data.tostring()).decode('utf8')
+ # 发送HTTP请求
+ data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+ headers = {"Content-type": "application/json"}
+ url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_54"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
-## 模型相关信息
+ # 打印预测结果
+ print(r.json()["results"])
+ ```
-### 模型代码
-https://github.com/TachibanaYoshino/AnimeGANv2
+## 五、更新历史
-### 依赖
+* 1.0.0
-paddlepaddle >= 1.8.0
+ 初始发布
-paddlehub >= 1.8.0
+* 1.0.1
+
+ 适配paddlehub2.0
+
+* 1.0.2
+
+ 删除batch_size选项
diff --git a/modules/image/Image_gan/style_transfer/animegan_v2_paprika_97/README.md b/modules/image/Image_gan/style_transfer/animegan_v2_paprika_97/README.md
index 10af52a3a71f2dd26168b659dab0cb05f3818323..ff8b5a3e95ff9155ceb016a1e3ec6dc08f7c18c0 100644
--- a/modules/image/Image_gan/style_transfer/animegan_v2_paprika_97/README.md
+++ b/modules/image/Image_gan/style_transfer/animegan_v2_paprika_97/README.md
@@ -1,125 +1,147 @@
-## 模型概述
-AnimeGAN V2 图像风格转换模型
+# animegan_v2_paprika_97
-模型可将输入的图像转换成Paprika风格
+|模型名称|animegan_v2_paprika_97|
+| :--- | :---: |
+|类别|图像 - 图像生成|
+|网络|AnimeGAN|
+|数据集|Paprika|
+|是否支持Fine-tuning|否|
+|模型大小|9.7MB|
+|最新更新日期|2021-07-30|
+|数据指标|-|
-模型权重转换自AnimeGAN V2官方开源项目
-模型所使用的权重为Paprika-97.ckpt
+## 一、模型基本信息
-模型详情请参考[AnimeGAN V2 开源项目](https://github.com/TachibanaYoshino/AnimeGANv2)
+- ### 应用效果展示
+ - 样例结果示例：
+
+
+
+ 输入图像
+
+ 
+
+ 输出图像
+
+
-## 模型安装
-```shell
-$hub install animegan_v2_paprika_97
-```
+- ### 模型介绍
-## API 说明
+ - AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成红辣椒动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGAN)。
-```python
-def style_transfer(
- self,
- images=None,
- paths=None,
- output_dir='output',
- visualization=False,
- min_size=32,
- max_size=1024
-)
-```
-风格转换API，将输入的图片转换为漫画风格。
+## 二、安装
-转换效果图如下：
+- ### 1、环境依赖
-
-
+ - paddlepaddle >= 1.8.0
+ - paddlehub >= 1.8.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
-**参数**
+- ### 2、安装
-* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，默认为 None；
-* paths (list\[str\]): 图片的路径，默认为 None；
-* visualization (bool): 是否将识别结果保存为图片文件，默认设为 False；
-* output\_dir (str): 图片的保存路径，默认设为 output；
-* min\_size (int): 输入图片的短边最小尺寸，默认设为 32；
-* max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
+ - ```shell
+ $ hub install animegan_v2_paprika_97
+ ```
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+## 三、模型API预测
-**返回**
+- ### 1、预测代码示例
-* res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]。
+ - ```python
+ import paddlehub as hub
+ import cv2
+ model = hub.Module(name="animegan_v2_paprika_97")
+ result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ # or
+ # result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
+ ```
-## 预测代码示例
+- ### 2、API
-```python
-import cv2
-import paddlehub as hub
+ - ```python
+ def style_transfer(images=None,
+ paths=None,
+ output_dir='output',
+ visualization=False,
+ min_size=32,
+ max_size=1024)
+ ```
-# 模型加载
-# use_gpu：是否使用GPU进行预测
-model = hub.Module(name='animegan_v2_paprika_97', use_gpu=False)
+ - 风格转换API，将输入的图片转换为漫画风格。
-# 模型预测
-result = model.style_transfer(images=[cv2.imread('/PATH/TO/IMAGE')])
+ - **参数**
-# or
-# result = model.style_transfer(paths=['/PATH/TO/IMAGE'])
-```
+ - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；
+ - paths (list\[str\]): 图片的路径；
+ - output\_dir (str): 图片的保存路径，默认设为 output；
+ - visualization (bool): 是否将识别结果保存为图片文件；
+ - min\_size (int): 输入图片的短边最小尺寸，默认设为 32；
+ - max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
-## 服务部署
+ **NOTE:** paths和images两个参数选择其一进行提供数据
-PaddleHub Serving可以部署一个在线图像风格转换服务。
+ - **返回**
+ - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
-## 第一步：启动PaddleHub Serving
-运行启动命令：
-```shell
-$ hub serving start -m animegan_v2_paprika_97
-```
+## 四、服务部署
-这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
+- PaddleHub Serving可以部署一个在线图像风格转换服务。
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- ### 第一步：启动PaddleHub Serving
-## 第二步：发送预测请求
+ - 运行启动命令：
+ - ```shell
+ $ hub serving start -m animegan_v2_paprika_97
+ ```
-配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - 这样就完成了一个图像风格转换的在线服务API的部署，默认端口号为8866。
-```python
-import requests
-import json
-import cv2
-import base64
+ - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
+- ### 第二步：发送预测请求
-def cv2_to_base64(image):
- data = cv2.imencode('.jpg', image)[1]
- return base64.b64encode(data.tostring()).decode('utf8')
+ - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
+ - ```python
+ import requests
+ import json
+ import cv2
+ import base64
-# 发送HTTP请求
-data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
-headers = {"Content-type": "application/json"}
-url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_97"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-# 打印预测结果
-print(r.json()["results"])
-```
+ def cv2_to_base64(image):
+ data = cv2.imencode('.jpg', image)[1]
+ return base64.b64encode(data.tostring()).decode('utf8')
+ # 发送HTTP请求
+ data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
+ headers = {"Content-type": "application/json"}
+ url = "http://127.0.0.1:8866/predict/animegan_v2_paprika_97"
+ r = requests.post(url=url, headers=headers, data=json.dumps(data))
-## 模型相关信息
+ # 打印预测结果
+ print(r.json()["results"])
+ ```
-### 模型代码
-https://github.com/TachibanaYoshino/AnimeGANv2
+## 五、更新历史
-### 依赖
+* 1.0.0
-paddlepaddle >= 1.8.0
+ 初始发布
-paddlehub >= 1.8.0
+* 1.0.1
+
+ 适配paddlehub2.0
+
+* 1.0.2
+
+ 删除batch_size选项
diff --git a/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP/README.md b/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..002bfeebc0201e7a825f24bfb850a3fb564a1c25
--- /dev/null
+++ b/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP/README.md
@@ -0,0 +1,92 @@
+
+# Pneumonia_CT_LKM_PP
+
+|模型名称|Pneumonia_CT_LKM_PP|
+| :--- | :---: |
+|类别|图像-图像分割|
+|网络|-|
+|数据集|-|
+|是否支持Fine-tuning|否|
+|模型大小|35M|
+|指标|-|
+|最新更新日期|2021-02-26|
+
+
+## 一、模型基本信息
+
+
+- ### 模型介绍
+
+ - 肺炎CT影像分析模型（Pneumonia-CT-LKM-PP）可以高效地完成对患者CT影像的病灶检测识别、病灶轮廓勾画，通过一定的后处理代码，可以分析输出肺部病灶的数量、体积、病灶占比等全套定量指标。值得强调的是，该系统采用的深度学习算法模型充分训练了所收集到的高分辨率和低分辨率的CT影像数据，能极好地适应不同等级CT影像设备采集的检查数据，有望为医疗资源受限和医疗水平偏低的基层医院提供有效的肺炎辅助诊断工具。
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 2.0.0
+
+ - paddlehub >= 2.0.0
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install Pneumonia_CT_LKM_PP==1.0.0
+ ```
+
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+## 三、模型API预测
+
+- ### 1、预测代码示例
+
+ ```python
+ import paddlehub as hub
+
+ pneumonia = hub.Module(name="Pneumonia_CT_LKM_PP")
+
+ input_only_lesion_np_path = "/PATH/TO/ONLY_LESION_NP"
+ input_both_lesion_np_path = "/PATH/TO/LESION_NP"
+ input_both_lung_np_path = "/PATH/TO/LUNG_NP"
+
+ # set input dict
+ input_dict = {"image_np_path": [
+ [input_only_lesion_np_path],
+ [input_both_lesion_np_path, input_both_lung_np_path],
+ ]}
+
+ # execute predict and print the result
+ results = pneumonia.segmentation(data=input_dict)
+ for result in results:
+ print(result)
+
+ ```
+
+
+- ### 2、API
+
+ ```python
+ def segmentation(data)
+ ```
+
+ - 预测API，用于肺炎CT影像分析。
+
+ - **参数**
+
+ * data (dict): key，str类型，"image_np_path"；value，list类型，每个元素为list类型，[用于病灶分析的影像numpy数组(文件后缀名.npy)路径, 用于肺部分割的影像numpy数组路径]，如果仅进行病灶分析不进行肺部分割，可以省略用于肺部分割的影像numpy数组路径
+
+
+ - **返回**
+
+ * result (list\[dict\]): 每个元素为对应输入的预测结果。每个预测结果为dict类型：预测结果有以下字段：
+ * input_lesion_np_path: 存放用于病灶分析的numpy数组路径；
+ * output_lesion_np: 存放病灶分析结果，numpy数组；
+ * input_lesion_np_path：存放用于肺部分割的numpy数组路径（仅当对应输入包含肺部影像numpy时存在该字段）
+ * output_lung_np：存放肺部分割结果，numpy数组（仅当对应输入包含肺部影像numpy时存在该字段）
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布
diff --git a/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP_lung/README.md b/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP_lung/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..24a6df13d15294b3c0f859aff5a7ff20befd9b9a
--- /dev/null
+++ b/modules/image/semantic_segmentation/Pneumonia_CT_LKM_PP_lung/README.md
@@ -0,0 +1,92 @@
+
+# Pneumonia_CT_LKM_PP_lung
+
+|模型名称|Pneumonia_CT_LKM_PP_lung|
+| :--- | :---: |
+|类别|图像-图像分割|
+|网络|-|
+|数据集|-|
+|是否支持Fine-tuning|否|
+|模型大小|35M|
+|指标|-|
+|最新更新日期|2021-02-26|
+
+
+## 一、模型基本信息
+
+
+- ### 模型介绍
+
+ - 肺炎CT影像分析模型（Pneumonia-CT-LKM-PP）可以高效地完成对患者CT影像的病灶检测识别、病灶轮廓勾画，通过一定的后处理代码，可以分析输出肺部病灶的数量、体积、病灶占比等全套定量指标。值得强调的是，该系统采用的深度学习算法模型充分训练了所收集到的高分辨率和低分辨率的CT影像数据，能极好地适应不同等级CT影像设备采集的检查数据，有望为医疗资源受限和医疗水平偏低的基层医院提供有效的肺炎辅助诊断工具。(此module为Pneumonia_CT_LKM_PP的子module。)
+
+## 二、安装
+
+- ### 1、环境依赖
+
+ - paddlepaddle >= 2.0.0
+
+ - paddlehub >= 2.0.0
+
+- ### 2、安装
+
+ - ```shell
+ $ hub install Pneumonia_CT_LKM_PP_lung==1.0.0
+ ```
+
+ - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
+ | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
+
+## 三、模型API预测
+
+- ### 1、预测代码示例
+
+ ```python
+ import paddlehub as hub
+
+ pneumonia = hub.Module(name="Pneumonia_CT_LKM_PP_lung")
+
+ input_only_lesion_np_path = "/PATH/TO/ONLY_LESION_NP"
+ input_both_lesion_np_path = "/PATH/TO/LESION_NP"
+ input_both_lung_np_path = "/PATH/TO/LUNG_NP"
+
+ # set input dict
+ input_dict = {"image_np_path": [
+ [input_only_lesion_np_path],
+ [input_both_lesion_np_path, input_both_lung_np_path],
+ ]}
+
+ # execute predict and print the result
+ results = pneumonia.segmentation(data=input_dict)
+ for result in results:
+ print(result)
+
+ ```
+
+
+- ### 2、API
+
+ ```python
+ def segmentation(data)
+ ```
+
+ - 预测API，用于肺炎CT影像分析。
+
+ - **参数**
+
+ * data (dict): key，str类型，"image_np_path"；value，list类型，每个元素为list类型，[用于病灶分析的影像numpy数组(文件后缀名.npy)路径, 用于肺部分割的影像numpy数组路径]，如果仅进行病灶分析不进行肺部分割，可以省略用于肺部分割的影像numpy数组路径
+
+
+ - **返回**
+
+ * result (list\[dict\]): 每个元素为对应输入的预测结果。每个预测结果为dict类型：预测结果有以下字段：
+ * input_lesion_np_path: 存放用于病灶分析的numpy数组路径；
+ * output_lesion_np: 存放病灶分析结果，numpy数组；
+ * input_lesion_np_path：存放用于肺部分割的numpy数组路径（仅当对应输入包含肺部影像numpy时存在该字段）
+ * output_lung_np：存放肺部分割结果，numpy数组（仅当对应输入包含肺部影像numpy时存在该字段）
+
+
+## 四、更新历史
+
+* 1.0.0
+
+ 初始发布