merge dygraph

deploy/hubserving/readme.md

@@ -34,10 +34,10 @@ pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/sim
 ```
 
 ### 2. 下载推理模型
-安装服务模块前，需要准备推理模型并放到正确路径。默认使用的是v2.0版的超轻量模型，默认模型路径为：
+安装服务模块前，需要准备推理模型并放到正确路径。默认使用的是PP-OCRv2模型，默认模型路径为：
 ```
-检测模型：./inference/ch_ppocr_mobile_v2.0_det_infer/
-识别模型：./inference/ch_ppocr_mobile_v2.0_rec_infer/
+检测模型：./inference/ch_PP-OCRv2_det_infer/
+识别模型：./inference/ch_PP-OCRv2_rec_infer/
 方向分类器：./inference/ch_ppocr_mobile_v2.0_cls_infer/
 ```  
 

deploy/hubserving/readme_en.md

@@ -35,10 +35,10 @@ pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/sim
 ```
 
 ### 2. Download inference model
-Before installing the service module, you need to prepare the inference model and put it in the correct path. By default, the ultra lightweight model of v2.0 is used, and the default model path is:  
+Before installing the service module, you need to prepare the inference model and put it in the correct path. By default, the PP-OCRv2 models are used, and the default model path is:  
 ```
-detection model: ./inference/ch_ppocr_mobile_v2.0_det_infer/
-recognition model: ./inference/ch_ppocr_mobile_v2.0_rec_infer/
+detection model: ./inference/ch_PP-OCRv2_det_infer/
+recognition model: ./inference/ch_PP-OCRv2_rec_infer/
 text direction classifier: ./inference/ch_ppocr_mobile_v2.0_cls_infer/
 ```  
 

deploy/slim/prune/sensitivity_anal.py

@@ -110,25 +110,42 @@ def main(config, device, logger, vdl_writer):
         logger.info("metric['hmean']: {}".format(metric['hmean']))
         return metric['hmean']
 
+    run_sensitive_analysis = False
+    """
+    run_sensitive_analysis=True: 
+        Automatically compute the sensitivities of convolutions in a model. 
+        The sensitivity of a convolution is the losses of accuracy on test dataset in 
+        differenct pruned ratios. The sensitivities can be used to get a group of best 
+        ratios with some condition.
+    
+    run_sensitive_analysis=False: 
+        Set prune trim ratio to a fixed value, such as 10%. The larger the value, 
+        the more convolution weights will be cropped.
+
+    """
+
+    if run_sensitive_analysis:
         params_sensitive = pruner.sensitive(
             eval_func=eval_fn,
-        sen_file="./sen.pickle",
+            sen_file="./deploy/slim/prune/sen.pickle",
             skip_vars=[
-            "conv2d_57.w_0", "conv2d_transpose_2.w_0", "conv2d_transpose_3.w_0"
+                "conv2d_57.w_0", "conv2d_transpose_2.w_0",
+                "conv2d_transpose_3.w_0"
             ])
-
         logger.info(
             "The sensitivity analysis results of model parameters saved in sen.pickle"
         )
         # calculate pruned params's ratio
-    params_sensitive = pruner._get_ratios_by_loss(params_sensitive, loss=0.02)
+        params_sensitive = pruner._get_ratios_by_loss(
+            params_sensitive, loss=0.02)
         for key in params_sensitive.keys():
             logger.info("{}, {}".format(key, params_sensitive[key]))
-
-    #params_sensitive = {}
-    #for param in model.parameters():
-    #    if 'transpose' not in param.name and 'linear' not in param.name:
-    #        params_sensitive[param.name] = 0.1  
+    else:
+        params_sensitive = {}
+        for param in model.parameters():
+            if 'transpose' not in param.name and 'linear' not in param.name:
+                # set prune ratio as 10%. The larger the value, the more convolution weights will be cropped
+                params_sensitive[param.name] = 0.1
 
     plan = pruner.prune_vars(params_sensitive, [0])
 

deploy/slim/quantization/quant_kl.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+
+__dir__ = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(__dir__)
+sys.path.append(os.path.abspath(os.path.join(__dir__, '..', '..', '..')))
+sys.path.append(
+    os.path.abspath(os.path.join(__dir__, '..', '..', '..', 'tools')))
+
+import yaml
+import paddle
+import paddle.distributed as dist
+
+paddle.seed(2)
+
+from ppocr.data import build_dataloader
+from ppocr.modeling.architectures import build_model
+from ppocr.losses import build_loss
+from ppocr.optimizer import build_optimizer
+from ppocr.postprocess import build_post_process
+from ppocr.metrics import build_metric
+from ppocr.utils.save_load import init_model
+import tools.program as program
+import paddleslim
+from paddleslim.dygraph.quant import QAT
+import numpy as np
+
+dist.get_world_size()
+
+
+class PACT(paddle.nn.Layer):
+    def __init__(self):
+        super(PACT, self).__init__()
+        alpha_attr = paddle.ParamAttr(
+            name=self.full_name() + ".pact",
+            initializer=paddle.nn.initializer.Constant(value=20),
+            learning_rate=1.0,
+            regularizer=paddle.regularizer.L2Decay(2e-5))
+
+        self.alpha = self.create_parameter(
+            shape=[1], attr=alpha_attr, dtype='float32')
+
+    def forward(self, x):
+        out_left = paddle.nn.functional.relu(x - self.alpha)
+        out_right = paddle.nn.functional.relu(-self.alpha - x)
+        x = x - out_left + out_right
+        return x
+
+
+quant_config = {
+    # weight preprocess type, default is None and no preprocessing is performed. 
+    'weight_preprocess_type': None,
+    # activation preprocess type, default is None and no preprocessing is performed.
+    'activation_preprocess_type': None,
+    # weight quantize type, default is 'channel_wise_abs_max'
+    'weight_quantize_type': 'channel_wise_abs_max',
+    # activation quantize type, default is 'moving_average_abs_max'
+    'activation_quantize_type': 'moving_average_abs_max',
+    # weight quantize bit num, default is 8
+    'weight_bits': 8,
+    # activation quantize bit num, default is 8
+    'activation_bits': 8,
+    # data type after quantization, such as 'uint8', 'int8', etc. default is 'int8'
+    'dtype': 'int8',
+    # window size for 'range_abs_max' quantization. default is 10000
+    'window_size': 10000,
+    # The decay coefficient of moving average, default is 0.9
+    'moving_rate': 0.9,
+    # for dygraph quantization, layers of type in quantizable_layer_type will be quantized
+    'quantizable_layer_type': ['Conv2D', 'Linear'],
+}
+
+
+def sample_generator(loader):
+    def __reader__():
+        for indx, data in enumerate(loader):
+            images = np.array(data[0])
+            yield images
+
+    return __reader__
+
+
+def main(config, device, logger, vdl_writer):
+    # init dist environment
+    if config['Global']['distributed']:
+        dist.init_parallel_env()
+
+    global_config = config['Global']
+
+    # build dataloader
+    config['Train']['loader']['num_workers'] = 0
+    train_dataloader = build_dataloader(config, 'Train', device, logger)
+    if config['Eval']:
+        config['Eval']['loader']['num_workers'] = 0
+        valid_dataloader = build_dataloader(config, 'Eval', device, logger)
+    else:
+        valid_dataloader = None
+
+    paddle.enable_static()
+    place = paddle.CPUPlace()
+    exe = paddle.static.Executor(place)
+
+    if 'inference_model' in global_config.keys():  # , 'inference_model'):
+        inference_model_dir = global_config['inference_model']
+    else:
+        inference_model_dir = os.path.dirname(global_config['pretrained_model'])
+        if  not (os.path.exists(os.path.join(inference_model_dir, "inference.pdmodel")) and \
+            os.path.exists(os.path.join(inference_model_dir, "inference.pdiparams")) ):
+            raise ValueError(
+                "Please set inference model dir in Global.inference_model or Global.pretrained_model for post-quantazition"
+            )
+
+    paddleslim.quant.quant_post_static(
+        executor=exe,
+        model_dir=inference_model_dir,
+        model_filename='inference.pdmodel',
+        params_filename='inference.pdiparams',
+        quantize_model_path=global_config['save_inference_dir'],
+        sample_generator=sample_generator(train_dataloader),
+        save_model_filename='inference.pdmodel',
+        save_params_filename='inference.pdiparams',
+        batch_size=1,
+        batch_nums=None)
+
+
+if __name__ == '__main__':
+    config, device, logger, vdl_writer = program.preprocess(is_train=True)
+    main(config, device, logger, vdl_writer)

doc/doc_ch/add_new_algorithm.md

@@ -2,16 +2,18 @@
 
 PaddleOCR将一个算法分解为以下几个部分，并对各部分进行模块化处理，方便快速组合出新的算法。
 
-* 数据加载和处理
-* 网络
-* 后处理
-* 损失函数
-* 指标评估
-* 优化器
+* [1. 数据加载和处理](#1)
+* [2. 网络](#2)
+* [3. 后处理](#3)
+* [4. 损失函数](#4)
+* [5. 指标评估](#5)
+* [6. 优化器](#6)
 
 下面将分别对每个部分进行介绍，并介绍如何在该部分里添加新算法所需模块。
 
-## 数据加载和处理
+<a name="1"></a>
+
+## 1. 数据加载和处理
 
 数据加载和处理由不同的模块(module)组成，其完成了图片的读取、数据增强和label的制作。这一部分在[ppocr/data](../../ppocr/data)下。 各个文件及文件夹作用说明如下:
 
@@ -64,7 +66,9 @@ transforms:
       keep_keys: [ 'image', 'label' ] # dataloader will return list in this order
 ```
 
-## 网络
+<a name="2"></a>
+
+## 2. 网络
 
 网络部分完成了网络的组网操作，PaddleOCR将网络划分为四部分，这一部分在[ppocr/modeling](../../ppocr/modeling)下。 进入网络的数据将按照顺序(transforms->backbones->
 necks->heads)依次通过这四个部分。
@@ -123,7 +127,9 @@ Architecture:
     args1: args1
 ```
 
-## 后处理
+<a name="3"></a>
+
+## 3. 后处理
 
 后处理实现解码网络输出获得文本框或者识别到的文字。这一部分在[ppocr/postprocess](../../ppocr/postprocess)下。
 PaddleOCR内置了DB,EAST,SAST,CRNN和Attention等算法相关的后处理模块，对于没有内置的组件可通过如下步骤添加:
@@ -171,7 +177,9 @@ PostProcess:
   args2: args2
 ```
 
-## 损失函数
+<a name="4"></a>
+
+## 4. 损失函数
 
 损失函数用于计算网络输出和label之间的距离。这一部分在[ppocr/losses](../../ppocr/losses)下。
 PaddleOCR内置了DB,EAST,SAST,CRNN和Attention等算法相关的损失函数模块，对于没有内置的模块可通过如下步骤添加:
@@ -208,7 +216,9 @@ Loss:
   args2: args2
 ```
 
-## 指标评估
+<a name="5"></a>
+
+## 5. 指标评估
 
 指标评估用于计算网络在当前batch上的性能。这一部分在[ppocr/metrics](../../ppocr/metrics)下。 PaddleOCR内置了检测，分类和识别等算法相关的指标评估模块，对于没有内置的模块可通过如下步骤添加:
 
@@ -262,7 +272,9 @@ Metric:
   main_indicator: acc
 ```
 
-## 优化器
+<a name="6"></a>
+
+## 6. 优化器
 
 优化器用于训练网络。优化器内部还包含了网络正则化和学习率衰减模块。 这一部分在[ppocr/optimizer](../../ppocr/optimizer)下。 PaddleOCR内置了`Momentum`,`Adam`
 和`RMSProp`等常用的优化器模块，`Linear`,`Cosine`,`Step`和`Piecewise`等常用的正则化模块与`L1Decay`和`L2Decay`等常用的学习率衰减模块。

doc/doc_ch/algorithm_overview.md

@@ -9,11 +9,13 @@
 ### 1.文本检测算法
 
 PaddleOCR开源的文本检测算法列表：
-- [x]  DB([paper]( https://arxiv.org/abs/1911.08947)) [2]（ppocr推荐）
-- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))[1]
-- [x]  SAST([paper](https://arxiv.org/abs/1908.05498))[4]
+- [x]  DB([paper]( https://arxiv.org/abs/1911.08947))（ppocr推荐）
+- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))
+- [x]  SAST([paper](https://arxiv.org/abs/1908.05498))
+- [x]  PSENet([paper](https://arxiv.org/abs/1903.12473v2)）
 
 在ICDAR2015文本检测公开数据集上，算法效果如下：
+
 |模型|骨干网络|precision|recall|Hmean|下载链接|
 | --- | --- | --- | --- | --- | --- |
 |EAST|ResNet50_vd|85.80%|86.71%|86.25%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_east_v2.0_train.tar)|
@@ -21,6 +23,8 @@ PaddleOCR开源的文本检测算法列表：
 |DB|ResNet50_vd|86.41%|78.72%|82.38%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_db_v2.0_train.tar)|
 |DB|MobileNetV3|77.29%|73.08%|75.12%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_mv3_db_v2.0_train.tar)|
 |SAST|ResNet50_vd|91.39%|83.77%|87.42%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_sast_icdar15_v2.0_train.tar)|
+|PSE|ResNet50_vd|85.81%|79.53%|82.55%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.1/en_det/det_r50_vd_pse_v2.0_train.tar)|
+|PSE|MobileNetV3|82.20%|70.48%|75.89%|[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.1/en_det/det_mv3_pse_v2.0_train.tar)|
 
 在Total-text文本检测公开数据集上，算法效果如下：
 
@@ -39,15 +43,15 @@ PaddleOCR文本检测算法的训练和使用请参考文档教程中[模型训
 ### 2.文本识别算法
 
 PaddleOCR基于动态图开源的文本识别算法列表：
-- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))[7]（ppocr推荐）
-- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))[10]
-- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))[11]
-- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))[12]
-- [x]  SRN([paper](https://arxiv.org/abs/2003.12294))[5]
+- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))（ppocr推荐）
+- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))
+- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))
+- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))
+- [x]  SRN([paper](https://arxiv.org/abs/2003.12294))
 - [x]  NRTR([paper](https://arxiv.org/abs/1806.00926v2))
 - [x]  SAR([paper](https://arxiv.org/abs/1811.00751v2))
 
-参考[DTRB][3](https://arxiv.org/abs/1904.01906)文字识别训练和评估流程，使用MJSynth和SynthText两个文字识别数据集训练，在IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE数据集上进行评估，算法效果如下：
+参考[DTRB](https://arxiv.org/abs/1904.01906) 文字识别训练和评估流程，使用MJSynth和SynthText两个文字识别数据集训练，在IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE数据集上进行评估，算法效果如下：
 
 |模型|骨干网络|Avg Accuracy|模型存储命名|下载链接|
 |---|---|---|---|---|

doc/doc_ch/angle_class.md

-## 文字角度分类
-### 方法介绍
-文字角度分类主要用于图片非0度的场景下，在这种场景下需要对图片里检测到的文本行进行一个转正的操作。在PaddleOCR系统内，
+# 文本方向分类器
+
+- [1.方法介绍](#方法介绍)
+- [2.数据准备](#数据准备)
+- [3.启动训练](#启动训练)
+- [4.训练](#训练)
+- [5.评估](#评估)
+- [6.预测](#预测)
+
+<a name="方法介绍"></a>
+## 1. 方法介绍
+文本方向分类器主要用于图片非0度的场景下，在这种场景下需要对图片里检测到的文本行进行一个转正的操作。在PaddleOCR系统内，
 文字检测之后得到的文本行图片经过仿射变换之后送入识别模型，此时只需要对文字进行一个0和180度的角度分类，因此PaddleOCR内置的
 文字角度分类器**只支持了0和180度的分类**。如果想支持更多角度，可以自己修改算法进行支持。
 
@@ -8,7 +17,8 @@
 
 ![](../imgs_results/angle_class_example.jpg)
 
-### 数据准备
+<a name="数据准备"></a>
+## 2. 数据准备
 
 请按如下步骤设置数据集：
 
@@ -59,6 +69,8 @@ train/cls/train/word_002.jpg   180
             |- word_003.jpg
             | ...
 ```
+<a name="启动训练"></a>
+## 3. 启动训练
 
 ### 启动训练
 
@@ -88,7 +100,8 @@ PaddleOCR提供了多种数据增强方式，如果您希望在训练时加入
 
 *由于OpenCV的兼容性问题，扰动操作暂时只支持linux*
 
-### 训练
+<a name="训练"></a>
+## 4. 训练
 
 PaddleOCR支持训练和评估交替进行, 可以在 `configs/cls/cls_mv3.yml` 中修改 `eval_batch_step` 设置评估频率，默认每1000个iter评估一次。训练过程中将会保存如下内容：
 ```bash
@@ -106,7 +119,8 @@ PaddleOCR支持训练和评估交替进行, 可以在 `configs/cls/cls_mv3.yml`
 
 **注意，预测/评估时的配置文件请务必与训练一致。**
 
-### 评估
+<a name="评估"></a>
+## 5. 评估
 
 评估数据集可以通过修改`configs/cls/cls_mv3.yml`文件里的`Eval.dataset.label_file_list` 字段设置。
 
@@ -116,7 +130,8 @@ export CUDA_VISIBLE_DEVICES=0
 python3 tools/eval.py -c configs/cls/cls_mv3.yml -o Global.checkpoints={path/to/weights}/best_accuracy
 ```
 
-### 预测
+<a name="预测"></a>
+## 6. 预测
 
 * 训练引擎的预测
 

doc/doc_ch/benchmark.md

@@ -12,40 +12,27 @@
 ## 评估指标  
 
 说明：
-- v1.0是未添加优化策略的DB+CRNN模型，v1.1是添加多种优化策略和方向分类器的PP-OCR模型。slim_v1.1是使用裁剪或量化的模型。
+
 - 检测输入图像的的长边尺寸是960。
-- 评估耗时阶段为图像输入到结果输出的完整阶段，包括了图像的预处理和后处理。  
+- 评估耗时阶段为图像预测耗时，不包括图像的预处理和后处理。  
 - `Intel至强6148`为服务器端CPU型号，测试中使用Intel MKL-DNN 加速。
 - `骁龙855`为移动端处理平台型号。  
 
-不同预测模型大小和整体识别精度对比
+预测模型大小和整体识别精度对比
 
 | 模型名称                     | 整体模型<br>大小\(M\) | 检测模型<br>大小\(M\) | 方向分类器<br>模型大小\(M\) | 识别模型<br>大小\(M\) | 整体识别<br>F\-score |
 |:-:|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 8\.1        | 2\.6        | 0\.9           | 4\.6        | 0\.5193      |
-| ch\_ppocr\_server\_v1\.1 | 155\.1      | 47\.2       | 0\.9           | 107         | 0\.5414      |
-| ch\_ppocr\_mobile\_v1\.0 | 8\.6        | 4\.1        | \-             | 4\.5        | 0\.393       |
-| ch\_ppocr\_server\_v1\.0 | 203\.8      | 98\.5       | \-             | 105\.3      | 0\.4436      |
-
-不同预测模型在T4 GPU上预测速度对比，单位ms
-
-| 模型名称                     | 整体  | 检测 | 方向分类器 | 识别  |
-|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 137 | 35 | 24    | 78  |
-| ch\_ppocr\_server\_v1\.1 | 204 | 39 | 25    | 140 |
-| ch\_ppocr\_mobile\_v1\.0 | 117 | 41 | \-    | 76  |
-| ch\_ppocr\_server\_v1\.0 | 199 | 52 | \-    | 147 |
+| PP-OCRv2 | 11\.6        | 3\.0        | 0\.9           | 8\.6        | 0\.5224      |
+| PP-OCR mobile |   8\.1  | 2\.6        | 0\.9           | 4\.6        | 0\.503       |
+| PP-OCR server | 155\.1  | 47\.2       | 0\.9           | 107         | 0\.570       |
 
-不同预测模型在CPU上预测速度对比，单位ms
 
-| 模型名称                     | 整体   | 检测  | 方向分类器 | 识别  |
-|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 421  | 164 | 51    | 206 |
-| ch\_ppocr\_mobile\_v1\.0 | 398  | 219 | \-    | 179 |
+预测模型在CPU和GPU上的速度对比，单位ms
 
-裁剪量化模型和原始模型模型大小，整体识别精度和在SD 855上预测速度对比
+| 模型名称                     | CPU   | T4 GPU  |
+|:-:|:-:|:-:|
+| PP-OCRv2 | 330  | 111 |
+| PP-OCR mobile | 356  | 11 6|
+| PP-OCR server | 1056  | 200 |
 
-| 模型名称                           | 整体模型<br>大小\(M\) | 检测模型<br>大小\(M\) | 方向分类器<br>模型大小\(M\) | 识别模型<br>大小\(M\) | 整体识别<br>F\-score | SD 855<br>\(ms\) |
-|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1       | 8\.1        | 2\.6        | 0\.9           | 4\.6        | 0\.5193      | 306          |
-| ch\_ppocr\_mobile\_slim\_v1\.1 | 3\.5        | 1\.4        | 0\.5           | 1\.6        | 0\.521       | 268          |
+更多 PP-OCR 系列模型的预测指标可以参考[PP-OCR Benchmark](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.2/doc/doc_ch/benchmark.md)

doc/doc_ch/config.md

 # 配置文件内容与生成
 
+* [1. 可选参数列表](#1)
+* [2. 配置文件参数介绍](#2)
+* [3. 多语言配置文件生成](#3)
+
+<a name="1"></a>
+
 ## 1. 可选参数列表
 
 以下列表可以通过`--help`查看
@@ -9,11 +15,12 @@
 |          -c              |      ALL       |  指定配置文件  |  None  |  **配置模块说明请参考 参数介绍** |
 |          -o              |      ALL       |  设置配置文件里的参数内容  |  None  |  使用-o配置相较于-c选择的配置文件具有更高的优先级。例如：`-o Global.use_gpu=false`  |  
 
+<a name="2"></a>
 
 ## 2. 配置文件参数介绍
 
 以 `rec_chinese_lite_train_v2.0.yml ` 为例
-### 2.1 Global
+### Global
 
 |         字段             |            用途                |      默认值       |            备注            |
 | :----------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
@@ -124,6 +131,8 @@
 |      drop_last        |        是否丢弃因数据集样本数不能被 batch_size 整除而产生的最后一个不完整的mini-batch        |  True | \  |
 |      num_workers        |        用于加载数据的子进程个数，若为0即为不开启子进程，在主进程中进行数据加载        |  8 | \  |
 
+<a name="3"></a>
+
 ## 3. 多语言配置文件生成
 
 PaddleOCR目前已支持80种（除中文外）语种识别，`configs/rec/multi_languages` 路径下提供了一个多语言的配置文件模版: [rec_multi_language_lite_train.yml](../../configs/rec/multi_language/rec_multi_language_lite_train.yml)。

doc/doc_ch/detection.md

@@ -91,11 +91,11 @@ wget -P ./pretrain_models/ https://paddle-imagenet-models-name.bj.bcebos.com/dyg
 ```shell
 # 单机单卡训练 mv3_db 模型
 python3 tools/train.py -c configs/det/det_mv3_db.yml \
-     -o Global.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained
+     -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained
 
 # 单机多卡训练，通过 --gpus 参数设置使用的GPU ID
 python3 -m paddle.distributed.launch --gpus '0,1,2,3' tools/train.py -c configs/det/det_mv3_db.yml \
-     -o Global.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained
+     -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained
 ```
 
 上述指令中，通过-c 选择训练使用configs/det/det_db_mv3.yml配置文件。
@@ -114,7 +114,7 @@ python3 tools/train.py -c configs/det/det_mv3_db.yml -o Optimizer.base_lr=0.0001
 python3 tools/train.py -c configs/det/det_mv3_db.yml -o Global.checkpoints=./your/trained/model
 ```
 
-**注意**：`Global.checkpoints`的优先级高于`Global.pretrain_weights`的优先级，即同时指定两个参数时，优先加载`Global.checkpoints`指定的模型，如果`Global.checkpoints`指定的模型路径有误，会加载`Global.pretrain_weights`指定的模型。
+**注意**：`Global.checkpoints`的优先级高于`Global.pretrained_model`的优先级，即同时指定两个参数时，优先加载`Global.checkpoints`指定的模型，如果`Global.checkpoints`指定的模型路径有误，会加载`Global.pretrained_model`指定的模型。
 
 <a name="15---backbone---"></a>
 ## 1.5 更换Backbone 训练

doc/doc_ch/knowledge_distillation.md

@@ -39,7 +39,7 @@ PaddleOCR中集成了知识蒸馏的算法，具体地，有以下几个主要
 
 ### 2.1 识别配置文件解析
 
-配置文件在[ch_PP-OCRv2_rec.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml)。
+配置文件在[ch_PP-OCRv2_rec_distillation.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec_distillation.yml)。
 
 #### 2.1.1 模型结构
 
@@ -246,6 +246,39 @@ Metric:
 关于`DistillationMetric`更加具体的实现可以参考: [distillation_metric.py](../../ppocr/metrics/distillation_metric.py#L24)。
 
 
+#### 2.1.5 蒸馏模型微调
+
+对蒸馏得到的识别蒸馏进行微调有2种方式。
+
+（1）基于知识蒸馏的微调：这种情况比较简单，下载预训练模型，在[ch_PP-OCRv2_rec_distillation.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec_distillation.yml)中配置好预训练模型路径以及自己的数据路径，即可进行模型微调训练。
+
+（2）微调时不使用知识蒸馏：这种情况，需要首先将预训练模型中的学生模型参数提取出来，具体步骤如下。
+
+* 首先下载预训练模型并解压。
+```shell
+# 下面预训练模型并解压
+wget https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_train.tar
+tar -xf ch_PP-OCRv2_rec_train.tar
+```
+
+* 然后使用python，对其中的学生模型参数进行提取
+
+```python
+import paddle
+# 加载预训练模型
+all_params = paddle.load("ch_PP-OCRv2_rec_train/best_accuracy.pdparams")
+# 查看权重参数的keys
+print(all_params.keys())
+# 学生模型的权重提取
+s_params = {key[len("Student."):]: all_params[key] for key in all_params if "Student." in key}
+# 查看学生模型权重参数的keys
+print(s_params.keys())
+# 保存
+paddle.save(s_params, "ch_PP-OCRv2_rec_train/student.pdparams")
+```
+
+转化完成之后，使用[ch_PP-OCRv2_rec.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml)，修改预训练模型的路径（为导出的`student.pdparams`模型路径）以及自己的数据路径，即可进行模型微调。
+
 ### 2.2 检测配置文件解析
 
 * coming soon!

doc/doc_ch/quickstart.md

@@ -90,10 +90,10 @@ cd /path/to/ppocr_img
   ```
 
 
-如需使用2.0模型，请指定参数`--version 2.0`，paddleocr默认使用2.1模型。更多whl包使用可参考[whl包文档](./whl.md)
-
+如需使用2.0模型，请指定参数`--version PP-OCR`，paddleocr默认使用2.1模型(`--versioin PP-OCRv2`)。更多whl包使用可参考[whl包文档](./whl.md)
 
 <a name="212"></a>
+
 #### 2.1.2 多语言模型
 
 Paddleocr目前支持80个语种，可以通过修改`--lang`参数进行切换，对于英文模型，指定`--lang=en`。

doc/doc_en/algorithm_overview_en.md

@@ -11,9 +11,10 @@ This tutorial lists the text detection algorithms and text recognition algorithm
 ### 1. Text Detection Algorithm
 
 PaddleOCR open source text detection algorithms list:
-- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))[2]
-- [x]  DB([paper](https://arxiv.org/abs/1911.08947))[1]
-- [x]  SAST([paper](https://arxiv.org/abs/1908.05498))[4]
+- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))
+- [x]  DB([paper](https://arxiv.org/abs/1911.08947))
+- [x]  SAST([paper](https://arxiv.org/abs/1908.05498))
+- [x]  PSE([paper](https://arxiv.org/abs/1903.12473v2))
 
 On the ICDAR2015 dataset, the text detection result is as follows:
 
@@ -24,6 +25,8 @@ On the ICDAR2015 dataset, the text detection result is as follows:
 |DB|ResNet50_vd|86.41%|78.72%|82.38%|[Download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_db_v2.0_train.tar)|
 |DB|MobileNetV3|77.29%|73.08%|75.12%|[Download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_mv3_db_v2.0_train.tar)|
 |SAST|ResNet50_vd|91.39%|83.77%|87.42%|[Download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_sast_icdar15_v2.0_train.tar)|
+|PSE|ResNet50_vd|85.81%|79.53%|82.55%|[Download link](https://paddleocr.bj.bcebos.com/dygraph_v2.1/en_det/det_r50_vd_pse_v2.0_train.tar)|
+|PSE|MobileNetV3|82.20%|70.48%|75.89%|[Download link](https://paddleocr.bj.bcebos.com/dygraph_v2.1/en_det/det_mv3_pse_v2.0_train.tar)|
 
 On Total-Text dataset, the text detection result is as follows:
 
@@ -41,11 +44,11 @@ For the training guide and use of PaddleOCR text detection algorithms, please re
 ### 2. Text Recognition Algorithm
 
 PaddleOCR open-source text recognition algorithms list:
-- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))[7]
-- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))[10]
-- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))[11]
-- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))[12]
-- [x]  SRN([paper](https://arxiv.org/abs/2003.12294))[5]
+- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))
+- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))
+- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))
+- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))
+- [x]  SRN([paper](https://arxiv.org/abs/2003.12294))
 - [x]  NRTR([paper](https://arxiv.org/abs/1806.00926v2))
 - [x]  SAR([paper](https://arxiv.org/abs/1811.00751v2))
 

doc/doc_en/angle_class_en.md

-## TEXT ANGLE CLASSIFICATION
+# Text Direction Classification
 
-### Method introduction
+- [1. Method Introduction](#method-introduction)
+- [2. Data Preparation](#data-preparation)
+- [3. Training](#training)
+- [4. Evaluation](#evaluation)
+- [5. Prediction](#prediction)
+
+<a name="method-introduction"></a>
+
+## 1. Method Introduction
 The angle classification is used in the scene where the image is not 0 degrees. In this scene, it is necessary to perform a correction operation on the text line detected in the picture. In the PaddleOCR system,
 The text line image obtained after text detection is sent to the recognition model after affine transformation. At this time, only a 0 and 180 degree angle classification of the text is required, so the built-in PaddleOCR text angle classifier **only supports 0 and 180 degree classification**. If you want to support more angles, you can modify the algorithm yourself to support.
 
@@ -9,6 +17,9 @@ Example of 0 and 180 degree data samples：
 ![](../imgs_results/angle_class_example.jpg)
 ### DATA PREPARATION
 
+<a name="data-preparation"></a>
+## 2. Data Preparation
+
 Please organize the dataset as follows:
 
 The default storage path for training data is `PaddleOCR/train_data/cls`, if you already have a dataset on your disk, just create a soft link to the dataset directory:
@@ -62,8 +73,8 @@ containing all images (test) and a cls_gt_test.txt. The structure of the test se
             |- word_003.jpg
             | ...
 ```
-
-### TRAINING
+<a name="training"></a>
+## 3. Training
 Write the prepared txt file and image folder path into the configuration file under the `Train/Eval.dataset.label_file_list` and `Train/Eval.dataset.data_dir` fields, the absolute path of the image consists of the `Train/Eval.dataset.data_dir` field and the image name recorded in the txt file.
 
 PaddleOCR provides training scripts, evaluation scripts, and prediction scripts.
@@ -107,7 +118,8 @@ If the evaluation set is large, the test will be time-consuming. It is recommend
 
 **Note that the configuration file for prediction/evaluation must be consistent with the training.**
 
-### EVALUATION
+<a name="evaluation"></a>
+## 4. Evaluation
 
 The evaluation dataset can be set by modifying the `Eval.dataset.label_file_list` field in the `configs/cls/cls_mv3.yml` file.
 
@@ -116,6 +128,8 @@ export CUDA_VISIBLE_DEVICES=0
 # GPU evaluation, Global.checkpoints is the weight to be tested
 python3 tools/eval.py -c configs/cls/cls_mv3.yml -o Global.checkpoints={path/to/weights}/best_accuracy
 ```
+<a name="prediction"></a>
+## 5. Prediction
 
 ### PREDICTION
 

doc/doc_en/benchmark_en.md

-# BENCHMARK
+# Benchmark 
 
 This document gives the performance of the series models for Chinese and English recognition.
 
-## TEST DATA
+## Test Data 
 
 We collected 300 images for different real application scenarios to evaluate the overall OCR system, including contract samples, license plates, nameplates, train tickets, test sheets, forms, certificates, street view images, business cards, digital meter, etc. The following figure shows some images of the test set.
 
@@ -10,10 +10,9 @@ We collected 300 images for different real application scenarios to evaluate the
 <img src="../datasets/doc.jpg"  width = "1000" height = "500" />
 </div>
 
-## MEASUREMENT
+## Measurement
 
 Explanation:
-- v1.0 indicates DB+CRNN models without the strategies. v1.1 indicates the PP-OCR models with the strategies and the direction classify. slim_v1.1 indicates the PP-OCR models with prunner or quantization.
 
 - The long size of the input for the text detector is 960.
 
@@ -27,30 +26,16 @@ Compares the model size and F-score:
 
 | Model Name                    | Model Size <br> of the <br> Whole System\(M\) | Model Size <br>of the Text <br> Detector\(M\) | Model Size <br> of the Direction <br> Classifier\(M\) | Model Size<br>of the Text <br> Recognizer \(M\) | F\-score |
 |:-:|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 8\.1        | 2\.6        | 0\.9           | 4\.6        | 0\.5193      |
-| ch\_ppocr\_server\_v1\.1 | 155\.1      | 47\.2       | 0\.9           | 107         | 0\.5414      |
-| ch\_ppocr\_mobile\_v1\.0 | 8\.6        | 4\.1        | \-             | 4\.5        | 0\.393       |
-| ch\_ppocr\_server\_v1\.0 | 203\.8      | 98\.5       | \-             | 105\.3      | 0\.4436      |
+| PP-OCRv2                 | 11\.6        | 3\.0        | 0\.9           | 8\.6        | 0\.5224      |
+| PP-OCR mobile            |   8\.1       | 2\.6        | 0\.9           | 4\.6        | 0\.503       |
+| PP-OCR server            | 155\.1       | 47\.2       | 0\.9           | 107         | 0\.570       |
 
-Compares the time-consuming on T4 GPU (ms):
+Compares the time-consuming on CPU and T4 GPU (ms):
 
-| Model Name                     | Overall  | Text Detector  | Direction Classifier  | Text Recognizer |
-|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 137 | 35 | 24    | 78  |
-| ch\_ppocr\_server\_v1\.1 | 204 | 39 | 25    | 140 |
-| ch\_ppocr\_mobile\_v1\.0 | 117 | 41 | \-    | 76  |
-| ch\_ppocr\_server\_v1\.0 | 199 | 52 | \-    | 147 |
+| Model Name    | CPU  | T4 GPU |
+|:-:|:-:|:-:|
+| PP-OCRv2      | 330  | 111 |
+| PP-OCR mobile | 356  | 116|
+| PP-OCR server | 1056 | 200 |
 
-Compares the time-consuming on CPU (ms):
-
-| Model Name                     | Overall  | Text Detector  | Direction Classifier  | Text Recognizer |
-|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1 | 421  | 164 | 51    | 206 |
-| ch\_ppocr\_mobile\_v1\.0 | 398  | 219 | \-    | 179 |
-
-Compares the model size, F-score, the time-consuming on SD 855 of between the slim models and the original models:
-
-| Model Name                          | Model Size <br> of the <br> Whole System\(M\) | Model Size <br>of the Text <br> Detector\(M\) | Model Size <br> of the Direction <br> Classifier\(M\) | Model Size<br>of the Text <br> Recognizer \(M\) | F\-score | SD 855<br>\(ms\) |
-|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
-| ch\_ppocr\_mobile\_v1\.1       | 8\.1        | 2\.6        | 0\.9           | 4\.6        | 0\.5193      | 306          |
-| ch\_ppocr\_mobile\_slim\_v1\.1 | 3\.5        | 1\.4        | 0\.5           | 1\.6        | 0\.521       | 268          |
+More indicators of PP-OCR series models can be referred to [PP-OCR Benchmark](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.2/doc/doc_en/benchmark_en.md)

doc/doc_en/config_en.md

-## Optional parameter list
+# Configuration 
+
+- [1. Optional Parameter List](#1-optional-parameter-list)
+- [2. Intorduction to Global Parameters of Configuration File](#2-intorduction-to-global-parameters-of-configuration-file)
+- [3. Multilingual Config File Generation](#3-multilingual-config-file-generation)
+
+<a name="1-optional-parameter-list"></a>
+
+## 1. Optional Parameter List
 
 The following list can be viewed through `--help`
 
@@ -7,7 +15,9 @@ The following list can be viewed through `--help`
 |          -c              |      ALL       |  Specify configuration file to use  |  None  |  **Please refer to the parameter introduction for configuration file usage** |
 |          -o              |      ALL       |  set configuration options  |  None  |  Configuration using -o has higher priority than the configuration file selected with -c. E.g: -o Global.use_gpu=false |
 
-## INTRODUCTION TO GLOBAL PARAMETERS OF CONFIGURATION FILE
+<a name="2-intorduction-to-global-parameters-of-configuration-file"></a>
+
+## 2. Intorduction to Global Parameters of Configuration File
 
 Take rec_chinese_lite_train_v2.0.yml as an example
 ### Global
@@ -121,8 +131,9 @@ In PaddleOCR, the network is divided into four stages: Transform, Backbone, Neck
 |      drop_last        |        Whether to discard the last incomplete mini-batch because the number of samples in the data set cannot be divisible by batch_size        |  True | \  |
 |      num_workers        |        The number of sub-processes used to load data, if it is 0, the sub-process is not started, and the data is loaded in the main process       |  8 | \  |
 
+<a name="3-multilingual-config-file-generation"></a>
 
-## 3. MULTILINGUAL CONFIG FILE GENERATION
+## 3. Multilingual Config File Generation
 
 PaddleOCR currently supports 80 (except Chinese) language recognition. A multi-language configuration file template is
 provided under the path `configs/rec/multi_languages`: [rec_multi_language_lite_train.yml](../../configs/rec/multi_language/rec_multi_language_lite_train.yml)。

doc/doc_en/detection_en.md

-# CONTENT
-
-- [Paste Your Document In Here](#paste-your-document-in-here)
-- [1. TEXT DETECTION](#1-text-detection)
-  * [1.1 DATA PREPARATION](#11-data-preparation)
-  * [1.2 DOWNLOAD PRETRAINED MODEL](#12-download-pretrained-model)
-  * [1.3 START TRAINING](#13-start-training)
-  * [1.4 LOAD TRAINED MODEL AND CONTINUE TRAINING](#14-load-trained-model-and-continue-training)
-  * [1.5 TRAINING WITH NEW BACKBONE](#15-training-with-new-backbone)
-  * [1.6 EVALUATION](#16-evaluation)
-  * [1.7 TEST](#17-test)
-  * [1.8 INFERENCE MODEL PREDICTION](#18-inference-model-prediction)
-- [2. FAQ](#2-faq)
+# Text Detection
 
+This section uses the icdar2015 dataset as an example to introduce the training, evaluation, and testing of the detection model in PaddleOCR.
 
-# 1. TEXT DETECTION
+- [1. Data and Weights Preparation](#1-data-and-weights-preparatio)
+  * [1.1 Data Preparation](#11-data-preparation)
+  * [1.2 Download Pretrained Model](#12-download-pretrained-model)
+- [2. Training](#2-training)
+  * [2.1 Start Training](#21-start-training)
+  * [2.2 Load Trained Model and Continue Training](#22-load-trained-model-and-continue-training)
+  * [2.3 Training with New Backbone](#23-training-with-new-backbone)
+- [3. Evaluation and Test](#3-evaluation-and-test)
+  * [3.1 Evaluation](#31-evaluation)
+  * [3.2 Test](#32-test)
+- [4. Inference](#4-inference)
+- [5. FAQ](#2-faq)
 
-This section uses the icdar2015 dataset as an example to introduce the training, evaluation, and testing of the detection model in PaddleOCR.
+## 1. Data and Weights Preparation
 
-## 1.1 DATA PREPARATION
+### 1.1 Data Preparation
 
 The icdar2015 dataset contains train set which has 1000 images obtained with wearable cameras and test set which has 500 images obtained with wearable cameras. The icdar2015 can be obtained from [official website](https://rrc.cvc.uab.es/?ch=4&com=downloads). Registration is required for downloading.
 
@@ -59,7 +59,7 @@ The `points` in the dictionary represent the coordinates (x, y) of the four poin
 If you want to train PaddleOCR on other datasets, please build the annotation file according to the above format.
 
 
-## 1.2 DOWNLOAD PRETRAINED MODEL
+### 1.2 Download Pretrained Model
 
 First download the pretrained model. The detection model of PaddleOCR currently supports 3 backbones, namely MobileNetV3, ResNet18_vd and ResNet50_vd. You can use the model in [PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/release/2.0/ppcls/modeling/architectures) to replace backbone according to your needs.
 And the responding download link of backbone pretrain weights can be found in (https://github.com/PaddlePaddle/PaddleClas/blob/release%2F2.0/README_cn.md#resnet%E5%8F%8A%E5%85%B6vd%E7%B3%BB%E5%88%97).
@@ -75,11 +75,14 @@ wget -P ./pretrain_models/ https://paddle-imagenet-models-name.bj.bcebos.com/dyg
 
 ```
 
-## 1.3 START TRAINING
+## 2. Training
+
+### 2.1 Start Training
+
 *If CPU version installed, please set the parameter `use_gpu` to `false` in the configuration.*
 ```shell
 python3 tools/train.py -c configs/det/det_mv3_db.yml  \
-         -o Global.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained
+         -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained
 ```
 
 In the above instruction, use `-c` to select the training to use the `configs/det/det_db_mv3.yml` configuration file.
@@ -89,16 +92,16 @@ You can also use `-o` to change the training parameters without modifying the ym
 ```shell
 # single GPU training
 python3 tools/train.py -c configs/det/det_mv3_db.yml -o   \
-         Global.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained  \
+         Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained  \
          Optimizer.base_lr=0.0001
 
 # multi-GPU training
 # Set the GPU ID used by the '--gpus' parameter.
-python3 -m paddle.distributed.launch --gpus '0,1,2,3'  tools/train.py -c configs/det/det_mv3_db.yml -o Global.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained
+python3 -m paddle.distributed.launch --gpus '0,1,2,3'  tools/train.py -c configs/det/det_mv3_db.yml -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained
 
 ```
 
-## 1.4 LOAD TRAINED MODEL AND CONTINUE TRAINING
+### 2.2 Load Trained Model and Continue Training
 If you expect to load trained model and continue the training again, you can specify the parameter `Global.checkpoints` as the model path to be loaded.
 
 For example:
@@ -106,10 +109,10 @@ For example:
 python3 tools/train.py -c configs/det/det_mv3_db.yml -o Global.checkpoints=./your/trained/model
 ```
 
-**Note**: The priority of `Global.checkpoints` is higher than that of `Global.pretrain_weights`, that is, when two parameters are specified at the same time, the model specified by `Global.checkpoints` will be loaded first. If the model path specified by `Global.checkpoints` is wrong, the one specified by `Global.pretrain_weights` will be loaded.
+**Note**: The priority of `Global.checkpoints` is higher than that of `Global.pretrained_model`, that is, when two parameters are specified at the same time, the model specified by `Global.checkpoints` will be loaded first. If the model path specified by `Global.checkpoints` is wrong, the one specified by `Global.pretrained_model` will be loaded.
 
 
-## 1.5 TRAINING WITH NEW BACKBONE
+### 2.3 Training with New Backbone
 
 The network part completes the construction of the network, and PaddleOCR divides the network into four parts, which are under [ppocr/modeling](../../ppocr/modeling). The data entering the network will pass through these four parts in sequence(transforms->backbones->
 necks->heads).
@@ -159,7 +162,9 @@ After adding the four-part modules of the network, you only need to configure th
 
 **NOTE**: More details about replace Backbone and other mudule can be found in [doc](add_new_algorithm_en.md).
 
-## 1.6 EVALUATION
+## 3. Evaluation and Test
+
+### 3.1 Evaluation
 
 PaddleOCR calculates three indicators for evaluating performance of OCR detection task: Precision, Recall, and Hmean(F-Score).
 
@@ -174,7 +179,7 @@ python3 tools/eval.py -c configs/det/det_mv3_db.yml  -o Global.checkpoints="{pat
 
 * Note: `box_thresh` and `unclip_ratio` are parameters required for DB post-processing, and not need to be set when evaluating the EAST and SAST model.
 
-## 1.7 TEST
+### 3.2 Test
 
 Test the detection result on a single image:
 ```shell
@@ -192,7 +197,7 @@ Test the detection result on all images in the folder:
 python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/" Global.pretrained_model="./output/det_db/best_accuracy"
 ```
 
-## 1.8 INFERENCE MODEL PREDICTION
+## 4. Inference
 
 The inference model (the model saved by `paddle.jit.save`) is generally a solidified model saved after the model training is completed, and is mostly used to give prediction in deployment.
 
@@ -215,7 +220,7 @@ If it is other detection algorithms, such as the EAST, the det_algorithm paramet
 python3 tools/infer/predict_det.py --det_algorithm="EAST" --det_model_dir="./output/det_db_inference/" --image_dir="./doc/imgs/" --use_gpu=True
 ```
 
-# 2. FAQ
+## 5. FAQ
 
 Q1: The prediction results of trained model and inference model are inconsistent?
 **A**: Most of the problems are caused by the inconsistency of the pre-processing and post-processing parameters during the prediction of the trained model and the pre-processing and post-processing parameters during the prediction of the inference model. Taking the model trained by the det_mv3_db.yml configuration file as an example, the solution to the problem of inconsistent prediction results between the training model and the inference model is as follows:

doc/doc_en/inference_en.md

 
-# Reasoning based on Python prediction engine
+# Inference Based on Python Prediction Engine
 
 The inference model (the model saved by `paddle.jit.save`) is generally a solidified model saved after the model training is completed, and is mostly used to give prediction in deployment.
 
@@ -10,37 +10,36 @@ For more details, please refer to the document [Classification Framework](https:
 
 Next, we first introduce how to convert a trained model into an inference model, and then we will introduce text detection, text recognition, angle class, and the concatenation of them based on inference model.
 
-- [CONVERT TRAINING MODEL TO INFERENCE MODEL](#CONVERT)
-    - [Convert detection model to inference model](#Convert_detection_model)
-    - [Convert recognition model to inference model](#Convert_recognition_model)
-    - [Convert angle classification model to inference model](#Convert_angle_class_model)
+- [1. Convert Training Model to Inference Model](#CONVERT)
+    - [1.1 Convert Detection Model to Inference Model](#Convert_detection_model)
+    - [1.2 Convert Recognition Model to Inference Model](#Convert_recognition_model)
+    - [1.3 Convert Angle Classification Model to Inference Model](#Convert_angle_class_model)
 
 
-- [TEXT DETECTION MODEL INFERENCE](#DETECTION_MODEL_INFERENCE)
-    - [1. LIGHTWEIGHT CHINESE DETECTION MODEL INFERENCE](#LIGHTWEIGHT_DETECTION)
-    - [2. DB TEXT DETECTION MODEL INFERENCE](#DB_DETECTION)
-    - [3. EAST TEXT DETECTION MODEL INFERENCE](#EAST_DETECTION)
-    - [4. SAST TEXT DETECTION MODEL INFERENCE](#SAST_DETECTION)
-    - [5. Multilingual model inference](#Multilingual model inference)
+- [2. Text Detection Model Inference](#DETECTION_MODEL_INFERENCE)
+    - [2.1 Lightweight Chinese Detection Model Inference](#LIGHTWEIGHT_DETECTION)
+    - [2.2 DB Text Detection Model Inference](#DB_DETECTION)
+    - [2.3 East Text Detection Model Inference](#EAST_DETECTION)
+    - [2.4 Sast Text Detection Model Inference](#SAST_DETECTION)
     
-- [TEXT RECOGNITION MODEL INFERENCE](#RECOGNITION_MODEL_INFERENCE)
-    - [1. LIGHTWEIGHT CHINESE MODEL](#LIGHTWEIGHT_RECOGNITION)
-    - [2. CTC-BASED TEXT RECOGNITION MODEL INFERENCE](#CTC-BASED_RECOGNITION)
-    - [3. SRN-BASED TEXT RECOGNITION MODEL INFERENCE](#SRN-BASED_RECOGNITION)
-    - [3. TEXT RECOGNITION MODEL INFERENCE USING CUSTOM CHARACTERS DICTIONARY](#USING_CUSTOM_CHARACTERS)
-    - [4. MULTILINGUAL MODEL INFERENCE](MULTILINGUAL_MODEL_INFERENCE)
+- [3. Text Recognition Model Inference](#RECOGNITION_MODEL_INFERENCE)
+    - [3.1 Lightweight Chinese Text Recognition Model Reference](#LIGHTWEIGHT_RECOGNITION)
+    - [3.2 CTC-Based Text Recognition Model Inference](#CTC-BASED_RECOGNITION)
+    - [3.3 SRN-Based Text Recognition Model Inference](#SRN-BASED_RECOGNITION)
+    - [3.4 Text Recognition Model Inference Using Custom Characters Dictionary](#USING_CUSTOM_CHARACTERS)
+    - [3.5 Multilingual Model Inference](#MULTILINGUAL_MODEL_INFERENCE)
 
-- [ANGLE CLASSIFICATION MODEL INFERENCE](#ANGLE_CLASS_MODEL_INFERENCE)
-    - [1. ANGLE CLASSIFICATION MODEL INFERENCE](#ANGLE_CLASS_MODEL_INFERENCE)
+- [4. Angle Classification Model Inference](#ANGLE_CLASS_MODEL_INFERENCE)
 
-- [TEXT DETECTION ANGLE CLASSIFICATION AND RECOGNITION INFERENCE CONCATENATION](#CONCATENATION)
-    - [1. LIGHTWEIGHT CHINESE MODEL](#LIGHTWEIGHT_CHINESE_MODEL)
-    - [2. OTHER MODELS](#OTHER_MODELS)
+- [5. Text Detection Angle Classification And Recognition Inference Concatenation](#CONCATENATION)
+    - [5.1 Lightweight Chinese Model](#LIGHTWEIGHT_CHINESE_MODEL)
+    - [5.2 Other Models](#OTHER_MODELS)
 
 <a name="CONVERT"></a>
-## CONVERT TRAINING MODEL TO INFERENCE MODEL
+## 1. Convert Training Model to Inference Model
 <a name="Convert_detection_model"></a>
-### Convert detection model to inference model
+
+### 1.1 Convert Detection Model to Inference Model
 
 Download the lightweight Chinese detection model:
 ```
@@ -67,7 +66,7 @@ inference/det_db/
 ```
 
 <a name="Convert_recognition_model"></a>
-### Convert recognition model to inference model
+### 1.2 Convert Recognition Model to Inference Model
 
 Download the lightweight Chinese recognition model:
 ```
@@ -95,7 +94,7 @@ inference/det_db/
 ```
 
 <a name="Convert_angle_class_model"></a>
-### Convert angle classification model to inference model
+### 1.3 Convert Angle Classification Model to Inference Model
 
 Download the angle classification model:
 ```
@@ -122,13 +121,13 @@ inference/det_db/
 
 
 <a name="DETECTION_MODEL_INFERENCE"></a>
-## TEXT DETECTION MODEL INFERENCE
+## 2. Text Detection Model Inference
 
 The following will introduce the lightweight Chinese detection model inference, DB text detection model inference and EAST text detection model inference. The default configuration is based on the inference setting of the DB text detection model.
 Because EAST and DB algorithms are very different, when inference, it is necessary to **adapt the EAST text detection algorithm by passing in corresponding parameters**.
 
 <a name="LIGHTWEIGHT_DETECTION"></a>
-### 1. LIGHTWEIGHT CHINESE DETECTION MODEL INFERENCE
+### 2.1 Lightweight Chinese Detection Model Inference
 
 For lightweight Chinese detection model inference, you can execute the following commands:
 
@@ -163,7 +162,7 @@ python3 tools/infer/predict_det.py --image_dir="./doc/imgs/1.jpg" --det_model_di
 ```
 
 <a name="DB_DETECTION"></a>
-### 2. DB TEXT DETECTION MODEL INFERENCE
+### 2.2 DB Text Detection Model Inference
 
 First, convert the model saved in the DB text detection training process into an inference model. Taking the model based on the Resnet50_vd backbone network and trained on the ICDAR2015 English dataset as an example ([model download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_db_v2.0_train.tar)), you can use the following command to convert:
 
@@ -184,7 +183,7 @@ The visualized text detection results are saved to the `./inference_results` fol
 **Note**: Since the ICDAR2015 dataset has only 1,000 training images, mainly for English scenes, the above model has very poor detection result on Chinese text images.
 
 <a name="EAST_DETECTION"></a>
-### 3. EAST TEXT DETECTION MODEL INFERENCE
+### 2.3 EAST TEXT DETECTION MODEL INFERENCE
 
 First, convert the model saved in the EAST text detection training process into an inference model. Taking the model based on the Resnet50_vd backbone network and trained on the ICDAR2015 English dataset as an example ([model download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_east_v2.0_train.tar)), you can use the following command to convert:
 
@@ -205,7 +204,7 @@ The visualized text detection results are saved to the `./inference_results` fol
 
 
 <a name="SAST_DETECTION"></a>
-### 4. SAST TEXT DETECTION MODEL INFERENCE
+### 2.4 Sast Text Detection Model Inference
 #### (1). Quadrangle text detection model (ICDAR2015)  
 First, convert the model saved in the SAST text detection training process into an inference model. Taking the model based on the Resnet50_vd backbone network and trained on the ICDAR2015 English dataset as an example ([model download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/det_r50_vd_sast_icdar15_v2.0_train.tar)), you can use the following command to convert:
 
@@ -243,13 +242,13 @@ The visualized text detection results are saved to the `./inference_results` fol
 **Note**: SAST post-processing locality aware NMS has two versions: Python and C++. The speed of C++ version is obviously faster than that of Python version. Due to the compilation version problem of NMS of C++ version, C++ version NMS will be called only in Python 3.5 environment, and python version NMS will be called in other cases.
 
 <a name="RECOGNITION_MODEL_INFERENCE"></a>
-## TEXT RECOGNITION MODEL INFERENCE
+## 3. Text Recognition Model Inference
 
 The following will introduce the lightweight Chinese recognition model inference, other CTC-based and Attention-based text recognition models inference. For Chinese text recognition, it is recommended to choose the recognition model based on CTC loss. In practice, it is also found that the result of the model based on Attention loss is not as good as the one based on CTC loss. In addition, if the characters dictionary is modified during training, make sure that you use the same characters set during inferencing. Please check below for details.
 
 
 <a name="LIGHTWEIGHT_RECOGNITION"></a>
-### 1. LIGHTWEIGHT CHINESE TEXT RECOGNITION MODEL REFERENCE
+### 3.1 Lightweight Chinese Text Recognition Model Reference
 
 For lightweight Chinese recognition model inference, you can execute the following commands:
 
@@ -269,7 +268,7 @@ Predicts of ./doc/imgs_words_en/word_10.png:('PAIN', 0.9897658)
 ```
 
 <a name="CTC-BASED_RECOGNITION"></a>
-### 2. CTC-BASED TEXT RECOGNITION MODEL INFERENCE
+### 3.2 CTC-Based Text Recognition Model Inference
 
 Taking CRNN as an example, we introduce the recognition model inference based on CTC loss. Rosetta and Star-Net are used in a similar way, No need to set the recognition algorithm parameter rec_algorithm.
 
@@ -292,6 +291,7 @@ After executing the command, the recognition result of the above image is as fol
 ```bash
 Predicts of ./doc/imgs_words_en/word_336.png:('super', 0.9999073)
 ```
+
 **Note**：Since the above model refers to [DTRB](https://arxiv.org/abs/1904.01906) text recognition training and evaluation process, it is different from the training of lightweight Chinese recognition model in two aspects:
 
 - The image resolution used in training is different: the image resolution used in training the above model is [3，32，100], while during our Chinese model training, in order to ensure the recognition effect of long text, the image resolution used in training is [3, 32, 320]. The default shape parameter of the inference stage is the image resolution used in training phase, that is [3, 32, 320]. Therefore, when running inference of the above English model here, you need to set the shape of the recognition image through the parameter `rec_image_shape`.
@@ -304,7 +304,7 @@ dict_character = list(self.character_str)
 ```
 
 <a name="SRN-BASED_RECOGNITION"></a>
-### 3. SRN-BASED TEXT RECOGNITION MODEL INFERENCE
+### 3.3 SRN-Based Text Recognition Model Inference
 
 The recognition model based on SRN requires additional setting of the recognition algorithm parameter
 --rec_algorithm="SRN". At the same time, it is necessary to ensure that the predicted shape is consistent
@@ -319,7 +319,7 @@ python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png
 ```
 
 <a name="USING_CUSTOM_CHARACTERS"></a>
-### 4. TEXT RECOGNITION MODEL INFERENCE USING CUSTOM CHARACTERS DICTIONARY
+### 3.4 Text Recognition Model Inference Using Custom Characters Dictionary
 If the text dictionary is modified during training, when using the inference model to predict, you need to specify the dictionary path used by `--rec_char_dict_path`, and set `rec_char_type=ch`
 
 ```
@@ -327,7 +327,8 @@ python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png
 ```
 
 <a name="MULTILINGUAL_MODEL_INFERENCE"></a>
-### 5. MULTILINGAUL MODEL INFERENCE
+
+### 3.5 Multilingual Model Inference
 If you need to predict other language models, when using inference model prediction, you need to specify the dictionary path used by `--rec_char_dict_path`. At the same time, in order to get the correct visualization results,
 You need to specify the visual font path through `--vis_font_path`. There are small language fonts provided by default under the `doc/fonts` path, such as Korean recognition:
 
@@ -343,13 +344,7 @@ Predicts of ./doc/imgs_words/korean/1.jpg:('바탕으로', 0.9948904)
 ```
 
 <a name="ANGLE_CLASSIFICATION_MODEL_INFERENCE"></a>
-## ANGLE CLASSIFICATION MODEL INFERENCE
-
-The following will introduce the angle classification model inference.
-
-
-<a name="ANGLE_CLASS_MODEL_INFERENCE"></a>
-### 1.ANGLE CLASSIFICATION MODEL INFERENCE
+## 4. Angle Classification Model Inference
 
 For angle classification model inference, you can execute the following commands:
 
@@ -371,10 +366,10 @@ After executing the command, the prediction results (classification angle and sc
 ```
 
 <a name="CONCATENATION"></a>
-## TEXT DETECTION ANGLE CLASSIFICATION AND RECOGNITION INFERENCE CONCATENATION
+## 5. Text Detection Angle Classification and Recognition Inference Concatenation
 
 <a name="LIGHTWEIGHT_CHINESE_MODEL"></a>
-### 1. LIGHTWEIGHT CHINESE MODEL
+### 5.1 Lightweight Chinese Model
 
 When performing prediction, you need to specify the path of a single image or a folder of images through the parameter `image_dir`, the parameter `det_model_dir` specifies the path to detect the inference model, the parameter `cls_model_dir` specifies the path to angle classification inference model and the parameter `rec_model_dir` specifies the path to identify the inference model. The parameter `use_angle_cls` is used to control whether to enable the angle classification model. The parameter `use_mp` specifies whether to use multi-process to infer `total_process_num` specifies process number when using multi-process. The parameter . The visualized recognition results are saved to the `./inference_results` folder by default.
 
@@ -388,14 +383,14 @@ python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --de
 # use multi-process
 python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./inference/det_db/" --rec_model_dir="./inference/rec_crnn/" --use_angle_cls=false --use_mp=True --total_process_num=6
 ```
-```
+
 
 After executing the command, the recognition result image is as follows:
 
 ![](../imgs_results/system_res_00018069.jpg)
 
 <a name="OTHER_MODELS"></a>
-### 2. OTHER MODELS
+### 5.2 Other Models
 
 If you want to try other detection algorithms or recognition algorithms, please refer to the above text detection model inference and text recognition model inference, update the corresponding configuration and model.
 

doc/doc_en/models_en.md

+# PP-OCR Model Zoo
+The PP-OCR model zoo section explains some basic concepts of the OCR model and how to quickly use the models in the PP-OCR model library.
+
+This section contains two parts. Firstly, [PP-OCR Model Download](./models_list_en.md) explains the concept of PP-OCR model types and provides links to download all models.  The next [Python Inference for PP-OCR Model Zoo](./inference_ppocr_en.md) is an introduction to the use of the PP-OCR model library, which can quickly utilize the rich model library models to obtain test results through the Python inference engine.
+
+------
+
+Let's first understand some basic concepts.
+
+- [Introduction about OCR](#introduction-about-ocr)
+  * [Basic Concepts of OCR Detection Model](#basic-concepts-of-ocr-detection-model)
+  * [Basic Concepts of OCR Recognition Model](#basic-concepts-of-ocr-recognition-model)
+  * [PP-OCR Model](#pp-ocr-model)
+
+
+## 1. Introduction about OCR
+
+This section briefly introduces the basic concepts of OCR detection model and recognition model, and introduces PaddleOCR's PP-OCR model.
+
+OCR (Optical Character Recognition, Optical Character Recognition) is currently the general term for text recognition. It is not limited to document or book text recognition, but also includes recognizing text in natural scenes. It can also be called STR (Scene Text Recognition).
+
+OCR text recognition generally includes two parts, text detection and text recognition. The text detection module first uses detection algorithms to detect text lines in the image. And then the recognition algorithm to identify the specific text in the text line.
+
+
+### 1.1 Basic Concepts of OCR Detection Model
+
+Text detection can locate the text area in the image, and then usually mark the word or text line in the form of a bounding box. Traditional text detection algorithms mostly extract features manually, which are characterized by fast speed and good effect in simple scenes, but the effect will be greatly reduced when faced with natural scenes. Currently, deep learning methods are mostly used.
+
+Text detection algorithms based on deep learning can be roughly divided into the following categories:
+1. Method based on target detection. Generally, after the text box is predicted, the final text box is filtered through NMS, which is mostly four-point text box, which is not ideal for curved text scenes. Typical algorithms are methods such as EAST and Text Box.
+2. Method based on text segmentation. The text line is regarded as the segmentation target, and then the external text box is constructed through the segmentation result, which can handle curved text, and the effect is not ideal for the text cross scene problem. Typical algorithms are DB, PSENet and other methods.
+3. Hybrid target detection and segmentation method.
+
+
+### 1.2 Basic Concepts of OCR Recognition Model
+
+The input of the OCR recognition algorithm is generally text lines images which has less background information, and the text information occupies the main part. The recognition algorithm can be divided into two types of algorithms:
+1. CTC-based method. The text prediction module of the recognition algorithm is based on CTC, and the commonly used algorithm combination is CNN+RNN+CTC. There are also some algorithms that try to add transformer modules to the network and so on.
+2. Attention-based method. The text prediction module of the recognition algorithm is based on Attention, and the commonly used algorithm combination is CNN+RNN+Attention.
+
+
+### 1.3 PP-OCR Model
+
+PaddleOCR integrates many OCR algorithms, text detection algorithms include DB, EAST, SAST, etc., text recognition algorithms include CRNN, RARE, StarNet, Rosetta, SRN and other algorithms.
+
+Among them, PaddleOCR has released the PP-OCR series model for the general OCR in Chinese and English natural scenes. The PP-OCR model is composed of the DB+CRNN algorithm. It uses massive Chinese data training and model tuning methods to have high text detection and recognition capabilities in Chinese scenes. And PaddleOCR has launched a high-precision and ultra-lightweight PP-OCRv2 model. The detection model is only 3M, and the recognition model is only 8.5M. Using [PaddleSlim](https://github.com/PaddlePaddle/PaddleSlim)'s model quantification method, the detection model can be compressed to 0.8M without reducing the accuracy. The recognition is compressed to 3M, which is more suitable for mobile deployment scenarios.

doc/doc_en/paddleOCR_overview_en.md

@@ -36,4 +36,4 @@ If you getting this error `OSError: [WinError 126] The specified module could no
 
 Please try to download Shapely whl file using [http://www.lfd.uci.edu/~gohlke/pythonlibs/#shapely](http://www.lfd.uci.edu/~gohlke/pythonlibs/#shapely).
 
-Reference: [Solve shapely installation on windows](
\ No newline at end of file
+Reference: [Solve shapely installation on windows](https://stackoverflow.com/questions/44398265/install-shapely-oserror-winerror-126-the-specified-module-could-not-be-found)
\ No newline at end of file