diff --git a/docs/apis/datasets.md b/docs/apis/datasets.md
index 3494aaa8a66840cecc16a79454b22bd252ab117b..94b8cbc7650ba89daea569cef817d41f4a0f8a73 100644
--- a/docs/apis/datasets.md
+++ b/docs/apis/datasets.md
@@ -3,7 +3,7 @@
 ## paddlex.datasets.ImageNet
 > **用于图像分类模型**  
 ```
-paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=8, parallel_method='process', shuffle=False)
 ```
 读取ImageNet格式的分类数据集，并对样本进行相应的处理。ImageNet数据集格式的介绍可查看文档:[数据集格式说明](../data/format/index.html)  
 
@@ -16,14 +16,14 @@ paddlex.datasets.ImageNet(data_dir, file_list, label_list, transforms=None, num_
 > > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
 > > * **transforms** (paddlex.cls.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.cls.transforms](./transforms/cls_transforms.md)。  
 > > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。  
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
+> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为8。  
 > > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
 > > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。  
 
 ## paddlex.datasets.VOCDetection
 > **用于目标检测模型**  
 ```
-paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='process', shuffle=False)
 ```
 
 > 读取PascalVOC格式的检测数据集，并对样本进行相应的处理。PascalVOC数据集格式的介绍可查看文档:[数据集格式说明](../data/format/index.html)  
@@ -44,7 +44,7 @@ paddlex.datasets.VOCDetection(data_dir, file_list, label_list, transforms=None,
 ## paddlex.datasets.CocoDetection
 > **用于实例分割/目标检测模型**  
 ```
-paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers='auto', buffer_size=100, parallel_method='process', shuffle=False)
 ```
 
 > 读取MSCOCO格式的检测数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。MSCOCO数据集格式的介绍可查看文档:[数据集格式说明](../data/format/index.html)  
@@ -64,7 +64,7 @@ paddlex.datasets.CocoDetection(data_dir, ann_file, transforms=None, num_workers=
 ## paddlex.datasets.SegDataset
 > **用于语义分割模型**  
 ```
-paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='process', shuffle=False)
 ```
 
 > 读取语义分割任务数据集，并对样本进行相应的处理。语义分割任务数据集格式的介绍可查看文档:[数据集格式说明](../data/format/index.html)  
@@ -85,7 +85,7 @@ paddlex.datasets.SegDataset(data_dir, file_list, label_list, transforms=None, nu
 ## paddlex.datasets.EasyDataCls
 > **用于图像分类模型**  
 ```
-paddlex.datasets.EasyDataCls(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.EasyDataCls(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=8, parallel_method='process', shuffle=False)
 ```
 
 > 读取EasyData平台标注图像分类数据集，并对样本进行相应的处理。
@@ -97,14 +97,14 @@ paddlex.datasets.EasyDataCls(data_dir, file_list, label_list, transforms=None, n
 > > * **label_list** (str): 描述数据集包含的类别信息文件路径。  
 > > * **transforms** (paddlex.seg.transforms): 数据集中每个样本的预处理/增强算子，详见[paddlex.cls.transforms](./transforms/cls_transforms.md)。  
 > > * **num_workers** (int|str)：数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核数的一半。
-> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。  
+> > * **buffer_size** (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为8。  
 > > * **parallel_method** (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。  
 > > * **shuffle** (bool): 是否需要对数据集中样本打乱顺序。默认为False。
 
 ## paddlex.datasets.EasyDataDet
 > 用于**目标检测/实例分割模型**  
 ```
-paddlex.datasets.EasyDataDet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.EasyDataDet(data_dir, file_list, label_list, transforms=None, num_workers=‘auto’, buffer_size=100, parallel_method='process', shuffle=False)
 ```
 
 > 读取EasyData目标检测/实例分割格式数据集，并对样本进行相应的处理，该格式的数据集同样可以应用到实例分割模型的训练中。
@@ -124,7 +124,7 @@ paddlex.datasets.EasyDataDet(data_dir, file_list, label_list, transforms=None, n
 ## paddlex.datasets.EasyDataSeg
 > **用于语义分割模型**  
 ```
-paddlex.datasets.EasyDataSeg(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False)
+paddlex.datasets.EasyDataSeg(data_dir, file_list, label_list, transforms=None, num_workers='auto', buffer_size=100, parallel_method='process', shuffle=False)
 ```
 
 > 读取EasyData语义分割任务数据集，并对样本进行相应的处理。
diff --git a/docs/apis/interpret.md b/docs/apis/interpret.md
index 24ab99a1a17b2ebee2dc4388843e5d81176038ac..60dfb9c6c11dcecf3d2da912e2b5dd68dad1de91 100644
--- a/docs/apis/interpret.md
+++ b/docs/apis/interpret.md
@@ -53,6 +53,6 @@ NormLIME是利用一定数量的样本来出一个全局的解释。由于NormLI
 >* **save_dir** (str): 可解释性可视化结果（保存为png格式文件）和中间文件存储路径。
 >* **normlime_weights_file** (str): NormLIME初始化文件名，若不存在，则计算一次，保存于该路径；若存在，则直接载入。
 
-**注意：** dataset`读取的是一个数据集，该数据集不宜过大，否则计算时间会较长，但应包含所有类别的数据。NormLIME可解释性结果可视化目前只支持分类模型。
+**注意：** `dataset`读取的是一个数据集，该数据集不宜过大，否则计算时间会较长，但应包含所有类别的数据。NormLIME可解释性结果可视化目前只支持分类模型。
 ### 使用示例
 > 对预测可解释性结果可视化的过程可参见[代码](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/interpret/normlime.py)。
diff --git a/docs/apis/models/classification.md b/docs/apis/models/classification.md
index 0890b334e7f13efc2b17ce49d79eefe59ad589d3..793a889568f8cb597fdea650310acada6512a1e9 100755
--- a/docs/apis/models/classification.md
+++ b/docs/apis/models/classification.md
@@ -84,7 +84,7 @@ predict(self, img_file, transforms=None, topk=5)
 batch_predict(self, img_file_list, transforms=None, topk=5, thread_num=2)
 ```
 
-> 分类模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`ResNet50.test_transforms`和`ResNet50.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
+> 分类模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`ResNet50.test_transforms`和`ResNet50.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`batch_predict`接口时，用户需要再重新定义test_transforms传入给`batch_predict`接口。
 
 > **参数**
 >
diff --git a/docs/apis/models/detection.md b/docs/apis/models/detection.md
index 1afe5ff3b12d2f6286bc7f858ad914a7fade1f51..8a8e6a752a3595bff702f6b88b8f4a7ead161806 100755
--- a/docs/apis/models/detection.md
+++ b/docs/apis/models/detection.md
@@ -101,7 +101,7 @@ predict(self, img_file, transforms=None)
 batch_predict(self, img_file_list, transforms=None, thread_num=2)
 ```
 
-> YOLOv3模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`YOLOv3.test_transforms`和`YOLOv3.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义`test_transforms`传入给`predict`接口
+> YOLOv3模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`YOLOv3.test_transforms`和`YOLOv3.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`batch_predict`接口时，用户需要再重新定义`test_transforms`传入给`batch_predict`接口
 
 > **参数**
 >
@@ -206,7 +206,7 @@ predict(self, img_file, transforms=None)
 batch_predict(self, img_file_list, transforms=None, thread_num=2)
 ```
 
-> FasterRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`FasterRCNN.test_transforms`和`FasterRCNN.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
+> FasterRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`FasterRCNN.test_transforms`和`FasterRCNN.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`batch_predict`接口时，用户需要再重新定义test_transforms传入给`batch_predict`接口。
 
 > **参数**
 >
diff --git a/docs/apis/models/instance_segmentation.md b/docs/apis/models/instance_segmentation.md
index 3ab5a9b81c5808600efc1d1e63bc4480237ab5f7..a054aaeb565f4f5dff2a56c00a3c72e39205a89b 100755
--- a/docs/apis/models/instance_segmentation.md
+++ b/docs/apis/models/instance_segmentation.md
@@ -73,7 +73,7 @@ evaluate(self, eval_dataset, batch_size=1, epoch_id=None, metric=None, return_de
 predict(self, img_file, transforms=None)
 ```
 
-> MaskRCNN模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。
+> MaskRCNN模型预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`FasterRCNN.test_transforms`和`FasterRCNN.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
 
 > **参数**
 >
@@ -91,7 +91,7 @@ predict(self, img_file, transforms=None)
 batch_predict(self, img_file_list, transforms=None, thread_num=2)
 ```
 
-> MaskRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在FasterRCNN.test_transforms和FasterRCNN.eval_transforms中。如未在训练时定义eval_dataset，那在调用预测predict接口时，用户需要再重新定义test_transforms传入给predict接口。
+> MaskRCNN模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`FasterRCNN.test_transforms`和`FasterRCNN.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`batch_predict`接口时，用户需要再重新定义test_transforms传入给`batch_predict`接口。
 
 > **参数**
 >
diff --git a/docs/apis/models/semantic_segmentation.md b/docs/apis/models/semantic_segmentation.md
index d0ccd54ce2e21eed6adc2db252e788a955566cfe..bcd41a2fb24cb5d547a42e53d87678f539bc4bcc 100755
--- a/docs/apis/models/semantic_segmentation.md
+++ b/docs/apis/models/semantic_segmentation.md
@@ -85,7 +85,7 @@ predict(self, img_file, transforms=None):
 > >
 > > - **img_file** (str|np.ndarray): 预测图像路径或numpy数组(HWC排列，BGR格式)。
 > > - **transforms** (paddlex.seg.transforms): 数据预处理操作。
-> > - **thread_num** (int): 并发执行各图像预处理时的线程数。
+
 > **返回值**
 > >
 > > - **dict**: 包含关键字'label_map'和'score_map', 'label_map'存储预测结果灰度图，像素值表示对应的类别，'score_map'存储各类别的概率，shape=(h, w, num_classes)。
@@ -94,15 +94,16 @@ predict(self, img_file, transforms=None):
 ### batch_predict
 
 ```
-batch_predict(self, img_file_list, transforms=None):
+batch_predict(self, img_file_list, transforms=None, thread_num=2):
 ```
 
-> DeepLabv3p模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`DeepLabv3p.test_transforms`和`DeepLabv3p.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`predict`接口时，用户需要再重新定义test_transforms传入给`predict`接口。
+> DeepLabv3p模型批量预测接口。需要注意的是，只有在训练过程中定义了eval_dataset，模型在保存时才会将预测时的图像处理流程保存在`DeepLabv3p.test_transforms`和`DeepLabv3p.eval_transforms`中。如未在训练时定义eval_dataset，那在调用预测`batch_predict`接口时，用户需要再重新定义test_transforms传入给`batch_predict`接口。
 
 > **参数**
 > >
 > > - **img_file_list** (list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素可以是预测图像路径或numpy数组(HWC排列，BGR格式)。
 > > - **transforms** (paddlex.seg.transforms): 数据预处理操作。
+> > - **thread_num** (int): 并发执行各图像预处理时的线程数。
 
 > **返回值**
 > >
diff --git a/docs/apis/slim.md b/docs/apis/slim.md
index 23c2d5ee7026320bfe0e1da33028c833be11dfc5..894d83ad7e05ced84ea334a6065a0838205afb6c 100755
--- a/docs/apis/slim.md
+++ b/docs/apis/slim.md
@@ -5,13 +5,15 @@
 ```
 paddlex.slim.cal_params_sensitivities(model, save_file, eval_dataset, batch_size=8)
 ```
-计算模型中可裁剪参数在验证集上的敏感度，并将敏感度信息保存至文件`save_file`
-1. 获取模型中可裁剪卷积Kernel的名称。
-2. 计算每个可裁剪卷积Kernel不同裁剪率下的敏感度。
-【注意】卷积的敏感度是指在不同裁剪率下评估数据集预测精度的损失，通过得到的敏感度，可以决定最终模型需要裁剪的参数列表和各裁剪参数对应的裁剪率。  
+计算模型中可剪裁参数在验证集上的敏感度，并将敏感度信息保存至文件`save_file`
+1. 获取模型中可剪裁卷积Kernel的名称。
+2. 计算每个可剪裁卷积Kernel不同剪裁率下的敏感度。
+
+【注意】卷积的敏感度是指按照剪裁率将模型剪裁后模型精度的损失。选择合适的敏感度，对应地也能确定最终模型需要剪裁的参数列表和各剪裁参数对应的剪裁率。  
+
 [查看使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/compress/classification/cal_sensitivities_file.py#L33)
 
-### 参数
+**参数**
 
 * **model** (paddlex.cls.models/paddlex.det.models/paddlex.seg.models): paddlex加载的模型。
 * **save_file** (str): 计算的得到的sensetives文件存储路径。
@@ -24,9 +26,9 @@ paddlex.slim.cal_params_sensitivities(model, save_file, eval_dataset, batch_size
 ```
 paddlex.slim.export_quant_model(model, test_dataset, batch_size=2, batch_num=10, save_dir='./quant_model', cache_dir='./temp')
 ```
-导出量化模型，该接口实现了Post Quantization量化方式，需要传入测试数据集，并设定`batch_size`和`batch_num`，模型会以`batch_size`的大小计算`batch_num`批样本数据，并以这些样本数据的计算结果为统计信息进行模型量化。
+导出量化模型，该接口实现了Post Quantization量化方式，需要传入测试数据集，并设定`batch_size`和`batch_num`。量化过程中会以数量为`batch_size` X `batch_num`的样本数据的计算结果为统计信息完成模型的量化。
 
-### 参数
+**参数**
 
 * **model**(paddlex.cls.models/paddlex.det.models/paddlex.seg.models): paddlex加载的模型。
 * **test_dataset**(paddlex.dataset): 测试数据集
@@ -36,7 +38,8 @@ paddlex.slim.export_quant_model(model, test_dataset, batch_size=2, batch_num=10,
 * **cache_dir**(str): 量化过程中的统计数据临时存储目录
 
 
-### 使用示例
+**使用示例**
+
 点击下载如下示例中的[模型](https://bj.bcebos.com/paddlex/models/vegetables_mobilenetv2.tar.gz)，[数据集](https://bj.bcebos.com/paddlex/datasets/vegetables_cls.tar.gz)
 ```
 import paddlex as pdx
diff --git a/docs/apis/transforms/augment.md b/docs/apis/transforms/augment.md
index f8c66b45d2d853fde57c520b079f9974e5fa4d76..7b7fb5f908df7e4c69c1a5e6a92662da0894e2e5 100644
--- a/docs/apis/transforms/augment.md
+++ b/docs/apis/transforms/augment.md
@@ -30,7 +30,7 @@ train_transforms = transforms.Compose([
 
 | 增强方法 | 图像分类 | 目标检测<br> 实例分割 | 语义分割 | 备注 |
 | :------  | :------- | :-------------------- | :------- | :--- |
-| [imgaug.augmenters.arithmetic](https://imgaug.readthedocs.io/en/latest/source/api_augmenters_arithmetic.html) |√ |√ |√ | Cutout, DropoutJpegCompression等|
+| [imgaug.augmenters.arithmetic](https://imgaug.readthedocs.io/en/latest/source/api_augmenters_arithmetic.html) |√ |√ |√ | Cutout, Dropout, JpegCompression等|
 | [imgaug.augmenters.artistic](https://imgaug.readthedocs.io/en/latest/source/api_augmenters_artistic.html) |√ |√ |√ | 图像卡通化|
 | [imgaug.augmenters.blur](https://imgaug.readthedocs.io/en/latest/source/api_augmenters_blur.html) |√ |√ |√ | GaussianBlur, AverageBlur等|
 | [imgaug.augmenters.collections](https://imgaug.readthedocs.io/en/latest/source/api_augmenters_collections.html) |√ | | |提供了RandAugment方法 |
diff --git a/docs/apis/transforms/cls_transforms.md b/docs/apis/transforms/cls_transforms.md
index e0507cf017f5272782e549e1ea42eb9f4790dc09..e9b37c3e66dbf8503e3a733ad577d4b6d0efe790 100755
--- a/docs/apis/transforms/cls_transforms.md
+++ b/docs/apis/transforms/cls_transforms.md
@@ -7,7 +7,7 @@
 paddlex.cls.transforms.Compose(transforms)
 ```
 
-根据数据预处理/增强算子对输入数据进行操作。  [使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/classification/mobilenetv2.py#L13)
+根据数据预处理/增强算子对输入数据进行操作。  [使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/image_classification/mobilenetv2.py#L15)
 
 > **参数**
 > * **transforms** (list): 数据预处理/数据增强列表。
diff --git a/docs/apis/transforms/det_transforms.md b/docs/apis/transforms/det_transforms.md
index 9388c01c544649d254d38fb37850a17fb65e8e06..b5559552bae561d47a006928d400ac0ff74d1ff9 100755
--- a/docs/apis/transforms/det_transforms.md
+++ b/docs/apis/transforms/det_transforms.md
@@ -7,7 +7,7 @@
 paddlex.det.transforms.Compose(transforms)
 ```
 
-根据数据预处理/增强算子对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/detection/yolov3_mobilenetv1.py#L13)
+根据数据预处理/增强算子对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/object_detection/yolov3_mobilenetv1.py#L15)
 
 ### 参数
 * **transforms** (list): 数据预处理/数据增强列表。
diff --git a/docs/apis/transforms/seg_transforms.md b/docs/apis/transforms/seg_transforms.md
index 0d49fbf8421bc458314569d185e47dec732f1f33..cb24c5869238342fcb3fab0e5b259da8d63da741 100755
--- a/docs/apis/transforms/seg_transforms.md
+++ b/docs/apis/transforms/seg_transforms.md
@@ -7,7 +7,7 @@
 ```python
 paddlex.seg.transforms.Compose(transforms)
 ```
-根据数据预处理/数据增强列表对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/segmentation/unet.py#L13)
+根据数据预处理/数据增强列表对输入数据进行操作。[使用示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/train/semantic_segmentation/fast_scnn.py#L15)
 ### 参数
 * **transforms** (list): 数据预处理/数据增强列表。
 
diff --git a/docs/apis/visualize.md b/docs/apis/visualize.md
index d5c59de62bb7a3863f96f34f37139fedd781553c..cc9a449245aa45078983044b7b11ed35a122f6de 100755
--- a/docs/apis/visualize.md
+++ b/docs/apis/visualize.md
@@ -101,11 +101,11 @@ pdx.det.draw_pr_curve(gt=gt, pred_bbox=bbox, save_dir='./insect')
 
 
 ## paddlex.slim.visualzie
-> **模型裁剪比例可视化分析**  
+> **模型剪裁比例可视化分析**  
 ```
 paddlex.slim.visualize(model, sensitivities_file, save_dir='./')
 ```
-利用此接口，可以分析在不同的`eval_metric_loss`参数下，模型被裁剪的比例情况。可视化结果纵轴为eval_metric_loss参数值，横轴为对应的模型被裁剪的比例。
+利用此接口，可以分析在不同的`eval_metric_loss`参数下，模型被剪裁的比例情况。可视化结果纵轴为eval_metric_loss参数值，横轴为对应的模型被剪裁的比例。`eval_metric_loss`即卷积的敏感度，是指按照剪裁率将模型剪裁后模型精度的损失。
 
 ### 参数
 >* **model** (paddlex.cv.models): 使用PaddleX加载的模型。
diff --git a/docs/appendix/interpret.md b/docs/appendix/interpret.md
index 00fa12cb2c08f3756e5a03bb75c9cfd08e5c8329..a015e30d075ede9cb0c1faf41a9b4b3541492cc8 100644
--- a/docs/appendix/interpret.md
+++ b/docs/appendix/interpret.md
@@ -1,16 +1,16 @@
 # PaddleX可解释性
 
-目前深度学习模型普遍存在一个问题，因为使用模型预测还是一个黑盒，几乎无法去感知它的内部工作状态，预测结果的可信度一直遭到质疑。为此，PadlleX提供了2种对图像分类预测结果进行可解释性研究的算法：LIME和NormLIME。
+目前深度学习普遍存在一个问题：模型目前还是黑盒，几乎无法感知到它的内部工作状态，预测结果的可信度一直遭到质疑。为此，PadlleX提供了2种对图像分类预测结果进行可解释性研究的算法：LIME和NormLIME。
 
 ## LIME
 LIME全称Local interpretable model-agnostic explanations，表示一种与模型无关的局部可解释性。其实现步骤主要如下：
 1. 获取图像的超像素。  
-2. 以输入样本为中心，在其附近的空间中进行随机采样，每个采样即对对象中的超像素进行随机遮掩（每个采样的权重和该采样与原样本的距离成反比）。  
+2. 以输入样本为中心，在其附近的空间中进行随机采样，每个采样即对样本中的超像素进行随机遮掩（每个采样的权重和该采样与原样本的距离成反比）。  
 3. 每个采样通过预测模型得到新的输出，这样得到一系列的输入`X`和对应的输出`Y`。  
 4. 将`X`转换为超像素特征`F`，用一个简单的、可解释的模型`Model`（这里使用岭回归）来拟合`F`和`Y`的映射关系。  
 5. `Model`将得到`F`每个输入维度的权重（每个维度代表一个超像素），以此来解释模型。  
 
-LIME的使用方式可参见[代码示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/interpret/lime.py)和[api介绍](../apis/visualize.html#lime)。在使用时，参数中的`num_samples`设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数`batch_size`则表示在计算上述步骤3时，预测的batch size，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定。  
+LIME的使用方式可参见[代码示例](https://github.com/PaddlePaddle/PaddleX/blob/develop/tutorials/interpret/lime.py)和[api介绍](../apis/visualize.html#lime)。在使用时，参数中的`num_samples`设置尤为重要，其表示上述步骤2中的随机采样的个数，若设置过小会影响可解释性结果的稳定性，若设置过大则将在上述步骤3耗费较长时间；参数`batch_size`则表示在计算上述步骤3时，若设置过小将在上述步骤3耗费较长时间，而上限则根据机器配置决定。  
 
 最终LIME可解释性算法的可视化结果如下所示：  
 ![](images/lime.png)  
diff --git a/docs/appendix/parameters.md b/docs/appendix/parameters.md
index d0f913600aa3a402be95ae9b998b3dfc2dd45901..df69da83a76ddff265e5a2dad1c31f5e6370fa96 100644
--- a/docs/appendix/parameters.md
+++ b/docs/appendix/parameters.md
@@ -2,12 +2,12 @@
 
 PaddleX所有训练接口中，内置的参数均为根据单GPU卡相应batch_size下的较优参数，用户在自己的数据上训练模型，涉及到参数调整时，如无太多参数调优经验，则可参考如下方式
 
-## 1.Epoch数的调整
-Epoch数是模型训练过程，迭代的轮数，用户可以设置较大的数值，根据模型迭代过程在验证集上的指标表现，来判断模型是否收敛，进而提前终止训练。此外也可以使用`train`接口中的`early_stop`策略，模型在训练过程会自动判断模型是否收敛自动中止。
+## 1.num_epochs的调整
+num_epochs是模型训练迭代的总轮数(模型对训练集全部样本过一遍即为一个epoch)，用户可以设置较大的数值，根据模型迭代过程在验证集上的指标表现，来判断模型是否收敛，进而提前终止训练。此外也可以使用`train`接口中的`early_stop`策略，模型在训练过程会自动判断模型是否收敛自动中止。
 
 ## 2.batch_size和learning_rate
 
-> - Batch Size指模型在训练过程中，一次性处理的样本数量
+> - Batch Size指模型在训练过程中，前向计算一次(即为一个step)所用到的样本数量
 > - 如若使用多卡训练， batch_size会均分到各张卡上（因此需要让batch size整除卡数）
 > - Batch Size跟机器的显存/内存高度相关，`batch_size`越高，所消耗的显存/内存就越高
 > - PaddleX在各个`train`接口中均配置了默认的batch size(默认针对单GPU卡)，如若训练时提示GPU显存不足，则相应调低BatchSize，如若GPU显存高或使用多张GPU卡时，可相应调高BatchSize。
@@ -15,9 +15,9 @@ Epoch数是模型训练过程，迭代的轮数，用户可以设置较大的数
 
 ## 3.warmup_steps和warmup_start_lr
 
-在训练模型时，一般都会使用预训练模型，例如检测模型在训练时使用backbone在ImageNet数据集上的预训练权重。但由于在自行训练时，自己的数据与ImageNet数据集存在较大的差异，可能会一开始由于梯度过大使得训练出现问题，因此可以在刚开始训练时，让学习率以一个较小的值，慢慢增长到设定的学习率。因此`warmup_steps`和`warmup_start_lr`就是这个作用，模型开始训练时，学习率会从`warmup_start_lr`开始，在`warmup_steps`个batch数据迭代后线性增长到设定的学习率。
+在训练模型时，一般都会使用预训练模型，例如检测模型在训练时使用backbone在ImageNet数据集上的预训练权重。但由于在自行训练时，自己的数据与ImageNet数据集存在较大的差异，可能会一开始由于梯度过大使得训练出现问题，这种情况下可以在刚开始训练时，让学习率以一个较小的值，慢慢增长到设定的学习率。`warmup_steps`和`warmup_start_lr`就是起到这个作用，模型开始训练时，学习率会从`warmup_start_lr`开始，在`warmup_steps`个batch数据迭代后线性增长到设定的学习率。
 
-> 例如YOLOv3的train接口，默认`train_batch_size`为8，`learning_rate`为0.000125, `warmup_steps`为1000， `warmup_start_lr`为0.0；在此参数配置下表示，模型在启动训练后，在前1000个step(每个step表示一个batch的数据，也就是8个样本)内，学习率会从0.0开始线性增长到设定的0.000125。
+> 例如YOLOv3的train接口，默认`train_batch_size`为8，`learning_rate`为0.000125, `warmup_steps`为1000， `warmup_start_lr`为0.0；在此参数配置下表示，模型在启动训练后，在前1000个step(每个step使用一个batch的数据，即8个样本)内，学习率会从0.0开始线性增长到设定的0.000125。
 
 ## 4.lr_decay_epochs和lr_decay_gamma
 
@@ -46,7 +46,7 @@ num_steps_each_eposh = num_samples_in_train_dataset // train_batch_size
 在`import paddlex`前配置环境变量，代码如下
 ```
 import os
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' # 使用第1张GPU卡进行训练
+os.environ['CUDA_VISIBLE_DEVICES'] = '0' # 使用0号GPU卡进行训练
 # 注意paddle或paddlex都需要在设置环境变量后再import
 import paddlex as pdx
 ```
@@ -59,7 +59,7 @@ import paddlex as pdx
 
 ```
 import os
-os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,3' # 使用第1、2、4张GPU卡进行训练
+os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,3' # 同时使用第0、1、3号GPU卡进行训练
 import paddlex as pdx
 ```
 
@@ -67,7 +67,7 @@ import paddlex as pdx
 ## 相关模型接口
 
 - 图像分类模型 [train接口](../apis/models/classification.html#train)
-- FasterRCNN [train接口](../apis/models/detection.html#id1)
-- YOLOv3 [train接口](../apis/models/detection.html#train)
-- MaskRCNN [train接口](../apis/models/instance_segmentation.html#train)
-- DeepLabv3p [train接口](../apis/models/semantic_segmentation.html#train)
+- 目标检测FasterRCNN [train接口](../apis/models/detection.html#id1)
+- 目标检测YOLOv3 [train接口](../apis/models/detection.html#train)
+- 实例分割MaskRCNN [train接口](../apis/models/instance_segmentation.html#train)
+- 语义分割 [train接口](../apis/models/semantic_segmentation.html#train)
diff --git a/docs/deploy/nvidia-jetson.md b/docs/deploy/nvidia-jetson.md
index 7b249a5ec981c318067ee455760898bbb87b040d..a707f4689198f0c1c626d75938a53df76ebfa881 100644
--- a/docs/deploy/nvidia-jetson.md
+++ b/docs/deploy/nvidia-jetson.md
@@ -1,10 +1,10 @@
 # Nvidia Jetson开发板
 
 ## 说明
-本文档在 `Linux`平台使用`GCC 4.8.5` 和 `GCC 4.9.4`测试过，如果需要使用更高G++版本编译使用，则需要重新编译Paddle预测库，请参考: [Nvidia Jetson嵌入式硬件预测库源码编译](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/advanced_guide/inference_deployment/inference/build_and_install_lib_cn.html#id12)。
+本文档在 `Linux`平台使用`GCC 7.4`测试过，如果需要使用更高G++版本编译使用，则需要重新编译Paddle预测库，请参考: [Nvidia Jetson嵌入式硬件预测库源码编译](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/advanced_guide/inference_deployment/inference/build_and_install_lib_cn.html#id12)。
 
 ## 前置条件
-* G++ 4.8.2 ~ 4.9.4
+* G++ 7.4
 * CUDA 9.0 / CUDA 10.0, CUDNN 7+ （仅在使用GPU版本的预测库时需要）
 * CMake 3.0+
 
diff --git a/docs/deploy/paddlelite/android.md b/docs/deploy/paddlelite/android.md
index 88c0e04bfab6de691b311df691dd387b2696607d..fa5de4d9baadc0a71bdf7a85f2538bbe08596f3d 100644
--- a/docs/deploy/paddlelite/android.md
+++ b/docs/deploy/paddlelite/android.md
@@ -1,6 +1,6 @@
 # Android平台
 
-PaddleX的安卓端部署由Paddle Lite实现，部署的流程如下，首先将训练好的模型导出为inference model，然后对模型进行优化，最后使用Paddle Lite的预测库进行部署，Paddle Lite的详细介绍和使用可参考：[Paddle Lite文档](https://paddle-lite.readthedocs.io/zh/latest/)
+PaddleX的安卓端部署基于Paddle Lite实现，部署的流程如下，首先将训练好的模型导出为inference model，然后对模型进行优化，最后使用Paddle Lite预测库进行部署，Paddle Lite的详细介绍和使用可参考：[Paddle Lite文档](https://paddle-lite.readthedocs.io/zh/latest/)
 
 > PaddleX --> Inference Model --> Paddle Lite Opt --> Paddle Lite Inference
 
@@ -18,8 +18,8 @@ PaddleX的安卓端部署由Paddle Lite实现，部署的流程如下，首先
 
 目前提供了两种方法将Paddle模型优化为Paddle Lite模型:
 
-- 1.python脚本优化模型，简单上手，目前支持最新的Paddle Lite 2.6.1版本
-- 2.bin文件优化模型(linux)，支持develop版本(Commit Id:11cbd50e)，适用于部署`DeepLab模型`和`Unet模型`的用户。
+- 1. python脚本优化模型，简单上手，目前支持最新的Paddle Lite 2.6.1版本
+- 2. bin文件优化模型(linux)，支持develop版本(Commit Id:11cbd50e)，**部署语义分割`DeepLab模型`和`Unet模型`时只能采用bin文件优化方式**。
 
 ### 2.1 使用python脚本优化模型
 
@@ -33,7 +33,7 @@ python export_lite.py --model_dir /path/to/inference_model --save_file /path/to/
 |  ----  | ----  |
 | --model_dir  | 预测模型所在路径，包含"\_\_model\_\_", "\_\_params\_\_", "model.yml"文件 |
 | --save_file  | 模型输出的名称，假设为/path/to/lite_model_name, 则输出为路径为/path/to/lite_model_name.nb |
-| --place | 运行的平台，可选：arm\|opencl\|x86\|npu\|xpu\|rknpu\|apu，安卓部署请选择`arm`|
+| --place | 运行的平台，可选：arm\|opencl\|x86\|npu\|xpu\|rknpu\|apu，安卓部署请选择arm|
 
 ### 2.3 使用bin文件优化模型(linux)
 
@@ -58,7 +58,7 @@ python export_lite.py --model_dir /path/to/inference_model --save_file /path/to/
 
 ## 3. 移动端（Android）Demo
 
-PaddleX提供了一个基于Mobilenetv2模型和PaddleX Android SDK的安卓demo，可供用户体验，该demo位于`/PaddleX/deploy/lite/android/demo`，可直接导入Android Studio后运行，并支持用户替换其他PaddleX导出的检测或分割模型进行预测。
+PaddleX提供了基于PaddleX Android SDK的安卓demo，位于`/PaddleX/deploy/lite/android/demo`，该demo已预置了MobilenetV2的模型参数，用户可直接将该demo导入Android Studio后运行体验，同时也支持用户将预置的Mobilenetv2模型参数替换成其他PaddleX导出的检测或分割模型进行预测。
 
 ### 3.1 要求
 
@@ -83,14 +83,14 @@ PaddleX提供了一个基于Mobilenetv2模型和PaddleX Android SDK的安卓demo
 - 将.nb文件拷贝到`/src/main/assets/model/`目录下, 根据.nb文件的名字，修改文件`/src/main/res/values/strings.xml`中的`MODEL_PATH_DEFAULT`；
 - 将.yml文件拷贝到`/src/main/assets/config/`目录下，根据.yml文件的名字，修改文件`/src/main/res/values/strings.xml`中的`YAML_PATH_DEFAULT`；
 - 可根据需要替换测试图片，将图片拷贝到`/src/main/assets/images/`目录下，根据图片文件的名字，修改文件`/src/main/res/values/strings.xml`中的`IMAGE_PATH_DEFAULT`；
-- 点击菜单栏的Run->Run 'App'按钮，在弹出的"Select Deployment Target"窗口选择已经连接的Android设备，然后点击"OK"按钮；
+- 将工程导入后，点击菜单栏的Run->Run 'App'按钮，在弹出的"Select Deployment Target"窗口选择已经连接的Android设备，然后点击"OK"按钮。
 
 ## 4. PaddleX Android SDK和二次开发
 
 PaddleX Android SDK是PaddleX基于Paddle Lite开发的安卓端AI推理工具，以PaddleX导出的Yaml配置文件为接口，针对不同的模型实现图片的预处理，后处理，并进行可视化，开发者可集成到业务中。
 该SDK自底向上主要包括：Paddle Lite推理引擎层，Paddle Lite接口层以及PaddleX业务层。
 
-- Paddle Lite推理引擎层，是在Android上编译好的二进制包，只涉及到Kernel 的执行，且可以单独部署，以支持极致的轻量级部署。
+- Paddle Lite推理引擎层，是在Android上编译好的二进制包，只涉及到Kernel 的执行，且可以单独部署，以支持极致轻量级部署。
 - Paddle Lite接口层，以Java接口封装了底层c++推理库。
 - PaddleX业务层，封装了PaddleX导出模型的预处理，推理和后处理，以及可视化，支持PaddleX导出的检测、分割、分类模型。
 
@@ -177,8 +177,8 @@ com.baidu.paddlex.postprocess.DetResult.Box
 ##### Fields
 > * **categoryId** (int): 类别ID。
 > * **category** (String): 类别名称。
-> * **score** (float): 预测置信度。
-> * **coordinate** (float[4]): 预测框值:{xmin, ymin, xmax, ymax}。
+> * **score** (float): 预测框的置信度。
+> * **coordinate** (float[4]): 预测框的坐标值{xmin, ymin, xmax, ymax}。
 
 ```java
 com.baidu.paddlex.postprocess.SegResult
@@ -195,9 +195,9 @@ com.baidu.paddlex.postprocess.SegResult.Mask
 ```
 ##### Fields
 > * **scoreData** (float[]): 模型预测在各个类别的置信度，长度为: 1 * numClass *  H * W
-> * **scoreShape** (long[4]): scoreData的shape信息，[1,numClass,H,W]
+> * **scoreShape** (long[4]): scoreData的shape信息，[1, numClass, H, W]
 > * **labelData** (long[]): 模型预测置信度最高的label，长度为: 1 * H * W * 1
-> * **labelShape** (long[4]): labelData的shape信息，[1,H,W,1]
+> * **labelShape** (long[4]): labelData的shape信息，[1, H, W, 1]
 
 ### 4.4 SDK二次开发
 
diff --git a/docs/deploy/paddlelite/slim/prune.md b/docs/deploy/paddlelite/slim/prune.md
index acf89ad31df59946f819a6e7eedfac717d914bf1..f246d8b875e4800b4f7e502d0d7557992a429e79 100644
--- a/docs/deploy/paddlelite/slim/prune.md
+++ b/docs/deploy/paddlelite/slim/prune.md
@@ -1,55 +1,56 @@
-# 模型裁剪
+# 模型剪裁
 
-为了更好地满足端侧部署场景下，低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim实现`模型裁剪`，可提升Paddle Lite端侧部署性能。
+为了更好地满足端侧部署场景下低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim来实现模型剪裁功能，进一步提升Paddle Lite端侧部署性能。
 
 ## 原理介绍
 
-模型裁剪通过裁剪卷积层中Kernel输出通道的大小及其关联层参数大小，来减小模型大小和降低模型计算复杂度，可以加快模型部署后的预测速度，其关联裁剪的原理可参见[PaddleSlim相关文档](https://paddlepaddle.github.io/PaddleSlim/algo/algo.html#id16)。**一般而言，在同等模型精度前提下，数据复杂度越低，模型可以被裁剪的比例就越高**。
+模型剪裁通过剪裁卷积层中Kernel输出通道的大小及其关联层参数大小，来减小模型大小和降低模型计算复杂度，可以加快模型部署后的预测速度，其关联剪裁的原理可参见[PaddleSlim相关文档](https://paddlepaddle.github.io/PaddleSlim/algo/algo.html#id16)。**一般而言，在同等模型精度前提下，数据复杂度越低，模型可以被剪裁的比例就越高**。
 
-## 裁剪方法
+## 剪裁方法
 PaddleX提供了两种方式:
 
-**1.用户自行计算裁剪配置(推荐)，整体流程包含三个步骤,**  
-> **第一步**： 使用数据集训练原始模型  
-> **第二步**：利用第一步训练好的模型，在验证数据集上计算模型中各个参数的敏感度，并将敏感度信息存储至本地文件  
-> **第三步**：使用数据集训练裁剪模型（与第一步差异在于需要在`train`接口中，将第二步计算得到的敏感信息文件传给接口的`sensitivities_file`参数）  
+**1.用户自行计算剪裁配置(推荐)，整体流程包含三个步骤**
 
-> 在如上三个步骤中，**相当于模型共需要训练两遍**，分别对应第一步和第三步，但其中第三步训练的是裁剪后的模型，因此训练速度较第一步会更快。  
-> 第二步会遍历模型中的部分裁剪参数，分别计算各个参数裁剪后对于模型在验证集上效果的影响，**因此会反复在验证集上评估多次**。  
+* **第一步**： 使用数据集训练原始模型  
+* **第二步**：利用第一步训练好的模型，在验证数据集上计算模型中各个参数的敏感度，并将敏感度信息存储至本地文件  
+* **第三步**：使用数据集训练剪裁模型（与第一步差异在于需要在`train`接口中，将第二步计算得到的敏感信息文件传给接口的`sensitivities_file`参数）  
 
-**2.使用PaddleX内置的裁剪方案**  
-> PaddleX内置的模型裁剪方案是**基于标准数据集**上计算得到的参数敏感度信息，由于不同数据集特征分布会有较大差异，所以该方案相较于第1种方案训练得到的模型**精度一般而言会更低**（**且用户自定义数据集与标准数据集特征分布差异越大，导致训练的模型精度会越低**），仅在用户想节省时间的前提下可以参考使用，使用方式只需一步，  
+> 以上三个步骤**相当于模型需要训练两遍**，第一遍和第二遍分别对应上面的第一步和第三步，但其中第三步训练的是剪裁后的模型，因此训练速度较第一步会更快。  
+> 上面的第二步会遍历模型中的部分剪裁参数，分别计算各个参数剪裁后对于模型在验证集上效果的影响，**因此会在验证集上评估多次**。  
 
-> **一步**： 使用数据集训练裁剪模型，在训练调用`train`接口时，将接口中的`sensitivities_file`参数设置为'DEFAULT'字符串
+**2.使用PaddleX内置的剪裁方案**  
+> PaddleX内置的模型剪裁方案是**基于各任务常用的公开数据集**上计算得到的参数敏感度信息，由于不同数据集特征分布会有较大差异，所以该方案相较于第1种方案剪裁得到的模型**精度一般而言会更低**（**且用户自定义数据集与标准数据集特征分布差异越大，导致训练的模型精度会越低**），仅在用户想节省时间的前提下可以参考使用，使用方式只需一步，  
 
-> 注：各模型内置的裁剪方案分别依据的数据集为： 图像分类——ImageNet数据集、目标检测——PascalVOC数据集、语义分割——CityScape数据集
+> **一步**： 使用数据集训练剪裁模型，在训练调用`train`接口时，将接口中的`sensitivities_file`参数设置为`DEFAULT`字符串
 
-## 裁剪实验
+> 注：各模型内置的剪裁方案分别依据的公开数据集为： 图像分类——ImageNet数据集、目标检测——PascalVOC数据集、语义分割——CityScape数据集
+
+## 剪裁实验
 基于上述两种方案，我们在PaddleX上使用样例数据进行了实验，在Tesla P40上实验指标如下所示:
 
 ### 图像分类
-实验背景：使用MobileNetV2模型，数据集为蔬菜分类示例数据，裁剪训练代码见[tutorials/compress/classification](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/classification)
+实验背景：使用MobileNetV2模型，数据集为蔬菜分类示例数据，剪裁训练代码见[tutorials/compress/classification](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/classification)
 
-| 模型 | 裁剪情况 | 模型大小 | Top1准确率(%) |GPU预测速度 | CPU预测速度 |
+| 模型 | 剪裁情况 | 模型大小 | Top1准确率(%) |GPU预测速度 | CPU预测速度 |
 | :-----| :--------| :-------- | :---------- |:---------- |:----------|
-|MobileNetV2 | 无裁剪（原模型）| 13.0M | 97.50|6.47ms |47.44ms |
+|MobileNetV2 | 无剪裁（原模型）| 13.0M | 97.50|6.47ms |47.44ms |
 |MobileNetV2 | 方案一(eval_metric_loss=0.10) | 2.1M | 99.58 |5.03ms |20.22ms |
 |MobileNetV2 | 方案二(eval_metric_loss=0.10) | 6.0M | 99.58 |5.42ms |29.06ms |
 
 ### 目标检测
-实验背景：使用YOLOv3-MobileNetV1模型，数据集为昆虫检测示例数据，裁剪训练代码见[tutorials/compress/detection](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/detection)
+实验背景：使用YOLOv3-MobileNetV1模型，数据集为昆虫检测示例数据，剪裁训练代码见[tutorials/compress/detection](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/detection)
 
-| 模型 | 裁剪情况 | 模型大小 | MAP(%) |GPU预测速度 | CPU预测速度 |
+| 模型 | 剪裁情况 | 模型大小 | MAP(%) |GPU预测速度 | CPU预测速度 |
 | :-----| :--------| :-------- | :---------- |:---------- | :---------|
-|YOLOv3-MobileNetV1 | 无裁剪（原模型）| 139M | 67.57| 14.88ms |976.42ms |
+|YOLOv3-MobileNetV1 | 无剪裁（原模型）| 139M | 67.57| 14.88ms |976.42ms |
 |YOLOv3-MobileNetV1 | 方案一(eval_metric_loss=0.10) | 34M | 75.49 |10.60ms |558.49ms |
 |YOLOv3-MobileNetV1 | 方案二(eval_metric_loss=0.05) | 29M | 50.27| 9.43ms |360.46ms |
 
 ### 语义分割
-实验背景：使用UNet模型，数据集为视盘分割示例数据，裁剪训练代码见[tutorials/compress/segmentation](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/segmentation)
+实验背景：使用UNet模型，数据集为视盘分割示例数据，剪裁训练代码见[tutorials/compress/segmentation](https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/compress/segmentation)
 
-| 模型 | 裁剪情况 | 模型大小 | mIOU(%) |GPU预测速度 | CPU预测速度 |
+| 模型 | 剪裁情况 | 模型大小 | mIOU(%) |GPU预测速度 | CPU预测速度 |
 | :-----| :--------| :-------- | :---------- |:---------- | :---------|
-|UNet | 无裁剪（原模型）| 77M | 91.22 |33.28ms |9523.55ms |
+|UNet | 无剪裁（原模型）| 77M | 91.22 |33.28ms |9523.55ms |
 |UNet | 方案一(eval_metric_loss=0.10) |26M | 90.37 |21.04ms |3936.20ms |
 |UNet | 方案二(eval_metric_loss=0.10) |23M | 91.21 |18.61ms |3447.75ms |
diff --git a/docs/deploy/paddlelite/slim/quant.md b/docs/deploy/paddlelite/slim/quant.md
index cb0558c0d1fbf2e321ca434313349c7f4b5c3c3f..1903b84a3d2a4bda76055392d6a7115a2eda324d 100644
--- a/docs/deploy/paddlelite/slim/quant.md
+++ b/docs/deploy/paddlelite/slim/quant.md
@@ -1,12 +1,12 @@
 # 模型量化
 
-为了更好地满足端侧部署场景下，低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim实现`模型量化`，可提升Paddle Lite端侧部署性能。
+为了更好地满足端侧部署场景下低内存带宽、低功耗、低计算资源占用以及低模型存储等需求，PaddleX通过集成PaddleSlim来实现模型量化功能，进一步提升Paddle Lite端侧部署性能。
 
 ## 原理介绍
 定点量化使用更少的比特数（如8-bit、3-bit、2-bit等）表示神经网络的权重和激活值，从而加速模型推理速度。PaddleX提供了训练后量化技术，其原理可参见[训练后量化原理](https://paddlepaddle.github.io/PaddleSlim/algo/algo.html#id14)，该量化使用KL散度确定量化比例因子，将FP32模型转成INT8模型，且不需要重新训练，可以快速得到量化模型。
 
 ## 使用PaddleX量化模型
-PaddleX提供了`export_quant_model`接口，让用户以接口的形式完成模型以post_quantization方式量化并导出。点击查看[量化接口使用文档](../../../apis/slim.html)。
+PaddleX提供了`export_quant_model`接口，让用户以接口的形式对训练后的模型进行量化。点击查看[量化接口使用文档](../../../apis/slim.html)。
 
 ## 量化性能对比
 模型量化后的性能对比指标请查阅[PaddleSlim模型库](https://paddlepaddle.github.io/PaddleSlim/model_zoo.html)
diff --git a/docs/deploy/server/cpp/linux.md b/docs/deploy/server/cpp/linux.md
index ee95a24d7726cf764de18ddb3a3a8bb3c80ac8d7..c7813ede08082555268eba5a46a77cbcd4cab13e 100644
--- a/docs/deploy/server/cpp/linux.md
+++ b/docs/deploy/server/cpp/linux.md
@@ -136,7 +136,7 @@ yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将`URL https://
 
 可使用[小度熊识别模型](../../export_model.md)中导出的`inference_model`和测试图片进行预测，导出到/root/projects，模型路径为/root/projects/inference_model。
 
-> 关于预测速度的说明：Paddle在部署预测时，由于涉及到内存显存初始化等原因，在模型加载后刚开始预测速度会较慢，一般在模型运行20~50后（即预测20~30张图片）预测速度才会稳定。
+> 关于预测速度的说明：加载模型后前几张图片的预测速度会较慢，这是因为运行启动时涉及到内存显存初始化等步骤，通常在预测20-30张图片后模型的预测速度达到稳定。
 
 `样例一`：
 
diff --git a/docs/deploy/server/cpp/windows.md b/docs/deploy/server/cpp/windows.md
index aab06a9748a806c96b224ad70fce9b571ddbe134..641d1cba9262e60bf43a152f288e23bda4b74464 100644
--- a/docs/deploy/server/cpp/windows.md
+++ b/docs/deploy/server/cpp/windows.md
@@ -59,22 +59,17 @@ PaddlePaddle C++ 预测库针对是否使用GPU、是否支持TensorRT、以及
 ### Step4: 使用Visual Studio 2019直接编译CMake
 
 1. 打开Visual Studio 2019 Community，点击`继续但无需代码`
-
-![step2](../../images/vs2019_step1.png)
+![](../../images/vs2019_step1.png)
 2. 点击： `文件`->`打开`->`CMake`
 
-![step2.1](../../images/vs2019_step2.png)
+![](../../images/vs2019_step2.png)
 
 选择C++预测代码所在路径（例如`D:\projects\PaddleX\deploy\cpp`），并打开`CMakeList.txt`：
-
-![step2.2](../../images/vs2019_step3.png)
+![](../../images/vs2019_step3.png)
 3. 点击：`项目`->`CMake设置`
-
-![step3](../../images/vs2019_step4.png)
+![](../../images/vs2019_step4.png)
 4. 点击`浏览`，分别设置编译选项指定`CUDA`、`OpenCV`、`Paddle预测库`的路径
-
-![step3](../../images/vs2019_step5.png)
-
+![](../../images/vs2019_step5.png)
 依赖库路径的含义说明如下（带*表示仅在使用**GPU版本**预测库时指定, 其中CUDA库版本尽量与Paddle预测库的对齐，例如Paddle预测库是**使用9.0、10.0版本**编译的，则编译PaddleX预测代码时**不使用9.2、10.1等版本**CUDA库）：
 
 |  参数名   | 含义  |
@@ -86,14 +81,10 @@ PaddlePaddle C++ 预测库针对是否使用GPU、是否支持TensorRT、以及
 **注意：**
 1. 如果使用`CPU`版预测库，请把`WITH_GPU`的`值`去掉勾
 2. 如果使用的是`openblas`版本，请把`WITH_MKL`的`值`去掉勾
-3. Windows环境下编译会自动下载YAML，如果编译环境无法访问外网，可手动下载： [yaml-cpp.zip](https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip)
-yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将`URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip` 中的网址，改为下载文件的路径。
-4. 如果需要使用模型加密功能，需要手动下载[Windows预测模型加密工具](https://bj.bcebos.com/paddlex/tools/win/paddlex-encryption.zip)。例如解压到D:/projects，解压后目录为D:/projects/paddlex-encryption。编译时需勾选WITH_EBNCRYPTION并且在ENCRTYPTION_DIR填入D:/projects/paddlex-encryption。
-
-![step_encryption](../../images/vs2019_step_encryption.png)
-
-![step4](../../images/vs2019_step6.png)
-
+3. Windows环境下编译会自动下载YAML，如果编译环境无法访问外网，可手动下载： [yaml-cpp.zip](https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip)。YAML文件下载后无需解压，在`cmake/yaml.cmake`中将`URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip` 中的网址，改为下载文件的路径。
+4. 如果需要使用模型加密功能，需要手动下载[Windows预测模型加密工具](https://bj.bcebos.com/paddlex/tools/win/paddlex-encryption.zip)。例如解压到`D:/projects`，解压后目录为`D:/projects/paddlex-encryption`。编译时需勾选`WITH_EBNCRYPTION`并且在`ENCRTYPTION_DIR`填入`D:/projects/paddlex-encryption`。
+![](../../images/vs2019_step_encryption.png)
+![](../../images/vs2019_step6.png)
 **设置完成后**, 点击上图中`保存并生成CMake缓存以加载变量`。
 5. 点击`生成`->`全部生成`
 
@@ -101,7 +92,7 @@ yaml-cpp.zip文件下载后无需解压，在cmake/yaml.cmake中将`URL https://
 
 ### Step5: 预测及可视化
 
-**在加载模型前，请检查你的模型目录中文件应该包括`model.yml`、`__model__`和`__params__`三个文件。如若不满足这个条件，请参考[模型导出为Inference文档](../../export_model.md)将模型导出为部署格式。**  
+**在加载模型前，请检查你的模型目录中文件应该包括`model.yml`、`__model__`和`__params__`三个文件。如若不满足这个条件，请参考[部署模型导出](../../export_model.md)将模型导出为部署格式。**  
 
 上述`Visual Studio 2019`编译产出的可执行文件在`out\build\x64-Release`目录下，打开`cmd`，并切换到该目录：
 
@@ -119,7 +110,7 @@ cd D:\projects\PaddleX\deploy\cpp\out\build\x64-Release
 | image_list  | 按行存储图片路径的.txt文件 |
 | use_gpu  | 是否使用 GPU 预测, 支持值为0或1(默认值为0) |
 | gpu_id  | GPU 设备ID, 默认值为0 |
-| save_dir | 保存可视化结果的路径, 默认值为"output"，classfier无该参数 |
+| save_dir | 保存可视化结果的路径, 默认值为"output"，classifier无该参数 |
 | key | 加密过程中产生的密钥信息，默认值为""表示加载的是未加密的模型 |
 | batch_size | 预测的批量大小，默认为1 |
 | thread_num | 预测的线程数，默认为cpu处理器个数 |
@@ -127,9 +118,10 @@ cd D:\projects\PaddleX\deploy\cpp\out\build\x64-Release
 
 ## 样例
 
-可使用[小度熊识别模型](../../export_model.md)中导出的`inference_model`和测试图片进行预测, 例如导出到D:\projects，模型路径为D:\projects\inference_model。
+可使用[小度熊识别模型](../../export_model.md)中导出的`inference_model`和测试图片进行预测, 例如导出到`D:\projects`，模型路径为`D:\projects\inference_model`。
+
+> 关于预测速度的说明：加载模型后前几张图片的预测速度会较慢，这是因为运行启动时涉及到内存显存初始化等步骤，通常在预测20-30张图片后模型的预测速度达到稳定。
 
-> 关于预测速度的说明：Paddle在部署预测时，由于涉及到内存显存初始化等原因，在模型加载后刚开始预测速度会较慢，一般在模型运行20~50后（即预测20~30张图片）预测速度才会稳定。
 
 ### 样例一：(使用未加密的模型对单张图像做预测)
 
diff --git a/docs/deploy/server/encryption.md b/docs/deploy/server/encryption.md
index fa9c65efae1ef135381d4c9df7696f40aec3e204..dcf67b1b8de31afcd638b5858624b52a5c17872a 100644
--- a/docs/deploy/server/encryption.md
+++ b/docs/deploy/server/encryption.md
@@ -34,7 +34,7 @@ PaddleX提供一个轻量级的模型加密部署方案，通过PaddleX内置的
 >
 > 6）在模型解密环节根据加密后的文件读取相关的加密数据到内存中，对内存数据使用AES算法进行解密，注意解密时需要采用与加密时一致的加密算法和加密的模式，以及密钥的数据和长度，否则会导致解密后数据错误。
 >
-> 7）集成模型预测的C/C++库，在具体使用预测时一般涉及paddle::AnalysisConfig和paddle:Predictor，为了能够从内存数据中直接load解密后的模型明文数据（避免模型解密后创建临时文件），这里需要将AnalysisConfig的模型加载函数从SetModel替换为SetModelBuffer来实现从内存中加载模型数据。
+> 7）集成模型预测的C/C++库，在具体使用预测时一般涉及paddle::AnalysisConfig和paddle::Predictor，为了能够从内存数据中直接load解密后的模型明文数据（避免模型解密后创建临时文件），这里需要将AnalysisConfig的模型加载函数从SetModel替换为SetModelBuffer来实现从内存中加载模型数据。
 
 需要注意的是，在本方案中，密钥集成在上层预测服务的代码中。故模型的安全强度等同于代码抵御逆向调试的强度。为了保护密钥和模型的安全，开发者还需对自己的应用进行加固保护。常见的应用加固手段有：代码混淆，二进制文件加壳 等等，亦或将加密机制更改为AES白盒加密技术来保护密钥。这类技术领域内有大量商业和开源产品可供选择，此处不一一赘述。
 
diff --git a/docs/deploy/server/python.md b/docs/deploy/server/python.md
index e30e2f41e40b46dc3c24ec3ea924f2ce66f19095..36b0891176bb9cf86078a3c9f9dfe5b48419613b 100644
--- a/docs/deploy/server/python.md
+++ b/docs/deploy/server/python.md
@@ -30,7 +30,7 @@ image_list = ['xiaoduxiong_test_image/JPEGImages/WeChatIMG110.jpeg',
 result = predictor.predict(image_list=image_list)
 ```
 
-**关于预测速度的说明**：加载模型后前几张图片的预测速度会较慢，这是因为运行启动时涉及到内存显存初始化等步骤，通常在预测20-30张图片后模型的预测速度表现稳定。
+> 关于预测速度的说明：加载模型后前几张图片的预测速度会较慢，这是因为运行启动时涉及到内存显存初始化等步骤，通常在预测20-30张图片后模型的预测速度达到稳定。
 
 ## 预测性能对比
 ### 测试环境
diff --git a/docs/gui/index.rst b/docs/gui/index.rst
index a42ac0441fcb324ee2338367b854462c707c9d59..f823b428bf09babffc8da3c4881d531f047a6099 100755
--- a/docs/gui/index.rst
+++ b/docs/gui/index.rst
@@ -1,7 +1,7 @@
 PaddleX GUI
 =======================================
 
-PaddleX GUI是基于PaddleX实现的可视化开发客户端。开发者可以点选、键入的方式快速体验深度学习模型开发的全流程。不仅可以作为您提升深度学习模型开发效率的工具，更可以作为您们应用PaddleX API搭建专属的行业软件/应用的示例参照。
+PaddleX GUI是基于PaddleX实现的可视化开发客户端。开发者以点选、键入的方式快速体验深度学习模型开发的全流程。不仅可以作为您提升深度学习模型开发效率的工具，更可以作为您们应用PaddleX API搭建专属的行业软件/应用的示例参照。
 
 PaddleX GUI 当前提供Windows，Mac，Ubuntu三种版本一键绿色安装的方式。请至[飞桨官网](https://www.paddlepaddle.org.cn/)下载您需要的版本。
 
diff --git a/paddlex/cv/datasets/imagenet.py b/paddlex/cv/datasets/imagenet.py
index 75567d01efc43d2ecaa39720fa6590d8f1f4342e..41024e6a37b365d91a83f075c8b289e1f9f8a826 100644
--- a/paddlex/cv/datasets/imagenet.py
+++ b/paddlex/cv/datasets/imagenet.py
@@ -34,7 +34,7 @@ class ImageNet(Dataset):
         num_workers (int|str): 数据集中样本在预处理过程中的线程或进程数。默认为'auto'。当设为'auto'时，根据
             系统的实际CPU核数设置`num_workers`: 如果CPU核数的一半大于8，则`num_workers`为8，否则为CPU核
             数的一半。
-        buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
+        buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为8。
         parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'
             线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。
         shuffle (bool): 是否需要对数据集中样本打乱顺序。默认为False。
diff --git a/paddlex/cv/datasets/seg_dataset.py b/paddlex/cv/datasets/seg_dataset.py
index b4ee7184a7f5de3210282cbab9726e1a306f52d3..40596ebb5e1071cd42a476423523b7c05c267abc 100644
--- a/paddlex/cv/datasets/seg_dataset.py
+++ b/paddlex/cv/datasets/seg_dataset.py
@@ -31,7 +31,7 @@ class SegDataset(Dataset):
         file_list (str): 描述数据集图片文件和对应标注文件的文件路径（文本内每行路径为相对data_dir的相对路）。
         label_list (str): 描述数据集包含的类别信息文件路径。默认值为None。
         transforms (list): 数据集中每个样本的预处理/增强算子。
-        num_workers (int): 数据集中样本在预处理过程中的线程或进程数。默认为4。
+        num_workers (int): 数据集中样本在预处理过程中的线程或进程数。默认为'auto'。
         buffer_size (int): 数据集中样本在预处理过程中队列的缓存长度，以样本数为单位。默认为100。
         parallel_method (str): 数据集中样本在预处理过程中并行处理的方式，支持'thread'
             线程和'process'进程两种方式。默认为'process'（Windows和Mac下会强制使用thread，该参数无效）。
diff --git a/setup.py b/setup.py
index 7eeb44f07bfdae4fdf31d4d0ed78d077392a5560..c7dbd5b9b33368877907d2de04beb8a32f2b714a 100644
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,8 @@ setuptools.setup(
     setup_requires=['cython', 'numpy'],
     install_requires=[
         "pycocotools;platform_system!='Windows'", 'pyyaml', 'colorama', 'tqdm',
-        'paddleslim==1.0.1', 'visualdl>=2.0.0b', 'paddlehub>=1.6.2'
+        'paddleslim==1.0.1', 'visualdl>=2.0.0b', 'paddlehub>=1.6.2',
+        'shapely>=1.7.0'
     ],
     classifiers=[
         "Programming Language :: Python :: 3",
diff --git a/tutorials/compress/README.md b/tutorials/compress/README.md
index e85b4485143bcaa6b0f8cc7845eaa05ca17e83c8..0d2f2eeff72181e40382f30b2b4ceb0ddc96e682 100644
--- a/tutorials/compress/README.md
+++ b/tutorials/compress/README.md
@@ -1,32 +1,35 @@
 # 使用教程——模型压缩
-本目录下整理了使用PaddleX进行模型裁剪训练的代码，代码中均提供了数据的自动下载，并使用单张GPU卡进行训练。
+本目录下整理了使用PaddleX进行模型剪裁训练的代码，代码均会自动下载数据，并使用单张GPU卡进行训练。
 
-PaddleX提供了两种裁剪训练方式，  
-1. 用户自行计算裁剪配置(推荐)，整体流程为
+PaddleX提供了两种剪裁训练方式，  
+1. 用户自行计算剪裁配置(推荐)，整体流程为
 > 1.使用数据训练原始模型；
 > 2.使用第1步训练好的模型，在验证集上计算各个模型参数的敏感度，并将敏感信息保存至本地文件
 > 3.再次使用数据训练原始模型，在训练时调用`train`接口时，传入第2步计算得到的参数敏感信息文件，
-> 4.模型在训练过程中，会根据传入的参数敏感信息文件，对模型结构裁剪后，继续迭代训练
+> 4.模型在训练过程中，会根据传入的参数敏感信息文件，对模型结构剪裁后，继续迭代训练
 >
 2. 使用PaddleX预先计算好的参数敏感度信息文件，整体流程为
-> 1. 在训练调用'train'接口时，将`sensetivities_file`参数设为`DEFAULT`字符串
-> 2. 在训练过程中，会自动下载PaddleX预先计算好的模型参数敏感度信息，并对模型结构裁剪，继而迭代训练
+> 1. 在训练调用`train`接口时，将`sensetivities_file`参数设为`DEFAULT`字符串
+> 2. 在训练过程中，会自动下载PaddleX预先计算好的模型参数敏感度信息，并对模型结构剪裁，继而迭代训练
 
-上述两种方式，第1种方法相对比第2种方法少了两步（即用户训练原始模型+自行计算参数敏感度信息)，在实际实验证，第1种方法的精度会更高，裁剪的模型效果更好，因此在用户时间和计算成本允许的前提下，更推荐使用第1种方法。
+上述两种方式，第1种方法相对比第2种方法少了两步（即用户训练原始模型+自行计算参数敏感度信息)，实验验证第1种方法的精度会更高，剪裁的模型效果更好，因此在时间和计算成本允许的前提下，更推荐使用第1种方法。
 
 
-## 开始裁剪训练
+## 开始剪裁训练
+
+* 第1种方法，用户自行计算剪裁配置
 
-1. 第1种方法，用户自行计算裁剪配置
 ```
 # 训练模型
 python classification/mobilenetv2.py
 # 计算模型参数敏感度
 python classification/cal_sensitivities_file.py --model_dir=output/mobilenetv2/best_model --save_file=./sensitivities.data
-# 裁剪训练
+# 剪裁训练
 python classification/mobilenetv2.py  --model_dir=output/mobilenetv2/best_model --sensitivities_file=./sensitivities.data --eval_metric_loss=0.05
 ```
-2. 第2种方法，使用PaddleX预先计算好的参数敏感度文件
+
+* 第2种方法，使用PaddleX预先计算好的参数敏感度文件
+
 ```
 # 自动下载PaddleX预先在ImageNet上计算好的参数敏感度信息文件
 python classification/mobilenetv2.py --sensitivities_file=DEFAULT --eval_metric_loss=0.05