Merge branch 'develop' of https://github.com/PaddlePaddle/PaddleX into develop_jf

dygraph/README.md

@@ -1,4 +1,4 @@
-# PaddleX全面升级动态图，2.0.0-rc发布！
+# PaddleX全面升级动态图，2.0.0-rc1发布！
 
 
 
@@ -8,11 +8,14 @@
  <p align= "center"> PaddleX -- 飞桨全流程开发工具，以低代码的形式支持开发者快速实现产业实际项目落地 </p>
 
 ## :heart:重磅功能升级
-* 全新发布Manufacture SDK，提供工业级多端多平台部署加速的预编译飞桨部署开发包（SDK），通过配置业务逻辑流程文件即可以低代码方式快速完成推理部署[欢迎体验](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp/docs/manufacture_sdk)。
+### 全新发布Manufacture SDK，提供工业级多端多平台部署加速的预编译飞桨部署开发包（SDK），通过配置业务逻辑流程文件即可以低代码方式快速完成推理部署。[欢迎体验](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp/docs/manufacture_sdk)
 
-* PaddleX部署全面升级，支持飞桨视觉套件PaddleDetection、PaddleClas、PaddleSeg、PaddleX的统一部署能力。[欢迎体验](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp)。
+### PaddleX部署全面升级，支持飞桨视觉套件PaddleDetection、PaddleClas、PaddleSeg、PaddleX的端到端统一部署能力。[欢迎体验](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp)
 
 
+### 发布产业实践案例：钢筋计数、缺陷检测、机械手抓取、工业表计读数、Windows系统下使用C#语言部署。[欢迎体验](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/examples)
+
+### 升级PaddleX GUI，支持30系列显卡、新增模型PP-YOLO V2、PP-YOLO Tiny 、BiSeNetV2。[欢迎体验](https://github.com/FlyingQianMM/PaddleX/blob/develop_qh/dygraph/docs/install.md#2-padldex-gui%E5%BC%80%E5%8F%91%E6%A8%A1%E5%BC%8F%E5%AE%89%E8%A3%85)
 
 [![License](https://img.shields.io/badge/license-Apache%202-red.svg)](LICENSE) [![Version](https://img.shields.io/github/release/PaddlePaddle/PaddleX.svg)](https://github.com/PaddlePaddle/PaddleX/releases) ![python version](https://img.shields.io/badge/python-3.6+-orange.svg) ![support os](https://img.shields.io/badge/os-linux%2C%20win%2C%20mac-yellow.svg)
  ![QQGroup](https://img.shields.io/badge/QQ_Group-1045148026-52B6EF?style=social&logo=tencent-qq&logoColor=000&logoWidth=20)
@@ -21,85 +24,86 @@
 
 :factory: **PaddleX** 经过**质检**、**安防**、**巡检**、**遥感**、**零售**、**医疗**等十多个行业实际应用场景验证，沉淀产业实际经验，**并提供丰富的案例实践教程**，全程助力开发者产业实践落地。
 
-
-
-:heart: **您可以前往  [完整PaddleX在线使用文档目录](https://paddlex.readthedocs.io/zh_CN/develop/index.html)  查看完整*Read the Doc* 格式的文档，获得更好的阅读体验**:heart:
-
-
-
 ![](../docs/gui/images/paddlexoverview.png)
 
 
+## PaddleX 使用文档
 
-## 安装
 
-**PaddleX提供三种开发模式，满足用户的不同需求：**
+### 1. 快速上手PaddleX
 
-1. **Python开发模式：**
 
-   通过简洁易懂的Python API，在兼顾功能全面性、开发灵活性、集成方便性的基础上，给开发者最流畅的深度学习开发体验。<br>
+* [快速安装PaddleX](./docs/install.md)
+  * [PaddleX API开发模式安装](./docs/install.md#1-paddlex-api开发模式安装)
+  * [PadldeX GUI开发模式安装](./docs/install.md#2-padldex-gui开发模式安装)
+  * [PaddleX Restful开发模式安装](./docs/install.md#3-paddlex-restful开发模式安装)
+* [10分钟快速上手使用](./docs/quick_start.md)
 
-  **前置依赖**
-> - 安装PaddlePaddle Develop版本，具体方式请参考PaddlePaddle[安装主页](https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/develop/install/pip/windows-pip.html)
 
-**安装方式**
+### 2. 数据准备
 
-> - git clone --recurse-submodules https://github.com/PaddlePaddle/PaddleX.git
-> - cd PaddleX/dygraph
-> - pip install -r requirements.txt
-> - pip install -r submodules.txt
-> - python setup.py install
+* [数据格式说明](./docs/data/format/README.md)
+* [标注工具LabelMe的安装和启动](./docs/data/annotation/labelme.md)
+* [数据标注](./docs/data/annotation/README.md)
+  * [手机拍照图片旋转](./docs/data/annotation/README.md)
+  * [开始数据标注](./docs/data/annotation/README.md)
+* [数据格式转换](./docs/data/convert.md)
+* [数据划分](./docs/data/split.md)
 
 
-**特别说明**   Windows除了执行上述命令外，还需要下载pycocotools
+### 3. 模型训练/评估/预测
 
-> - pip install cython
-> - pip install git+https://gitee.com/jiangjiajun/philferriere-cocoapi.git#subdirectory=PythonAPI
+* **PaddleX API开发模式：**
 
+    * [API文档](./docs/apis)
+      * [数据集读取API](./docs/apis/datasets.md)
+      * [数据预处理和数据增强API](./docs/apis/transforms/transforms.md)
+      * [图像分类模型API](./docs/apis/models/classification.md)
+      * [目标检测模型API](./docs/apis/models/detection.md)
+      * [实例分割模型API](./docs/apis/models/instance_segmentation.md)
+      * [图像分割模型API](./docs/apis/models/semantic_segmentation.md)
+    * [模型训练与参数调整](tutorials/train)
+      * [模型训练](tutorials/train)
+      * [训练参数调整](./docs//parameters.md)
+    * [VisualDL可视化训练指标](../docs/train/visualdl.md)
+    * [加载训好的模型完成预测及预测结果可视化](../docs/train/prediction.md)
 
-2. **Padlde GUI模式：**
+* **PaddleX GUI开发模式：**
 
-   无代码开发的可视化客户端，应用Paddle API实现，使开发者快速进行产业项目验证，并为用户开发自有深度学习软件/应用提供参照。
+    - [图像分类](https://www.bilibili.com/video/BV1nK411F7J9?from=search&seid=3068181839691103009)
+    - [目标检测](https://www.bilibili.com/video/BV1HB4y1A73b?from=search&seid=3068181839691103009)
+    - [实例分割](https://www.bilibili.com/video/BV1M44y1r7s6?from=search&seid=3068181839691103009)
+    - [语义分割](https://www.bilibili.com/video/BV1qQ4y1Z7co?from=search&seid=3068181839691103009)
 
-- 前往[PaddleX官网](https://www.paddlepaddle.org.cn/paddle/paddlex)，申请下载PaddleX GUI一键绿色安装包。
 
-- 前往[PaddleX GUI使用教程](../docs/gui/how_to_use.md)了解PaddleX GUI使用详情。
+### 4. 模型剪裁和量化
 
-- [PaddleX GUI安装环境说明](../docs/gui/download.md)
+- [模型剪裁](tutorials/slim/prune)
+- [模型量化](tutorials/slim/quantize)
 
-3. **PaddleX Restful:**  
-  使用基于RESTful API开发的GUI与Web Demo实现远程的深度学习全流程开发；同时开发者也可以基于RESTful API开发个性化的可视化界面
-- 前往[PaddleX RESTful API使用教程](../docs/Resful_API/docs/readme.md)  
+### 5. 模型部署
 
+- [PaddleX Manufacture SDK低代码高效部署](./deploy/cpp/docs/manufacture_sdk)
+- [PaddleX/PaddleClas/PaddleDetection/PaddleSeg端到端高性能统一部署](./deploy/cpp)
 
-## 使用教程
+### 6. 产业级应用示例
 
-1. **API模式：**
+- [钢筋计数](examples/rebar_count)
+- [缺陷检测](examples/defect_detection)
+- [机械手抓取](examples/robot_grab)
+- [工业表计读数](examples/meter_reader)
+- [Windows系统下使用C#语言部署](examples/C#_deploy)
 
-- [模型训练](https://github.com/PaddlePaddle/PaddleX/tree/release/2.0-rc/tutorials/train)
-- [模型剪裁](https://github.com/PaddlePaddle/PaddleX/tree/release/2.0-rc/tutorials/slim/prune)
+## 版本更新
 
+- **2021.07.05 v2.0.0-rc1**
 
+  PaddleX部署全面升级，支持飞桨视觉套件PaddleDetection、PaddleClas、PaddleSeg、PaddleX的端到端统一部署能力。全新发布Manufacture SDK，提供工业级多端多平台部署加速的预编译飞桨部署开发包（SDK），通过配置业务逻辑流程文件即可以低代码方式快速完成推理部署。发布产业实践案例：钢筋计数、缺陷检测、机械手抓取、工业表计读数、Windows系统下使用C#语言部署。升级PaddleX GUI，支持30系列显卡、新增模型PP-YOLO V2、PP-YOLO Tiny 、BiSeNetV2。详细内容请参考[版本更新文档](./docs/CHANGELOG.md)
 
-2. **GUI模式：**
-
-- [图像分类](https://www.bilibili.com/video/BV1nK411F7J9?from=search&seid=3068181839691103009)
-- [目标检测](https://www.bilibili.com/video/BV1HB4y1A73b?from=search&seid=3068181839691103009)
-- [实例分割](https://www.bilibili.com/video/BV1M44y1r7s6?from=search&seid=3068181839691103009)
-- [语义分割](https://www.bilibili.com/video/BV1qQ4y1Z7co?from=search&seid=3068181839691103009)
+- **2021.05.19 v2.0.0-rc**
 
-3. **模型部署：**
-- [Manufacture SDK](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp)
-提供工业级多端多平台部署加速的预编译飞桨部署开发包（SDK），通过配置业务逻辑流程文件即可以低代码方式快速完成推理部署
-- [PaddleX Deploy](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp) 支持飞桨视觉套件PaddleDetection、PaddleClas、PaddleSeg、PaddleX的统一部署能力
-## 产业级应用示例
+  全面支持飞桨2.0动态图，更易用的开发模式。 目标检测任务新增PP-YOLOv2, COCO test数据集精度达到49.5%、V100预测速度达到68.9 FPS。目标检测任务新增4.2MB的超轻量级模型PP-YOLO tiny。语义分割任务新增实时分割模型BiSeNetV2。C++部署模块全面升级，PaddleInference部署适配2.0预测库，支持飞桨PaddleDetection、PaddleSeg、PaddleClas以及PaddleX的模型部署；新增基于PaddleInference的GPU多卡预测；GPU部署新增基于ONNX的的TensorRT高性能加速引擎部署方式；GPU部署新增基于ONNX的Triton服务化部署方式。详情内容请参考[版本更新文档](./docs/CHANGELOG.md)。
 
-- [钢筋计数](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/examples/rebar_count)
-- [缺陷检测](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/examples/defect_detection)
-- [机械手抓取](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/examples/robot_grab)
-- [表计检测]()
-## :question:[FAQ]
-(../docs/gui/faq.md):question:
 
 ## 交流与反馈
 
@@ -112,39 +116,6 @@
   </p>
 
 
-
-## 更新日志
-
-- **2021.05.19 v2.0.0-rc**
-
-  * 全面支持飞桨2.0动态图，更易用的开发模式
-  * 目标检测任务新增[PP-YOLOv2](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/object_detection/ppyolov2.py), COCO test数据集精度达到49.5%、V100预测速度达到68.9 FPS
-  * 目标检测任务新增4.2MB的超轻量级模型[PP-YOLO tiny](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/object_detection/ppyolotiny.py)
-  * 语义分割任务新增实时分割模型[BiSeNetV2](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/semantic_segmentation/bisenetv2.py)
-  * C++部署模块全面升级
-    * PaddleInference部署适配2.0预测库[（使用文档）](https://github.com/PaddlePaddle/PaddleX/tree/release/2.0-rc/deploy/cpp)
-    * 支持飞桨[PaddleDetection]( https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddledetection.md)、[PaddleSeg]( https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddleseg.md)、[PaddleClas](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddleclas.md)以及PaddleX的模型部署
-    * 新增基于PaddleInference的GPU多卡预测[（使用文档）](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/demo/multi_gpu_model_infer.md)
-    * GPU部署新增基于ONNX的的TensorRT高性能加速引擎部署方式[（使用文档）]()
-    * GPU部署新增基于ONNX的Triton服务化部署方式[（使用文档）](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/compile/triton/docker.md)
-
-
-- **2020.09.07 v1.2.0**
-
-  新增产业最实用目标检测模型PP-YOLO，FasterRCNN、MaskRCNN、YOLOv3、DeepLabv3p等模型新增内置COCO数据集预训练模型，适用于小模型精调。新增多种Backbone，优化体积及预测速度。优化OpenVINO、PaddleLite Android、服务端C++预测部署方案，新增树莓派部署方案等。
-
-- **2020.07.12 v1.1.0**
-
-  新增人像分割、工业标记读数案例。模型新增HRNet、FastSCNN、FasterRCNN，实例分割MaskRCNN新增Backbone HRNet。集成X2Paddle，PaddleX所有分类模型和语义分割模型支持导出为ONNX协议。新增模型加密Windows平台支持。新增Jetson、Paddle Lite模型部署预测方案。
-
-- **2020.05.20 v1.0.0**
-
-  新增C++和Python部署，模型加密部署，分类模型OpenVINO部署。新增模型可解释性接口
-
-- **2020.05.17 v0.1.8**
-
-  新增EasyData平台数据标注格式，支持imgaug数据增强库的pixel-level算子
-
 ## :hugs: 贡献代码:hugs:
 
 我们非常欢迎您为PaddleX贡献代码或者提供使用建议。如果您可以修复某个issue或者增加一个新功能，欢迎给我们提交Pull Requests。

dygraph/docs/CHANGELOG.md

@@ -0,0 +1,43 @@
+# 版本更新信息
+
+## 最新版本信息
+
+- **2021.07.05 v2.0.0-rc1**
+
+  * PaddleX部署全面升级，支持飞桨视觉套件PaddleDetection、PaddleClas、PaddleSeg、PaddleX的端到端统一部署能力。[使用教程](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp)
+  * 全新发布Manufacture SDK，提供工业级多端多平台部署加速的预编译飞桨部署开发包（SDK），通过配置业务逻辑流程文件即可以低代码方式快速完成推理部署。[使用教程](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp/docs/manufacture_sdk)
+  * 发布产业实践案例：钢筋计数、缺陷检测、机械手抓取、工业表计读数、Windows系统下使用C#语言部署。[使用教程](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/examples)
+  * 升级PaddleX GUI，支持30系列显卡、新增模型PP-YOLO V2、PP-YOLO Tiny 、BiSeNetV2。[使用教程](https://github.com/FlyingQianMM/PaddleX/blob/develop_qh/dygraph/docs/install.md#2-padldex-gui%E5%BC%80%E5%8F%91%E6%A8%A1%E5%BC%8F%E5%AE%89%E8%A3%85)
+
+
+- **2021.05.19 v2.0.0-rc**
+
+  * 全面支持飞桨2.0动态图，更易用的开发模式
+  * 目标检测任务新增[PP-YOLOv2](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/object_detection/ppyolov2.py), COCO test数据集精度达到49.5%、V100预测速度达到68.9 FPS
+  * 目标检测任务新增4.2MB的超轻量级模型[PP-YOLO tiny](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/object_detection/ppyolotiny.py)
+  * 语义分割任务新增实时分割模型[BiSeNetV2](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/tutorials/train/semantic_segmentation/bisenetv2.py)
+  * C++部署模块全面升级
+    * PaddleInference部署适配2.0预测库[（使用文档）](https://github.com/PaddlePaddle/PaddleX/tree/release/2.0-rc/deploy/cpp)
+    * 支持飞桨[PaddleDetection]( https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddledetection.md)、[PaddleSeg]( https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddleseg.md)、[PaddleClas](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/models/paddleclas.md)以及PaddleX的模型部署
+    * 新增基于PaddleInference的GPU多卡预测[（使用文档）](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/demo/multi_gpu_model_infer.md)
+    * GPU部署新增基于ONNX的的TensorRT高性能加速引擎部署方式[（使用文档）]()
+    * GPU部署新增基于ONNX的Triton服务化部署方式[（使用文档）](https://github.com/PaddlePaddle/PaddleX/blob/release/2.0-rc/deploy/cpp/docs/compile/triton/docker.md)
+
+
+## 历史版本信息
+
+- **2020.09.07 v1.2.0**
+
+  新增产业最实用目标检测模型PP-YOLO，FasterRCNN、MaskRCNN、YOLOv3、DeepLabv3p等模型新增内置COCO数据集预训练模型，适用于小模型精调。新增多种Backbone，优化体积及预测速度。优化OpenVINO、PaddleLite Android、服务端C++预测部署方案，新增树莓派部署方案等。
+
+- **2020.07.12 v1.1.0**
+
+  新增人像分割、工业标记读数案例。模型新增HRNet、FastSCNN、FasterRCNN，实例分割MaskRCNN新增Backbone HRNet。集成X2Paddle，PaddleX所有分类模型和语义分割模型支持导出为ONNX协议。新增模型加密Windows平台支持。新增Jetson、Paddle Lite模型部署预测方案。
+
+- **2020.05.20 v1.0.0**
+
+  新增C++和Python部署，模型加密部署，分类模型OpenVINO部署。新增模型可解释性接口
+
+- **2020.05.17 v0.1.8**
+
+  新增EasyData平台数据标注格式，支持imgaug数据增强库的pixel-level算子

dygraph/docs/apis/datasets.md

@@ -0,0 +1,82 @@
+# 数据集读取
+
+## 目录
+
+* [ImageNet](#1)
+* [VOCDetection](#2)
+* [CocoDetection](#3)
+* [SegDataset](#4)
+
+## <h2 id="1">paddlex.datasets.ImageNet</h2>
+> **用于图像分类模型**  
+```python
+paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_workers='auto', shuffle=False)
+```
+读取ImageNet格式的分类数据集，并对样本进行相应的处理。ImageNet数据集格式的介绍可查看文档:[数据集格式说明](../data/format/classification.md)  
+
+示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/dygraph/tutorials/train/image_classification/mobilenetv3_small.py)
+
+> **参数**
+>
+> > * **data_dir** (str): 数据集所在的目录路径。  
+> > * **file_list** (str): 描述数据集图片文件和类别id的文件路径（文本内每行路径为相对`data_dir`的相对路径）。  
+> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
+> > * **transforms** (paddlex.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.transforms](./transforms/transforms.md)。  
+> > * **num_workers** (int|str)：数据集中样本在预处理过程中的进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。  
+> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。  
+
+## <h2 id="1">paddlex.datasets.VOCDetection</h2>
+> **用于目标检测模型**  
+```python
+paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None, num_workers='auto', shuffle=False)
+```
+
+> 读取PascalVOC格式的检测数据集，并对样本进行相应的处理。PascalVOC数据集格式的介绍可查看文档:[数据集格式说明](../data/format/detection.md)  
+
+> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/dygraph/tutorials/train/object_detection/yolov3_darknet53.py)
+
+> **参数**
+>
+> > * **data_dir** (str): 数据集所在的目录路径。  
+> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
+> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
+> > * **transforms** (paddlex.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.transforms](./transforms/transforms.md)。  
+> > * **num_workers** (int|str)：数据集中样本在预处理过程中的进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
+> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
+
+## <h2 id="1">paddlex.datasets.CocoDetection</h2>
+> **用于实例分割/目标检测模型**  
+```python
+paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers='auto', shuffle=False)
+```
+
+> 读取MSCOCO格式的检测数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。MSCOCO数据集格式的介绍可查看文档:[数据集格式说明](../data/format/instance_segmentation.md)  
+
+> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/dygraph/tutorials/train/instance_segmentation/mask_rcnn_r50_fpn.py)
+
+> **参数**
+>
+> > * **data_dir** (str): 数据集所在的目录路径。  
+> > * **ann_file** (str): 数据集的标注文件，为一个独立的json格式文件。
+> > * **transforms** (paddlex.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.transforms](./transforms/transforms.md)。
+> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。  
+> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
+
+## <h2 id="1">paddlex.datasets.SegDataset</h2>
+> **用于语义分割模型**  
+```python
+paddlex.datasets.SegDataset(data_dir, file_list, label_list=None, transforms=None, num_workers='auto', shuffle=False)
+```
+
+> 读取语义分割任务数据集，并对样本进行相应的处理。语义分割任务数据集格式的介绍可查看文档:[数据集格式说明](../data/format/segmentation.md)  
+
+> 示例：[代码文件](https://github.com/PaddlePaddle/PaddleX/blob/develop/dygraph/tutorials/train/semantic_segmentation/unet.py)
+
+> **参数**
+>
+> > * **data_dir** (str): 数据集所在的目录路径。  
+> > * **file_list** (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对`data_dir`的相对路径）。
+> > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
+> > * **transforms** (paddlex.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.transforms](./transforms/seg_transforms.md)。  
+> > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
+> > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。

dygraph/docs/apis/models/classification.md

@@ -0,0 +1,201 @@
+# Image Classification
+
+## paddlex.cls.ResNet50
+
+```python
+paddlex.cls.ResNet50(num_classes=1000)
+```
+
+> 构建ResNet50分类器，并实现其训练、评估和预测。
+
+> **参数**
+>
+> - **num_classes** (int): 类别数。默认为1000。  
+
+### train
+
+```python
+train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', pretrain_weights='IMAGENET', learning_rate=.025, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(30, 60, 90), lr_decay_gamma=0.1, early_stop=False, early_stop_patience=5, use_vdl=True)
+```
+>
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小。同时作为验证数据batch大小。默认为64。
+> > - **eval_dataset** (paddlex.dataset or None): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代步数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **pretrain_weights** (str or None): 若指定为'.pdparams'文件时，则从文件加载模型权重；若为字符串'IMAGENET'，则自动下载在ImageNet图片数据上预训练的模型权重；若为None，则不使用预训练模型。默认为'IMAGENET'。
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.025。
+> > - **warmup_steps** (int): 默认优化器的warmup步数，学习率将在设定的步数内，从warmup_start_lr线性增长至设定的learning_rate，默认为0。
+> > - **warmup_start_lr**(float): 默认优化器的warmup起始学习率，默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[30, 60, 90]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+
+### evaluate
+
+```python
+evaluate(self, eval_dataset, batch_size=1, return_details=False)
+```
+>
+> **参数**
+>
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。
+> > - **batch_size** (int): 验证数据批大小。默认为1。
+> > - **return_details** (bool): 是否返回详细信息。默认为False。
+>
+> **返回值**
+>
+> > - **tuple** (metrics, eval_details) | **dict** (metrics): 当`return_details`为True时，返回(metrics, eval_details)，当`return_details`为False时，返回metrics。 metrics为dict，包含键值：'acc1'、'acc5'，分别表示最大值的accuracy、前5个最大值的accuracy。eval_details为dict。包含键值：'true_labels'、'pred_scores'，分别代表真实类别id、每个类别的预测得分。
+
+### predict
+
+```python
+predict(self, img_file, transforms=None, topk=1)
+```
+
+> 分类模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`ResNet50.test_transforms`和`ResNet50.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
+
+> **参数**
+>
+> > - **img_file** (List[np.ndarray or str], str or np.ndarray): 预测图像或包含多张预测图像的列表，预测图像可以是路径或numpy数组(HWC排列，BGR格式)。
+> > - **transforms** (paddlex.transforms): 数据预处理操作。
+> > - **topk** (int): 预测时前k个最大值。
+
+> **返回值**
+>
+> > - **dict** ｜ **List[dict]**: 如果输入为单张图像，返回dict。包含的键值为'category_id'、'category'、'score'，分别对应预测类别id、预测类别标签、预测得分。如果输入为多张图像，返回由每张图像预测结果组成的列表。
+
+### analyze_sensitivity
+
+```python
+analyze_sensitivity(self, dataset, batch_size=8, criterion='l1_norm', save_dir='output')
+```
+
+> 模型敏感度分析接口。
+
+> **参数**
+>
+> > - **dataset** (paddlex.dataset): 用于评估模型在不同剪裁比例下精度损失的评估数据集。
+> > - **batch_size** (int): 评估模型精度损失时的batch大小。默认为8。
+> > - **criterion** ({'l1_norm', 'fpgm'}): 进行Filter粒度剪裁时评估，评估Filter重要性的范数标准。如果为'l1_norm'，采用L1-Norm标准。如果为'fpgm'，采用 [Geometric Median](https://arxiv.org/abs/1811.00250) 标准。
+> > - **save_dir** (str): 计算的得到的sensetives文件的存储路径。
+
+### prune
+
+```python
+prune(self, pruned_flops, save_dir=None)
+```
+
+> 模型剪裁接口。
+
+> **参数**
+> > - **pruned_flops** (float): 每秒浮点数运算次数（FLOPs）的剪裁比例。
+> > - **save_dir** (None or str): 剪裁后模型保存路径。如果为None，剪裁完成后不会对模型进行保存。默认为None。
+
+### quant_aware_train
+
+```python
+quant_aware_train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', learning_rate=.000025, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(30, 60, 90), lr_decay_gamma=0.1, early_stop=False, early_stop_patience=5, use_vdl=True, quant_config=None)
+```
+
+> 分类模型在线量化接口。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小。同时作为验证数据batch大小。默认为64。
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代步数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.000025。
+> > - **warmup_steps** (int): 默认优化器的warmup步数，学习率将在设定的步数内，从warmup_start_lr线性增长至设定的learning_rate，默认为0。
+> > - **warmup_start_lr**(float): 默认优化器的warmup起始学习率，默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[30, 60, 90]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+> > - **quant_config** (None or dict): 量化器配置。如果为None，使用默认配置。如果为dict，可配置项如下：
+> >  ```python
+> >  {
+> >     # weight预处理方法，默认为None，代表不进行预处理；当需要使用`PACT`方法时设置为`"PACT"`
+> >      'weight_preprocess_type': None,
+> >
+> >     # activation预处理方法，默认为None，代表不进行预处理`
+> >     'activation_preprocess_type': None,
+> >
+> >     # weight量化方法, 默认为'channel_wise_abs_max', 此外还支持'channel_wise_abs_max'
+> >     'weight_quantize_type': 'channel_wise_abs_max',
+> >
+> >     # activation量化方法, 默认为'moving_average_abs_max', 此外还支持'abs_max'
+> >     'activation_quantize_type': 'moving_average_abs_max',
+> >
+> >     # weight量化比特数, 默认为 8
+> >     'weight_bits': 8,
+> >
+> >     # activation量化比特数, 默认为 8
+> >     'activation_bits': 8,
+> >
+> >     # 'moving_average_abs_max'的滑动平均超参, 默认为0.9
+> >     'moving_rate': 0.9,
+> >
+> >     # 需要量化的算子类型
+> >     'quantizable_layer_type': ['Conv2D', 'Linear']
+> >  }
+> >  ```
+
+
+## 其它分类模型
+
+PaddleX提供了共计38种分类模型，所有分类模型均提供同`ResNet50`相同的训练`train`，评估`evaluate`，预测`predict`，敏感度分析`analyze_sensitivity`，剪裁`prune`和在线量化`quant_aware_train`接口，各模型效果可参考[模型库](../../appendix/model_zoo.md)。
+
+| 模型              | 接口                    |
+| :---------------- | :---------------------- |
+| ResNet18          | paddlex.cls.ResNet18(num_classes=1000) |
+| ResNet18_vd       | paddlex.cls.ResNet18_vd(num_classes=1000) |
+| ResNet34          | paddlex.cls.ResNet34(num_classes=1000) |
+| ResNet34_vd          | paddlex.cls.ResNet34_vd(num_classes=1000) |
+| ResNet50          | paddlex.cls.ResNet50(num_classes=1000) |
+| ResNet50_vd       | paddlex.cls.ResNet50_vd(num_classes=1000) |
+| ResNet50_vd_ssld    | paddlex.cls.ResNet50_vd_ssld(num_classes=1000) |
+| ResNet101          | paddlex.cls.ResNet101(num_classes=1000) |
+| ResNet101_vd        | paddlex.cls.ResNet101_vd(num_classes=1000) |
+| ResNet101_vd_ssld   | paddlex.cls.ResNet101_vd_ssld(num_classes=1000) |
+| ResNet152 | paddlex.cls.ResNet152(num_classes=1000) |
+| ResNet152_vd | paddlex.cls.ResNet152_vd(num_classes=1000) |
+| ResNet200_vd | paddlex.cls.ResNet200_vd(num_classes=1000) |
+| DarkNet53      | paddlex.cls.DarkNet53(num_classes=1000) |
+| MobileNetV1         | paddlex.cls.MobileNetV1(num_classes=1000, scale=1.0) |
+| MobileNetV2       | paddlex.cls.MobileNetV2(num_classes=1000, scale=1.0) |
+| MobileNetV3_small       | paddlex.cls.MobileNetV3_small(num_classes=1000, scale=1.0) |
+| MobileNetV3_small_ssld  | paddlex.cls.MobileNetV3_small_ssld(num_classes=1000, scale=1.0) |
+| MobileNetV3_large   | paddlex.cls.MobileNetV3_large(num_classes=1000, scale=1.0) |
+| MobileNetV3_large_ssld | paddlex.cls.MobileNetV3_large_ssld(num_classes=1000) |
+| Xception41     | paddlex.cls.Xception41(num_classes=1000) |
+| Xception65     | paddlex.cls.Xception65(num_classes=1000) |
+| Xception71     | paddlex.cls.Xception71(num_classes=1000) |
+| ShuffleNetV2     | paddlex.cls.ShuffleNetV2(num_classes=1000, scale=1.0) |
+| ShuffleNetV2_swish     | paddlex.cls.ShuffleNetV2_swish(num_classes=1000) |
+| DenseNet121      | paddlex.cls.DenseNet121(num_classes=1000) |
+| DenseNet161       | paddlex.cls.DenseNet161(num_classes=1000) |
+| DenseNet169       | paddlex.cls.DenseNet169(num_classes=1000) |
+| DenseNet201       | paddlex.cls.DenseNet201(num_classes=1000) |
+| DenseNet264       | paddlex.cls.DenseNet264(num_classes=1000) |
+| HRNet_W18_C       | paddlex.cls.HRNet_W18_C(num_classes=1000) |
+| HRNet_W30_C       | paddlex.cls.HRNet_W30_C(num_classes=1000) |
+| HRNet_W32_C       | paddlex.cls.HRNet_W32_C(num_classes=1000) |
+| HRNet_W40_C       | paddlex.cls.HRNet_W40_C(num_classes=1000) |
+| HRNet_W44_C       | paddlex.cls.HRNet_W44_C(num_classes=1000) |
+| HRNet_W48_C       | paddlex.cls.HRNet_W48_C(num_classes=1000) |
+| HRNet_W64_C       | paddlex.cls.HRNet_W64_C(num_classes=1000) |
+| AlexNet         | paddlex.cls.AlexNet(num_classes=1000) |

dygraph/docs/apis/models/detection.md

@@ -0,0 +1,306 @@
+# Object Detection
+
+## paddlex.det.PPYOLOv2
+
+```python
+paddlex.det.PPYOLOv2(num_classes=80, backbone='ResNet50_vd_dcn', anchors=[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]], anchor_masks=[[6, 7, 8], [3, 4, 5], [0, 1, 2]], use_iou_aware=True, use_spp=True, use_drop_block=True, scale_x_y=1.05, ignore_threshold=0.7, label_smooth=False, use_iou_loss=True, use_matrix_nms=True, nms_score_threshold=0.01, nms_topk=-1, nms_keep_topk=100, nms_iou_threshold=0.45)
+```
+
+> 构建PPYOLOv2检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): PPYOLOv2的backbone网络，取值范围为['ResNet50_vd_dcn', 'ResNet101_vd_dcn']。默认为'ResNet50_vd_dcn'。
+> > - **anchors** (list or tuple): anchor框的宽度和高度，默认为[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]]。
+> > - **anchor_masks** (list or tuple): 在计算PPYOLOv2损失时，使用anchor的mask索引，默认为[[6, 7, 8], [3, 4, 5], [0, 1, 2]]。
+> > - **use_iou_aware** (bool): 是否使用IoU Aware分支。默认为True。
+> > - **use_spp** (bool): 是否使用Spatial Pyramid Pooling结构。默认为True。
+> > - **use_drop_block** (bool): 是否使用Drop Block。默认为True。
+> > - **scale_x_y** (float): 调整中心点位置时的系数因子。默认为1.05。
+> > - **ignore_threshold** (float): 在计算PPYOLOv2损失时，IoU大于`ignore_threshold`的预测框的置信度被忽略。默认为0.7。
+> > - **label_smooth** (bool): 是否使用label smooth。默认为False。
+> > - **use_iou_loss** (bool): 是否使用IoU loss。默认为True。
+> > - **use_matrix_nms** (bool): 是否使用Matrix NMS。默认为True。
+> > - **nms_score_threshold** (float): 检测框的置信度得分阈值，置信度得分低于阈值的框应该被忽略。默认为0.01。
+> > - **nms_topk** (int): 进行NMS时，根据置信度保留的最大检测框数。如果为-1则全部保留。默认为-1。
+> > - **nms_keep_topk** (int): 进行NMS后，每个图像要保留的总检测框数。默认为100。
+> > - **nms_iou_threshold** (float): 进行NMS时，用于剔除检测框IOU的阈值。默认为0.45。
+
+### train
+
+```python
+train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', pretrain_weights='IMAGENET', learning_rate=.001, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(216, 243), lr_decay_gamma=0.1, metric=None, use_ema=False, early_stop=False, early_stop_patience=5, use_vdl=True)
+```
+
+> PPYOLOv2模型的训练接口，函数内置了`piecewise`学习率衰减策略和`momentum`优化器。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小，默认为64。目前检测仅支持单卡batch大小为1进行评估，`train_batch_size`参数不影响评估时的batch大小。
+> > - **eval_dataset** (paddlex.dataset or None): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代次数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **pretrain_weights** (str ort None): 若指定为'.pdparams'文件时，则从文件加载模型权重；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重（仅包含backbone网络）；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重；若为None，则不使用预训练模型。默认为'IMAGENET'。
+> > - **learning_rate** (float): 默认优化器的学习率。默认为0.001。
+> > - **warmup_steps** (int):  默认优化器进行warmup过程的步数。默认为0。
+> > - **warmup_start_lr** (int): 默认优化器warmup的起始学习率。默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[216, 243]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'。
+> > - **use_ema** (bool): 是否使用指数衰减计算参数的滑动平均值。默认为False。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+
+### evaluate
+
+```python
+evaluate(self, eval_dataset, batch_size=1, metric=None, return_details=False)
+```
+
+> PPYOLOv2模型的评估接口，模型评估后会返回在验证集上的指标`box_map`(metric指定为'VOC'时)或`box_mmap`(metric指定为`COCO`时)。
+
+> **参数**
+>
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。
+> > - **batch_size** (int): 验证数据批大小。默认为1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'默认为None， 如为EasyData类型数据集，同时也会使用'VOC'。
+> > - **return_details** (bool): 是否返回详细信息。默认为False。
+> >
+>  **返回值**
+>
+> > - **tuple** (metrics, eval_details) | **dict** (metrics): 当`return_details`为True时，返回(metrics, eval_details)，当`return_details`为False时，返回metrics。metrics为dict，包含关键字：'bbox_mmap'或者’bbox_map‘，分别表示平均准确率平均值在各个阈值下的结果取平均值的结果（mmAP）、平均准确率平均值（mAP）。eval_details为dict，包含bbox和gt两个关键字。其中关键字bbox的键值是一个列表，列表中每个元素代表一个预测结果，一个预测结果是一个由图像id，预测框类别id, 预测框坐标，预测框得分组成的列表。而关键字gt的键值是真实标注框的相关信息。
+
+### predict
+
+```python
+predict(self, img_file, transforms=None)
+```
+
+> PPYOLOv2模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`PPYOLOv2.test_transforms`和`PPYOLOv2.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义`test_transforms`传入给`predict`接口
+
+> **参数**
+>
+> > - **img_file** (List[np.ndarray or str], str or np.ndarray): 预测图像或包含多张预测图像的列表，预测图像可以是路径或numpy数组(HWC排列，BGR格式)。
+> > - **transforms** (paddlex.transforms): 数据预处理操作。
+>
+> **返回值**
+>
+> > - **list**: 预测结果列表。如果输入为单张图像，列表中每个元素均为一个dict，键值包括'bbox', 'category', 'category_id', 'score'，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。如果输入为多张图像，如果输入为多张图像，返回由每张图像预测结果组成的列表。
+
+### analyze_sensitivity
+
+```python
+analyze_sensitivity(self, dataset, batch_size=8, criterion='l1_norm', save_dir='output')
+```
+
+> PPYOLOv2模型敏感度分析接口。
+
+> **参数**
+>
+> > - **dataset** (paddlex.dataset): 用于评估模型在不同剪裁比例下精度损失的评估数据集。
+> > - **batch_size** (int): 评估模型精度损失时的batch大小。默认为8。
+> > - **criterion** ({'l1_norm', 'fpgm'}): 进行Filter粒度剪裁时评估，评估Filter重要性的范数标准。如果为'l1_norm'，采用L1-Norm标准。如果为'fpgm'，采用 [Geometric Median](https://arxiv.org/abs/1811.00250) 标准。
+> > - **save_dir** (str): 计算的得到的sensetives文件的存储路径。
+
+### prune
+
+```python
+prune(self, pruned_flops, save_dir=None)
+```
+
+> PPYOLOv2模型剪裁接口。
+
+> **参数**
+> > - **pruned_flops** (float): 每秒浮点数运算次数（FLOPs）的剪裁比例。
+> > - **save_dir** (None or str): 剪裁后模型保存路径。如果为None，剪裁完成后不会对模型进行保存。默认为None。
+
+### quant_aware_train
+
+```python
+quant_aware_train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', learning_rate=.00001, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(216, 243), lr_decay_gamma=0.1, metric=None, use_ema=False, early_stop=False, early_stop_patience=5, use_vdl=True, quant_config=None)
+```
+
+> PPYOLOv2模型在线量化接口。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小。同时作为验证数据batch大小。默认为64。
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代步数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.00001。
+> > - **warmup_steps** (int): 默认优化器的warmup步数，学习率将在设定的步数内，从warmup_start_lr线性增长至设定的learning_rate，默认为0。
+> > - **warmup_start_lr**(float): 默认优化器的warmup起始学习率，默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[216， 243]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'。
+> > - **use_ema** (bool): 是否使用指数衰减计算参数的滑动平均值。默认为False。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+> > - **quant_config** (None or dict): 量化器配置。如果为None，使用默认配置。如果为dict，可配置项如下：
+> >  ```python
+> >  {
+> >     # weight预处理方法，默认为None，代表不进行预处理；当需要使用`PACT`方法时设置为`"PACT"`
+> >      'weight_preprocess_type': None,
+> >
+> >     # activation预处理方法，默认为None，代表不进行预处理`
+> >     'activation_preprocess_type': None,
+> >
+> >     # weight量化方法, 默认为'channel_wise_abs_max', 此外还支持'channel_wise_abs_max'
+> >     'weight_quantize_type': 'channel_wise_abs_max',
+> >
+> >     # activation量化方法, 默认为'moving_average_abs_max', 此外还支持'abs_max'
+> >     'activation_quantize_type': 'moving_average_abs_max',
+> >
+> >     # weight量化比特数, 默认为 8
+> >     'weight_bits': 8,
+> >
+> >     # activation量化比特数, 默认为 8
+> >     'activation_bits': 8,
+> >
+> >     # 'moving_average_abs_max'的滑动平均超参, 默认为0.9
+> >     'moving_rate': 0.9,
+> >
+> >     # 需要量化的算子类型
+> >     'quantizable_layer_type': ['Conv2D', 'Linear']
+> >  }
+> >  ```
+
+## paddlex.det.PPYOLO
+
+```python
+paddlex.det.PPYOLO(num_classes=80, backbone='ResNet50_vd_dcn', anchors=None, anchor_masks=None, use_coord_conv=True, use_iou_aware=True, use_spp=True, use_drop_block=True, scale_x_y=1.05, ignore_threshold=0.7, label_smooth=False, use_iou_loss=True, use_matrix_nms=True, nms_score_threshold=0.01, nms_topk=-1, nms_keep_topk=100, nms_iou_threshold=0.45)
+```
+
+> 构建PPYOLO检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): PPYOLOv2的backbone网络，取值范围为['ResNet50_vd_dcn', 'ResNet18_vd', 'MobileNetV3_large', 'MobileNetV3_small']。默认为'ResNet50_vd_dcn'。
+> > - **anchors** (list or tuple): anchor框的宽度和高度，为None时表示使用默认值。backbone网络为'ResNet50_vd_dcn'时默认为[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]]。backbone网络为'ResNet18_vd'时默认为[[10, 14], [23, 27], [37, 58], [81, 82], [135, 169], [344, 319]]。backbone网络为'MobileNetV3_large'或'MobileNetV3_small'时默认为[[11, 18], [34, 47], [51, 126], [115, 71], [120, 195], [254, 235]]。
+> > - **anchor_masks** (list or tuple): 在计算PPYOLO损失时，使用anchor的mask索引，为None时表示使用默认值。backbone网络为'ResNet50_vd_dcn'时默认为[[6, 7, 8], [3, 4, 5], [0, 1, 2]]。backbone网络为'ResNet18_vd'时默认为[[3, 4, 5], [0, 1, 2]]。backbone网络为'MobileNetV3_large'或'MobileNetV3_small'时默认为[[3, 4, 5], [0, 1, 2]]。
+> > - **use_coord_conv** (bool): 是否使用CoordConv。默认为True。
+> > - **use_iou_aware** (bool): 是否使用IoU Aware分支。默认为True。
+> > - **use_spp** (bool): 是否使用Spatial Pyramid Pooling结构。默认为True。
+> > - **use_drop_block** (bool): 是否使用Drop Block。默认为True。
+> > - **scale_x_y** (float): 调整中心点位置时的系数因子。默认为1.05。
+> > - **ignore_threshold** (float): 在计算PPYOLO损失时，IoU大于`ignore_threshold`的预测框的置信度被忽略。默认为0.7。
+> > - **label_smooth** (bool): 是否使用label smooth。默认为False。
+> > - **use_iou_loss** (bool): 是否使用IoU loss。默认为True。
+> > - **use_matrix_nms** (bool): 是否使用Matrix NMS。默认为True。
+> > - **nms_score_threshold** (float): 检测框的置信度得分阈值，置信度得分低于阈值的框应该被忽略。默认为0.01。
+> > - **nms_topk** (int): 进行NMS时，根据置信度保留的最大检测框数。如果为-1则全部保留。默认为-1。
+> > - **nms_keep_topk** (int): 进行NMS后，每个图像要保留的总检测框数。默认为100。
+> > - **nms_iou_threshold** (float): 进行NMS时，用于剔除检测框IOU的阈值。默认为0.45。
+
+> - train 训练接口说明同 [PPYOLOv2模型train接口](#train)
+> - evaluate 评估接口说明同 [PPYOLOv2模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [PPYOLOv2模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [PPYOLOv2模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [PPYOLOv2模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [PPYOLOv2模型quant_aware_train接口](#quant_aware_train)
+
+## paddlex.det.PPYOLOTiny
+```python
+paddlex.det.PPYOLOTiny(num_classes=80, backbone='MobileNetV3', anchors=[[10, 15], [24, 36], [72, 42], [35, 87], [102, 96], [60, 170], [220, 125], [128, 222], [264, 266]], anchor_masks=[[6, 7, 8], [3, 4, 5], [0, 1, 2]], use_iou_aware=False, use_spp=True, use_drop_block=True, scale_x_y=1.05, ignore_threshold=0.5, label_smooth=False, use_iou_loss=True, use_matrix_nms=False, nms_score_threshold=0.005, nms_topk=1000, nms_keep_topk=100, nms_iou_threshold=0.45)
+```
+
+> 构建PPYOLOTiny检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): YOLOv3的backbone网络，取值范围为['MobileNetV3']。默认为'MobileNetV3'。
+> > - **anchors** (list|tuple): anchor框的宽度和高度。默认为[[10, 15], [24, 36], [72, 42], [35, 87], [102, 96], [60, 170], [220, 125], [128, 222], [264, 266]]。
+> > - **anchor_masks** (list|tuple): 在计算YOLOv3损失时，使用anchor的mask索引。默认为[[6, 7, 8], [3, 4, 5], [0, 1, 2]]。
+> > - **use_iou_aware** (bool): 是否使用IoU Aware分支。默认为False。
+> > - **use_spp** (bool): 是否使用Spatial Pyramid Pooling结构。默认为True。
+> > - **use_drop_block** (bool): 是否使用Drop Block。默认为True。
+> > - **scale_x_y** (float): 调整中心点位置时的系数因子。默认为1.05。
+> > - **ignore_threshold** (float): 在计算PPYOLOv2损失时，IoU大于`ignore_threshold`的预测框的置信度被忽略。默认为0.5。
+> > - **label_smooth** (bool): 是否使用label smooth。默认为False。
+> > - **use_iou_loss** (bool): 是否使用IoU loss。默认为True。
+> > - **use_matrix_nms** (bool): 是否使用Matrix NMS。默认为False。
+> > - **nms_score_threshold** (float): 检测框的置信度得分阈值，置信度得分低于阈值的框应该被忽略。默认为0.005。
+> > - **nms_topk** (int): 进行NMS时，根据置信度保留的最大检测框数。如果为-1则全部保留。默认为1000。
+> > - **nms_keep_topk** (int): 进行NMS后，每个图像要保留的总检测框数。默认为100。
+> > - **nms_iou_threshold** (float): 进行NMS时，用于剔除检测框IOU的阈值。默认为0.45。
+
+> - train 训练接口说明同 [PPYOLOv2模型train接口](#train)
+> - evaluate 评估接口说明同 [PPYOLOv2模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [PPYOLOv2模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [PPYOLOv2模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [PPYOLOv2模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [PPYOLOv2模型quant_aware_train接口](#quant_aware_train)
+
+## paddlex.det.YOLOv3
+
+```python
+paddlex.det.YOLOv3(num_classes=80, backbone='MobileNetV1', anchors=[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]], anchor_masks=[[6, 7, 8], [3, 4, 5], [0, 1, 2]], ignore_threshold=0.7, nms_score_threshold=0.01, nms_topk=1000, nms_keep_topk=100, nms_iou_threshold=0.45, label_smooth=False)
+```
+
+> 构建YOLOv3检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): YOLOv3的backbone网络，取值范围为['MobileNetV1', 'MobileNetV1_ssld', 'MobileNetV3', 'MobileNetV3_ssld', 'DarkNet53', 'ResNet50_vd_dcn', 'ResNet34']。默认为'MobileNetV1'。
+> > - **anchors** (list|tuple): anchor框的宽度和高度。默认为[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45], [59, 119], [116, 90], [156, 198], [373, 326]]。
+> > - **anchor_masks** (list|tuple): 在计算YOLOv3损失时，使用anchor的mask索引。默认为[[6, 7, 8], [3, 4, 5], [0, 1, 2]]。
+> > - **ignore_threshold** (float): 在计算YOLOv3损失时，IoU大于`ignore_threshold`的预测框的置信度被忽略。默认为0.7。
+> > - **nms_score_threshold** (float): 检测框的置信度得分阈值，置信度得分低于阈值的框应该被忽略。默认为0.01。
+> > - **nms_topk** (int): 进行NMS时，根据置信度保留的最大检测框数。默认为1000。
+> > - **nms_keep_topk** (int): 进行NMS后，每个图像要保留的总检测框数。默认为100。
+> > - **nms_iou_threshold** (float): 进行NMS时，用于剔除检测框IoU的阈值。默认为0.45。
+> > - **label_smooth** (bool): 是否使用label smooth。默认为False。
+
+> - train 训练接口说明同 [PPYOLOv2模型train接口](#train)
+> - evaluate 评估接口说明同 [PPYOLOv2模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [PPYOLOv2模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [PPYOLOv2模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [PPYOLOv2模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [PPYOLOv2模型quant_aware_train接口](#quant_aware_train)
+
+
+## paddlex.det.FasterRCNN
+
+```python
+paddlex.det.FasterRCNN(num_classes=80, backbone='ResNet50', with_fpn=True, aspect_ratios=[0.5, 1.0, 2.0], anchor_sizes=[[32], [64], [128], [256], [512]], keep_top_k=100, nms_threshold=0.5, score_threshold=0.05, fpn_num_channels=256, rpn_batch_size_per_im=256, rpn_fg_fraction=0.5, test_pre_nms_top_n=None, test_post_nms_top_n=1000)
+```
+
+> 构建FasterRCNN检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): FasterRCNN的backbone网络，取值范围为['ResNet50', 'ResNet50_vd', 'ResNet50_vd_ssld', 'ResNet34', 'ResNet34_vd', 'ResNet101', 'ResNet101_vd', 'HRNet_W18']。默认为'ResNet50'。
+> > - **with_fpn** (bool): 是否使用FPN结构。默认为True。
+> > - **aspect_ratios** (list): 生成anchor高宽比的可选值。默认为[0.5, 1.0, 2.0]。
+> > - **anchor_sizes** (list): 生成anchor大小的可选值。默认为[[32], [64], [128], [256], [512]]。
+> > - **keep_top_k** (int): RCNN部分在进行非极大值抑制计算后，每张图像保留最多保存`keep_top_k`个检测框。默认为100。
+> > - **nms_threshold** (float): RCNN部分在进行非极大值抑制时，用于剔除检测框所需的IoU阈值。当`rcnn_nms`设置为`MultiClassSoftNMS`时，`nms_threshold`的设置不生效。默认为0.5。
+> > - **score_threshold** (float): RCNN部分在进行非极大值抑制前，用于过滤掉低置信度边界框所需的置信度阈值。默认为0.05。
+> > - **fpn_num_channels** (int): FPN部分特征层的通道数量。默认为256。
+> > - **rpn_batch_size_per_im** (int): 训练阶段，RPN部分每张图片的正负样本的数量总和。默认为256。
+> > - **rpn_fg_fraction** (float): 训练阶段，RPN部分每张图片的正负样本数量总和中正样本的占比。默认为0.5。
+> > - **test_pre_nms_top_n** (int)：预测阶段，RPN部分做非极大值抑制计算的候选框的数量。若设置为None, 有FPN结构的话，`test_pre_nms_top_n`会被设置成6000, 无FPN结构的话，`test_pre_nms_top_n`会被设置成1000。默认为None。
+> > - **test_post_nms_top_n** (int): 预测阶段，RPN部分做完非极大值抑制后保留的候选框的数量。默认为1000。
+
+> - train 训练接口说明同 [PPYOLOv2模型train接口](#train)
+> - evaluate 评估接口说明同 [PPYOLOv2模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [PPYOLOv2模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [PPYOLOv2模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [PPYOLOv2模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [PPYOLOv2模型quant_aware_train接口](#quant_aware_train)

dygraph/docs/apis/models/instance_segmentation.md

@@ -0,0 +1,175 @@
+# Instance Segmentation
+
+## MaskRCNN
+
+```python
+paddlex.det.MaskRCNN(num_classes=80, backbone='ResNet50_vd', with_fpn=True, aspect_ratios=[0.5, 1.0, 2.0], anchor_sizes=[[32], [64], [128], [256], [512]], keep_top_k=100, nms_threshold=0.5, score_threshold=0.05, fpn_num_channels=256, rpn_batch_size_per_im=256, rpn_fg_fraction=0.5, test_pre_nms_top_n=None, test_post_nms_top_n=1000)
+```
+
+> 构建MaskRCNN检测器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数。默认为80。
+> > - **backbone** (str): MaskRCNN的backbone网络，取值范围为['ResNet50', 'ResNet50_vd', 'ResNet50_vd_ssld', 'ResNet101', 'ResNet101_vd']。默认为'ResNet50_vd'。
+> > - **with_fpn** (bool): 是否使用FPN结构。默认为True。
+> > - **aspect_ratios** (list): 生成anchor高宽比的可选值。默认为[0.5, 1.0, 2.0]。
+> > - **anchor_sizes** (list): 生成anchor大小的可选值。默认为[[32], [64], [128], [256], [512]]。
+> > - **keep_top_k** (int): RCNN部分在进行非极大值抑制计算后，每张图像保留最多保存`keep_top_k`个检测框。默认为100。
+> > - **nms_threshold** (float): RCNN部分在进行非极大值抑制时，用于剔除检测框所需的IoU阈值。默认为0.5。
+> > - **score_threshold** (float): RCNN部分在进行非极大值抑制前，用于过滤掉低置信度边界框所需的置信度阈值。默认为0.05。
+> > - **fpn_num_channels** (int): FPN部分特征层的通道数量。默认为256。
+> > - **rpn_batch_size_per_im** (int): 训练阶段，RPN部分每张图片的正负样本的数量总和。默认为256。
+> > - **rpn_fg_fraction** (float): 训练阶段，RPN部分每张图片的正负样本数量总和中正样本的占比。默认为0.5。
+> > - **test_pre_nms_top_n** (int)：预测阶段，RPN部分做非极大值抑制计算的候选框的数量。若设置为None, 有FPN结构的话，`test_pre_nms_top_n`会被设置成6000, 无FPN结构的话，`test_pre_nms_top_n`会被设置成1000。默认为None。
+> > - **test_post_nms_top_n** (int): 预测阶段，RPN部分做完非极大值抑制后保留的候选框的数量。默认为1000。
+
+### train
+
+```python
+train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', pretrain_weights='IMAGENET', learning_rate=.001, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(216, 243), lr_decay_gamma=0.1, metric=None, use_ema=False, early_stop=False, early_stop_patience=5, use_vdl=True)
+```
+
+> MaskRCNN模型的训练接口，函数内置了`piecewise`学习率衰减策略和`momentum`优化器。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小，默认为64。目前实例分割仅支持单卡batch大小为1进行评估，`train_batch_size`参数不影响评估时的batch大小。
+> > - **eval_dataset** (paddlex.dataset or None): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代次数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **pretrain_weights** (str or None): 若指定为'.pdparams'文件时，则从文件加载模型权重；若为字符串’IMAGENET’，则自动下载在ImageNet图片数据上预训练的模型权重（仅包含backbone网络）；若为字符串’COCO’，则自动下载在COCO数据集上预训练的模型权重；若为None，则不使用预训练模型。默认为'IMAGENET'。
+> > - **learning_rate** (float): 默认优化器的学习率。默认为0.001。
+> > - **warmup_steps** (int):  默认优化器进行warmup过程的步数。默认为0。
+> > - **warmup_start_lr** (int): 默认优化器warmup的起始学习率。默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[216, 243]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'。
+> > - **use_ema** (bool): 是否使用指数衰减计算参数的滑动平均值。默认为False。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+
+### evaluate
+
+```python
+evaluate(self, eval_dataset, batch_size=1, metric=None, return_details=False)
+```
+
+> MaskRCNN模型的评估接口，模型评估后会返回在验证集上的指标`box_map`(metric指定为'VOC'时)或`box_mmap`(metric指定为`COCO`时)。
+
+> **参数**
+>
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。
+> > - **batch_size** (int): 验证数据批大小。默认为1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'默认为None， 如为EasyData类型数据集，同时也会使用'VOC'。
+> > - **return_details** (bool): 是否返回详细信息。默认为False。
+> >
+>  **返回值**
+>
+> > - **tuple** (metrics, eval_details) | **dict** (metrics): 当`return_details`为True时，返回(metrics, eval_details)，当`return_details`为False时，返回metrics。metrics为dict，包含关键字：'bbox_mmap'或者’bbox_map‘，分别表示平均准确率平均值在各个阈值下的结果取平均值的结果（mmAP）、平均准确率平均值（mAP）。eval_details为dict，包含bbox和gt两个关键字。其中关键字bbox的键值是一个列表，列表中每个元素代表一个预测结果，一个预测结果是一个由图像id，预测框类别id, 预测框坐标，预测框得分组成的列表。而关键字gt的键值是真实标注框的相关信息。
+
+### predict
+
+```python
+predict(self, img_file, transforms=None)
+```
+
+> MaskRCNN模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`MaskRCNN.test_transforms`和`MaskRCNN.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义`test_transforms`传入给`predict`接口
+
+> **参数**
+>
+> > - **img_file** (List[np.ndarray or str], str or np.ndarray): 预测图像或包含多张预测图像的列表，预测图像可以是路径或numpy数组(HWC排列，BGR格式)。
+> > - **transforms** (paddlex.transforms): 数据预处理操作。
+>
+> **返回值**
+>
+> > - **list**: 预测结果列表。如果输入为单张图像，列表中每个元素均为一个dict，键值包括'bbox', 'category', 'category_id', 'score'，分别表示每个预测目标的框坐标信息、类别、类别id、置信度，其中框坐标信息为[xmin, ymin, w, h]，即左上角x, y坐标和框的宽和高。如果输入为多张图像，如果输入为多张图像，返回由每张图像预测结果组成的列表。
+
+### analyze_sensitivity
+
+```python
+analyze_sensitivity(self, dataset, batch_size=8, criterion='l1_norm', save_dir='output')
+```
+
+> MaskRCNN模型敏感度分析接口。
+
+> **参数**
+>
+> > - **dataset** (paddlex.dataset): 用于评估模型在不同剪裁比例下精度损失的评估数据集。
+> > - **batch_size** (int): 评估模型精度损失时的batch大小。默认为8。
+> > - **criterion** ({'l1_norm', 'fpgm'}): 进行Filter粒度剪裁时评估，评估Filter重要性的范数标准。如果为'l1_norm'，采用L1-Norm标准。如果为'fpgm'，采用 [Geometric Median](https://arxiv.org/abs/1811.00250) 标准。
+> > - **save_dir** (str): 计算的得到的sensetives文件的存储路径。
+
+### prune
+
+```python
+prune(self, pruned_flops, save_dir=None)
+```
+
+> MaskRCNN模型剪裁接口。
+
+> **参数**
+> > - **pruned_flops** (float): 每秒浮点数运算次数（FLOPs）的剪裁比例。
+> > - **save_dir** (None or str): 剪裁后模型保存路径。如果为None，剪裁完成后不会对模型进行保存。默认为None。
+
+### quant_aware_train
+
+```python
+quant_aware_train(self, num_epochs, train_dataset, train_batch_size=64, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=10, save_dir='output', learning_rate=.00001, warmup_steps=0, warmup_start_lr=0.0, lr_decay_epochs=(216, 243), lr_decay_gamma=0.1, metric=None, use_ema=False, early_stop=False, early_stop_patience=5, use_vdl=True, quant_config=None)
+```
+
+> MaskRCNN模型在线量化接口。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小。同时作为验证数据batch大小。默认为64。
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。当该参数为None时，训练过程中不会进行模型评估。默认为None。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认优化器：paddle.optimizer.lr.PiecewiseDecay衰减策略，paddle.optimizer.Momentum优化方法。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代步数）。默认为10。
+> > - **save_dir** (str): 模型保存路径。默认为'output'。
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.00001。
+> > - **warmup_steps** (int): 默认优化器的warmup步数，学习率将在设定的步数内，从warmup_start_lr线性增长至设定的learning_rate，默认为0。
+> > - **warmup_start_lr**(float): 默认优化器的warmup起始学习率，默认为0.0。
+> > - **lr_decay_epochs** (list): 默认优化器的学习率衰减轮数。默认为[216， 243]。
+> > - **lr_decay_gamma** (float): 默认优化器的学习率衰减率。默认为0.1。
+> > - **metric** ({'COCO', 'VOC', None}): 训练过程中评估的方式。默认为None，根据用户传入的Dataset自动选择，如为VOCDetection，则`metric`为'VOC'；如为COCODetection，则`metric`为'COCO'。
+> > - **use_ema** (bool): 是否使用指数衰减计算参数的滑动平均值。默认为False。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+> > - **quant_config** (None or dict): 量化器配置。如果为None，使用默认配置。如果为dict，可配置项如下：
+> >  ```python
+> >  {
+> >     # weight预处理方法，默认为None，代表不进行预处理；当需要使用`PACT`方法时设置为`"PACT"`
+> >      'weight_preprocess_type': None,
+> >
+> >     # activation预处理方法，默认为None，代表不进行预处理`
+> >     'activation_preprocess_type': None,
+> >
+> >     # weight量化方法, 默认为'channel_wise_abs_max', 此外还支持'channel_wise_abs_max'
+> >     'weight_quantize_type': 'channel_wise_abs_max',
+> >
+> >     # activation量化方法, 默认为'moving_average_abs_max', 此外还支持'abs_max'
+> >     'activation_quantize_type': 'moving_average_abs_max',
+> >
+> >     # weight量化比特数, 默认为 8
+> >     'weight_bits': 8,
+> >
+> >     # activation量化比特数, 默认为 8
+> >     'activation_bits': 8,
+> >
+> >     # 'moving_average_abs_max'的滑动平均超参, 默认为0.9
+> >     'moving_rate': 0.9,
+> >
+> >     # 需要量化的算子类型
+> >     'quantizable_layer_type': ['Conv2D', 'Linear']
+> >  }
+> >  ```

dygraph/docs/apis/models/semantic_segmentation.md

@@ -0,0 +1,240 @@
+# Semantic Segmentation
+
+## paddlex.seg.DeepLabv3p
+
+```python
+paddlex.seg.DeepLabV3P(num_classes=2, backbone='ResNet50_vd', use_mixed_loss=False, output_stride=8, backbone_indices=(0, 3), aspp_ratios=(1, 12, 24, 36), aspp_out_channels=256, align_corners=False)
+```
+
+> 构建DeepLabV3P分割器。
+
+> **参数**
+> > - **num_classes** (int): 类别数，默认为2。
+> > - **backbone** (str): DeepLabv3+的backbone网络，实现特征图的计算，取值范围为['ResNet50_vd', 'ResNet101_vd']，默认为'ResNet50_vd'。
+> > - **use_mixed_loss** (bool or List[tuple]): 是否使用混合损失函数。如果为True，混合使用CrossEntropyLoss和LovaszSoftmaxLoss，权重分别为0.8和0.2。如果为False，则仅使用CrossEntropyLoss。也可以以列表的形式自定义混合损失函数，列表的每一个元素为(损失函数类型，权重)元组，损失函数类型取值范围为['CrossEntropyLoss', 'DiceLoss', 'LovaszSoftmaxLoss']。
+> > - **output_stride** (int): backbone 输出特征图相对于输入的下采样倍数，一般取值为8或16。默认为8。
+> > - **backbone_indices** (tuple): backbone网络输出层的索引值。默认为(0, 3)。
+> > - **assp_ratios** (tuple): assp模块中空洞卷积的空洞大小。默认为(1, 12, 24, 36)。
+> > - **assp_out_channels** (int): assp模块输出通道数。默认为256。
+> > - **align_corners** (bool): 网络中对特征图进行插值时是否将四个角落像素的中心对齐。若特征图尺寸为偶数，建议设为True。若特征图尺寸为奇数，建议设为False。默认为False。
+
+### train
+
+```python
+train(num_epochs, train_dataset, train_batch_size=2, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=2, save_dir='output', pretrain_weights='CITYSCAPES', learning_rate=0.01, lr_decay_power=0.9, early_stop=False, early_stop_patience=5, use_vdl=True)
+```
+
+> DeepLabV3P模型的训练接口，函数内置了`polynomial`学习率衰减策略和`momentum`优化器。
+
+> **参数**
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小，默认为2。目前语义分割仅支持每张卡上batch大小为1进行评估，`train_batch_size`参数不影响评估时的batch大小。
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认的优化器：使用paddle.optimizer.Momentum优化方法，paddle.optimizer.lr.PolynomialDecay学习率衰减策略。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代次数）。默认为2。
+> > - **save_dir** (str): 模型保存路径。默认'output'
+> > - **pretrain_weights** (str): 若指定为'.pdparams'文件时，则从文件加载模型权重；若为字符串'CITYSCAPES'，则自动下载在CITYSCAPES图片数据上预训练的模型权重；若为字符串'PascalVOC'，则自动下载在PascalVOC图片数据上预训练的模型权重；若为字符串'IMAGENET'，则自动下载在ImageNet图片数据上预训练的模型权重；若为None，则不使用预训练模型。默认为'CITYSCAPES'。
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.01。
+> > - **lr_decay_power** (float): 默认优化器学习率衰减指数。默认为0.9。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+
+### evaluate
+
+```python
+evaluate(self, eval_dataset, batch_size=1, return_details=False):
+```
+
+> DeepLabV3P模型评估接口。
+
+>  **参数**
+> > - **eval_dataset** (paddlex.datasets): 评估数据集。
+> > - **batch_size** (int): 评估时的batch大小。默认1。
+> > - **return_details** (bool): 是否返回详细信息。默认False。
+
+> **返回值**
+> >
+> > - **tuple** (metrics, eval_details) | **dict** (metrics): 当`return_details`为True时，返回(metrics, eval_details)，当`return_details`为False时，返回metrics。metrics为dict，包含关键字：'miou'、'category_iou'、'oacc'、'category_acc'和'kappa'，分别表示平均IoU、各类别IoU、总体准确率、各类别准确率和kappa系数。eval_details为dict，包含关键字：'confusion_matrix'，表示评估的混淆矩阵。
+
+### predict
+
+```
+predict(self, img_file, transforms=None):
+```
+
+> DeepLabV3P模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`DeepLabv3p.test_transforms`和`DeepLabv3p.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
+
+> **参数**
+> >
+> > - **img_file** (List[np.ndarray or str], str or np.ndarray): 预测图像或包含多张预测图像的列表，预测图像可以是路径或numpy数组(HWC排列，BGR格式)。
+> > - **transforms** (paddlex.seg.transforms): 数据预处理操作。
+
+> **返回值**
+> >
+> > - **dict** ｜ **List[dict]**: 如果输入为单张图像，返回dict。包含关键字'label_map'和'score_map', 'label_map'存储预测结果灰度图，像素值表示对应的类别，'score_map'存储各类别的概率，shape=(h, w, num_classes)。如果输入为多张图像，返回由每张图像预测结果组成的列表。
+
+```python
+analyze_sensitivity(self, dataset, batch_size=8, criterion='l1_norm', save_dir='output')
+```
+
+> DeepLabV3P模型敏感度分析接口。
+
+> **参数**
+>
+> > - **dataset** (paddlex.dataset): 用于评估模型在不同剪裁比例下精度损失的评估数据集。
+> > - **batch_size** (int): 评估模型精度损失时的batch大小。默认为8。
+> > - **criterion** ({'l1_norm', 'fpgm'}): 进行Filter粒度剪裁时评估，评估Filter重要性的范数标准。如果为'l1_norm'，采用L1-Norm标准。如果为'fpgm'，采用 [Geometric Median](https://arxiv.org/abs/1811.00250) 标准。
+> > - **save_dir** (str): 计算的得到的sensetives文件的存储路径。
+
+### prune
+
+```python
+prune(self, pruned_flops, save_dir=None)
+```
+
+> DeepLabV3P模型剪裁接口。
+
+> **参数**
+> > - **pruned_flops** (float): 每秒浮点数运算次数（FLOPs）的剪裁比例。
+> > - **save_dir** (None or str): 剪裁后模型保存路径。如果为None，剪裁完成后不会对模型进行保存。默认为None。
+
+### quant_aware_train
+
+```python
+quant_aware_train(self, num_epochs, train_dataset, train_batch_size=2, eval_dataset=None, optimizer=None, save_interval_epochs=1, log_interval_steps=2, save_dir='output', learning_rate=.0001, lr_decay_power=0.9, early_stop=False, early_stop_patience=5, use_vdl=True, quant_config=None)
+```
+
+> DeepLabV3P模型在线量化接口。
+
+> **参数**
+>
+> > - **num_epochs** (int): 训练迭代轮数。
+> > - **train_dataset** (paddlex.dataset): 训练数据集。
+> > - **train_batch_size** (int): 训练数据batch大小。同时作为验证数据batch大小。默认为2。
+> > - **eval_dataset** (paddlex.dataset): 评估数据集。
+> > - **optimizer** (paddle.optimizer.Optimizer): 优化器。当该参数为None时，使用默认的优化器：使用paddle.optimizer.Momentum优化方法，paddle.optimizer.lr.PolynomialDecay学习率衰减策略。
+> > - **save_interval_epochs** (int): 模型保存间隔（单位：迭代轮数）。默认为1。
+> > - **log_interval_steps** (int): 训练日志输出间隔（单位：迭代次数）。默认为2。
+> > - **save_dir** (str): 模型保存路径。默认'output'
+> > - **learning_rate** (float): 默认优化器的初始学习率。默认为0.0001。
+> > - **lr_decay_power** (float): 默认优化器学习率衰减指数。默认为0.9。
+> > - **early_stop** (bool): 是否使用提前终止训练策略。默认为False。
+> > - **early_stop_patience** (int): 当使用提前终止训练策略时，如果验证集精度在`early_stop_patience`个epoch内连续下降或持平，则终止训练。默认为5。
+> > - **use_vdl** (bool): 是否使用VisualDL进行可视化。默认为True。
+> > - **quant_config** (None or dict): 量化器配置。如果为None，使用默认配置。如果为dict，可配置项如下：
+> >  ```python
+> >  {
+> >     # weight预处理方法，默认为None，代表不进行预处理；当需要使用`PACT`方法时设置为`"PACT"`
+> >      'weight_preprocess_type': None,
+> >
+> >     # activation预处理方法，默认为None，代表不进行预处理`
+> >     'activation_preprocess_type': None,
+> >
+> >     # weight量化方法, 默认为'channel_wise_abs_max', 此外还支持'channel_wise_abs_max'
+> >     'weight_quantize_type': 'channel_wise_abs_max',
+> >
+> >     # activation量化方法, 默认为'moving_average_abs_max', 此外还支持'abs_max'
+> >     'activation_quantize_type': 'moving_average_abs_max',
+> >
+> >     # weight量化比特数, 默认为 8
+> >     'weight_bits': 8,
+> >
+> >     # activation量化比特数, 默认为 8
+> >     'activation_bits': 8,
+> >
+> >     # 'moving_average_abs_max'的滑动平均超参, 默认为0.9
+> >     'moving_rate': 0.9,
+> >
+> >     # 需要量化的算子类型
+> >     'quantizable_layer_type': ['Conv2D', 'Linear']
+> >  }
+> >  ```
+
+## paddlex.seg.BiSeNetV2
+
+```python
+paddlex.seg.BiSeNetV2(num_classes=2, use_mixed_loss=False, align_corners=False)
+```
+
+> 构建BiSeNetV2分割器
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数，默认为2。
+> > - **use_mixed_loss** (bool or List[tuple]): 是否使用混合损失函数。如果为True，混合使用CrossEntropyLoss和LovaszSoftmaxLoss，权重分别为0.8和0.2。如果为False，则仅使用CrossEntropyLoss。也可以以列表的形式自定义混合损失函数，列表的每一个元素为(损失函数类型，权重)元组，损失函数类型取值范围为['CrossEntropyLoss', 'DiceLoss', 'LovaszSoftmaxLoss']。
+> > - **align_corners** (bool): 网络中对特征图进行插值时是否将四个角落像素的中心对齐。若特征图尺寸为偶数，建议设为True。若特征图尺寸为奇数，建议设为False。默认为False。
+
+> - train 训练接口说明同 [DeepLabV3P模型train接口](#train)（`pretrain_weights`取值范围为['CITYSCAPES', None]）
+> - evaluate 评估接口说明同 [DeepLabV3P模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [DeepLabV3P模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [DeepLabV3P模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [DeepLabV3P模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [DeepLabV3P模型quant_aware_train接口](#quant_aware_train)
+
+## paddlex.seg.UNet
+
+```python
+paddlex.seg.UNet(num_classes=2, use_mixed_loss=False, use_deconv=False, align_corners=False)
+```
+
+> 构建UNet分割器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数，默认为2。
+> > - **use_mixed_loss** (bool or List[tuple]): 是否使用混合损失函数。如果为True，混合使用CrossEntropyLoss和LovaszSoftmaxLoss，权重分别为0.8和0.2。如果为False，则仅使用CrossEntropyLoss。也可以以列表的形式自定义混合损失函数，列表的每一个元素为(损失函数类型，权重)元组，损失函数类型取值范围为['CrossEntropyLoss', 'DiceLoss', 'LovaszSoftmaxLoss']。
+> > - **use_deconv** (bool): 在上采样过程中是否使用反卷积操作。如果为True，使用反卷积进行上采样。如果为False，使用双线性插值方法进行上采样。默认为False。
+> > - **align_corners** (bool): 网络中对特征图进行插值时是否将四个角落像素的中心对齐。若特征图尺寸为偶数，建议设为True。若特征图尺寸为奇数，建议设为False。默认为False。
+
+> - train 训练接口说明同 [DeepLabV3P模型train接口](#train)（`pretrain_weights`取值范围为['CITYSCAPES', None]）
+> - evaluate 评估接口说明同 [DeepLabV3P模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [DeepLabV3P模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [DeepLabV3P模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [DeepLabV3P模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [DeepLabV3P模型quant_aware_train接口](#quant_aware_train)
+
+## paddlex.seg.HRNet
+
+```python
+paddlex.seg.HRNet(num_classes=2, width=48, use_mixed_loss=False, align_corners=False)
+```
+
+> 构建HRNet分割器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数，默认为2。
+> > - **width** (int|str): 高分辨率分支中特征层的通道数量。默认为48。可选择取值为[18, 48]。
+> > - **use_mixed_loss** (bool or List[tuple]): 是否使用混合损失函数。如果为True，混合使用CrossEntropyLoss和LovaszSoftmaxLoss，权重分别为0.8和0.2。如果为False，则仅使用CrossEntropyLoss。也可以以列表的形式自定义混合损失函数，列表的每一个元素为(损失函数类型，权重)元组，损失函数类型取值范围为['CrossEntropyLoss', 'DiceLoss', 'LovaszSoftmaxLoss']。
+> > - **align_corners** (bool): 网络中对特征图进行插值时是否将四个角落像素的中心对齐。若特征图尺寸为偶数，建议设为True。若特征图尺寸为奇数，建议设为False。默认为False。
+
+> - train 训练接口说明同 [DeepLabV3P模型train接口](#train)（`pretrain_weights`取值范围为['CITYSCAPES', 'PascalVOC', None]）
+> - evaluate 评估接口说明同 [DeepLabV3P模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [DeepLabV3P模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [DeepLabV3P模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [DeepLabV3P模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [DeepLabV3P模型quant_aware_train接口](#quant_aware_train)
+
+## paddlex.seg.FastSCNN
+
+```python
+paddlex.seg.FastSCNN(num_classes=2, use_mixed_loss=False, align_corners=False)
+```
+
+> 构建FastSCNN分割器。
+
+> **参数**
+>
+> > - **num_classes** (int): 类别数，默认为2。
+> > - **use_mixed_loss** (bool or List[tuple]): 是否使用混合损失函数。如果为True，混合使用CrossEntropyLoss和LovaszSoftmaxLoss，权重分别为0.8和0.2。如果为False，则仅使用CrossEntropyLoss。也可以以列表的形式自定义混合损失函数，列表的每一个元素为(损失函数类型，权重)元组，损失函数类型取值范围为['CrossEntropyLoss', 'DiceLoss', 'LovaszSoftmaxLoss']。
+> > - **align_corners** (bool): 网络中对特征图进行插值时是否将四个角落像素的中心对齐。若特征图尺寸为偶数，建议设为True。若特征图尺寸为奇数，建议设为False。默认为False。
+
+> - train 训练接口说明同 [DeepLabV3P模型train接口](#train)（`pretrain_weights`取值范围为['CITYSCAPES', None]）
+> - evaluate 评估接口说明同 [DeepLabV3P模型evaluate接口](#evaluate)
+> - predict 预测接口说明同 [DeepLabV3P模型predict接口](#predict)
+> - analyze_sensitivity 敏感度分析接口说明同 [DeepLabV3P模型analyze_sensivity接口](#analyze_sensitivity)
+> - prune 剪裁接口说明同 [DeepLabV3P模型prune接口](#prune)
+> - quant_aware_train 在线量化接口说明同 [DeepLabV3P模型quant_aware_train接口](#quant_aware_train)

dygraph/docs/apis/transforms/transforms.md

@@ -0,0 +1,253 @@
+# paddlex.transforms
+
+对图像分类、语义分割、目标检测、实例分割任务的数据进行操作。可以利用[Compose](#compose)类将图像预处理/增强操作进行组合。
+
+## 目录
+
+* [Compose](#1)
+* [Normalize](#2)
+* [Resize](#3)
+* [RandomResize](#4)
+* [ResizeByShort](#5)
+* [RandomResizeByShort](#6)
+* [ResizeByLong](#7)
+* [RandomHorizontalFlip](#8)
+* [RandomVerticalFlip](#9)
+* [CenterCrop](#10)
+* [RandomCrop](#11)
+* [RandomScaleAspect](#12)
+* [RandomExpand](#13)
+* [Padding](#14)
+* [MixupImage](#15)
+* [RandomDistort](#16)
+* [RandomBlur](#17)
+
+## <h2 id="1">Compose</h2>
+```python
+paddlex.transforms.Compose(transforms)
+```
+
+根据数据预处理/增强算子对输入数据进行操作。  [使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/dygraph/tutorials/train/image_classification/mobilenetv3_small.py#L10)
+
+> **参数**
+> * **transforms** (List[paddlex.transforms.Transform]): 数据预处理/数据增强列表。
+
+## <h2 id="2">Normalize</h2>
+```python
+paddlex.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], min_val=[0, 0, 0], max_val=[255., 255., 255.], is_scale=True)
+```
+对图像进行标准化。
+
+1. 像素值减去min_val
+2. 像素值除以(max_val-min_val), 归一化到区间 [0.0, 1.0]。
+3. 对图像进行减均值除以标准差操作。
+
+> **参数**
+> * **mean** (list): 图像数据集的均值。默认为[0.485, 0.456, 0.406]。长度应与图像通道数量相同。
+> * **std** (list): 图像数据集的标准差。默认为[0.229, 0.224, 0.225]。长度应与图像通道数量相同。
+> * **min_val** (list): 图像数据集的最小值。默认值[0, 0, 0]。长度应与图像通道数量相同。
+> * **max_val** (list): 图像数据集的最大值。默认值[255.0, 255.0, 255.0]。长度应与图像通道数量相同。
+> * **is_scale** (bool): 是否将图片像素值除以255。默认为True。
+
+## <h2 id="3">Resize</h2>
+```python
+paddlex.transfroms.Resize(target_size, interp='LINEAR', keep_ratio=False)
+```
+调整图像大小。
+
+> **参数**
+> * **target_size** (int, List[int] or Tuple[int]): 目标尺寸。如果为int，图像的高和宽共用同一目标尺寸。如果为List[int]或Tuple[int]，长度须为2，分别代表图像的目标高度和目标宽度。
+> * **interp** (str): 调整图像尺寸时使用的插值方法。取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为'LINEAR'。
+> * **keep_ratio** (bool): 是否保留图像的原始高宽比。默认为False。
+
+## <h2 id="4">RandomResize</h2>
+```python
+paddlex.transfroms.RandomResize(target_sizes, interp='LINEAR')
+```
+随机选取目标尺寸调整图像大小。
+
+> **参数**
+> * **target_sizes** (List[int], List[list or tuple] or Tuple[list or tuple]): 备选目标尺寸列表，每张图像会从中随机选取目标尺寸值。如果为List[int]，图像的高和宽共用同一目标尺寸。如果为List[list or tuple]或Tuple[list or tuple]，每一个元素长度须为2，分别代表图像的目标高度和目标宽度。
+> * **interp** (str): 调整图像尺寸时使用的插值方法。取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为'LINEAR'。
+
+## <h2 id="5">ResizeByShort</h2>
+```python
+paddlex.transforms.ResizeByShort(short_size=256, max_size=-1, interp='LINEAR')
+```
+
+根据图像的短边调整图像大小。  
+1. 获取图像的长边和短边长度。  
+2. 根据短边与short_size的比例，计算长边的目标长度，此时高、宽的缩放比例为short_size/原图短边长度。  
+3. 如果max_size>0，调整resize比例：
+   如果长边的目标长度>max_size，则高、宽的缩放比例为max_size/原图长边长度。
+4. 根据高、宽的缩放比例调整图像尺寸。
+
+> **参数**
+> * **short_size** (int): 调整大小后的图像目标短边长度。默认为256。
+> * **max_size** (int): 长边目标长度的最大限制。默认为-1。
+> * **interp** (str): 调整图像尺寸时使用的插值方法。取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为'LINEAR'。
+
+## <h2 id="6">RandomResizeByShort</h2>
+```python
+paddlex.transforms.RandomResizeByShort(short_sizes, max_size=-1, interp='LINEAR')
+```
+随机选取目标尺寸，根据图像的短边调整图像大小。
+> **参数**
+> * **short_size** (List[int]): 调整大小后的图像目标短边长度备选值列表，每张图像会从中随机选取目标尺寸值。
+> * **max_size** (int): 长边目标长度的最大限制。默认为-1。
+> * **interp** (str): 调整图像尺寸时使用的插值方法。取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为'LINEAR'。
+
+## <h2 id="7">ResizeByLong</h2>
+
+```python
+paddlex.transforms.ResizeByLong(long_size=256, interp='LINEAR')
+```
+图像长边调整到固定值，短边按比例进行缩放。
+> **参数**
+> * **long_size** (int): 调整大小后图像的长边长度。
+> * **interp** (str): 调整图像尺寸时使用的插值方法。取值范围为['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']。默认为'LINEAR'。
+
+## <h2 id="8">RandomHorizontalFlip</h2>
+```python
+paddlex.cls.transforms.RandomHorizontalFlip(prob=0.5)
+```
+以一定的概率对图像进行随机水平翻转，模型训练时的数据增强操作。
+> **参数**
+> * **prob** (float): 随机水平翻转的概率。默认为0.5。
+
+## <h2 id="9">RandomVerticalFlip</h2>
+```python
+paddlex.cls.transforms.RandomVerticalFlip(prob=0.5)
+```
+以一定的概率对图像进行随机垂直翻转，模型训练时的数据增强操作。
+> **参数**
+> * **prob** (float): 随机垂直翻转的概率。默认为0.5。
+
+## <h2 id="10">CenterCrop</h2>
+```python
+paddlex.transforms.CenterCrop(crop_size=224)
+```
+以图像中心点扩散裁剪长宽为目标尺寸的正方形  
+1. 计算剪裁的起始点。  
+2. 剪裁图像。
+> **参数**
+> * **crop_size** (int): 裁剪的目标边长。默认为224。
+
+## <h2 id="11">RandomCrop</h2>
+```python
+paddlex.transforms.RandomCrop(crop_size=None, aspect_ratio=[.5, 2.], thresholds=[.0, .1, .3, .5, .7, .9], scaling=[.3, 1.], num_attempts=50, allow_no_crop=True, cover_all_box=False)
+```
+随机裁剪图像，模型训练时的数据增强操作。
+
+如果为检测或实例分割任务，操作步骤如下：
+1. 若`allow_no_crop`为True，则在`thresholds`加入’no_crop’。
+2. 随机打乱`thresholds`。
+3. 遍历`thresholds`中各元素（thresh）：
+   1. 如果当前thresh为’no_crop’，则返回原始图像和标注信息。
+   2. 随机取出`aspect_ratio`和`scaling`中的值并由此计算出候选裁剪区域的高、宽、起始点。
+   3. 计算真实标注框与候选裁剪区域IoU，若全部真实标注框的IoU都小于thresh，则继续第3步。
+   4. 如果`cover_all_box`为True且存在真实标注框的IoU小于thresh，则继续第3步。
+   5. 筛选出位于候选裁剪区域内的真实标注框，若有效框的个数为0，则继续第3步，否则进行第4步。
+4. 换算有效真值标注框相对候选裁剪区域的位置坐标。
+5. 换算有效分割区域相对候选裁剪区域的位置坐标。
+
+对于其他任务，随机取出`aspect_ratio`和`scaling`中的值并由此计算出候选裁剪区域的高、宽、起始点对图像进行裁切。
+> **参数**
+> * **crop_size** (int, List[int], Tuple[int] or None): 随机裁剪后重新调整的目标尺寸。如果为None，裁剪后不会对图像尺寸进行调整。默认为None。
+> * **aspect_ratio** (List(float)): 裁剪后高宽比的取值范围，以[min, max]形式表示。默认值为[.5, 2.]。
+> * **thresholds** (List(float)): 判断裁剪候选区域是否有效所需的IoU阈值取值列表。该参数仅在检测和实例分割任务中有效。默认值为[.0, .1, .3, .5, .7, .9]。
+> * **scaling** (List(float)): 裁剪面积相对原面积的取值范围，以[min, max]形式表示。默认值为[.3, 1.]。
+> * **num_attempts** (int): 在放弃寻找有效裁剪区域前尝试的次数。默认值为50。
+> * **allow_no_crop** (bool): 是否允许未进行裁剪。该参数仅在检测和实例分割任务中有效。默认值为True。
+> * **cover_all_box** (bool): 是否要求所有的真实标注框都必须在裁剪区域内。该参数仅在检测和实例分割任务中有效。默认值为False。
+
+## <h2 id="12">RandomScaleAspect</h2>
+```python
+paddlex.transforms.RandomScaleAspect(min_scale=0.5, aspect_ratio=0.33)
+```
+按照一定的面积比和高宽比对图像进行裁剪，并调整回图像原始尺寸。
+> **参数**
+> * **min_scale**  (float)：裁取图像占原始图像的面积比，取值[0，1]，为0时则返回原图。默认为0.5。
+> * **aspect_ratio** (float): 裁取图像的高宽比范围，非负值，为0时返回原图。默认为0.33。
+
+## <h2 id="13">RandomExpand</h2>
+```python
+paddlex.transforms.RandomExpand(upper_ratio=4., prob=.5, im_padding_value=(127.5, 127.5, 127.5), label_padding_value=255)
+```
+随机扩张图像，模型训练时的数据增强操作。
+1. 随机选取扩张比例（扩张比例大于1时才进行扩张）。
+2. 计算扩张后图像大小。
+3. 初始化像素值为输入填充值的图像，并将原图像随机粘贴于该图像上。
+
+> **参数**
+> * **upper_ratio** (float): 图像扩张的最大比例。默认为4.0。
+> * **prob** (float): 随机扩张的概率。默认为0.5。
+> * **im_padding_value** (list): 扩张图像的初始填充值（0-255）。默认为[127.5, 127.5, 127.5]。
+> * **label_padding_value** (int): 扩张标注的填充值。该参数仅在分割任务中有效。默认为255。
+
+【注意】该数据增强必须在数据增强Resize、ResizeByShort之前使用。
+
+## <h2 id="14">Padding</h2>
+```python
+paddlex.transforms.Padding(target_size=None, pad_mode=0, offsets=None, im_padding_value=(127.5, 127.5, 127.5), label_padding_value=255, size_divisor=32)
+```
+使用指定像素值对图像进行填充。
+> **参数**
+> * **target_size** (int, List[int], Tuple[int] or None): 填充后的目标尺寸。如果为int，填充后的高和宽均为`target_size`。如果为List[int]或Tuple[int]，长度须为2，分别表示填充后图像的高度和宽度。如果为None，则将图像的高和宽均调整到最近的`size_divisor`的倍数。默认为None。
+> * **pad_model** (int): 填充使用的模式，取值范围为[-1, 0, 1, 2]。如果为-1，根据指定的`offsets`进行填充；如果为0，仅向原始图像右下方进行填充；如果为1，向原始图像四个方向均匀填充；如果为2，仅向原始图像左上方进行填充。默认为0。
+> * **offsets** (List[int] or None): 填充后原始图像左上角坐标值，长度须为2，分别代表左侧填充宽度和上方填充宽度（右侧填充宽度和下方填充宽度会根据指定的`target_size`进行计算）。该参数仅在pad_mode为-1是有效。
+> * **im_padding_value** (List[float]): 图像填充的值。长度须与图像通道数量相同，代表每个通道的填充值。默认为[127.5, 127.5, 127.5]。
+> * **label_padding_value** (int): 标注图像padding的值。默认值为255（仅在训练时需要设定该参数）。该参数仅在分割任务中有效。
+> * **size_divisor** (int): 如果`target_size`为None，将图像的高和宽均调整到最近的`size_divisor`的倍数。
+
+## <h2 id="15">MixupImage</h2>
+```python
+paddlex.transforms.MixupImage(alpha=1.5, beta=1.5, mixup_epoch=-1)
+```
+对图像进行 [mixup](https://arxiv.org/abs/1710.09412) 操作，模型训练时的数据增强操作。
+
+操作步骤如下：
+1. 从数据集中随机选取一张图像。
+2. 从随机beta分布中抽取出随机因子factor。
+3. 根据不同情况进行处理：
+   * 当factor>=1.0时，返回当前图像。
+   * 当factor<=0.0时，返回随机选取到的图像。
+   * 其余情况，执行下述操作：  
+     （1）原图像乘以factor，mixup图像乘以(1-factor)，叠加2个结果。  
+     （2）拼接原图像标注框和mixup图像标注框。  
+     （3）拼接原图像标注框类别和mixup图像标注框类别。  
+     （4）原图像标注框混合得分乘以factor，mixup图像标注框混合得分乘以(1-factor)，叠加2个结果。
+
+> **参数**
+> * **alpha** (float): 随机beta分布的下限。默认为1.5。
+> * **beta** (float): 随机beta分布的上限。默认为1.5。
+> * **mixup_epoch** (int): 在前mixup_epoch轮使用mixup增强操作；当该参数为-1时，该策略会在整个训练过程生效。默认为-1。
+
+## <h2 id="16">RandomDistort</h2>
+```python
+paddlex.transforms.RandomDistort(brightness_range=0.5, brightness_prob=0.5, contrast_range=0.5, contrast_prob=0.5, saturation_range=0.5, saturation_prob=0.5, hue_range=18, hue_prob=0.5, random_apply=True, count=4, shuffle_channel=False)```
+```
+以一定的概率对图像进行随机像素内容变换，可包括亮度、对比度、饱和度、色相角度、通道顺序的调整，模型训练时的数据增强操作。
+
+【注意】如果输入是uint8/uint16的RGB图像，该数据增强必须在数据增强Normalize之前使用。
+
+> **参数**
+> * **brightness_range** (float): 明亮度的缩放系数范围。从[1-`brightness_range`, 1+`brightness_range`]中随机取值作为明亮度缩放因子`scale`，按照公式`image = image * scale`调整图像明亮度。默认值为0.9。
+> * **brightness_prob** (float): 随机调整明亮度的概率。默认为0.5。
+> * **contrast_range** (float): 对比度的缩放系数范围。从[1-`contrast_range`, 1+`contrast_range`]中随机取值作为对比度缩放因子`scale`，按照公式`image = image * scale + (image_mean + 0.5) * (1 - scale)`调整图像对比度。默认为0.9。
+> * **contrast_prob** (float): 随机调整对比度的概率。默认为0.5。
+> * **saturation_range** (float): 饱和度的缩放系数范围。从[1-`saturation_range`, 1+`saturation_range`]中随机取值作为饱和度缩放因子`scale`，按照公式`image = gray * (1 - scale) + image * scale`，其中`gray = R * 299/1000 + G * 587/1000+ B * 114/1000`。默认为0.9。
+> * **saturation_prob** (float): 随机调整饱和度的概率。默认为0.5。
+> * **hue_range** (int): 调整色相角度的差值取值范围。从[-`hue_range`, `hue_range`]中随机取值作为色相角度调整差值`delta`，按照公式`hue = hue + delta`调整色相角度 。默认为18，取值范围[0, 360]。
+> * **hue_prob** (float): 随机调整色调的概率。默认为0.5。
+> * **random_apply** (bool): 是否采用随机顺序进行系列变换。如果为True，从亮度、对比度、饱和度、色相角度中随机选取`count`个，并按照随机顺序进行调整。如果为False，按照亮度、对比度、饱和度、色相角度或按照亮度、饱和度、色相角度、对比度的顺序依次进行调整，两种顺序的概率均为0.5。
+> * **count** (int): 当`random_apply`为True时，选取的像素变换种类个数。默认为4。
+> * **shuffle_channel** (bool): 是否随机调整通道顺序。默认为False。
+
+## <h2 id="17">RandomBlur</h2>
+```python
+paddlex.transforms.RandomBlur(prob=0.1)
+```
+以一定的概率对图像进行高斯模糊，模型训练时的数据增强操作。
+> **参数**
+> * **prob** (float): 图像模糊概率。默认为0.1。

dygraph/docs/data/README.md

@@ -0,0 +1,27 @@
+# 数据准备
+
+因PaddleX对数据集的格式做了规定，使用LabelMe标注完数据后，需要将LabelMe的标注协议转换成PaddleX要求的格式。此外，PaddleX也支持精灵标注助手的协议转换。
+
+在完成标注协议转换后，还需要将数据集划分出训练集和验证集用于模型的训练和精度验证。
+
+通过执行以下步骤完成数据的准备：
+
+### [1 数据格式说明](format/README.md)
+
+点击文档[数据格式说明](format/README.md)查看PaddleX对数据集格式的要求。
+
+### [2 标注工具LabelMe的安装和启动](./annotation/labelme.md)
+
+参考文档[标注工具LabelMe的安装和启动](./annotation/labelme.md)安装标注工具。
+
+### [3 数据标注](./annotation/README.md)
+
+文档[数据标注](./annotation/README.md)示例了使用标注工具完成标注的步骤，并将各步骤以图片展示。
+
+### [4 数据格式转换](./convert.md)
+
+参考文档[数据格式转换](./convert.md)将标注工具的标注协议转换成PaddleX要求的格式。
+
+### [5 数据划分](./split.md)
+
+点击文档[数据划分](./split.md)将数据集划分成训练集、验证集和测试集（可选），用于模型的训练和精度验证。

dygraph/docs/data/annotation/README.md

@@ -0,0 +1,43 @@
+# 数据标注
+
+## 手机拍照图片旋转
+
+当您收集的样本图像来源于手机拍照时，请注意由于手机拍照信息内附带水平垂直方向信息，这可能会使得在标注和训练时出现问题，因此在拍完照后注意根据方向对照片进行处理，使用如下函数即可解决
+```
+from PIL import Image, ExifTags
+def rotate(im):
+    try:
+        for orientation in ExifTags.TAGS.keys():
+            if ExifTags.TAGS[orientation] == 'Orientation':
+                break
+        exif = dict(im._getexif().items())
+        if exif[orientation] == 3:
+            im = im.rotate(180, expand=True)
+        if exif[orientation] == 6:
+            im = im.rotate(270, expand=True)
+        if exif[orientation] == 8:
+            im = im.rotate(90, expand=True)
+    except:
+        pass
+
+img_file = '1.jpeg'
+im = Image.open(img_file)
+rotate(im)
+im.save('new_1.jpeg')
+```
+
+## 图像分类数据标注
+
+详见文档[图像分类数据标注](classification.md)
+
+## 目标检测数据标注
+
+详见文档[目标检测数据标注](object_detection.md)
+
+## 实例分割数据标注
+
+详见文档[实例分割数据标注](instance_segmentation.md)
+
+## 语义分割数据标注
+
+详见文档[语义分割数据标注](semantic_segmentation.md)

dygraph/docs/data/annotation/classification.md

@@ -0,0 +1,23 @@
+# 图像分数据标注
+
+图像分类标注是一项最基础，最简单的标注任务，图像分类无需标注工具，只需将属于同一类的图片放在同一个文件夹下即可，例如下所示目录结构，
+```
+MyDataset/ # 图像分类数据集根目录
+|--dog/ # 当前文件夹所有图片属于dog类别
+|  |--d1.jpg
+|  |--d2.jpg
+|  |--...
+|  |--...
+|
+|--...
+|
+|--snake/ # 当前文件夹所有图片属于snake类别
+|  |--s1.jpg
+|  |--s2.jpg
+|  |--...
+|  |--...
+```
+
+## 数据划分
+
+参考文档[数据划分](../split.md)完成训练集和验证集的划分，用于模型训练和精度验证。

dygraph/docs/data/annotation/instance_segmentation.md

@@ -0,0 +1,32 @@
+# 实例分割数据标注
+
+实例分割数据的标注推荐使用LabelMe标注工具，如您先前并无安装，那么LabelMe的安装可参考[LabelMe安装和启动](labelme.md)
+
+**注意：LabelMe对于中文支持不够友好，因此请不要在如下的路径以及文件名中出现中文字符!**
+
+## 准备工作  
+
+1. 将收集的图像存放于`JPEGImages`文件夹下，例如存储在`D:\MyDataset\JPEGImages`
+2. 创建与图像文件夹相对应的文件夹`Annotations`，用于存储标注的json文件，如`D:MyDataset\Annotations`
+3. 打开LabelMe，点击”Open Dir“按钮，选择需要标注的图像所在的文件夹打开，则”File List“对话框中会显示所有图像所对应的绝对路径，接着便可以开始遍历每张图像，进行标注工作  
+
+## 目标边缘标注  
+
+1. 打开多边形标注工具（右键菜单->Create Polygon)以打点的方式圈出目标的轮廓，并在弹出的对话框中写明对应label（当label已存在时点击即可，此处请注意label勿使用中文），具体如下提所示，当框标注错误时，可点击左侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。
+![](./pics/detection2.png)
+
+2. 点击右侧”Save“，将标注结果保存到中创建的文件夹Annotations目录中
+
+## 格式转换
+
+LabelMe标注后的数据还需要进行转换为MSCOCO格式，才可以用于实例分割任务的训练，创建保存目录`D:\dataset_seg`，在python环境中安装paddlex后，使用如下命令即可
+```
+paddlex --data_conversion --source labelme --to MSCOCO \
+        --pics D:\MyDataset\JPEGImages \
+        --annotations D:\MyDataset\Annotations \
+        --save_dir D:\dataset_coco
+```
+
+## 数据集划分
+
+参考文档[数据划分](../split.md)完成训练集和验证集的划分，用于模型训练和精度验证。

dygraph/docs/data/annotation/labelme.md

@@ -0,0 +1,26 @@
+# 标注工具LabelMe的安装和启动
+
+LabelMe可用于标注目标检测、实例分割、语义分割数据集，是一款开源的标注工具。
+
+## 1. 安装Anaconda
+
+推荐使用Anaconda安装python依赖，有经验的开发者可以跳过此步骤。安装Anaconda的方式可以参考[文档](../../../../docs/appendix/anaconda_install.md)。
+
+在安装Anaconda，并创建环境之后，再进行接下来的步骤
+
+## 2. 安装LabelMe
+
+进入Python环境后，执行如下命令即可
+```
+conda activate my_paddlex
+conda install pyqt
+pip install labelme
+```
+
+## 3. 启动LabelMe
+
+进入安装了LabelMe的Python环境，执行如下命令即可启动LabelMe
+```
+conda activate my_paddlex
+labelme
+```

dygraph/docs/data/annotation/object_detection.md

@@ -0,0 +1,37 @@
+# 目标检测数据标注
+
+目标检测数据的标注推荐使用LabelMe标注工具，如您先前并无安装，那么LabelMe的安装可参考[LabelMe安装和启动](labelme.md)
+
+**注意：LabelMe对于中文支持不够友好，因此请不要在如下的路径以及文件名中出现中文字符!**
+
+## 准备工作  
+
+1. 将收集的图像存放于`JPEGImages`文件夹下，例如存储在`D:\MyDataset\JPEGImages`
+2. 创建与图像文件夹相对应的文件夹`Annotations`，用于存储标注的json文件，如`D:MyDataset\Annotations`
+3. 打开LabelMe，点击”Open Dir“按钮，选择需要标注的图像所在的文件夹打开，则”File List“对话框中会显示所有图像所对应的绝对路径，接着便可以开始遍历每张图像，进行标注工作  
+
+## 目标框标注  
+
+1. 打开矩形框标注工具(右键菜单->Create Rectangle)，具体如下图所示  
+![](./pics/detection1.png)
+
+2. 使用拖拉的方式对目标物体进行标识，并在弹出的对话框中写明对应label（当label已存在时点击即可, 此处请注意label勿使用中文），具体如下图所示，当框标注错误时，可点击左侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。  
+![](./pics/detection3.png)
+
+3. 点击右侧”Save“，将标注结果保存到中创建的文件夹Annotations目录中
+
+## 格式转换
+
+LabelMe标注后的数据还需要进行转换为PascalVOC或MSCOCO格式，才可以用于目标检测任务的训练，创建`D:\dataset_voc`目录，在python环境中安装paddlex后，使用如下命令即可
+```
+paddlex --data_conversion --source labelme --to PascalVOC \
+        --pics D:\MyDataset\JPEGImages \
+        --annotations D:\MyDataset\Annotations \
+        --save_dir D:\dataset_voc
+```
+
+> 注：此文档中以LabelMe为示例，展示了格式转换，如您使用的是数据标注精灵工具，则可在标注完后，选择直接保存为PascalVOC格式
+
+## 数据集划分
+
+参考文档[数据划分](../split.md)完成训练集和验证集的划分，用于模型训练和精度验证。

dygraph/docs/data/annotation/semantic_segmentation.md

@@ -0,0 +1,32 @@
+# 语义分割数据标注
+
+语义数据的标注推荐使用LabelMe标注工具，如您先前并无安装，那么LabelMe的安装可参考[LabelMe安装和启动](labelme.md)，语义分割的标注与实例分割类似，流程如下
+
+**注意：LabelMe对于中文支持不够友好，因此请不要在如下的路径以及文件名中出现中文字符!**
+
+## 准备工作  
+
+1. 将收集的图像存放于`JPEGImages`文件夹下，例如存储在`D:\MyDataset\JPEGImages`
+2. 创建与图像文件夹相对应的文件夹`Annotations`，用于存储标注的json文件，如`D:MyDataset\Annotations`
+3. 打开LabelMe，点击”Open Dir“按钮，选择需要标注的图像所在的文件夹打开，则”File List“对话框中会显示所有图像所对应的绝对路径，接着便可以开始遍历每张图像，进行标注工作  
+
+## 目标边缘标注  
+
+1. 打开多边形标注工具（右键菜单->Create Polygon)以打点的方式圈出目标的轮廓，并在弹出的对话框中写明对应label（当label已存在时点击即可，此处请注意label勿使用中文），具体如下提所示，当框标注错误时，可点击左侧的“Edit Polygons”再点击标注框，通过拖拉进行修改，也可再点击“Delete Polygon”进行删除。
+![](./pics/detection2.png)
+
+2. 点击右侧”Save“，将标注结果保存到中创建的文件夹Annotations目录中
+
+## 格式转换
+
+LabelMe标注后的数据还需要进行转换为SEG格式，才可以用于语义分割任务的训练，创建保存目录`D:\dataset_seg`，在python环境中安装paddlex后，使用如下命令即可
+```
+paddlex --data_conversion --source labelme --to SEG \
+        --pics D:\MyDataset\JPEGImages \
+        --annotations D:\MyDataset\Annotations \
+        --save_dir D:\dataset_seg
+```
+
+## 数据集划分
+
+参考文档[数据划分](../split.md)完成训练集和验证集的划分，用于模型训练和精度验证。

dygraph/docs/data/convert.md

@@ -0,0 +1,40 @@
+# 数据格式转换
+
+PaddleX支持图像分类、目标检测、实例分割和语义分割四大视觉领域常见的任务，对于每类视觉任务，都支持了特定的数据格式。PaddleX目前支持了图像分类的ImageNet格式，目标检测的PascalVOC格式，实例分割的MSCOCO格式（MSCOCO也可以用于目标检测）以及语义分割数据格式。
+
+## 常见标注工具
+
+ 图像分类无需标注工具，用户只需以txt文件记录每张图片的类别标签即可。对于目标检测、实例分割和语义分割，PaddleX已经与主流的标注工具进行了适配，用户可根据自己的需求，选择以下标注工具进行数据标注。
+
+| 标注工具    | 图像分类 | 目标检测 | 实例分割 | 语义分割 | 安装                                             |
+| :---------  | :------- | :------ | :------  | :------- | :----------------------------------------------- |
+| Labelme     | -        | √        | √        | √        | pip install labelme （本地数据标注）                              |
+| 精灵标注    | √        | √*        | √        | √        | [官网下载](http://www.jinglingbiaozhu.com/) （本地数据标注）     |
+
+数据标注完成后，参照如下流程，将标注数据转为可用PaddleX模型训练的数据组织格式。
+
+***注意**：精灵标注的目标检测数据可以在工具内部导出为PascalVOC格式，因此paddlex未提供精灵标注数据到PascalVOC格式的转换
+
+
+## 标注数据格式转换
+
+目前所有标注工具生成的标注文件，均为与原图同名的json格式文件，如`1.jpg`在标注完成后，则会在标注文件保存的目录中生成`1.json`文件。转换时参照以下步骤：
+
+1. 将所有的原图文件放在同一个目录下，如`pics`目录  
+2. 将所有的标注json文件放在同一个目录下，如`annotations`目录  
+3. 使用如下命令进行转换:
+
+```
+paddlex --data_conversion --source labelme --to PascalVOC --pics ./pics --annotations ./annotations --save_dir ./converted_dataset_dir
+```
+
+| 参数 | 说明 |
+| ---- | ---- |
+| --source | 表示数据标注来源，支持`labelme`、`jingling`（分别表示数据来源于LabelMe，精灵标注助手）|
+| --to | 表示数据需要转换成为的格式，支持`ImageNet`（图像分类）、`PascalVOC`（目标检测），`MSCOCO`（实例分割，也可用于目标检测）和`SEG`(语义分割)  |
+| --pics | 指定原图所在的目录路径  |
+| --annotations | 指定标注文件所在的目录路径 |
+
+**注意**：  
+1. 精灵标注的目标检测数据可以在工具内部导出为PascalVOC格式，因此paddlex未提供精灵标注数据到PascalVOC格式的转换  
+2. 在将LabelMe数据集转换为COCO数据集时，LabelMe的图像文件名和json文件名需要一一对应，才可正确转换

dygraph/docs/data/format/README.md

@@ -0,0 +1,11 @@
+# 数据格式说明
+
+请根据具体任务查看相应的数据格式说明文档：
+
+- [图像分类ImageNet](./classification.md)
+
+- [目标检测PascalVOC](./detection.md)
+
+- [实例分割MSCOCO](./instance_segmentation.md)
+
+- [语义分割Seg](./segmentation.md)

dygraph/docs/data/format/classification.md

@@ -0,0 +1,97 @@
+# 图像分类ImageNet
+
+## 目录
+
+* [数据格式](#1)
+  * [数据文件夹结构](#11)
+  * [训练集、验证集列表和类别标签列表](#12)
+* [数据加载](#2)
+
+## <h2 id="1">数据格式</h2>
+
+在PaddleX中，图像分类任务支持的ImageNet数据集格式要求如下：
+
+### <h3 id="11">1. 数据文件夹结构</h3>
+
+数据集目录`data_dir`下包含多个文件夹，每个文件夹中的图像均属于同一个类别，文件夹的命名即为类别名（**注意路径中不要包括中文，空格**）。
+
+文件夹结构示例如下：
+
+```
+MyDataset/ # 图像分类数据集根目录
+|--dog/ # 当前文件夹所有图片属于dog类别
+|  |--d1.jpg
+|  |--d2.jpg
+|  |--...
+|  |--...
+|
+|--...
+|
+|--snake/ # 当前文件夹所有图片属于snake类别
+|  |--s1.jpg
+|  |--s2.jpg
+|  |--...
+|  |--...
+```
+
+### <h3 id="12">2. 训练集、验证集列表和类别标签列表</h3>
+
+**为了完成模型的训练和精度验证。我们需要在`MyDataset`目录下准备`train_list.txt`, `val_list.txt`和`labels.txt`三个文件**，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载[图像分类示例数据集](https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz)查看具体的数据格式。
+
+
+* **labels.txt**  
+
+labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容
+```
+dog
+cat
+snake
+```
+即表示该分类数据集中共有3个类别，分别为`dog`，`cat`和`snake`，在模型训练中`dog`对应的类别id为0, `cat`对应1，以此类推
+
+* **train_list.txt**  
+
+train_list.txt列出用于训练时的图片集合，与其对应的类别id，示例如下
+```
+dog/d1.jpg 0
+dog/d2.jpg 0
+cat/c1.jpg 1
+... ...
+snake/s1.jpg 2
+```
+其中第一列为相对对`MyDataset`的相对路径，第二列为图片对应类别的类别id
+
+* **val_list.txt**  
+
+val_list列出用于验证时的图片集成，与其对应的类别id，格式与train_list.txt一致
+
+## <h2 id="2">数据集加载</h2>
+
+训练过程中，PaddleX加载数据集的示例代码如下:
+
+```
+import paddlex as pdx
+from paddlex import transforms as T
+
+train_transforms = T.Compose([
+     T.RandomCrop(crop_size=224),
+     T.RandomHorizontalFlip(),
+     T.Normalize()])
+
+eval_transforms = T.Compose([
+    T.ResizeByShort(short_size=256),
+    T.CenterCrop(crop_size=224),
+    T.Normalize()
+])
+
+train_dataset = pdx.datasets.ImageNet(
+                    data_dir='./MyDataset',
+                    file_list='./MyDataset/train_list.txt',
+                    label_list='./MyDataset/labels.txt',
+                    transforms=train_transforms)
+eval_dataset = pdx.datasets.ImageNet(
+                    data_dir='./MyDataset',
+                    file_list='./MyDataset/eval_list.txt',
+                    label_list='./MyDataset/labels.txt',
+                    transforms=eval_transforms)
+```

dygraph/docs/data/format/detection.md

@@ -0,0 +1,101 @@
+# 目标检测PascalVOC
+
+## 目录
+
+* [数据格式](#1)
+  * [数据文件夹结构](#11)
+  * [训练集、验证集列表和类别标签列表](#12)
+* [数据加载](#2)
+
+
+## <h2 id="1">数据格式</h2>
+
+在PaddleX中，目标检测支持PascalVOC数据集格式。
+
+### <h3 id="11">数据文件夹结构</h2>
+
+数据集按照如下方式进行组织，原图均放在同一目录，如`JPEGImages`，标注的同名xml文件均放在同一目录，如`Annotations`，示例如下：
+
+```
+MyDataset/ # 目标检测数据集根目录
+|--JPEGImages/ # 原图文件所在目录
+|  |--1.jpg
+|  |--2.jpg
+|  |--...
+|  |--...
+|
+|--Annotations/ # 标注文件所在目录
+|  |--1.xml
+|  |--2.xml
+|  |--...
+|  |--...
+```
+
+### <h3 id="12">训练集、验证集列表和类别标签列表</h3>
+
+**为了用于训练，我们需要在`MyDataset`目录下准备`train_list.txt`, `val_list.txt`和`labels.txt`三个文件**，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载[目标检测示例数据集](https://bj.bcebos.com/paddlex/datasets/insect_det.tar.gz)查看具体的数据格式。
+
+* **labels.txt**  
+
+labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容
+```
+dog
+cat
+snake
+```
+表示该检测数据集中共有3个目标类别，分别为`dog`，`cat`和`snake`，在模型训练中`dog`对应的类别id为0, `cat`对应1，以此类推
+
+* **train_list.txt**  
+
+train_list.txt列出用于训练时的图片集合，与其对应的标注文件，示例如下
+```
+JPEGImages/1.jpg Annotations/1.xml
+JPEGImages/2.jpg Annotations/2.xml
+... ...
+```
+其中第一列为原图相对`MyDataset`的相对路径，第二列为标注文件相对`MyDataset`的相对路径
+
+* **val_list.txt**  
+
+val_list列出用于验证时的图片集成，与其对应的标注文件，格式与val_list.txt一致
+
+
+## <h2 id="2">数据集加载</h2>
+
+训练过程中，PaddleX加载数据集的示例代码如下:
+
+
+```
+import paddlex as pdx
+from paddlex import transforms as T
+
+train_transforms = T.Compose([
+    T.RandomResizeByShort(
+        short_sizes=[640, 672, 704, 736, 768, 800],
+        max_size=1333,
+        interp='CUBIC'),
+    T.RandomHorizontalFlip(),
+    T.Normalize(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+eval_transforms = T.Compose([
+    T.ResizeByShort(
+        short_size=800, max_size=1333, interp='CUBIC'),
+    T.Normalize(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+
+train_dataset = pdx.datasets.VOCDetection(
+                        data_dir='./MyDataset',
+                        file_list='./MyDataset/train_list.txt',
+                        label_list='./MyDataset/labels.txt',
+                        transforms=train_transforms)
+eval_dataset = pdx.datasets.VOCDetection(
+                        data_dir='./MyDataset',
+                        file_list='./MyDataset/val_list.txt',
+                        label_list='MyDataset/labels.txt',
+                        transforms=eval_transforms)
+
+```

dygraph/docs/data/format/instance_segmentation.md

@@ -0,0 +1,67 @@
+# 实例分割MSCOCO
+
+## 目录
+
+* [数据格式](#1)
+  * [数据文件夹结构](#11)
+  * [训练集、验证集列表](#12)
+* [数据加载](#2)
+
+
+## <h2 id="1">数据格式</h2>
+
+在PaddleX中，实例分割支持MSCOCO数据集格式。（MSCOCO格式同样也可以用于目标检测）。
+
+### <h3 id="11">数据文件夹结构</h2>
+
+数据集按照如下方式进行组织，原图均放在同一目录，如JPEGImages，标注文件（如annotations.json）放在与JPEGImages所在目录同级目录下，示例结构如下
+```
+MyDataset/ # 实例分割数据集根目录
+|--JPEGImages/ # 原图文件所在目录
+|  |--1.jpg
+|  |--2.jpg
+|  |--...
+|  |--...
+|
+|--annotations.json # 标注文件所在目录
+```
+
+## <h3 id="12">训练集、验证集列表</h3>
+
+为了区分训练集和验证集，在`MyDataset`同级目录，使用不同的json表示数据的划分，例如`train.json`和`val.json`。点击下载[实例分割示例数据集](https://bj.bcebos.com/paddlex/datasets/garbage_ins_det.tar.gz)查看具体的数据格式。
+
+
+## <h2 id="2">数据集加载</h2>
+
+训练过程中，PaddleX加载数据集的示例代码如下:
+
+```
+import paddlex as pdx
+from paddlex import transforms as T
+
+train_transforms = T.Compose([
+    T.RandomResizeByShort(
+        short_sizes=[640, 672, 704, 736, 768, 800],
+        max_size=1333,
+        interp='CUBIC'),
+    T.RandomHorizontalFlip(),
+    T.Normalize(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+eval_transforms = T.Compose([
+    T.ResizeByShort(
+        short_size=800, max_size=1333, interp='CUBIC'),
+    T.Normalize(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+train_dataset = pdx.dataset.CocoDetection(
+                    data_dir='./MyDataset/JPEGImages',
+                    ann_file='./MyDataset/train.json',
+                    transforms=train_transforms)
+eval_dataset = pdx.dataset.CocoDetection(
+                    data_dir='./MyDataset/JPEGImages',
+                    ann_file='./MyDataset/val.json',
+                    transforms=eval_transforms)
+```

dygraph/docs/data/format/segmentation.md

@@ -0,0 +1,93 @@
+# 语义分割Seg
+
+## 目录
+
+* [数据格式](#1)
+  * [数据文件夹结构](#11)
+  * [训练集、验证集列表和类别标签列表](#12)
+* [数据加载](#2)
+
+
+## <h2 id="1">数据格式</h2>
+
+### <h3 id="11">数据文件夹结构</h2>
+
+数据集按照如下方式进行组织，原图均放在同一目录，如`JPEGImages`，标注的同名png文件均放在同一目录，如`Annotations`。示例如下：
+```
+MyDataset/ # 语义分割数据集根目录
+|--JPEGImages/ # 原图文件所在目录
+|  |--1.jpg
+|  |--2.jpg
+|  |--...
+|  |--...
+|
+|--Annotations/ # 标注文件所在目录
+|  |--1.png
+|  |--2.png
+|  |--...
+|  |--...
+```
+语义分割的标注图像，如1.png，为单通道图像,像素标注类别需要从0开始递增（一般0表示background背景), 例如0， 1， 2， 3表示4种类别，标注类别最多255个类别(其中像素值255不参与训练和评估)。
+
+
+### <h3 id="12">训练集、验证集列表和类别标签列表</h3>
+
+**为了用于训练，我们需要在`MyDataset`目录下准备`train_list.txt`, `val_list.txt`和`labels.txt`三个文件**，分别用于表示训练集列表，验证集列表和类别标签列表。点击下载[语义分割示例数据集](https://bj.bcebos.com/paddlex/datasets/optic_disc_seg.tar.gz)查看具体的数据格式。
+
+
+* **labels.txt**  
+
+labels.txt用于列出所有类别，类别对应行号表示模型训练过程中类别的id(行号从0开始计数)，例如labels.txt为以下内容
+```
+background
+human
+car
+```
+表示该检测数据集中共有3个分割类别，分别为`background`，`human`和`car`，在模型训练中`background`对应的类别id为0, `human`对应1，以此类推，如不知具体类别标签，可直接在labels.txt逐行写0，1，2...序列即可。
+
+* **train_list.txt**  
+
+train_list.txt列出用于训练时的图片集合，与其对应的标注文件，示例如下
+```
+JPEGImages/1.jpg Annotations/1.png
+JPEGImages/2.jpg Annotations/2.png
+... ...
+```
+其中第一列为原图相对`MyDataset`的相对路径，第二列为标注文件相对`MyDataset`的相对路径
+
+* **val_list.txt**  
+
+val_list列出用于验证时的图片集成，与其对应的标注文件，格式与val_list.txt一致
+
+## <h2 id="2">数据集加载</h2>
+
+训练过程中，PaddleX加载数据集的示例代码如下:
+
+```
+import paddlex as pdx
+from paddlex.seg import transforms
+
+train_transforms = T.Compose([
+    T.Resize(target_size=512),
+    T.RandomHorizontalFlip(),
+    T.Normalize(
+        mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+])
+
+eval_transforms = T.Compose([
+    T.Resize(target_size=512),
+    T.Normalize(
+        mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+])
+
+train_dataset = pdx.datasets.SegDataset(
+                        data_dir='./MyDataset',
+                        file_list='./MyDataset/train_list.txt',
+                        label_list='./MyDataset/labels.txt',
+                        transforms=train_transforms)
+eval_dataset = pdx.datasets.SegDataset(
+                        data_dir='./MyDataset',
+                        file_list='./MyDataset/val_list.txt',
+                        label_list='MyDataset/labels.txt',
+                        transforms=eval_transforms)
+```

dygraph/docs/data/split.md

@@ -0,0 +1,53 @@
+# 数据划分
+
+在模型进行训练时，我们需要划分训练集，验证集和测试集，可直接使用paddlex命令将数据集随机划分。如果数据已经划分过，该步骤可跳过。
+
+> 注：如您使用PaddleX可视化客户端进行模型训练，数据集划分功能集成在客户端内，无需自行使用paddlex命令划分
+
+## 图像分类
+
+使用paddlex命令即可将数据集随机划分成70%训练集，20%验证集和10%测试集:
+
+```
+paddlex --split_dataset --format ImageNet --dataset_dir MyDataset --val_value 0.2 --test_value 0.1
+```
+
+划分好的数据集会额外生成`labels.txt`, `train_list.txt`, `val_list.txt`, `test_list.txt`四个文件，之后可直接进行训练。
+
+
+- [图像分类任务训练示例代码](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/image_classification/mobilenetv2.py)
+
+## 目标检测
+
+使用paddlex命令即可将数据集随机划分成70%训练集，20%验证集和10%测试集:
+
+```
+paddlex --split_dataset --format VOC --dataset_dir D:\MyDataset --val_value 0.2 --test_value 0.1
+```
+执行上面命令行，会在`D:\MyDataset`下生成`labels.txt`, `train_list.txt`, `val_list.txt`和`test_list.txt`，分别存储类别信息，训练样本列表，验证样本列表，测试样本列表
+
+
+- [目标检测任务训练示例代码](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/object_detection/yolov3_mobilenetv1.py)
+
+## 实例分割
+
+使用paddlex命令即可将数据集随机划分成70%训练集，20%验证集和10%测试集:
+
+```
+paddlex --split_dataset --format COCO --dataset_dir D:\MyDataset --val_value 0.2 --test_value 0.1
+```
+执行上面命令行，会在`D:\MyDataset`下生成`train.json`, `val.json`, `test.json`，分别存储训练样本信息，验证样本信息，测试样本信息
+
+
+- [实例分割任务训练示例代码](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/instance_segmentation/mask_rcnn_r50_fpn.py)
+
+## 语义分割
+
+使用paddlex命令即可将数据集随机划分成70%训练集，20%验证集和10%测试集:
+```
+paddlex --split_dataset --format SEG --dataset_dir D:\MyDataset --val_value 0.2 --test_value 0.1
+```
+执行上面命令行，会在`D:\MyDataset`下生成`train_list.txt`, `val_list.txt`, `test_list.txt`，分别存储训练样本信息，验证样本信息，测试样本信息
+
+
+- [语义分割任务训练示例代码](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/semantic_segmentation/deeplabv3p_xception65.py)

dygraph/docs/install.md

@@ -0,0 +1,84 @@
+# 快速安装PaddleX
+
+## 目录
+
+* [1. PaddleX API开发模式安装](#1)
+* [2. PadldeX GUI开发模式安装](#2)
+* [3. PaddleX Restful开发模式安装](#3)
+
+
+**PaddleX提供三种开发模式，满足用户的不同需求：**
+
+## <h2 id="1">1. PaddleX API开发模式安装</h2>
+
+通过简洁易懂的Python API，在兼顾功能全面性、开发灵活性、集成方便性的基础上，给开发者最流畅的深度学习开发体验。<br>
+
+以下安装过程默认用户已安装好**paddlepaddle-gpu或paddlepaddle(版本大于或等于2.1.0)**，paddlepaddle安装方式参照[飞桨官网](https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/develop/install/pip/windows-pip.html)
+
+
+### PaddleX 2.0.0-rc1安装
+
+#### * Linux / macOS 操作系统
+
+使用pip安装方式安装2.0.0-rc1版本：
+
+```
+pip install paddlex -i https://mirror.baidu.com/pypi/simple
+```
+
+因PaddleX依赖pycocotools包，如遇到pycocotools安装失败，可参照如下方式安装pycocotools：
+
+```
+pip install cython  
+pip install pycocotools
+```
+
+**我们推荐大家先安装Anacaonda，而后在新建的conoda环境中使用上述pip安装方式**。Anaconda是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。使用Anaconda可以通过创建多个独立的Python环境，避免用户的Python环境安装太多不同版本依赖导致冲突。参考[Anaconda安装PaddleX文档](../../docs/appendix/anaconda_install.md)
+
+#### * Windows 操作系统
+
+
+使用pip安装方式安装2.0.0-rc1版本：
+
+```
+pip install paddlex -i https://mirror.baidu.com/pypi/simple
+```
+
+因PaddleX依赖pycocotools包，Windows安装时可能会提示`Microsoft Visual C++ 14.0 is required`，从而导致安装出错，[点击下载VC build tools](https://go.microsoft.com/fwlink/?LinkId=691126)安装再执行如下pip命令
+> 注意：安装完后，需要重新打开新的终端命令窗口
+
+```
+pip install cython
+pip install git+https://gitee.com/jiangjiajun/philferriere-cocoapi.git#subdirectory=PythonAPI
+```
+
+### PaddleX develop安装
+
+github代码会跟随开发进度不断更新，可以安装develop分支的代码使用最新的功能，安装方式如下：
+
+```
+> - git clone --recurse-submodules https://github.com/PaddlePaddle/PaddleX.git
+> - cd PaddleX/dygraph
+> - pip install -r requirements.txt
+> - pip install -r submodules.txt
+> - python setup.py install
+```
+
+如遇到pycocotools安装失败，参考[PaddleX 2.0.0-rc1安装](./install.md#paddlex-200-rc1安装)中介绍的解决方法。
+
+## <h2 id="2">2. PadldeX GUI开发模式安装</h2>
+
+
+   无代码开发的可视化客户端，应用PaddleX API实现，使开发者快速进行产业项目验证，并为用户开发自有深度学习软件/应用提供参照。
+
+- 前往[PaddleX官网](https://www.paddlepaddle.org.cn/paddle/paddlex)，申请下载PaddleX GUI一键绿色安装包。
+
+- 前往[PaddleX GUI使用教程](../../docs/gui/how_to_use.md)了解PaddleX GUI使用详情。
+
+- [PaddleX GUI安装环境说明](../../docs/gui/download.md)
+
+
+## <h2 id="3">3. PaddleX Restful开发模式安装</h2>
+
+使用基于RESTful API开发的GUI与Web Demo实现远程的深度学习全流程开发；同时开发者也可以基于RESTful API开发个性化的可视化界面
+- 前往[PaddleX RESTful API使用教程](../../docs/Resful_API/docs/readme.md)  

dygraph/docs/quick_start.md

@@ -0,0 +1,147 @@
+# 10分钟快速上手使用
+
+## 目录
+* [前置说明](#1)
+  * [PaddleX的模型训练](#11)
+  * [PaddleX的其他用法](#12)
+* [使用示例](#2)
+  * <a href=#安装PaddleX>安装PaddleX</a>
+  * <a href=#准备蔬菜分类数据集>准备蔬菜分类数据集</a>
+  * <a href=#定义训练验证图像处理流程transforms>定义训练/验证图像处理流程transforms</a>
+  * <a href=#定义dataset加载图像分类数据集>定义dataset加载图像分类数据集</a>
+  * <a href=#使用MoibleNetV3_small模型开始训练>使用MoibleNetV3_small模型开始训练</a>
+  * <a href=#训练过程使用VisualDL查看训练指标变化>训练过程使用VisualDL查看训练指标变化</a>
+  * <a href=加载训练保存的模型预测>加载训练保存的模型预测</a>
+* [更多使用教程](#3)
+
+
+## <h2 id="1">前置说明</h2>
+
+### <h3 id="11">PaddleX的模型训练</h3>
+
+跟随以下3个步骤，即可快速完成训练代码开发:
+
+| 步骤 |                  |说明             |
+| :--- | :--------------- | :-------------- |
+| 第1步| <a href=#定义训练验证图像处理流程transforms>定义transforms</a>  | 用于定义模型训练、验证、预测过程中，<br>输入图像的预处理和数据增强操作 |
+| 第2步| <a href="#定义dataset加载图像分类数据集">定义datasets</a>  | 用于定义模型要加载的训练、验证数据集 |
+| 第3步| <a href="#使用MoibleNetV3_small_ssld模型开始训练">定义模型开始训练</a> | 选择需要的模型，进行训练 |
+
+> **注意**：不同模型的transforms、datasets和训练参数都有较大差异。可直接根据[模型训练教程](../tutorials/train)获取更多模型的训练代码。
+
+### <h3 id="12">PaddleX的其它用法</h3>
+
+- <a href="#训练过程使用VisualDL查看训练指标变化">使用VisualDL查看训练过程中的指标变化</a>
+- <a href="#加载训练保存的模型预测">加载训练保存的模型进行预测</a>
+
+## <h2 id="2">使用示例</h2>
+
+接下来展示如何通过PaddleX在一个小数据集上进行训练。示例代码源于Github [tutorials/train/image_classification/mobilenetv3_small.py](../tutorials/train/image_classification/mobilenetv3_small.py)，用户可自行下载至本地运行。  
+
+<a name="安装PaddleX"></a>
+**1. 安装PaddleX**  
+
+PaddleX的安装以及安装问题的解决可以参考PaddleX的[安装文档](./install.md)。
+
+<a name="准备蔬菜分类数据集"></a>
+**2. 准备蔬菜分类数据集**  
+
+```
+wget https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz
+tar xzvf vegetables_cls.tar.gz
+```
+
+<a name="定义训练验证图像处理流程transforms"></a>
+**3. 定义训练/验证图像处理流程transforms**  
+
+因为训练时加入了数据增强操作，因此在训练和验证过程中，模型的数据处理流程需要分别进行定义。如下所示，代码在`train_transforms`中加入了[RandomCrop](./apis/transforms/transforms.md#randomcrop)和[RandomHorizontalFlip](./apis/transforms/transforms.md#randomhorizontalflip)两种数据增强方式, 更多方法可以参考[数据增强文档](./apis/transforms/transforms.md)。
+
+```
+from paddlex import transforms as T
+train_transforms = T.Compose([
+    T.RandomCrop(crop_size=224),
+    T.RandomHorizontalFlip(),
+    T.Normalize()])
+
+eval_transforms = T.Compose([
+    T.ResizeByShort(short_size=256),
+    T.CenterCrop(crop_size=224),
+    T.Normalize()
+])
+```
+
+<a name="定义dataset加载图像分类数据集"></a>
+**4. 定义`dataset`加载图像分类数据集**  
+
+定义数据集，`pdx.datasets.ImageNet`表示读取ImageNet格式的分类数据集：
+
+```
+train_dataset = pdx.datasets.ImageNet(
+    data_dir='vegetables_cls',
+    file_list='vegetables_cls/train_list.txt',
+    label_list='vegetables_cls/labels.txt',
+    transforms=train_transforms,
+    shuffle=True)
+eval_dataset = pdx.datasets.ImageNet(
+    data_dir='vegetables_cls',
+    file_list='vegetables_cls/val_list.txt',
+    label_list='vegetables_cls/labels.txt',
+    transforms=eval_transforms)
+```
+
+- [paddlex.datasets.ImageNet接口说明](./apis/datasets.md#1)
+- [ImageNet数据格式说明](./data/format/classification.md)
+
+<a name="使用MoibleNetV3_small模型开始训练"></a>
+**5. 使用MobileNetV3_small模型开始训练**  
+
+本文档中使用百度基于蒸馏方法得到的MobileNetV3预训练模型，模型结构与MobileNetV3一致，但精度更高。PaddleX内置了20多种分类模型，查阅[PaddleX 图像分类模型API](apis/models/classification.md#其它分类模型)了解更多分类模型。
+```
+num_classes = len(train_dataset.labels)
+model = pdx.cls.MobileNetV3_small(num_classes=num_classes)
+
+model.train(num_epochs=10,
+            train_dataset=train_dataset,
+            train_batch_size=32,
+            eval_dataset=eval_dataset,
+            lr_decay_epochs=[4, 6, 8],
+            save_dir='output/mobilenetv3_small',
+            use_vdl=True)
+```
+
+<a name="训练过程使用VisualDL查看训练指标变化"></a>
+**6. 训练过程使用VisualDL查看训练指标变化**  
+
+训练过程中，模型在训练集和验证集上的指标均会以标准输出流形式输出到命令终端。当用户设定`use_vdl=True`时，也会使用VisualDL格式将指标打点到`save_dir`目录下的`vdl_log`文件夹，在终端运行如下命令启动visualdl并查看可视化的指标变化情况。
+```
+visualdl --logdir output/mobilenetv3_small --port 8001
+```
+服务启动后，通过浏览器打开https://0.0.0.0:8001或https://localhost:8001即可。
+
+如果您使用的是AIStudio平台进行训练，不能通过此方式启动visualdl，请参考AIStudio VisualDL启动教程使用
+
+<a name="加载训练保存的模型预测"></a>
+**7. 加载训练保存的模型预测**  
+
+模型在训练过程中，会每间隔一定轮数保存一次模型，在验证集上评估效果最好的一轮会保存在`save_dir`目录下的`best_model`文件夹。通过如下方式可加载模型，进行预测：
+
+```
+import paddlex as pdx
+model = pdx.load_model('output/mobilenetv3_small/best_model')
+result = model.predict('vegetables_cls/bocai/100.jpg')
+print("Predict Result: ", result)
+```
+预测结果输出如下,
+```
+Predict Result: Predict Result: [{'score': 0.9999393, 'category': 'bocai', 'category_id': 0}]
+```
+- [load_model接口说明](../../docs/train/prediction.md)
+- [分类模型predict接口说明](./apis/models/classification.md#predict)
+
+
+<h2 id="3">更多使用教程</h2>
+
+- 1.[目标检测模型训练](../tutorials/train)
+- 2.[语义分割模型训练](../tutorials/train)
+- 3.[实例分割模型训练](../tutorials/train)
+- 4.[模型太大，想要更小的模型，试试模型裁剪吧!](../tutorials/slim/prune)

dygraph/examples/C#_deploy/README.md

@@ -37,7 +37,11 @@
 ## 2 代码编译
 下载好PaddleX代码
 
-`git clone `
+```
+git clone https://github.com/PaddlePaddle/PaddleX
+cd dygraph
+```
+
 
 使用Cmake进行编译，我们主要对`PaddleX/dygraph/deploy/cpp`中代码进行编译，并创建`out`文件夹用来承接编译生成的内容，
 
@@ -63,9 +67,9 @@
 <img src="./images/7.png"  width = "800" />              </div>
 打开sln文件，会发现在PaddleDeploy目录下生成了7个项目，其中关键的是
 
-`batch_infer` 
+`batch_infer`
 
-`model_infer` 
+`model_infer`
 
 `multi_gpu_model_infer`
 
@@ -75,23 +79,28 @@
 <img src="./images/8.png"  width = "800" />              </div>
 
 ## 3 生成dll
+
 ### 3.1 修改cmakelists
 <div align="center">
 <img src="./images/17.png"  width = "800" />             </div>
 
 
 ### 3.2 修改model_infer.cpp并重新生成dll
-* 该部分代码已经提供
 
-### 3.3 创建一个c#项目并被调用
-* 将生成的dll导入到C#项目中
+* 修改后的model_infer.cpp已经提供，位于[model_infer.cpp](./model_infer.cpp)。请将[model_infer.cpp](./model_infer.cpp)替换[deploy/cpp/demodeploy/cpp/demo](https://github.com/PaddlePaddle/PaddleX/tree/develop/dygraph/deploy/cpp/demo)中的model_infer.cpp，或者参考[model_infer.cpp](./model_infer.cpp)修改自己的model_infer.cpp。
+
+### 3.3 创建一个c#项目并调用dll
+
+默认已经创建好了一个c#项目。
+
+* 将前面生成的dll拷贝到C#项目中
+
 <div align="center">
 <img src="./images/16.png"  width = "800" />             </div>
 
 * 3.4 执行C#项目去预测
-<div align="center">
-<img src="./images/15.png"  width = "800" />             </div>
 
+C#项目中的Program.cs代码已经提供，位于[Program.cs](Program.cs)。执行运行后得到预测结果如下：
 
--------------
-## 修改后的model_infer.cpp和C#代码已经提供.
+<div align="center">
+<img src="./images/15.png"  width = "800" />             </div>

dygraph/examples/README.md

@@ -8,3 +8,5 @@
 * [缺陷检测](./defect_detection)
 
 * [工业表计检测](./meter_reader)
+
+* [Windows系统下使用C#语言部署](./C%23_deploy)

dygraph/examples/meter_reader/README.md

@@ -428,7 +428,7 @@ git clone https://github.com/PaddlePaddle/PaddleX.git
 | TENSORRT_DIR | PaddleXManufacture的路径，例如 `D:\\projects\\TensorRT-7.0.0.11`                                                                           |
 
 - 如果使用`CPU`版预测库，请把`WITH_GPU`的`值`去掉勾
-- **`WITH_GPU`的`值`必须打上勾**
+- **`WITH_TENSORRT`的`值`必须打上勾**
 
 5. 保存并生成CMake缓存
 
@@ -470,5 +470,6 @@ Meter 2: 6.21739101
 ![](./images/20190822_168.jpg)
 
 在分割模型可视化的预测结果保存在`PaddleX\dygraph\examples\meter_reader\deploy\cpp\meter_reader\out\build\x64-Release\output_seg`，可以点击进行查看：
-![](./images/20190822_168_06-30-17-09-33-217.jpg)
-![](20190822_168_06-30-17-09-33-213.jpg)
+| 表1可视化分割结果 | 表2可视化分割结果|
+| -- | -- |
+| ![](./images/20190822_168_06-30-17-09-33-217.jpg) | ![](20190822_168_06-30-17-09-33-213.jpg) |

dygraph/paddlex/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = '2.0.0rc0'
+__version__ = '2.0.0rc1'
 
 from paddlex.utils.env import get_environ_info, init_parallel_env
 init_parallel_env()

dygraph/setup.py

@@ -19,7 +19,7 @@ long_description = "PaddlePaddle Entire Process Development Toolkit"
 
 setuptools.setup(
     name="paddlex",
-    version='2.0.0rc0',
+    version='2.0.0rc1',
     author="paddlex",
     author_email="paddlex@baidu.com",
     description=long_description,

dygraph/tutorials/slim/quantize/README.md

@@ -0,0 +1,46 @@
+# 模型量化
+
+
+这里**以图像分类为例**展示模型量化的使用过程，示例代码位于[image_classification/mobilenetv2_train.py](image_classification/mobilenetv2_train.py)和[image_classification/mobilenetv2_qat.py](image_classification/mobilenetv2_qat.py)，目标检测、实例分割和语义分割的量化使用均与图像分类一致，皆可参考以下步骤完成模型的在线量化。
+
+
+## 第一步 正常训练图像分类模型
+
+```
+python mobilenetv2_train.py
+```
+
+在此步骤中，训练的模型会保存在`output/mobilenet_v2`目录下
+
+
+## 第二步 模型在线量化
+
+```
+python mobilenetv2_qat.py
+```
+
+`mobilenetv2_qat.py`中主要执行了以下API：
+
+step 1: 加载之前训练好的模型
+
+
+```
+model = pdx.load_model('output/mobilenet_v2/best_model')
+```
+
+step 2: 完成在线量化
+
+```
+model.quant_aware_train(
+    num_epochs=5,
+    train_dataset=train_dataset,
+    train_batch_size=32,
+    eval_dataset=eval_dataset,
+    learning_rate=0.000025,
+    save_dir='output/mobilenet_v2/quant',
+    use_vdl=True)
+```
+
+量化训练后的模型保存在`output/mobilenet_v2/quant`。
+
+**注意：** 重新训练时需将`pretrain_weights`设置为`None`，否则模型会加载`pretrain_weights`指定的预训练模型参数。

dygraph/tutorials/train/README.md

@@ -28,7 +28,7 @@
 - [PaddlePaddle安装](https://www.paddlepaddle.org.cn/install/quick)
 * 版本要求：PaddlePaddle==2.1.0
 
-- [PaddleX安装](https://paddlex.readthedocs.io/zh_CN/develop/install.html)
+- [PaddleX安装](../../docs/install.md)
 
 ## 开始训练
 * 在安装PaddleX后，使用如下命令开始训练，代码会自动下载训练数据, 并均使用单张GPU卡进行训练。