update docs

7ce67e43 · jiangjiajun · df84bc6b · df84bc6b · df84bc6b · df84bc6b
37 changed file
--- a/docs/apis/datasets/classification.md
+++ b/docs/apis/datasets/classification.md
-# 图像分类数据集
-## ImageNet
-```
-paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
-```
-读取ImageNet格式的分类数据集，并对样本进行相应的处理。ImageNet数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/classification/mobilenetv2.py#L25)
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和类别id的文件路径（文本内每行路径为相对`data_dir`的相对路径）。  
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.cls.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.cls.transforms](./transforms/cls_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。  
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。  
-## EasyDataCls
-```
-paddlex.datasets.EasyDatasetCls(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 读取EasyData平台标注图像分类数据集，并对样本进行相应的处理。EasyData图像分类任务数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)。
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.cls.transforms](./transforms/cls_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
--- a/docs/apis/datasets/dataset_convert.md
+++ b/docs/apis/datasets/dataset_convert.md
-# 数据集转换
-## labelme2voc
-```python
-pdx.tools.labelme2voc(image_dir, json_dir, dataset_save_dir)
-```
-将LabelMe标注的数据集转换为VOC数据集。
-> **参数**
-> > * **image_dir** (str): 图像文件存放的路径。
-> > * **json_dir** (str): 与每张图像对应的json文件的存放路径。
-> > * **dataset_save_dir** (str): 转换后数据集存放路径。
-## 其它数据集转换
-### easydata2imagenet
-```python
-pdx.tools.easydata2imagenet(image_dir, json_dir, dataset_save_dir)
-```
-### easydata2voc
-```python
-pdx.tools.easydata2voc(image_dir, json_dir, dataset_save_dir)
-```
-### easydata2coco
-```python
-pdx.tools.easydata2coco(image_dir, json_dir, dataset_save_dir)
-```
-### easydata2seg
-```python
-pdx.tools.easydata2seg(image_dir, json_dir, dataset_save_dir)
-```
-### labelme2coco
-```python
-pdx.tools.labelme2coco(image_dir, json_dir, dataset_save_dir)
-```
-### labelme2seg
-```python
-pdx.tools.labelme2seg(image_dir, json_dir, dataset_save_dir)
-```
-### jingling2seg
-```python
-pdx.tools.jingling2seg(image_dir, json_dir, dataset_save_dir)
-```
--- a/docs/apis/datasets/detection.md
+++ b/docs/apis/datasets/detection.md
-# 检测和实例分割数据集
-## VOCDetection类
-```
-paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 仅用于**目标检测**。读取PascalVOC格式的检测数据集，并对样本进行相应的处理。PascalVOC数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/yolov3_darknet53.py#L29)
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.det.transforms](./transforms/det_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。  
-> 【可选】支持在训练过程中加入无目标真值的背景图片来减少背景误检，定义VOCDetection类后调用其成员函数`add_negative_samples`添加背景图片即可：
-> ```
-> add_negative_samples(image_dir)
-> ```
-> > 示例：[代码](../../tuning_strategy/detection/negatives_training.html#id4)
-> > **参数**
-> > > * **image_dir** (str): 背景图片所在的目录路径。
-## CocoDetection类
-```
-paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 用于**目标检测或实例分割**。读取MSCOCO格式的检测数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。MSCOCO数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/mask_rcnn_r50_fpn.py#L27)
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **ann_file** (str): 数据集的标注文件，为一个独立的json格式文件。
-> > * **transforms** (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.det.transforms](./transforms/det_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。  
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。  
-> 【可选】支持在训练过程中加入无目标真值的背景图片来减少背景误检，定义CocoDetection类后调用其成员函数`add_negative_samples`添加背景图片即可：
-> ```
-> add_negative_samples(image_dir)
-> ```
-> > 示例：[代码](../../tuning_strategy/detection/negatives_training.html#id4)
-> > **参数**
-> > > * **image_dir** (str): 背景图片所在的目录路径。
-## EasyDataDet类
-```
-paddlex.datasets.EasyDataDet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 用于**目标检测或实例分割**。读取EasyData目标检测格式数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。EasyData目标检测或实例分割任务数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.det.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.det.transforms](./transforms/det_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
-> 【可选】支持在训练过程中加入无目标真值的背景图片来减少背景误检，定义EasyDataDet类后调用其成员函数`add_negative_samples`添加背景图片即可：
-> ```
-> add_negative_samples(image_dir)
-> ```
-> > 示例：[代码](../../tuning_strategy/detection/negatives_training.html#id4)
-> > **参数**
-> > > * **image_dir** (str): 背景图片所在的目录路径。
--- a/docs/apis/datasets/index.rst
+++ b/docs/apis/datasets/index.rst
-数据集-datasets
-============================
-PaddleX目前支持主流的CV数据集格式和 `EasyData <https://ai.baidu.com/easydata/>`_ 数据标注平台的标注数据格式，此外PaddleX也提升了数据格式转换工具API，支持包括LabelMe，精灵标注助手和EasyData平台数据格式的转换，可以参考PaddleX的tools API文档。
-下表为各数据集格式与相应任务的对应关系，
-+------------------------+------------+----------+----------+----------+
-| 数据集格式             | 图像分类   | 目标检测 | 实例分割 | 语义分割 |
-+========================+============+==========+==========+==========+
-| ImageNet               | √          | -        | -        | -        |
-+------------------------+------------+----------+----------+----------+
-| VOCDetection           | -          | √        | -        | -        |
-+------------------------+------------+----------+----------+----------+
-| CocoDetection          | -          | √        | √        | -        |
-+------------------------+------------+----------+----------+----------+
-| SegDataset             | -          | -        | -        | √        |
-+------------------------+------------+----------+----------+----------+
-| EasyDataCls            | √          | -        | -        | -        |
-+------------------------+------------+----------+----------+----------+
-| EasyDataDet            | -          | √        | √        | -        |
-+------------------------+------------+----------+----------+----------+
-| EasyDataSeg            | -          | -        | -        | √        |
-+------------------------+------------+----------+----------+----------+
-.. toctree::
-   :maxdepth: 2
-   classification.md
-   detection.md
-   semantic_segmentation.md
-   dataset_convert.md
--- a/docs/apis/datasets/semantic_segmentation.md
+++ b/docs/apis/datasets/semantic_segmentation.md
-# 语义分割数据集
-## SegDataset类
-```
-paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 读取语义分割任务数据集，并对样本进行相应的处理。语义分割任务数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/unet.py#L27)
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.seg.transforms](./transforms/seg_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。 
-## EasyDataSeg类
-```
-paddlex.datasets.EasyDataSeg(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
-```
-> 读取EasyData语义分割任务数据集，并对样本进行相应的处理。EasyData语义分割任务数据集格式的介绍可查看文档:[数据集格式说明](../datasets.md)  
-> **参数**
-> > * **data_dir** (str): 数据集所在的目录路径。  
-> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
-> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
-> > * **transforms** (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.seg.transforms](./transforms/seg_transforms.md)。  
-> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
-> > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
-> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。 
--- a/docs/apis/visualize.md
+++ b/docs/apis/visualize.md
@@ -16,12 +16,12 @@ paddlex.det.visualize(image, result, threshold=0.5, save_dir='./')
 > * **save_dir**(str): 可视化结果保存路径。若为None，则表示不保存，该函数将可视化的结果以np.ndarray的形式返回；若设为目录路径，则将可视化结果保存至该目录下。默认值为'./'。
 ### 使用示例
-> 点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/xiaoduxiong_epoch_12.tar.gz)和[测试图片](https://bj.bcebos.com/paddlex/datasets/xiaoduxiong.jpeg)
+> 点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/xiaoduxiong_epoch_12.tar.gz)
 ```
 import paddlex as pdx
 model = pdx.load_model('xiaoduxiong_epoch_12')
-result = model.predict('xiaoduxiong.jpeg')
+result = model.predict('./xiaoduxiong_epoch_12/xiaoduxiong.jpeg')
-pdx.det.visualize('xiaoduxiong.jpeg', result, save_dir='./')
+pdx.det.visualize('./xiaoduxiong_epoch_12/xiaoduxiong.jpeg', result, save_dir='./')
 # 预测结果保存在./visualize_xiaoduxiong.jpeg
 ```
 ## paddlex.seg.visualize

--- a/docs/appendix/anaconda_install.md
+++ b/docs/appendix/anaconda_install.md
@@ -8,7 +8,7 @@ Anaconda是一个开源的Python发行版本，其包含了conda、Python等180
 ### 第二步 安装
 运行下载的安装包(以.exe为后辍)，根据引导完成安装, 用户可自行修改安装目录（如下图）
-![](../images/anaconda_windows.png)
+![](images/anaconda_windows.png)
 ### 第三步 使用
 - 点击Windows系统左下角的Windows图标，打开：所有程序->Anaconda3/2（64-bit）->Anaconda Prompt  

--- a/docs/appendix/datasets.md
+++ b/docs/appendix/datasets.md
-# 数据集格式说明
---
-## 图像分类ImageNet
-图像分类ImageNet数据集包含对应多个标签的图像文件夹、标签文件及图像列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录
-|--labelA  # 标签为labelA的图像目录
-|  |--a1.jpg
-|  |--...
-|  └--...
-|
-|--...
-|
-|--labelZ  # 标签为labelZ的图像目录
-|  |--z1.jpg
-|  |--...
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表文件
-```
-其中，相应的文件名可根据需要自行定义。
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为图像文件对应的标签id(从0开始)。如下所示：
-```
-labelA/a1.jpg 0
-labelZ/z1.jpg 25
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-labelA
-labelB
-...
-```
-[点击这里](https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz)，下载蔬菜分类分类数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.ImageNet`([API说明](../apis/datasets/classification.html#imagenet))加载分类数据集。
-## 目标检测VOC
-目标检测VOC数据集包含图像文件夹、标注信息文件夹、标签文件及图像列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录
-|--JPEGImages  # 图像目录
-|  |--xxx1.jpg
-|  |--...
-|  └--...
-|
-|--Annotations  # 标注信息目录
-|  |--xxx1.xml
-|  |--...
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表文件
-```
-其中，相应的文件名可根据需要自行定义。
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为标注文件相对于dataset的相对路径。如下所示：
-```
-JPEGImages/xxx1.jpg Annotations/xxx1.xml
-JPEGImages/xxx2.jpg Annotations/xxx2.xml
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-labelA
-labelB
-...
-```
-[点击这里](https://bj.bcebos.com/paddlex/datasets/insect_det.tar.gz)，下载昆虫检测数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.VOCDetection`([API说明](../apis/datasets/detection.html#vocdetection))加载目标检测VOC数据集。
-## 目标检测和实例分割COCO
-目标检测和实例分割COCO数据集包含图像文件夹及图像标注信息文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录
-|--JPEGImages  # 图像目录
-|  |--xxx1.jpg
-|  |--...
-|  └--...
-|
-|--train.json  # 训练相关信息文件
-|
-└--val.json  # 验证相关信息文件
-```
-其中，相应的文件名可根据需要自行定义。
-`train.json`和`val.json`存储与标注信息、图像文件相关的信息。如下所示：
-```
-{
-  "annotations": [
-    {
-      "iscrowd": 0,
-      "category_id": 1,
-      "id": 1,
-      "area": 33672.0,
-      "image_id": 1,
-      "bbox": [232, 32, 138, 244],
-      "segmentation": [[32, 168, 365, 117, ...]]
-    },
-    ...
-  ],
-  "images": [
-    {
-      "file_name": "xxx1.jpg",
-      "height": 512,
-      "id": 267,
-      "width": 612
-    },
-    ...
-  ]
-  "categories": [
-    {
-      "name": "labelA",
-      "id": 1,
-      "supercategory": "component"
-    }
-  ]
-}
-```
-其中，每个字段的含义如下所示：
-| 域名 | 字段名 | 含义 | 数据类型 | 备注 |
-|:-----|:--------|:------------|------|:-----|
-| annotations | id | 标注信息id | int | 从1开始 |
-| annotations | iscrowd      | 标注框是否为一组对象 | int | 只有0、1两种取值 |
-| annotations | category_id  | 标注框类别id | int |  |
-| annotations | area         | 标注框的面积 | float |  |
-| annotations | image_id     | 当前标注信息所在图像的id | int |  |
-| annotations | bbox         | 标注框坐标 | list | 长度为4，分别代表x,y,w,h |
-| annotations | segmentation | 标注区域坐标 | list | list中有至少1个list，每个list由每个小区域坐标点的横纵坐标(x,y)组成 |
-| images          | id                | 图像id | int | 从1开始 |
-| images   | file_name         | 图像文件名 | str |  |
-| images      | height            | 图像高度 | int |  |
-| images       | width             | 图像宽度 | int |  |
-| categories  | id            | 类别id | int | 从1开始 |
-| categories | name          | 类别标签名 | str |  |
-| categories | supercategory | 类别父类的标签名 | str |  |
-[点击这里](https://bj.bcebos.com/paddlex/datasets/garbage_ins_det.tar.gz)，下载垃圾实例分割数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.COCODetection`([API说明](../apis/datasets/detection.html#cocodetection))加载COCO格式数据集。
-## 语义分割数据
-语义分割数据集包含原图、标注图及相应的文件列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录
-|--images  # 原图目录
-|  |--xxx1.png
-|  |--...
-|  └--...
-|
-|--annotations  # 标注图目录
-|  |--xxx1.png
-|  |--...
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表
-```
-其中，相应的文件名可根据需要自行定义。
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为标注图像文件相对于dataset的相对路径。如下所示：
-```
-images/xxx1.png annotations/xxx1.png
-images/xxx2.png annotations/xxx2.png
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-background
-labelA
-labelB
-...
-```
-标注图像为单通道图像，像素值即为对应的类别,像素标注类别需要从0开始递增（一般第一个类别为`background`），
-例如0，1，2，3表示有4种类别，标注类别最多为256类。其中可以指定特定的像素值用于表示该值的像素不参与训练和评估（默认为255）。
-[点击这里](https://bj.bcebos.com/paddlex/datasets/optic_disc_seg.tar.gz)，下载视盘语义分割数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.SegReader`([API说明](../apis/datasets/semantic_segmentation.html#segdataset))加载语义分割数据集。
-## 图像分类EasyDataCls
-图像分类EasyDataCls数据集包含存放图像和json文件的文件夹、标签文件及图像列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录
-|--easydata  # 存放图像和json文件的文件夹
-|  |--0001.jpg
-|  |--0001.json
-|  |--0002.jpg
-|  |--0002.json
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表文件
-```
-其中，图像文件名应与json文件名一一对应。   
-每个json文件存储于`labels`相关的信息。如下所示：
-```
-{"labels": [{"name": "labelA"}]}
-```
-其中，`name`字段代表对应图像的类别。  
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为json文件相对于dataset的相对路径。如下所示：
-```
-easydata/0001.jpg easydata/0001.json
-easydata/0002.jpg easydata/0002.json
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-labelA
-labelB
-...
-```
-[点击这里](https://ai.baidu.com/easydata/)，可以标注图像分类EasyDataCls数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.EasyDataCls`([API说明](../apis/datasets/classification.html#easydatacls))加载分类数据集。
-## 目标检测和实例分割EasyDataDet
-目标检测和实例分割EasyDataDet数据集包含存放图像和json文件的文件夹、标签文件及图像列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录ß
-|--easydata  # 存放图像和json文件的文件夹
-|  |--0001.jpg
-|  |--0001.json
-|  |--0002.jpg
-|  |--0002.json
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表文件
-```
-其中，图像文件名应与json文件名一一对应。   
-每个json文件存储于`labels`相关的信息。如下所示：
-```
-"labels": [{"y1": 18, "x2": 883, "x1": 371, "y2": 404, "name": "labelA", 
-            "mask": "kVfc0`0Zg0<F7J7I5L5K4L4L4L3N3L3N3L3N2N3M2N2N2N2N2N2N1O2N2O1N2N1O2O1N101N1O2O1N101N10001N101N10001N10001O0O10001O000O100000001O0000000000000000000000O1000001O00000O101O000O101O0O101O0O2O0O101O0O2O0O2N2O0O2O0O2N2O1N1O2N2N2O1N2N2N2N2N2N2M3N3M2M4M2M4M3L4L4L4K6K5J7H9E\\iY1"}, 
-           {"y1": 314, "x2": 666, "x1": 227, "y2": 676, "name": "labelB",
-            "mask": "mdQ8g0Tg0:G8I6K5J5L4L4L4L4M2M4M2M4M2N2N2N3L3N2N2N2N2O1N1O2N2N2O1N1O2N2O0O2O1N1O2O0O2O0O2O001N100O2O000O2O000O2O00000O2O000000001N100000000000000000000000000000000001O0O100000001O0O10001N10001O0O101N10001N101N101N101N101N2O0O2N2O0O2N2N2O0O2N2N2N2N2N2N2N2N2N3L3N2N3L3N3L4M2M4L4L5J5L5J7H8H;BUcd<"}, 
-           ...]}
-```
-其中，list中的每个元素代表一个标注信息，标注信息中字段的含义如下所示： 
-| 字段名 | 含义 | 数据类型 | 备注 |
-|:--------|:------------|------|:-----|
-| x1 | 标注框左下角横坐标 | int | |
-| y1 | 标注框左下角纵坐标 | int | |
-| x2 | 标注框右上角横坐标 | int | |
-| y2 | 标注框右上角纵坐标 | int | |
-| name | 标注框中物体类标 | str | |
-| mask | 分割区域布尔型numpy编码后的字符串 | str | 该字段可以不存在，当不存在时只能进行目标检测 |
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为json文件相对于dataset的相对路径。如下所示：
-```
-easydata/0001.jpg easydata/0001.json
-easydata/0002.jpg easydata/0002.json
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-labelA
-labelB
-...
-```
-[点击这里](https://ai.baidu.com/easydata/)，可以标注图像分类EasyDataDet数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.EasyDataDet`([API说明](../apis/datasets/detection.html#easydatadet))加载分类数据集。
-## 语义分割EasyDataSeg
-语义分割EasyDataSeg数据集包含存放图像和json文件的文件夹、标签文件及图像列表文件。
-参考数据文件结构如下：
-```
-./dataset/  # 数据集根目录ß
-|--easydata  # 存放图像和json文件的文件夹
-|  |--0001.jpg
-|  |--0001.json
-|  |--0002.jpg
-|  |--0002.json
-|  └--...
-|
-|--train_list.txt  # 训练文件列表文件
-|
-|--val_list.txt  # 验证文件列表文件
-|
-└--labels.txt  # 标签列表文件
-```
-其中，图像文件名应与json文件名一一对应。   
-每个json文件存储于`labels`相关的信息。如下所示：
-```
-"labels": [{"y1": 18, "x2": 883, "x1": 371, "y2": 404, "name": "labelA", 
-            "mask": "kVfc0`0Zg0<F7J7I5L5K4L4L4L3N3L3N3L3N2N3M2N2N2N2N2N2N1O2N2O1N2N1O2O1N101N1O2O1N101N10001N101N10001N10001O0O10001O000O100000001O0000000000000000000000O1000001O00000O101O000O101O0O101O0O2O0O101O0O2O0O2N2O0O2O0O2N2O1N1O2N2N2O1N2N2N2N2N2N2M3N3M2M4M2M4M3L4L4L4K6K5J7H9E\\iY1"}, 
-           {"y1": 314, "x2": 666, "x1": 227, "y2": 676, "name": "labelB",
-            "mask": "mdQ8g0Tg0:G8I6K5J5L4L4L4L4M2M4M2M4M2N2N2N3L3N2N2N2N2O1N1O2N2N2O1N1O2N2O0O2O1N1O2O0O2O0O2O001N100O2O000O2O000O2O00000O2O000000001N100000000000000000000000000000000001O0O100000001O0O10001N10001O0O101N10001N101N101N101N101N2O0O2N2O0O2N2N2O0O2N2N2N2N2N2N2N2N2N3L3N2N3L3N3L4M2M4L4L5J5L5J7H8H;BUcd<"}, 
-           ...]}
-```
-其中，list中的每个元素代表一个标注信息，标注信息中字段的含义如下所示： 
-| 字段名 | 含义 | 数据类型 | 备注 |
-|:--------|:------------|------|:-----|
-| x1 | 标注框左下角横坐标 | int | |
-| y1 | 标注框左下角纵坐标 | int | |
-| x2 | 标注框右上角横坐标 | int | |
-| y2 | 标注框右上角纵坐标 | int | |
-| name | 标注框中物体类标 | str | |
-| mask | 分割区域布尔型numpy编码后的字符串 | str | 该字段必须存在 |
-`train_list.txt`和`val_list.txt`文本以空格为分割符分为两列，第一列为图像文件相对于dataset的相对路径，第二列为json文件相对于dataset的相对路径。如下所示：
-```
-easydata/0001.jpg easydata/0001.json
-easydata/0002.jpg easydata/0002.json
-...
-```
-`labels.txt`: 每一行为一个单独的类别，相应的行号即为类别对应的id（行号从0开始)，如下所示：
-```
-labelA
-labelB
-...
-```
-[点击这里](https://ai.baidu.com/easydata/)，可以标注图像分类EasyDataSeg数据集。  
-在PaddleX中，使用`paddlex.cv.datasets.EasyDataSeg`([API说明](../apis/datasets/semantic_segmentation.html#easydataseg))加载分类数据集。
--- a/docs/appendix/how_to_convert_dataset.md
+++ b/docs/appendix/how_to_convert_dataset.md
-# 数据集转换
-当前PaddleX GUI支持ImageNet格式的图像分类数据集、VOC格式的目标检测数据集、COCO格式的实例分割数据集、Seg格式的语义分割的数据集，当使用LabelMe、EasyData、标注精灵这3个工具标注数据时，PaddleX提供了相应接口可将数据转换成与PaddleX GUI想适配的数据集，使用方式如下所示：
-```python
-import paddlex as pdx
-# 该接口实现LabelMe数据集到VOC数据集的转换。
-# image_dir为图像文件存放的路径。
-# json_dir为与每张图像对应的json文件的存放路径。
-# dataset_save_dir为转换后数据集存放路径。
-pdx.tools.labelme2voc(image_dir='labelme_imgs',
-                      json_dir='labelme_jsons',
-                      dataset_save_dir='voc_dataset')
-```
-可替换labelme2voc实现不同数据集间的转换，目前提供的转换接口如下：  
-| 接口      | 转换关系 |
-| :-------- | :------- |
-| labelme2voc  | LabelMe数据集转换为VOC数据集   |
-| labelme2coco  | LabelMe数据集转换为COCO数据集   |
-| labelme2seg  | LabelMe数据集转换为Seg数据集  |
-| easydata2imagenet | EasyData数据集转换为ImageNet数据集  |
-| easydata2voc | EasyData数据集转换为VOC数据集  |
-| easydata2coco | EasyData数据集转换为COCO数据集  |
-| easydata2seg | EasyData数据集转换为Seg数据集  |
-| jingling2seg | 标注精灵数据集转换为Seg数据集  |
\ No newline at end of file
--- a/docs/appendix/images/anaconda_windows.png
+++ b/docs/appendix/images/anaconda_windows.png
--- a/docs/appendix/images/cls_eval.png
+++ b/docs/appendix/images/cls_eval.png
--- a/docs/appendix/images/cls_train.png
+++ b/docs/appendix/images/cls_train.png
--- a/docs/appendix/images/faster_eval.png
+++ b/docs/appendix/images/faster_eval.png
--- a/docs/appendix/images/faster_train.png
+++ b/docs/appendix/images/faster_train.png
--- a/docs/appendix/images/lime.png
+++ b/docs/appendix/images/lime.png
--- a/docs/appendix/images/mask_eval.png
+++ b/docs/appendix/images/mask_eval.png
--- a/docs/appendix/images/mask_train.png
+++ b/docs/appendix/images/mask_train.png
--- a/docs/appendix/images/normlime.png
+++ b/docs/appendix/images/normlime.png
--- a/docs/appendix/images/seg_eval.png
+++ b/docs/appendix/images/seg_eval.png
--- a/docs/appendix/images/seg_train.png
+++ b/docs/appendix/images/seg_train.png
--- a/docs/appendix/images/voc_eval.png
+++ b/docs/appendix/images/voc_eval.png
--- a/docs/appendix/images/yolo_train.png
+++ b/docs/appendix/images/yolo_train.png
--- a/docs/appendix/index.rst
+++ b/docs/appendix/index.rst
@@ -11,6 +11,4 @@
   metrics.md
   interpret.md
   parameters.md
-   how_to_convert_dataset.md
-   datasets.md
--- a/docs/appendix/interpret.md
+++ b/docs/appendix/interpret.md
@@ -13,7 +13,7 @@ LIME全称Local interpretable model-agnostic explanations，表示一种与模
 LIME的使用方式可参见[代码示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/interpret/lime.py)和[api介绍](../apis/visualize.html#lime)。在使用时，参数中的`num_samples`设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数`batch_size`则表示在计算上述步骤3时，预测的batch size，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定。  
 最终LIME可解释性算法的可视化结果如下所示：  
-![](../images/lime.png)  
+![](images/lime.png)  
 图中绿色区域代表起正向作用的超像素，红色区域代表起反向作用的超像素，"First n superpixels"代表前n个权重比较大的超像素（由上述步骤5计算所得结果）。
@@ -31,12 +31,12 @@ NormLIME是在LIME上的改进，LIME的解释是局部性的，是针对当前
        预测的`label`为输出，构建逻辑回归函数`regression_func`。  
    (2) 由`regression_func`可获得每个聚类中心不同类别下的权重，并对权重进行归一化。  
 3. 使用Kmeans模型获取需要可视化图像的每个超像素的聚类中心。  
-4. 对需要可视化的图像的超像素进行随机遮掩构成新的图像。   
+4. 对需要可视化的图像的超像素进行随机遮掩构成新的图像。  
 5. 对每张构造的图像使用预测模型预测label。  
-6. 根据normlime的权重信息，每个超像素可获不同的权重，选取最高的权重为最终的权重，以此来解释模型。   
+6. 根据normlime的权重信息，每个超像素可获不同的权重，选取最高的权重为最终的权重，以此来解释模型。  
 NormLIME的使用方式可参见[代码示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/interpret/normlime.py)和[api介绍](../apis/visualize.html#normlime)。在使用时，参数中的`num_samples`设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数`batch_size`则表示在计算上述步骤3时，预测的batch size，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定；而`dataset`则是由测试集或验证集构造的数据。  
 最终NormLIME可解释性算法的可视化结果如下所示：  
-![](../images/normlime.png)  
+![](images/normlime.png)  
 图中绿色区域代表起正向作用的超像素，红色区域代表起反向作用的超像素，"First n superpixels"代表前n个权重比较大的超像素（由上述步骤5计算所得结果）。图中最后一行代表把LIME和NormLIME对应超像素权重相乘的结果。
\ No newline at end of file
--- a/docs/appendix/metrics.md
+++ b/docs/appendix/metrics.md
@@ -6,7 +6,7 @@ PaddleX在模型训练、评估过程中，都会有相应的日志和指标反
 PaddleX所有模型在训练过程中，输出的日志信息都包含了6个通用的统计信息，用于辅助用户进行模型训练，例如**分割模型**的训练日志，如下图所示。
-![](../images/seg_train.png)
+![](images/seg_train.png)
 各字段含义如下:
@@ -26,7 +26,7 @@ PaddleX所有模型在训练过程中，输出的日志信息都包含了6个通
 PaddleX所有模型在训练过程中会根据用户设定的`save_interval_epochs`参数，每间隔一定轮数进行评估和保存。例如**分类模型**的评估日志，如下图所示。
-![](../images/cls_eval.png)
+![](images/cls_eval.png)
 上图中第1行表明验证数据集中样本数为240，需要迭代8步才能评估完所有验证数据；第5行用于表明第2轮的模型已经完成保存操作；第6行则表明当前保存的模型中，第2轮的模型在验证集上指标最优（分类任务看`acc1`，此时`acc1`值为0.258333），最优模型会保存在`best_model`目录中。
@@ -38,7 +38,7 @@ PaddleX所有模型在训练过程中会根据用户设定的`save_interval_epoc
 > 注： acck准确率是针对一张图片进行计算的：把模型在各个类别上的预测得分按从高往低进行排序，取出前k个预测类别，若这k个预测类别包含了真值类，则认为该图片分类正确。
-![](../images/cls_train.png)
+![](images/cls_train.png)
 上图中第1行中的`acc1`表示参与当前迭代步数的训练样本的平均top1准确率，值越高代表模型越优；`acc5`表示参与当前迭代步数的训练样本的平均top5（若类别数n少于5，则为topn）准确率，值越高代表模型越优。第4行中的`loss`表示整个训练集的平均损失函数值，`acc1`表示整个训练集的平均top1准确率，`acc5`表示整个训练集的平均top5准确率。
@@ -46,7 +46,7 @@ PaddleX所有模型在训练过程中会根据用户设定的`save_interval_epoc
 ### 评估日志字段
-![](../images/cls_eval.png)
+![](images/cls_eval.png)
 上图中第3行中的`acc1`表示整个验证集的平均top1准确率，`acc5`表示整个验证集的平均top5准确率。
@@ -59,7 +59,7 @@ PaddleX所有模型在训练过程中会根据用户设定的`save_interval_epoc
 YOLOv3的训练日志只包括训练通用统计信息（见上文训练通用统计信息）。
-![](../images/yolo_train.png)
+![](images/yolo_train.png)
 上图中第5行`loss`表示整个训练集的平均损失函数loss值。
@@ -75,7 +75,7 @@ FasterRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`lo
 | loss_rpn_bbox      | RPN子网络中检测框回归损失函数值  |
 | loss              | 所有子网络损失函数值之和          |
-![](../images/faster_train.png)
+![](images/faster_train.png)
 上图中第1行`loss`, `loss_cls`、`loss_bbox`、`loss_rpn_clss`、`loss_rpn_bbox`都是参与当前迭代步数的训练样本的损失值，而第7行是针整个训练集的损失函数值。
@@ -93,7 +93,7 @@ MaskRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`loss
 | loss_rpn_bbox      | RPN子网络中检测框回归损失函数值  |
 | loss              | 所有子网络损失函数值之和          |
-![](../images/mask_train.png)
+![](images/mask_train.png)
 上图中第1行`loss`, `loss_cls`、`loss_bbox`、`loss_mask`、`loss_rpn_clss`、`loss_rpn_bbox`都是参与当前迭代步数的训练样本的损失值，而第7行是针整个训练集的损失函数值。
@@ -103,7 +103,7 @@ MaskRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`loss
 #### VOC评估标准
-![](../images/voc_eval.png)
+![](images/voc_eval.png)
 > 注：`map`为平均准确率的平均值，即IoU(Intersection Over Union)取0.5时各个类别的准确率-召回率曲线下面积的平均值。
@@ -115,11 +115,11 @@ MaskRCNN的训练日志除了通用统计信息外，还包括`loss_cls`、`loss
 COCO格式的数据集不仅可以用于训练目标检测模型，也可以用于训练实例分割模型。在目标检测中，PaddleX主要反馈针对检测框的`bbox_mmAP`指标；在实例分割中，还包括针对Mask的`seg_mmAP`指标。如下所示，第一张日志截图为目标检测的评估结果，第二张日志截图为实例分割的评估结果。
-![](../images/faster_eval.png)
+![](images/faster_eval.png)
 上图中红框标注的`bbox_mmap`表示整个验证集的检测框平均准确率平均值。
-![](../images/mask_eval.png)
+![](images/mask_eval.png)
 上图中红框标注的`bbox_mmap`和`seg_mmap`分别表示整个验证集的检测框平均准确率平均值、Mask平均准确率平均值。
 ## 分割特有统计信息
@@ -128,7 +128,7 @@ COCO格式的数据集不仅可以用于训练目标检测模型，也可以用
 语义分割的训练日志只包括训练通用统计信息（见上文训练通用统计信息）。
-![](../images/seg_train.png)
+![](images/seg_train.png)
 ### 评估日志字段
@@ -142,4 +142,4 @@ COCO格式的数据集不仅可以用于训练目标检测模型，也可以用
 | category_acc       | 各类别的准确率，即各类别预测正确的像素数/预测为该类别的总像素数  |
 | kappa      | kappa系数，用于一致性检验  |
-![](../images/seg_eval.png)
+![](images/seg_eval.png)
--- a/docs/appendix/parameters.md
+++ b/docs/appendix/parameters.md
@@ -23,7 +23,7 @@ Epoch数是模型训练过程，迭代的轮数，用户可以设置较大的数
 `lr_decay_epochs`用于让学习率在模型训练后期逐步衰减，它一般是一个list，如[6, 8, 10]，表示学习率在第6个epoch时衰减一次，第8个epoch时再衰减一次，第10个epoch时再衰减一次。每次学习率衰减为之前的学习率*lr_decay_gamma。
-> 例如YOLOv3的train接口，默认`num_epochs`为270,`learning_rate`为0.000125， `lr_decay_epochs`为[213, 240]，`lr_decay_gamma`为0.1;在此参数配置下表示，模型在启动训练后，在前213个epoch中，训练时使用的学习率为0.000125，在第213至240个epoch之间，训练使用的学习率为0.000125*0.1，在240个epoch之后，使用的学习率为0.000125*0.1*0.1
+> 例如YOLOv3的train接口，默认`num_epochs`为270,`learning_rate`为0.000125， `lr_decay_epochs`为[213, 240]，`lr_decay_gamma`为0.1;在此参数配置下表示，模型在启动训练后，在前213个epoch中，训练时使用的学习率为0.000125，在第213至240个epoch之间，训练使用的学习率为0.000125x0.1=0.0000125，在240个epoch之后，使用的学习率为0.000125x0.1x0.1=0.00000125
 ## 5.参数设定时的约束
 根据上述几个参数，可以了解到学习率的变化分为WarmUp热身阶段和Decay衰减阶段，

--- a/docs/change_log.md
+++ b/docs/change_log.md
 # 更新日志
-**v1.1.0** 2020.07.10
+**v1.1.0** 2020.07.12
 - 模型更新
 > - 新增语义分割模型HRNet、FastSCNN

--- a/docs/conf.py
+++ b/docs/conf.py
@@ -76,5 +76,4 @@ if not on_rtd:  # only import and set the theme if we're building docs locally
 html_static_path = ['_static']
-html_logo = 'images/paddlex.jpg'
+html_logo = 'paddlex.png'
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -17,5 +17,4 @@ PaddleX是基于飞桨核心框架、开发套件和工具组件的深度学习
   gui/index
   apis/index
   change_log.md
-   FAQ.md
   appendix/index
--- a/docs/install.md
+++ b/docs/install.md
@@ -2,12 +2,7 @@
 以下安装过程默认用户已安装好**paddlepaddle-gpu或paddlepaddle(版本大于或等于1.8.1)**，paddlepaddle安装方式参照[飞桨官网](https://www.paddlepaddle.org.cn/install/quick)
- <a href="#pip安装">pip安装PaddleX</a>  
+## pip安装
- <a href="#github代码安装">github代码安装PaddleX</a>
- <a href="#pycocotools安装问题">pycocotools安装问题</a>
-<a name="pip安装"></a>
-**安装方式一 pip安装**
 > 注意其中pycocotools在Windows安装较为特殊，可参考下面的Windows安装命令  
@@ -15,8 +10,11 @@
 pip install paddlex -i https://mirror.baidu.com/pypi/simple
 ```
-<a name="github代码安装"></a>
+## Anaconda安装
-**安装方式二 Github代码安装**  
+Anaconda是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。使用Anaconda可以通过创建多个独立的Python环境，避免用户的Python环境安装太多不同版本依赖导致冲突。  
+- 参考[Anaconda安装PaddleX文档](appendix/anaconda_install.md)
+## 代码安装
 github代码会跟随开发进度不断更新
@@ -28,8 +26,8 @@ python setup.py install
 ```
-<a name="pycocotools安装问题"></a>
+## pycocotools安装问题
-**pycocotools安装问题**  
 > PaddleX依赖pycocotools包，如安装pycocotools失败，可参照如下方式安装pycocotools
 > Windows安装时可能会提示缺少`Microsoft Visual C++ 2015 build tools`，[点击下载VC build tools](https://go.microsoft.com/fwlink/?LinkId=691126)安装再执行如下pip命令

--- a/docs/paddlex.png
+++ b/docs/paddlex.png
--- a/docs/quick_start.md
+++ b/docs/quick_start.md
@@ -2,11 +2,21 @@
 本文档在一个小数据集上展示了如何通过PaddleX进行训练，您可以阅读PaddleX的**使用教程**来了解更多模型任务的训练使用方式。本示例同步在AIStudio上，可直接[在线体验模型训练](https://aistudio.baidu.com/aistudio/projectdetail/439860)
-PaddleX的模型训练都分为以下几个步骤
+PaddleX中的所有模型训练跟随以下3个步骤，即可快速完成训练代码开发！
-> 1.<a href="#定义训练验证图像处理流程transforms">定义训练/验证图像处理流程transforms</a>  
-> 2.<a href="#定义dataset加载图像分类数据集">定义dataset加载数据集</a>  
+| 步骤 |                  |说明             |
-> 3.<a href="#使用MoibleNetV3_small_ssld模型开始训练">定义模型开始训练</a>  
+| :--- | :--------------- | :-------------- |
-> 4.<a href="#加载训练保存的模型预测">加载训练保存的模型进行预测</a>  
+| 第1步| <a href=#定义训练验证图像处理流程transforms>定义transforms</a>  | 用于定义模型训练、验证、预测过程中，<br>输入图像的预处理和数据增强操作 |
+| 第2步| <a href="#定义dataset加载图像分类数据集">定义datasets</a>  | 用于定义模型要加载的训练、验证数据集 |
+| 第3步| <a href="#使用MoibleNetV3_small_ssld模型开始训练">定义模型开始训练</a> | 选择需要的模型，进行训练 |
+> **注意**：不同模型的transforms、datasets和训练参数都有较大差异，更多模型训练，可直接根据文档教程获取更多模型的训练代码。[模型训练教程](train/index.html)
+PaddleX的其它用法
+- <a href="#加载训练保存的模型预测">加载训练保存的模型进行预测</a>
+- [使用VisualDL查看训练过程中的指标变化]()
 <a name="安装PaddleX"></a>
 **1. 安装PaddleX**  

--- a/docs/train/classification.md
+++ b/docs/train/classification.md
 # 图像分类
-PaddleX共提供了20+的图像分类模型，包括基于大规模数据训练的
+## 介绍
-点击表格中模型名，可获取各模型训练的教程代码
+PaddleX共提供了20+的图像分类模型，可满足开发者不同场景的需求下的使用。
-| 模型               | Top1精度 | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
+- **Top1精度**: 模型在ImageNet数据集上的测试精度
-| :----------------  | :------- | :------- | :---------  | :---------  |     |
+- **预测速度**：单张图片的预测用时（不包括预处理和后处理)
-| MobileNetV3_small_ssld |    |    |     |   |     |
+- "-"表示指标暂未更新
-| MobileNetV2        |   |    |    |   |     |
-| ShuffleNetV2     |   |    |    |   |     |
-| AlexNet |    |      |      |    |     |
-| ResNet50_vd_ssld   |  97.5%   |   22M    | 10ms        |   200ms     |    |
-更多图像分类模型，可查阅PaddleX模型库和API使用文档。
+| 模型(点击获取代码)               | Top1精度 | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
+| :----------------  | :------- | :------- | :---------  | :---------  | :-----    |
+| [MobileNetV3_small_ssld](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/mobilenetv3_small_ssld.py) |  71.3%  |  21.0MB  |  6.809ms   | -  |  模型小，预测速度快，适用于低性能或移动端设备   |
+| [MobileNetV2](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/mobilenetv2.py)        | 72.2%  | 14.0MB   |  4.546ms  | -  |  模型小，预测速度快，适用于低性能或移动端设备   |
+| [ShuffleNetV2](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/shufflenetv2.py)     | 68.8%  | 9.0MB   | 6.101ms   | -  |  模型体积小，预测速度快，适用于低性能或移动端设备   |
+| [ResNet50_vd_ssld](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/resnet50_vd_ssld.py)   |  82.4%   |   102.8MB    |  9.058ms       |   -    | 模型精度高，适用于服务端部署   |
-在选取分类模型时，一般模型大小越大，表示模型的拟合能力越强，但并非越大训练效果越佳。需要用户根据自己的数据集来评估，一般数据样本较少时，MobileNetV3_small_ssld已经可以满足大部分需求。
+## 开始训练
+> 代码保存到本地后，即可直接训练，**训练代码会自动下载训练数据开始训练**
+> > 如保存为`mobilenetv3_small_ssld.py`，如下命令即可开始训练
+> > ```
+> > python mobilenetv3_small_ssld.py
+> > ```
-点击上述表格模型名，将对应模型的训练代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练，如保存为`mobilenetv3_small_ssld.py`，如下命令即可开始训练
-```
-python mobilenetv3_small_ssld.py
-```
- 针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数。[——>>传送门]()
+## 相关文档
- 没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门]()
+- 【**重要**】针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数作用。[——>>传送门](../appendix/parameters.md)
+- 【**有用**】没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门](https://aistudio.baidu.com/aistudio/projectdetail/450925)
+- 【**拓展**】更多图像分类模型，查阅[PaddleX模型库](../appendix/model_zoo.md)和[API使用文档](../apis/models/index.html)。
--- a/docs/train/instance_segmentation.md
+++ b/docs/train/instance_segmentation.md
 # 实例分割
-| 模型               | Top1精度 | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
+## 介绍
-| :----------------  | :------- | :------- | :---------  | :---------  |     |
-| MaskRCNN-ResNet50-FPN   |  97.5%   |   22M    | 10ms        |   200ms     |    |
+PaddleX目前提供了MaskRCNN实例分割模型结构,多种backbone模型，可满足开发者不同场景和性能的需求。
-| MaskRCNN-ResNet101-FPN  |   |    |       |     |     |
-| MaskRCNN-HRNet-FPN |    |    |     |   |     |
+- **Box MMAP/Seg MMAP**: 模型在COCO数据集上的测试精度
+- **预测速度**：单张图片的预测用时（不包括预处理和后处理)
-将对应模型的训练代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练，如保存为`mask_r50_fpn.py`，如下命令即可开始训练
+- "-"表示指标暂未更新
-```
-python mask_r50_fpn.py
+| 模型(点击获取代码)               | Box MMAP/Seg MMAP | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
-```
+| :----------------  | :------- | :------- | :---------  | :---------  | :-----    |
+| [MaskRCNN-ResNet50-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/instance_segmentation/mask_r50_fpn.py)   |  -/-   |   136.0MB    |  197.715ms       |   -    | 模型精度高，适用于服务端部署   |
- 针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数。[——>>传送门]()
+| [MaskRCNN-ResNet18-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/instance_segmentation/mask_r18_fpn.py)   |  -/-   |   -    |  -       |   -    | 模型精度高，适用于服务端部署   |
- 没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门]()
+| [MaskRCNN-HRNet-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/instance_segmentation/mask_hrnet_fpn.py)   |  -/-   |   115.MB    |  81.592ms       |   -    | 模型精度高，预测速度快，适用于服务端部署   |
+## 开始训练
+> 代码保存到本地后，即可直接训练，**训练代码会自动下载训练数据开始训练**
+> > 如保存为`mask_r50_fpn.py`，如下命令即可开始训练
+> > ```
+> > python mask_r50_fpn.py
+> > ```
+## 相关文档
+- 【**重要**】针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数作用。[——>>传送门](../appendix/parameters.md)
+- 【**有用**】没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门](https://aistudio.baidu.com/aistudio/projectdetail/450925)
+- 【**拓展**】更多图像分类模型，查阅[PaddleX模型库](../appendix/model_zoo.md)和[API使用文档](../apis/models/index.html)。
--- a/docs/train/object_detection.md
+++ b/docs/train/object_detection.md
 # 目标检测
-| 模型               | Top1精度 | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
+## 介绍
-| :----------------  | :------- | :------- | :---------  | :---------  |     |
-| YOLOv3-MobileNetV1   |  97.5%   |   22M    | 10ms        |   200ms     |    |
+PaddleX目前提供了FasterRCNN和YOLOv3两种检测结构,多种backbone模型，可满足开发者不同场景和性能的需求。
-| YOLOv3-MobileNetV3  |   |    |       |     |     |
-| YOLOv3-DarkNet53 |    |    |     |   |     |
+- **Box MMAP**: 模型在COCO数据集上的测试精度
-| FasterRCNN-ResNet50-FPN |    |   |     |   |    |
+- **预测速度**：单张图片的预测用时（不包括预处理和后处理)
-| FasterRCNN-ResNet101-FPN        |   |    |    |   |     |
+- "-"表示指标暂未更新
-| FasterRCNN-HRNet-FPN     |   |    |    |   |     |
+| 模型(点击获取代码)               | Box MMAP | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
-将对应模型的训练代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练，如保存为`faster_r50_fpn.py`，如下命令即可开始训练
+| :----------------  | :------- | :------- | :---------  | :---------  | :-----    |
-```
+| [YOLOv3-MobileNetV1](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_mobilenetv1.py) |  29.3%  |  99.2MB  |  15.442ms   | -  |  模型小，预测速度快，适用于低性能或移动端设备   |
-python faster_r50_fpn.py
+| [YOLOv3-MobileNetV3](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_mobilenetv3.py)        | 31.6%  | 100.7MB   |  143.322ms  | -  |  模型小，移动端上预测速度有优势   |
-```
+| [YOLOv3-DarkNet53](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_darknet53.py)     | 38.9  | 249.2MB   | 42.672ms   | -  |  模型较大，预测速度快，适用于服务端   |
+| [FasterRCNN-ResNet50-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/faster_r50_fpn.py)   |  37.2%   |   136.0MB    |  197.715ms       |   -    | 模型精度高，适用于服务端部署   |
- 针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数。[——>>传送门]()
+| [FasterRCNN-ResNet18-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/faster_r18_fpn.py)   |  -   |   -    |  -       |   -    | 模型精度高，适用于服务端部署   |
- 没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门]()
+| [FasterRCNN-HRNet-FPN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/faster_hrnet_fpn.py)   |  36.0%   |   115.MB    |  81.592ms       |   -    | 模型精度高，预测速度快，适用于服务端部署   |
+## 开始训练
+> 代码保存到本地后，即可直接训练，**训练代码会自动下载训练数据开始训练**
+> > 如保存为`yolov3_mobilenetv1.py`，如下命令即可开始训练
+> > ```
+> > python yolov3_mobilenetv1.py
+> > ```
+## 相关文档
+- 【**重要**】针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数作用。[——>>传送门](../appendix/parameters.md)
+- 【**有用**】没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门](https://aistudio.baidu.com/aistudio/projectdetail/450925)
+- 【**拓展**】更多图像分类模型，查阅[PaddleX模型库](../appendix/model_zoo.md)和[API使用文档](../apis/models/index.html)。
--- a/docs/train/semantic_segmentation.md
+++ b/docs/train/semantic_segmentation.md
 # 语义分割
-| 模型               | Top1精度 | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
+## 介绍
-| :----------------  | :------- | :------- | :---------  | :---------  |     |
-| DeepLabv3p-MobileNetV2   |  97.5%   |   22M    | 10ms        |   200ms     |    |
+PaddleX目前提供了DeepLabv3p、UNet、HRNet和FastSCNN四种语义分割结构,多种backbone模型，可满足开发者不同场景和性能的需求。
-| DeepLabv3p-Xception65  |   |    |       |     |     |
-| UNet |    |    |     |   |     |
+- **mIOU**: 模型在COCO数据集上的测试精度
-| HRNet |   |    |     |   |     |
+- **预测速度**：单张图片的预测用时（不包括预处理和后处理)
-| FastSCNN |  |   |    |    |    |
+- "-"表示指标暂未更新
-将对应模型的训练代码保存到本地后，即可直接训练，训练代码会自动下载训练数据开始训练，如保存为`deeplab_mobilenetv2.py`，如下命令即可开始训练
+| 模型(点击获取代码)               | Box MMAP | 模型大小 | GPU预测速度 | Arm预测速度 | 备注 |
-```
+| :----------------  | :------- | :------- | :---------  | :---------  | :-----    |
-python deeplab_mobilenetv2.py
+| [DeepLabv3p-MobileNetV2-x0.25](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_mobilenetv1.py) |  29.3%  |  99.2MB  |  15.442ms   | -  |  模型小，预测速度快，适用于低性能或移动端设备   |
-```
+| [DeepLabv3p-MobileNetV2-x1.0](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_mobilenetv1.py) |  29.3%  |  99.2MB  |  15.442ms   | -  |  模型小，预测速度快，适用于低性能或移动端设备   |
+| [DeepLabv3p-Xception65](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_mobilenetv3.py)        | 31.6%  | 100.7MB   |  143.322ms  | -  |  模型小，移动端上预测速度有优势   |
- 针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数。[——>>传送门]()
+| [UNet](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/yolov3_darknet53.py)     | 38.9  | 249.2MB   | 42.672ms   | -  |  模型较大，预测速度快，适用于服务端   |
- 没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门]()
+| [HRNet](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/faster_r50_fpn.py)   |  37.2%   |   136.0MB    |  197.715ms       |   -    | 模型精度高，适用于服务端部署   |
+| [FastSCNN](https://github.com/PaddlePaddle/PaddleX/blob/doc/tutorials/train/image_classification/faster_r18_fpn.py)   |  -   |   -    |  -       |   -    | 模型精度高，适用于服务端部署   |
+## 开始训练
+> 代码保存到本地后，即可直接训练，**训练代码会自动下载训练数据开始训练**
+> > 如保存为`deeplabv3p_mobilenetv2_x0.25.py`，如下命令即可开始训练
+> > ```
+> > python deeplabv3p_mobilenetv2_x0.25.py
+> > ```
+## 相关文档
+- 【**重要**】针对自己的机器环境和数据，调整训练参数？先了解下PaddleX中训练参数作用。[——>>传送门](../appendix/parameters.md)
+- 【**有用**】没有机器资源？使用AIStudio免费的GPU资源在线训练模型。[——>>传送门](https://aistudio.baidu.com/aistudio/projectdetail/450925)
+- 【**拓展**】更多图像分类模型，查阅[PaddleX模型库](../appendix/model_zoo.md)和[API使用文档](../apis/models/index.html)。
--- a/paddlex/cv/models/utils/visualize.py
+++ b/paddlex/cv/models/utils/visualize.py
 # copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-# 
+#
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -28,7 +28,7 @@ def visualize_detection(image, result, threshold=0.5, save_dir='./'):
    """
    if isinstance(image, np.ndarray):
-        image_name = str(int(time.time())) + '.jpg'
+        image_name = str(int(time.time() * 1000)) + '.jpg'
    else:
        image_name = os.path.split(image)[-1]
        image = cv2.imread(image)
@@ -64,7 +64,7 @@ def visualize_segmentation(image, result, weight=0.6, save_dir='./'):
    if isinstance(image, np.ndarray):
        im = image
-        image_name = str(int(time.time())) + '.jpg'
+        image_name = str(int(time.time() * 1000)) + '.jpg'
    else:
        image_name = os.path.split(image)[-1]
        im = cv2.imread(image)
@@ -145,8 +145,8 @@ def draw_bbox_mask(image, results, threshold=0.5):
        assert brightness_factor >= -1.0 and brightness_factor <= 1.0
        color = mplc.to_rgb(color)
        polygon_color = colorsys.rgb_to_hls(*mplc.to_rgb(color))
-        modified_lightness = polygon_color[1] + (
+        modified_lightness = polygon_color[1] + (brightness_factor *
-            brightness_factor * polygon_color[1])
+                                                 polygon_color[1])
        modified_lightness = 0.0 if modified_lightness < 0.0 else modified_lightness
        modified_lightness = 1.0 if modified_lightness > 1.0 else modified_lightness
        modified_color = colorsys.hls_to_rgb(
@@ -161,8 +161,7 @@ def draw_bbox_mask(image, results, threshold=0.5):
    dpi = fig.get_dpi()
    fig.set_size_inches(
        (width * scale + 1e-2) / dpi,
-        (height * scale + 1e-2) / dpi,
+        (height * scale + 1e-2) / dpi, )
-    )
    canvas = FigureCanvasAgg(fig)
    ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
    ax.axis("off")
@@ -208,8 +207,7 @@ def draw_bbox_mask(image, results, threshold=0.5):
                edgecolor=color,
                linewidth=linewidth * scale,
                alpha=0.8,
-                linestyle="-",
+                linestyle="-", ))
-            ))
        # draw mask
        if 'mask' in dt:
@@ -232,23 +230,22 @@ def draw_bbox_mask(image, results, threshold=0.5):
                        fill=True,
                        facecolor=mplc.to_rgb(color) + (alpha, ),
                        edgecolor=edge_color,
-                        linewidth=max(default_font_size // 15 * scale, 1),
+                        linewidth=max(default_font_size // 15 * scale, 1), )
-                    )
                    ax.add_patch(polygon)
        # draw label
        text_pos = (xmin, ymin)
        horiz_align = "left"
        instance_area = w * h
-        if (instance_area < _SMALL_OBJECT_AREA_THRESH * scale
+        if (instance_area < _SMALL_OBJECT_AREA_THRESH * scale or
-                or h < 40 * scale):
+                h < 40 * scale):
            if ymin >= height - 5:
                text_pos = (xmin, ymin)
            else:
                text_pos = (xmin, ymax)
        height_ratio = h / np.sqrt(height * width)
-        font_size = (np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2) * 0.5 *
+        font_size = (np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2,
-                     default_font_size)
+                             2) * 0.5 * default_font_size)
        text = "{} {:.2f}".format(cname, score)
        color = np.maximum(list(mplc.to_rgb(color)), 0.2)
        color[np.argmax(color)] = max(0.8, np.max(color))
@@ -269,8 +266,7 @@ def draw_bbox_mask(image, results, threshold=0.5):
            horizontalalignment=horiz_align,
            color=color,
            zorder=10,
-            rotation=0,
+            rotation=0, )
-        )
    s, (width, height) = canvas.print_to_buffer()
    buffer = np.frombuffer(s, dtype="uint8")
@@ -408,8 +404,8 @@ def draw_pr_curve(eval_details_file=None,
            plt.plot(x, sr_array, color=color, label=nm, linewidth=1)
        plt.legend(loc="lower left", fontsize=5)
        plt.savefig(
-            os.path.join(save_dir, "./{}_pr_curve(iou-{}).png".format(
+            os.path.join(save_dir,
-                style, iou_thresh)),
+                         "./{}_pr_curve(iou-{}).png".format(style, iou_thresh)),
            dpi=800)
        plt.close()