Merge branch 'release/2.5' of https://github.com/PaddlePaddle/PaddleOCR into release/2.5

PPOCRLabel/README.md

@@ -15,8 +15,7 @@ PPOCRLabelv2 is a semi-automatic graphic annotation tool suitable for OCR field,
 - 2022.05: Add table annotations, follow `2.2 Table Annotations` for more information （by [whjdark](https://github.com/peterh0323); [Evezerest](https://github.com/Evezerest))
 - 2022.02:（by [PeterH0323](https://github.com/peterh0323) ）
   - Add KIE Mode by using `--kie`, for [detection + identification + keyword extraction] labeling.
-  - Improve user experience: prompt for the number of files and labels, optimize interaction, and fix bugs such as only use CPU when inference
-  - New functions: Support using `C` or `X` to rotate box.
+  - Improve user experience: support using `C` or `X` to rotate box, prompt for the number of files and labels, optimize interaction.
 - 2021.11.17:
   - Support install and start PPOCRLabel through the whl package (by [d2623587501](https://github.com/d2623587501))
   - Dataset segmentation: Divide the annotation file into training, verification and testing parts (refer to section 3.5 below, by [MrCuiHao](https://github.com/MrCuiHao))

README.md

@@ -107,6 +107,7 @@ PaddleOCR support a variety of cutting-edge algorithms related to OCR, and devel
         - [Serving](./deploy/pdserving/README.md)
         - [Mobile](./deploy/lite/readme.md)
         - [Paddle2ONNX](./deploy/paddle2onnx/readme.md)
+        - [PaddleCloud](./deploy/paddlecloud/README.md)
         - [Benchmark](./doc/doc_en/benchmark_en.md)  
 - [PP-Structure 🔥](./ppstructure/README.md)
     - [Quick Start](./ppstructure/docs/quickstart_en.md)

README_ch.md

@@ -122,6 +122,7 @@ PaddleOCR旨在打造一套丰富、领先、且实用的OCR工具库，助力
         - [服务化部署](./deploy/pdserving/README_CN.md)
         - [端侧部署](./deploy/lite/readme.md)
         - [Paddle2ONNX模型转化与预测](./deploy/paddle2onnx/readme.md)
+        - [云上飞桨部署工具](./deploy/paddlecloud/README.md)
         - [Benchmark](./doc/doc_ch/benchmark.md)
 - [PP-Structure文档分析🔥](./ppstructure/README_ch.md)
     - [快速开始](./ppstructure/docs/quickstart.md)
@@ -140,11 +141,7 @@ PaddleOCR旨在打造一套丰富、领先、且实用的OCR工具库，助力
     - [文本识别算法](./doc/doc_ch/algorithm_overview.md#12-%E6%96%87%E6%9C%AC%E8%AF%86%E5%88%AB%E7%AE%97%E6%B3%95)
     - [端到端算法](./doc/doc_ch/algorithm_overview.md#2-%E6%96%87%E6%9C%AC%E8%AF%86%E5%88%AB%E7%AE%97%E6%B3%95)
     - [使用PaddleOCR架构添加新算法](./doc/doc_ch/add_new_algorithm.md)
-- [场景应用](./doc/doc_ch/application.md)
-    - [金融场景（表单/票据等）]()
-    - [工业场景（电表度数/车牌等）]()
-    - [教育场景（手写体/公式等）]()
-    - [医疗场景（化验单等）]()
+- [场景应用](./applications)
 - 数据标注与合成
     - [半自动标注工具PPOCRLabel](./PPOCRLabel/README_ch.md)
     - [数据合成工具Style-Text](./StyleText/README_ch.md)

deploy/hubserving/ocr_det/params.py

@@ -32,8 +32,8 @@ def read_params():
 
     #DB parmas
     cfg.det_db_thresh = 0.3
-    cfg.det_db_box_thresh = 0.5
-    cfg.det_db_unclip_ratio = 1.6
+    cfg.det_db_box_thresh = 0.6
+    cfg.det_db_unclip_ratio = 1.5
     cfg.use_dilation = False
     cfg.det_db_score_mode = "fast"
 

deploy/paddlecloud/README.md

+# 云上飞桨部署工具
+
+[云上飞桨（PaddleCloud）](https://github.com/PaddlePaddle/PaddleCloud) 是面向飞桨框架及其模型套件的部署工具， 
+为用户提供了模型套件Docker化部署和Kubernetes集群部署两种方式，可以满足不同场景与环境的部署需求。
+本章节我们将使用PaddleCloud提供的OCR标准镜像以及云原生组件来训练和部署PP-OCRv3识别模型。
+
+## 云上飞桨部署工具的优势
+
+<div align="center">
+  <img src="./images/paddlecloud.png" title="architecture" width="80%" height="80%" alt="">
+</div>
+
+- **模型套件Docker镜像大礼包。**
+
+  PaddleCloud为用户提供了飞桨模型套件Docker镜像大礼包，这些镜像中包含运行模型套件案例的所有依赖并能持续更新，支持异构硬件环境和常见CUDA版本、开箱即用。
+
+- **具有丰富的云上飞桨组件。**
+
+  云上飞桨具有丰富的云原生功能组件，包括样本数据缓存组件、分布式训练组件、推理服务组件等，使用这些组件用户可以快速地在Kubernetes集群上进行训练和部署工作。
+
+- **功能强大的自运维能力。**
+
+  云上飞桨组件基于Kubernetes的Operator机制提供了功能强大的自运维能力，如训练组件支持多种架构模式并具有分布式容错与弹性训练的能力，推理服务组件支持自动扩缩容与蓝绿发版等。
+
+- **针对飞桨框架的定制优化。**
+
+  除了部署便捷与自运维的优势，PaddleCloud还针对飞桨框架进行了正对性优化，如通过缓存样本数据来加速云上飞桨分布式训练作业、基于飞桨框架和调度器的协同设计来优化集群GPU利用率等。
+
+
+## 1. PP-OCRv3 Docker化部署
+
+PaddleCloud基于 [Tekton](https://github.com/tektoncd/pipeline) 为OCR模型套件提供了镜像持续构建的能力，并支持CPU、GPU以及常见CUDA版本的镜像。
+您可以查看 [PaddleOCR 镜像仓库](https://hub.docker.com/repository/docker/paddlecloud/paddleocr) 来获取所有的镜像列表。
+同时我们也将PP-OCRv3识别模型的训练与推理实战案例放置到了AI Studio平台上，您可以点击 [PP-OCRv3识别训推一体项目实战](https://aistudio.baidu.com/aistudio/projectdetail/3916206?channelType=0&channel=0) 在平台上快速体验。
+
+> **适用场景**：本地测试开发环境、单机部署环境。
+
+### 1.1 安装Docker
+
+如果您所使用的机器上还没有安装 Docker，您可以参考 [Docker 官方文档](https://docs.docker.com/get-docker/) 来进行安装。
+如果您需要使用支持 GPU 版本的镜像，则还需安装好NVIDIA相关驱动和 [nvidia-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker) 。
+
+**注意**：如果您使用的是Windows系统，需要开启 [WSL2（Linux子系统功能）功能](https://docs.microsoft.com/en-us/windows/wsl/install)。
+
+### 1.2 启动容器
+
+**使用CPU版本的Docker镜像**
+
+```bash
+# 这是加上参数 --shm-size=32g 是为了防止容器里内存不足
+docker run --name ppocr -v $PWD:/mnt -p 8888:8888 -it --shm-size=32g paddlecloud/paddleocr:2.5-cpu-efbb0a /bin/bash
+```
+
+**使用GPU版本的Docker镜像**
+
+```bash
+docker run --name ppocr --runtime=nvidia -v $PWD:/mnt -p 8888:8888 -it --shm-size=32g paddlecloud/paddleocr:2.5-gpu-cuda10.2-cudnn7-efbb0a /bin/bash
+```
+
+进入容器内，则可进行 PP-OCRv3 模型的训练和部署工作。
+
+### 1.3 准备训练数据
+
+本教程以 [HierText](https://github.com/google-research-datasets/hiertext) 数据集为例，HierText是第一个具有自然场景和文档中文本分层注释的数据集。
+该数据集包含从 Open Images 数据集中选择的 11639 张图像，提供高质量的单词 (~1.2M)、行和段落级别的注释。值得注意的是该数据集的标注格式与ppocrlabel格式不一样，
+我们需要对其数据标签格式进行相应的转换，您可以从AI Studio中直接下载 [标签格式转换后的HierText数据集](https://aistudio.baidu.com/aistudio/datasetdetail/143700)。
+同时，我们也将数据集上传到了百度云对象存储（BOS），您可以通过运行如下指令，完成数据集的下载和解压操作：
+
+```bash
+# 下载数据集
+$ wget -P /mnt https://paddleflow-public.hkg.bcebos.com/ppocr/hiertext1.tar
+
+# 解压数据集
+$ tar xf /mnt/hiertext1.tar -C /mnt && mv /mnt/hiertext1 /mnt/hiertext
+```
+
+运行上述命令后，在 `/mnt` 目录下包含以下文件：
+
+```
+/mnt/hiertext
+  └─ train/     HierText训练集数据
+  └─ validation/     HierText验证集数据
+  └─ label_hiertext_train.txt  HierText训练集的行标注
+  └─ label_hiertext_val.txt    HierText验证集的行标注
+```
+
+### 1.4 修改配置文件
+
+PP-OCRv3模型配置文件位于`/home/PaddleOCR/configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml`，需要修改的配置如下：
+
+- 修改训练数据配置：
+
+```yaml
+Train:
+  dataset:
+    name: SimpleDataSet
+    data_dir: ./train_data/icdar2015/text_localization/
+    label_file_list:
+      - ./train_data/icdar2015/text_localization/train_icdar2015_label.txt
+```
+
+修改为：
+
+```yaml
+Train:
+  dataset:
+    name: SimpleDataSet
+    data_dir: /mnt/
+    label_file_list:
+      - /mnt/hiertext/label_hiertext_train.txt
+```
+
+- 修改验证数据配置：
+
+```yaml
+Eval:
+  dataset:
+    name: SimpleDataSet
+    data_dir: ./train_data/icdar2015/text_localization/
+    label_file_list:
+      - ./train_data/icdar2015/text_localization/test_icdar2015_label.txt
+```
+
+修改为：
+
+```yaml
+Eval:
+  dataset:
+    name: SimpleDataSet
+    data_dir: /mnt/
+    label_file_list:
+      - /mnt/hiertext/label_hiertext_val.txt
+```
+
+### 1.5 启动训练
+
+下载PP-OCRv3的蒸馏预训练模型并进行训练的方式如下
+
+```bash
+# 下载预训练模型到/home/PaddleOCR/pre_train文件夹下
+$ mkdir /home/PaddleOCR/pre_train
+
+$ wget -P /home/PaddleOCR/pre_train https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_distill_train.tar
+
+$ tar xf /home/PaddleOCR/pre_train/ch_PP-OCRv3_det_distill_train.tar -C /home/PaddleOCR/pre_train/
+```
+
+启动训练，训练模型默认保存在`output`目录下，加载PP-OCRv3检测预训练模型。
+
+```bash 
+# 这里以 GPU 训练为例，使用 CPU 进行训练的话，需要指定参数 Global.use_gpu=false
+python3 tools/train.py -c configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml -o Global.save_model_dir=./output/ Global.pretrained_model=./pre_train/ch_PP-OCRv3_det_distill_train/best_accuracy
+```
+
+如果要使用多GPU分布式训练，请使用如下命令：
+
+```bash
+# 启动训练，训练模型默认保存在output目录下，--gpus '0,1,2,3'表示使用0，1，2，3号GPU训练
+python3 -m paddle.distributed.launch --log_dir=./debug/ --gpus '0,1,2,3' tools/train.py -c configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml -o Global.save_model_dir=./output/ Global.pretrained_model=./pre_train/ch_PP-OCRv3_det_distill_train/best_accuracy
+```
+
+### 1.6 模型评估
+
+训练过程中保存的模型在output目录下，包含以下文件：
+
+```
+best_accuracy.states    
+best_accuracy.pdparams  # 默认保存最优精度的模型参数
+best_accuracy.pdopt     # 默认保存最优精度的优化器相关参数
+latest.states    
+latest.pdparams  # 默认保存的最新模型参数
+latest.pdopt     # 默认保存的最新模型的优化器相关参数
+```
+
+其中，best_accuracy是保存的最优模型，可以直接使用该模型评估
+
+```bash
+# 进行模型评估
+cd /home/PaddleOCR/
+
+python3 tools/eval.py -c configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml -o Global.checkpoints=./output/best_accuracy
+```
+
+## 2. PP-OCRv3云端部署
+
+PaddleCloud基于Kubernetes的Operator机制为您提供了多个功能强大的云原生组件，如样本数据缓存组件、分布式训练组件、 以及模型推理服务组件，
+使用这些组件您可以快速地在云上进行分布式训练和模型服务化部署。更多关于PaddleCloud云原生组件的内容，请参考文档 [PaddleCloud架构概览](https://github.com/PaddlePaddle/PaddleCloud/blob/main/docs/zh_CN/paddlecloud-overview.md) 。
+
+> **适用场景**：基于Kubernetes的多机部署环境。
+
+### 2.1 安装云上飞桨组件
+
+**环境要求**
+
+- [Kubernetes v1.16+](https://kubernetes.io/zh/)
+- [kubectl](https://kubernetes.io/docs/tasks/tools/)
+- [Helm](https://helm.sh/zh/docs/intro/install/)
+
+如果您没有Kubernetes环境，可以使用MicroK8S在本地搭建环境，更多详情请参考 [MicroK8S官方文档](https://microk8s.io/docs/getting-started)。
+
+使用Helm一键安装所有组件和所有依赖
+
+```bash
+# 添加PaddleCloud Chart仓库
+$ helm repo add paddlecloud https://paddleflow-public.hkg.bcebos.com/charts
+$ helm repo update
+
+# 安装云上飞桨组件
+$ helm install pdc paddlecloud/paddlecloud --set tags.all-dep=true --namespace paddlecloud --create-namespace
+
+# 检查所有云上飞桨组件是否成功启动，命名空间下的所有Pod都为Runing状态则安装成功。
+$ kubectl get pods -n paddlecloud
+NAME                                                 READY   STATUS    RESTARTS   AGE
+pdc-hostpath-5b6bd6787d-bxvxg                        1/1     Running   0          10h
+juicefs-csi-node-pkldt                               3/3     Running   0          10h
+juicefs-csi-controller-0                             3/3     Running   0          10h
+pdc-paddlecloud-sampleset-767bdf6947-pb6zm           1/1     Running   0          10h
+pdc-paddlecloud-paddlejob-7cc8b7bfc6-7gqnh           1/1     Running   0          10h
+pdc-minio-7cc967669d-824q5                           1/1     Running   0          10h
+pdc-redis-master-0                                   1/1     Running   0          10h
+```
+
+更多安装参数请参考[PaddleCloud安装指南](https://github.com/PaddlePaddle/PaddleCloud/blob/main/docs/zh_CN/installation.md)
+
+### 2.2 云原生组件介绍
+
+<div align="center">
+  <img src="./images/architecture.jpeg" title="architecture" width="60%" height="60%" alt="">
+</div>
+
+- **数据缓存组件。** 数据缓存组件使用JuiceFS作为缓存引擎，能够将远程样本数据缓存到训练集群本地，大幅加速云上飞桨分布式训练作业。
+- **分布式训练组件。** 分布式训练组件支持参数服务器（PS）与集合通信（Collective）两种架构模式，方便用户在云上快速运行飞桨分布式训练作业。
+
+以下内容我们将使用这两个云原生组件来在Kubernetes集群中部署PP-OCRv3识别模型的训练作业。
+
+### 2.3 准备hiertext数据集
+
+使用数据缓存组件来准备数据集，编写SampleSet Yaml文件如下：
+
+```yaml
+# hiertext.yaml
+apiVersion: batch.paddlepaddle.org/v1alpha1
+kind: SampleSet
+metadata:
+  name: hiertext
+  namespace: paddlecloud
+spec:
+  partitions: 1
+  source:
+    uri: bos://paddleflow-public.hkg.bcebos.com/ppocr/hiertext
+    secretRef:
+      name: none
+  secretRef:
+    name: data-center
+```
+
+然后在命令行中，使用kubectl执行如下命令。
+
+```bash
+# 创建hiertext数据集
+$ kubectl apply -f hiertext.yaml
+sampleset.batch.paddlepaddle.org/hiertext created
+
+# 查看数据集的状态
+$ kubectl get sampleset hiertext -n paddlecloud
+NAME       TOTAL SIZE   CACHED SIZE   AVAIL SPACE   RUNTIME   PHASE   AGE
+hiertext   3.3 GiB       3.2 GiB      12 GiB        1/1       Ready   11m
+```
+
+### 2.4 训练PP-OCRv3模型
+
+使用训练组件在Kubernetes集群上训练PP-OCRv3模型，编写PaddleJob Yaml文件如下：
+
+```yaml
+# ppocrv3.yaml
+apiVersion: batch.paddlepaddle.org/v1
+kind: PaddleJob
+metadata:
+  name: ppocrv3
+  namespace: paddlecloud
+spec:
+  cleanPodPolicy: OnCompletion
+  sampleSetRef:
+    name: hiertext
+    namespace: paddlecloud
+    mountPath: /mnt/hiertext
+  worker:
+    replicas: 1
+    template:
+      spec:
+        containers:
+          - name: ppocrv3
+            image: paddlecloud/paddleocr:2.5-gpu-cuda10.2-cudnn7-efbb0a
+            command:
+              - /bin/bash
+            args:
+              - "-c"
+              - >
+                mkdir /home/PaddleOCR/pre_train &&
+                wget -P ./pre_train https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_distill_train.tar &&
+                tar xf ./pre_train/ch_PP-OCRv3_det_distill_train.tar -C ./pre_train/ &&
+                python tools/train.py -c configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml -o
+                Train.dataset.data_dir=/mnt/
+                Train.dataset.label_file_list=[\"/mnt/hiertext/label_hiertext_train.txt\"]
+                Eval.dataset.data_dir=/mnt/
+                Eval.dataset.label_file_list=[\"/mnt/hiertext/label_hiertext_val.txt\"]
+                Global.save_model_dir=./output/
+                Global.pretrained_model=./pre_train/ch_PP-OCRv3_det_distill_train/best_accuracy
+            resources:
+              limits:
+                nvidia.com/gpu: 1
+            volumeMounts:  # 添加 shared memory 挂载以防止缓存出错
+              - mountPath: /dev/shm
+                name: dshm
+        volumes:
+          - name: dshm
+            emptyDir:
+              medium: Memory
+```
+
+本案例采用GPU进行训练，如果您只有CPU机器，则可以将镜像替换成CPU版本 `paddlecloud/paddleocr:2.5-cpu-efbb0a`，并在args中加上参数`Global.use_gpu=false`。
+
+```bash
+# 创建PaddleJob训练模型
+$ kubectl apply -f ppocrv3.yaml
+paddlejob.batch.paddlepaddle.org/ppocrv3 created
+
+# 查看PaddleJob状态
+$ kubectl get pods -n paddlecloud -l paddle-res-name=ppocrv3-worker-0
+NAME               READY   STATUS    RESTARTS   AGE
+ppocrv3-worker-0   1/1     Running   0          4s
+
+# 查看训练日志
+$ kubectl logs -f ppocrv3-worker-0 -n paddlecloud
+```
+
+## 更多资源
+
+欢迎关注[云上飞桨项目PaddleCloud](https://github.com/PaddlePaddle/PaddleCloud)，我们为您提供了飞桨模型套件标准镜像以及全栈的云原生模型套件部署组件，如您有任何关于飞桨模型套件的部署问题，请联系我们。
+如果你发现任何PaddleCloud存在的问题或者是建议, 欢迎通过[GitHub Issues](https://github.com/PaddlePaddle/PaddleCloud/issues)给我们提issues。
\ No newline at end of file

doc/doc_ch/algorithm_overview.md

@@ -44,7 +44,7 @@
 在CTW1500文本检测公开数据集上，算法效果如下：
 
 |模型|骨干网络|precision|recall|Hmean|下载链接|
-| --- | --- | --- | --- | --- | --- |         
+| --- | --- | --- | --- | --- | --- |  
 |FCE|ResNet50_dcn|88.39%|82.18%|85.27%|[训练模型](https://paddleocr.bj.bcebos.com/contribution/det_r50_dcn_fce_ctw_v2.0_train.tar)|
 
 **说明：** SAST模型训练额外加入了icdar2013、icdar2017、COCO-Text、ArT等公开数据集进行调优。PaddleOCR用到的经过整理格式的英文公开数据集下载：
@@ -65,6 +65,7 @@
 - [x]  [NRTR](./algorithm_rec_nrtr.md)
 - [x]  [SAR](./algorithm_rec_sar.md)
 - [x]  [SEED](./algorithm_rec_seed.md)
+- [x]  [SVTR](./algorithm_rec_svtr.md)
 
 参考[DTRB](https://arxiv.org/abs/1904.01906)[3]文字识别训练和评估流程，使用MJSynth和SynthText两个文字识别数据集训练，在IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE数据集上进行评估，算法效果如下：
 
@@ -82,6 +83,7 @@
 |NRTR|NRTR_MTB| 84.21% | rec_mtb_nrtr | [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_mtb_nrtr_train.tar) |
 |SAR|Resnet31| 87.20% | rec_r31_sar | [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.1/rec/rec_r31_sar_train.tar) |
 |SEED|Aster_Resnet| 85.35% | rec_resnet_stn_bilstm_att | [训练模型](https://paddleocr.bj.bcebos.com/dygraph_v2.1/rec/rec_resnet_stn_bilstm_att.tar) |
+|SVTR|SVTR-Tiny| 89.25% | rec_svtr_tiny_none_ctc_en | [训练模型](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/rec_svtr_tiny_none_ctc_en_train.tar) |
 
 
 <a name="2"></a>
@@ -90,5 +92,3 @@
 
 已支持的端到端OCR算法列表（戳链接获取使用教程）：
 - [x]  [PGNet](./algorithm_e2e_pgnet.md)
-
-

doc/doc_ch/application.md

-# 场景应用
\ No newline at end of file

doc/doc_ch/ocr_book.md

@@ -20,8 +20,7 @@
 
 
 ## 资料地址
-- [notebook教程](../../notebook/notebook_ch/)
-- [教学视频](https://aistudio.baidu.com/aistudio/education/group/info/25207)
+- [教学视频与notebook教程](https://aistudio.baidu.com/aistudio/education/group/info/25207)
 - 中文版电子书下载请扫描以下二维码入群后领取
 <div align="center">
 <img src="https://raw.githubusercontent.com/PaddlePaddle/PaddleOCR/dygraph/doc/joinus.PNG"  width = "200" height = "200" />

doc/doc_en/algorithm_overview_en.md

@@ -58,6 +58,7 @@ Supported text recognition algorithms (Click the link to get the tutorial):
 - [x]  [NRTR](./algorithm_rec_nrtr_en.md)
 - [x]  [SAR](./algorithm_rec_sar_en.md)
 - [x]  [SEED](./algorithm_rec_seed_en.md)
+- [x]  [SVTR](./algorithm_rec_svtr_en.md)
 
 Refer to [DTRB](https://arxiv.org/abs/1904.01906), the training and evaluation result of these above text recognition (using MJSynth and SynthText for training, evaluate on IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE) is as follow:
 
@@ -75,6 +76,7 @@ Refer to [DTRB](https://arxiv.org/abs/1904.01906), the training and evaluation r
 |NRTR|NRTR_MTB| 84.21% | rec_mtb_nrtr | [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/en/rec_mtb_nrtr_train.tar) |
 |SAR|Resnet31| 87.20% | rec_r31_sar | [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.1/rec/rec_r31_sar_train.tar) |
 |SEED|Aster_Resnet| 85.35% | rec_resnet_stn_bilstm_att | [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.1/rec/rec_resnet_stn_bilstm_att.tar) |
+|SVTR|SVTR-Tiny| 89.25% | rec_svtr_tiny_none_ctc_en | [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/rec_svtr_tiny_none_ctc_en_train.tar) |
 
 
 <a name="2"></a>

doc/doc_en/ocr_book_en.md

 # E-book: *Dive Into OCR*
 
-"Dive Into OCR" is a textbook that combines OCR theory and practice, written by the PaddleOCR team, Chen Zhineng, a Junior Research Fellow at Fudan University, Huang Wenhui, a senior expert in the field of vision at China Mobile Research Institute, and other industry-university-research colleagues, as well as OCR developers. The main features are as follows:
+"Dive Into OCR" is a textbook that combines OCR theory and practice, written by the PaddleOCR team, Chen Zhineng, a Pre-tenure Professor at Fudan University, Huang Wenhui, a senior expert in the field of vision at China Mobile Research Institute, and other industry-university-research colleagues, as well as OCR developers. The main features are as follows:
 
 - OCR full-stack technology covering text detection, recognition and document analysis
 - Closely integrate theory and practice, cross the code implementation gap, and supporting instructional videos
@@ -17,5 +17,4 @@
 
 ## Address
 - [E-book: *Dive Into OCR* (link generating)]()
-- [Jupyter notebook](../../notebook/notebook_en/)
-- [videos (Chinese only)](https://aistudio.baidu.com/aistudio/education/group/info/25207)
+- [Videos and Jupyter notebook (Chinese only)](https://aistudio.baidu.com/aistudio/education/group/info/25207)

notebook/notebook_ch/2.text_detection/文本检测FAQ.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# 文本检测FAQ\n",
-    "\n",
-    "本节罗列一些开发者们使用PaddleOCR的文本检测模型常遇到的一些问题，并给出相应的问题解决方法或建议。\n",
-    "\n",
-    "FAQ分两个部分来介绍，分别是：\n",
-    " - 文本检测训练相关\n",
-    " - 文本检测预测相关"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "## 1. 文本检测训练相关FAQ\n",
-    "\n",
-    "**1.1 PaddleOCR提供的文本检测算法包括哪些？**\n",
-    "\n",
-    "**A**：PaddleOCR中包含多种文本检测模型，包括基于回归的文本检测方法EAST、SAST，和基于分割的文本检测方法DB，PSENet。\n",
-    "\n",
-    "\n",
-    "**1.2：请问PaddleOCR项目中的中文超轻量和通用模型用了哪些数据集？训练多少样本，gpu什么配置，跑了多少个epoch，大概跑了多久？**\n",
-    "\n",
-    "**A**：对于超轻量DB检测模型，训练数据包括开源数据集lsvt，rctw，CASIA，CCPD，MSRA，MLT，BornDigit，iflytek，SROIE和合成的数据集等，总数据量越10W，数据集分为5个部分，训练时采用随机采样策略，在4卡V100GPU上约训练500epoch，耗时3天。\n",
-    "\n",
-    "\n",
-    "**1.3 文本检测训练标签是否需要具体文本标注，标签中的”###”是什么意思？**\n",
-    "\n",
-    "**A**：文本检测训练只需要文本区域的坐标即可，标注可以是四点或者十四点，按照左上，右上，右下，左下的顺序排列。PaddleOCR提供的标签文件中包含文本字段，对于文本区域文字不清晰会使用###代替。训练检测模型时，不会用到标签中的文本字段。\n",
-    " \n",
-    "**1.4 对于文本行较紧密的情况下训练的文本检测模型效果较差？**\n",
-    "\n",
-    "**A**：使用基于分割的方法，如DB，检测密集文本行时，最好收集一批数据进行训练，并且在训练时，并将生成二值图像的[shrink_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/ppocr/data/imaug/make_shrink_map.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L37)参数调小一些。另外，在预测的时候，可以适当减小[unclip_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/configs/det/ch_ppocr_v2.0/ch_det_mv3_db_v2.0.yml?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L59)参数，unclip_ratio参数值越大检测框就越大。\n",
-    "\n",
-    "\n",
-    "**1.5 对于一些尺寸较大的文档类图片， DB在检测时会有较多的漏检，怎么避免这种漏检的问题呢？**\n",
-    "\n",
-    "**A**：首先，需要确定是模型没有训练好的问题还是预测时处理的问题。如果是模型没有训练好，建议多加一些数据进行训练，或者在训练的时候多加一些数据增强。\n",
-    "如果是预测图像过大的问题，可以增大预测时输入的最长边设置参数[det_limit_side_len](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L47)，默认为960。\n",
-    "其次，可以通过可视化后处理的分割图观察漏检的文字是否有分割结果，如果没有分割结果，说明是模型没有训练好。如果有完整的分割区域，说明是预测后处理的问题，建议调整[DB后处理参数](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L51-L53)。\n",
-    "\n",
-    "\n",
-    "**1.6  DB模型弯曲文本（如略微形变的文档图像）漏检问题?**\n",
-    "\n",
-    "**A**: DB后处理中计算文本框平均得分时，是求rectangle区域的平均分数，容易造成弯曲文本漏检，已新增求polygon区域的平均分数，会更准确，但速度有所降低，可按需选择，在相关pr中可查看[可视化对比效果](https://github.com/PaddlePaddle/PaddleOCR/pull/2604)。该功能通过参数 [det_db_score_mode](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.1/tools/infer/utility.py#L51)进行选择，参数值可选[`fast`(默认)、`slow`]，`fast`对应原始的rectangle方式，`slow`对应polygon方式。感谢用户[buptlihang](https://github.com/buptlihang)提[pr](https://github.com/PaddlePaddle/PaddleOCR/pull/2574)帮助解决该问题。\n",
-    "\n",
-    "\n",
-    "**1.7 简单的对于精度要求不高的OCR任务，数据集需要准备多少张呢？**\n",
-    "\n",
-    "**A**：（1）训练数据的数量和需要解决问题的复杂度有关系。难度越大，精度要求越高，则数据集需求越大，而且一般情况实际中的训练数据越多效果越好。\n",
-    "\n",
-    "（2）对于精度要求不高的场景，检测任务和识别任务需要的数据量是不一样的。对于检测任务，500张图像可以保证基本的检测效果。对于识别任务，需要保证识别字典中每个字符出现在不同场景的行文本图像数目需要大于200张（举例，如果有字典中有5个字，每个字都需要出现在200张图片以上，那么最少要求的图像数量应该在200-1000张之间），这样可以保证基本的识别效果。\n",
-    "\n",
-    "\n",
-    "**1.8 当训练数据量少时，如何获取更多的数据？**\n",
-    "\n",
-    "**A**：当训练数据量少时，可以尝试以下三种方式获取更多的数据：（1）人工采集更多的训练数据，最直接也是最有效的方式。（2）基于PIL和opencv基本图像处理或者变换。例如PIL中ImageFont, Image, ImageDraw三个模块将文字写到背景中，opencv的旋转仿射变换，高斯滤波等。（3）利用数据生成算法合成数据，例如pix2pix等算法。\n",
-    "\n",
-    "\n",
-    "**1.9 如何更换文本检测/识别的backbone？**\n",
-    "\n",
-    "A：无论是文字检测，还是文字识别，骨干网络的选择是预测效果和预测效率的权衡。一般，选择更大规模的骨干网络，例如ResNet101_vd，则检测或识别更准确，但预测耗时相应也会增加。而选择更小规模的骨干网络，例如MobileNetV3_small_x0_35，则预测更快，但检测或识别的准确率会大打折扣。幸运的是不同骨干网络的检测或识别效果与在ImageNet数据集图像1000分类任务效果正相关。飞桨图像分类套件PaddleClas汇总了ResNet_vd、Res2Net、HRNet、MobileNetV3、GhostNet等23种系列的分类网络结构，在上述图像分类任务的top1识别准确率，GPU(V100和T4)和CPU(骁龙855)的预测耗时以及相应的117个预训练模型下载地址。\n",
-    "\n",
-    "（1）文字检测骨干网络的替换，主要是确定类似与ResNet的4个stages，以方便集成后续的类似FPN的检测头。此外，对于文字检测问题，使用ImageNet训练的分类预训练模型，可以加速收敛和效果提升。\n",
-    "\n",
-    "（2）文字识别的骨干网络的替换，需要注意网络宽高stride的下降位置。由于文本识别一般宽高比例很大，因此高度下降频率少一些，宽度下降频率多一些。可以参考[PaddleOCR中MobileNetV3骨干网络的改动](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/ppocr/modeling/backbones/rec_mobilenet_v3.py)。\n",
-    "\n",
-    "\n",
-    "**1.10 如何对检测模型finetune，比如冻结前面的层或某些层使用小的学习率学习？**\n",
-    "\n",
-    "**A**：如果是冻结某些层，可以将变量的stop_gradient属性设置为True，这样计算这个变量之前的所有参数都不会更新了，参考：https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/faq/train_cn.html#id4\n",
-    "\n",
-    "如果对某些层使用更小的学习率学习，静态图里还不是很方便，一个方法是在参数初始化的时候，给权重的属性设置固定的学习率，参考：https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/fluid/param_attr/ParamAttr_cn.html#paramattr\n",
-    "\n",
-    "实际上我们实验发现，直接加载模型去fine-tune，不设置某些层不同学习率，效果也都不错。\n",
-    "\n",
-    "**1.11 DB的预处理部分，图片的长和宽为什么要处理成32的倍数？**\n",
-    "\n",
-    "**A**：和网络下采样的倍数（stride）有关。以检测中的resnet骨干网络为例，图像输入网络之后，需要经过5次2倍降采样，共32倍，因此建议输入的图像尺寸为32的倍数。\n",
-    "\n",
-    "\n",
-    "**1.12 在PP-OCR系列的模型中，文本检测的骨干网络为什么没有使用SEBlock？**\n",
-    "\n",
-    "**A**：SE模块是MobileNetV3网络一个重要模块，目的是估计特征图每个特征通道重要性，给特征图每个特征分配权重，提高网络的表达能力。但是，对于文本检测，输入网络的分辨率比较大，一般是640\\*640，利用SE模块估计特征图每个特征通道重要性比较困难，网络提升能力有限，但是该模块又比较耗时，因此在PP-OCR系统中，文本检测的骨干网络没有使用SE模块。实验也表明，当去掉SE模块，超轻量模型大小可以减小40%，文本检测效果基本不受影响。详细可以参考PP-OCR技术文章，https://arxiv.org/abs/2009.09941.\n",
-    "\n",
-    "\n",
-    "**1.13 PP-OCR检测效果不好，该如何优化？**\n",
-    "\n",
-    "**A**： 具体问题具体分析:\n",
-    "- 如果在你的场景上检测效果不可用，首选是在你的数据上做finetune训练；\n",
-    "- 如果图像过大，文字过于密集，建议不要过度压缩图像，可以尝试修改检测预处理的resize逻辑，防止图像被过度压缩；\n",
-    "- 检测框大小过于紧贴文字或检测框过大，可以调整db_unclip_ratio这个参数，加大参数可以扩大检测框，减小参数可以减小检测框大小；\n",
-    "- 检测框存在很多漏检问题，可以减小DB检测后处理的阈值参数det_db_box_thresh，防止一些检测框被过滤掉，也可以尝试设置det_db_score_mode为'slow';\n",
-    "- 其他方法可以选择use_dilation为True，对检测输出的feature map做膨胀处理，一般情况下，会有效果改善；\n",
-    "\n",
-    "\n",
-    "## 2. 文本检测预测相关FAQ\n",
-    "\n",
-    "**2.1 DB有些框太贴文本了反而去掉了一些文本的边角影响识别，这个问题有什么办法可以缓解吗？**\n",
-    "\n",
-    "**A**：可以把后处理的参数[unclip_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/d80afce9b51f09fd3d90e539c40eba8eb5e50dd6/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L52)适当调大一点，该参数越大文本框越大。\n",
-    "\n",
-    "\n",
-    "**2.2 为什么PaddleOCR检测预测是只支持一张图片测试？即test_batch_size_per_card=1**\n",
-    "\n",
-    "**A**：预测的时候，对图像等比例缩放，最长边960，不同图像等比例缩放后长宽不一致，无法组成batch，所以设置为test_batch_size为1。\n",
-    "\n",
-    "\n",
-    "**2.3 在CPU上加速PaddleOCR的文本检测模型预测？**\n",
-    "\n",
-    "**A**：x86 CPU可以使用mkldnn（OneDNN）进行加速；在支持mkldnn加速的CPU上开启[enable_mkldnn](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py#L105)参数。另外，配合增加CPU上预测使用的[线程数num_threads](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py#L106)，可以有效加快CPU上的预测速度。\n",
-    "\n",
-    "**2.4 在GPU上加速PaddleOCR的文本检测模型预测？**\n",
-    "\n",
-    "**A**：GPU加速预测推荐使用TensorRT。\n",
-    "- 1. 从[链接](https://paddleinference.paddlepaddle.org.cn/master/user_guides/download_lib.html)下载带TensorRT的Paddle安装包或者预测库。\n",
-    "- 2. 从Nvidia官网下载[TensorRT](https://developer.nvidia.com/tensorrt)，注意下载的TensorRT版本与paddle安装包中编译的TensorRT版本一致。\n",
-    "- 3. 设置环境变量`LD_LIBRARY_PATH`，指向TensorRT的lib文件夹\n",
-    "```\n",
-    "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<TensorRT-${version}/lib>\n",
-    "```\n",
-    "- 4. 开启PaddleOCR预测的[tensorrt选项](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L38)。\n",
-    "\n",
-    "**2.5 如何在移动端部署PaddleOCR模型？**\n",
-    "\n",
-    "**A**: 飞桨Paddle有专门针对移动端部署的工具[PaddleLite](https://github.com/PaddlePaddle/Paddle-Lite)，并且PaddleOCR提供了DB+CRNN为demo的android arm部署代码，参考[链接](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/deploy/lite/readme.md)。\n",
-    "\n",
-    "\n",
-    "**2.6 如何使用PaddleOCR多进程预测？**\n",
-    "\n",
-    "**A**: 近期PaddleOCR新增了[多进程预测控制参数](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L111)，`use_mp`表示是否使用多进程，`total_process_num`表示在使用多进程时的进程数。具体使用方式请参考[文档](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/doc/doc_ch/inference.md#1-%E8%B6%85%E8%BD%BB%E9%87%8F%E4%B8%AD%E6%96%87ocr%E6%A8%A1%E5%9E%8B%E6%8E%A8%E7%90%86)。\n",
-    "\n",
-    "**2.7 预测时显存爆炸、内存泄漏问题？**\n",
-    "\n",
-    "**A**: 如果是训练模型的预测，由于模型太大或者输入图像太大导致显存不够用，可以参考代码在主函数运行前加上paddle.no_grad()，即可减小显存占用。如果是inference模型预测时显存占用过高，可以配置Config时，加入[config.enable_memory_optim()](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L267)用于减小内存占用。\n",
-    "\n",
-    "另外关于使用Paddle预测时出现内存泄漏的问题，建议安装paddle最新版本，内存泄漏已修复。"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "py35-paddle1.2.0"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

notebook/notebook_ch/3.text_recognition/文本识别理论部分.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "\n",
-    "# 文本识别算法理论\n",
-    "\n",
-    "本章主要介绍文本识别算法的理论知识，包括背景介绍、算法分类和部分经典论文思路。\n",
-    "\n",
-    "通过本章的学习，你可以掌握：\n",
-    "\n",
-    "1. 文本识别的目标\n",
-    "\n",
-    "2. 文本识别算法的分类\n",
-    "\n",
-    "3. 各类算法的典型思想\n",
-    "\n",
-    "\n",
-    "## 1 背景介绍\n",
-    "\n",
-    "文本识别是OCR（Optical Character Recognition）的一个子任务，其任务为识别一个固定区域的文本内容。在OCR的两阶段方法里，它接在文本检测后面，将图像信息转换为文字信息。\n",
-    "\n",
-    "具体地，模型输入一张定位好的文本行，由模型预测出图片中的文字内容和置信度，可视化结果如下图所示：\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/a7c3404f778b489db9c1f686c7d2ff4d63b67c429b454f98b91ade7b89f8e903 width=\"600\"></center>\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/e72b1d6f80c342ac951d092bc8c325149cebb3763ec849ec8a2f54e7c8ad60ca width=\"600\"></center>\n",
-    "\n",
-    "\n",
-    "文本识别的应用场景很多，有文档识别、路标识别、车牌识别、工业编号识别等等，根据实际场景可以把文本识别任务分为两个大类：**规则文本识别**和**不规则文本识别**。\n",
-    "\n",
-    "* 规则文本识别：主要指印刷字体、扫描文本等，认为文本大致处在水平线位置\n",
-    "\n",
-    "* 不规则文本识别： 往往出现在自然场景中，且由于文本曲率、方向、变形等方面差异巨大，文字往往不在水平位置，存在弯曲、遮挡、模糊等问题。\n",
-    "\n",
-    "\n",
-    "下图展示的是 IC15 和 IC13 的数据样式，它们分别代表了不规则文本和规则文本。可以看出不规则文本往往存在扭曲、模糊、字体差异大等问题，更贴近真实场景，也存在更大的挑战性。\n",
-    "\n",
-    "因此目前各大算法都试图在不规则数据集上获得更高的指标。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/bae4fce1370b4751a3779542323d0765a02a44eace7b44d2a87a241c13c6f8cf width=\"400\">\n",
-    "<br><center>IC15 图片样例（不规则文本）</center>\n",
-    "<img src=https://ai-studio-static-online.cdn.bcebos.com/b55800d3276f4f5fad170ea1b567eb770177fce226f945fba5d3247a48c15c34 width=\"400\"></center>\n",
-    "<br><center>IC13 图片样例（规则文本）</center>\n",
-    "\n",
-    "\n",
-    "不同的识别算法在对比能力时，往往也在这两大类公开数据集上比较。对比多个维度上的效果，目前较为通用的英文评估集合分类如下：\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/4d0aada261064031a16816b39a37f2ff6af70dbb57004cb7a106ae6485f14684 width=\"600\"></center>\n",
-    "\n",
-    "## 2 文本识别算法分类\n",
-    "\n",
-    "在传统的文本识别方法中，任务分为3个步骤，即图像预处理、字符分割和字符识别。需要对特定场景进行建模，一旦场景变化就会失效。面对复杂的文字背景和场景变动，基于深度学习的方法具有更优的表现。\n",
-    "\n",
-    "多数现有的识别算法可用如下统一框架表示，算法流程被划分为4个阶段：\n",
-    "\n",
-    "![](https://ai-studio-static-online.cdn.bcebos.com/a2750f4170864f69a3af36fc13db7b606d851f2f467d43cea6fbf3521e65450f)\n",
-    "\n",
-    "\n",
-    "我们整理了主流的算法类别和主要论文，参考下表：\n",
-    "\n",
-    "<center>\n",
-    "  \n",
-    "| 算法类别 | 主要思路        | 主要论文 |\n",
-    "| -------- | --------------- | -------- |\n",
-    "| 传统算法   | 滑动窗口、字符提取、动态规划    |   - |\n",
-    "| ctc      | 基于ctc的方法，序列不对齐，更快速识别 | CRNN, Rosetta |\n",
-    "| Attention    | 基于attention的方法，应用于非常规文本 | RARE, DAN, PREN |\n",
-    "| Transformer   | 基于transformer的方法             | SRN, NRTR, Master, ABINet  |\n",
-    "|  校正     |  校正模块学习文本边界并校正成水平方向       | RARE, ASTER, SAR     |   \n",
-    "| 分割 | 基于分割的方法，提取字符位置再做分类 | Text Scanner， Mask TextSpotter |\n",
-    "  \n",
-    "</center>\n",
-    "\n",
-    "\n",
-    "### 2.1 规则文本识别\n",
-    "\n",
-    "\n",
-    "文本识别的主流算法有两种，分别是基于 CTC (Conectionist Temporal Classification) 的算法和 Sequence2Sequence 算法，区别主要在解码阶段。\n",
-    "\n",
-    "基于 CTC 的算法是将编码产生的序列接入 CTC 进行解码；基于 Sequence2Sequence 的方法则是把序列接入循环神经网络(Recurrent Neural Network, RNN)模块进行循环解码，两种方式都验证有效也是主流的两大做法。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/f64eee66e4a6426f934c1befc3b138629324cf7360c74f72bd6cf3c0de9d49bd width=\"600\"></center>\n",
-    "<br><center>左：基于CTC的方法，右：基于Sequece2Sequence的方法 </center>\n",
-    "\n",
-    "\n",
-    "#### 2.1.1 基于CTC的算法\n",
-    "\n",
-    "基于 CTC 最典型的算法是CRNN (Convolutional Recurrent Neural Network)[1]，它的特征提取部分使用主流的卷积结构，常用的有ResNet、MobileNet、VGG等。由于文本识别任务的特殊性，输入数据中存在大量的上下文信息，卷积神经网络的卷积核特性使其更关注于局部信息，缺乏长依赖的建模能力，因此仅使用卷积网络很难挖掘到文本之间的上下文联系。为了解决这一问题，CRNN文本识别算法引入了双向 LSTM(Long Short-Term Memory) 用来增强上下文建模，通过实验证明双向LSTM模块可以有效的提取出图片中的上下文信息。最终将输出的特征序列输入到CTC模块，直接解码序列结果。该结构被验证有效，并广泛应用在文本识别任务中。Rosetta[2]是FaceBook提出的识别网络，由全卷积模型和CTC组成。Gao Y[3]等人使用CNN卷积替代LSTM，参数更少，性能提升精度持平。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/d3c96dd9e9794fddb12fa16f926abdd3485194f0a2b749e792e436037490899b width=\"600\"></center>\n",
-    "<center> CRNN 结构图 </center>\n",
-    "\n",
-    "\n",
-    "#### 2.1.2 Sequence2Sequence 算法\n",
-    "\n",
-    "Sequence2Sequence 算法是由编码器 Encoder 把所有的输入序列都编码成一个统一的语义向量，然后再由解码器Decoder解码。在解码器Decoder解码的过程中，不断地将前一个时刻的输出作为后一个时刻的输入，循环解码，直到输出停止符为止。一般编码器是一个RNN，对于每个输入的词，编码器输出向量和隐藏状态，并将隐藏状态用于下一个输入的单词，循环得到语义向量；解码器是另一个RNN，它接收编码器输出向量并输出一系列字以创建转换。受到 Sequence2Sequence 在翻译领域的启发， Shi[4]提出了一种基于注意的编解码框架来识别文本,通过这种方式，rnn能够从训练数据中学习隐藏在字符串中的字符级语言模型。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/f575333696b7438d919975dc218e61ccda1305b638c5497f92b46a7ec3b85243 width=\"400\" hight=\"500\"></center>\n",
-    "<center> Sequence2Sequence 结构图 </center>\n",
-    "\n",
-    "以上两个算法在规则文本上都有很不错的效果，但由于网络设计的局限性，这类方法很难解决弯曲和旋转的不规则文本识别任务。为了解决这类问题，部分算法研究人员在以上两类算法的基础上提出了一系列改进算法。\n",
-    "\n",
-    "### 2.2 不规则文本识别\n",
-    "\n",
-    "* 不规则文本识别算法可以被分为4大类：基于校正的方法；基于 Attention 的方法；基于分割的方法；基于 Transformer 的方法。\n",
-    "\n",
-    "#### 2.2.1 基于校正的方法\n",
-    "\n",
-    "基于校正的方法利用一些视觉变换模块，将非规则的文本尽量转换为规则文本，然后使用常规方法进行识别。\n",
-    "\n",
-    "RARE[4]模型首先提出了对不规则文本的校正方案，整个网络分为两个主要部分：一个空间变换网络STN(Spatial Transformer Network) 和一个基于Sequence2Squence的识别网络。其中STN就是校正模块，不规则文本图像进入STN，通过TPS(Thin-Plate-Spline)变换成一个水平方向的图像，该变换可以一定程度上校正弯曲、透射变换的文本，校正后送入序列识别网络进行解码。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/66406f89507245e8a57969b9bed26bfe0227a8cf17a84873902dd4a464b97bb5 width=\"600\"></center>\n",
-    "<center> RARE 结构图 </center>\n",
-    "\n",
-    "RARE论文指出，该方法在不规则文本数据集上有较大的优势，特别比较了CUTE80和SVTP这两个数据集，相较CRNN高出5个百分点以上，证明了校正模块的有效性。基于此[6]同样结合了空间变换网络(STN)和基于注意的序列识别网络的文本识别系统。\n",
-    "\n",
-    "基于校正的方法有较好的迁移性，除了RARE这类基于Attention的方法外，STAR-Net[5]将校正模块应用到基于CTC的算法上，相比传统CRNN也有很好的提升。\n",
-    "\n",
-    "#### 2.2.2 基于Attention的方法\n",
-    "\n",
-    "基于 Attention 的方法主要关注的是序列之间各部分的相关性，该方法最早在机器翻译领域提出，认为在文本翻译的过程中当前词的结果主要由某几个单词影响的，因此需要给有决定性的单词更大的权重。在文本识别领域也是如此，将编码后的序列解码时，每一步都选择恰当的context来生成下一个状态，这样有利于得到更准确的结果。\n",
-    "\n",
-    "R^2AM [7] 首次将 Attention 引入文本识别领域，该模型首先将输入图像通过递归卷积层提取编码后的图像特征，然后利用隐式学习到的字符级语言统计信息通过递归神经网络解码输出字符。在解码过程中引入了Attention 机制实现了软特征选择，以更好地利用图像特征，这一有选择性的处理方式更符合人类的直觉。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/a64ef10d4082422c8ac81dcda4ab75bf1db285d6b5fd462a8f309240445654d5 width=\"600\"></center>\n",
-    "<center> R^2AM 结构图 </center>\n",
-    "\n",
-    "后续有大量算法在Attention领域进行探索和更新，例如SAR[8]将1D attention拓展到2D attention上，校正模块提到的RARE也是基于Attention的方法。实验证明基于Attention的方法相比CTC的方法有很好的精度提升。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/4e2507fb58d94ec7a9b4d17151a986c84c5053114e05440cb1e7df423d32cb02 width=\"600\"></center>\n",
-    "\n",
-    "\n",
-    "#### 2.2.3 基于分割的方法\n",
-    "\n",
-    "基于分割的方法是将文本行的各字符作为独立个体，相比与对整个文本行做矫正后识别，识别分割出的单个字符更加容易。它试图从输入的文本图像中定位每个字符的位置，并应用字符分类器来获得这些识别结果，将复杂的全局问题简化成了局部问题解决，在不规则文本场景下有比较不错的效果。然而这种方法需要字符级别的标注，数据获取上存在一定的难度。Lyu[9]等人提出了一种用于单词识别的实例分词模型，该模型在其识别部分使用了基于 FCN(Fully Convolutional Network) 的方法。[10]从二维角度考虑文本识别问题，设计了一个字符注意FCN来解决文本识别问题，当文本弯曲或严重扭曲时，该方法对规则文本和非规则文本都具有较优的定位结果。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/fd3e8ef0d6ce4249b01c072de31297ca5d02fc84649846388f890163b624ff10 width=\"800\"></center>\n",
-    "<center> Mask TextSpotter 结构图 </center>\n",
-    "\n",
-    "\n",
-    "\n",
-    "#### 2.2.4 基于Transformer的方法\n",
-    "\n",
-    "随着 Transformer 的快速发展，分类和检测领域都验证了 Transformer 在视觉任务中的有效性。如规则文本识别部分所说，CNN在长依赖建模上存在局限性，Transformer 结构恰好解决了这一问题，它可以在特征提取器中关注全局信息，并且可以替换额外的上下文建模模块（LSTM）。\n",
-    "\n",
-    "一部分文本识别算法使用 Transformer 的 Encoder 结构和卷积共同提取序列特征，Encoder 由多个 MultiHeadAttentionLayer 和 Positionwise Feedforward Layer 堆叠而成的block组成。MulitHeadAttention 中的 self-attention 利用矩阵乘法模拟了RNN的时序计算，打破了RNN中时序长时依赖的障碍。也有一部分算法使用 Transformer 的 Decoder 模块解码，相比传统RNN可获得更强的语义信息，同时并行计算具有更高的效率。\n",
-    "\n",
-    "SRN[11] 算法将Transformer的Encoder模块接在ResNet50后，增强了2D视觉特征。并提出了一个并行注意力模块，将读取顺序用作查询，使得计算与时间无关，最终并行输出所有时间步长的对齐视觉特征。此外SRN还利用Transformer的Eecoder作为语义模块，将图片的视觉信息和语义信息做融合，在遮挡、模糊等不规则文本上有较大的收益。\n",
-    "\n",
-    "NRTR[12] 使用了完整的Transformer结构对输入图片进行编码和解码，只使用了简单的几个卷积层做高层特征提取，在文本识别上验证了Transformer结构的有效性。\n",
-    "\n",
-    "<center><img src=https://ai-studio-static-online.cdn.bcebos.com/e7859f4469a842f0bd450e7e793a679d6e828007544241d09785c9b4ea2424a2 width=\"800\"></center>\n",
-    "<center> NRTR 结构图 </center>\n",
-    "\n",
-    "SRACN[13]使用Transformer的解码器替换LSTM，再一次验证了并行训练的高效性和精度优势。\n",
-    "\n",
-    "## 3 总结\n",
-    "\n",
-    "本节主要介绍了文本识别相关的理论知识和主流算法，包括基于CTC的方法、基于Sequence2Sequence的方法以及基于分割的方法，并分别列举了经典论文的思路和贡献。下一节将基于CRNN算法进行实践课程讲解，从组网到优化完成整个训练过程，\n",
-    "\n",
-    "## 4  参考文献\n",
-    "\n",
-    "\n",
-    "[1]Shi, B., Bai, X., & Yao, C. (2016). An end-to-end trainable neural network for image-based sequence recognition and its application to scene text recognition. IEEE transactions on pattern analysis and machine intelligence, 39(11), 2298-2304.\n",
-    "\n",
-    "[2]Fedor Borisyuk, Albert Gordo, and Viswanath Sivakumar. Rosetta: Large scale system for text detection and recognition in images. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 71–79. ACM, 2018.\n",
-    "\n",
-    "[3]Gao, Y., Chen, Y., Wang, J., & Lu, H. (2017). Reading scene text with attention convolutional sequence modeling. arXiv preprint arXiv:1709.04303.\n",
-    "\n",
-    "[4]Shi, B., Wang, X., Lyu, P., Yao, C., & Bai, X. (2016). Robust scene text recognition with automatic rectification. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 4168-4176).\n",
-    "\n",
-    "[5] Star-Net  Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spa- tial transformer networks. In Advances in neural information processing systems, pages 2017–2025, 2015.\n",
-    "\n",
-    "[6]Baoguang Shi, Mingkun Yang, XingGang Wang, Pengyuan Lyu, Xiang Bai, and Cong Yao. Aster: An attentional scene text recognizer with flexible rectification. IEEE transactions on pattern analysis and machine intelligence, 31(11):855–868, 2018.\n",
-    "\n",
-    "[7] Lee C Y ,  Osindero S . Recursive Recurrent Nets with Attention Modeling for OCR in the Wild[C]// IEEE Conference on Computer Vision & Pattern Recognition. IEEE, 2016.\n",
-    "\n",
-    "[8]Li, H., Wang, P., Shen, C., & Zhang, G. (2019, July). Show, attend and read: A simple and strong baseline for irregular text recognition. In Proceedings of the AAAI Conference on Artificial Intelligence (Vol. 33, No. 01, pp. 8610-8617).\n",
-    "\n",
-    "[9]P. Lyu, C. Yao, W. Wu, S. Yan, and X. Bai. Multi-oriented scene text detection via corner localization and region segmentation. In Proc. CVPR, pages 7553–7563, 2018.\n",
-    "\n",
-    "[10] Liao, M., Zhang, J., Wan, Z., Xie, F., Liang, J., Lyu, P., ... & Bai, X. (2019, July). Scene text recognition from two-dimensional perspective. In Proceedings of the AAAI Conference on Artificial Intelligence (Vol. 33, No. 01, pp. 8714-8721).\n",
-    "\n",
-    "[11] Yu, D., Li, X., Zhang, C., Liu, T., Han, J., Liu, J., & Ding, E. (2020). Towards accurate scene text recognition with semantic reasoning networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 12113-12122).\n",
-    "\n",
-    "[12] Sheng, F., Chen, Z., & Xu, B. (2019, September). NRTR: A no-recurrence sequence-to-sequence model for scene text recognition. In 2019 International Conference on Document Analysis and Recognition (ICDAR) (pp. 781-786). IEEE.\n",
-    "\n",
-    "[13]Yang, L., Wang, P., Li, H., Li, Z., & Zhang, Y. (2020). A holistic representation guided attention network for scene text recognition. Neurocomputing, 414, 67-75.\n",
-    "\n",
-    "[14]Wang, T., Zhu, Y., Jin, L., Luo, C., Chen, X., Wu, Y., ... & Cai, M. (2020, April). Decoupled attention network for text recognition. In Proceedings of the AAAI Conference on Artificial Intelligence (Vol. 34, No. 07, pp. 12216-12224).\n",
-    "\n",
-    "[15] Wang, Y., Xie, H., Fang, S., Wang, J., Zhu, S., & Zhang, Y. (2021). From two to one: A new scene text recognizer with visual language modeling network. In Proceedings of the IEEE/CVF International Conference on Computer Vision (pp. 14194-14203).\n",
-    "\n",
-    "[16] Fang, S., Xie, H., Wang, Y., Mao, Z., & Zhang, Y. (2021). Read Like Humans: Autonomous, Bidirectional and Iterative Language Modeling for Scene Text Recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 7098-7107).\n",
-    "\n",
-    "[17] Yan, R., Peng, L., Xiao, S., & Yao, G. (2021). Primitive Representation Learning for Scene Text Recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 284-293)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "py35-paddle1.2.0"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

notebook/notebook_ch/如何使用本书.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# 1. 课程预备知识\n",
-    "\n",
-    "本课所涉及的OCR模型建立在深度学习的基础之上，因此与其相关的基础知识、环境配置、项目工程与其他资料将在本节介绍，尤其对深度学习不熟悉的读者可以查看和学习相应内容。\n",
-    "\n",
-    "### 1.1 预备知识\n",
-    "\n",
-    "深度学习的“学习”由机器学习中的神经元、感知机、多层神经网络等内容一路发展而来，因此了解基础的机器学习算法对于深度学习的理解和应用有很大帮助。而深度学习的“深”则体现在对大量信息处理过程中使用的卷积、池化等一系列以向量为基础的数学运算。如果缺乏这两者的理论基础，可以学习李宏毅老师的[线性代数](https://aistudio.baidu.com/aistudio/course/introduce/2063)和[机器学习](https://aistudio.baidu.com/aistudio/course/introduce/1978)课程。\n",
-    "\n",
-    "对于深度学习本身的理解，可以参考百度杰出架构师毕然老师的零基础课程：[百度架构师手把手带你零基础实践深度学习](https://aistudio.baidu.com/aistudio/course/introduce/1297)，其中覆盖了深度学习的发展历史，通过一个经典案例介绍深度学习的完整组成部分，是一套以实践为导向的深度学习课程。\n",
-    "\n",
-    "对于理论知识的实践，[Python基础知识](https://aistudio.baidu.com/aistudio/course/introduce/1224)必不可少，同时为了快速复现深度学习模型，本课程使用的深度学习框架为：飞桨PaddlePaddle。如果你已经使用过其他框架，通过[快速上手文档](https://www.paddlepaddle.org.cn/documentation/docs/zh/practices/quick_start/hello_paddle.html)可以迅速了解飞桨的使用方法。\n",
-    "\n",
-    "### 1.2 基础环境准备\n",
-    "\n",
-    "如果你想在本地环境运行本课程的代码且之前未搭建过Python环境，可以根据[零基础运行环境准备](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.3/doc/doc_ch/environment.md)，根据自己的操作系统安装Anaconda或docker环境。\n",
-    "\n",
-    "如果你没有本地资源，可以通过AI Studio实训平台完成代码运行，其中的每个项目都通过Notebook的方式呈现，方便开发者学习。若对Notebook的相关操作不熟悉，可以参考[AI Studio项目说明](https://ai.baidu.com/ai-doc/AISTUDIO/0k3e2tfzm)。\n",
-    "\n",
-    "### 1.3 获取和运行代码\n",
-    "\n",
-    "本课程依托PaddleOCR的代码库形成，首先，克隆PaddleOCR的完整项目：\n",
-    "\n",
-    "```bash\n",
-    "#【推荐】\n",
-    "git clone https://github.com/PaddlePaddle/PaddleOCR\n",
-    "\n",
-    "# 如果因为网络问题无法pull成功，也可选择使用码云上的托管：\n",
-    "git clone https://gitee.com/paddlepaddle/PaddleOCR\n",
-    "```\n",
-    "\n",
-    "> 注：码云托管代码可能无法实时同步本github项目更新，存在3~5天延时，请优先使用推荐方式。\n",
-    ">\n",
-    "> ​\t\t如果你不熟悉git操作，可以直接在PaddleOCR的首页的 `Code` 中下载压缩包\n",
-    "\n",
-    "然后安装第三方库：\n",
-    "\n",
-    "```bash\n",
-    "cd PaddleOCR\n",
-    "pip3 install -r requirements.txt\n",
-    "```\n",
-    "\n",
-    "\n",
-    "\n",
-    "### 1.4 查阅资料\n",
-    "\n",
-    "[PaddleOCR使用文档](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.3/README_ch.md#%E6%96%87%E6%A1%A3%E6%95%99%E7%A8%8B) (中文) 中详细介绍了如何使用PaddleOCR完成模型应用、训练和部署。文档内容丰富，大多数用户的问题都在文档或FAQ中有所描述，尤其在[FAQ(中文)](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.3/doc/doc_ch/FAQ.md)中，按照深度学习的应用过程沉淀了用户的常见问题，建议大家仔细阅读。\n",
-    "\n",
-    "### 1.5 寻求帮助\n",
-    "\n",
-    "如果你在使用PaddleOCR的过程中遇到BUG、易用性或者文档相关的问题，可通过[Github issue](https://github.com/PaddlePaddle/PaddleOCR/issues)与官方联系，请按照issue模板尽可能多的提供信息，以便官方人员迅速定位问题。同时，微信群是广大PaddleOCR用户的日常交流阵地，更适合提问一些咨询类问题，除了有PaddleOCR团队成员以外，还会有热心开发者回答大家的问题。"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "py35-paddle1.2.0"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

notebook/notebook_en/2.text_detection/text_detection_FAQ.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Text detection FAQ\n",
-    "\n",
-    "This section lists some of the problems that developers often encounter when using PaddleOCR's text detection model, and gives corresponding solutions or suggestions.\n",
-    "\n",
-    "The FAQ is introduced in two parts, namely:\n",
-    "  -Text detection training related\n",
-    "  -Text detection and prediction related"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. FAQ about Text Detection Training\n",
-    "\n",
-    "**1.1 What are the text detection algorithms provided by PaddleOCR?**\n",
-    "\n",
-    "**A**: PaddleOCR contains a variety of text detection models, including regression-based text detection methods EAST and SAST, and segmentation-based text detection methods DB, PSENet.\n",
-    "\n",
-    "\n",
-    "**1.2: What data sets are used in the Chinese ultra-lightweight and general models in the PaddleOCR project? How many samples were trained, what configuration of GPUs, how many epochs were run, and how long did they run?**\n",
-    "\n",
-    "**A**: For the ultra-lightweight DB detection model, the training data includes open source data sets lsvt, rctw, CASIA, CCPD, MSRA, MLT, BornDigit, iflytek, SROIE and synthetic data sets, etc. The total data volume is 10W, The data set is divided into 5 parts. A random sampling strategy is used during training. The training takes about 500 epochs on a 4-card V100GPU, which takes 3 days.\n",
-    "\n",
-    "\n",
-    "**1.3 Does the text detection training label require specific text labeling? What does the \"###\" in the label mean?**\n",
-    "\n",
-    "**A**: Text detection training only needs the coordinates of the text area. The label can be four or fourteen points, arranged in the order of upper left, upper right, lower right, and lower left. The label file provided by PaddleOCR contains text fields. For unclear text in the text area, ### will be used instead. When training the detection model, the text field in the label will not be used.\n",
-    " \n",
-    "**1.4 Is the effect of the text detection model trained when the text lines are tight?**\n",
-    "\n",
-    "**A**: When using segmentation-based methods, such as DB, to detect dense text lines, it is best to collect a batch of data for training, and during training, a binary image will be generated [shrink_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/ppocr/data/imaug/make_shrink_map.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L37)Turn down the parameter. In addition, when forecasting, you can appropriately reduce [unclip_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/configs/det/ch_ppocr_v2.0/ch_det_mv3_db_v2.0.yml?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L59) parameter, the larger the unclip_ratio parameter value, the larger the detection frame.\n",
-    "\n",
-    "\n",
-    "**1.5 For some large-sized document images, DB will have more missed inspections during inspection. How to avoid this kind of missed inspections?**\n",
-    "\n",
-    "**A**: First of all, you need to determine whether the model is not well-trained or is the problem handled during prediction. If the model is not well trained, it is recommended to add more data for training, or add more data to enhance it during training.\n",
-    "If the problem is that the predicted image is too large, you can increase the longest side setting parameter [det_limit_side_len] entered during prediction [det_limit_side_len](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L47), which is 960 by default.\n",
-    "Secondly, you can observe whether the missed text has segmentation results by visualizing the post-processed segmentation map. If there is no segmentation result, the model is not well trained. If there is a complete segmentation area, it means that it is a problem of post-prediction processing. In this case, it is recommended to adjust [DB post-processing parameters](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L51-L53)。\n",
-    "\n",
-    "\n",
-    "**1.6 The problem of missed detection of DB model bending text (such as a slightly deformed document image)?**\n",
-    "\n",
-    "**A**: When calculating the average score of the text box in the DB post-processing, it is the average score of the rectangle area, which is easy to cause the missed detection of the curved text. The average score of the polygon area has been added, which will be more accurate, but the speed is somewhat different. Decrease, can be selected as needed, and you can view the [Visual Contrast Effect] (https://github.com/PaddlePaddle/PaddleOCR/pull/2604) in the relevant pr. This function is selected by the parameter [det_db_score_mode](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.1/tools/infer/utility.py#L51), the parameter value is optional [`fast` (default) , `slow`], `fast` corresponds to the original rectangle mode, and `slow` corresponds to the polygon mode. Thanks to the user [buptlihang](https://github.com/buptlihang) for mentioning [pr](https://github.com/PaddlePaddle/PaddleOCR/pull/2574) to help solve this problem.\n",
-    "\n",
-    "\n",
-    "**1.7 For simple OCR tasks with low accuracy requirements, how many data sets do I need to prepare?**\n",
-    "\n",
-    "**A**: (1) The amount of training data is related to the complexity of the problem to be solved. The greater the difficulty and the higher the accuracy requirements, the greater the data set requirements, and in general, the more training data in practice, the better the effect.\n",
-    "\n",
-    "(2) For scenes with low accuracy requirements, the amount of data required for detection tasks and recognition tasks is different. For inspection tasks, 500 images can guarantee the basic inspection results. For recognition tasks, it is necessary to ensure that the number of line text images in which each character in the recognition dictionary appears in different scenes needs to be greater than 200 (for example, if there are 5 words in the dictionary, each word needs to appear in more than 200 pictures, then The minimum required number of images should be between 200-1000), so that the basic recognition effect can be guaranteed.\n",
-    "\n",
-    "\n",
-    "**1.8 How to get more data when the amount of training data is small?**\n",
-    "\n",
-    "**A**: When the amount of training data is small, you can try the following three ways to get more data: (1) Collect more training data manually, the most direct and effective way. (2) Basic image processing or transformation based on PIL and opencv. For example, the three modules of ImageFont, Image, ImageDraw in PIL write text into the background, opencv's rotating affine transformation, Gaussian filtering and so on. (3) Synthesize data using data generation algorithms, such as algorithms such as pix2pix.\n",
-    "\n",
-    "\n",
-    "**1.9 How to replace the backbone of text detection/recognition?**\n",
-    "\n",
-    "A: Whether it is text detection or text recognition, the choice of backbone network is a trade-off between prediction effect and prediction efficiency. Generally, if you choose a larger-scale backbone network, such as ResNet101_vd, the detection or recognition will be more accurate, but the prediction time will increase accordingly. However, choosing a smaller-scale backbone network, such as MobileNetV3_small_x0_35, will predict faster, but the accuracy of detection or recognition will be greatly reduced. Fortunately, the detection or recognition effects of different backbone networks are positively correlated with the image 1000 classification task in the ImageNet dataset. PaddleClas, a flying paddle image classification suite, summarizes 23 series of classification network structures such as ResNet_vd, Res2Net, HRNet, MobileNetV3, GhostNet, etc. The top1 recognition accuracy rate of the above image classification task, GPU (V100 and T4) and CPU (Snapdragon 855) The prediction time-consuming and the corresponding 117 pre-training model download addresses.\n",
-    "\n",
-    "(1) The replacement of the text detection backbone network is mainly to determine 4 stages similar to ResNet to facilitate the integration of subsequent detection heads similar to FPN. In addition, for the text detection problem, the classification pre-training model trained by ImageNet can accelerate the convergence and improve the effect.\n",
-    "\n",
-    "(2) The replacement of the backbone network for text recognition requires attention to the drop position of the network width and height stride. Since text recognition generally has a large ratio of width to height, the frequency of height reduction is less, and the frequency of width reduction is more. You can refer to [Changes to the MobileNetV3 backbone network in PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/ppocr/modeling/backbones/rec_mobilenet_v3.py)。\n",
-    "\n",
-    "\n",
-    "**1.10 How to finetune the detection model, such as freezing the previous layer or learning with a small learning rate for some layers?**\n",
-    "\n",
-    "**A**: If you freeze certain layers, you can set the stop_gradient property of the variable to True, so that all the parameters before calculating this variable will not be updated, refer to: https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/faq/train_cn.html#id4\n",
-    "\n",
-    "If learning with a smaller learning rate for some layers is not very convenient in the static graph, one method is to set a fixed learning rate for the weight attribute when the parameters are initialized, refer to: https://www.paddlepaddle.org.cn/documentation/docs/en/develop/api/paddle/fluid/param_attr/ParamAttr_cn.html#paramattr\n",
-    "\n",
-    "In fact, our experiment found that directly loading the model to fine-tune without setting different learning rates of certain layers, the effect is also good.\n",
-    "\n",
-    "**1.11 In the preprocessing part of DB, why should the length and width of the picture be processed into multiples of 32?**\n",
-    "\n",
-    "**A**: It is related to the stride of the network downsampling. Take the resnet backbone network under inspection as an example. After the image is input to the network, it needs to be downsampled by 2 times for 5 times, a total of 32 times. Therefore, it is recommended that the input image size be a multiple of 32.\n",
-    "\n",
-    "\n",
-    "**1.12 In the PP-OCR series models, why does the backbone network for text detection not use SEBlock?**\n",
-    "\n",
-    "**A**: The SE module is an important module of the MobileNetV3 network. Its purpose is to estimate the importance of each feature channel of the feature map, assign weights to each feature of the feature map, and improve the expressive ability of the network. However, for text detection, the resolution of the input network is relatively large, generally 640\\*640. It is difficult to use the SE module to estimate the importance of each feature channel of the feature map. The network improvement ability is limited, but the module is relatively time-consuming. In the PP-OCR system, the backbone network for text detection does not use the SE module. Experiments also show that when the SE module is removed, the size of the ultra-lightweight model can be reduced by 40%, and the text detection effect is basically not affected. For details, please refer to the PP-OCR technical article, https://arxiv.org/abs/2009.09941.\n",
-    "\n",
-    "\n",
-    "**1.13 The PP-OCR detection effect is not good, how to optimize it?**\n",
-    "\n",
-    "**A**: Specific analysis of specific issues:\n",
-    "- If the detection effect is not available on your scene, the first choice is to do finetune training on your data;\n",
-    "- If the image is too large and the text is too dense, it is recommended not to over-compress the image. You can try to modify the resize logic of the detection preprocessing to prevent the image from being over-compressed;\n",
-    "- The size of the detection frame is too close to the text or the detection frame is too large, you can adjust the db_unclip_ratio parameter, increasing the parameter can enlarge the detection frame, and reducing the parameter can reduce the size of the detection frame;\n",
-    "- There are many missed detection problems in the detection frame, which can reduce the threshold parameter det_db_box_thresh for DB detection to prevent some detection frames from being filtered out. You can also try to set det_db_score_mode to'slow';\n",
-    "- Other methods can choose use_dilation as True to expand the feature map of the detection output. In general, the effect will be improved.\n",
-    "\n",
-    "\n",
-    "## 2. FAQ about Text Detection and Prediction\n",
-    "\n",
-    "**2.1 In DB, some boxes are too pasted with text, but some corners of the text are removed to affect the recognition. Is there any way to alleviate this problem?**\n",
-    "\n",
-    "**A**: The post-processing parameter [unclip_ratio](https://github.com/PaddlePaddle/PaddleOCR/blob/d80afce9b51f09fd3d90e539c40eba8eb5e50dd6/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L52) can be appropriately increased. the larger the parameter, the larger the text box.\n",
-    "\n",
-    "\n",
-    "**2.2 Why does the PaddleOCR detection prediction only support one image test? That is, test_batch_size_per_card=1**\n",
-    "\n",
-    "**A**: When predicting, the image is scaled in equal proportions, the longest side is 960, and the length and width of different images after scaling in equal proportions are inconsistent, and they cannot form a batch, so set test_batch_size to 1.\n",
-    "\n",
-    "\n",
-    "**2.3 Accelerate PaddleOCR's text detection model prediction on the CPU?**\n",
-    "\n",
-    "**A**: x86 CPU can use mkldnn (OneDNN) for acceleration; enable [enable_mkldnn](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py#L105) Parameters. In addition, in conjunction with increasing the number of threads used for prediction on the CPU, [num_threads](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py#L106) can effectively speed up the prediction speed on the CPU.\n",
-    "\n",
-    "**2.4 Accelerate PaddleOCR's text detection model prediction on GPU?**\n",
-    "\n",
-    "**A**: TensorRT is recommended for GPU accelerated prediction.\n",
-    "- 1. Download the Paddle installation package or prediction library with TensorRT from [link](https://paddleinference.paddlepaddle.org.cn/master/user_guides/download_lib.html).\n",
-    "- 2. Download the [TensorRT](https://developer.nvidia.com/tensorrt) from the Nvidia official website. Note that the downloaded TensorRT version is consistent with the TensorRT version compiled in the paddle installation package.\n",
-    "- 3. Set the environment variable `LD_LIBRARY_PATH` to point to the lib folder of TensorRT\n",
-    "```\n",
-    "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<TensorRT-${version}/lib>\n",
-    "```\n",
-    "- 4. Enable [tensorrt option](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L38).\n",
-    "\n",
-    "**2.5 How to deploy PaddleOCR model on the mobile terminal?**\n",
-    "\n",
-    "**A**: Flying Oar Paddle has a special tool for mobile deployment [PaddleLite](https://github.com/PaddlePaddle/Paddle-Lite), and PaddleOCR provides DB+CRNN as the demo android arm deployment code , Refer to [link](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/deploy/lite/readme.md).\n",
-    "\n",
-    "\n",
-    "**2.6 How to use PaddleOCR multi-process prediction?**\n",
-    "\n",
-    "**A**: PaddleOCR recently added [Multi-Process Predictive Control Parameters](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L111), `use_mp` indicates whether When using multiple processes, `total_process_num` indicates the number of processes when using multiple processes. For specific usage, please refer to [document](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/doc/doc_ch/inference.md#1-%E8%B6%85%E8%BD%BB%E9%87%8F%E4%B8%AD%E6%96%87ocr%E6%A8%A1%E5%9E%8B%E6%8E%A8%E7%90%86).\n",
-    "\n",
-    "**2.7 Video memory explosion and memory leak during prediction?**\n",
-    "\n",
-    "**A**: If it is the prediction of the training model, the video memory is not enough because the model is too large or the input image is too large, you can refer to the code and add paddle.no_grad() before the main function runs to reduce the video memory usage. If the memory usage of the inference model is too high, you can add [config.enable_memory_optim()](https://github.com/PaddlePaddle/PaddleOCR/blob/8b656a3e13631dfb1ac21d2095d4d4a4993ef710/tools/infer/utility.py?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L267) to reduce the memory usage when configuring Config.\n",
-    "\n",
-    "In addition, regarding the memory leak when using Paddle to predict, it is recommended to install the latest version of paddle. The memory leak has been fixed."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

notebook/notebook_en/how_to_use_these_notebooks.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# 1. Course Prerequisites\n",
-    "\n",
-    "The OCR model involved in this course is based on deep learning, so its related basic knowledge, environment configuration, project engineering and other materials will be introduced in this section, especially for readers who are not familiar with deep learning. content.\n",
-    "\n",
-    "### 1.1 Preliminary Knowledge\n",
-    "\n",
-    "The \"learning\" of deep learning has been developed from the content of neurons, perceptrons, and multilayer neural networks in machine learning. Therefore, understanding the basic machine learning algorithms is of great help to the understanding and application of deep learning. The \"deepness\" of deep learning is embodied in a series of vector-based mathematical operations such as convolution and pooling used in the process of processing a large amount of information. If you lack the theoretical foundation of the two, you can learn from teacher Li Hongyi's [Linear Algebra](https://aistudio.baidu.com/aistudio/course/introduce/2063) and [Machine Learning](https://aistudio.baidu.com/aistudio/course/introduce/1978) courses.\n",
-    "\n",
-    "For the understanding of deep learning itself, you can refer to the zero-based course of Bai Ran, an outstanding architect of Baidu: [Baidu architects take you hands-on with zero-based practice deep learning](https://aistudio.baidu.com/aistudio/course/introduce/1297), which covers the development history of deep learning and introduces the complete components of deep learning through a classic case. It is a set of practice-oriented deep learning courses.\n",
-    "\n",
-    "For the practice of theoretical knowledge, [Python basic knowledge](https://aistudio.baidu.com/aistudio/course/introduce/1224) is essential. At the same time, in order to quickly reproduce the deep learning model, the deep learning framework used in this course For: Flying PaddlePaddle. If you have used other frameworks, you can quickly learn how to use flying paddles through [Quick Start Document](https://www.paddlepaddle.org.cn/documentation/docs/zh/practices/quick_start/hello_paddle.html).\n",
-    "\n",
-    "### 1.2 Basic Environment Preparation\n",
-    "\n",
-    "If you want to run the code of this course in a local environment and have not built a Python environment before, you can follow the [zero-base operating environment preparation](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.3/doc/doc_ch/environment.md), install Anaconda or docker environment according to your operating system.\n",
-    "\n",
-    "If you don't have local resources, you can run the code through the AI Studio training platform. Each item in it is presented in a notebook, which is convenient for developers to learn. If you are not familiar with the related operations of Notebook, you can refer to [AI Studio Project Description](https://ai.baidu.com/ai-doc/AISTUDIO/0k3e2tfzm).\n",
-    "\n",
-    "### 1.3 Get and Run the Code\n",
-    "\n",
-    "This course relies on the formation of PaddleOCR's code repository. First, clone the complete project of PaddleOCR:\n",
-    "\n",
-    "```bash\n",
-    "# [recommend]\n",
-    "git clone https://github.com/PaddlePaddle/PaddleOCR\n",
-    "\n",
-    "# If you cannot pull successfully due to network problems, you can also choose to use the hosting on Code Cloud:\n",
-    "git clone https://gitee.com/paddlepaddle/PaddleOCR\n",
-    "```\n",
-    "\n",
-    "> Note: The code cloud hosted code may not be able to synchronize the update of this github project in real time, there is a delay of 3~5 days, please use the recommended method first.\n",
-    ">\n",
-    "> If you are not familiar with git operations, you can download the compressed package directly from the `Code` on the homepage of PaddleOCR\n",
-    "\n",
-    "Then install third-party libraries:\n",
-    "\n",
-    "```bash\n",
-    "cd PaddleOCR\n",
-    "pip3 install -r requirements.txt\n",
-    "```\n",
-    "\n",
-    "\n",
-    "\n",
-    "### 1.4 Access to Information\n",
-    "\n",
-    "[PaddleOCR Usage Document](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.3/README.md) describes in detail how to use PaddleOCR to complete model application, training and deployment. The document is rich in content, most of the user’s questions are described in the document or FAQ, especially in [FAQ](https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.3/doc/doc_en/FAQ_en.md), in accordance with the application process of deep learning, has precipitated the user's common questions, it is recommended that you read it carefully.\n",
-    "\n",
-    "### 1.5 Ask for Help\n",
-    "\n",
-    "If you encounter BUG, ease of use or documentation related issues while using PaddleOCR, you can contact the official via [Github issue](https://github.com/PaddlePaddle/PaddleOCR/issues), please follow the issue template Provide as much information as possible so that official personnel can quickly locate the problem. At the same time, the WeChat group is the daily communication position for the majority of PaddleOCR users, and it is more suitable for asking some consulting questions. In addition to the PaddleOCR team members, there will also be enthusiastic developers answering your questions."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "py35-paddle1.2.0"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

paddleocr.py

@@ -47,8 +47,8 @@ __all__ = [
 ]
 
 SUPPORT_DET_MODEL = ['DB']
-VERSION = '2.5.0.1'
-SUPPORT_REC_MODEL = ['CRNN']
+VERSION = '2.5.0.3'
+SUPPORT_REC_MODEL = ['CRNN', 'SVTR_LCNet']
 BASE_DIR = os.path.expanduser("~/.paddleocr/")
 
 DEFAULT_OCR_MODEL_VERSION = 'PP-OCRv3'

ppstructure/README.md

@@ -40,7 +40,7 @@ The main features of PP-Structure are as follows:
 
 ### 4.1 Layout analysis and table recognition
 
-<img src="../doc/table/ppstructure.GIF" width="100%"/>
+<img src="docs/table/ppstructure.GIF" width="100%"/>
 
 The figure shows the pipeline of layout analysis + table recognition. The image is first divided into four areas of image, text, title and table by layout analysis, and then OCR detection and recognition is performed on the three areas of image, text and title, and the table is performed table recognition, where the image will also be stored for use.
 
@@ -48,7 +48,7 @@ The figure shows the pipeline of layout analysis + table recognition. The image
 
 * SER
 *
-![](../doc/vqa/result_ser/zh_val_0_ser.jpg) | ![](../doc/vqa/result_ser/zh_val_42_ser.jpg)
+![](docs/vqa/result_ser/zh_val_0_ser.jpg) | ![](docs/vqa/result_ser/zh_val_42_ser.jpg)
 ---|---
 
 Different colored boxes in the figure represent different categories. For xfun dataset, there are three categories: query, answer and header:
@@ -62,7 +62,7 @@ The corresponding category and OCR recognition results are also marked at the to
 
 * RE
 
-![](../doc/vqa/result_re/zh_val_21_re.jpg) | ![](../doc/vqa/result_re/zh_val_40_re.jpg)
+![](docs/vqa/result_re/zh_val_21_re.jpg) | ![](docs/vqa/result_re/zh_val_40_re.jpg)
 ---|---
 
 
@@ -76,7 +76,7 @@ Start from [Quick Installation](./docs/quickstart.md)
 
 ### 6.1 Layout analysis and table recognition
 
-![pipeline](../doc/table/pipeline.jpg)
+![pipeline](docs/table/pipeline.jpg)
 
 In PP-Structure, the image will be divided into 5 types of areas **text, title, image list and table**. For the first 4 types of areas, directly use PP-OCR system to complete the text detection and recognition. For the table area, after the table structuring process, the table in image is converted into an Excel file with the same table style.
 

tools/infer/predict_rec.py

@@ -131,7 +131,7 @@ class TextRecognizer(object):
         padding_im = np.zeros((imgC, imgH, imgW), dtype=np.float32)
         padding_im[:, :, 0:resized_w] = resized_image
         return padding_im
-    
+
     def resize_norm_img_svtr(self, img, image_shape):
 
         imgC, imgH, imgW = image_shape
@@ -274,7 +274,7 @@ class TextRecognizer(object):
                 wh_ratio = w * 1.0 / h
                 max_wh_ratio = max(max_wh_ratio, wh_ratio)
             for ino in range(beg_img_no, end_img_no):
-               
+
                 if self.rec_algorithm == "SAR":
                     norm_img, _, _, valid_ratio = self.resize_norm_img_sar(
                         img_list[indices[ino]], self.rec_image_shape)
@@ -296,8 +296,8 @@ class TextRecognizer(object):
                     gsrm_slf_attn_bias2_list.append(norm_img[4])
                     norm_img_batch.append(norm_img[0])
                 elif self.rec_algorithm == "SVTR":
-                    norm_img = self.resize_norm_img_svtr(
-                        img_list[indices[ino]], self.rec_image_shape)
+                    norm_img = self.resize_norm_img_svtr(img_list[indices[ino]],
+                                                         self.rec_image_shape)
                     norm_img = norm_img[np.newaxis, :]
                     norm_img_batch.append(norm_img)
                 else:
@@ -405,9 +405,13 @@ def main(args):
     valid_image_file_list = []
     img_list = []
 
+    logger.info(
+        "In PP-OCRv3, rec_image_shape parameter defaults to '3, 48, 320', "
+        "if you are using recognition model with PP-OCRv2 or an older version, please set --rec_image_shape='3,32,320"
+    )
     # warmup 2 times
     if args.warmup:
-        img = np.random.uniform(0, 255, [32, 320, 3]).astype(np.uint8)
+        img = np.random.uniform(0, 255, [48, 320, 3]).astype(np.uint8)
         for i in range(2):
             res = text_recognizer([img] * int(args.rec_batch_num))
 

tools/infer/predict_system.py

@@ -133,6 +133,9 @@ def main(args):
     os.makedirs(draw_img_save_dir, exist_ok=True)
     save_results = []
 
+    logger.info("In PP-OCRv3, rec_image_shape parameter defaults to '3, 48, 320', "
+                "if you are using recognition model with PP-OCRv2 or an older version, please set --rec_image_shape='3,32,320")
+                
     # warm up 10 times
     if args.warmup:
         img = np.random.uniform(0, 255, [640, 640, 3]).astype(np.uint8)

tools/infer/utility.py

@@ -79,9 +79,9 @@ def init_args():
     parser.add_argument("--det_fce_box_type", type=str, default='poly')
 
     # params for text recognizer
-    parser.add_argument("--rec_algorithm", type=str, default='CRNN')
+    parser.add_argument("--rec_algorithm", type=str, default='SVTR_LCNet')
     parser.add_argument("--rec_model_dir", type=str)
-    parser.add_argument("--rec_image_shape", type=str, default="3, 32, 320")
+    parser.add_argument("--rec_image_shape", type=str, default="3, 48, 320")
     parser.add_argument("--rec_batch_num", type=int, default=6)
     parser.add_argument("--max_text_length", type=int, default=25)
     parser.add_argument(
@@ -269,11 +269,11 @@ def create_predictor(args, mode, logger):
                 max_input_shape.update(max_pact_shape)
                 opt_input_shape.update(opt_pact_shape)
             elif mode == "rec":
-                if args.rec_algorithm != "CRNN":
+                if args.rec_algorithm not in ["CRNN", "SVTR_LCNet"]:
                     use_dynamic_shape = False
                 imgH = int(args.rec_image_shape.split(',')[-2])
                 min_input_shape = {"x": [1, 3, imgH, 10]}
-                max_input_shape = {"x": [args.rec_batch_num, 3, imgH, 1536]}
+                max_input_shape = {"x": [args.rec_batch_num, 3, imgH, 2304]}
                 opt_input_shape = {"x": [args.rec_batch_num, 3, imgH, 320]}
             elif mode == "cls":
                 min_input_shape = {"x": [1, 3, 48, 10]}
@@ -320,7 +320,7 @@ def create_predictor(args, mode, logger):
 def get_output_tensors(args, mode, predictor):
     output_names = predictor.get_output_names()
     output_tensors = []
-    if mode == "rec" and args.rec_algorithm == "CRNN":
+    if mode == "rec" and args.rec_algorithm in ["CRNN", "SVTR_LCNet"]:
         output_name = 'softmax_0.tmp_0'
         if output_name in output_names:
             return [predictor.get_output_handle(output_name)]