Update image classification module docs (#1614)

modules/image/classification/ghostnet_x0_5_imagenet/README.md

-```shell
-$ hub install ghostnet_x0_5_imagenet==1.0.0
-```
+# ghostnet_x0_5_imagenet
 
-## 命令行预测
+|模型名称|ghostnet_x0_5_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|GhostNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|15MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run ghostnet_x0_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
 
-    model = hub.Module(name='ghostnet_x0_5_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install ghostnet_x0_5_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run ghostnet_x0_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='ghostnet_x0_5_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='ghostnet_x0_5_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x0_5_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="ghostnet_x0_5_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='ghostnet_x0_5_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m ghostnet_x0_5_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m ghostnet_x0_5_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/ghostnet_x0_5_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/ghostnet_x0_5_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/ghostnet_x1_0_imagenet/README.md

-```shell
-$ hub install ghostnet_x1_0_imagenet==1.0.0
-```
+# ghostnet_x1_0_imagenet
 
-## 命令行预测
+|模型名称|ghostnet_x1_0_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|GhostNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|30MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run ghostnet_x1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
 
-    model = hub.Module(name='ghostnet_x1_0_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install ghostnet_x1_0_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run ghostnet_x1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='ghostnet_x1_0_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='ghostnet_x1_0_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="ghostnet_x1_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='ghostnet_x1_0_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m ghostnet_x1_0_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m ghostnet_x1_0_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/ghostnet_x1_0_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/ghostnet_x1_0_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/ghostnet_x1_3_imagenet/README.md

-```shell
-$ hub install ghostnet_x1_3_imagenet==1.0.0
-```
+# ghostnet_x1_3_imagenet
 
-## 命令行预测
+|模型名称|ghostnet_x1_3_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|GhostNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|43MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run ghostnet_x1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
 
-    model = hub.Module(name='ghostnet_x1_3_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install ghostnet_x1_3_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run ghostnet_x1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='ghostnet_x1_3_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='ghostnet_x1_3_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="ghostnet_x1_3_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='ghostnet_x1_3_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m ghostnet_x1_3_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m ghostnet_x1_3_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/ghostnet_x1_3_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/ghostnet_x1_3_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md

-```shell
-$ hub install ghostnet_x1_3_imagenet_ssld==1.0.0
-```
+# ghostnet_x1_3_imagenet_ssld
 
-## 命令行预测
+|模型名称|ghostnet_x1_3_imagenet_ssld|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|GhostNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|43MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run ghostnet_x1_3_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
 
-    model = hub.Module(name='ghostnet_x1_3_imagenet_ssld',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install ghostnet_x1_3_imagenet_ssld
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run ghostnet_x1_3_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='ghostnet_x1_3_imagenet_ssld')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='ghostnet_x1_3_imagenet_ssld',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="ghostnet_x1_3_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='ghostnet_x1_3_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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m ghostnet_x1_3_imagenet_ssld
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m ghostnet_x1_3_imagenet_ssld
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/ghostnet_x1_3_imagenet_ssld"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/ghostnet_x1_3_imagenet_ssld"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet18_imagenet/README.md

-```shell
-$ hub install hrnet18_imagenet==1.0.0
-```
+# hrnet18_imagenet
 
-## 命令行预测
+|模型名称|hrnet18_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|124MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet18_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet18_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet18_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet18_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet18_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet18_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet18_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet18_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet18_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet18_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet18_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet18_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet18_imagenet_ssld/README.md

-```shell
-$ hub install hrnet18_imagenet_ssld==1.0.0
-```
+# hrnet18_imagenet_ssld
 
-## 命令行预测
+|模型名称|hrnet18_imagenet_ssld|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|124MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet18_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet18_imagenet_ssld',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet18_imagenet_ssld
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet18_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet18_imagenet_ssld')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet18_imagenet_ssld',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet18_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet18_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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet18_imagenet_ssld
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet18_imagenet_ssld
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet18_imagenet_ssld"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet18_imagenet_ssld"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet30_imagenet/README.md

-```shell
-$ hub install hrnet30_imagenet==1.0.0
-```
+# hrnet30_imagenet
 
-## 命令行预测
+|模型名称|hrnet30_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|218MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet30_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet30_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet30_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet30_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet30_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet30_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet30_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet30_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet30_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet30_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet30_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet30_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet30_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet32_imagenet/README.md

-```shell
-$ hub install hrnet32_imagenet==1.0.0
-```
+# hrnet32_imagenet
 
-## 命令行预测
+|模型名称|hrnet32_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|238MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet32_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet32_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet32_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet32_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet32_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet32_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet32_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet32_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet32_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet32_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet32_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet32_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet32_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet40_imagenet/README.md

-```shell
-$ hub install hrnet40_imagenet==1.0.0
-```
+# hrnet40_imagenet
 
-## 命令行预测
+|模型名称|hrnet40_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|333MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet40_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet40_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet40_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet40_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet40_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet40_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet40_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet40_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet40_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet40_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet40_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet40_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet40_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet44_imagenet/README.md

-```shell
-$ hub install hrnet44_imagenet==1.0.0
-```
+# hrnet44_imagenet
 
-## 命令行预测
+|模型名称|hrnet44_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|388MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet44_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet44_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet44_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet44_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet44_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet44_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet44_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet44_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet44_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet44_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet44_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet44_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet44_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet48_imagenet/README.md

-```shell
-$ hub install hrnet48_imagenet==1.0.0
-```
+# hrnet48_imagenet
 
-## 命令行预测
+|模型名称|hrnet48_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|448MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet48_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet48_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet48_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet48_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet48_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet48_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet48_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet48_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet48_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet48_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet48_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet48_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet48_imagenet_ssld/README.md

-```shell
-$ hub install hrnet48_imagenet_ssld==1.0.0
-```
+# hrnet48_imagenet_ssld
 
-## 命令行预测
+|模型名称|hrnet48_imagenet_ssld|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|446MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet48_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet48_imagenet_ssld',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet48_imagenet_ssld
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet48_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet48_imagenet_ssld')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet48_imagenet_ssld',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet48_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet48_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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet48_imagenet_ssld
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet48_imagenet_ssld
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet48_imagenet_ssld"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet48_imagenet_ssld"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/hrnet64_imagenet/README.md

-```shell
-$ hub install hrnet64_imagenet==1.0.0
-```
+# hrnet64_imagenet
 
-## 命令行预测
+|模型名称|hrnet64_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|HRNet|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|740MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run hrnet64_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
 
-    model = hub.Module(name='hrnet64_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install hrnet64_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run hrnet64_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='hrnet64_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='hrnet64_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet64_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="hrnet64_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='hrnet64_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m hrnet64_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m hrnet64_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/hrnet64_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/hrnet64_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/repvgg_a0_imagenet/README.md

-```shell
-$ hub install repvgg_a0_imagenet==1.0.0
-```
+# repvgg_a0_imagenet
 
-## 命令行预测
+|模型名称|repvgg_a0_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|RepVGG|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|53MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run repvgg_a0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - RepVGG（Making VGG-style ConvNets Great Again）系列模型是清华大学（丁桂光团队）、旷视科技（孙建等）、香港科技大学和阿伯里斯特威斯大学于2021年提出的一种简单但功能强大的卷积神经网络架构。有一个类似于 VGG 的推理时间代理。主体由3x3卷积和relu stack组成，而训练时间模型具有多分支拓扑。训练时间和推理时间的解耦是通过重新参数化技术实现的，因此该模型被称为repvgg。
 
-    model = hub.Module(name='repvgg_a0_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install repvgg_a0_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run repvgg_a0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='repvgg_a0_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='repvgg_a0_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="repvgg_a0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='repvgg_a0_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m repvgg_a0_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m repvgg_a0_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/repvgg_a0_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/repvgg_a0_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布

modules/image/classification/repvgg_a1_imagenet/README.md

-```shell
-$ hub install repvgg_a1_imagenet==1.0.0
-```
+# repvgg_a1_imagenet
 
-## 命令行预测
+|模型名称|repvgg_a1_imagenet|
+| :--- | :---: |
+|类别|图像-图像分类|
+|网络|RepVGG|
+|数据集|ImageNet-2012|
+|是否支持Fine-tuning|是|
+|模型大小|82MB|
+|指标|-|
+|最新更新日期|2021-09-14|
 
-```shell
-$ hub run repvgg_a1_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
-```
 
-## 脚本预测
+## 一、模型基本信息
 
-```python
-import paddle
-import paddlehub as hub
+- ### 模型介绍
 
-if __name__ == '__main__':
+  - RepVGG（Making VGG-style ConvNets Great Again）系列模型是清华大学（丁桂光团队）、旷视科技（孙建等）、香港科技大学和阿伯里斯特威斯大学于2021年提出的一种简单但功能强大的卷积神经网络架构。有一个类似于 VGG 的推理时间代理。主体由3x3卷积和relu stack组成，而训练时间模型具有多分支拓扑。训练时间和推理时间的解耦是通过重新参数化技术实现的，因此该模型被称为repvgg。
 
-    model = hub.Module(name='repvgg_a1_imagenet',)
-    result = model.predict([PATH/TO/IMAGE])
-```
 
-## Fine-tune代码步骤
+## 二、安装
 
-使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。
+- ### 1、环境依赖
 
-### Step1: 定义数据预处理方式
-```python
-import paddlehub.vision.transforms as T
+    - paddlepaddle >= 2.0.0
 
-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)
-```
+    - paddlehub >= 2.0.0
 
-'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
+- ### 2、安装
+    - ```shell
+      $ hub install repvgg_a1_imagenet
+      ```
 
-### Step2: 下载数据集并使用
-```python
-from paddlehub.datasets import Flowers
+    -  如您安装时遇到问题，可参考：[零基础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)  
 
-flowers = Flowers(transforms)
-flowers_validate = Flowers(transforms, mode='val')
-```
-* transforms(Callable): 数据预处理方式。
-* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
+## 三、模型API预测
 
-'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。
+- ### 1.命令行预测
 
+    ```shell
+    $ hub run repvgg_a1_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
+    ```
+- ### 2.预测代码示例
 
-### Step3: 加载预训练模型
-
-```python
-import paddlehub as hub
+    ```python
+    import paddle
+    import paddlehub as hub
+    if __name__ == '__main__':
+        model = hub.Module(name='repvgg_a1_imagenet')
+        result = model.predict(['flower.jpg'])
+    ```
+- ### 3.如何开始Fine-tune
 
-model = hub.Module(name='repvgg_a1_imagenet',
-                   label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
-                   load_checkpoint=None)
-```
-* name(str): 选择预训练模型的名字。
-* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
-* load _checkpoint(str): 模型参数地址。
+    - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a1_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
 
-PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。
+    - 代码步骤
 
-如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可.
-```python
-import paddlehub as hub
+        - Step1: 定义数据预处理方式
+            - ```python
+              import paddlehub.vision.transforms as T
+              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)
+              ```
 
-# 更换name参数即可无缝切换efficientnet模型, 代码示例如下
-module = hub.Module(name="efficientnetb7_imagenet")
-```
-**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
+                - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
 
-### Step4: 选择优化策略和运行配置
+        - Step2: 下载数据集并使用
+            - ```python
+              from paddlehub.datasets import Flowers
+              flowers = Flowers(transforms)
+              flowers_validate = Flowers(transforms, mode='val')
+              ```
 
-```python
-import paddle
-from paddlehub.finetune.trainer import Trainer
+                * `transforms`: 数据预处理方式。
+                * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
 
-optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+                * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
 
-trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
-```
 
-#### 优化策略
+        - Step3: 加载预训练模型
 
-Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。
+            - ```python
+              model = hub.Module(name="repvgg_a1_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
+              ```
+                * `name`: 选择预训练模型的名字。
+                * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
 
-其中'Adam':
+        - Step4: 选择优化策略和运行配置
 
-* learning_rate: 全局学习率。默认为1e-3；
-* parameters: 待优化模型参数。
+            ```python
+            optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+            trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
+            trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
+            ```
 
-#### 运行配置
-'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* model: 被优化模型；
-* optimizer: 优化器选择；
-* use_vdl: 是否使用vdl可视化训练过程；
-* checkpoint_dir: 保存模型参数的地址；
-* compare_metrics: 保存最优模型的衡量指标；
+            - 运行配置
 
-'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数：
+            - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
 
-* train_dataset: 训练时所用的数据集；
-* epochs: 训练轮数；
-* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
-* num_workers: works的数量，默认为0；
-* eval_dataset: 验证集；
-* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
-* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
+                * `model`: 被优化模型；
+                * `optimizer`: 优化器选择；
+                * `use_vdl`: 是否使用vdl可视化训练过程；
+                * `checkpoint_dir`: 保存模型参数的地址；
+                * `compare_metrics`: 保存最优模型的衡量指标；
 
-## 模型预测
+            - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
 
-当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。
-我们使用该模型来进行预测。predict.py脚本如下：
+                * `train_dataset`: 训练时所用的数据集；
+                * `epochs`: 训练轮数；
+                * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
+                * `num_workers`: works的数量，默认为0；
+                * `eval_dataset`: 验证集；
+                * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
+                * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
 
-```python
-import paddle
-import paddlehub as hub
+    - 模型预测
 
-if __name__ == '__main__':
+        -   当完成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='repvgg_a1_imagenet', 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可以部署一个在线分类任务服务
+            - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
 
-## Step1: 启动PaddleHub Serving
+## 四、服务部署
 
-运行启动命令：
+- PaddleHub Serving可以部署一个在线分类任务服务。
 
-```shell
-$ hub serving start -m repvgg_a1_imagenet
-```
+- ### 第一步：启动PaddleHub Serving
 
-这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
+    - 运行启动命令：
 
-**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
+    - ```shell
+      $ hub serving start -m repvgg_a1_imagenet
+      ```
 
-## Step2: 发送预测请求
+    - 这样就完成了一个分类任务服务化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):
+        ```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):
+        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/repvgg_a1_imagenet"
-r = requests.post(url=url, headers=headers, data=json.dumps(data))
-data =r.json()["results"]['data']
-```
-
-### 查看代码
-
-[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
-
-### 依赖
-
-paddlepaddle >= 2.0.0
-
-paddlehub >= 2.0.0
+        # 发送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/repvgg_a1_imagenet"
+        r = requests.post(url=url, headers=headers, data=json.dumps(data))
+        data =r.json()["results"]['data']
+        ```
+## 五、更新历史
+
+* 1.0.0
+
+  初始发布