first commit

2025-07-02 08:57:16 +03:00
commit 56532cc9a9
1901 changed files with 457695 additions and 0 deletions
--- a/docs/version2.x/ppocr/blog/PP-OCRv3_introduction.md
+++ b/docs/version2.x/ppocr/blog/PP-OCRv3_introduction.md
@@ -0,0 +1,183 @@
+---
+typora-copy-images-to: images
+comments: true
+---
+
+# PP-OCRv3
+
+## 1. 简介
+
+PP-OCRv3在PP-OCRv2的基础上进一步升级。整体的框架图保持了与PP-OCRv2相同的pipeline，针对检测模型和识别模型进行了优化。其中，检测模块仍基于DB算法优化，而识别模块不再采用CRNN，换成了IJCAI 2022最新收录的文本识别算法[SVTR](https://arxiv.org/abs/2205.00159)，并对其进行产业适配。PP-OCRv3系统框图如下所示（粉色框中为PP-OCRv3新增策略）：
+
+![img](./images/ppocrv3_framework-0052468.png)
+
+从算法改进思路上看，分别针对检测和识别模型，进行了共9个方面的改进：
+
+- 检测模块：
+    - LK-PAN：大感受野的PAN结构；
+    - DML：教师模型互学习策略；
+    - RSE-FPN：残差注意力机制的FPN结构；
+
+- 识别模块：
+    - SVTR_LCNet：轻量级文本识别网络；
+    - GTC：Attention指导CTC训练策略；
+    - TextConAug：挖掘文字上下文信息的数据增广策略；
+    - TextRotNet：自监督的预训练模型；
+    - UDML：联合互学习策略；
+    - UIM：无标注数据挖掘方案。
+
+从效果上看，速度可比情况下，多种场景精度均有大幅提升：
+
+- 中文场景，相对于PP-OCRv2中文模型提升超5%；
+- 英文数字场景，相比于PP-OCRv2英文模型提升11%；
+- 多语言场景，优化80+语种识别效果，平均准确率提升超5%。
+
+## 2. 检测优化
+
+PP-OCRv3检测模型是对PP-OCRv2中的[CML](https://arxiv.org/pdf/2109.03144.pdf)（Collaborative Mutual Learning) 协同互学习文本检测蒸馏策略进行了升级。如下图所示，CML的核心思想结合了①传统的Teacher指导Student的标准蒸馏与 ②Students网络之间的DML互学习，可以让Students网络互学习的同时，Teacher网络予以指导。PP-OCRv3分别针对教师模型和学生模型进行进一步效果优化。其中，在对教师模型优化时，提出了大感受野的PAN结构LK-PAN和引入了DML（Deep Mutual Learning）蒸馏策略；在对学生模型优化时，提出了残差注意力机制的FPN结构RSE-FPN。
+
+![img](./images/ppocrv3_det_cml.png)
+
+消融实验如下：
+
+|序号|策略|模型大小|hmean|速度（cpu + mkldnn)|
+|-|-|-|-|-|
+|baseline teacher|PP-OCR server|49.0M|83.20%|171ms|
+|teacher1|DB-R50-LK-PAN|124.0M|85.00%|396ms|
+|teacher2|DB-R50-LK-PAN-DML|124.0M|86.00%|396ms|
+|baseline student|PP-OCRv2|3.0M|83.20%|117ms|
+|student0|DB-MV3-RSE-FPN|3.6M|84.50%|124ms|
+|student1|DB-MV3-CML（teacher2）|3.0M|84.30%|117ms|
+|student2|DB-MV3-RSE-FPN-CML（teacher2）|3.60M|85.40%|124ms|
+
+测试环境： Intel Gold 6148 CPU，预测时开启MKLDNN加速。
+
+### （1）LK-PAN：大感受野的PAN结构
+
+LK-PAN (Large Kernel PAN) 是一个具有更大感受野的轻量级[PAN](https://arxiv.org/pdf/1803.01534.pdf)结构，核心是将PAN结构的path augmentation中卷积核从`3*3`改为`9*9`。通过增大卷积核，提升特征图每个位置覆盖的感受野，更容易检测大字体的文字以及极端长宽比的文字。使用LK-PAN结构，可以将教师模型的hmean从83.2%提升到85.0%。
+
+![img](./images/LKPAN.png)
+
+### （2）DML：教师模型互学习策略
+
+[DML](https://arxiv.org/abs/1706.00384) （Deep Mutual Learning）互学习蒸馏方法，如下图所示，通过两个结构相同的模型互相学习，可以有效提升文本检测模型的精度。教师模型采用DML策略，hmean从85%提升到86%。将PP-OCRv2中CML的教师模型更新为上述更高精度的教师模型，学生模型的hmean可以进一步从83.2%提升到84.3%。
+
+![img](./images/teacher_dml.png)
+
+### （3）RSE-FPN：残差注意力机制的FPN结构
+
+RSE-FPN（Residual Squeeze-and-Excitation FPN）如下图所示，引入残差结构和通道注意力结构，将FPN中的卷积层更换为通道注意力结构的RSEConv层，进一步提升特征图的表征能力。考虑到PP-OCRv2的检测模型中FPN通道数非常小，仅为96，如果直接用SEblock代替FPN中卷积会导致某些通道的特征被抑制，精度会下降。RSEConv引入残差结构会缓解上述问题，提升文本检测效果。进一步将PP-OCRv2中CML的学生模型的FPN结构更新为RSE-FPN，学生模型的hmean可以进一步从84.3%提升到85.4%。
+
+![img](./images/RSEFPN.png)
+
+## 3. 识别优化
+
+PP-OCRv3的识别模块是基于文本识别算法[SVTR](https://arxiv.org/abs/2205.00159)优化。SVTR不再采用RNN结构，通过引入Transformers结构更加有效地挖掘文本行图像的上下文信息，从而提升文本识别能力。直接将PP-OCRv2的识别模型，替换成SVTR_Tiny，识别准确率从74.8%提升到80.1%（+5.3%），但是预测速度慢了将近11倍，CPU上预测一条文本行，将近100ms。因此，如下图所示，PP-OCRv3采用如下6个优化策略进行识别模型加速。
+
+![img](./images/v3_rec_pipeline.png)
+
+基于上述策略，PP-OCRv3识别模型相比PP-OCRv2，在速度可比的情况下，精度进一步提升4.6%。 具体消融实验如下所示：
+
+| ID | 策略 |  模型大小 | 精度 | 预测耗时（CPU + MKLDNN)|
+|-----|-----|--------|----| --- |
+| 01 | PP-OCRv2 | 8.0M | 74.80% | 8.54ms |
+| 02 | SVTR_Tiny | 21.0M | 80.10% | 97.00ms |
+| 03 | SVTR_LCNet(h32) | 12.0M | 71.90% | 6.60ms |
+| 04 | SVTR_LCNet(h48) | 12.0M | 73.98% | 7.60ms |
+| 05 | + GTC | 12.0M | 75.80% | 7.60ms |
+| 06 | + TextConAug | 12.0M | 76.30% | 7.60ms |
+| 07 | + TextRotNet | 12.0M | 76.90% | 7.60ms |
+| 08 | + UDML | 12.0M | 78.40% | 7.60ms |
+| 09 | + UIM | 12.0M | 79.40% | 7.60ms |
+
+注： 测试速度时，实验01-03输入图片尺寸均为(3,32,320)，04-08输入图片尺寸均为(3,48,320)。在实际预测时，图像为变长输入，速度会有所变化。测试环境： Intel Gold 6148 CPU，预测时开启MKLDNN加速。
+
+### （1）SVTR_LCNet：轻量级文本识别网络
+
+SVTR_LCNet是针对文本识别任务，将基于Transformer的[SVTR](https://arxiv.org/abs/2205.00159)网络和轻量级CNN网络[PP-LCNet](https://arxiv.org/abs/2109.15099) 融合的一种轻量级文本识别网络。使用该网络，预测速度优于PP-OCRv2的识别模型20%，但是由于没有采用蒸馏策略，该识别模型效果略差。此外，进一步将输入图片规范化高度从32提升到48，预测速度稍微变慢，但是模型效果大幅提升，识别准确率达到73.98%（+2.08%），接近PP-OCRv2采用蒸馏策略的识别模型效果。
+
+SVTR_Tiny 网络结构如下所示：
+
+![img](./images/svtr_tiny.png)
+
+由于 MKLDNN 加速库支持的模型结构有限，SVTR 在 CPU+MKLDNN 上相比 PP-OCRv2 慢了10倍。PP-OCRv3 期望在提升模型精度的同时，不带来额外的推理耗时。通过分析发现，SVTR_Tiny 结构的主要耗时模块为 Mixing Block，因此我们对 SVTR_Tiny 的结构进行了一系列优化（详细速度数据请参考下方消融实验表格）:
+
+1. 将 SVTR 网络前半部分替换为 PP-LCNet 的前三个stage，保留4个 Global Mixing Block ，精度为76%，加速69%，网络结构如下所示：
+
+    ![img](./images/svtr_g4.png)
+
+2. 将4个 Global Mixing Block 减小到2个，精度为72.9%，加速69%，网络结构如下所示：
+
+    ![img](./images/svtr_g2.png)
+
+3. 实验发现 Global Mixing Block 的预测速度与输入其特征的shape有关，因此后移 Global Mixing Block 的位置到池化层之后，精度下降为71.9%，速度超越基于CNN结构的PP-OCRv2-baseline 22%，网络结构如下所示：
+
+    ![img](./images/LCNet_SVTR.png)
+
+具体消融实验如下所示：
+
+| ID | 策略 |  模型大小 | 精度 | 速度（CPU + MKLDNN)|
+|-----|-----|--------|----| --- |
+| 01 | PP-OCRv2-baseline | 8.0M | 69.30%  | 8.54ms |
+| 02 | SVTR_Tiny | 21.0M | 80.10% | 97.00ms |
+| 03 | SVTR_LCNet(G4) | 9.2M | 76.00% | 30.00ms |
+| 04 | SVTR_LCNet(G2) | 13.0M | 72.98% | 9.37ms |
+| 05 | SVTR_LCNet(h32) | 12.0M | 71.90% | 6.60ms |
+| 06 | SVTR_LCNet(h48)  | 12.0M | 73.98% | 7.60ms |
+
+注： 测试速度时，01-05输入图片尺寸均为(3,32,320)； PP-OCRv2-baseline 代表没有借助蒸馏方法训练得到的模型
+
+### （2）GTC：Attention指导CTC训练策略
+
+[GTC](https://arxiv.org/pdf/2002.01276.pdf)（Guided Training of CTC），利用Attention模块CTC训练，融合多种文本特征的表达，是一种有效的提升文本识别的策略。使用该策略，预测时完全去除 Attention 模块，在推理阶段不增加任何耗时，识别模型的准确率进一步提升到75.8%（+1.82%）。训练流程如下所示：
+
+![img](./images/GTC.png)
+
+### （3）TextConAug：挖掘文字上下文信息的数据增广策略
+
+TextConAug是一种挖掘文字上下文信息的数据增广策略，主要思想来源于论文[ConCLR](https://www.cse.cuhk.edu.hk/~byu/papers/C139-AAAI2022-ConCLR.pdf)，作者提出ConAug数据增广，在一个batch内对2张不同的图像进行联结，组成新的图像并进行自监督对比学习。PP-OCRv3将此方法应用到有监督的学习任务中，设计了TextConAug数据增强方法，可以丰富训练数据上下文信息，提升训练数据多样性。使用该策略，识别模型的准确率进一步提升到76.3%（+0.5%）。TextConAug示意图如下所示：
+
+![img](./images/recconaug.png)
+
+### （4）TextRotNet：自监督的预训练模型
+
+TextRotNet是使用大量无标注的文本行数据，通过自监督方式训练的预训练模型，参考于论文[STR-Fewer-Labels](https://github.com/ku21fan/STR-Fewer-Labels)。该模型可以初始化SVTR_LCNet的初始权重，从而帮助文本识别模型收敛到更佳位置。使用该策略，识别模型的准确率进一步提升到76.9%（+0.6%）。TextRotNet训练流程如下图所示：
+
+<img src="./images/SSL.png" alt="img" style="zoom:67%;" />
+
+### （5）UDML：联合互学习策略
+
+UDML（Unified-Deep Mutual Learning）联合互学习是PP-OCRv2中就采用的对于文本识别非常有效的提升模型效果的策略。在PP-OCRv3中，针对两个不同的SVTR_LCNet和Attention结构，对他们之间的PP-LCNet的特征图、SVTR模块的输出和Attention模块的输出同时进行监督训练。使用该策略，识别模型的准确率进一步提升到78.4%（+1.5%）。
+
+### （6）UIM：无标注数据挖掘方案
+
+UIM（Unlabeled Images Mining）是一种非常简单的无标注数据挖掘方案。核心思想是利用高精度的文本识别大模型对无标注数据进行预测，获取伪标签，并且选择预测置信度高的样本作为训练数据，用于训练小模型。使用该策略，识别模型的准确率进一步提升到79.4%（+1%）。实际操作中，我们使用全量数据集训练高精度SVTR-Tiny模型（acc=82.5%）进行数据挖掘，点击获取[模型下载地址和使用教程](../applications/高精度中文识别模型.md)。
+
+<img src="./images/UIM.png" alt="img" style="zoom:67%;" />
+
+## 4. 端到端评估
+
+经过以上优化，最终PP-OCRv3在速度可比情况下，中文场景端到端Hmean指标相比于PP-OCRv2提升5%，效果大幅提升。具体指标如下表所示：
+
+| Model | Hmean |  Model Size (M) | Time Cost (CPU, ms) | Time Cost (T4 GPU, ms) |
+|-----|-----|--------|----| --- |
+| PP-OCR mobile | 50.30% | 8.1 | 356.00  | 116.00 |
+| PP-OCR server | 57.00% | 155.1 | 1056.00 | 200.00 |
+| PP-OCRv2 | 57.60% | 11.6 | 330.00 | 111.00 |
+| PP-OCRv3 | 62.90% | 15.6 | 331.00 | 86.64 |
+
+测试环境：CPU型号为Intel Gold 6148，CPU预测时开启MKLDNN加速。
+
+除了更新中文模型，本次升级也同步优化了英文数字模型，端到端效果提升11%，如下表所示：
+
+| Model | Recall |  Precision | Hmean |
+|-----|-----|--------|----|
+| PP-OCR_en | 38.99% | 45.91% | 42.17%  |
+| PP-OCRv3_en | 50.95% | 55.53% | 53.14% |
+
+同时，也对已支持的80余种语言识别模型进行了升级更新，在有评估集的四种语系识别准确率平均提升5%以上，如下表所示：
+
+| Model | 拉丁语系 |  阿拉伯语系 | 日语 | 韩语 |
+|-----|-----|--------|----| --- |
+| PP-OCR_mul | 69.60% | 40.50% | 38.50%  | 55.40% |
+| PP-OCRv3_mul | 75.20%| 45.37% | 45.80% | 60.10% |
--- a/docs/version2.x/ppocr/blog/PP-OCRv4_introduction.md
+++ b/docs/version2.x/ppocr/blog/PP-OCRv4_introduction.md
@@ -0,0 +1,153 @@
+---
+typora-copy-images-to: images
+comments: true
+---
+
+# PP-OCRv4
+
+## 1. 简介
+
+PP-OCRv4在PP-OCRv3的基础上进一步升级。整体的框架图保持了与PP-OCRv3相同的pipeline，针对检测模型和识别模型进行了数据、网络结构、训练策略等多个模块的优化。 PP-OCRv4系统框图如下所示：
+
+![img](./images/ppocrv4_framework.png)
+
+从算法改进思路上看，分别针对检测和识别模型，进行了共10个方面的改进：
+
+* 检测模块：
+    * LCNetV3：精度更高的骨干网络
+    * PFHead：并行head分支融合结构
+    * DSR: 训练中动态增加shrink ratio
+    * CML：添加Student和Teacher网络输出的KL div loss
+
+* 识别模块：
+    * SVTR_LCNetV3：精度更高的骨干网络
+    * Lite-Neck：精简的Neck结构
+    * GTC-NRTR：稳定的Attention指导分支
+    * Multi-Scale：多尺度训练策略
+    * DF: 数据挖掘方案
+    * DKD ：DKD蒸馏策略
+
+从效果上看，速度可比情况下，多种场景精度均有大幅提升：
+
+* 中文场景，相对于PP-OCRv3中文模型提升超4%；
+* 英文数字场景，相比于PP-OCRv3英文模型提升6%；
+* 多语言场景，优化80个语种识别效果，平均准确率提升超8%。
+
+## 2. 检测优化
+
+PP-OCRv4检测模型在PP-OCRv3检测模型的基础上，在网络结构，训练策略，蒸馏策略三个方面做了优化。首先，PP-OCRv4检测模型使用PP-LCNetV3替换MobileNetv3，并提出并行分支融合的PFhead结构；其次，训练时动态调整shrink ratio的比例；最后，PP-OCRv4对CML的蒸馏loss进行优化，进一步提升文字检测效果。
+
+消融实验如下：
+
+|序号|策略|模型大小|hmean|速度（cpu + mkldnn)|
+|-|-|-|-|-|
+|baseline|PP-OCRv3|3.4M|78.84%|69ms|
+|baseline student|PP-OCRv3 student|3.4M|76.22%|69ms|
+|01|+PFHead|3.6M|76.97%|96ms|
+|02|+Dynamic Shrink Ratio|3.6M|78.24%|96ms|
+|03|+PP-LCNetv3|4.8M|79.08%|94ms|
+|03|+CML|4.8M|79.87%|67ms|
+
+测试环境： Intel Gold 6148 CPU，预测引擎使用openvino。
+
+### （1）PFhead：多分支融合Head结构
+
+PFhead结构如下图所示，PFHead在经过第一个转置卷积后，分别进行上采样和转置卷积，上采样的输出通过3x3卷积得到输出结果，然后和转置卷积的分支的结果级联并经过1x1卷积层，最后1x1卷积的结果和转置卷积的结果相加得到最后输出的概率图。PP-OCRv4学生检测模型使用PFhead，hmean从76.22%增加到76.97%。
+
+  ![img](./images/PFHead.png)
+
+### （2）DSR: 收缩比例动态调整策略
+
+动态shrink ratio(dynamic shrink ratio): 在训练中，shrink ratio由固定值调整为动态变化，随着训练epoch的增加，shrink ratio从0.4线性增加到0.6。该策略在PP-OCRv4学生检测模型上，hmean从76.97%提升到78.24%。
+
+### (3) PP-LCNetV3：精度更高的骨干网络
+
+PP-LCNetV3系列模型是PP-LCNet系列模型的延续，覆盖了更大的精度范围，能够适应不同下游任务的需要。PP-LCNetV3系列模型从多个方面进行了优化，提出了可学习仿射变换模块，对重参数化策略、激活函数进行了改进，同时调整了网络深度与宽度。最终，PP-LCNetV3系列模型能够在性能与效率之间达到最佳的平衡，在不同精度范围内取得极致的推理速度。使用PP-LCNetV3替换MobileNetv3 backbone，PP-OCRv4学生检测模型hmean从78.24%提升到79.08%。
+
+### （4）CML: 融合KD的互学习策略
+
+PP-OCRv4检测模型对PP-OCRv3中的CML（Collaborative Mutual Learning) 协同互学习文本检测蒸馏策略进行了优化。如下图所示，在计算Student Model和Teacher Model的distill Loss时，额外添加KL div loss，让两者输出的response maps分布接近，由此进一步提升Student网络的精度，检测Hmean从79.08%增加到79.56%，端到端指标从61.31%增加到61.87%。
+
+  ![img](./images/ppocrv4_det_cml.png)
+
+## 3. 识别优化
+
+PP-OCRv4识别模型在PP-OCRv3的基础上进一步升级。如下图所示，整体的框架图保持了与PP-OCRv3识别模型相同的pipeline，分别进行了数据、网络结构、训练策略等方面的优化。
+
+![img](./images/v4_rec_pipeline.png)
+
+经过如图所示的策略优化，PP-OCRv4识别模型相比PP-OCRv3，在速度可比的情况下，精度进一步提升4%。 具体消融实验如下所示：
+
+| ID | 策略 |  模型大小 | 精度 | 预测耗时（CPU openvino)|
+|-----|-----|--------|----| --- |
+| 01 | PP-OCRv3 | 12M | 71.50% | 8.54ms |
+| 02 | +DF | 12M | 72.70% | 8.54ms |
+| 03 | + LiteNeck + GTC | 9.6M | 73.21% | 9.09ms |
+| 04 | + PP-LCNetV3 | 11M | 74.18% | 9.8ms |
+| 05 | + multi-scale | 11M | 74.20% | 9.8ms |
+| 06 | + TextConAug | 11M | 74.72% | 9.8ms |
+| 08 | + UDML | 11M | 75.45% | 9.8ms |
+
+注： 测试速度时，输入图片尺寸均为(3,48,320)。在实际预测时，图像为变长输入，速度会有所变化。测试环境： Intel Gold 6148 CPU，预测时使用Openvino预测引擎。
+
+### （1）DF：数据挖掘方案
+
+DF(Data Filter) 是一种简单有效的数据挖掘方案。核心思想是利用已有模型预测训练数据，通过置信度和预测结果等信息，对全量的训练数据进行筛选。具体的：首先使用少量数据快速训练得到一个低精度模型，使用该低精度模型对千万级的数据进行预测，去除置信度大于0.95的样本，该部分被认为是对提升模型精度无效的冗余样本。其次使用PP-OCRv3作为高精度模型，对剩余数据进行预测，去除置信度小于0.15的样本，该部分被认为是难以识别或质量很差的样本。
+使用该策略，千万级别训练数据被精简至百万级，模型训练时间从2周减少到5天，显著提升了训练效率，同时精度提升至72.7%(+1.2%)。
+
+![img](./images/DF.png)
+
+### （2）PP-LCNetV3：精度更优的骨干网络
+
+PP-LCNetV3系列模型是PP-LCNet系列模型的延续，覆盖了更大的精度范围，能够适应不同下游任务的需要。PP-LCNetV3系列模型从多个方面进行了优化，提出了可学习仿射变换模块，对重参数化策略、激活函数进行了改进，同时调整了网络深度与宽度。最终，PP-LCNetV3系列模型能够在性能与效率之间达到最佳的平衡，在不同精度范围内取得极致的推理速度。
+
+### （3）Lite-Neck：精简参数的Neck结构
+
+Lite-Neck整体结构沿用PP-OCRv3版本的结构，在参数上稍作精简，识别模型整体的模型大小可从12M降低到8.5M，而精度不变；在CTCHead中，将Neck输出特征的维度从64提升到120，此时模型大小从8.5M提升到9.6M。
+
+### （4）GTC-NRTR：Attention指导CTC训练策略
+
+GTC（Guided Training of CTC），是PP-OCRv3识别模型的最有效的策略之一，融合多种文本特征的表达，有效的提升文本识别精度。在PP-OCRv4中使用训练更稳定的Transformer模型NRTR作为指导分支，相比V3版本中的SAR基于循环神经网络的结构，NRTR基于Transformer实现解码过程泛化能力更强，能有效指导CTC分支学习，解决简单场景下快速过拟合的问题。使用Lite-Neck和GTC-NRTR两个策略，识别精度提升至73.21%(+0.5%)。
+
+![img](./images/ppocrv4_gtc.png)
+
+### （5）Multi-Scale：多尺度训练策略
+
+动态尺度训练策略，是在训练过程中随机resize输入图片的高度，以增强识别模型在端到端串联使用时的鲁棒性。在训练时，每个iter从（32，48，64）三种高度中随机选择一种高度进行resize。实验证明，使用该策略，尽管在识别测试集上准确率没有提升，但在端到端串联评估时，指标提升0.5%。
+
+![img](./images/multi_scale.png)
+
+### （6）DKD：蒸馏策略
+
+识别模型的蒸馏包含两个部分，NRTRhead蒸馏和CTCHead蒸馏;
+
+对于NRTR head，使用了DKD loss蒸馏，拉近学生模型和教师模型的NRTR head logits。最终NRTR head的loss是学生与教师间的DKD loss和与ground truth的cross entropy loss的加权和，用于监督学生模型的backbone训练。通过实验，我们发现加入DKD loss后，计算与ground truth的cross entropy loss时去除label smoothing可以进一步提高精度，因此我们在这里使用的是不带label smoothing的cross entropy loss。
+
+对于CTCHead，由于CTC的输出中存在Blank位，即使教师模型和学生模型的预测结果一样，二者的输出的logits分布也会存在差异，影响教师模型向学生模型的知识传递。PP-OCRv4识别模型蒸馏策略中，将CTC输出logits沿着文本长度维度计算均值，将多字符识别问题转换为多字符分类问题，用于监督CTC Head的训练。使用该策略融合NRTRhead DKD蒸馏策略，指标从74.72%提升到75.45%。
+
+## 4. 端到端评估
+
+经过以上优化，最终PP-OCRv4在速度可比情况下，中文场景端到端Hmean指标相比于PP-OCRv3提升4.5%，效果大幅提升。具体指标如下表所示：
+
+| Model | Hmean |  Model Size (M) | Time Cost (CPU, ms) |
+|-----|-----|--------|----|
+| PP-OCRv3 | 57.99% | 15.6 | 78 |
+| PP-OCRv4 | 62.24% | 15.8 | 76 |
+
+测试环境：CPU型号为Intel Gold 6148，CPU预测时使用openvino。
+
+除了更新中文模型，本次升级也优化了英文数字模型，在自有评估集上文本识别准确率提升6%，如下表所示：
+
+| Model | ACC |
+|-----|-----|
+| PP-OCR_en | 54.38% |
+| PP-OCRv3_en | 64.04% |
+| PP-OCRv4_en | 70.1% |
+
+同时，对已支持的80余种语言识别模型进行了升级更新，在有评估集的四种语系识别准确率平均提升8%以上，如下表所示：
+
+| Model | 拉丁语系 |  阿拉伯语系 | 日语 | 韩语 |
+|-----|-----|--------|----| --- |
+| PP-OCR_mul | 69.60% | 40.50% | 38.50%  | 55.40% |
+| PP-OCRv3_mul | 71.57%| 72.90% | 45.85% | 77.23% |
+| PP-OCRv4_mul | 80.00%| 75.48% | 56.50% | 83.25% |
--- a/docs/version2.x/ppocr/blog/clone.en.md
+++ b/docs/version2.x/ppocr/blog/clone.en.md
@@ -0,0 +1,31 @@
+---
+comments: true
+---
+
+# Project Clone
+
+## 1. Clone PaddleOCR
+
+```bash linenums="1"
+# Recommend
+git clone https://github.com/PaddlePaddle/PaddleOCR
+
+# If you cannot pull successfully due to network problems, you can switch to the mirror hosted on Gitee:
+
+git clone https://gitee.com/paddlepaddle/PaddleOCR
+
+# Note: The mirror on Gitee may not keep in synchronization with the latest project on GitHub. There might be a delay of 3-5 days. Please try GitHub at first.
+```
+
+## 2. Install third-party libraries
+
+```bash linenums="1"
+cd PaddleOCR
+pip3 install -r requirements.txt
+```
+
+If you getting this error `OSError: [WinError 126] The specified module could not be found` when you install shapely on windows.
+
+Please try to download Shapely whl file from [http://www.lfd.uci.edu/~gohlke/pythonlibs/#shapely](http://www.lfd.uci.edu/~gohlke/pythonlibs/#shapely).
+
+Reference: [Solve shapely installation on windows](https://stackoverflow.com/questions/44398265/install-shapely-oserror-winerror-126-the-specified-module-could-not-be-found)
--- a/docs/version2.x/ppocr/blog/clone.md
+++ b/docs/version2.x/ppocr/blog/clone.md
@@ -0,0 +1,26 @@
+---
+comments: true
+---
+
+# 项目克隆
+
+## 1. 克隆PaddleOCR repo代码
+
+```bash linenums="1"
+git clone https://github.com/PaddlePaddle/PaddleOCR
+```
+
+如果因为网络问题无法pull成功，也可选择使用码云上的托管：
+
+```bash linenums="1"
+git clone https://gitee.com/paddlepaddle/PaddleOCR
+```
+
+注：码云托管代码可能无法实时同步本github项目更新，存在3~5天延时，请优先使用推荐方式。
+
+## 2. 安装第三方库
+
+```bash linenums="1"
+cd PaddleOCR
+pip3 install -r requirements.txt
+```
--- a/docs/version2.x/ppocr/blog/config.en.md
+++ b/docs/version2.x/ppocr/blog/config.en.md
@@ -0,0 +1,245 @@
+---
+comments: true
+---
+
+# Configuration
+
+## 1. Optional Parameter List
+
+The following list can be viewed through `--help`
+
+|         FLAG             |     Supported script    |        Use        |      Defaults       |         Note         |
+| :----------------------: | :------------: | :---------------: | :--------------: | :-----------------: |
+|          -c              |      ALL       |  Specify configuration file to use  |  None  |  **Please refer to the parameter introduction for configuration file usage** |
+|          -o              |      ALL       |  set configuration options  |  None  |  Configuration using -o has higher priority than the configuration file selected with -c. E.g: -o Global.use_gpu=false |
+
+## 2. Introduction to Global Parameters of Configuration File
+
+Take rec_chinese_lite_train_v2.0.yml as an example
+
+### Global
+
+|         Parameter             |            Use                |      Defaults       |            Note            |
+| :----------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      use_gpu             |    Set using GPU or not           |       true        |                \                 |
+|      epoch_num           |    Maximum training epoch number             |       500        |                \                 |
+|      log_smooth_window   |    Log queue length, the median value in the queue each time will be printed           |       20          |                \                 |
+|      print_batch_step    |    Set print log interval         |       10          |                \                 |
+|      save_model_dir      |    Set model save path        |  output/{算法名称}  |                \                 |
+|      save_epoch_step     |    Set model save interval        |       3           |                \                 |
+|      eval_batch_step     |    Set the model evaluation interval        | 2000 or [1000, 2000]        | running evaluation every 2000 iters or evaluation is run every 2000 iterations after the 1000th iteration   |
+|      cal_metric_during_train     |    Set whether to evaluate the metric during the training process. At this time, the metric of the model under the current batch is evaluated        |       true         |                \                 |
+|      load_static_weights     |   Set whether the pre-training model is saved in static graph mode (currently only required by the detection algorithm)        |       true         |                \                 |
+|      pretrained_model    |    Set the path of the pre-trained model      |  ./pretrain_models/CRNN/best_accuracy  |  \          |
+|      checkpoints         |    set model parameter path            |       None        |   Used to load parameters after interruption to continue training|
+|      use_visualdl  |    Set whether to enable visualdl for visual log display |          False        |    [Tutorial](https://www.paddlepaddle.org.cn/paddle/visualdl) |
+|      use_wandb     |    Set whether to enable W&B for visual log display      | False | [Documentation](https://docs.wandb.ai/)
+|      infer_img            |    Set inference image path or folder path     |       ./infer_img | \ |
+|      character_dict_path |    Set dictionary path            |  ./ppocr/utils/ppocr_keys_v1.txt  | If the character_dict_path is None, model can only recognize number and lower letters |
+|      max_text_length     |    Set the maximum length of text        |       25          |                \                 |
+|      use_space_char     |    Set whether to recognize spaces             |        True      |          \               |
+|      label_list          |    Set the angle supported by the direction classifier       |    ['0','180']    |     Only valid in angle classifier model |
+|      save_res_path          |    Set the save address of the test model results       |    ./output/det_db/predicts_db.txt    |     Only valid in the text detection model |
+
+### Optimizer ([ppocr/optimizer](../../ppocr/optimizer))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         Optimizer class name          |  Adam  |  Currently supports`Momentum`,`Adam`,`RMSProp`, see [ppocr/optimizer/optimizer.py](../../ppocr/optimizer/optimizer.py)  |
+|      beta1           |    Set the exponential decay rate for the 1st moment estimates  |       0.9         |               \             |
+|      beta2           |    Set the exponential decay rate for the 2nd moment estimates  |     0.999         |               \             |
+|      clip_norm           |    The maximum norm value  |    -         |               \             |
+|      **lr**                |         Set the learning rate decay method       |   -    |       \  |
+|        name    |      Learning rate decay class name   |         Cosine       | Currently supports`Linear`,`Cosine`,`Step`,`Piecewise`, see [ppocr/optimizer/learning_rate.py](../../ppocr/optimizer/learning_rate.py) |
+|        learning_rate      |    Set the base learning rate        |       0.001      |  \        |
+|      **regularizer**      |  Set network regularization method        |       -      | \        |
+|        name      |    Regularizer class name      |       L2     |  Currently support`L1`,`L2`, see [ppocr/optimizer/regularizer.py](../../ppocr/optimizer/regularizer.py)        |
+|        factor      |    Regularizer coefficient       |       0.00001     |  \        |
+
+### Architecture ([ppocr/modeling](../../ppocr/modeling))
+
+In PaddleOCR, the network is divided into four stages: Transform, Backbone, Neck and Head
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      model_type        |         Network Type          |  rec  |  Currently support`rec`,`det`,`cls`  |
+|      algorithm           |    Model name  |       CRNN         |               See [algorithm_overview](./algorithm_overview_en.md) for the support list             |
+|      **Transform**           |    Set the transformation method  |       -       |               Currently only recognition algorithms are supported, see [ppocr/modeling/transform](../../ppocr/modeling/transforms) for details            |
+|        name    |      Transformation class name   |         TPS       | Currently supports `TPS` |
+|        num_fiducial      |   Number of TPS control points        |       20      |  Ten on the top and bottom       |
+|        loc_lr      |    Localization network learning rate        |       0.1      |  \      |
+|        model_name      |    Localization network size        |       small      |  Currently support`small`,`large`       |
+|      **Backbone**      |  Set the network backbone class name        |       -      | see [ppocr/modeling/backbones](../../ppocr/modeling/backbones)        |
+|        name      |    backbone class name       |       ResNet     | Currently support`MobileNetV3`,`ResNet`        |
+|        layers      |    resnet layers       |       34     |  Currently support18,34,50,101,152,200       |
+|        model_name      |    MobileNetV3 network size       |       small     |  Currently support`small`,`large`       |
+|      **Neck**      |  Set network neck        |       -      | see [ppocr/modeling/necks](../../ppocr/modeling/necks)        |
+|        name      |    neck class name       |       SequenceEncoder     | Currently support`SequenceEncoder`,`DBFPN`        |
+|        encoder_type      |    SequenceEncoder encoder type       |       rnn     |  Currently support`reshape`,`fc`,`rnn`       |
+|        hidden_size      |   rnn number of internal units       |       48     |  \      |
+|        out_channels      |   Number of DBFPN output channels       |       256     |  \      |
+|      **Head**      |  Set the network head        |       -      | see [ppocr/modeling/heads](../../ppocr/modeling/heads)        |
+|        name      |    head class name       |       CTCHead     | Currently support`CTCHead`,`DBHead`,`ClsHead`        |
+|        fc_decay      |    CTCHead regularization coefficient       |       0.0004     |  \      |
+|        k      |   DBHead binarization coefficient       |       50     |  \      |
+|        class_dim      |   ClsHead output category number       |       2     |  \      |
+
+### Loss ([ppocr/losses](../../ppocr/losses))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         loss class name          |  CTCLoss  |  Currently support`CTCLoss`,`DBLoss`,`ClsLoss`  |
+|      balance_loss        |        Whether to balance the number of positive and negative samples in DBLossloss (using OHEM)         |  True  |  \  |
+|      ohem_ratio        |        The negative and positive sample ratio of OHEM in DBLossloss         |  3  |  \  |
+|      main_loss_type        |        The loss used by shrink_map in DBLossloss        |  DiceLoss  |  Currently support`DiceLoss`,`BCELoss`  |
+|      alpha        |        The coefficient of shrink_map_loss in DBLossloss       |  5  |  \  |
+|      beta        |        The coefficient of threshold_map_loss in DBLossloss       |  10  |  \  |
+
+### PostProcess ([ppocr/postprocess](../../ppocr/postprocess))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         Post-processing class name          |  CTCLabelDecode  |  Currently support`CTCLoss`,`AttnLabelDecode`,`DBPostProcess`,`ClsPostProcess`  |
+|      thresh        |        The threshold for binarization of the segmentation map in DBPostProcess         |  0.3  |  \  |
+|      box_thresh        |        The threshold for filtering output boxes in DBPostProcess. Boxes below this threshold will not be output         |  0.7  |  \  |
+|      max_candidates        |        The maximum number of text boxes output in DBPostProcess        |  1000  |   |
+|      unclip_ratio        |        The unclip ratio of the text box in DBPostProcess       |  2.0  |  \  |
+
+### Metric ([ppocr/metrics](../../ppocr/metrics))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         Metric method name          |  CTCLabelDecode  |  Currently support`DetMetric`,`RecMetric`,`ClsMetric`  |
+|      main_indicator        |        Main indicators, used to select the best model        |  acc |  For the detection method is hmean, the recognition and classification method is acc  |
+
+### Dataset  ([ppocr/data](../../ppocr/data))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      **dataset**        |         Return one sample per iteration          |  -  |  -  |
+|      name        |        dataset class name         |  SimpleDataSet |   Currently support`SimpleDataSet`,`LMDBDataSet`  |
+|      data_dir        |        Image folder path        |  ./train_data |  \  |
+|      label_file_list        |        Groundtruth file path         |  ["./train_data/train_list.txt"] | This parameter is not required when dataset is LMDBDataSet   |
+|      ratio_list        |        Ratio of data set         |  [1.0] | If there are two train_lists in label_file_list and ratio_list is [0.4,0.6], 40% will be sampled from train_list1, and 60% will be sampled from train_list2 to combine the entire dataset   |
+|      transforms        |        List of methods to transform images and labels         |  [DecodeImage,CTCLabelEncode,RecResizeImg,KeepKeys] |   see [ppocr/data/imaug](../../ppocr/data/imaug)  |
+|      **loader**        |        dataloader related         |  - |   |
+|      shuffle        |        Does each epoch disrupt the order of the data set         |  True | \  |
+|      batch_size_per_card        |        Single card batch size during training         |  256 | \  |
+|      drop_last        |        Whether to discard the last incomplete mini-batch because the number of samples in the data set cannot be divisible by batch_size        |  True | \  |
+|      num_workers        |        The number of sub-processes used to load data, if it is 0, the sub-process is not started, and the data is loaded in the main process       |  8 | \  |
+
+### Weights & Biases ([W&B](../../ppocr/utils/loggers/wandb_logger.py))
+
+|         Parameter             |            Use            |      Defaults        |            Note             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|          project              |     Project to which the run is to be logged | uncategorized | \
+|          name                 |     Alias/Name of the run | Randomly generated by wandb | \
+|          id                   |     ID of the run    | Randomly generated by wandb     | \
+|          entity               | User or team to which the run is being logged         | The logged in user | \
+|          save_dir             | local directory in which all the models and other data is saved | wandb | \
+|          config               | model configuration | None | \
+
+## 3. Multilingual Config File Generation
+
+PaddleOCR currently supports recognition for 80 languages (besides Chinese). A multi-language configuration file template is
+provided under the path `configs/rec/multi_languages`: [rec_multi_language_lite_train.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/rec_multi_language_lite_train.yml).
+
+There are two ways to create the required configuration file:
+
+1. Automatically generated by script
+
+Script [generate_multi_language_configs.py](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/generate_multi_language_configs.py) can help you generate configuration files for multi-language models.
+
+- Take Italian as an example, if your data is prepared in the following format:
+
+    ```text linenums="1"
+    |-train_data
+        |- it_train.txt # train_set label
+        |- it_val.txt # val_set label
+        |- data
+            |- word_001.jpg
+            |- word_002.jpg
+            |- word_003.jpg
+            | ...
+    ```
+
+    You can use the default parameters to generate a configuration file:
+
+    ```bash linenums="1"
+    # The code needs to be run in the specified directory
+    cd PaddleOCR/configs/rec/multi_language/
+    # Set the configuration file of the language to be generated through the -l or --language parameter.
+    # This command will write the default parameters into the configuration file
+    python3 generate_multi_language_configs.py -l it
+    ```
+
+- If your data is placed in another location, or you want to use your own dictionary, you can generate the configuration file by specifying the relevant parameters:
+
+    ```bash linenums="1"
+    # -l or --language field is required
+    # --train to modify the training set
+    # --val to modify the validation set
+    # --data_dir to modify the data set directory
+    # --dict to modify the dict path
+    # -o to modify the corresponding default parameters
+    cd PaddleOCR/configs/rec/multi_language/
+    python3 generate_multi_language_configs.py -l it \  # language
+    --train {path/of/train_label.txt} \ # path of train_label
+    --val {path/of/val_label.txt} \     # path of val_label
+    --data_dir {train_data/path} \      # root directory of training data
+    --dict {path/of/dict} \             # path of dict
+    -o Global.use_gpu=False             # whether to use gpu
+    ...
+
+    ```
+
+Italian is made up of Latin letters, so after executing the command, you will get the rec_latin_lite_train.yml.
+
+2. Manually modify the configuration file
+
+   You can also manually modify the following fields in the template:
+
+   ```yaml linenums="1"
+    Global:
+      use_gpu: True
+      epoch_num: 500
+      ...
+      character_dict_path:  {path/of/dict} # path of dict
+
+   Train:
+      dataset:
+        name: SimpleDataSet
+        data_dir: train_data/ # root directory of training data
+        label_file_list: ["./train_data/train_list.txt"] # train label path
+      ...
+
+   Eval:
+      dataset:
+        name: SimpleDataSet
+        data_dir: train_data/ # root directory of val data
+        label_file_list: ["./train_data/val_list.txt"] # val label path
+      ...
+
+   ```
+
+Currently, the multi-language algorithms supported by PaddleOCR are:
+
+| Configuration file |  Algorithm name |   backbone |   trans   |   seq      |     pred     |  language |
+| :--------: |  :-------:   | :-------:  |   :-------:   |   :-----:   |  :-----:   | :-----:  |
+| rec_chinese_cht_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | chinese traditional  |
+| rec_en_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | English(Case sensitive)   |
+| 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  | Japanese |
+| 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  | arabic |
+| 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  |
+
+For more supported languages, please refer to: [Multi-language model](./multi_languages.en.md)
+
+The multi-language model training method is the same as the Chinese model. The training data set is 100w synthetic data. A small amount of fonts and test data can be downloaded using the following two methods.
+
+- [Baidu Netdisk](https://pan.baidu.com/s/1bS_u207Rm7YbY33wOECKDA),Extraction code:frgi.
+- [Google drive](https://drive.google.com/file/d/18cSWX7wXSy4G0tbKJ0d9PuIaiwRLHpjA/view)
--- a/docs/version2.x/ppocr/blog/config.md
+++ b/docs/version2.x/ppocr/blog/config.md
@@ -0,0 +1,222 @@
+---
+comments: true
+---
+
+# 配置文件内容与生成
+
+## 1. 可选参数列表
+
+以下列表可以通过`--help`查看
+
+|         FLAG             |     支持脚本    |        用途        |      默认值       |         备注         |
+| :----------------------: | :------------: | :---------------: | :--------------: | :-----------------: |
+|          -c              |      ALL       |  指定配置文件  |  None  |  **配置模块说明请参考 参数介绍** |
+|          -o              |      ALL       |  设置配置文件里的参数内容  |  None  |  使用-o配置相较于-c选择的配置文件具有更高的优先级。例如：`-o Global.use_gpu=false`  |
+
+## 2. 配置文件参数介绍
+
+以 `rec_chinese_lite_train_v2.0.yml` 为例
+
+### Global
+
+|         字段             |            用途                |      默认值       |            备注            |
+| :----------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      use_gpu             |    设置代码是否在gpu运行           |       true        |                \                 |
+|      epoch_num           |    最大训练epoch数             |       500        |                \                 |
+|      log_smooth_window   |    log队列长度，每次打印输出队列里的中间值            |       20          |                \                 |
+|      print_batch_step    |    设置打印log间隔         |       10          |                \                 |
+|      save_model_dir      |    设置模型保存路径        |  output/{算法名称}  |                \                 |
+|      save_epoch_step     |    设置模型保存间隔        |       3           |                \                 |
+|      eval_batch_step     |    设置模型评估间隔        | 2000 或 [1000, 2000]        | 2000 表示每2000次迭代评估一次，[1000， 2000]表示从1000次迭代开始，每2000次评估一次   |
+|      cal_metric_during_train     |    设置是否在训练过程中评估指标，此时评估的是模型在当前batch下的指标        |       true         |                \                 |
+|      load_static_weights     |   设置预训练模型是否是静态图模式保存(目前仅检测算法需要)        |       true         |                \                 |
+|      pretrained_model    |    设置加载预训练模型路径      |  ./pretrain_models/CRNN/best_accuracy  |  \          |
+|      checkpoints         |    加载模型参数路径            |       None        |    用于中断后加载参数继续训练 |
+|      use_visualdl  |    设置是否启用visualdl进行可视化log展示 |          False        |    [教程地址](https://www.paddlepaddle.org.cn/paddle/visualdl) |
+|      infer_img            |    设置预测图像路径或文件夹路径     |       ./infer_img | \||
+|      character_dict_path |    设置字典路径            |  ./ppocr/utils/ppocr_keys_v1.txt  | 如果为空，则默认使用小写字母+数字作为字典 |
+|      max_text_length     |    设置文本最大长度        |       25          |                \                 |
+|      use_space_char     |    设置是否识别空格             |        True      |          \|               |
+|      label_list          |    设置方向分类器支持的角度       |    ['0','180']    |     仅在方向分类器中生效 |
+|      save_res_path          |    设置检测模型的结果保存地址       |    ./output/det_db/predicts_db.txt    |     仅在检测模型中生效 |
+
+### Optimizer ([ppocr/optimizer](../../ppocr/optimizer))
+
+|         字段             |      用途       |      默认值      |            备注             |
+| :---------------------: |:-------------:|:-------------:|   :--------------------:   |
+|      name        |     优化器类名     |     Adam      |  目前支持`Momentum`,`Adam`,`RMSProp`, 见[ppocr/optimizer/optimizer.py](../../ppocr/optimizer/optimizer.py)  |
+|      beta1           | 设置一阶矩估计的指数衰减率 |      0.9      |               \             |
+|      beta2           | 设置二阶矩估计的指数衰减率 |     0.999     |               \             |
+|      clip_norm           |  所允许的二范数最大值   |               |               \             |
+|      **lr**                | 设置学习率decay方式  |       -       |       \  |
+|        name    |  学习率decay类名   |    Cosine     | 目前支持`Linear`,`Cosine`,`Step`,`Piecewise`, 见[ppocr/optimizer/learning_rate.py](../../ppocr/optimizer/learning_rate.py) |
+|        learning_rate      |     基础学习率     |     0.001     |  \        |
+|      **regularizer**      |   设置网络正则化方式   |       -       | \        |
+|        name      |     正则化类名     |      L2       | 目前支持`L1`,`L2`, 见[ppocr/optimizer/regularizer.py](../../ppocr/optimizer/regularizer.py)        |
+|        factor      |     正则化系数     |       0.00001        |  \        |
+
+### Architecture ([ppocr/modeling](../../ppocr/modeling))
+
+在PaddleOCR中，网络被划分为Transform,Backbone,Neck和Head四个阶段
+
+|         字段             |            用途            |      默认值        |            备注             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      model_type        |         网络类型          |  rec  |  目前支持`rec`,`det`,`cls`  |
+|      algorithm           |    模型名称  |       CRNN         |               支持列表见[algorithm_overview](./algorithm_overview.md)             |
+|      **Transform**           |    设置变换方式  |       -       |               目前仅rec类型的算法支持, 具体见[ppocr/modeling/transforms](../../ppocr/modeling/transforms)              |
+|        name    |      变换方式类名   |         TPS       | 目前支持`TPS` |
+|        num_fiducial      |    TPS控制点数        |       20      |  上下边各十个       |
+|        loc_lr      |    定位网络学习率        |       0.1      |  \      |
+|        model_name      |    定位网络大小        |       small      |  目前支持`small`,`large`       |
+|      **Backbone**      |  设置网络backbone类名        |       -      | 具体见[ppocr/modeling/backbones](../../ppocr/modeling/backbones)        |
+|        name      |    backbone类名       |       ResNet     | 目前支持`MobileNetV3`,`ResNet`        |
+|        layers      |    resnet层数       |       34     |  支持18,34,50,101,152,200       |
+|        model_name      |    MobileNetV3 网络大小       |       small     |  支持`small`,`large`       |
+|      **Neck**      |  设置网络neck        |       -      | 具体见[ppocr/modeling/necks](../../ppocr/modeling/necks)        |
+|        name      |    neck类名       |       SequenceEncoder     | 目前支持`SequenceEncoder`,`DBFPN`        |
+|        encoder_type      |    SequenceEncoder编码器类型       |       rnn     |  支持`reshape`,`fc`,`rnn`       |
+|        hidden_size      |   rnn内部单元数       |       48     |  \      |
+|        out_channels      |   DBFPN输出通道数       |       256     |  \      |
+|      **Head**      |  设置网络Head        |       -      | 具体见[ppocr/modeling/heads](../../ppocr/modeling/heads)        |
+|        name      |    head类名       |       CTCHead     | 目前支持`CTCHead`,`DBHead`,`ClsHead`        |
+|        fc_decay      |    CTCHead正则化系数       |       0.0004     |  \      |
+|        k      |   DBHead二值化系数       |       50     |  \      |
+|        class_dim      |   ClsHead输出分类数       |       2     |  \      |
+
+### Loss ([ppocr/losses](../../ppocr/losses))
+
+|         字段             |            用途            |      默认值        |            备注             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         网络loss类名          |  CTCLoss  |  目前支持`CTCLoss`,`DBLoss`,`ClsLoss`  |
+|      balance_loss        |        DBLossloss中是否对正负样本数量进行均衡(使用OHEM)         |  True  |  \  |
+|      ohem_ratio        |        DBLossloss中的OHEM的负正样本比例         |  3  |  \  |
+|      main_loss_type        |        DBLossloss中shrink_map所采用的loss        |  DiceLoss  |  支持`DiceLoss`,`BCELoss`  |
+|      alpha        |        DBLossloss中shrink_map_loss的系数       |  5  |  \  |
+|      beta        |        DBLossloss中threshold_map_loss的系数       |  10  |  \  |
+
+### PostProcess ([ppocr/postprocess](../../ppocr/postprocess))
+
+|         字段             |            用途            |      默认值        |            备注             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         后处理类名          |  CTCLabelDecode  |  目前支持`CTCLoss`,`AttnLabelDecode`,`DBPostProcess`,`ClsPostProcess`  |
+|      thresh        |        DBPostProcess中分割图进行二值化的阈值         |  0.3  |  \  |
+|      box_thresh        |        DBPostProcess中对输出框进行过滤的阈值，低于此阈值的框不会输出         |  0.7  |  \  |
+|      max_candidates        |        DBPostProcess中输出的最大文本框数量        |  1000  |   |
+|      unclip_ratio        |        DBPostProcess中对文本框进行放大的比例       |  2.0  |  \  |
+
+### Metric ([ppocr/metrics](../../ppocr/metrics))
+
+|         字段             |            用途            |      默认值        |            备注             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      name        |         指标评估方法名称          |  CTCLabelDecode  |  目前支持`DetMetric`,`RecMetric`,`ClsMetric`  |
+|      main_indicator        |        主要指标,用于选取最优模型         |  acc |  对于检测方法为hmean，识别和分类方法为acc  |
+
+### Dataset  ([ppocr/data](../../ppocr/data))
+
+|         字段             |            用途            |      默认值        |            备注             |
+| :---------------------: |  :---------------------:   | :--------------:  |   :--------------------:   |
+|      **dataset**        |         每次迭代返回一个样本          |  -  |  -  |
+|      name        |        dataset类名         |  SimpleDataSet |  目前支持`SimpleDataSet`和`LMDBDataSet`  |
+|      data_dir        |        数据集图片存放路径         |  ./train_data |  \  |
+|      label_file_list        |        数据标签路径         |  ["./train_data/train_list.txt"] | dataset为LMDBDataSet时不需要此参数   |
+|      ratio_list        |        数据集的比例         |  [1.0] | 若label_file_list中有两个train_list，且ratio_list为[0.4,0.6]，则从train_list1中采样40%，从train_list2中采样60%组合整个dataset   |
+|      transforms        |        对图片和标签进行变换的方法列表         |  [DecodeImage,CTCLabelEncode,RecResizeImg,KeepKeys] |   见[ppocr/data/imaug](../../ppocr/data/imaug)  |
+|      **loader**        |        dataloader相关         |  - |   |
+|      shuffle        |        每个epoch是否将数据集顺序打乱         |  True | \  |
+|      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](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/rec_multi_language_lite_train.yml)。
+
+您有两种方式创建所需的配置文件：
+
+1. 通过脚本自动生成
+
+[generate_multi_language_configs.py](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/generate_multi_language_configs.py) 可以帮助您生成多语言模型的配置文件
+
+* 以意大利语为例，如果您的数据是按如下格式准备的：
+
+    ```text linenums="1"
+    |-train_data
+        |- it_train.txt # 训练集标签
+        |- it_val.txt # 验证集标签
+        |- data
+            |- word_001.jpg
+            |- word_002.jpg
+            |- word_003.jpg
+            | ...
+    ```
+
+    可以使用默认参数，生成配置文件：
+
+    ```bash linenums="1"
+    # 该代码需要在指定目录运行
+    cd PaddleOCR/configs/rec/multi_language/
+    # 通过-l或者--language参数设置需要生成的语种的配置文件，该命令会将默认参数写入配置文件
+    python3 generate_multi_language_configs.py -l it
+    ```
+
+* 如果您的数据放置在其他位置，或希望使用自己的字典，可以通过指定相关参数来生成配置文件:
+
+    ```bash linenums="1"
+    # -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. 手动修改配置文件
+
+   您也可以手动修改模版中的以下几个字段得到配置文件:
+
+   ```yaml linenums="1"
+    Global:
+      use_gpu: True
+      epoch_num: 500
+      ...
+      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 |
+| :--------: |  :-------:   | :-------:  |   :-------:   |   :-----:   |  :-----:   | :-----:  |
+| rec_chinese_cht_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 中文繁体  |
+| rec_en_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 英语（区分大小写）   |
+| rec_french_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 法语 |
+| rec_ger_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 德语   |
+| rec_japan_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 日语  |
+| rec_korean_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 韩语  |
+| rec_latin_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 拉丁字母  |
+| rec_arabic_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 阿拉伯字母 |
+| rec_cyrillic_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 斯拉夫字母  |
+| rec_devanagari_lite_train.yml |  CRNN |   Mobilenet_v3 small 0.5 |  None   |  BiLSTM |  ctc  | 梵文字母  |
+
+更多支持语种请参考: [多语言模型](./multi_languages.md)
--- a/docs/version2.x/ppocr/blog/customize.en.md
+++ b/docs/version2.x/ppocr/blog/customize.en.md
@@ -0,0 +1,39 @@
+---
+comments: true
+---
+
+# HOW TO MAKE YOUR OWN LIGHTWEIGHT OCR MODEL?
+
+The process of making a customized ultra-lightweight OCR models can be divided into three steps: training text detection model, training text recognition model, and concatenate the predictions from previous steps.
+
+## STEP1: TRAIN TEXT DETECTION MODEL
+
+PaddleOCR provides two text detection algorithms: EAST and DB. Both support MobileNetV3 and ResNet50_vd backbone networks, select the corresponding configuration file as needed and start training. For example, to train with MobileNetV3 as the backbone network for DB detection model :
+
+```bash linenums="1"
+python3 tools/train.py -c configs/det/det_mv3_db.yml 2>&1 | tee det_db.log
+```
+
+For more details about data preparation and training tutorials, refer to the documentation [Text detection model training/evaluation/prediction](../model_train/detection.en.md)
+
+## STEP2: TRAIN TEXT RECOGNITION MODEL
+
+PaddleOCR provides four text recognition algorithms: CRNN, Rosetta, STAR-Net, and RARE. They all support two backbone networks: MobileNetV3 and ResNet34_vd, select the corresponding configuration files as needed to start training. For example, to train a CRNN recognition model that uses MobileNetV3 as the backbone network:
+
+```bash linenums="1"
+python3 tools/train.py -c configs/rec/rec_chinese_lite_train.yml 2>&1 | tee rec_ch_lite.log
+```
+
+For more details about data preparation and training tutorials, refer to the documentation [Text recognition model training/evaluation/prediction](../model_train/recognition.en.md)
+
+## STEP3: CONCATENATE PREDICTIONS
+
+PaddleOCR provides a concatenation tool for detection and recognition models, which can connect any trained detection model and any recognition model into a two-stage text recognition system. The input image goes through four main stages: text detection, text rectification, text recognition, and score filtering to output the text position and recognition results, and at the same time, you can choose to visualize the results.
+
+When performing prediction, you need to specify the path of a single image or a image folder through the parameter `image_dir`, the parameter `det_model_dir` specifies the path of detection model, and the parameter `rec_model_dir` specifies the path of recognition model. The visualized results are saved to the `./inference_results` folder by default.
+
+```bash linenums="1"
+python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/det/"  --rec_model_dir="./inference/rec/"
+```
+
+For more details about text detection and recognition concatenation, please refer to the document [Inference](../infer_deploy/python_infer.en.md)
--- a/docs/version2.x/ppocr/blog/customize.md
+++ b/docs/version2.x/ppocr/blog/customize.md
@@ -0,0 +1,39 @@
+---
+comments: true
+---
+
+# 如何生产自定义超轻量模型？
+
+生产自定义的超轻量模型可分为三步：训练文本检测模型、训练文本识别模型、模型串联预测。
+
+## step1：训练文本检测模型
+
+PaddleOCR提供了EAST、DB两种文本检测算法，均支持MobileNetV3、ResNet50_vd两种骨干网络，根据需要选择相应的配置文件，启动训练。例如，训练使用MobileNetV3作为骨干网络的DB检测模型（即超轻量模型使用的配置）：
+
+```bash linenums="1"
+python3 tools/train.py -c configs/det/det_mv3_db.yml 2>&1 | tee det_db.log
+```
+
+更详细的数据准备和训练教程参考文档教程中[文本检测模型训练/评估/预测](../model_train/detection.md)。
+
+## step2：训练文本识别模型
+
+PaddleOCR提供了CRNN、Rosetta、STAR-Net、RARE四种文本识别算法，均支持MobileNetV3、ResNet34_vd两种骨干网络，根据需要选择相应的配置文件，启动训练。例如，训练使用MobileNetV3作为骨干网络的CRNN识别模型（即超轻量模型使用的配置）：
+
+```bash linenums="1"
+python3 tools/train.py -c configs/rec/rec_chinese_lite_train.yml 2>&1 | tee rec_ch_lite.log
+```
+
+更详细的数据准备和训练教程参考文档教程中[文本识别模型训练/评估/预测](../model_train/recognition.md)。
+
+## step3：模型串联预测
+
+PaddleOCR提供了检测和识别模型的串联工具，可以将训练好的任一检测模型和任一识别模型串联成两阶段的文本识别系统。输入图像经过文本检测、检测框矫正、文本识别、得分过滤四个主要阶段输出文本位置和识别结果，同时可选择对结果进行可视化。
+
+在执行预测时，需要通过参数image_dir指定单张图像或者图像集合的路径、参数det_model_dir指定检测inference模型的路径和参数rec_model_dir指定识别inference模型的路径。可视化识别结果默认保存到 ./inference_results 文件夹里面。
+
+```bash linenums="1"
+python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/det/"  --rec_model_dir="./inference/rec/"
+```
+
+更多的文本检测、识别串联推理使用方式请参考文档教程中的[基于预测引擎推理](../infer_deploy/python_infer.md)。
--- a/docs/version2.x/ppocr/blog/distributed_training.en.md
+++ b/docs/version2.x/ppocr/blog/distributed_training.en.md
@@ -0,0 +1,65 @@
+---
+comments: true
+---
+
+# Distributed training
+
+## Introduction
+
+The high performance of distributed training is one of the core advantages of PaddlePaddle. In the classification task, distributed training can achieve almost linear speedup ratio. Generally, OCR training task need massive training data. Such as recognition, PP-OCR v2.0 model is trained based on 1800W dataset, which is very time-consuming if using single machine. Therefore, the distributed training is used in PaddleOCR to speedup the training task. For more information about distributed training, please refer to [distributed training quick start tutorial](https://fleet-x.readthedocs.io/en/latest/paddle_fleet_rst/parameter_server/ps_quick_start.html).
+
+## Quick Start
+
+### Training with single machine
+
+Take recognition as an example. After the data is prepared locally, start the training task with the interface of `paddle.distributed.launch`. The start command as follows:
+
+```bash linenums="1"
+python3 -m paddle.distributed.launch \
+    --log_dir=./log/ \
+    --gpus "0,1,2,3,4,5,6,7" \
+    tools/train.py \
+    -c configs/rec/rec_mv3_none_bilstm_ctc.yml
+```
+
+### Training with multi machine
+
+Compared with single machine, training with multi machine only needs to add the parameter `--ips` to start command, which represents the IP list of machines used for distributed training, and the IP of different machines are separated by commas. The start command as follows:
+
+```bash linenums="1"
+ip_list="192.168.0.1,192.168.0.2"
+python3 -m paddle.distributed.launch \
+    --log_dir=./log/ \
+    --ips="${ip_list}" \
+    --gpus="0,1,2,3,4,5,6,7" \
+    tools/train.py \
+    -c configs/rec/rec_mv3_none_bilstm_ctc.yml
+```
+
+**Notice:**
+
+* The IP addresses of different machines need to be separated by commas, which can be queried through `ifconfig` or `ipconfig`.
+* Different machines need to be set to be secret free and can `ping` success with others directly, otherwise communication cannot establish between them.
+* The code, data and start command between different machines must be completely consistent and then all machines need to run start command. The first machine in the `ip_list` is set to `trainer0`, and so on.
+
+## Performance comparison
+
+We conducted model training on 2x8 P40 GPUs. Accuracy, training time, and multi machine acceleration ratio of different models are shown below.
+
+| Model    | Configuration | Configuration   | 8 GPU training time / Accuracy | 3x8 GPU training time / Accuracy | Acceleration ratio  |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| CRNN | [rec_chinese_lite_train_v2.0.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml) |  260k Chinese dataset | 2.50d/66.70%   | 1.67d/67.00%  | **1.5** |
+
+We conducted model training on 3x8 V100 GPUs. Accuracy, training time, and multi machine acceleration ratio of different models are shown below.
+
+| Model    | Configuration | Configuration   | 8 GPU training time / Accuracy | 3x8 GPU training time / Accuracy | Acceleration ratio  |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| SLANet | [SLANet.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/table/SLANet.yml) |  PubTabNet | 49.80h/76.20%   | 19.75h/74.77%  | **2.52** |
+
+Note: when training with 3x8 GPUs, the single card batch size is unchanged compared with the 1x8 GPUs' training process, and the learning rate is multiplied by 2 (if it is multiplied by 3 by default, the accuracy is only 73.42%).
+
+We conducted model training on 4x8 V100 GPUs. Accuracy, training time, and multi machine acceleration ratio of different models are shown below.
+
+| Model    | Configuration | Configuration   | 8 GPU training time / Accuracy | 4x8 GPU training time / Accuracy | Acceleration ratio  |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| SVTR | [PP-OCRv3_mobile_rec_distillation.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec_distillation.yml) |  PP-OCRv3_rec data | 10d/-   | 2.84d/74.00%  | **3.5** |
--- a/docs/version2.x/ppocr/blog/distributed_training.md
+++ b/docs/version2.x/ppocr/blog/distributed_training.md
@@ -0,0 +1,67 @@
+---
+comments: true
+---
+
+# 分布式训练
+
+## 简介
+
+* 分布式训练的高性能，是飞桨的核心优势技术之一，在分类任务上，分布式训练可以达到几乎线性的加速比。OCR训练任务中往往包含大量训练数据，以识别为例，ppocrv2.0模型在训练时使用了1800W数据，如果使用单机训练，会非常耗时。因此，PaddleOCR中使用分布式训练接口完成训练任务，同时支持单机训练与多机训练。更多关于分布式训练的方法与文档可以参考：[分布式训练快速开始教程](https://fleet-x.readthedocs.io/en/latest/paddle_fleet_rst/parameter_server/ps_quick_start.html)。
+
+## 使用方法
+
+### 单机训练
+
+* 以识别为例，本地准备好数据之后，使用`paddle.distributed.launch`的接口启动训练任务即可。下面为运行代码示例。
+
+```bash linenums="1"
+python3 -m paddle.distributed.launch \
+    --log_dir=./log/ \
+    --gpus "0,1,2,3,4,5,6,7" \
+    tools/train.py \
+    -c configs/rec/rec_mv3_none_bilstm_ctc.yml
+```
+
+### 多机训练
+
+* 相比单机训练，多机训练时，只需要添加`--ips`的参数，该参数表示需要参与分布式训练的机器的ip列表，不同机器的ip用逗号隔开。下面为运行代码示例。
+
+```bash linenums="1"
+ip_list="192.168.0.1,192.168.0.2"
+python3 -m paddle.distributed.launch \
+    --log_dir=./log/ \
+    --ips="${ip_list}" \
+    --gpus="0,1,2,3,4,5,6,7" \
+    tools/train.py \
+    -c configs/rec/rec_mv3_none_bilstm_ctc.yml
+```
+
+**注：**
+
+* 不同机器的ip信息需要用逗号隔开，可以通过`ifconfig`或者`ipconfig`查看。
+* 不同机器之间需要做免密设置，且可以直接ping通，否则无法完成通信。
+* 不同机器之间的代码、数据与运行命令或脚本需要保持一致，且所有的机器上都需要运行设置好的训练命令或者脚本。最终`ip_list`中的第一台机器的第一块设备是trainer0，以此类推。
+
+## 性能效果测试
+
+在2机8卡P40的机器上进行模型训练，不同模型的精度、训练耗时、多机加速比情况如下所示。
+
+| 模型   | 配置  | 数据集   | 单机8卡耗时/精度 | 2机8卡耗时/精度 | 加速比 |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| CRNN | [rec_chinese_lite_train_v2.0.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml) |  26W中文数据集 | 2.50d/66.7%   | 1.67d/67.0%  | **1.5** |
+
+在3机8卡V100的机器上进行模型训练，不同模型的精度、训练耗时、多机加速比情况如下所示。
+
+| 模型   | 配置  | 数据集   | 单机8卡耗时/精度 | 3机8卡耗时/精度 | 加速比 |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| SLANet | [SLANet.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/table/SLANet.yml) |  PubTabNet | 49.8h/76.2%   | 19.75h/74.77%  | **2.52** |
+
+注意：这里3机8卡训练时，单卡batch size相比于单机8卡不变，学习率乘以2 (默认乘以3的话，精度仅有73.42%)
+
+在4机8卡V100的机器上进行模型训练，不同模型的精度、训练耗时、多机加速比情况如下所示。
+
+| 模型   | 配置  | 数据集   | 单机8卡耗时/精度 | 4机8卡耗时/精度 | 加速比 |
+|:------:|:-----:|:--------:|:--------:|:--------:|:-----:|
+| SVTR | [PP-OCRv3_mobile_rec_distillation.yml](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec_distillation.yml) |  PP-OCRv3_rec data | 10d/-   | 2.84d/74.0%  | **3.5** |
+
+**注意**: 在训练的GPU卡数过多时，精度会稍微有所损失（1%左右），此时可以尝试通过添加warmup或者适当增加迭代轮数来弥补精度损失。
--- a/docs/version2.x/ppocr/blog/enhanced_ctc_loss.en.md
+++ b/docs/version2.x/ppocr/blog/enhanced_ctc_loss.en.md
@@ -0,0 +1,100 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# Enhanced CTC Loss
+
+In OCR recognition, CRNN is a text recognition algorithm widely applied in the industry. In the training phase, it uses CTCLoss to calculate the network loss. In the inference phase, it uses CTCDecode to obtain the decoding result. Although the CRNN algorithm has been proven to achieve reliable recognition results in actual business, users have endless requirements for recognition accuracy. So how to improve the accuracy of text recognition? Taking CTCLoss as the starting point, this paper explores the improved fusion scheme of CTCLoss from three different perspectives: Hard Example Mining, Multi-task Learning, and Metric Learning. Based on the exploration, we propose EnhancedCTCLoss, which includes the following 3 components: Focal-CTC Loss, A-CTC Loss, C-CTC Loss.
+
+## 1. Focal-CTC Loss
+
+Focal Loss was proposed by the paper, "[Focal Loss for Dense Object Detection](https://arxiv.org/abs/1708.02002)". When the loss was first proposed, it was mainly to solve the problem of a serious imbalance in the ratio of positive and negative samples in one-stage target detection. This loss function reduces the weight of a large number of simple negative samples in training and also can be understood as a kind of difficult sample mining.
+The form of the loss function is as follows:
+
+$$
+\begin{equation}
+L_{fl}=\left\{
+\begin{array}{cl}
+-\alpha(1 - y^{'})^{\gamma}logy^{'} ,&  y = 1 \\
+-(1 - \alpha)y^{'\gamma}log(1 - y^{'}), &  y = 0 \\
+\end{array} \right.
+\end{equation}
+$$
+
+Among them, y' is the output of the activation function, and the value is between 0-1. It adds a modulation factor (1-y’)^&gamma; and a balance factor &alpha; on the basis of the original cross-entropy loss. When &alpha; = 1, y = 1, the comparison between the loss function and the cross-entropy loss is shown in the following figure:
+
+![img](./images/focal_loss_image.png)
+
+As can be seen from the above figure, when &gamma; > 0, the adjustment coefficient (1-y’)^&gamma; gives smaller weight to the easy-to-classify sample loss, making the network pay more attention to the difficult and misclassified samples. The adjustment factor &gamma; is used to adjust the rate at which the weight of simple samples decreases. When &gamma; = 0, it is the cross-entropy loss function. When &gamma; increases, the influence of the adjustment factor will also increase. Experiments revealed that 2 is the optimal value of &gamma;. The balance factor &alpha; is used to balance the uneven proportions of the positive and negative samples. In the text, &alpha; is taken as 0.25.
+
+For the classic CTC algorithm, suppose a certain feature sequence (f<sub>1</sub>, f<sub>2</sub>, ......f<sub>t</sub>), after CTC decoding, the probability that the result is equal to label is y', then the probability that the CTC decoding result is not equal to label is (1-y'); it is not difficult to find that the CTCLoss value and y' have the following relationship:
+
+$$
+L_{CTC} = -log(y^{'})
+$$
+
+Combining the idea of Focal Loss, assigning larger weights to difficult samples and smaller weights to simple samples can make the network focus more on the mining of difficult samples and further improve the accuracy of recognition. Therefore, we propose Focal-CTC Loss. Its definition is as follows:
+
+$$
+L_{Focal\_CTC} = \alpha * (1 - y^{'})^{\gamma} * L_{CTC}
+$$
+
+In the experiment, the value of &gamma; is 2, &alpha; = 1, see this for specific implementation: [rec_ctc_loss.py](../../ppocr/losses/rec_ctc_loss.py)
+
+## 2. A-CTC Loss
+A-CTC Loss is short for CTC Loss + ACE Loss. Among them, ACE Loss was proposed by the paper, “[Aggregation Cross-Entropy for Sequence Recognition](https://arxiv.org/abs/1904.08364)”. Compared with CTCLoss, ACE Loss has the following two advantages:
+ ACE Loss can solve the recognition problem of 2-D text, while CTCLoss can only process 1-D text
+ ACE Loss is better than CTC loss in time complexity and space complexity
+
+The advantages and disadvantages of the OCR recognition algorithm summarized by the predecessors are shown in the following figure:
+
+![img](./images/rec_algo_compare.png)
+
+Although ACELoss does handle 2D predictions, as shown in the figure above, and has advantages in memory usage and inference speed, in practice, we found that using ACELoss alone, the recognition effect is not as good as CTCLoss. Consequently, we tried to combine CTCLoss and ACELoss, and CTCLoss is the mainstay while ACELoss acts as an auxiliary supervision loss. This attempt has achieved better results. On our internal experimental data set, compared to using CTCLoss alone, the recognition accuracy can be improved by about 1%.
+A_CTC Loss is defined as follows:
+
+$$
+L_{A-CTC} = L_{CTC} + \lambda * L_{ACE}
+$$
+
+In the experiment, λ = 0.1. See the ACE loss implementation code: [ace_loss.py](../../ppocr/losses/ace_loss.py)
+
+## 3. C-CTC Loss
+C-CTC Loss is short for CTC Loss + Center Loss. Among them, Center Loss was proposed by the paper, “[A Discriminative Feature Learning Approach for Deep Face Recognition](https://link.springer.com/chapter/10.1007/978-3-319-46478-7_31)“. It was first used in face recognition tasks to increase the distance between classes and reduce the distance within classes. It is an earlier and also widely used algorithm.
+
+In the task of Chinese OCR recognition, through the analysis of bad cases, we found that a major difficulty in Chinese recognition is that there are many similar characters, which are easy to misunderstand. From this, we thought about whether we can learn from the idea of n to increase the class spacing of similar characters, to improve recognition accuracy. However, Metric Learning is mainly used in the field of image recognition, and the label of the training data is a fixed value; for OCR recognition, it is a sequence recognition task essentially, and there is no explicit alignment between features and labels. Therefore, how to combine the two is still a direction worth exploring.
+
+By trying Arcmargin, Cosmargin and other methods, we finally found that Centerloss can help further improve the accuracy of recognition. C_CTC Loss is defined as follows:
+
+$$
+L_{C-CTC} = L_{CTC} + \lambda * L_{center}
+$$
+
+In the experiment, we set λ=0.25. See the center_loss implementation code: [center_loss.py](../../ppocr/losses/center_loss.py)
+
+It is worth mentioning that in C-CTC Loss, choosing to initialize the Center randomly does not bring significant improvement. Our Center initialization method is as follows:
+ Based on the original CTCLoss, a network N is obtained by training
+ Select the training set, identify the completely correct part, and form the set G
+ Send each sample in G to the network, perform forward calculation, and extract the correspondence between the input of the last FC layer (ie feature) and the result of argmax calculation (ie index)
+ Aggregate features with the same index, calculate the average, and get the initial center of each character.
+
+Taking the configuration file `configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml` as an example, the center extraction command is as follows:
+
+```bash linenums="1"
+python tools/export_center.py -c configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml -o Global.pretrained_model="./output/rec_mobile_pp-OCRv2/best_accuracy"
+```
+
+After running, `train_center.pkl` will be generated in the main directory of PaddleOCR.
+
+## 4. Experiment
+
+For the above three solutions, we conducted training and evaluation based on Baidu's internal data set. The experimental conditions are shown in the following table:
+
+| algorithm | Focal_CTC | A_CTC | C-CTC |
+| :-------- | :-------- | ----: | :---: |
+| gain      | +0.3%     | +0.7% | +1.7% |
+
+Based on the above experimental conclusions, we adopted the C-CTC strategy in PP-OCRv2. It is worth mentioning that, because PP-OCRv2 deals with the recognition task of 6625 Chinese characters, the character set is relatively large and there are many similar characters, so the C-CTC solution brings a significant improvement on this task. But if you switch to other OCR recognition tasks, the conclusion may be different. You can try Focal-CTC, A-CTC, C-CTC, and the combined solution EnhancedCTC. We believe it will bring different degrees of improvement.
+
+The unified combined plan is shown in the following file: [rec_enhanced_ctc_loss.py](../../ppocr/losses/rec_enhanced_ctc_loss.py)
--- a/docs/version2.x/ppocr/blog/enhanced_ctc_loss.md
+++ b/docs/version2.x/ppocr/blog/enhanced_ctc_loss.md
@@ -0,0 +1,101 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# Enhanced CTC Loss
+
+在OCR识别中， CRNN是一种在工业界广泛使用的文字识别算法。 在训练阶段，其采用CTCLoss来计算网络损失； 在推理阶段，其采用CTCDecode来获得解码结果。虽然CRNN算法在实际业务中被证明能够获得很好的识别效果， 然而用户对识别准确率的要求却是无止境的，如何进一步提升文字识别的准确率呢？ 本文以CTCLoss为切人点，分别从难例挖掘、 多任务学习、 Metric Learning 3个不同的角度探索了CTCLoss的改进融合方案，提出了EnhancedCTCLoss，其包括如下3个组成部分： Focal-CTC Loss，A-CTC Loss， C-CTC Loss。
+
+## 1. Focal-CTC Loss
+
+Focal Loss 出自论文《Focal Loss for Dense Object Detection》, 该loss最先提出的时候主要是为了解决one-stage目标检测中正负样本比例严重失衡的问题。该损失函数降低了大量简单负样本在训练中所占的权重，也可理解为一种困难样本挖掘。
+其损失函数形式如下：
+
+$$
+\begin{equation}
+L_{fl}=\left\{
+\begin{array}{cl}
+-\alpha(1 - y^{'})^{\gamma}logy^{'} ,&  y = 1 \\
+-(1 - \alpha)y^{'\gamma}log(1 - y^{'}), &  y = 0 \\
+\end{array} \right.
+\end{equation}
+$$
+
+其中,  y' 是经过激活函数的输出，取值在0-1之间。其在原始的交叉熵损失的基础上加了一个调制系数（1 – y’)^ &gamma;和平衡因子&alpha;。 当&alpha; = 1，y=1时，其损失函数与交叉熵损失的对比如下图所示:
+
+![img](./images/focal_loss_image.png)
+
+从上图可以看到, 当&gamma;> 0时，调整系数（1-y’）^&gamma; 赋予易分类样本损失一个更小的权重，使得网络更关注于困难的、错分的样本。 调整因子&gamma;用于调节简单样本权重降低的速率，当&gamma;为0时即为交叉熵损失函数，当&gamma;增加时，调整因子的影响也会随之增大。实验发现&gamma;为2是最优。平衡因子&alpha;用来平衡正负样本本身的比例不均，文中&alpha;取0.25。
+
+对于经典的CTC算法，假设某个特征序列（f<sub>1</sub>, f<sub>2</sub>, ......f<sub>t</sub>), 经过CTC解码之后结果等于label的概率为y’, 则CTC解码结果不为label的概率即为（1-y’)；不难发现, CTCLoss值和y’有如下关系：
+
+$$
+L_{CTC} = -log(y^{'})
+$$
+
+结合Focal Loss的思想，赋予困难样本较大的权重，简单样本较小的权重，可以使网络更加聚焦于对困难样本的挖掘，进一步提升识别的准确率，由此我们提出了Focal-CTC Loss； 其定义如下所示：
+
+$$
+L_{Focal\_CTC} = \alpha * (1 - y^{'})^{\gamma} * L_{CTC}
+$$
+
+实验中，&gamma;取值为2, &alpha;= 1, 具体实现见:  [rec_ctc_loss.py](../../ppocr/losses/rec_ctc_loss.py)
+
+## 2. A-CTC Loss
+
+A-CTC Loss是CTC Loss + ACE Loss的简称。 其中ACE Loss出自论文< Aggregation Cross-Entropy for Sequence Recognition>.  ACE Loss相比于CTCLoss，主要有如下两点优势:
+
+ ACE Loss能够解决2-D文本的识别问题;  CTCLoss只能够处理1-D文本
+ ACE Loss 在时间复杂度和空间复杂度上优于CTC loss
+
+前人总结的OCR识别算法的优劣如下图所示：
+
+![img](./images/rec_algo_compare.png)
+
+虽然ACELoss确实如上图所说，可以处理2D预测，在内存占用及推理速度方面具备优势，但在实践过程中，我们发现单独使用ACE Loss,  识别效果并不如CTCLoss.  因此，我们尝试将CTCLoss和ACELoss进行结合，同时以CTCLoss为主，将ACELoss 定位为一个辅助监督loss。 这一尝试收到了效果，在我们内部的实验数据集上，相比单独使用CTCLoss，识别准确率可以提升1%左右。
+A_CTC Loss定义如下:
+
+$$
+L_{A-CTC} = L_{CTC} + \lambda * L_{ACE}
+$$
+
+实验中，λ = 0.1.  ACE loss实现代码见:  [ace_loss.py](../../ppocr/losses/ace_loss.py)
+
+## 3. C-CTC Loss
+
+C-CTC Loss是CTC Loss + Center Loss的简称。 其中Center Loss出自论文 < A Discriminative Feature Learning Approach for Deep Face Recognition>.  最早用于人脸识别任务，用于增大类间距离，减小类内距离,  是Metric Learning领域一种较早的、也比较常用的一种算法。
+在中文OCR识别任务中，通过对badcase分析， 我们发现中文识别的一大难点是相似字符多，容易误识。 由此我们想到是否可以借鉴Metric Learing的想法， 增大相似字符的类间距，从而提高识别准确率。然而，MetricLearning主要用于图像识别领域，训练数据的标签为一个固定的值；而对于OCR识别来说，其本质上是一个序列识别任务，特征和label之间并不具有显式的对齐关系，因此两者如何结合依然是一个值得探索的方向。
+通过尝试Arcmargin, Cosmargin等方法， 我们最终发现Centerloss 有助于进一步提升识别的准确率。C_CTC Loss定义如下：
+
+$$
+L_{C-CTC} = L_{CTC} + \lambda * L_{center}
+$$
+
+实验中，我们设置λ=0.25. center_loss实现代码见:  [center_loss.py](../../ppocr/losses/center_loss.py)
+
+值得一提的是， 在C-CTC Loss中，选择随机初始化Center并不能够带来明显的提升. 我们的Center初始化方法如下：
+
+ 基于原始的CTCLoss， 训练得到一个网络N
+ 挑选出训练集中，识别完全正确的部分, 组成集合G
+ 将G中的每个样本送入网络，进行前向计算， 提取最后一个FC层的输入（即feature）及其经过argmax计算的结果（即index）之间的对应关系
+ 将相同index的feature进行聚合，计算平均值，得到各自字符的初始center.
+
+以配置文件`configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml`为例， center提取命令如下所示:
+
+```bash linenums="1"
+python tools/export_center.py -c configs/rec/ch_PP-OCRv2/ch_PP-OCRv2_rec.yml -o Global.pretrained_model="./output/rec_mobile_pp-OCRv2/best_accuracy"
+```
+
+运行完后，会在PaddleOCR主目录下生成`train_center.pkl`.
+
+## 4. 实验
+
+对于上述的三种方案，我们基于百度内部数据集进行了训练、评测，实验情况如下表所示：
+
+|algorithm| Focal_CTC | A_CTC | C-CTC |
+|:------| :------| ------: | :------: |
+|gain| +0.3% | +0.7% | +1.7% |
+
+基于上述实验结论，我们在PP-OCRv2中，采用了C-CTC的策略。 值得一提的是，由于PP-OCRv2 处理的是6625个中文字符的识别任务，字符集比较大，形似字较多，所以在该任务上C-CTC 方案带来的提升较大。 但如果换做其他OCR识别任务，结论可能会有所不同。大家可以尝试Focal-CTC，A-CTC, C-CTC以及组合方案EnhancedCTC，相信会带来不同程度的提升效果。
+统一的融合方案见如下文件：  [rec_enhanced_ctc_loss.py](../../ppocr/losses/rec_enhanced_ctc_loss.py)
--- a/docs/version2.x/ppocr/blog/images/11_det.jpg
+++ b/docs/version2.x/ppocr/blog/images/11_det.jpg
--- a/docs/version2.x/ppocr/blog/images/11_det_rec.jpg
+++ b/docs/version2.x/ppocr/blog/images/11_det_rec.jpg
--- a/docs/version2.x/ppocr/blog/images/12_det.jpg
+++ b/docs/version2.x/ppocr/blog/images/12_det.jpg
--- a/docs/version2.x/ppocr/blog/images/12_det_rec.jpg
+++ b/docs/version2.x/ppocr/blog/images/12_det_rec.jpg
--- a/docs/version2.x/ppocr/blog/images/187578511-9f3c351e-b68c-4359-a6e5-475810993c61.png
+++ b/docs/version2.x/ppocr/blog/images/187578511-9f3c351e-b68c-4359-a6e5-475810993c61.png
--- a/docs/version2.x/ppocr/blog/images/254-20240709081442260.jpg
+++ b/docs/version2.x/ppocr/blog/images/254-20240709081442260.jpg
--- a/docs/version2.x/ppocr/blog/images/5e612.png
+++ b/docs/version2.x/ppocr/blog/images/5e612.png
--- a/docs/version2.x/ppocr/blog/images/DF.png
+++ b/docs/version2.x/ppocr/blog/images/DF.png
--- a/docs/version2.x/ppocr/blog/images/GTC.png
+++ b/docs/version2.x/ppocr/blog/images/GTC.png
--- a/docs/version2.x/ppocr/blog/images/LCNet_SVTR.png
+++ b/docs/version2.x/ppocr/blog/images/LCNet_SVTR.png
--- a/docs/version2.x/ppocr/blog/images/LKPAN.png
+++ b/docs/version2.x/ppocr/blog/images/LKPAN.png
--- a/docs/version2.x/ppocr/blog/images/PFHead.png
+++ b/docs/version2.x/ppocr/blog/images/PFHead.png
--- a/docs/version2.x/ppocr/blog/images/RSEFPN.png
+++ b/docs/version2.x/ppocr/blog/images/RSEFPN.png
--- a/docs/version2.x/ppocr/blog/images/SSL.png
+++ b/docs/version2.x/ppocr/blog/images/SSL.png
--- a/docs/version2.x/ppocr/blog/images/UIM.png
+++ b/docs/version2.x/ppocr/blog/images/UIM.png
--- a/docs/version2.x/ppocr/blog/images/arabic_0.jpg
+++ b/docs/version2.x/ppocr/blog/images/arabic_0.jpg
--- a/docs/version2.x/ppocr/blog/images/focal_loss_image.png
+++ b/docs/version2.x/ppocr/blog/images/focal_loss_image.png
--- a/docs/version2.x/ppocr/blog/images/french_0.jpg
+++ b/docs/version2.x/ppocr/blog/images/french_0.jpg
--- a/docs/version2.x/ppocr/blog/images/img_02.jpg
+++ b/docs/version2.x/ppocr/blog/images/img_02.jpg
--- a/docs/version2.x/ppocr/blog/images/img_12.jpg
+++ b/docs/version2.x/ppocr/blog/images/img_12.jpg
--- a/docs/version2.x/ppocr/blog/images/japan_2-20240709081138234.jpg
+++ b/docs/version2.x/ppocr/blog/images/japan_2-20240709081138234.jpg
--- a/docs/version2.x/ppocr/blog/images/korean.jpg
+++ b/docs/version2.x/ppocr/blog/images/korean.jpg
--- a/docs/version2.x/ppocr/blog/images/korean_0.jpg
+++ b/docs/version2.x/ppocr/blog/images/korean_0.jpg
--- a/docs/version2.x/ppocr/blog/images/multi_scale.png
+++ b/docs/version2.x/ppocr/blog/images/multi_scale.png
--- a/docs/version2.x/ppocr/blog/images/ppocrv3_det_cml.png
+++ b/docs/version2.x/ppocr/blog/images/ppocrv3_det_cml.png
--- a/docs/version2.x/ppocr/blog/images/ppocrv3_framework-0052468.png
+++ b/docs/version2.x/ppocr/blog/images/ppocrv3_framework-0052468.png
--- a/docs/version2.x/ppocr/blog/images/ppocrv4_det_cml.png
+++ b/docs/version2.x/ppocr/blog/images/ppocrv4_det_cml.png
--- a/docs/version2.x/ppocr/blog/images/ppocrv4_framework.png
+++ b/docs/version2.x/ppocr/blog/images/ppocrv4_framework.png
--- a/docs/version2.x/ppocr/blog/images/ppocrv4_gtc.png
+++ b/docs/version2.x/ppocr/blog/images/ppocrv4_gtc.png
--- a/docs/version2.x/ppocr/blog/images/rec_algo_compare.png
+++ b/docs/version2.x/ppocr/blog/images/rec_algo_compare.png
--- a/docs/version2.x/ppocr/blog/images/recconaug.png
+++ b/docs/version2.x/ppocr/blog/images/recconaug.png
--- a/docs/version2.x/ppocr/blog/images/svtr_g2.png
+++ b/docs/version2.x/ppocr/blog/images/svtr_g2.png
--- a/docs/version2.x/ppocr/blog/images/svtr_g4.png
+++ b/docs/version2.x/ppocr/blog/images/svtr_g4.png
--- a/docs/version2.x/ppocr/blog/images/svtr_tiny.png
+++ b/docs/version2.x/ppocr/blog/images/svtr_tiny.png
--- a/docs/version2.x/ppocr/blog/images/teacher_dml.png
+++ b/docs/version2.x/ppocr/blog/images/teacher_dml.png
--- a/docs/version2.x/ppocr/blog/images/v3_rec_pipeline.png
+++ b/docs/version2.x/ppocr/blog/images/v3_rec_pipeline.png
--- a/docs/version2.x/ppocr/blog/images/v4_rec_pipeline.png
+++ b/docs/version2.x/ppocr/blog/images/v4_rec_pipeline.png
--- a/docs/version2.x/ppocr/blog/images/word_308.png
+++ b/docs/version2.x/ppocr/blog/images/word_308.png
--- a/docs/version2.x/ppocr/blog/inference_args.en.md
+++ b/docs/version2.x/ppocr/blog/inference_args.en.md
@@ -0,0 +1,131 @@
+---
+comments: true
+---
+
+
+# PaddleOCR Model Inference Parameter Explanation
+
+When using PaddleOCR for model inference, you can customize the modification parameters to modify the model, data, preprocessing, postprocessing, etc. (parameter file: [utility.py](../../tools/infer/utility.py))，The detailed parameter explanation is as follows:
+
+* Global parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  image_dir | str | None, must be specified explicitly | Image or folder path |
+|  page_num | int | 0 | Valid when the input type is pdf file, specify to predict the previous page_num pages, all pages are predicted by default |
+|  vis_font_path | str | "./doc/fonts/simfang.ttf" | font path for visualization |
+|  drop_score | float | 0.5 | Results with a recognition score less than this value will be discarded and will not be returned as results |
+|  use_pdserving | bool | False | Whether to use Paddle Serving for prediction |
+|  warmup | bool | False | Whether to enable warmup, this method can be used when statistical prediction time |
+|  draw_img_save_dir | str | "./inference_results" | The saving folder of the system's tandem prediction OCR results |
+|  save_crop_res | bool | False  | Whether to save the recognized text image for OCR |
+|  crop_res_save_dir | str | "./output" | Save the text image path recognized by OCR |
+|  use_mp | bool | False | Whether to enable multi-process prediction  |
+|  total_process_num | int | 6 | The number of processes, which takes effect when `use_mp` is `True` |
+|  process_id | int | 0 | The id number of the current process, no need to modify it yourself |
+|  benchmark | bool | False | Whether to enable benchmark, and make statistics on prediction speed, memory usage, etc. |
+|  save_log_path | str | "./log_output/" | Folder where log results are saved when `benchmark` is enabled |
+|  show_log | bool | True | Whether to show the log information in the inference |
+|  use_onnx | bool | False | Whether to enable onnx prediction |
+
+* Prediction engine related parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  use_gpu | bool | True | Whether to use GPU for prediction |
+|  ir_optim | bool | True | Whether to analyze and optimize the calculation graph. The prediction process can be accelerated when `ir_optim` is enabled |
+|  use_tensorrt | bool | False | Whether to enable tensorrt |
+|  min_subgraph_size | int | 15 | The minimum subgraph size in tensorrt. When the size of the subgraph is greater than this value, it will try to use the trt engine to calculate the subgraph. |
+|  precision | str | fp32 | The precision of prediction, supports `fp32`, `fp16`, `int8` |
+|  enable_mkldnn | bool | True | Whether to enable mkldnn |
+|  cpu_threads | int | 10 | When mkldnn is enabled, the number of threads predicted by the cpu |
+
+* Text detection model related parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  det_algorithm | str | "DB" | Text detection algorithm name, currently supports `DB`, `EAST`, `SAST`, `PSE`, `DB++`, `FCE` |
+|  det_model_dir | str | xx | Detection inference model paths |
+|  det_limit_side_len | int | 960 | image side length limit |
+|  det_limit_type | str | "max" | The side length limit type, currently supports `min`and `max`. `min` means to ensure that the shortest side of the image is not less than `det_limit_side_len`, `max` means to ensure that the longest side of the image is not greater than `det_limit_side_len` |
+
+The relevant parameters of the DB algorithm are as follows
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  det_db_thresh | float | 0.3 | In the probability map output by DB, only pixels with a score greater than this threshold will be considered as text pixels |
+|  det_db_box_thresh | float | 0.6 | Within the detection box, when the average score of all pixels is greater than the threshold, the result will be considered as a text area |
+|  det_db_unclip_ratio | float | 1.5 | The expansion factor of the `Vatti clipping` algorithm, which is used to expand the text area |
+|  max_batch_size | int | 10 | max batch size |
+|  use_dilation | bool | False | Whether to inflate the segmentation results to obtain better detection results |
+|  det_db_score_mode | str | "fast" | DB detection result score calculation method, supports `fast` and `slow`, `fast` calculates the average score according to all pixels within the bounding rectangle of the polygon, `slow` calculates the average score according to all pixels within the original polygon, The calculation speed is relatively slower, but more accurate. |
+
+The relevant parameters of the EAST algorithm are as follows
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  det_east_score_thresh | float | 0.8 | Threshold for score map in EAST postprocess |
+|  det_east_cover_thresh | float | 0.1 | Average score threshold for text boxes in EAST postprocess |
+|  det_east_nms_thresh | float | 0.2 | Threshold of nms in EAST postprocess |
+
+The relevant parameters of the SAST algorithm are as follows
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  det_sast_score_thresh | float | 0.5 | Score thresholds in SAST postprocess |
+|  det_sast_nms_thresh | float | 0.5 | Thresholding of nms in SAST postprocess |
+|  det_box_type | str | 'quad' | Whether polygon detection, curved text scene (such as Total-Text) is set to 'poly' |
+
+The relevant parameters of the PSE algorithm are as follows
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  det_pse_thresh | float | 0.0 | Threshold for binarizing the output image |
+|  det_pse_box_thresh | float | 0.85 | Threshold for filtering boxes, below this threshold is discarded |
+|  det_pse_min_area | float | 16 | The minimum area of the box, below this threshold is discarded |
+|  det_box_type | str | "quad" | The type of the returned box, quad: four point coordinates, poly: all point coordinates of the curved text |
+|  det_pse_scale | int | 1 | The ratio of the input image relative to the post-processed image, such as an image of `640*640`, the network output is `160*160`, and when the scale is 2, the shape of the post-processed image is `320*320`. Increasing this value can speed up the post-processing speed, but it will bring about a decrease in accuracy |
+
+* Text recognition model related parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  rec_algorithm | str | "CRNN" | Text recognition algorithm name, currently supports `CRNN`, `SRN`, `RARE`, `NETR`, `SAR`, `ViTSTR`, `ABINet`, `VisionLAN`, `SPIN`, `RobustScanner`, `SVTR`, `SVTR_LCNet` |
+|  rec_model_dir | str | None, it is required if using the recognition model | recognition inference model paths |
+|  rec_image_shape | str | "3,48,320" ] | Image size at the time of recognition |
+|  rec_batch_num | int | 6 | batch size |
+|  max_text_length | int | 25 | The maximum length of the recognition result, valid in `SRN` |
+|  rec_char_dict_path | str | "./ppocr/utils/ppocr_keys_v1.txt" | character dictionary file |
+|  use_space_char | bool | True | Whether to include spaces, if `True`, the `space` character will be added at the end of the character dictionary |
+
+* End-to-end text detection and recognition model related parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  e2e_algorithm | str | "PGNet" | End-to-end algorithm name, currently supports `PGNet` |
+|  e2e_model_dir | str | None, it is required if using the end-to-end model | end-to-end model inference model path |
+|  e2e_limit_side_len | int | 768 | End-to-end input image side length limit |
+|  e2e_limit_type | str | "max" | End-to-end side length limit type, currently supports `min` and `max`. `min` means to ensure that the shortest side of the image is not less than `e2e_limit_side_len`, `max` means to ensure that the longest side of the image is not greater than `e2e_limit_side_len` |
+|  e2e_pgnet_score_thresh | float | 0.5 | End-to-end score threshold, results below this threshold are discarded |
+|  e2e_char_dict_path | str | "./ppocr/utils/ic15_dict.txt" | Recognition dictionary file path |
+|  e2e_pgnet_valid_set | str | "totaltext" | The name of the validation set, currently supports `totaltext`, `partvgg`, the post-processing methods corresponding to different data sets are different, and it can be consistent with the training process |
+|  e2e_pgnet_mode | str | "fast" | PGNet's detection result score calculation method, supports `fast` and `slow`, `fast` calculates the average score according to all pixels within the bounding rectangle of the polygon, `slow` calculates the average score according to all pixels within the original polygon, The calculation speed is relatively slower, but more accurate. |
+
+* Angle classifier model related parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  use_angle_cls | bool | False | whether to use an angle classifier |
+|  cls_model_dir | str | None, if you need to use, you must specify the path explicitly | angle classifier inference model path |
+|  cls_image_shape | str | "3,48,192" | prediction shape |
+|  label_list | list | ['0', '180'] | The angle value corresponding to the class id |
+|  cls_batch_num | int | 6 | batch size |
+|  cls_thresh | float | 0.9 | Prediction threshold, when the model prediction result is 180 degrees, and the score is greater than the threshold, the final prediction result is considered to be 180 degrees and needs to be flipped |
+
+* OCR image preprocessing parameters
+
+| parameters | type | default | implication |
+| :--: | :--: | :--: | :--: |
+|  invert | bool | False | whether to invert image before processing |
+|  binarize | bool | False | whether to threshold binarize image before processing |
+|  alphacolor | tuple | "255,255,255" | Replacement color for the alpha channel, if the latter is present; R,G,B integers |
--- a/docs/version2.x/ppocr/blog/inference_args.md
+++ b/docs/version2.x/ppocr/blog/inference_args.md
@@ -0,0 +1,118 @@
+# PaddleOCR模型推理参数解释
+
+在使用PaddleOCR进行模型推理时，可以自定义修改参数，来修改模型、数据、预处理、后处理等内容（参数文件：[utility.py](../../tools/infer/utility.py)），详细的参数解释如下所示。
+
+* 全局信息
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  image_dir | str | 无，必须显式指定 | 图像或者文件夹路径 |
+|  page_num | int | 0 | 当输入类型为pdf文件时有效，指定预测前面page_num页，默认预测所有页 |
+|  vis_font_path | str | "./doc/fonts/simfang.ttf" | 用于可视化的字体路径 |
+|  drop_score | float | 0.5 | 识别得分小于该值的结果会被丢弃，不会作为返回结果 |
+|  use_pdserving | bool | False | 是否使用Paddle Serving进行预测 |
+|  warmup | bool | False | 是否开启warmup，在统计预测耗时的时候，可以使用这种方法 |
+|  draw_img_save_dir | str | "./inference_results" | 系统串联预测OCR结果的保存文件夹 |
+|  save_crop_res | bool | False  | 是否保存OCR的识别文本图像 |
+|  crop_res_save_dir | str | "./output" | 保存OCR识别出来的文本图像路径 |
+|  use_mp | bool | False | 是否开启多进程预测  |
+|  total_process_num | int | 6 | 开启的进程数，`use_mp`为`True`时生效  |
+|  process_id | int | 0 | 当前进程的id号，无需自己修改  |
+|  benchmark | bool | False | 是否开启benchmark，对预测速度、显存占用等进行统计  |
+|  save_log_path | str | "./log_output/" | 开启`benchmark`时，日志结果的保存文件夹 |
+|  show_log | bool | True | 是否显示预测中的日志信息  |
+|  use_onnx | bool | False | 是否开启onnx预测 |
+
+* 预测引擎相关
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  use_gpu | bool | True | 是否使用GPU进行预测 |
+|  ir_optim | bool | True | 是否对计算图进行分析与优化，开启后可以加速预测过程 |
+|  use_tensorrt | bool | False | 是否开启tensorrt |
+|  min_subgraph_size | int | 15 | tensorrt中最小子图size，当子图的size大于该值时，才会尝试对该子图使用trt engine计算 |
+|  precision | str | fp32 | 预测的精度，支持`fp32`, `fp16`, `int8` 3种输入 |
+|  enable_mkldnn | bool | True | 是否开启mkldnn |
+|  cpu_threads | int | 10 | 开启mkldnn时，cpu预测的线程数 |
+
+* 文本检测模型相关
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  det_algorithm | str | "DB" | 文本检测算法名称，目前支持`DB`, `EAST`, `SAST`, `PSE`, `DB++`, `FCE`  |
+|  det_model_dir | str | xx | 检测inference模型路径 |
+|  det_limit_side_len | int | 960 | 检测的图像边长限制 |
+|  det_limit_type | str | "max" | 检测的边长限制类型，目前支持`min`和`max`，`min`表示保证图像最短边不小于`det_limit_side_len`，`max`表示保证图像最长边不大于`det_limit_side_len` |
+
+其中，DB算法相关参数如下
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  det_db_thresh | float | 0.3 | DB输出的概率图中，得分大于该阈值的像素点才会被认为是文字像素点 |
+|  det_db_box_thresh | float | 0.6 | 检测结果边框内，所有像素点的平均得分大于该阈值时，该结果会被认为是文字区域 |
+|  det_db_unclip_ratio | float | 1.5 | `Vatti clipping`算法的扩张系数，使用该方法对文字区域进行扩张 |
+|  max_batch_size | int | 10 | 预测的batch size |
+|  use_dilation | bool | False | 是否对分割结果进行膨胀以获取更优检测效果 |
+|  det_db_score_mode | str | "fast" | DB的检测结果得分计算方法，支持`fast`和`slow`，`fast`是根据polygon的外接矩形边框内的所有像素计算平均得分，`slow`是根据原始polygon内的所有像素计算平均得分，计算速度相对较慢一些，但是更加准确一些。 |
+
+EAST算法相关参数如下
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  det_east_score_thresh | float | 0.8 | EAST后处理中score map的阈值 |
+|  det_east_cover_thresh | float | 0.1 | EAST后处理中文本框的平均得分阈值 |
+|  det_east_nms_thresh | float | 0.2 | EAST后处理中nms的阈值 |
+
+SAST算法相关参数如下
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  det_sast_score_thresh | float | 0.5 | SAST后处理中的得分阈值 |
+|  det_sast_nms_thresh | float | 0.5 | SAST后处理中nms的阈值 |
+|  det_box_type | str | quad | 是否多边形检测，弯曲文本场景（如Total-Text）设置为'poly' |
+
+PSE算法相关参数如下
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  det_pse_thresh | float | 0.0 | 对输出图做二值化的阈值 |
+|  det_pse_box_thresh | float | 0.85 | 对box进行过滤的阈值，低于此阈值的丢弃 |
+|  det_pse_min_area | float | 16 | box的最小面积，低于此阈值的丢弃 |
+|  det_box_type | str | "quad" | 返回框的类型，quad:四点坐标，poly: 弯曲文本的所有点坐标 |
+|  det_pse_scale | int | 1 | 输入图像相对于进后处理的图的比例，如`640*640`的图像，网络输出为`160*160`，scale为2的情况下，进后处理的图片shape为`320*320`。这个值调大可以加快后处理速度，但是会带来精度的下降 |
+
+* 文本识别模型相关
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  rec_algorithm | str | "CRNN" | 文本识别算法名称，目前支持`CRNN`, `SRN`, `RARE`, `NETR`, `SAR`, `ViTSTR`, `ABINet`, `VisionLAN`, `SPIN`, `RobustScanner`, `SVTR`, `SVTR_LCNet` |
+|  rec_model_dir | str | 无，如果使用识别模型，该项是必填项 | 识别inference模型路径 |
+|  rec_image_shape | str | "3,48,320" | 识别时的图像尺寸 |
+|  rec_batch_num | int | 6 | 识别的batch size |
+|  max_text_length | int | 25 | 识别结果最大长度，在`SRN`中有效 |
+|  rec_char_dict_path | str | "./ppocr/utils/ppocr_keys_v1.txt" | 识别的字符字典文件 |
+|  use_space_char | bool | True | 是否包含空格，如果为`True`，则会在最后字符字典中补充`空格`字符 |
+
+* 端到端文本检测与识别模型相关
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  e2e_algorithm | str | "PGNet" | 端到端算法名称，目前支持`PGNet` |
+|  e2e_model_dir | str | 无，如果使用端到端模型，该项是必填项 | 端到端模型inference模型路径 |
+|  e2e_limit_side_len | int | 768 | 端到端的输入图像边长限制 |
+|  e2e_limit_type | str | "max" | 端到端的边长限制类型，目前支持`min`, `max`，`min`表示保证图像最短边不小于`e2e_limit_side_len`，`max`表示保证图像最长边不大于`e2e_limit_side_len` |
+|  e2e_pgnet_score_thresh | float | 0.5 | 端到端得分阈值，小于该阈值的结果会被丢弃 |
+|  e2e_char_dict_path | str | "./ppocr/utils/ic15_dict.txt" | 识别的字典文件路径 |
+|  e2e_pgnet_valid_set | str | "totaltext" | 验证集名称，目前支持`totaltext`, `partvgg`，不同数据集对应的后处理方式不同，与训练过程保持一致即可 |
+|  e2e_pgnet_mode | str | "fast" | PGNet的检测结果得分计算方法，支持`fast`和`slow`，`fast`是根据polygon的外接矩形边框内的所有像素计算平均得分，`slow`是根据原始polygon内的所有像素计算平均得分，计算速度相对较慢一些，但是更加准确一些。 |
+
+* 方向分类器模型相关
+
+| 参数名称 | 类型 | 默认值 | 含义 |
+| :--: | :--: | :--: | :--: |
+|  use_angle_cls | bool | False | 是否使用方向分类器 |
+|  cls_model_dir | str | 无，如果需要使用，则必须显式指定路径 | 方向分类器inference模型路径 |
+|  cls_image_shape | str | "3,48,192" | 预测尺度 |
+|  label_list | list | ['0', '180'] | class id对应的角度值 |
+|  cls_batch_num | int | 6 | 方向分类器预测的batch size |
+|  cls_thresh | float | 0.9 | 预测阈值，模型预测结果为180度，且得分大于该阈值时，认为最终预测结果为180度，需要翻转 |
--- a/docs/version2.x/ppocr/blog/multi_languages.en.md
+++ b/docs/version2.x/ppocr/blog/multi_languages.en.md
@@ -0,0 +1,225 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# Multi-language model
+
+**Recent Update**
+
+- 2022.5.8 update the `PP-OCRv3` version of the multi-language detection and recognition model, and the average recognition accuracy has increased by more than 5%.
+- 2021.4.9 supports the detection and recognition of 80 languages
+- 2021.4.9 supports **lightweight high-precision** English model detection and recognition
+
+PaddleOCR aims to create a rich, leading, and practical OCR tool library, which not only provides
+Chinese and English models in general scenarios, but also provides models specifically trained
+in English scenarios. And multilingual models covering [80 languages](#language_abbreviations).
+
+Among them, the English model supports the detection and recognition of uppercase and lowercase
+letters and common punctuation, and the recognition of space characters is optimized:
+
+![img](./images/img_12.jpg)
+
+The multilingual models cover Latin, Arabic, Traditional Chinese, Korean, Japanese, etc.:
+
+![img](./images/japan_2-20240709081138234.jpg)
+
+![img](./images/french_0.jpg)
+
+![img](./images/korean_0.jpg)
+
+![img](./images/arabic_0.jpg)
+
+This document will briefly introduce how to use the multilingual model.
+
+## 1 Installation
+
+### 1.1 Paddle installation
+
+```bash linenums="1"
+# cpu
+pip install "paddlepaddle<=2.6"
+
+# gpu
+pip install "paddlepaddle-gpu<=2.6"
+```
+
+### 1.2 PaddleOCR package installation
+
+```bash linenums="1"
+pip install "paddleocr<3.0"
+```
+
+Build and install locally
+
+```bash linenums="1"
+python3 -m build
+pip3 install dist/paddleocr-x.x.x-py3-none-any.whl # x.x.x is the version number of paddleocr
+```
+
+## 2 Quick use
+
+### 2.1 Command line operation
+
+View help information
+
+```bash linenums="1"
+paddleocr -h
+```
+
+- Whole image prediction (detection + recognition)
+
+PaddleOCR currently supports 80 languages, which can be specified by the --lang parameter.
+The supported languages are listed in the [table](#language_abbreviations).
+
+``` bash
+paddleocr --image_dir doc/imgs_en/254.jpg --lang=en
+```
+
+![](./images/254-20240709081442260.jpg)
+
+![img](./images/img_02.jpg)
+
+The result is a list. Each item contains a text box, text and recognition confidence
+
+```text linenums="1"
+[('PHO CAPITAL', 0.95723116), [[66.0, 50.0], [327.0, 44.0], [327.0, 76.0], [67.0, 82.0]]]
+[('107 State Street', 0.96311164), [[72.0, 90.0], [451.0, 84.0], [452.0, 116.0], [73.0, 121.0]]]
+[('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]]]
+......
+```
+
+- Recognition
+
+```bash linenums="1"
+paddleocr --image_dir doc/imgs_words_en/word_308.png --det false --lang=en
+```
+
+![img](./images/word_308.png)
+
+The result is a 2-tuple, which contains the recognition result and recognition confidence
+
+```text linenums="1"
+(0.99879867, 'LITTLE')
+```
+
+- Detection
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --rec false
+```
+
+The result is a list. Each item represents the coordinates of a text box.
+
+```bash linenums="1"
+[[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]]
+......
+```
+
+### 2.2 Run with Python script
+
+PPOCR is able to run with Python scripts for easy integration with your own code:
+
+- Whole image prediction (detection + recognition)
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# Also switch the language by modifying the lang parameter
+ocr = PaddleOCR(lang="korean") # The model file will be downloaded automatically when executed for the first time
+img_path ='doc/imgs/korean_1.jpg'
+result = ocr.ocr(img_path)
+# Recognition and detection can be performed separately through parameter control
+# result = ocr.ocr(img_path, det=False)  Only perform recognition
+# result = ocr.ocr(img_path, rec=False)  Only perform detection
+# Print detection frame and recognition result
+for line in result:
+    print(line)
+
+# Visualization
+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='/path/to/PaddleOCR/doc/fonts/korean.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+Visualization of results:
+
+![img](./images/korean.jpg)
+
+PPOCR also supports direction classification. For more detailed usage, please refer to: [whl package instructions](whl_en.md).
+
+## 3 Custom training
+
+PPOCR supports using your own data for custom training or fine-tune, where the recognition model can refer to [French configuration file](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/rec_french_lite_train.yml)
+Modify the training data path, dictionary and other parameters.
+
+For specific data preparation and training process, please refer to: [Text Detection](../doc_en/detection_en.md), [Text Recognition](../doc_en/recognition_en.md), more functions such as predictive deployment,
+For functions such as data annotation, you can read the complete [Document Tutorial](../../README.md).
+
+## 4 Inference and Deployment
+
+In addition to installing the whl package for quick forecasting,
+PPOCR also provides a variety of forecasting deployment methods.
+If necessary, you can read related documents:
+
+- [Python Inference](./inference_ppocr_en.md)
+- [C++ Inference](../../deploy/cpp_infer/readme.md)
+- [Serving](../../deploy/hubserving/readme_en.md)
+- [Mobile](../../deploy/lite/readme.md)
+- [Benchmark](./benchmark_en.md)
+
+## 5 Support languages and abbreviations
+
+| Language  | Abbreviation | | Language  | Abbreviation |
+| ---  | --- | --- | ---  | --- |
+|Chinese & English|ch| |Arabic|ar|
+|English|en| |Hindi|hi|
+|French|fr| |Uyghur|ug|
+|German|german| |Persian|fa|
+|Japanese|japan| |Urdu|ur|
+|Korean|korean| | Serbian(latin) |rs_latin|
+|Chinese Traditional |chinese_cht| |Occitan |oc|
+| Italian |it| |Marathi|mr|
+|Spanish |es| |Nepali|ne|
+| Portuguese|pt| |Serbian(cyrillic)|rs_cyrillic|
+|Russian|ru||Bulgarian |bg|
+|Ukranian|uk| |Estonian |et|
+|Belarusian|be| |Irish |ga|
+|Telugu |te| |Croatian |hr|
+|Sanskrit|sa| |Hungarian |hu|
+|Tamil |ta| |Indonesian|id|
+|Afrikaans |af| |Icelandic|is|
+|Azerbaijani  |az||Kurdish|ku|
+|Bosnian|bs| |Lithuanian |lt|
+|Czech|cs| |Latvian |lv|
+|Welsh |cy| |Maori|mi|
+|Danish|da| |Malay|ms|
+|Maltese |mt| |Adyghe |ady|
+|Dutch |nl| |Kabardian |kbd|
+|Norwegian |no| |Avar |ava|
+|Polish |pl| |Dargwa |dar|
+|Romanian |ro| |Ingush |inh|
+|Slovak |sk| |Lak |lbe|
+|Slovenian |sl| |Lezghian |lez|
+|Albanian |sq| |Tabassaran |tab|
+|Swedish |sv| |Bihari |bh|
+|Swahili |sw| |Maithili |mai|
+|Tagalog |tl| |Angika |ang|
+|Turkish |tr| |Bhojpuri |bho|
+|Uzbek |uz| |Magahi |mah|
+|Vietnamese |vi| |Nagpur |sck|
+|Mongolian |mn| |Newari |new|
+|Abaza |abq| |Goan Konkani|gom|
+|Chechen |che| |Pali |pi|
+|Haryanvi |bgc| |Latin |la|
--- a/docs/version2.x/ppocr/blog/multi_languages.md
+++ b/docs/version2.x/ppocr/blog/multi_languages.md
@@ -0,0 +1,275 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# 多语言模型
+
+**近期更新**
+
+- 2022.5.8 更新`PP-OCRv3`版 多语言检测和识别模型，平均识别准确率提升5%以上。
+- 2021.4.9 支持**80种**语言的检测和识别
+- 2021.4.9 支持**轻量高精度**英文模型检测识别
+
+PaddleOCR 旨在打造一套丰富、领先、且实用的OCR工具库，不仅提供了通用场景下的中英文模型，也提供了专门在英文场景下训练的模型，
+和覆盖[80个语言](#语种缩写)的小语种模型。
+
+其中英文模型支持，大小写字母和常见标点的检测识别，并优化了空格字符的识别：
+
+![img](./images/img_12.jpg)
+
+小语种模型覆盖了拉丁语系、阿拉伯语系、中文繁体、韩语、日语等等：
+
+![img](./images/japan_2-20240709081138234.jpg)
+
+![img](./images/french_0.jpg)
+
+![img](./images/korean_0.jpg)
+
+![img](./images/arabic_0.jpg)
+
+本文档将简要介绍小语种模型的使用方法。
+
+## 1 安装
+
+### 1.1 paddle 安装
+
+```bash linenums="1"
+# cpu
+pip install "paddlepaddle<=2.6"
+
+# gpu
+pip install "paddlepaddle-gpu<=2.6"
+```
+
+### 1.2 paddleocr package 安装
+
+pip 安装
+
+```bash linenums="1"
+pip install "paddleocr<3.0"
+```
+
+本地构建并安装
+
+```bash linenums="1"
+python3 -m build
+pip3 install dist/paddleocr-x.x.x-py3-none-any.whl # x.x.x是paddleocr的版本号
+```
+
+## 2 快速使用
+
+### 2.1 命令行运行
+
+查看帮助信息
+
+```bash linenums="1"
+paddleocr -h
+```
+
+- 整图预测（检测+识别）
+
+Paddleocr目前支持80个语种，可以通过修改--lang参数进行切换，具体支持的[语种](#语种缩写)可查看表格。
+
+``` bash
+paddleocr --image_dir doc/imgs_en/254.jpg --lang=en
+```
+
+![](./images/254-20240709081442260.jpg)
+
+![img](./images/img_02.jpg)
+
+结果是一个list，每个item包含了文本框，文字和识别置信度
+
+```text linenums="1"
+[('PHO CAPITAL', 0.95723116), [[66.0, 50.0], [327.0, 44.0], [327.0, 76.0], [67.0, 82.0]]]
+[('107 State Street', 0.96311164), [[72.0, 90.0], [451.0, 84.0], [452.0, 116.0], [73.0, 121.0]]]
+[('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]]]
+......
+```
+
+- 识别预测
+
+```bash linenums="1"
+paddleocr --image_dir doc/imgs_words_en/word_308.png --det false --lang=en
+```
+
+![img](./images/word_308.png)
+
+结果是一个tuple，返回识别结果和识别置信度
+
+```text linenums="1"
+(0.99879867, 'LITTLE')
+```
+
+- 检测预测
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --rec false
+```
+
+结果是一个list，每个item只包含文本框
+
+```bash linenums="1"
+[[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]]
+......
+```
+
+### 2.2 python 脚本运行
+
+ppocr 也支持在python脚本中运行，便于嵌入到您自己的代码中 ：
+
+- 整图预测（检测+识别）
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# 同样也是通过修改 lang 参数切换语种
+ocr = PaddleOCR(lang="korean") # 首次执行会自动下载模型文件
+img_path = 'doc/imgs/korean_1.jpg '
+result = ocr.ocr(img_path)
+# 可通过参数控制单独执行识别、检测
+# result = ocr.ocr(img_path, det=False) 只执行识别
+# result = ocr.ocr(img_path, rec=False) 只执行检测
+# 打印检测框和识别结果
+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='/path/to/PaddleOCR/doc/fonts/korean.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+结果可视化:
+
+![img](./images/korean.jpg)
+
+ppocr 还支持方向分类， 更多使用方式请参考：[whl包使用说明](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.0/doc/doc_ch/whl.md)
+
+## 3 自定义训练
+
+ppocr 支持使用自己的数据进行自定义训练或finetune, 其中识别模型可以参考[法语配置文件](https://github.com/PaddlePaddle/PaddleOCR/tree/main/configs/rec/multi_language/rec_french_lite_train.yml)
+修改训练数据路径、字典等参数。
+
+详细数据准备、训练过程可参考：[文本识别](../doc_ch/recognition.md)、[文本检测](../doc_ch/detection.md)。
+
+假设已经准备好了训练数据，可根据以下步骤快速启动训练：
+
+- 修改配置文件
+
+以 `rec_french_lite_train.yml` 为例：
+
+```yaml linenums="1"
+Global:
+  ...
+  # 添加自定义字典，如修改字典请将路径指向新字典
+  character_dict_path: ./ppocr/utils/dict/french_dict.txt
+  ...
+  # 识别空格
+  use_space_char: True
+
+...
+
+Train:
+  dataset:
+    # 数据集格式，支持LMDBDataSet以及SimpleDataSet
+    name: SimpleDataSet
+    # 数据集路径
+    data_dir: ./train_data/
+    # 训练集标签文件
+    label_file_list: ["./train_data/french_train.txt"]
+    ...
+
+Eval:
+  dataset:
+    # 数据集格式，支持LMDBDataSet以及SimpleDataSet
+    name: SimpleDataSet
+    # 数据集路径
+    data_dir: ./train_data
+    # 验证集标签文件
+    label_file_list: ["./train_data/french_val.txt"]
+    ...
+```
+
+- 启动训练：
+
+```bash linenums="1"
+# 下载预训练模型
+wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/multilingual/french_mobile_v2.0_rec_train.tar
+tar -xf french_mobile_v2.0_rec_train.tar
+
+#加载预训练模型 单卡训练
+python3 tools/train.py -c configs/rec/rec_french_lite_train.yml -o Global.pretrained_model=french_mobile_v2.0_rec_train/best_accuracy
+
+#加载预训练模型  多卡训练，通过--gpus参数指定卡号
+python3 -m paddle.distributed.launch --gpus '0,1,2,3'  tools/train.py -c configs/rec/rec_french_lite_train.yml -o Global.pretrained_model=french_mobile_v2.0_rec_train/best_accuracy
+```
+
+更多功能如预测部署、数据标注等功能可以阅读完整的[文档教程](../../README_ch.md)。
+
+## 4 预测部署
+
+除了安装whl包进行快速预测，ppocr 也提供了多种预测部署方式，如有需求可阅读相关文档：
+
+- [基于Python脚本预测引擎推理](./inference_ppocr.md)
+- [基于C++预测引擎推理](../../deploy/cpp_infer/readme_ch.md)
+- [服务化部署](../../deploy/hubserving/readme.md)
+- [端侧部署](../../deploy/lite/readme_ch.md)
+- [Benchmark](./benchmark.md)
+
+## 5 支持语种及缩写
+
+| 语种 | 描述 | 缩写 | | 语种 | 描述 | 缩写 |
+| --- | --- | --- | ---|--- | --- | --- |
+|中文|Chinese & English|ch| |保加利亚文|Bulgarian |bg|
+|英文|English|en| |乌克兰文|Ukranian|uk|
+|法文|French|fr| |白俄罗斯文|Belarusian|be|
+|德文|German|german| |泰卢固文|Telugu |te|
+|日文|Japanese|japan| | 阿巴扎文 |Abaza | abq |
+|韩文|Korean|korean| |泰米尔文|Tamil |ta|
+|中文繁体|Chinese Traditional |chinese_cht| |南非荷兰文 |Afrikaans |af|
+|意大利文| Italian |it| |阿塞拜疆文 |Azerbaijani    |az|
+|西班牙文|Spanish |es| |波斯尼亚文|Bosnian|bs|
+|葡萄牙文| Portuguese|pt| |捷克文|Czech|cs|
+|俄罗斯文|Russian|ru| |威尔士文 |Welsh |cy|
+|阿拉伯文|Arabic|ar| |丹麦文 |Danish|da|
+|印地文|Hindi|hi| |爱沙尼亚文 |Estonian |et|
+|维吾尔|Uyghur|ug| |爱尔兰文 |Irish |ga|
+|波斯文|Persian|fa| |克罗地亚文|Croatian |hr|
+|乌尔都文|Urdu|ur| |匈牙利文|Hungarian |hu|
+|塞尔维亚文（latin)| Serbian(latin) |rs_latin| |印尼文|Indonesian|id|
+|欧西坦文|Occitan |oc| |冰岛文 |Icelandic|is|
+|马拉地文|Marathi|mr| |库尔德文 |Kurdish|ku|
+|尼泊尔文|Nepali|ne| |立陶宛文|Lithuanian |lt|
+|塞尔维亚文（cyrillic)|Serbian(cyrillic)|rs_cyrillic| |拉脱维亚文 |Latvian |lv|
+|毛利文|Maori|mi| | 达尔瓦文|Dargwa |dar|
+|马来文 |Malay|ms| | 因古什文|Ingush |inh|
+|马耳他文 |Maltese |mt| | 拉克文|Lak |lbe|
+|荷兰文 |Dutch |nl| | 莱兹甘文|Lezghian |lez|
+|挪威文 |Norwegian |no| |塔巴萨兰文 |Tabassaran |tab|
+|波兰文|Polish |pl| | 比尔哈文|Bihari |bh|
+| 罗马尼亚文|Romanian |ro| | 迈蒂利文|Maithili |mai|
+| 斯洛伐克文|Slovak |sk| | 昂加文|Angika |ang|
+| 斯洛文尼亚文|Slovenian |sl| | 孟加拉文|Bhojpuri |bho|
+| 阿尔巴尼亚文|Albanian |sq| | 摩揭陀文 |Magahi |mah|
+| 瑞典文|Swedish |sv| | 那格浦尔文|Nagpur |sck|
+| 西瓦希里文|Swahili |sw| | 尼瓦尔文|Newari |new|
+| 塔加洛文|Tagalog |tl| | 保加利亚文 |Goan Konkani|gom|
+| 土耳其文|Turkish |tr| | 梵文|Sanskrit|sa|
+| 乌兹别克文|Uzbek |uz| | 阿瓦尔文|Avar |ava|
+| 越南文|Vietnamese |vi| | 阿瓦尔文|Avar |ava|
+| 蒙古文|Mongolian |mn| | 阿迪赫文|Adyghe |ady|
+| 车臣文 |Chechen |che| | 巴利文 |Pali |pi|
+| 哈里亚纳语 |Haryanvi |bgc| | 拉丁文 |Latin |la|
--- a/docs/version2.x/ppocr/blog/ocr_book.en.md
+++ b/docs/version2.x/ppocr/blog/ocr_book.en.md
@@ -0,0 +1,28 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# E-book: *Dive Into OCR*
+
+"Dive Into OCR" is a textbook that combines OCR theory and practice, written by the PaddleOCR community. 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
+- Jupyter Notebook textbook, flexibly modifying code for instant results
+
+## Structure
+
+![img](./images/187578511-9f3c351e-b68c-4359-a6e5-475810993c61.png)
+
+- The first part is the preliminary knowledge of the book, including the knowledge index and resource links needed in the process of positioning and using the book content of the book
+
+- The second part is chapters 4-8 of the book, which introduce the concepts, applications, and industry practices related to the detection and identification capabilities of the OCR engine. In the "Introduction to OCR Technology", the application scenarios and challenges of OCR, the basic concepts of technology, and the pain points in industrial applications are comprehensively explained. Then, in the two chapters of "Text Detection" and "Text Recognition", the two basic tasks of OCR are introduced. In each chapter, an algorithm is accompanied by a detailed explanation of the code and practical exercises. Chapters 6 and 7 are a detailed introduction to the PP-OCR series model, PP-OCR is a set of OCR systems for industrial applications, on the basis of the basic detection and identification model, after a series of optimization strategies to achieve the general field of industrial SOTA model, while opening up a variety of predictive deployment solutions, enabling enterprises to quickly land OCR applications.
+
+- The third part is chapter 9-12 of the book, which introduces applications other than the two-stage OCR engine, including data synthesis, preprocessing algorithm, and end-to-end model, focusing on OCR's layout analysis, table recognition, visual document question and answer capabilities in the document scene, and also through the combination of algorithm and code, so that readers can deeply understand and apply.
+
+## Address
+
+- [E-book: *Dive Into OCR* (PDF)](https://paddleocr.bj.bcebos.com/ebook/Dive_into_OCR.pdf)
+- [Notebook (.ipynb)](https://github.com/PaddleOCR-Community/Dive-into-OCR)
+- [Videos (Chinese only)](https://aistudio.baidu.com/aistudio/education/group/info/25207)
--- a/docs/version2.x/ppocr/blog/ocr_book.md
+++ b/docs/version2.x/ppocr/blog/ocr_book.md
@@ -0,0 +1,29 @@
+---
+comments: true
+typora-copy-images-to: images
+---
+
+# 《动手学OCR》电子书
+
+《动手学OCR》是PaddleOCR团队携手华中科技大学博导/教授，IAPR Fellow 白翔、复旦大学青年研究员陈智能、中国移动研究院视觉领域资深专家黄文辉、中国工商银行大数据人工智能实验室研究员等产学研同仁，以及OCR开发者共同打造的结合OCR前沿理论与代码实践的教材。主要特色如下：
+
+- 覆盖从文本检测识别到文档分析的OCR全栈技术
+- 紧密结合理论实践，跨越代码实现鸿沟，并配套教学视频
+- Notebook交互式学习，灵活修改代码，即刻获得结果
+
+## 本书结构
+
+![](./images/5e612.png)
+
+- 第一部分是本书的推荐序、序言与预备知识，包含本书的定位与使用书籍内容的过程中需要用到的知识索引、资源链接等
+- 第二部分是本书的4-8章，介绍与OCR核心的检测、识别能力相关的概念、应用与产业实践。在“OCR技术导论”中总括性的解释OCR的应用场景和挑战、技术基本概念以及在产业应用中的痛点问题。然后在
+“文本检测”与“文本识别”两章中介绍OCR的两个基本任务，并在每章中配套一个算法展开代码详解与实战练习。第6、7章是关于PP-OCR系列模型的详细介绍，PP-OCR是一套面向产业应用的OCR系统，在
+基础检测和识别模型的基础之上经过一系列优化策略达到通用领域的产业级SOTA模型，同时打通多种预测部署方案，赋能企业快速落地OCR应用。
+- 第三部分是本书的9-12章，介绍两阶段OCR引擎之外的应用，包括数据合成、预处理算法、端到端模型，重点展开了OCR在文档场景下的版面分析、表格识别、视觉文档问答的能力，同样通过算法与代码结
+合的方式使得读者能够深入理解并应用。
+
+## 资料地址
+
+-  🎁《动手学OCR》、《OCR产业范例20讲》电子书、OCR垂类模型、PDF2Word软件以及其他学习大礼包领取链接：[百度网盘 PaddleOCR 开源大礼包](https://pan.baidu.com/s/1h__OYbbQ_rASB-m8ZC1bCA)，提取码：4232
+- [notebook教程](https://github.com/PaddleOCR-Community/Dive-into-OCR)
+- [教学视频](https://aistudio.baidu.com/aistudio/education/group/info/25207)
--- a/docs/version2.x/ppocr/blog/slice.en.md
+++ b/docs/version2.x/ppocr/blog/slice.en.md
@@ -0,0 +1,22 @@
+---
+comments: true
+---
+
+
+# Slice Operator
+
+If you have a very large image/document that you would like to run PaddleOCR (detection and recognition) on, you can use the slice operation as follows:
+
+`ocr_inst  =  PaddleOCR(**ocr_settings)`
+`results  =  ocr_inst.ocr(img, det=True,rec=True, slice=slice, cls=False,bin=False,inv=False,alpha_color=False)`
+
+where
+`slice  = {'horizontal_stride': h_stride, 'vertical_stride':v_stride, 'merge_x_thres':x_thres, 'merge_y_thres': y_thres}`
+
+Here, `h_stride`, `v_stride`, `x_thres`, and `y_thres` are user-configurable values and need to be set manually. The way the `slice` operator works is that it runs a sliding window across the large input image, creating slices of it and runs the OCR algorithms on it.
+
+The fragmented slice-level results are then merged together to output image-level detection and recognition results. The horizontal and vertical strides cannot be lower than a certain limit (as too low values would create so many slices it would be very computationally expensive to get results for each of them). However, as an example the recommended values for an image with dimensions 6616x14886 would be as follows.
+
+`slice = {'horizontal_stride': 300, 'vertical_stride':500, 'merge_x_thres':50, 'merge_y_thres': 35}`
+
+All slice-level detections with bounding boxes as close as `merge_x_thres` and `merge_y_thres` will be merged together.
--- a/docs/version2.x/ppocr/blog/slice.md
+++ b/docs/version2.x/ppocr/blog/slice.md
@@ -0,0 +1,25 @@
+---
+comments: true
+---
+
+# 切片操作
+
+如果希望运行 PaddleOCR 处理一张非常大的图像或文档，对其进行检测和识别，可以使用切片操作，如下所示：
+
+```python linenums="1"
+ocr_inst = PaddleOCR(**ocr_settings)
+results = ocr_inst.ocr(img, det=True, rec=True, slice=slice, cls=False, bin=False, inv=False, alpha_color=False)
+```
+
+其中，
+`slice = {'horizontal_stride': h_stride, 'vertical_stride': v_stride, 'merge_x_thres': x_thres, 'merge_y_thres': y_thres}`
+
+这里的 `h_stride`、`v_stride`、`x_thres` 和 `y_thres` 是用户可配置的参数，需要手动设置。切片操作符的工作原理是，在大图像上运行一个滑动窗口，创建图像的切片，并在这些切片上运行 OCR 算法。
+
+然后将这些切片级别的零散结果合并，生成图像级别的检测和识别结果。水平和垂直步幅不能低于一定限度，因为过低的值会产生太多切片，导致计算结果非常耗时。例如，对于尺寸为 6616x14886 的图像，推荐使用以下参数：
+
+```python linenums="1"
+slice = {'horizontal_stride': 300, 'vertical_stride': 500, 'merge_x_thres': 50, 'merge_y_thres': 35}
+```
+
+所有边界框接近 `merge_x_thres` 和 `merge_y_thres` 的切片级检测结果将被合并在一起。
--- a/docs/version2.x/ppocr/blog/whl.en.md
+++ b/docs/version2.x/ppocr/blog/whl.en.md
@@ -0,0 +1,488 @@
+---
+typora-copy-images-to: images
+comments: true
+---
+
+# Paddleocr Package
+
+## 1 Get started quickly
+
+### 1.1 Install package
+
+install by pypi
+
+```bash linenums="1"
+pip install "paddleocr>=2.0.1" # Recommend to use version 2.0.1+
+```
+
+build own whl package and install
+
+```bash linenums="1"
+python3 -m build
+pip3 install dist/paddleocr-x.x.x-py3-none-any.whl # x.x.x is the version of paddleocr
+```
+
+## 2 Use
+
+### 2.1 Use by code
+
+The paddleocr whl package will automatically download the ppocr lightweight model as the default model, which can be customized and replaced according to the section 3 **Custom Model**.
+
+* detection angle classification and recognition
+
+```python linenums="1"
+from paddleocr import PaddleOCR,draw_ocr
+# Paddleocr supports Chinese, English, French, German, Korean and Japanese.
+# You can set the parameter `lang` as `ch`, `en`, `french`, `german`, `korean`, `japan`
+# to switch the language model in order.
+ocr = PaddleOCR(use_angle_cls=True, lang='en') # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_en/img_12.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# draw result
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+Output will be a list, each item contains bounding box, text and recognition confidence
+
+```bash linenums="1"
+[[[442.0, 173.0], [1169.0, 173.0], [1169.0, 225.0], [442.0, 225.0]], ['ACKNOWLEDGEMENTS', 0.99283075]]
+[[[393.0, 340.0], [1207.0, 342.0], [1207.0, 389.0], [393.0, 387.0]], ['We would like to thank all the designers and', 0.9357758]]
+[[[399.0, 398.0], [1204.0, 398.0], [1204.0, 433.0], [399.0, 433.0]], ['contributors whohave been involved in the', 0.9592447]]
+......
+```
+
+Visualization of results
+
+![img](./images/12_det_rec.jpg)
+
+* detection and recognition
+
+```python linenums="1"
+from paddleocr import PaddleOCR,draw_ocr
+ocr = PaddleOCR(lang='en') # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_en/img_12.jpg'
+result = ocr.ocr(img_path, cls=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# draw result
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+Output will be a list, each item contains bounding box, text and recognition confidence
+
+```bash linenums="1"
+[[[442.0, 173.0], [1169.0, 173.0], [1169.0, 225.0], [442.0, 225.0]], ['ACKNOWLEDGEMENTS', 0.99283075]]
+[[[393.0, 340.0], [1207.0, 342.0], [1207.0, 389.0], [393.0, 387.0]], ['We would like to thank all the designers and', 0.9357758]]
+[[[399.0, 398.0], [1204.0, 398.0], [1204.0, 433.0], [399.0, 433.0]], ['contributors whohave been involved in the', 0.9592447]]
+......
+```
+
+Visualization of results
+
+![img](./images/12_det_rec.jpg)
+
+* classification and recognition
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+ocr = PaddleOCR(use_angle_cls=True, lang='en') # need to run only once to load model into memory
+img_path = 'PaddleOCR/doc/imgs_words_en/word_10.png'
+result = ocr.ocr(img_path, det=False, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+Output will be a list, each item contains recognition text and confidence
+
+```bash linenums="1"
+['PAIN', 0.990372]
+```
+
+* only detection
+
+```python linenums="1"
+from paddleocr import PaddleOCR,draw_ocr
+ocr = PaddleOCR() # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_en/img_12.jpg'
+result = ocr.ocr(img_path,rec=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# draw result
+from PIL import Image
+result = result[0]
+image = Image.open(img_path).convert('RGB')
+im_show = draw_ocr(image, result, txts=None, scores=None, font_path='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+Output will be a list, each item only contains bounding box
+
+```bash linenums="1"
+[[756.0, 812.0], [805.0, 812.0], [805.0, 830.0], [756.0, 830.0]]
+[[820.0, 803.0], [1085.0, 801.0], [1085.0, 836.0], [820.0, 838.0]]
+[[393.0, 801.0], [715.0, 805.0], [715.0, 839.0], [393.0, 836.0]]
+......
+```
+
+Visualization of results
+
+![img](./images/12_det.jpg)
+
+* only recognition
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+ocr = PaddleOCR(lang='en') # need to run only once to load model into memory
+img_path = 'PaddleOCR/doc/imgs_words_en/word_10.png'
+result = ocr.ocr(img_path, det=False, cls=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+Output will be a list, each item contains recognition text and confidence
+
+```bash linenums="1"
+['PAIN', 0.990372]
+```
+
+* only classification
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+ocr = PaddleOCR(use_angle_cls=True) # need to run only once to load model into memory
+img_path = 'PaddleOCR/doc/imgs_words_en/word_10.png'
+result = ocr.ocr(img_path, det=False, rec=False, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+Output will be a list, each item contains classification result and confidence
+
+```bash linenums="1"
+['0', 0.99999964]
+```
+
+### 2.2 Use by command line
+
+show help information
+
+```bash linenums="1"
+paddleocr -h
+```
+
+* detection classification and recognition
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_en/img_12.jpg --use_angle_cls true --lang en
+```
+
+Output will be a list, each item contains bounding box, text and recognition confidence
+
+```bash linenums="1"
+[[[441.0, 174.0], [1166.0, 176.0], [1165.0, 222.0], [441.0, 221.0]], ('ACKNOWLEDGEMENTS', 0.9971134662628174)]
+[[[403.0, 346.0], [1204.0, 348.0], [1204.0, 384.0], [402.0, 383.0]], ('We would like to thank all the designers and', 0.9761400818824768)]
+[[[403.0, 396.0], [1204.0, 398.0], [1204.0, 434.0], [402.0, 433.0]], ('contributors who have been involved in the', 0.9791957139968872)]
+......
+```
+
+pdf file is also supported, you can infer the first few pages by using the `page_num` parameter, the default is 0, which means infer all pages
+
+```bash linenums="1"
+paddleocr --image_dir ./xxx.pdf --use_angle_cls true --use_gpu false --page_num 2
+```
+
+* detection and recognition
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_en/img_12.jpg --lang en
+```
+
+Output will be a list, each item contains bounding box, text and recognition confidence
+
+```bash linenums="1"
+[[[441.0, 174.0], [1166.0, 176.0], [1165.0, 222.0], [441.0, 221.0]], ('ACKNOWLEDGEMENTS', 0.9971134662628174)]
+[[[403.0, 346.0], [1204.0, 348.0], [1204.0, 384.0], [402.0, 383.0]], ('We would like to thank all the designers and', 0.9761400818824768)]
+[[[403.0, 396.0], [1204.0, 398.0], [1204.0, 434.0], [402.0, 433.0]], ('contributors who have been involved in the', 0.9791957139968872)]
+......
+```
+
+* classification and recognition
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words_en/word_10.png --use_angle_cls true --det false --lang en
+```
+
+Output will be a list, each item contains text and recognition confidence
+
+```bash linenums="1"
+['PAIN', 0.9934559464454651]
+```
+
+* only detection
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_en/img_12.jpg --rec false
+```
+
+Output will be a list, each item only contains bounding box
+
+```bash linenums="1"
+[[397.0, 802.0], [1092.0, 802.0], [1092.0, 841.0], [397.0, 841.0]]
+[[397.0, 750.0], [1211.0, 750.0], [1211.0, 789.0], [397.0, 789.0]]
+[[397.0, 702.0], [1209.0, 698.0], [1209.0, 734.0], [397.0, 738.0]]
+......
+```
+
+* only recognition
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words_en/word_10.png --det false --lang en
+```
+
+Output will be a list, each item contains text and recognition confidence
+
+```bash linenums="1"
+['PAIN', 0.9934559464454651]
+```
+
+* only classification
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words_en/word_10.png --use_angle_cls true --det false --rec false
+```
+
+Output will be a list, each item contains classification result and confidence
+
+```bash linenums="1"
+['0', 0.99999964]
+```
+
+## 3 Use custom model
+
+When the built-in model cannot meet the needs, you need to use your own trained model.
+First, refer to [export](../model_train/detection.en.md#4-inference) doc to convert your det and rec model to inference model, and then use it as follows
+
+### 3.1 Use by code
+
+```python linenums="1"
+from paddleocr import PaddleOCR,draw_ocr
+# The path of detection and recognition model must contain model and params files
+ocr = PaddleOCR(det_model_dir='{your_det_model_dir}', rec_model_dir='{your_rec_model_dir}', rec_char_dict_path='{your_rec_char_dict_path}', cls_model_dir='{your_cls_model_dir}', use_angle_cls=True)
+img_path = 'PaddleOCR/doc/imgs_en/img_12.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# draw result
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+### 3.2 Use by command line
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --det_model_dir {your_det_model_dir} --rec_model_dir {your_rec_model_dir} --rec_char_dict_path {your_rec_char_dict_path} --cls_model_dir {your_cls_model_dir} --use_angle_cls true
+```
+
+## 4 Use web images or numpy array as input
+
+### 4.1 Web image
+
+* Use by code
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+ocr = PaddleOCR(use_angle_cls=True, lang="ch") # need to run only once to download and load model into memory
+img_path = 'http://n.sinaimg.cn/ent/transform/w630h933/20171222/o111-fypvuqf1838418.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# show result
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+* Use by command line
+
+```bash linenums="1"
+paddleocr --image_dir http://n.sinaimg.cn/ent/transform/w630h933/20171222/o111-fypvuqf1838418.jpg --use_angle_cls=true
+```
+
+### 4.2 Numpy array
+
+Support numpy array as input only when used by code
+
+```python linenums="1"
+import cv2
+from paddleocr import PaddleOCR, draw_ocr, download_with_progressbar
+ocr = PaddleOCR(use_angle_cls=True, lang="ch") # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs/11.jpg'
+img = cv2.imread(img_path)
+# img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY), If your own training model supports grayscale images, you can uncomment this line
+result = ocr.ocr(img, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# show result
+from PIL import Image
+result = result[0]
+download_with_progressbar(img_path, 'tmp.jpg')
+image = Image.open('tmp.jpg').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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+## 5 PDF file
+
+* Use by command line
+
+you can infer the first few pages by using the `page_num` parameter, the default is 0, which means infer all pages
+
+```bash linenums="1"
+paddleocr --image_dir ./xxx.pdf --use_angle_cls true --use_gpu false --page_num 2
+```
+
+* Use by code
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# Paddleocr supports Chinese, English, French, German, Korean and Japanese.
+# You can set the parameter `lang` as `ch`, `en`, `fr`, `german`, `korean`, `japan`
+# to switch the language model in order.
+ocr = PaddleOCR(use_angle_cls=True, lang="ch"， page_num=2)  # need to run only once to download and load model into memory
+img_path = './xxx.pdf'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# draw result
+import fitz
+from PIL import Image
+import cv2
+import numpy as np
+imgs = []
+with fitz.open(img_path) as pdf:
+    for pg in range(0, pdf.pageCount):
+        page = pdf[pg]
+        mat = fitz.Matrix(2, 2)
+        pm = page.getPixmap(matrix=mat, alpha=False)
+        # if width or height > 2000 pixels, don't enlarge the image
+        if pm.width > 2000 or pm.height > 2000:
+            pm = page.getPixmap(matrix=fitz.Matrix(1, 1), alpha=False)
+
+        img = Image.frombytes("RGB", [pm.width, pm.height], pm.samples)
+        img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+        imgs.append(img)
+for idx in range(len(result)):
+    res = result[idx]
+    image = imgs[idx]
+    boxes = [line[0] for line in res]
+    txts = [line[1][0] for line in res]
+    scores = [line[1][1] for line in res]
+    im_show = draw_ocr(image, boxes, txts, scores, font_path='doc/fonts/simfang.ttf')
+    im_show = Image.fromarray(im_show)
+    im_show.save('result_page_{}.jpg'.format(idx))
+```
+
+## 6 Parameter Description
+
+| Parameter                    | Description                                                                                                                                                                                                                 | Default value                  |
+|-------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------|
+| use_gpu                 | use GPU or not                                                                                                                                                                                                          | TRUE                    |
+| gpu_mem                 | GPU memory size used for initialization                                                                                                                                                                                              | 8000M                   |
+| image_dir               | The images path or folder path for predicting when used by the command line                                                                                                                                                                           |                         |
+| page_num               | Valid when the input type is pdf file, specify to predict the previous page_num pages, all pages are predicted by default                                                                                                                                                                           |          0               |
+| det_algorithm           | Type of detection algorithm selected                                                                                                                                                                                                   | DB                      |
+| det_model_dir           | the text detection inference model folder. There are two ways to transfer parameters, 1. None: Automatically download the built-in model to `~/.paddleocr/det`; 2. The path of the inference model converted by yourself, the model and params files must be included in the model path | None           |
+| det_max_side_len        | The maximum size of the long side of the image. When the long side exceeds this value, the long side will be resized to this size, and the short side will be scaled proportionally                                                                                                                         | 960                     |
+| det_db_thresh           | Binarization threshold value of DB output map                                                                                                                                                                                        | 0.3                     |
+| det_db_box_thresh       | The threshold value of the DB output box. Boxes score lower than this value will be discarded                                                                                                                                                                         | 0.5                     |
+| det_db_unclip_ratio     | The expanded ratio of DB output box                                                                                                                                                                                             | 2                       |
+| det_db_score_mode |  The parameter that control how the score of the detection frame is calculated. There are 'fast' and 'slow' options. If the text to be detected is curved, it is recommended to use 'slow'  | 'fast' |
+| det_east_score_thresh   | Binarization threshold value of EAST output map                                                                                                                                                                                       | 0.8                     |
+| det_east_cover_thresh   | The threshold value of the EAST output box. Boxes score lower than this value will be discarded                                                                                                                                                                         | 0.1                     |
+| det_east_nms_thresh     | The NMS threshold value of EAST model output box                                                                                                                                                                                              | 0.2                     |
+| rec_algorithm           | Type of recognition algorithm selected                                                                                                                                                                                                | CRNN                    |
+| rec_model_dir           | the text recognition inference model folder. There are two ways to transfer parameters, 1. None: Automatically download the built-in model to `~/.paddleocr/rec`; 2. The path of the inference model converted by yourself, the model and params files must be included in the model path | None |
+| rec_image_shape         | image shape of recognition algorithm                                                                                                                                                                                            | "3,32,320"              |
+| rec_batch_num           | When performing recognition, the batchsize of forward images                                                                                                                                                                                         | 30                      |
+| max_text_length         | The maximum text length that the recognition algorithm can recognize                                                                                                                                                                                         | 25                      |
+| rec_char_dict_path      | the alphabet path which needs to be modified to your own path when `rec_model_Name` use mode 2                                                                                                                                              | ./ppocr/utils/ppocr_keys_v1.txt                        |
+| use_space_char          | Whether to recognize spaces                                                                                                                                                                                                         | TRUE                    |
+| drop_score          | Filter the output by score (from the recognition model), and those below this score will not be returned                                                                                                                                                                                                        | 0.5                    |
+| use_angle_cls          | Whether to load classification model                                                                                                                                                                                                       | FALSE                    |
+| cls_model_dir           | the classification inference model folder. There are two ways to transfer parameters, 1. None: Automatically download the built-in model to `~/.paddleocr/cls`; 2. The path of the inference model converted by yourself, the model and params files must be included in the model path | None |
+| cls_image_shape         | image shape of classification algorithm                                                                                                                                                                                            | "3,48,192"              |
+| label_list         | label list of classification algorithm                                                                                                                                                                                            | ['0','180']           |
+| cls_batch_num           | When performing classification, the batchsize of forward images                                                                                                                                                                                         | 30                      |
+| enable_mkldnn           | Whether to enable mkldnn                                                                                                                                                                                                       | FALSE                   |
+| use_zero_copy_run           | Whether to forward by zero_copy_run                                                                                                                                                                               | FALSE                   |
+| lang                     | The support language, now only Chinese(ch)、English(en)、French(french)、German(german)、Korean(korean)、Japanese(japan) are supported                                                                                                                                                                                                  | ch                    |
+| det                     | Enable detection when `ppocr.ocr` func exec                                                                                                                                                                                                   | TRUE                    |
+| rec                     | Enable recognition when `ppocr.ocr` func exec                                                                                                                                                                                                   | TRUE                    |
+| cls                     | Enable classification when `ppocr.ocr` func exec((Use use_angle_cls in command line mode to control whether to start classification in the forward direction)                                                                                                                                                                                                   | FALSE                    |
+| show_log                     | Whether to print log| FALSE                    |
+| type                     | Perform ocr or table structuring, the value is selected in ['ocr','structure']                                                                                                                                                                                             | ocr                    |
+| ocr_version                     | OCR Model version number, the current model support list is as follows: PP-OCRv3 supports Chinese and English detection, recognition, multilingual recognition, direction classifier models, PP-OCRv2 support Chinese detection and recognition model, PP-OCR support Chinese detection, recognition and direction classifier, multilingual recognition model | PP-OCRv3                 |
--- a/docs/version2.x/ppocr/blog/whl.md
+++ b/docs/version2.x/ppocr/blog/whl.md
@@ -0,0 +1,501 @@
+---
+typora-copy-images-to: images
+comments: true
+---
+
+# paddleocr package使用说明
+
+## 1 快速上手
+
+### 1.1 安装whl包
+
+pip安装
+
+```bash linenums="1"
+pip install "paddleocr<3.0"
+```
+
+本地构建并安装
+
+```bash linenums="1"
+python3 -m build
+pip3 install dist/paddleocr-x.x.x-py3-none-any.whl # x.x.x是paddleocr的版本号
+```
+
+## 2 使用
+
+### 2.1 代码使用
+
+paddleocr whl包会自动下载ppocr轻量级模型作为默认模型，可以根据第3节**自定义模型**进行自定义更换。
+
+* 检测+方向分类器+识别全流程
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# Paddleocr目前支持中英文、英文、法语、德语、韩语、日语，可以通过修改lang参数进行切换
+# 参数依次为`ch`, `en`, `french`, `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 = 'PaddleOCR/doc/imgs/11.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+结果是一个list，每个item包含了文本框，文字和识别置信度
+
+```bash linenums="1"
+[[[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]]
+......
+```
+
+结果可视化
+
+<div align="center">
+    <img src="./images/11_det_rec.jpg" width="800">
+</div>
+
+* 检测+识别
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+ocr = PaddleOCR()  # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs/11.jpg'
+result = ocr.ocr(img_path, cls=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+结果是一个list，每个item包含了文本框，文字和识别置信度
+
+```bash linenums="1"
+[[[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]]
+......
+```
+
+结果可视化
+
+<div align="center">
+    <img src="./images/11_det_rec.jpg" width="800">
+</div>
+
+* 方向分类器+识别
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+
+ocr = PaddleOCR(use_angle_cls=True)  # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_words/ch/word_1.jpg'
+result = ocr.ocr(img_path, det=False, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+结果是一个list，每个item只包含识别结果和识别置信度
+
+```bash linenums="1"
+['韩国小馆', 0.9907421]
+```
+
+* 单独执行检测
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+ocr = PaddleOCR()  # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs/11.jpg'
+result = ocr.ocr(img_path, rec=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+image = Image.open(img_path).convert('RGB')
+im_show = draw_ocr(image, result, txts=None, scores=None, font_path='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+结果是一个list，每个item只包含文本框
+
+```bash linenums="1"
+[[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]]
+......
+```
+
+结果可视化
+
+<div align="center">
+    <img src="./images/11_det.jpg" width="800">
+</div>
+
+* 单独执行识别
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+
+ocr = PaddleOCR()  # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_words/ch/word_1.jpg'
+result = ocr.ocr(img_path, det=False)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+结果是一个list，每个item只包含识别结果和识别置信度
+
+```bash linenums="1"
+['韩国小馆', 0.9907421]
+```
+
+* 单独执行方向分类器
+
+```python linenums="1"
+from paddleocr import PaddleOCR
+
+ocr = PaddleOCR(use_angle_cls=True)  # need to run only once to download and load model into memory
+img_path = 'PaddleOCR/doc/imgs_words/ch/word_1.jpg'
+result = ocr.ocr(img_path, det=False, rec=False, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+```
+
+结果是一个list，每个item只包含分类结果和分类置信度
+
+```bash linenums="1"
+['0', 0.9999924]
+```
+
+### 2.2 通过命令行使用
+
+查看帮助信息
+
+```bash linenums="1"
+paddleocr -h
+```
+
+* 检测+方向分类器+识别全流程
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --use_angle_cls true
+```
+
+结果是一个list，每个item包含了文本框，文字和识别置信度
+
+```bash linenums="1"
+[[[28.0, 37.0], [302.0, 39.0], [302.0, 72.0], [27.0, 70.0]], ('纯臻营养护发素', 0.9658738374710083)]
+......
+```
+
+此外，paddleocr也支持输入pdf文件，并且可以通过指定参数`page_num`来控制推理前面几页，默认为0，表示推理所有页。
+
+```bash linenums="1"
+paddleocr --image_dir ./xxx.pdf --use_angle_cls true --use_gpu false --page_num 2
+```
+
+* 检测+识别
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg
+```
+
+结果是一个list，每个item包含了文本框，文字和识别置信度
+
+```bash linenums="1"
+[[[28.0, 37.0], [302.0, 39.0], [302.0, 72.0], [27.0, 70.0]], ('纯臻营养护发素', 0.9658738374710083)]
+......
+```
+
+* 方向分类器+识别
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words/ch/word_1.jpg --use_angle_cls true --det false
+```
+
+结果是一个list，每个item只包含识别结果和识别置信度
+
+```bash linenums="1"
+['韩国小馆', 0.994467]
+```
+
+* 单独执行检测
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --rec false
+```
+
+结果是一个list，每个item只包含文本框
+
+```bash linenums="1"
+[[27.0, 459.0], [136.0, 459.0], [136.0, 479.0], [27.0, 479.0]]
+[[28.0, 429.0], [372.0, 429.0], [372.0, 445.0], [28.0, 445.0]]
+......
+```
+
+* 单独执行识别
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words/ch/word_1.jpg --det false
+```
+
+结果是一个list，每个item只包含识别结果和识别置信度
+
+```bash linenums="1"
+['韩国小馆', 0.994467]
+```
+
+* 单独执行方向分类器
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs_words/ch/word_1.jpg --use_angle_cls true --det false --rec false
+```
+
+结果是一个list，每个item只包含分类结果和分类置信度
+
+```bash linenums="1"
+['0', 0.9999924]
+```
+
+## 3 自定义模型
+
+当内置模型无法满足需求时，需要使用到自己训练的模型。 首先，参照[模型导出](../model_train/detection.md#4-模型导出与预测)将检测、分类和识别模型转换为inference模型，然后按照如下方式使用
+
+### 3.1 代码使用
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# 模型路径下必须含有model和params文件
+ocr = PaddleOCR(det_model_dir='{your_det_model_dir}', rec_model_dir='{your_rec_model_dir}',
+                rec_char_dict_path='{your_rec_char_dict_path}', cls_model_dir='{your_cls_model_dir}',
+                use_angle_cls=True)
+img_path = 'PaddleOCR/doc/imgs/11.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+### 3.2 通过命令行使用
+
+```bash linenums="1"
+paddleocr --image_dir PaddleOCR/doc/imgs/11.jpg --det_model_dir {your_det_model_dir} --rec_model_dir {your_rec_model_dir} --rec_char_dict_path {your_rec_char_dict_path} --cls_model_dir {your_cls_model_dir} --use_angle_cls true
+```
+
+## 4 使用网络图片或者numpy数组作为输入
+
+### 4.1 网络图片
+
+* 代码使用
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr, download_with_progressbar
+
+# Paddleocr目前支持中英文、英文、法语、德语、韩语、日语，可以通过修改lang参数进行切换
+# 参数依次为`ch`, `en`, `french`, `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 = 'http://n.sinaimg.cn/ent/transform/w630h933/20171222/o111-fypvuqf1838418.jpg'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+download_with_progressbar(img_path, 'tmp.jpg')
+image = Image.open('tmp.jpg').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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+* 命令行模式
+
+```bash linenums="1"
+paddleocr --image_dir http://n.sinaimg.cn/ent/transform/w630h933/20171222/o111-fypvuqf1838418.jpg --use_angle_cls=true
+```
+
+### 4.2 numpy数组
+
+仅通过代码使用时支持numpy数组作为输入
+
+```python linenums="1"
+import cv2
+from paddleocr import PaddleOCR, draw_ocr
+
+# Paddleocr目前支持中英文、英文、法语、德语、韩语、日语，可以通过修改lang参数进行切换
+# 参数依次为`ch`, `en`, `french`, `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 = 'PaddleOCR/doc/imgs/11.jpg'
+img = cv2.imread(img_path)
+# img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY), 如果你自己训练的模型支持灰度图，可以将这句话的注释取消
+result = ocr.ocr(img, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+from PIL import Image
+result = result[0]
+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='/path/to/PaddleOCR/doc/fonts/simfang.ttf')
+im_show = Image.fromarray(im_show)
+im_show.save('result.jpg')
+```
+
+## 5 PDF文件作为输入
+
+* 命令行模式
+
+可以通过指定参数`page_num`来控制推理前面几页，默认为0，表示推理所有页。
+
+```bash linenums="1"
+paddleocr --image_dir ./xxx.pdf --use_angle_cls true --use_gpu false --page_num 2
+```
+
+* 代码使用
+
+```python linenums="1"
+from paddleocr import PaddleOCR, draw_ocr
+
+# Paddleocr目前支持的多语言语种可以通过修改lang参数进行切换
+# 例如`ch`, `en`, `fr`, `german`, `korean`, `japan`
+ocr = PaddleOCR(use_angle_cls=True, lang="ch"， page_num=2)  # need to run only once to download and load model into memory
+img_path = './xxx.pdf'
+result = ocr.ocr(img_path, cls=True)
+for idx in range(len(result)):
+    res = result[idx]
+    for line in res:
+        print(line)
+
+# 显示结果
+import fitz
+from PIL import Image
+import cv2
+import numpy as np
+imgs = []
+with fitz.open(img_path) as pdf:
+    for pg in range(0, pdf.pageCount):
+        page = pdf[pg]
+        mat = fitz.Matrix(2, 2)
+        pm = page.getPixmap(matrix=mat, alpha=False)
+        # if width or height > 2000 pixels, don't enlarge the image
+        if pm.width > 2000 or pm.height > 2000:
+            pm = page.getPixmap(matrix=fitz.Matrix(1, 1), alpha=False)
+
+        img = Image.frombytes("RGB", [pm.width, pm.height], pm.samples)
+        img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+        imgs.append(img)
+for idx in range(len(result)):
+    res = result[idx]
+    image = imgs[idx]
+    boxes = [line[0] for line in res]
+    txts = [line[1][0] for line in res]
+    scores = [line[1][1] for line in res]
+    im_show = draw_ocr(image, boxes, txts, scores, font_path='doc/fonts/simfang.ttf')
+    im_show = Image.fromarray(im_show)
+    im_show.save('result_page_{}.jpg'.format(idx))
+```
+
+## 6 参数说明
+
+| 字段   | 说明| 默认值 |
+|-------------------------|----------|-------------------------|
+| use_gpu| 是否使用GPU          | TRUE   |
+| gpu_mem| 初始化占用的GPU内存大小               | 8000M  |
+| image_dir               | 通过命令行调用时执行预测的图片或文件夹路径   |
+| page_num               | 当输入类型为pdf文件时有效，指定预测前面page_num页，默认预测所有页    |        0|
+| det_algorithm           | 使用的检测算法类型   | DB     |
+| det_model_dir          |  检测模型所在文件夹。传参方式有两种，1. None: 自动下载内置模型到 `~/.paddleocr/det`；2.自己转换好的inference模型路径，模型路径下必须包含model和params文件 |   None        |
+| det_max_side_len        | 检测算法前向时图片长边的最大尺寸，当长边超出这个值时会将长边resize到这个大小，短边等比例缩放   | 960    |
+| det_db_thresh           | DB模型输出预测图的二值化阈值          | 0.3    |
+| det_db_box_thresh       | DB模型输出框的阈值，低于此值的预测框会被丢弃   | 0.5    |
+| det_db_unclip_ratio     | DB模型输出框扩大的比例                | 2      |
+| det_db_score_mode |  计算检测框score的方式，有'fast'和'slow'，如果要检测的文字有弯曲，建议用'slow'，'slow'模式计算的box的score偏大，box不容易被过滤掉  | 'fast' |
+| det_east_score_thresh   | EAST模型输出预测图的二值化阈值        | 0.8    |
+| det_east_cover_thresh   | EAST模型输出框的阈值，低于此值的预测框会被丢弃 | 0.1    |
+| det_east_nms_thresh     | EAST模型输出框NMS的阈值               | 0.2    |
+| rec_algorithm           | 使用的识别算法类型   | CRNN   |
+| rec_model_dir          | 识别模型所在文件夹。传参方式有两种，1. None: 自动下载内置模型到 `~/.paddleocr/rec`；2.自己转换好的inference模型路径，模型路径下必须包含model和params文件 | None |
+| rec_image_shape         | 识别算法的输入图片尺寸              | "3,32,320"              |
+| rec_batch_num           | 进行识别时，同时前向的图片数          | 30     |
+| max_text_length         | 识别算法能识别的最大文字长度          | 25     |
+| rec_char_dict_path      | 识别模型字典路径，当rec_model_dir使用方式2传参时需要修改为自己的字典路径 | ./ppocr/utils/ppocr_keys_v1.txt       |
+| use_space_char          | 是否识别空格         | TRUE   |
+| drop_score          | 对输出按照分数(来自于识别模型)进行过滤，低于此分数的不返回         | 0.5   |
+| use_angle_cls          | 是否加载分类模型         | FALSE   |
+| cls_model_dir          | 分类模型所在文件夹。传参方式有两种，1. None: 自动下载内置模型到 `~/.paddleocr/cls`；2.自己转换好的inference模型路径，模型路径下必须包含model和params文件     | None   |
+| cls_image_shape          | 分类算法的输入图片尺寸                | "3, 48, 192"   |
+| label_list          | 分类算法的标签列表                | ['0', '180'] |
+| cls_batch_num          | 进行分类时，同时前向的图片数               |30|
+| enable_mkldnn           | 是否启用mkldnn       | FALSE  |
+| use_zero_copy_run           | 是否通过zero_copy_run的方式进行前向| FALSE  |
+| lang    | 模型语言类型,目前支持 目前支持中英文(ch)、英文(en)、法语(french)、德语(german)、韩语(korean)、日语(japan)                | ch   |
+| det    | 前向时使用启动检测   | TRUE   |
+| rec    | 前向时是否启动识别   | TRUE   |
+| cls    | 前向时是否启动分类 (命令行模式下使用use_angle_cls控制前向是否启动分类)| FALSE   |
+| show_log    | 是否打印logger信息| FALSE   |
+| type    | 执行ocr或者表格结构化, 值可选['ocr','structure']              | ocr   |
+| ocr_version    | OCR模型版本，可选PP-OCRv3, PP-OCRv2, PP-OCR。PP-OCRv3 支持中、英文的检测、识别、多语种识别，方向分类器等模型；PP-OCRv2 目前仅支持中文的检测和识别模型；PP-OCR支持中文的检测，识别，多语种识别，方向分类器等模型          | PP-OCRv3  |