diff --git a/README.md b/README.md
index 1f0f1720..26ecef77 100644
--- a/README.md
+++ b/README.md
@@ -1,213 +1,216 @@
-[English](README_en.md) | 简体中文
+English | [简体中文](README_cn.md)
-## 简介
-PaddleOCR旨在打造一套丰富、领先、且实用的OCR工具库，助力使用者训练出更好的模型，并应用落地。
+## Introduction
+PaddleOCR aims to create rich, leading, and practical OCR tools that help users train better models and apply them into practice.
-**直播预告：2020年7月21日晚8点B站直播，PaddleOCR开源大礼包全面解读，直播地址当天更新**
+**Live stream on coming day**: July 21, 2020 at 8 pm BiliBili station live stream
-**近期更新**
-- 2020.7.15 添加基于EasyEdge和Paddle-Lite的移动端DEMO，支持iOS和Android系统
-- 2020.7.15 完善预测部署，添加基于C++预测引擎推理、服务化部署和端侧部署方案，以及超轻量级中文OCR模型预测耗时Benchmark
-- 2020.7.15 整理OCR相关数据集、常用数据标注以及合成工具
-- 2020.7.9 添加支持空格的识别模型，识别效果，预测及训练方式请参考快速开始和文本识别训练相关文档
-- 2020.7.9 添加数据增强、学习率衰减策略,具体参考[配置文件](./doc/doc_ch/config.md)
-- [more](./doc/doc_ch/update.md)
+**Recent updates**
+- 2020.7.15, Add mobile App demo , support both iOS and Android ( based on easyedge and Paddle Lite)
+- 2020.7.15, Improve the deployment ability, add the C + + inference , serving deployment. In addtion, the benchmarks of the ultra-lightweight OCR model are provided.
+- 2020.7.15, Add several related datasets, data annotation and synthesis tools.
+- 2020.7.9 Add a new model to support recognize the character "space".
+- 2020.7.9 Add the data augument and learning rate decay strategies during training.
+- [more](./doc/doc_en/update_en.md)
-## 特性
-- 超轻量级中文OCR模型，总模型仅8.6M
- - 单模型支持中英文数字组合识别、竖排文本识别、长文本识别
- - 检测模型DB（4.1M）+识别模型CRNN（4.5M）
-- 实用通用中文OCR模型
-- 多种预测推理部署方案，包括服务部署和端侧部署
-- 多种文本检测训练算法，EAST、DB
-- 多种文本识别训练算法，Rosetta、CRNN、STAR-Net、RARE
-- 可运行于Linux、Windows、MacOS等多种系统
+## Features
+- Ultra-lightweight OCR model, total model size is only 8.6M
+ - Single model supports Chinese/English numbers combination recognition, vertical text recognition, long text recognition
+ - Detection model DB (4.1M) + recognition model CRNN (4.5M)
+- Various text detection algorithms: EAST, DB
+- Various text recognition algorithms: Rosetta, CRNN, STAR-Net, RARE
+- Support Linux, Windows, MacOS and other systems.
-## 快速体验
+## Visualization
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-## REFERENCES
-```
-1. EAST:
-@inproceedings{zhou2017east,
- title={EAST: an efficient and accurate scene text detector},
- author={Zhou, Xinyu and Yao, Cong and Wen, He and Wang, Yuzhi and Zhou, Shuchang and He, Weiran and Liang, Jiajun},
- booktitle={Proceedings of the IEEE conference on Computer Vision and Pattern Recognition},
- pages={5551--5560},
- year={2017}
-}
-
-2. DB:
-@article{liao2019real,
- title={Real-time Scene Text Detection with Differentiable Binarization},
- author={Liao, Minghui and Wan, Zhaoyi and Yao, Cong and Chen, Kai and Bai, Xiang},
- journal={arXiv preprint arXiv:1911.08947},
- year={2019}
-}
-
-3. DTRB:
-@inproceedings{baek2019wrong,
- title={What is wrong with scene text recognition model comparisons? dataset and model analysis},
- author={Baek, Jeonghun and Kim, Geewook and Lee, Junyeop and Park, Sungrae and Han, Dongyoon and Yun, Sangdoo and Oh, Seong Joon and Lee, Hwalsuk},
- booktitle={Proceedings of the IEEE International Conference on Computer Vision},
- pages={4715--4723},
- year={2019}
-}
-
-4. SAST:
-@inproceedings{wang2019single,
- title={A Single-Shot Arbitrarily-Shaped Text Detector based on Context Attended Multi-Task Learning},
- author={Wang, Pengfei and Zhang, Chengquan and Qi, Fei and Huang, Zuming and En, Mengyi and Han, Junyu and Liu, Jingtuo and Ding, Errui and Shi, Guangming},
- booktitle={Proceedings of the 27th ACM International Conference on Multimedia},
- pages={1277--1285},
- year={2019}
-}
-
-5. SRN:
-@article{yu2020towards,
- title={Towards Accurate Scene Text Recognition with Semantic Reasoning Networks},
- author={Yu, Deli and Li, Xuan and Zhang, Chengquan and Han, Junyu and Liu, Jingtuo and Ding, Errui},
- journal={arXiv preprint arXiv:2003.12294},
- year={2020}
-}
-
-6. end2end-psl:
-@inproceedings{sun2019chinese,
- title={Chinese Street View Text: Large-scale Chinese Text Reading with Partially Supervised Learning},
- author={Sun, Yipeng and Liu, Jiaming and Liu, Wei and Han, Junyu and Ding, Errui and Liu, Jingtuo},
- booktitle={Proceedings of the IEEE International Conference on Computer Vision},
- pages={9086--9095},
- year={2019}
-}
-```
-
-## LICENSE
-This project is released under Apache 2.0 license
-
-## CONTRIBUTION
-We welcome all the contributions to PaddleOCR and appreciate for your feedback very much.
-
-- Many thanks to [Khanh Tran](https://github.com/xxxpsyduck) for contributing the English documentation.
-- Many thanks to [zhangxin](https://github.com/ZhangXinNan) for contributing the new visualize function、add .gitgnore and discard set PYTHONPATH manually.
-- Many thanks to [lyl120117](https://github.com/lyl120117) for contributing the code for printing the network structure.
diff --git a/deploy/cpp_infer/readme.md b/deploy/cpp_infer/readme.md
index 47aa3a11..03db8c50 100644
--- a/deploy/cpp_infer/readme.md
+++ b/deploy/cpp_infer/readme.md
@@ -184,7 +184,7 @@ make -j
### 运行demo
-* 执行以下命令，完成对一幅图像的OCR识别与检测，最终输出
+* 执行以下命令，完成对一幅图像的OCR识别与检测。
```shell
sh tools/run.sh
diff --git a/deploy/cpp_infer/readme_en.md b/deploy/cpp_infer/readme_en.md
new file mode 100644
index 00000000..ecb29f9b
--- /dev/null
+++ b/deploy/cpp_infer/readme_en.md
@@ -0,0 +1,213 @@
+# Server-side C++ inference
+
+
+In this tutorial, we will introduce the detailed steps of deploying PaddleOCR ultra-lightweight Chinese detection and recognition models on the server side.
+
+
+## 1. Prepare the environment
+
+### Environment
+
+- Linux, docker is recommended.
+
+
+### 1.1 Compile opencv
+
+* First of all, you need to download the source code compiled package in the Linux environment from the opencv official website. Taking opencv3.4.7 as an example, the download command is as follows.
+
+```
+wget https://github.com/opencv/opencv/archive/3.4.7.tar.gz
+tar -xf 3.4.7.tar.gz
+```
+
+Finally, you can see the folder of `opencv-3.4.7/` in the current directory.
+
+* Compile opencv, the opencv source path (`root_path`) and installation path (`install_path`) should be set by yourself. Enter the opencv source code path and compile it in the following way.
+
+
+```shell
+root_path=your_opencv_root_path
+install_path=${root_path}/opencv3
+
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+ -DCMAKE_INSTALL_PREFIX=${install_path} \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DBUILD_SHARED_LIBS=OFF \
+ -DWITH_IPP=OFF \
+ -DBUILD_IPP_IW=OFF \
+ -DWITH_LAPACK=OFF \
+ -DWITH_EIGEN=OFF \
+ -DCMAKE_INSTALL_LIBDIR=lib64 \
+ -DWITH_ZLIB=ON \
+ -DBUILD_ZLIB=ON \
+ -DWITH_JPEG=ON \
+ -DBUILD_JPEG=ON \
+ -DWITH_PNG=ON \
+ -DBUILD_PNG=ON \
+ -DWITH_TIFF=ON \
+ -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+Among them, `root_path` is the downloaded opencv source code path, and `install_path` is the installation path of opencv. After `make install` is completed, the opencv header file and library file will be generated in this folder for later OCR source code compilation.
+
+
+
+The final file structure under the opencv installation path is as follows.
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib
+|-- lib64
+|-- share
+```
+
+### 1.2 Compile or download or the Paddle inference library
+
+* There are 2 ways to obtain the Paddle inference library, described in detail below.
+
+
+#### 1.2.1 Compile from the source code
+* If you want to get the latest Paddle inference library features, you can download the latest code from Paddle github repository and compile the inference library from the source code.
+* You can refer to [Paddle inference library] (https://www.paddlepaddle.org.cn/documentation/docs/en/advanced_guide/inference_deployment/inference/build_and_install_lib_en.html) to get the Paddle source code from github, and then compile To generate the latest inference library. The method of using git to access the code is as follows.
+
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+```
+
+* After entering the Paddle directory, the compilation method is as follows.
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+ -DWITH_CONTRIB=OFF \
+ -DWITH_MKL=ON \
+ -DWITH_MKLDNN=ON \
+ -DWITH_TESTING=OFF \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DWITH_INFERENCE_API_TEST=OFF \
+ -DON_INFER=ON \
+ -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+For more compilation parameter options, please refer to the official website of the Paddle C++ inference library:[https://www.paddlepaddle.org.cn/documentation/docs/en/advanced_guide/inference_deployment/inference/build_and_install_lib_en.html](https://www.paddlepaddle.org.cn/documentation/docs/en/advanced_guide/inference_deployment/inference/build_and_install_lib_en.html).
+
+
+* After the compilation process, you can see the following files in the folder of `build/fluid_inference_install_dir/`.
+
+```
+build/fluid_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+Among them, `paddle` is the Paddle library required for C++ prediction later, and `version.txt` contains the version information of the current inference library.
+
+
+
+#### 1.2.2 Direct download and installation
+
+* Different cuda versions of the Linux inference library (based on GCC 4.8.2) are provided on the
+[Paddle inference library official website](https://www.paddlepaddle.org.cn/documentation/docs/en/advanced_guide/inference_deployment/inference/build_and_install_lib_en.html). You can view and select the appropriate version of the inference library on the official website.
+
+
+* After downloading, use the following method to uncompress.
+
+```
+tar -xf fluid_inference.tgz
+```
+
+Finally you can see the following files in the folder of `fluid_inference/`.
+
+
+## 2. Compile and run the demo
+
+### 2.1 Export the inference model
+
+* You can refer to [Model inference](../../doc/doc_ch/inference.md)，export the inference model. After the model is exported, assuming it is placed in the `inference` directory, the directory structure is as follows.
+
+```
+inference/
+|-- det_db
+| |--model
+| |--params
+|-- rec_rcnn
+| |--model
+| |--params
+```
+
+
+### 2.2 Compile PaddleOCR C++ inference demo
+
+
+* The compilation commands are as follows. The addresses of Paddle C++ inference library, opencv and other Dependencies need to be replaced with the actual addresses on your own machines.
+
+```shell
+sh tools/build.sh
+```
+
+具体地，`tools/build.sh`中内容如下。
+
+```shell
+OPENCV_DIR=your_opencv_dir
+LIB_DIR=your_paddle_inference_dir
+CUDA_LIB_DIR=your_cuda_lib_dir
+CUDNN_LIB_DIR=your_cudnn_lib_dir
+
+BUILD_DIR=build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+ -DPADDLE_LIB=${LIB_DIR} \
+ -DWITH_MKL=ON \
+ -DDEMO_NAME=ocr_system \
+ -DWITH_GPU=OFF \
+ -DWITH_STATIC_LIB=OFF \
+ -DUSE_TENSORRT=OFF \
+ -DOPENCV_DIR=${OPENCV_DIR} \
+ -DCUDNN_LIB=${CUDNN_LIB_DIR} \
+ -DCUDA_LIB=${CUDA_LIB_DIR} \
+
+make -j
+```
+
+`OPENCV_DIR` is the opencv installation path; `LIB_DIR` is the download (`fluid_inference` folder) or the generated Paddle inference library path (`build/fluid_inference_install_dir` folder); `CUDA_LIB_DIR` is the cuda library file path, in docker; it is `/usr/local/cuda/lib64`; `CUDNN_LIB_DIR` is the cudnn library file path, in docker it is `/usr/lib/x86_64-linux-gnu/`.
+
+
+* After the compilation is completed, an executable file named `ocr_system` will be generated in the `build` folder.
+
+
+### Run the demo
+* Execute the following command to complete the OCR recognition and detection of an image.
+
+```shell
+sh tools/run.sh
+```
+
+The detection results will be shown on the screen, which is as follows.
+
+
+
+
+
+
*`When Version is not specified, the latest version is selected by default`*|
+|--port/-p|Service port, default is 8866|
+|--use_multiprocess|Enable concurrent mode, the default is single-process mode, this mode is recommended for multi-core CPU machines
*`Windows operating system only supports single-process mode`*|
+|--workers|The number of concurrent tasks specified in concurrent mode, the default is `2*cpu_count-1`, where `cpu_count` is the number of CPU cores|
+
+For example, start the 2-stage series service:
+```shell
+hub serving start -m ocr_system
+```
+
+This completes the deployment of a service API, using the default port number 8866.
+
+#### Way 2. Start with configuration file（CPU、GPU）
+**start command：**
+```shell
+hub serving start --config/-c config.json
+```
+Wherein, the format of `config.json` is as follows:
+```python
+{
+ "modules_info": {
+ "ocr_system": {
+ "init_args": {
+ "version": "1.0.0",
+ "use_gpu": true
+ },
+ "predict_args": {
+ }
+ }
+ },
+ "port": 8868,
+ "use_multiprocess": false,
+ "workers": 2
+}
+```
+- The configurable parameters in `init_args` are consistent with the `_initialize` function interface in `module.py`. Among them, **when `use_gpu` is `true`, it means that the GPU is used to start the service**.
+- The configurable parameters in `predict_args` are consistent with the `predict` function interface in `module.py`.
+
+**Note:**
+- When using the configuration file to start the service, other parameters will be ignored.
+- If you use GPU prediction (that is, `use_gpu` is set to `true`), you need to set the environment variable CUDA_VISIBLE_DEVICES before starting the service, such as: ```export CUDA_VISIBLE_DEVICES=0```, otherwise you do not need to set it.
+- **`use_gpu` and `use_multiprocess` cannot be `true` at the same time.**
+
+For example, use GPU card No. 3 to start the 2-stage series service:
+```shell
+export CUDA_VISIBLE_DEVICES=3
+hub serving start -c deploy/hubserving/ocr_system/config.json
+```
+
+## Send prediction requests
+After the service starts, you can use the following command to send a prediction request to obtain the prediction result:
+```shell
+python tools/test_hubserving.py server_url image_path
+```
+
+Two parameters need to be passed to the script:
+- **server_url**：service address，format of which is
+`http://[ip_address]:[port]/predict/[module_name]`
+For example, if the detection, recognition and 2-stage serial services are started with provided configuration files, the respective `server_url` would be:
+`http://127.0.0.1:8866/predict/ocr_det`
+`http://127.0.0.1:8867/predict/ocr_rec`
+`http://127.0.0.1:8868/predict/ocr_system`
+- **image_path**：Test image path, can be a single image path or an image directory path
+
+**Eg.**
+```shell
+python tools/test_hubserving.py http://127.0.0.1:8868/predict/ocr_system ./doc/imgs/
+```
+
+## Returned result format
+The returned result is a list. Each item in the list is a dict. The dict may contain three fields. The information is as follows:
+
+|field name|data type|description|
+|-|-|-|
+|text|str|text content|
+|confidence|float|text recognition confidence|
+|text_region|list|text location coordinates|
+
+The fields returned by different modules are different. For example, the results returned by the text recognition service module do not contain `text_region`. The details are as follows:
+
+|field name/module name|ocr_det|ocr_rec|ocr_system|
+|-|-|-|-|
+|text||✔|✔|
+|confidence||✔|✔|
+|text_region|✔||✔|
+
+**Note：** If you need to add, delete or modify the returned fields, you can modify the file `module.py` of the corresponding module. For the complete process, refer to the user-defined modification service module in the next section.
+
+## User defined service module modification
+If you need to modify the service logic, the following steps are generally required (take the modification of `ocr_system` for example):
+
+- 1. Stop service
+```shell
+hub serving stop --port/-p XXXX
+```
+- 2. Modify the code in the corresponding files, like `module.py` and `params.py`, according to the actual needs.
+For example, if you need to replace the model used by the deployed service, you need to modify model path parameters `det_model_dir` and `rec_model_dir` in `params.py`. Of course, other related parameters may need to be modified at the same time. Please modify and debug according to the actual situation. It is suggested to run `module.py` directly for debugging after modification before starting the service test.
+- 3. Uninstall old service module
+```shell
+hub uninstall ocr_system
+```
+- 4. Install modified service module
+```shell
+hub install deploy/hubserving/ocr_system/
+```
+- 5. Restart service
+```shell
+hub serving start -m ocr_system
+```
diff --git a/doc/doc_en/tricks_en.md b/doc/doc_en/tricks_en.md
new file mode 100644
index 00000000..eab9c892
--- /dev/null
+++ b/doc/doc_en/tricks_en.md
@@ -0,0 +1,68 @@
+## Tricks
+Here we have sorted out some Chinese OCR training and prediction tricks, which are being updated continuously. You are welcome to contribute more OCR tricks ~
+
+- [Replace Backbone Network](#ReplaceBackboneNetwork)
+- [Long Chinese Text Recognition](#LongChineseTextRecognition)
+- [Space Recognition](#SpaceRecognition)
+
+
+#### 1、Replace Backbone Network
+- **Problem Description**
+
+ At present, ResNet_vd series and MobileNetV3 series are the backbone networks used in PaddleOCR, whether replacing the other backbone networks will help to improve the accuracy? What should be paid attention to when replacing?
+
+- **Tips**
+ - Whether text detection or text recognition, the choice of backbone network is a trade-off between prediction effect and prediction efficiency. Generally, a larger backbone network is selected, e.g. ResNet101_vd, then the performance of the detection or recognition is more accurate, but the time cost will increase accordingly. And a smaller backbone network is selected, e.g. MobileNetV3_small_x0_35, the prediction speed is faster, but the accuracy of detection or recognition will be reduced. Fortunately, the detection or recognition effect of different backbone networks is positively correlated with the performance of ImageNet 1000 classification task. [**PaddleClas**](https://github.com/PaddlePaddle/PaddleClas/blob/master/README_en.md) have sorted out the 23 series of classification network structures, such as ResNet_vd、Res2Net、HRNet、MobileNetV3、GhostNet. It provides the top1 accuracy of classification, the time cost of GPU(V100 and T4) and CPU(SD 855), and the 117 pretrained models [**download addresses**](https://paddleclas-en.readthedocs.io/en/latest/models/models_intro_en.html).
+
+ - Similar as the 4 stages of ResNet, the replacement of text detection backbone network is to determine those four stages to facilitate the integration of FPN like the object detection heads. In addition, for the text detection problem, the pre trained model in ImageNet1000 can accelerate the convergence and improve the accuracy.
+
+ - In order to replace the backbone network of text recognition, we need to pay attention to the descending position of network width and height stride. Since the ratio between width and height is large in chinese text recognition, the frequency of height decrease is less and the frequency of width decrease is more. You can refer the [modifies of MobileNetV3](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/ppocr/modeling/backbones/rec_mobilenet_v3.py) in PaddleOCR.
+
+
+#### 2、Long Chinese Text Recognition
+- **Problem Description**
+ The maximum resolution of Chinese recognition model during training is [3,32,320], if the text image to be recognized is too long, as shown in the figure below, how to adapt?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+