Merge branch 'dygraph' into fix_prepare

a8a9b2e5 · xiaoting · GitHub · 49e42a16 · 0f5a5d96 · a8a9b2e5
Unverified Commit a8a9b2e5 authored Sep 07, 2021 by xiaoting Committed by GitHub Sep 07, 2021
20 changed files
--- a/deploy/cpp_infer/src/ocr_cls.cpp
+++ b/deploy/cpp_infer/src/ocr_cls.cpp
@@ -77,10 +77,16 @@ void Classifier::LoadModel(const std::string &model_dir) {
  if (this->use_gpu_) {
    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+     if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      } 
      config.EnableTensorRtEngine(
          1 << 20, 10, 3,
-          this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+          precision,
-                          : paddle_infer::Config::Precision::kFloat32,
          false, false);
    }
  } else {

--- a/deploy/cpp_infer/src/ocr_det.cpp
+++ b/deploy/cpp_infer/src/ocr_det.cpp
@@ -26,10 +26,16 @@ void DBDetector::LoadModel(const std::string &model_dir) {
  if (this->use_gpu_) {
    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+     if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      } 
      config.EnableTensorRtEngine(
          1 << 20, 10, 3,
-          this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+          precision,
-                          : paddle_infer::Config::Precision::kFloat32,
          false, false);
      std::map<std::string, std::vector<int>> min_input_shape = {
          {"x", {1, 3, 50, 50}},
@@ -91,13 +97,16 @@ void DBDetector::LoadModel(const std::string &model_dir) {
 }
 void DBDetector::Run(cv::Mat &img,
-                     std::vector<std::vector<std::vector<int>>> &boxes) {
+                     std::vector<std::vector<std::vector<int>>> &boxes,
+                     std::vector<double> *times) {
  float ratio_h{};
  float ratio_w{};
  cv::Mat srcimg;
  cv::Mat resize_img;
  img.copyTo(srcimg);
+  auto preprocess_start = std::chrono::steady_clock::now();
  this->resize_op_.Run(img, resize_img, this->max_side_len_, ratio_h, ratio_w,
                       this->use_tensorrt_);
@@ -106,14 +115,17 @@ void DBDetector::Run(cv::Mat &img,
  std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
  this->permute_op_.Run(&resize_img, input.data());
+  auto preprocess_end = std::chrono::steady_clock::now();
  // Inference.
  auto input_names = this->predictor_->GetInputNames();
  auto input_t = this->predictor_->GetInputHandle(input_names[0]);
  input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
+  auto inference_start = std::chrono::steady_clock::now();
  input_t->CopyFromCpu(input.data());
  this->predictor_->Run();
  std::vector<float> out_data;
  auto output_names = this->predictor_->GetOutputNames();
  auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
@@ -123,7 +135,9 @@ void DBDetector::Run(cv::Mat &img,
  out_data.resize(out_num);
  output_t->CopyToCpu(out_data.data());
+  auto inference_end = std::chrono::steady_clock::now();
+  auto postprocess_start = std::chrono::steady_clock::now();
  int n2 = output_shape[2];
  int n3 = output_shape[3];
  int n = n2 * n3;
@@ -151,7 +165,15 @@ void DBDetector::Run(cv::Mat &img,
      this->det_db_unclip_ratio_, this->use_polygon_score_);
  boxes = post_processor_.FilterTagDetRes(boxes, ratio_h, ratio_w, srcimg);
+  auto postprocess_end = std::chrono::steady_clock::now();
  std::cout << "Detected boxes num: " << boxes.size() << endl;
+  std::chrono::duration<float> preprocess_diff = preprocess_end - preprocess_start;
+  times->push_back(double(preprocess_diff.count() * 1000));
+  std::chrono::duration<float> inference_diff = inference_end - inference_start;
+  times->push_back(double(inference_diff.count() * 1000));
+  std::chrono::duration<float> postprocess_diff = postprocess_end - postprocess_start;
+  times->push_back(double(postprocess_diff.count() * 1000));
  //// visualization
  if (this->visualize_) {

--- a/deploy/cpp_infer/src/ocr_rec.cpp
+++ b/deploy/cpp_infer/src/ocr_rec.cpp
@@ -16,13 +16,13 @@
 namespace PaddleOCR {
-void CRNNRecognizer::Run(cv::Mat &img) {
+void CRNNRecognizer::Run(cv::Mat &img, std::vector<double> *times) {
  cv::Mat srcimg;
  img.copyTo(srcimg);
  cv::Mat resize_img;
  float wh_ratio = float(srcimg.cols) / float(srcimg.rows);
+  auto preprocess_start = std::chrono::steady_clock::now();
  this->resize_op_.Run(srcimg, resize_img, wh_ratio, this->use_tensorrt_);
  this->normalize_op_.Run(&resize_img, this->mean_, this->scale_,
@@ -31,11 +31,13 @@ void CRNNRecognizer::Run(cv::Mat &img) {
  std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
  this->permute_op_.Run(&resize_img, input.data());
+  auto preprocess_end = std::chrono::steady_clock::now();
  // Inference.
  auto input_names = this->predictor_->GetInputNames();
  auto input_t = this->predictor_->GetInputHandle(input_names[0]);
  input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
+  auto inference_start = std::chrono::steady_clock::now();
  input_t->CopyFromCpu(input.data());
  this->predictor_->Run();
@@ -49,8 +51,10 @@ void CRNNRecognizer::Run(cv::Mat &img) {
  predict_batch.resize(out_num);
  output_t->CopyToCpu(predict_batch.data());
+  auto inference_end = std::chrono::steady_clock::now();
  // ctc decode
+  auto postprocess_start = std::chrono::steady_clock::now();
  std::vector<std::string> str_res;
  int argmax_idx;
  int last_index = 0;
@@ -73,11 +77,19 @@ void CRNNRecognizer::Run(cv::Mat &img) {
    }
    last_index = argmax_idx;
  }
+  auto postprocess_end = std::chrono::steady_clock::now();
  score /= count;
  for (int i = 0; i < str_res.size(); i++) {
    std::cout << str_res[i];
  }
  std::cout << "\tscore: " << score << std::endl;
+  std::chrono::duration<float> preprocess_diff = preprocess_end - preprocess_start;
+  times->push_back(double(preprocess_diff.count() * 1000));
+  std::chrono::duration<float> inference_diff = inference_end - inference_start;
+  times->push_back(double(inference_diff.count() * 1000));
+  std::chrono::duration<float> postprocess_diff = postprocess_end - postprocess_start;
+  times->push_back(double(postprocess_diff.count() * 1000));
 }
 void CRNNRecognizer::LoadModel(const std::string &model_dir) {
@@ -89,10 +101,16 @@ void CRNNRecognizer::LoadModel(const std::string &model_dir) {
  if (this->use_gpu_) {
    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+     if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      } 
      config.EnableTensorRtEngine(
          1 << 20, 10, 3,
-          this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+          precision,
-                          : paddle_infer::Config::Precision::kFloat32,
          false, false);
      std::map<std::string, std::vector<int>> min_input_shape = {
          {"x", {1, 3, 32, 10}}};
@@ -126,59 +144,4 @@ void CRNNRecognizer::LoadModel(const std::string &model_dir) {
  this->predictor_ = CreatePredictor(config);
 }
-cv::Mat CRNNRecognizer::GetRotateCropImage(const cv::Mat &srcimage,
-                                           std::vector<std::vector<int>> box) {
-  cv::Mat image;
-  srcimage.copyTo(image);
-  std::vector<std::vector<int>> points = box;
-  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
-  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
-  int left = int(*std::min_element(x_collect, x_collect + 4));
-  int right = int(*std::max_element(x_collect, x_collect + 4));
-  int top = int(*std::min_element(y_collect, y_collect + 4));
-  int bottom = int(*std::max_element(y_collect, y_collect + 4));
-  cv::Mat img_crop;
-  image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
-  for (int i = 0; i < points.size(); i++) {
-    points[i][0] -= left;
-    points[i][1] -= top;
-  }
-  int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
-                                pow(points[0][1] - points[1][1], 2)));
-  int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
-                                 pow(points[0][1] - points[3][1], 2)));
-  cv::Point2f pts_std[4];
-  pts_std[0] = cv::Point2f(0., 0.);
-  pts_std[1] = cv::Point2f(img_crop_width, 0.);
-  pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
-  pts_std[3] = cv::Point2f(0.f, img_crop_height);
-  cv::Point2f pointsf[4];
-  pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
-  pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
-  pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
-  pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
-  cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
-  cv::Mat dst_img;
-  cv::warpPerspective(img_crop, dst_img, M,
-                      cv::Size(img_crop_width, img_crop_height),
-                      cv::BORDER_REPLICATE);
-  if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
-    cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
-    cv::transpose(dst_img, srcCopy);
-    cv::flip(srcCopy, srcCopy, 0);
-    return srcCopy;
-  } else {
-    return dst_img;
-  }
-}
 } // namespace PaddleOCR
--- a/deploy/cpp_infer/src/utility.cpp
+++ b/deploy/cpp_infer/src/utility.cpp
@@ -92,4 +92,59 @@ void Utility::GetAllFiles(const char *dir_name,
  }
 }
+cv::Mat Utility::GetRotateCropImage(const cv::Mat &srcimage,
+                            std::vector<std::vector<int>> box) {
+  cv::Mat image;
+  srcimage.copyTo(image);
+  std::vector<std::vector<int>> points = box;
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+  cv::Mat img_crop;
+  image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
+  for (int i = 0; i < points.size(); i++) {
+    points[i][0] -= left;
+    points[i][1] -= top;
+  }
+  int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
+                                pow(points[0][1] - points[1][1], 2)));
+  int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
+                                 pow(points[0][1] - points[3][1], 2)));
+  cv::Point2f pts_std[4];
+  pts_std[0] = cv::Point2f(0., 0.);
+  pts_std[1] = cv::Point2f(img_crop_width, 0.);
+  pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
+  pts_std[3] = cv::Point2f(0.f, img_crop_height);
+  cv::Point2f pointsf[4];
+  pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
+  pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
+  pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
+  pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
+  cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
+  cv::Mat dst_img;
+  cv::warpPerspective(img_crop, dst_img, M,
+                      cv::Size(img_crop_width, img_crop_height),
+                      cv::BORDER_REPLICATE);
+  if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
+    cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
+    cv::transpose(dst_img, srcCopy);
+    cv::flip(srcCopy, srcCopy, 0);
+    return srcCopy;
+  } else {
+    return dst_img;
+  }
+}
 } // namespace PaddleOCR
\ No newline at end of file
--- a/deploy/slim/prune/sensitivity_anal.py
+++ b/deploy/slim/prune/sensitivity_anal.py
@@ -75,7 +75,7 @@ def main(config, device, logger, vdl_writer):
    model = build_model(config['Architecture'])
    flops = paddle.flops(model, [1, 3, 640, 640])
-    logger.info(f"FLOPs before pruning: {flops}")
+    logger.info("FLOPs before pruning: {}".format(flops))
    from paddleslim.dygraph import FPGMFilterPruner
    model.train()
@@ -106,8 +106,8 @@ def main(config, device, logger, vdl_writer):
    def eval_fn():
        metric = program.eval(model, valid_dataloader, post_process_class,
-                              eval_class)
+                              eval_class, False)
-        logger.info(f"metric['hmean']: {metric['hmean']}")
+        logger.info("metric['hmean']: {}".format(metric['hmean']))
        return metric['hmean']
    params_sensitive = pruner.sensitive(
@@ -123,16 +123,17 @@ def main(config, device, logger, vdl_writer):
    # calculate pruned params's ratio
    params_sensitive = pruner._get_ratios_by_loss(params_sensitive, loss=0.02)
    for key in params_sensitive.keys():
-        logger.info(f"{key}, {params_sensitive[key]}")
+        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  
    plan = pruner.prune_vars(params_sensitive, [0])
-    for param in model.parameters():
-        if ("weights" in param.name and "conv" in param.name) or (
-                "w_0" in param.name and "conv2d" in param.name):
-            logger.info(f"{param.name}: {param.shape}")
    flops = paddle.flops(model, [1, 3, 640, 640])
-    logger.info(f"FLOPs after pruning: {flops}")
+    logger.info("FLOPs after pruning: {}".format(flops))
    # start train

--- a/doc/PaddleOCR_log.png
+++ b/doc/PaddleOCR_log.png
--- a/doc/datasets/ic15_location_download.png
+++ b/doc/datasets/ic15_location_download.png
--- a/doc/datasets/icdar_rec.png
+++ b/doc/datasets/icdar_rec.png
--- a/doc/doc_ch/FAQ.md
+++ b/doc/doc_ch/FAQ.md
--- a/doc/doc_ch/algorithm_overview.md
+++ b/doc/doc_ch/algorithm_overview.md
@@ -44,6 +44,7 @@ PaddleOCR基于动态图开源的文本识别算法列表：
 - [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]  NRTR([paper](https://arxiv.org/abs/1806.00926v2))
 参考[DTRB][3](https://arxiv.org/abs/1904.01906)文字识别训练和评估流程，使用MJSynth和SynthText两个文字识别数据集训练，在IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE数据集上进行评估，算法效果如下：
@@ -58,6 +59,7 @@ PaddleOCR基于动态图开源的文本识别算法列表：
 |RARE|MobileNetV3|82.5%|rec_mv3_tps_bilstm_att |[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_mv3_tps_bilstm_att_v2.0_train.tar)|
 |RARE|Resnet34_vd|83.6%|rec_r34_vd_tps_bilstm_att |[下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_r34_vd_tps_bilstm_att_v2.0_train.tar)|
 |SRN|Resnet50_vd_fpn| 88.52% | rec_r50fpn_vd_none_srn | [下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_r50_vd_srn_train.tar) |
+|NRTR|NRTR_MTB| 84.3% | rec_mtb_nrtr | [下载链接](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_mtb_nrtr_train.tar) |
 PaddleOCR文本识别算法的训练和使用请参考文档教程中[模型训练/评估中的文本识别部分](./recognition.md)。
--- a/doc/doc_ch/config.md
+++ b/doc/doc_ch/config.md
-## 可选参数列表
+# 配置文件内容与生成
+## 1. 可选参数列表
 以下列表可以通过`--help`查看
@@ -8,10 +10,10 @@
 |          -o              |      ALL       |  设置配置文件里的参数内容  |  None  |  使用-o配置相较于-c选择的配置文件具有更高的优先级。例如：`-o Global.use_gpu=false`  |  
-## 配置文件参数介绍
+## 2. 配置文件参数介绍
 以 `rec_chinese_lite_train_v2.0.yml ` 为例
-### Global
+### 2.1 Global
 |         字段             |            用途                |      默认值       |            备注            |
 | :----------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
@@ -52,7 +54,7 @@
 ### Architecture ([ppocr/modeling](../../ppocr/modeling))
-在ppocr中，网络被划分为Transform,Backbone,Neck和Head四个阶段
+在PaddleOCR中，网络被划分为Transform,Backbone,Neck和Head四个阶段
 |         字段             |            用途            |      默认值        |            备注             |
 | :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
@@ -121,3 +123,97 @@
 |      batch_size_per_card        |        训练时单卡batch size         |  256 | \  |
 |      drop_last        |        是否丢弃因数据集样本数不能被 batch_size 整除而产生的最后一个不完整的mini-batch        |  True | \  |
 |      num_workers        |        用于加载数据的子进程个数，若为0即为不开启子进程，在主进程中进行数据加载        |  8 | \  |
+## 3. 多语言配置文件生成
+PaddleOCR目前已支持80种（除中文外）语种识别，`configs/rec/multi_languages` 路径下提供了一个多语言的配置文件模版: [rec_multi_language_lite_train.yml](../../configs/rec/multi_language/rec_multi_language_lite_train.yml)。
+您有两种方式创建所需的配置文件：
+1. 通过脚本自动生成
+[generate_multi_language_configs.py](../../configs/rec/multi_language/generate_multi_language_configs.py) 可以帮助您生成多语言模型的配置文件
+- 以意大利语为例，如果您的数据是按如下格式准备的：
+    ```
+    |-train_data
+        |- it_train.txt # 训练集标签
+        |- it_val.txt # 验证集标签
+        |- data
+            |- word_001.jpg
+            |- word_002.jpg
+            |- word_003.jpg
+            | ...
+    ```
+    可以使用默认参数，生成配置文件：
+    ```bash
+    # 该代码需要在指定目录运行
+    cd PaddleOCR/configs/rec/multi_language/
+    # 通过-l或者--language参数设置需要生成的语种的配置文件，该命令会将默认参数写入配置文件
+    python3 generate_multi_language_configs.py -l it
+    ```
+- 如果您的数据放置在其他位置，或希望使用自己的字典，可以通过指定相关参数来生成配置文件:
+    ```bash
+    # -l或者--language字段是必须的
+    # --train修改训练集，--val修改验证集，--data_dir修改数据集目录，--dict修改字典路径， -o修改对应默认参数
+    cd PaddleOCR/configs/rec/multi_language/
+    python3 generate_multi_language_configs.py -l it \  # 语种
+    --train {path/of/train_label.txt} \ # 训练标签文件的路径
+    --val {path/of/val_label.txt} \     # 验证集标签文件的路径
+    --data_dir {train_data/path} \      # 训练数据的根目录
+    --dict {path/of/dict} \             # 字典文件路径
+    -o Global.use_gpu=False             # 是否使用gpu
+    ...
+    ```
+意大利文由拉丁字母组成，因此执行完命令后会得到名为 rec_latin_lite_train.yml 的配置文件。
+2. 手动修改配置文件
+   您也可以手动修改模版中的以下几个字段得到配置文件:
+   ```
+    Global:
+      use_gpu: True
+      epoch_num: 500
+      ...
+      character_type: it  # 需要识别的语种
+      character_dict_path:  {path/of/dict} # 字典文件所在路径
+   Train:
+      dataset:
+        name: SimpleDataSet
+        data_dir: train_data/ # 数据存放根目录
+        label_file_list: ["./train_data/train_list.txt"] # 训练集label路径
+      ...
+   Eval:
+      dataset:
+        name: SimpleDataSet
+        data_dir: train_data/ # 数据存放根目录
+        label_file_list: ["./train_data/val_list.txt"] # 验证集label路径
+      ...
+   ```
+目前PaddleOCR支持的多语言算法有：
+| 配置文件 |  算法名称 |   backbone |   trans   |   seq      |     pred     |  language | character_type |
+| :--------: |  :-------:   | :-------:  |   :-------:   |   :-----:   |  :-----:   | :-----:  | :-----:  |
+| rec_chinese_cht_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 中文繁体  | chinese_cht|
+| rec_en_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 英语（区分大小写）   | EN |
+| rec_french_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 法语 |  french |
+| rec_ger_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 德语   | german |
+| rec_japan_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 日语  | japan |
+| rec_korean_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 韩语  | korean |
+| rec_latin_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 拉丁字母  | latin |
+| rec_arabic_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 阿拉伯字母 |  ar |
+| rec_cyrillic_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 斯拉夫字母  | cyrillic |
+| rec_devanagari_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 梵文字母  | devanagari |
+更多支持语种请参考: [多语言模型](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.1/doc/doc_ch/multi_languages.md#%E8%AF%AD%E7%A7%8D%E7%BC%A9%E5%86%99)
--- a/doc/doc_ch/detection.md
+++ b/doc/doc_ch/detection.md
-# 文字检测
-本节以icdar2015数据集为例，介绍PaddleOCR中检测模型的训练、评估与测试。
+# 目录
+- [1. 文字检测](#1-----)
+  * [1.1 数据准备](#11-----)
+  * [1.2 下载预训练模型](#12--------)
+  * [1.3 启动训练](#13-----)
+  * [1.4 断点训练](#14-----)
+  * [1.5 更换Backbone 训练](#15---backbone---)
+  * [1.6 指标评估](#16-----)
+  * [1.7 测试检测效果](#17-------)
+  * [1.8 转inference模型测试](#18--inference----)
+- [2. FAQ](#2-faq)
-## 数据准备
+<a name="1-----"></a>
+# 1. 文字检测
+本节以icdar2015数据集为例，介绍PaddleOCR中检测模型训练、评估、测试的使用方式。
+<a name="11-----"></a>
+## 1.1 数据准备
+icdar2015 TextLocalization数据集是文本检测的数据集，包含1000张训练图像和500张测试图像。
 icdar2015数据集可以从[官网](https://rrc.cvc.uab.es/?ch=4&com=downloads)下载到，首次下载需注册。
+注册完成登陆后，下载下图中红色框标出的部分，其中， `Training Set Images`下载的内容保存为`icdar_c4_train_imgs`文件夹下，`Test Set Images` 下载的内容保存为`ch4_test_images`文件夹下
+<p align="center">
+ <img src="../datasets/ic15_location_download.png" align="middle" width = "700"/>
+<p align="center">
-将下载到的数据集解压到工作目录下，假设解压在 PaddleOCR/train_data/ 下。另外，PaddleOCR将零散的标注文件整理成单独的标注文件
+将下载到的数据集解压到工作目录下，假设解压在 PaddleOCR/train_data/下。另外，PaddleOCR将零散的标注文件整理成单独的标注文件
 ，您可以通过wget的方式进行下载。
 ```shell
 # 在PaddleOCR路径下
@@ -23,7 +46,7 @@ python gen_label.py --mode="det" --root_path="/path/to/icdar_c4_train_imgs/"  \
                    --output_label="/path/to/train_icdar2015_label.txt"
 ```
-解压数据集和下载标注文件后，PaddleOCR/train_data/ 有两个文件夹和两个文件，分别是：
+解压数据集和下载标注文件后，PaddleOCR/train_data/ 有两个文件夹和两个文件，按照如下方式组织icdar2015数据集：
 ```
 /PaddleOCR/train_data/icdar2015/text_localization/
  └─ icdar_c4_train_imgs/         icdar数据集的训练数据
@@ -42,11 +65,13 @@ json.dumps编码前的图像标注信息是包含多个字典的list，字典中
 如果您想在其他数据集上训练，可以按照上述形式构建标注文件。
-## 快速启动训练
+<a name="12--------"></a>
+## 1.2 下载预训练模型
 首先下载模型backbone的pretrain model，PaddleOCR的检测模型目前支持两种backbone，分别是MobileNetV3、ResNet_vd系列，
-您可以根据需求使用[PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/develop/ppcls/modeling/architectures)中的模型更换backbone，
+您可以根据需求使用[PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/release/2.0/ppcls/modeling/architectures)中的模型更换backbone，
-对应的backbone预训练模型可以从[PaddleClas repo 主页中找到下载链接](https://github.com/PaddlePaddle/PaddleClas#mobile-series)。
+对应的backbone预训练模型可以从[PaddleClas repo 主页中找到下载链接](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)。
 ```shell
 cd PaddleOCR/
 # 根据backbone的不同选择下载对应的预训练模型
@@ -56,23 +81,23 @@ wget -P ./pretrain_models/ https://paddle-imagenet-models-name.bj.bcebos.com/dyg
 wget -P ./pretrain_models/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet18_vd_pretrained.pdparams
 # 或，下载ResNet50_vd的预训练模型
 wget -P ./pretrain_models/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/ResNet50_vd_ssld_pretrained.pdparams
 ```
-#### 启动训练
+<a name="13-----"></a>
+## 1.3 启动训练
 *如果您安装的是cpu版本，请将配置文件中的 `use_gpu` 字段修改为false*
 ```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.pretrain_weights=./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.pretrain_weights=./pretrain_models/MobileNetV3_large_x0_5_pretrained
 ```
 上述指令中，通过-c 选择训练使用configs/det/det_db_mv3.yml配置文件。
 有关配置文件的详细解释，请参考[链接](./config.md)。
@@ -81,46 +106,122 @@ python3 -m paddle.distributed.launch --gpus '0,1,2,3' tools/train.py -c configs/
 python3 tools/train.py -c configs/det/det_mv3_db.yml -o Optimizer.base_lr=0.0001
 ```
-#### 断点训练
+<a name="14-----"></a>
+## 1.4 断点训练
 如果训练程序中断，如果希望加载训练中断的模型从而恢复训练，可以通过指定Global.checkpoints指定要加载的模型路径：
 ```shell
 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`指定的模型。
+<a name="15---backbone---"></a>
+## 1.5 更换Backbone 训练
+PaddleOCR将网络划分为四部分，分别在[ppocr/modeling](../../ppocr/modeling)下。 进入网络的数据将按照顺序(transforms->backbones->
+necks->heads)依次通过这四个部分。
+```bash
+├── architectures # 网络的组网代码
+├── transforms    # 网络的图像变换模块
+├── backbones     # 网络的特征提取模块
+├── necks         # 网络的特征增强模块
+└── heads         # 网络的输出模块
 ```
+如果要更换的Backbone 在PaddleOCR中有对应实现，直接修改配置yml文件中`Backbone`部分的参数即可。
-**注意**：`Global.checkpoints`的优先级高于`Global.pretrain_weights`的优先级，即同时指定两个参数时，优先加载`Global.checkpoints`指定的模型，如果`Global.checkpoints`指定的模型路径有误，会加载`Global.pretrain_weights`指定的模型。
+如果要使用新的Backbone，更换backbones的例子如下:
+1. 在 [ppocr/modeling/backbones](../../ppocr/modeling/backbones) 文件夹下新建文件，如my_backbone.py。
+2. 在 my_backbone.py 文件内添加相关代码，示例代码如下:
+```python
+import paddle
+import paddle.nn as nn
+import paddle.nn.functional as F
+class MyBackbone(nn.Layer):
+    def __init__(self, *args, **kwargs):
+        super(MyBackbone, self).__init__()
+        # your init code
+        self.conv = nn.xxxx
+    def forward(self, inputs):
+        # your network forward
+        y = self.conv(inputs)
+        return y
+```
+3. 在 [ppocr/modeling/backbones/\__init\__.py](../../ppocr/modeling/backbones/__init__.py)文件内导入添加的`MyBackbone`模块，然后修改配置文件中Backbone进行配置即可使用，格式如下:
-## 指标评估
+```yaml
+Backbone:
+name: MyBackbone
+args1: args1
+```
-PaddleOCR计算三个OCR检测相关的指标，分别是：Precision、Recall、Hmean。
+**注意**：如果要更换网络的其他模块，可以参考[文档](./add_new_algorithm.md)。
-运行如下代码，根据配置文件`det_db_mv3.yml`中`save_res_path`指定的测试集检测结果文件，计算评估指标。
+<a name="16-----"></a>
+## 1.6 指标评估
+PaddleOCR计算三个OCR检测相关的指标，分别是：Precision、Recall、Hmean（F-Score）。
-评估时设置后处理参数`box_thresh=0.5`，`unclip_ratio=1.5`，使用不同数据集、不同模型训练，可调整这两个参数进行优化
 训练中模型参数默认保存在`Global.save_model_dir`目录下。在评估指标时，需要设置`Global.checkpoints`指向保存的参数文件。
 ```shell
-python3 tools/eval.py -c configs/det/det_mv3_db.yml  -o Global.checkpoints="{path/to/weights}/best_accuracy" PostProcess.box_thresh=0.5 PostProcess.unclip_ratio=1.5
+python3 tools/eval.py -c configs/det/det_mv3_db.yml  -o Global.checkpoints="{path/to/weights}/best_accuracy"
 ```
 * 注：`box_thresh`、`unclip_ratio`是DB后处理所需要的参数，在评估EAST模型时不需要设置
-## 测试检测效果
+<a name="17-------"></a>
+## 1.7 测试检测效果
 测试单张图像的检测效果
 ```shell
 python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/img_10.jpg" Global.pretrained_model="./output/det_db/best_accuracy"
 ```
-测试DB模型时，调整后处理阈值，
+测试DB模型时，调整后处理阈值
 ```shell
-python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/img_10.jpg" Global.pretrained_model="./output/det_db/best_accuracy"  PostProcess.box_thresh=0.6 PostProcess.unclip_ratio=1.5
+python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/img_10.jpg" Global.pretrained_model="./output/det_db/best_accuracy"  PostProcess.box_thresh=0.6 PostProcess.unclip_ratio=2.0
 ```
 测试文件夹下所有图像的检测效果
 ```shell
 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"
 ```
+<a name="18--inference----"></a>
+## 1.8 转inference模型测试
+inference 模型（`paddle.jit.save`保存的模型）
+一般是模型训练，把模型结构和模型参数保存在文件中的固化模型，多用于预测部署场景。
+训练过程中保存的模型是checkpoints模型，保存的只有模型的参数，多用于恢复训练等。
+与checkpoints模型相比，inference 模型会额外保存模型的结构信息，在预测部署、加速推理上性能优越，灵活方便，适合于实际系统集成。
+检测模型转inference 模型方式：
+```shell
+# 加载配置文件`det_mv3_db.yml`，从`output/det_db`目录下加载`best_accuracy`模型，inference模型保存在`./output/det_db_inference`目录下
+python3 tools/export_model.py -c configs/det/det_mv3_db.yml -o Global.pretrained_model="./output/det_db/best_accuracy" Global.save_inference_dir="./output/det_db_inference/"
+```
+DB检测模型inference 模型预测：
+```shell
+python3 tools/infer/predict_det.py --det_algorithm="DB" --det_model_dir="./output/det_db_inference/" --image_dir="./doc/imgs/" --use_gpu=True
+```
+如果是其他检测，比如EAST模型，det_algorithm参数需要修改为EAST，默认为DB算法：
+```shell
+python3 tools/infer/predict_det.py --det_algorithm="EAST" --det_model_dir="./output/det_db_inference/" --image_dir="./doc/imgs/" --use_gpu=True
+```
+<a name="2"></a>
+# 2. FAQ
+Q1: 训练模型转inference 模型之后预测效果不一致？
+**A**：此类问题出现较多，问题多是trained model预测时候的预处理、后处理参数和inference model预测的时候的预处理、后处理参数不一致导致的。以det_mv3_db.yml配置文件训练的模型为例，训练模型、inference模型预测结果不一致问题解决方式如下：
+- 检查[trained model预处理](https://github.com/PaddlePaddle/PaddleOCR/blob/c1ed243fb68d5d466258243092e56cbae32e2c14/configs/det/det_mv3_db.yml#L116)，和[inference model的预测预处理](https://github.com/PaddlePaddle/PaddleOCR/blob/c1ed243fb68d5d466258243092e56cbae32e2c14/tools/infer/predict_det.py#L42)函数是否一致。算法在评估的时候，输入图像大小会影响精度，为了和论文保持一致，训练icdar15配置文件中将图像resize到[736, 1280]，但是在inference model预测的时候只有一套默认参数，会考虑到预测速度问题，默认限制图像最长边为960做resize的。训练模型预处理和inference模型的预处理函数位于[ppocr/data/imaug/operators.py](https://github.com/PaddlePaddle/PaddleOCR/blob/c1ed243fb68d5d466258243092e56cbae32e2c14/ppocr/data/imaug/operators.py#L147)
+- 检查[trained model后处理](https://github.com/PaddlePaddle/PaddleOCR/blob/c1ed243fb68d5d466258243092e56cbae32e2c14/configs/det/det_mv3_db.yml#L51)，和[inference 后处理参数](https://github.com/PaddlePaddle/PaddleOCR/blob/c1ed243fb68d5d466258243092e56cbae32e2c14/tools/infer/utility.py#L50)是否一致。
--- a/doc/doc_ch/environment.md
+++ b/doc/doc_ch/environment.md
+# 运行环境准备
+Windows和Mac用户推荐使用Anaconda搭建Python环境，Linux用户建议使用docker搭建PyThon环境。
+如果对于Python环境熟悉的用户可以直接跳到第2步安装PaddlePaddle。
+* [1. Python环境搭建](#1)
+  + [1.1 Windows](#1.1)
+  + [1.2 Mac](#1.2)
+  + [1.3 Linux](#1.3)
+* [2. 安装PaddlePaddle](#2)
+<a name="1"></a>
+## 1. Python环境搭建
+<a name="1.1"></a>
+### 1.1 Windows
+#### 1.1.1 安装Anaconda
+- 说明：使用paddlepaddle需要先安装python环境，这里我们选择python集成环境Anaconda工具包
+  - Anaconda是1个常用的python包管理程序
+  - 安装完Anaconda后，可以安装python环境，以及numpy等所需的工具包环境。
+- Anaconda下载：
+  - 地址：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/?C=M&O=D
+  - 大部分win10电脑均为64位操作系统，选择x86_64版本；若电脑为32位操作系统，则选择x86.exe
+    <img src="../install/windows/Anaconda_download.png" alt="anaconda download" width="800" align="center"/>
+  - 下载完成后，双击安装程序进入图形界面
+  - 默认安装位置为C盘，建议将安装位置更改到D盘：
+    <img src="../install/windows/anaconda_install_folder.png" alt="install config" width="500" align="center"/>
+  - 勾选conda加入环境变量，忽略警告：
+    <img src="../install/windows/anaconda_install_env.png" alt="add conda to path" width="500" align="center"/>
+#### 1.1.2 打开终端并创建conda环境
+- 打开Anaconda Prompt终端：左下角Windows Start Menu -> Anaconda3 -> Anaconda Prompt启动控制台
+  <img src="../install/windows/anaconda_prompt.png" alt="anaconda download" width="300" align="center"/>
+- 创建新的conda环境
+  ```shell
+  # 在命令行输入以下命令，创建名为paddle_env的环境
+  # 此处为加速下载，使用清华源
+  conda create --name paddle_env python=3.8 --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/  # 这是一行命令
+  ```
+  该命令会创建1个名为paddle_env、python版本为3.8的可执行环境，根据网络状态，需要花费一段时间
+  之后命令行中会输出提示信息，输入y并回车继续安装
+  <img src="../install/windows/conda_new_env.png" alt="conda create" width="700" align="center"/>
+- 激活刚创建的conda环境，在命令行中输入以下命令：
+  ```shell
+  # 激活paddle_env环境
+  conda activate paddle_env
+  # 查看当前python的位置
+  where python
+  ```
+    <img src="../install/windows/conda_list_env.png" alt="create environment" width="600" align="center"/>
+以上anaconda环境和python环境安装完毕
+<a name="1.2"></a>
+### 1.2 Mac
+#### 1.2.1 安装Anaconda
+- 说明：使用paddlepaddle需要先安装python环境，这里我们选择python集成环境Anaconda工具包
+  - Anaconda是1个常用的python包管理程序
+  - 安装完Anaconda后，可以安装python环境，以及numpy等所需的工具包环境
+- Anaconda下载：
+  - 地址：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/?C=M&O=D
+  <img src="../install/mac/anaconda_start.png" alt="anaconda download" width="800" align="center"/>
+  - 选择最下方的`Anaconda3-2021.05-MacOSX-x86_64.pkg`下载
+- 下载完成后，双击.pkg文件进入图形界面
+  - 按默认设置即可，安装需要花费一段时间
+- 建议安装vscode或pycharm等代码编辑器
+#### 1.2.2 打开终端并创建conda环境
+- 打开终端
+  - 同时按下command键和空格键，在聚焦搜索中输入"终端"，双击进入终端
+- **将conda加入环境变量**
+  - 加入环境变量是为了让系统能识别conda命令
+  - 输入以下命令，在终端中打开`~/.bash_profile`：
+     ```shell
+     vim ~/.bash_profile
+     ```
+  - 在`~/.bash_profile`中将conda添加为环境变量：
+     ```shell
+     # 先按i进入编辑模式
+     # 在第一行输入：
+     export PATH="~/opt/anaconda3/bin:$PATH"
+     # 若安装时自定义了安装位置，则将~/opt/anaconda3/bin改为自定义的安装目录下的bin文件夹
+     ```
+    ```shell
+    # 修改后的~/.bash_profile文件应如下（其中xxx为用户名）：
+    export PATH="~/opt/anaconda3/bin:$PATH"
+    # >>> conda initialize >>>
+    # !! Contents within this block are managed by 'conda init' !!
+    __conda_setup="$('/Users/xxx/opt/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+    if [ $? -eq 0 ]; then
+    		eval "$__conda_setup"
+    else
+    		if [ -f "/Users/xxx/opt/anaconda3/etc/profile.d/conda.sh" ]; then
+    				. "/Users/xxx/opt/anaconda3/etc/profile.d/conda.sh"
+    		else
+    				export PATH="/Users/xxx/opt/anaconda3/bin:$PATH"
+    		fi
+    fi
+    unset __conda_setup
+    # <<< conda initialize <<<
+    ```
+    - 修改完成后，先按`esc`键退出编辑模式，再输入`:wq!`并回车，以保存退出
+  - 验证是否能识别conda命令：
+    - 在终端中输入`source ~/.bash_profile`以更新环境变量
+    - 再在终端输入`conda info --envs`，若能显示当前有base环境，则conda已加入环境变量
+- 创建新的conda环境
+  ```shell
+  # 在命令行输入以下命令，创建名为paddle_env的环境
+  # 此处为加速下载，使用清华源
+  conda create --name paddle_env python=3.8 --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+  ```
+  - 该命令会创建1个名为paddle_env、python版本为3.8的可执行环境，根据网络状态，需要花费一段时间
+  - 之后命令行中会输出提示信息，输入y并回车继续安装
+    - <img src="../install/mac/conda_create.png" alt="conda_create" width="600" align="center"/>
+- 激活刚创建的conda环境，在命令行中输入以下命令：
+  ```shell
+  # 激活paddle_env环境
+  conda activate paddle_env
+  # 查看当前python的位置
+  where python
+  ```
+  <img src="../install/mac/conda_activate.png" alt="conda_actviate" width="600" align="center"/>
+以上anaconda环境和python环境安装完毕
+<a name="1.3"></a>
+### 1.3 Linux
+Linux用户可选择Anaconda或Docker两种方式运行。如果你熟悉Docker且需要训练PaddleOCR模型，推荐使用Docker环境，PaddleOCR的开发流程均在Docker环境下运行。如果你不熟悉Docker，也可以使用Anaconda来运行项目。
+#### 1.3.1 Anaconda环境配置
+- 说明：使用paddlepaddle需要先安装python环境，这里我们选择python集成环境Anaconda工具包
+  - Anaconda是1个常用的python包管理程序
+  - 安装完Anaconda后，可以安装python环境，以及numpy等所需的工具包环境
+- **下载Anaconda**：
+  - 下载地址：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/?C=M&O=D
+    <img src="../install/linux/anaconda_download.png" akt="anaconda download" width="800" align="center"/>
+    - 选择适合您操作系统的版本
+    - 可在终端输入`uname -m`查询系统所用的指令集
+- 下载法1：本地下载，再将安装包传到linux服务器上
+- 下载法2：直接使用linux命令行下载
+  ```shell
+    # 首先安装wget
+  sudo apt-get install wget  # Ubuntu
+    sudo yum install wget  # CentOS
+  ```
+  ```shell
+    # 然后使用wget从清华源上下载
+  # 如要下载Anaconda3-2021.05-Linux-x86_64.sh，则下载命令如下：
+    wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2021.05-Linux-x86_64.sh
+  # 若您要下载其他版本，需要将最后1个/后的文件名改成您希望下载的版本
+    ```
+- 安装Anaconda：
+  - 在命令行输入`sh Anaconda3-2021.05-Linux-x86_64.sh`
+    - 若您下载的是其它版本，则将该命令的文件名替换为您下载的文件名
+  - 按照安装提示安装即可
+    - 查看许可时可输入q来退出
+- **将conda加入环境变量**
+  - 加入环境变量是为了让系统能识别conda命令，若您在安装时已将conda加入环境变量path，则可跳过本步
+  - 在终端中打开`~/.bashrc`：
+    ```shell
+    # 在终端中输入以下命令：
+    vim ~/.bashrc
+    ```
+  - 在`~/.bashrc`中将conda添加为环境变量：
+    ```shell
+    # 先按i进入编辑模式
+    # 在第一行输入：
+    export PATH="~/anaconda3/bin:$PATH"
+    # 若安装时自定义了安装位置，则将~/anaconda3/bin改为自定义的安装目录下的bin文件夹
+    ```
+     ```shell
+      # 修改后的~/.bash_profile文件应如下（其中xxx为用户名）：
+      export PATH="~/opt/anaconda3/bin:$PATH"
+      # >>> conda initialize >>>
+      # !! Contents within this block are managed by 'conda init' !!
+      __conda_setup="$('/Users/xxx/opt/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+      if [ $? -eq 0 ]; then
+          eval "$__conda_setup"
+      else
+          if [ -f "/Users/xxx/opt/anaconda3/etc/profile.d/conda.sh" ]; then
+              . "/Users/xxx/opt/anaconda3/etc/profile.d/conda.sh"
+          else
+              export PATH="/Users/xxx/opt/anaconda3/bin:$PATH"
+          fi
+      fi
+      unset __conda_setup
+      # <<< conda initialize <<<
+     ```
+    - 修改完成后，先按`esc`键退出编辑模式，再输入`:wq!`并回车，以保存退出
+  - 验证是否能识别conda命令：
+    - 在终端中输入`source ~/.bash_profile`以更新环境变量
+    - 再在终端输入`conda info --envs`，若能显示当前有base环境，则conda已加入环境变量
+- 创建新的conda环境
+   ```shell
+   # 在命令行输入以下命令，创建名为paddle_env的环境
+   # 此处为加速下载，使用清华源
+   conda create --name paddle_env python=3.8 --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+   ```
+  - 该命令会创建1个名为paddle_env、python版本为3.8的可执行环境，根据网络状态，需要花费一段时间
+  - 之后命令行中会输出提示信息，输入y并回车继续安装
+    <img src="../install/linux/conda_create.png" alt="conda_create" width="500" align="center"/>
+- 激活刚创建的conda环境，在命令行中输入以下命令：
+  ```shell
+  # 激活paddle_env环境
+  conda activate paddle_env
+  ```
+以上anaconda环境和python环境安装完毕
+#### 1.3.2 Docker环境配置
+**注意：第一次使用这个镜像，会自动下载该镜像，请耐心等待。您也可以访问[DockerHub](https://hub.docker.com/r/paddlepaddle/paddle/tags/)获取与您机器适配的镜像。**
+```bash
+# 切换到工作目录下
+cd /home/Projects
+# 首次运行需创建一个docker容器，再次运行时不需要运行当前命令
+# 创建一个名字为ppocr的docker容器，并将当前目录映射到容器的/paddle目录下
+如果您希望在CPU环境下使用docker，使用docker而不是nvidia-docker创建docker
+sudo docker run --name ppocr -v $PWD:/paddle --network=host -it paddlepaddle/paddle:latest-dev-cuda10.1-cudnn7-gcc82 /bin/bash
+如果使用CUDA10，请运行以下命令创建容器，设置docker容器共享内存shm-size为64G，建议设置32G以上
+sudo nvidia-docker run --name ppocr -v $PWD:/paddle --shm-size=64G --network=host -it paddlepaddle/paddle:latest-dev-cuda10.1-cudnn7-gcc82 /bin/bash
+# ctrl+P+Q可退出docker 容器，重新进入docker 容器使用如下命令
+sudo docker container exec -it ppocr /bin/bash
+```
+<a name="2"></a>
+## 2. 安装PaddlePaddle
+- 如果您的机器安装的是CUDA9或CUDA10，请运行以下命令安装
+```bash
+python3 -m pip install paddlepaddle-gpu -i https://mirror.baidu.com/pypi/simple
+```
+- 如果您的机器是CPU，请运行以下命令安装
+```bash
+python3 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
+```
+更多的版本需求，请参照[飞桨官网安装文档](https://www.paddlepaddle.org.cn/install/quick)中的说明进行操作。
--- a/doc/doc_ch/inference_ppocr.md
+++ b/doc/doc_ch/inference_ppocr.md
+# PP-OCR模型库快速推理
+本文介绍针对PP-OCR模型库的Python推理引擎使用方法，内容依次为文本检测、文本识别、方向分类器以及三者串联在CPU、GPU上的预测方法。
+- [1. 文本检测模型推理](#文本检测模型推理)
+- [2. 文本识别模型推理](#文本识别模型推理)
+  - [2.1 超轻量中文识别模型推理](#超轻量中文识别模型推理)
+  - [2.2 多语言模型的推理](#多语言模型的推理)
+- [3. 方向分类模型推理](#方向分类模型推理)
+- [4. 文本检测、方向分类和文字识别串联推理](#文本检测、方向分类和文字识别串联推理)
+<a name="文本检测模型推理"></a>
+## 1. 文本检测模型推理
+文本检测模型推理，默认使用DB模型的配置参数。超轻量中文检测模型推理，可以执行如下命令：
+```
+# 下载超轻量中文检测模型：
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tartar xf ch_ppocr_mobile_v2.0_det_infer.tarpython3 tools/infer/predict_det.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./ch_ppocr_mobile_v2.0_det_infer/"
+```
+可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下：
+![](/Users/zhulingfeng01/OCR/PaddleOCR/doc/imgs_results/det_res_00018069.jpg)
+通过参数`limit_type`和`det_limit_side_len`来对图片的尺寸进行限制，
+`limit_type`可选参数为[`max`, `min`]，
+`det_limit_size_len` 为正整数，一般设置为32 的倍数，比如960。
+参数默认设置为`limit_type='max', det_limit_side_len=960`。表示网络输入图像的最长边不能超过960，
+如果超过这个值，会对图像做等宽比的resize操作，确保最长边为`det_limit_side_len`。
+设置为`limit_type='min', det_limit_side_len=960` 则表示限制图像的最短边为960。
+如果输入图片的分辨率比较大，而且想使用更大的分辨率预测，可以设置det_limit_side_len 为想要的值，比如1216：
+```
+python3 tools/infer/predict_det.py --image_dir="./doc/imgs/1.jpg" --det_model_dir="./inference/det_db/" --det_limit_type=max --det_limit_side_len=1216
+```
+如果想使用CPU进行预测，执行命令如下
+```
+python3 tools/infer/predict_det.py --image_dir="./doc/imgs/1.jpg" --det_model_dir="./inference/det_db/"  --use_gpu=False
+```
+<a name="文本识别模型推理"></a>
+## 2. 文本识别模型推理
+<a name="超轻量中文识别模型推理"></a>
+### 2.1 超轻量中文识别模型推理
+超轻量中文识别模型推理，可以执行如下命令：
+```
+# 下载超轻量中文识别模型：
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar
+tar xf ch_ppocr_mobile_v2.0_rec_infer.tar
+python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words/ch/word_4.jpg" --rec_model_dir="ch_ppocr_mobile_v2.0_rec_infer"
+```
+![](/Users/zhulingfeng01/OCR/PaddleOCR/doc/imgs_words/ch/word_4.jpg)
+执行命令后，上面图像的预测结果（识别的文本和得分）会打印到屏幕上，示例如下：
+```bash
+Predicts of ./doc/imgs_words/ch/word_4.jpg:('实力活力', 0.98458153)
+```
+<a name="多语言模型的推理"></a>
+### 2.2 多语言模型的推理
+如果您需要预测的是其他语言模型，在使用inference模型预测时，需要通过`--rec_char_dict_path`指定使用的字典路径, 同时为了得到正确的可视化结果，
+需要通过 `--vis_font_path` 指定可视化的字体路径，`doc/fonts/` 路径下有默认提供的小语种字体，例如韩文识别：
+```
+python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words/korean/1.jpg" --rec_model_dir="./your inference model" --rec_char_type="korean" --rec_char_dict_path="ppocr/utils/dict/korean_dict.txt" --vis_font_path="doc/fonts/korean.ttf"
+```
+![](/Users/zhulingfeng01/OCR/PaddleOCR/doc/imgs_words/korean/1.jpg)
+执行命令后，上图的预测结果为：
+``` text
+Predicts of ./doc/imgs_words/korean/1.jpg:('바탕으로', 0.9948904)
+```
+<a name="方向分类模型推理"></a>
+## 3. 方向分类模型推理
+方向分类模型推理，可以执行如下命令：
+```
+# 下载超轻量中文方向分类器模型：
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar
+tar xf ch_ppocr_mobile_v2.0_cls_infer.tar
+python3 tools/infer/predict_cls.py --image_dir="./doc/imgs_words/ch/word_4.jpg" --cls_model_dir="ch_ppocr_mobile_v2.0_cls_infer"
+```
+![](/Users/zhulingfeng01/OCR/PaddleOCR/doc/imgs_words/ch/word_1.jpg)
+执行命令后，上面图像的预测结果（分类的方向和得分）会打印到屏幕上，示例如下：
+```
+Predicts of ./doc/imgs_words/ch/word_4.jpg:['0', 0.9999982]
+```
+<a name="文本检测、方向分类和文字识别串联推理"></a>
+## 4. 文本检测、方向分类和文字识别串联推理
+以超轻量中文OCR模型推理为例，在执行预测时，需要通过参数`image_dir`指定单张图像或者图像集合的路径、参数`det_model_dir`,`cls_model_dir`和`rec_model_dir`分别指定检测，方向分类和识别的inference模型路径。参数`use_angle_cls`用于控制是否启用方向分类模型。`use_mp`表示是否使用多进程。`total_process_num`表示在使用多进程时的进程数。可视化识别结果默认保存到 ./inference_results 文件夹里面。
+```shell
+# 使用方向分类器
+python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./inference/det_db/" --cls_model_dir="./inference/cls/" --rec_model_dir="./inference/rec_crnn/" --use_angle_cls=true
+# 不使用方向分类器
+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
+# 使用多进程
+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
+```
+执行命令后，识别结果图像如下：
+![](/Users/zhulingfeng01/OCR/PaddleOCR/doc/imgs_results/system_res_00018069.jpg)
--- a/doc/doc_ch/knowledge_distillation.md
+++ b/doc/doc_ch/knowledge_distillation.md
@@ -39,7 +39,7 @@ PaddleOCR中集成了知识蒸馏的算法，具体地，有以下几个主要
 ### 2.1 识别配置文件解析
-配置文件在[rec_chinese_lite_train_distillation_v2.1.yml](../../configs/rec/ch_ppocr_v2.1/rec_chinese_lite_train_distillation_v2.1.yml)。
+配置文件在[ch_PP-OCRv2_rec.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml)。
 #### 2.1.1 模型结构

--- a/doc/doc_ch/models_and_config.md
+++ b/doc/doc_ch/models_and_config.md
+# PP-OCR模型与配置文件
+PP-OCR模型与配置文件一章主要补充一些OCR模型的基本概念、配置文件的内容与作用以便对模型后续的参数调整和训练中拥有更好的体验。
+本章包含三个部分，首先在[PP-OCR模型下载](./models_list.md)中解释PP-OCR模型的类型概念，并提供所有模型的下载链接。然后在[配置文件内容与生成](./config.md)中详细说明调整PP-OCR模型所需的参数。最后的[模型库快速使用](./inference_ppocr.md)是对第一节PP-OCR模型库使用方法的介绍，可以通过Python推理引擎快速利用丰富的模型库模型获得测试结果。
+------
+下面我们首先了解一些OCR相关的基本概念：
+- [1. OCR 简要介绍](#1-ocr-----)
+  * [1.1 OCR 检测模型基本概念](#11-ocr---------)
+  * [1.2 OCR 识别模型基本概念](#12-ocr---------)
+  * [1.3 PP-OCR模型](#13-pp-ocr--)
+<a name="1-ocr-----"></a>
+## 1. OCR 简要介绍
+本节简要介绍OCR检测模型、识别模型的基本概念，并介绍PaddleOCR的PP-OCR模型。
+OCR（Optical Character Recognition，光学字符识别）目前是文字识别的统称，已不限于文档或书本文字识别，更包括识别自然场景下的文字，又可以称为STR（Scene Text Recognition）。
+OCR文字识别一般包括两个部分，文本检测和文本识别；文本检测首先利用检测算法检测到图像中的文本行；然后检测到的文本行用识别算法去识别到具体文字。
+<a name="11-ocr---------"></a>
+### 1.1 OCR 检测模型基本概念
+文本检测就是要定位图像中的文字区域，然后通常以边界框的形式将单词或文本行标记出来。传统的文字检测算法多是通过手工提取特征的方式，特点是速度快，简单场景效果好，但是面对自然场景，效果会大打折扣。当前多是采用深度学习方法来做。
+基于深度学习的文本检测算法可以大致分为以下几类：
+1. 基于目标检测的方法；一般是预测得到文本框后，通过NMS筛选得到最终文本框，多是四点文本框，对弯曲文本场景效果不理想。典型算法为EAST、Text Box等方法。
+2. 基于分割的方法；将文本行当成分割目标，然后通过分割结果构建外接文本框，可以处理弯曲文本，对于文本交叉场景问题效果不理想。典型算法为DB、PSENet等方法。
+3. 混合目标检测和分割的方法；
+<a name="12-ocr---------"></a>
+### 1.2 OCR 识别模型基本概念
+OCR识别算法的输入数据一般是文本行，背景信息不多，文字占据主要部分，识别算法目前可以分为两类算法：
+1. 基于CTC的方法；即识别算法的文字预测模块是基于CTC的，常用的算法组合为CNN+RNN+CTC。目前也有一些算法尝试在网络中加入transformer模块等等。
+2. 基于Attention的方法；即识别算法的文字预测模块是基于Attention的，常用算法组合是CNN+RNN+Attention。
+<a name="13-pp-ocr--"></a>
+### 1.3 PP-OCR模型
+PaddleOCR 中集成了很多OCR算法，文本检测算法有DB、EAST、SAST等等，文本识别算法有CRNN、RARE、StarNet、Rosetta、SRN等算法。
+其中PaddleOCR针对中英文自然场景通用OCR，推出了PP-OCR系列模型，PP-OCR模型由DB+CRNN算法组成，利用海量中文数据训练加上模型调优方法，在中文场景上具备较高的文本检测识别能力。并且PaddleOCR推出了高精度超轻量PP-OCRv2模型，检测模型仅3M，识别模型仅8.5M，利用[PaddleSlim](https://github.com/PaddlePaddle/PaddleSlim)的模型量化方法，可以在保持精度不降低的情况下，将检测模型压缩到0.8M，识别压缩到3M，更加适用于移动端部署场景。
--- a/doc/doc_ch/models_list.md
+++ b/doc/doc_ch/models_list.md
-## OCR模型列表（V2.0，2021年1月20日更新）
+## OCR模型列表（V2.1，2021年9月6日更新）
 > **说明**
-> 1. 2.0版模型和[1.1版模型](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_ch/models_list.md) 的主要区别在于动态图训练vs.静态图训练，模型性能上无明显差距。
+> 1. 2.1版模型相比2.0版模型，2.1的模型在模型精度上做了提升
-> 2. 本文档提供的是PPOCR自研模型列表，更多基于公开数据集的算法介绍与预训练模型可以参考：[算法概览文档](./algorithm_overview.md)。
+> 2. 2.0版模型和[1.1版模型](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_ch/models_list.md) 的主要区别在于动态图训练vs.静态图训练，模型性能上无明显差距。
+> 3. 本文档提供的是PPOCR自研模型列表，更多基于公开数据集的算法介绍与预训练模型可以参考：[算法概览文档](./algorithm_overview.md)。
 - [一、文本检测模型](#文本检测模型)
@@ -32,6 +33,8 @@ PaddleOCR提供的可下载模型包括`推理模型`、`训练模型`、`预训
 |模型名称|模型简介|配置文件|推理模型大小|下载地址|
 | --- | --- | --- | --- | --- |
+|ch_PP-OCRv2_det_slim|slim量化+蒸馏版超轻量模型，支持中英文、多语种文本检测|[ch_PP-OCRv2_det_cml.yml](../../configs/det/ch_PP-OCRv2/ch_PP-OCR_det_cml.yml)| 3M |[推理模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_slim_quant_infer.tar)|
+|ch_PP-OCRv2_det|原始超轻量模型，支持中英文、多语种文本检测|[ch_PP-OCRv2_det_cml.yml](../../configs/det/ch_PP-OCRv2/ch_PP-OCR_det_cml.yml)|3M|[推理模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_distill_train.tar)|
 |ch_ppocr_mobile_slim_v2.0_det|slim裁剪版超轻量模型，支持中英文、多语种文本检测|[ch_det_mv3_db_v2.0.yml](../../configs/det/ch_ppocr_v2.0/ch_det_mv3_db_v2.0.yml)| 2.6M |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_det_prune_infer.tar)|
 |ch_ppocr_mobile_v2.0_det|原始超轻量模型，支持中英文、多语种文本检测|[ch_det_mv3_db_v2.0.yml](../../configs/det/ch_ppocr_v2.0/ch_det_mv3_db_v2.0.yml)|3M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_train.tar)|
 |ch_ppocr_server_v2.0_det|通用模型，支持中英文、多语种文本检测，比超轻量模型更大，但效果更好|[ch_det_res18_db_v2.0.yml](../../configs/det/ch_ppocr_v2.0/ch_det_res18_db_v2.0.yml)|47M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_train.tar)|
@@ -45,6 +48,8 @@ PaddleOCR提供的可下载模型包括`推理模型`、`训练模型`、`预训
 |模型名称|模型简介|配置文件|推理模型大小|下载地址|
 | --- | --- | --- | --- | --- |
+|ch_PP-OCRv2_rec_slim|slim量化版超轻量模型，支持中英文、数字识别|[ch_PP-OCRv2_rec.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml)| 9M |[推理模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_slim_quant_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_slim_quant_train.tar) |
+|ch_PP-OCRv2_rec|原始超轻量模型，支持中英文、数字识别|[ch_PP-OCRv2_rec.yml](../../configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml)|8.5M|[推理模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_train.tar) |
 |ch_ppocr_mobile_slim_v2.0_rec|slim裁剪量化版超轻量模型，支持中英文、数字识别|[rec_chinese_lite_train_v2.0.yml](../../configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml)| 6M |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_slim_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_slim_train.tar) |
 |ch_ppocr_mobile_v2.0_rec|原始超轻量模型，支持中英文、数字识别|[rec_chinese_lite_train_v2.0.yml](../../configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml)|5.2M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_train.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_pre.tar) |
 |ch_ppocr_server_v2.0_rec|通用模型，支持中英文、数字识别|[rec_chinese_common_train_v2.0.yml](../../configs/rec/ch_ppocr_v2.0/rec_chinese_common_train_v2.0.yml)|94.8M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_train.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_pre.tar) |
@@ -62,46 +67,6 @@ PaddleOCR提供的可下载模型包括`推理模型`、`训练模型`、`预训
 <a name="多语言识别模型"></a>
 #### 3. 多语言识别模型（更多语言持续更新中...）
-**说明：** 新增的多语言模型的配置文件通过代码方式生成，您可以通过`--help`参数查看当前PaddleOCR支持生成哪些多语言的配置文件：
-```bash
-# 该代码需要在指定目录运行
-cd {your/path/}PaddleOCR/configs/rec/multi_language/
-python3 generate_multi_language_configs.py --help
-```
-下面以生成意大利语配置文件为例：
-##### 1. 生成意大利语配置文件测试现有模型
-如果您仅仅想用配置文件测试PaddleOCR提供的多语言模型可以通过下面命令生成默认的配置文件，使用PaddleOCR提供的小语种字典进行预测。
-```bash
-# 该代码需要在指定目录运行
-cd {your/path/}PaddleOCR/configs/rec/multi_language/
-# 通过-l或者--language参数设置需要生成的语种的配置文件，该命令会将默认参数写入配置文件
-python3 generate_multi_language_configs.py -l it
-```
-##### 2. 生成意大利语配置文件训练自己的数据
-如果您想训练自己的小语种模型，可以准备好训练集文件、验证集文件、字典文件和训练数据路径，这里假设准备的意大利语的训练集、验证集、字典和训练数据路径为：
- 训练集:{your/path/}PaddleOCR/train_data/train_list.txt
- 验证集:{your/path/}PaddleOCR/train_data/val_list.txt
- 使用PaddleOCR提供的默认字典：{your/path/}PaddleOCR/ppocr/utils/dict/it_dict.txt
- 训练数据路径:{your/path/}PaddleOCR/train_data
-使用以下命令生成配置文件：
-```bash
-# 该代码需要在指定目录运行
-cd {your/path/}PaddleOCR/configs/rec/multi_language/
-# -l或者--language字段是必须的
-# --train修改训练集，--val修改验证集，--data_dir修改数据集目录，-o修改对应默认参数
-# --dict命令改变字典路径，示例使用默认字典路径则该参数可不填
-python3 generate_multi_language_configs.py -l it \
--train train_data/train_list.txt \
--val train_data/val_list.txt \
--data_dir train_data \
-o Global.use_gpu=False
-```
-<a name="多语言模型与配置文件"></a>
-##### 3. 多语言模型与配置文件
 |模型名称|字典文件|模型简介|配置文件|推理模型大小|下载地址|
 | --- | --- | --- | --- |--- | --- |
 | french_mobile_v2.0_rec | ppocr/utils/dict/french_dict.txt |法文识别|[rec_french_lite_train.yml](../../configs/rec/multi_language/rec_french_lite_train.yml)|2.65M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/multilingual/french_mobile_v2.0_rec_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/multilingual/french_mobile_v2.0_rec_train.tar) |
@@ -125,13 +90,16 @@ python3 generate_multi_language_configs.py -l it \
 |模型名称|模型简介|配置文件|推理模型大小|下载地址|
 | --- | --- | --- | --- | --- |
-|ch_ppocr_mobile_slim_v2.0_cls|slim量化版模型|[cls_mv3.yml](../../configs/cls/cls_mv3.yml)| 2.1M |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_slim_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_slim_infer.tar) |
+|ch_ppocr_mobile_slim_v2.0_cls|slim量化版模型，对检测到的文本行文字角度分类|[cls_mv3.yml](../../configs/cls/cls_mv3.yml)| 2.1M |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_slim_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_slim_infer.tar) |
-|ch_ppocr_mobile_v2.0_cls|原始模型|[cls_mv3.yml](../../configs/cls/cls_mv3.yml)|1.38M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |
+|ch_ppocr_mobile_v2.0_cls|原始分类器模型，对检测到的文本行文字角度分类|[cls_mv3.yml](../../configs/cls/cls_mv3.yml)|1.38M|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |
 <a name="Paddle-Lite模型"></a>
 ### 四、Paddle-Lite 模型
 |模型版本|模型简介|模型大小|检测模型|文本方向分类模型|识别模型|Paddle-Lite版本|
 |---|---|---|---|---|---|---|
-|V2.0|超轻量中文OCR 移动端模型|7.8M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_opt.nb)|v2.9|
+|PP-OCRv2|蒸馏版超轻量中文OCR移动端模型|11M|[下载地址](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_infer_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_infer_opt.nb)|v2.9|
-|V2.0(slim)|超轻量中文OCR 移动端模型|3.3M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_slim_opt.nb)|v2.9|
+|PP-OCRv2(slim)|蒸馏版超轻量中文OCR移动端模型|4.9M|[下载地址](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_slim_opt.nb)|v2.9|
+|V2.0|ppocr_v2.0超轻量中文OCR移动端模型|7.8M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_opt.nb)|v2.9|
+|V2.0(slim)|ppocr_v2.0超轻量中文OCR移动端模型|3.3M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_slim_opt.nb)|v2.9|
--- a/doc/doc_ch/multi_languages.md
+++ b/doc/doc_ch/multi_languages.md
@@ -200,9 +200,9 @@ ppocr 支持使用自己的数据进行自定义训练或finetune, 其中识别
 |英文|english|en| |乌克兰文|Ukranian|uk|
 |法文|french|fr| |白俄罗斯文|Belarusian|be|
 |德文|german|german| |泰卢固文|Telugu |te|
-|日文|japan|japan| | |阿巴扎文|Abaza |abq|
+|日文|japan|japan| | 阿巴扎文 | Abaza        | abq  |
 |韩文|korean|korean| |泰米尔文|Tamil |ta|
-|中文繁体|chinese traditional |ch_tra| |南非荷兰文 |Afrikaans |af|
+|中文繁体|chinese traditional |chinese_cht| |南非荷兰文 |Afrikaans |af|
 |意大利文| Italian |it| |阿塞拜疆文 |Azerbaijani    |az|
 |西班牙文|Spanish |es| |波斯尼亚文|Bosnian|bs|
 |葡萄牙文| Portuguese|pt| |捷克文|Czech|cs|

--- a/doc/doc_ch/paddleOCR_overview.md
+++ b/doc/doc_ch/paddleOCR_overview.md
+# PaddleOCR全景图与项目克隆
+## 1. PaddleOCR全景图
+PaddleOCR包含丰富的文本检测、文本识别以及端到端算法。结合实际测试与产业经验，PaddleOCR选择DB和CRNN作为基础的检测和识别模型，经过一系列优化策略提出面向产业应用的PP-OCR模型。PP-OCR模型针对通用场景，根据不同语种形成了PP-OCR模型库。基于PP-OCR的能力，PaddleOCR针对文档场景任务发布PP-Structure工具库，包含版面分析和表格识别两大任务。为了打通产业落地的全流程，PaddleOCR提供了规模化的数据生产工具和多种预测部署工具，助力开发者快速落地。
+<div align="center">
+    <img src="../overview.png">
+</div>
+## 2. 项目克隆
+### **2.1 克隆PaddleOCR repo代码**
+```
+【推荐】git clone https://github.com/PaddlePaddle/PaddleOCR
+```
+如果因为网络问题无法pull成功，也可选择使用码云上的托管：
+```
+git clone https://gitee.com/paddlepaddle/PaddleOCR
+```
+注：码云托管代码可能无法实时同步本github项目更新，存在3~5天延时，请优先使用推荐方式。
+### **2.2 安装第三方库**
+```
+cd PaddleOCR
+pip3 install -r requirements.txt
+```
--- a/doc/doc_ch/quickstart.md
+++ b/doc/doc_ch/quickstart.md
+# PaddleOCR快速开始
-# 中文OCR模型快速使用
-## 1.环境配置
+- [PaddleOCR快速开始](#paddleocr)
-请先参考[快速安装](./installation.md)配置PaddleOCR运行环境。
+  + [1. 安装PaddleOCR whl包](#1)
+  * [2. 便捷使用](#2)
+    + [2.1 命令行使用](#21)
+      - [2.1.1 中英文模型](#211)
+      - [2.1.2 多语言模型](#212)
+      - [2.1.3 版面分析](#213)
+    + [2.2 Python脚本使用](#22)
+      - [2.2.1 中英文与多语言使用](#221)
+      - [2.2.2 版面分析](#222)
-*注意：也可以通过 whl 包安装使用PaddleOCR，具体参考[Paddleocr Package使用说明](./whl.md)。*
+<a name="1"></a>
-## 2.inference模型下载
+## 1. 安装PaddleOCR whl包
-* 移动端和服务器端的检测与识别模型如下，更多模型下载（包括多语言），可以参考[PP-OCR v2.0 系列模型下载](../doc_ch/models_list.md)
+```bash
+pip install "paddleocr>=2.0.1" # 推荐使用2.0.1+版本
+```
-| 模型简介     | 模型名称     |推荐场景          | 检测模型 | 方向分类器 | 识别模型 |
+- 对于Windows环境用户：
-| ------------ | --------------- | ----------------|---- | ---------- | -------- |
-| 中英文超轻量OCR模型（8.1M） | ch_ppocr_mobile_v2.0_xx |移动端&服务器端|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_train.tar)|[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_pre.tar)      |
-| 中英文通用OCR模型（143M）   | ch_ppocr_server_v2.0_xx |服务器端 |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_train.tar)          |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar)    |[推理模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_pre.tar)  |
+  直接通过pip安装的shapely库可能出现`[winRrror 126] 找不到指定模块的问题`。建议从[这里](https://www.lfd.uci.edu/~gohlke/pythonlibs/#shapely)下载shapely安装包完成安装，
-* windows 环境下如果没有安装wget,下载模型时可将链接复制到浏览器中下载，并解压放置在相应目录下
+- 使用**版面分析**功能时，运行以下命令**安装 Layout-Parser**
-复制上表中的检测和识别的`inference模型`下载地址，并解压
+  ```bash
+  pip3 install -U https://paddleocr.bj.bcebos.com/whl/layoutparser-0.0.0-py3-none-any.whl
+  ```
-```
-mkdir inference && cd inference
-# 下载检测模型并解压
-wget {url/of/detection/inference_model} && tar xf {name/of/detection/inference_model/package}
-# 下载识别模型并解压
-wget {url/of/recognition/inference_model} && tar xf {name/of/recognition/inference_model/package}
-# 下载方向分类器模型并解压
-wget {url/of/classification/inference_model} && tar xf {name/of/classification/inference_model/package}
-cd ..
-```
-以超轻量级模型为例：
+<a name="2"></a>
+## 2. 便捷使用
+<a name="21"></a>
+### 2.1 命令行使用
+PaddleOCR提供了一系列测试图片，点击[这里](https://paddleocr.bj.bcebos.com/dygraph_v2.1/ppocr_img.zip)下载并解压，然后在终端中切换到相应目录
 ```
-mkdir inference && cd inference
+cd /path/to/ppocr_img
-# 下载超轻量级中文OCR模型的检测模型并解压
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar && tar xf ch_ppocr_mobile_v2.0_det_infer.tar
-# 下载超轻量级中文OCR模型的识别模型并解压
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar && tar xf ch_ppocr_mobile_v2.0_rec_infer.tar
-# 下载超轻量级中文OCR模型的文本方向分类器模型并解压
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar && tar xf ch_ppocr_mobile_v2.0_cls_infer.tar
-cd ..
 ```
-解压完毕后应有如下文件结构：
+如果不使用提供的测试图片，可以将下方`--image_dir`参数替换为相应的测试图片路径
+<a name="211"></a>
+#### 2.1.1 中英文模型
+* 检测+方向分类器+识别全流程：设置方向分类器参数`--use_angle_cls true`后可对竖排文本进行识别。
+  ```bash
+  paddleocr --image_dir ./imgs/11.jpg --use_angle_cls true
+  ```
+  结果是一个list，每个item包含了文本框，文字和识别置信度
+  ```bash
+  [[[24.0, 36.0], [304.0, 34.0], [304.0, 72.0], [24.0, 74.0]], ['纯臻营养护发素', 0.964739]]
+  [[[24.0, 80.0], [172.0, 80.0], [172.0, 104.0], [24.0, 104.0]], ['产品信息/参数', 0.98069626]]
+  [[[24.0, 109.0], [333.0, 109.0], [333.0, 136.0], [24.0, 136.0]], ['（45元/每公斤，100公斤起订）', 0.9676722]]
+  ......
+  ```
+- 单独使用检测：设置`--rec`为`false`
+  ```bash
+  paddleocr --image_dir ./imgs/11.jpg --rec false
+  ```
+  结果是一个list，每个item只包含文本框
+  ```bash
+  [[26.0, 457.0], [137.0, 457.0], [137.0, 477.0], [26.0, 477.0]]
+  [[25.0, 425.0], [372.0, 425.0], [372.0, 448.0], [25.0, 448.0]]
+  [[128.0, 397.0], [273.0, 397.0], [273.0, 414.0], [128.0, 414.0]]
+  ......
+  ```
+- 单独使用识别：设置`--det`为`false`
+  ```bash
+  paddleocr --image_dir ./imgs_words/ch/word_1.jpg --det false
+  ```
+  结果是一个list，每个item只包含识别结果和识别置信度
+  ```bash
+  ['韩国小馆', 0.9907421]
+  ```
+如需使用2.0模型，请指定参数`--version 2.0`，paddleocr默认使用2.1模型。更多whl包使用可参考[whl包文档](./whl.md)
+<a name="212"></a>
+#### 2.1.2 多语言模型
+Paddleocr目前支持80个语种，可以通过修改`--lang`参数进行切换，对于英文模型，指定`--lang=en`。
+``` bash
+paddleocr --image_dir ./imgs_en/254.jpg --lang=en
 ```
-├── ch_ppocr_mobile_v2.0_cls_infer
-│   ├── inference.pdiparams
+<div align="center">
-│   ├── inference.pdiparams.info
+    <img src="../imgs_en/254.jpg" width="300" height="600">
-│   └── inference.pdmodel
+    <img src="../imgs_results/multi_lang/img_02.jpg" width="600" height="600">
-├── ch_ppocr_mobile_v2.0_det_infer
+</div>
-│   ├── inference.pdiparams
-│   ├── inference.pdiparams.info
+结果是一个list，每个item包含了文本框，文字和识别置信度
-│   └── inference.pdmodel
-├── ch_ppocr_mobile_v2.0_rec_infer
+```text
-    ├── inference.pdiparams
+[('PHO CAPITAL', 0.95723116), [[66.0, 50.0], [327.0, 44.0], [327.0, 76.0], [67.0, 82.0]]]
-    ├── inference.pdiparams.info
+[('107 State Street', 0.96311164), [[72.0, 90.0], [451.0, 84.0], [452.0, 116.0], [73.0, 121.0]]]
-    └── inference.pdmodel
+[('Montpelier Vermont', 0.97389287), [[69.0, 132.0], [501.0, 126.0], [501.0, 158.0], [70.0, 164.0]]]
+[('8022256183', 0.99810505), [[71.0, 175.0], [363.0, 170.0], [364.0, 202.0], [72.0, 207.0]]]
+[('REG 07-24-201706:59 PM', 0.93537045), [[73.0, 299.0], [653.0, 281.0], [654.0, 318.0], [74.0, 336.0]]]
+[('045555', 0.99346405), [[509.0, 331.0], [651.0, 325.0], [652.0, 356.0], [511.0, 362.0]]]
+[('CT1', 0.9988654), [[535.0, 367.0], [654.0, 367.0], [654.0, 406.0], [535.0, 406.0]]]
+......
 ```
-## 3.单张图像或者图像集合预测
+常用的多语言简写包括
-以下代码实现了文本检测、方向分类器和识别串联推理，在执行预测时，需要通过参数image_dir指定单张图像或者图像集合的路径、参数`det_model_dir`指定检测inference模型的路径、参数`rec_model_dir`指定识别inference模型的路径、参数`use_angle_cls`指定是否使用方向分类器、参数`cls_model_dir`指定方向分类器inference模型的路径、参数`use_space_char`指定是否预测空格字符。可视化识别结果默认保存到`./inference_results`文件夹里面。
+| 语种     | 缩写        |      | 语种     | 缩写   |      | 语种     | 缩写   |
+| -------- | ----------- | ---- | -------- | ------ | ---- | -------- | ------ |
+| 中文     | ch          |      | 法文     | fr     |      | 日文     | japan  |
+| 英文     | en          |      | 德文     | german |      | 韩文     | korean |
+| 繁体中文 | chinese_cht |      | 意大利文 | it     |      | 俄罗斯文 | ru     |
-```bash
+全部语种及其对应的缩写列表可查看[多语言模型教程](./multi_languages.md)
+<a name="213"></a>
+#### 2.1.3 版面分析
-# 预测image_dir指定的单张图像
+版面分析是指对文档图片中的文字、标题、列表、图片和表格5类区域进行划分。对于前三类区域，直接使用OCR模型完成对应区域文字检测与识别，并将结果保存在txt中。对于表格类区域，经过表格结构化处理后，表格图片转换为相同表格样式的Excel文件。图片区域会被单独裁剪成图像。
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_ppocr_mobile_v2.0_det_infer/"  --rec_model_dir="./inference/ch_ppocr_mobile_v2.0_rec_infer/" --cls_model_dir="./inference/ch_ppocr_mobile_v2.0_cls_infer/" --use_angle_cls=True --use_space_char=True
-# 预测image_dir指定的图像集合
+使用PaddleOCR的版面分析功能，需要指定`--type=structure`
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/" --det_model_dir="./inference/ch_ppocr_mobile_v2.0_det_infer/"  --rec_model_dir="./inference/ch_ppocr_mobile_v2.0_rec_infer/" --cls_model_dir="./inference/ch_ppocr_mobile_v2.0_cls_infer/" --use_angle_cls=True --use_space_char=True
-# 如果想使用CPU进行预测，需设置use_gpu参数为False
+```bash
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_ppocr_mobile_v2.0_det_infer/"  --rec_model_dir="./inference/ch_ppocr_mobile_v2.0_rec_infer/" --cls_model_dir="./inference/ch_ppocr_mobile_v2.0_cls_infer/" --use_angle_cls=True --use_space_char=True --use_gpu=False
+paddleocr --image_dir=./table/1.png --type=structure
 ```
- 通用中文OCR模型
+- **返回结果说明**
+  PP-Structure的返回结果为一个dict组成的list，示例如下
+  ```shell
+  [{   'type': 'Text',
+        'bbox': [34, 432, 345, 462],
+        'res': ([[36.0, 437.0, 341.0, 437.0, 341.0, 446.0, 36.0, 447.0], [41.0, 454.0, 125.0, 453.0, 125.0, 459.0, 41.0, 460.0]],
+                  [('Tigure-6. The performance of CNN and IPT models using difforen', 0.90060663), ('Tent  ', 0.465441)])
+    }
+  ]
+  ```
+  其中各个字段说明如下
+  | 字段 | 说明                                                         |
+  | ---- | ------------------------------------------------------------ |
+  | type | 图片区域的类型                                               |
+  | bbox | 图片区域的在原图的坐标，分别[左上角x，左上角y，右下角x，右下角y] |
+  | res  | 图片区域的OCR或表格识别结果。<br>表格: 表格的HTML字符串; <br>OCR: 一个包含各个单行文字的检测坐标和识别结果的元组 |
+  运行完成后，每张图片会在`output`字段指定的目录下有一个同名目录，图片里的每个表格会存储为一个excel，图片区域会被裁剪之后保存下来，excel文件和图片名为表格在图片里的坐标。
+  ```
+  /output/table/1/
+    └─ res.txt
+    └─ [454, 360, 824, 658].xlsx  表格识别结果
+    └─ [16, 2, 828, 305].jpg			被裁剪出的图片区域
+    └─ [17, 361, 404, 711].xlsx		表格识别结果
+  ```
+- **参数说明**
+  | 字段            | 说明                                     | 默认值                                       |
+  | --------------- | ---------------------------------------- | -------------------------------------------- |
+  | output          | excel和识别结果保存的地址                | ./output/table                               |
+  | table_max_len   | 表格结构模型预测时，图像的长边resize尺度 | 488                                          |
+  | table_model_dir | 表格结构模型 inference 模型地址          | None                                         |
+  | table_char_type | 表格结构模型所用字典地址                 | ../ppocr/utils/dict/table_structure_dict.txt |
+  大部分参数和paddleocr whl包保持一致，见 [whl包文档](./whl.md)
+<a name="22"></a>
+### 2.2 Python脚本使用
+<a name="221"></a>
+#### 2.2.1 中英文与多语言使用
-请按照上述步骤下载相应的模型，并且更新相关的参数，示例如下：
+通过Python脚本使用PaddleOCR whl包，whl包会自动下载ppocr轻量级模型作为默认模型。
+* 检测+方向分类器+识别全流程
+```python
+from paddleocr import PaddleOCR, draw_ocr
+# Paddleocr目前支持的多语言语种可以通过修改lang参数进行切换
+# 例如`ch`, `en`, `fr`, `german`, `korean`, `japan`
+ocr = PaddleOCR(use_angle_cls=True, lang="ch")  # need to run only once to download and load model into memory
+img_path = './imgs/11.jpg'
+result = ocr.ocr(img_path, cls=True)
+for line in result:
+    print(line)
+# 显示结果
+from PIL import Image
+image = Image.open(img_path).convert('RGB')
+boxes = [line[0] for line in result]
+txts = [line[1][0] for line in result]
+scores = [line[1][1] for line in result]
+im_show = draw_ocr(image, boxes, txts, scores, font_path='./fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+结果是一个list，每个item包含了文本框，文字和识别置信度
 ```bash
-# 预测image_dir指定的单张图像
+[[[24.0, 36.0], [304.0, 34.0], [304.0, 72.0], [24.0, 74.0]], ['纯臻营养护发素', 0.964739]]
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_ppocr_server_v2.0_det_infer/"  --rec_model_dir="./inference/ch_ppocr_server_v2.0_rec_infer/" --cls_model_dir="./inference/ch_ppocr_mobile_v2.0_cls_infer/" --use_angle_cls=True --use_space_char=True
+[[[24.0, 80.0], [172.0, 80.0], [172.0, 104.0], [24.0, 104.0]], ['产品信息/参数', 0.98069626]]
+[[[24.0, 109.0], [333.0, 109.0], [333.0, 136.0], [24.0, 136.0]], ['（45元/每公斤，100公斤起订）', 0.9676722]]
+......
 ```
-* 注意：
+结果可视化
-    - 如果希望使用不支持空格的识别模型，在预测的时候需要注意：请将代码更新到最新版本，并添加参数 `--use_space_char=False`。
-    - 如果不希望使用方向分类器，在预测的时候需要注意：请将代码更新到最新版本，并添加参数 `--use_angle_cls=False`。
+<div align="center">
+    <img src="../imgs_results/whl/11_det_rec.jpg" width="800">
+</div>
+<a name="222"></a>
-更多的文本检测、识别串联推理使用方式请参考文档教程中[基于Python预测引擎推理](./inference.md)。
+#### 2.2.2 版面分析
-此外，文档教程中也提供了中文OCR模型的其他预测部署方式：
+```python
- [基于C++预测引擎推理](../../deploy/cpp_infer/readme.md)
+import os
- [服务部署](../../deploy/hubserving)
+import cv2
- [端侧部署（目前只支持静态图）](https://github.com/PaddlePaddle/PaddleOCR/tree/develop/deploy/lite)
+from paddleocr import PPStructure,draw_structure_result,save_structure_res
+table_engine = PPStructure(show_log=True)
+save_folder = './output/table'
+img_path = './table/paper-image.jpg'
+img = cv2.imread(img_path)
+result = table_engine(img)
+save_structure_res(result, save_folder,os.path.basename(img_path).split('.')[0])
+for line in result:
+    line.pop('img')
+    print(line)
+from PIL import Image
+font_path = './fonts/simfang.ttf' # PaddleOCR下提供字体包
+image = Image.open(img_path).convert('RGB')
+im_show = draw_structure_result(image, result,font_path=font_path)
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```