持续创造，加速生长！这是我参与「日新计划 10 月更文挑战」的第3天，点击检查活动详情

最近一段时间运用PaddleOCR做了一个OCR相关的项目，本文记载一下项目的完结进程。因为数据集是公司的真是数据，不便利揭露，我从网上搜集了一些数据集，给我们做演示。PaddleOCR用的最新的PaddleOCR-release-2.5，模型用的v3模型。

一、装备Paddle环境

创立虚拟环境

conda create --name pp python=3.7

创立完结后激活环境

conda activate pp

登录飞桨的官网下载最新的paddle，官网地址：飞桨PaddlePaddle-源于工业实践的开源深度学习渠道

挑选适宜的CUDA版别，然后会在下面生成对应的指令。

然后，仿制指令即可

conda install paddlepaddle-gpu==2.2.2 cudatoolkit=11.2 -c https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/Paddle/ -c conda-forge

二、装备PaddleOCR

下载地址：(gitee.com/paddlepaddl…

将其下载到本地，然后解压装备环境。

1、装置python包

1、yaml

pip install pyyaml

2、imgaug

pip install imgaug

3、pyclipper

pip install pyclipper

4、lmdb

pip install lmdb

5、Levenshtein

pip install Levenshtein

6、tqdm

pip install tqdm

2、测验环境

模型简介	模型称号	引荐场景	检测模型	方向分类器	辨认模型
中英文超轻量PP-OCRv3模型（16.2M）	ch_PP-OCRv3_xx	移动端&服务器端	推理模型 / 练习模型	推理模型 / 练习模型	推理模型 / 练习模型
英文超轻量PP-OCRv3模型（13.4M）	en_PP-OCRv3_xx	移动端&服务器端	推理模型 / 练习模型	推理模型 / 练习模型	推理模型 / 练习模型
中英文超轻量PP-OCRv2模型（13.0M）	ch_PP-OCRv2_xx	移动端&服务器端	推理模型 / 练习模型	推理模型 / 预练习模型	推理模型 / 练习模型
中英文超轻量PP-OCR mobile模型（9.4M）	ch_ppocr_mobile_v2.0_xx	移动端&服务器端	推理模型 / 预练习模型	推理模型 / 预练习模型	推理模型 / 预练习模型
中英文通用PP-OCR server模型（143.4M）	ch_ppocr_server_v2.0_xx	服务器端	推理模型 / 预练习模型	推理模型 / 预练习模型	推理模型 / 预练习模型

挑选上面的一组模型放入到inference文件夹中，留意：是一组，包括：监测模型、方向分类器、辨认模型。如下：

PaddleOCR-release-2.5
	└─inference
	   ├─ch_PP-OCRv3_det_infer #检测模型
	   │	 ├─inference.pdiparams
	   │	 ├─inference.pdiparams.info
	   │	 └─inference.pdmodel
	   ├─ch_PP-OCRv3_rec_infer #辨认模型
       │	 ├─inference.pdiparams
	   │	 ├─inference.pdiparams.info
	   │	 └─inference.pdmodel
	   └─cls #方向分类器
			 ├─inference.pdiparams
			 ├─inference.pdiparams.info
			 └─inference.pdmodel

将待检测的图片放在./doc/imgs/文件夹下面，然后履行指令：

python tools/infer/predict_system.py --image_dir="./doc/imgs/0.jpg" --det_model_dir="./inference/ch_PP-OCRv3_det_infer/" --cls_model_dir="./inference/cls/" --rec_model_dir="./inference/ch_PP-OCRv3_rec_infer/" --use_angle_cls=true

然后在inference_results文件夹中检查成果，例如：

假如能看到成果就阐明环境是ok的。

更多的指令，如下：

# 运用方向分类器
python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./ch_PP-OCRv3_det_infer/" --cls_model_dir="./cls/" --rec_model_dir="./ch_PP-OCRv3_rec_infer/" --use_angle_cls=true --rec_image_shape=3,48,320
# 不运用方向分类器
python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./ch_PP-OCRv3_det_infer/" --rec_model_dir="./ch_PP-OCRv3_rec_infer/" --use_angle_cls=false --rec_image_shape=3,48,320
# 运用多进程
python3 tools/infer/predict_system.py --image_dir="./doc/imgs/00018069.jpg" --det_model_dir="./ch_PP-OCRv3_det_infer/" --rec_model_dir="./ch_PP-OCRv3_rec_infer/" --use_angle_cls=false --use_mp=True --total_process_num=6 --rec_image_shape=3,48,320

也能够新建test.py脚本进行测验，体系会主动下载预练习模型，代码如下：

import cv2
from paddleocr import PaddleOCR, draw_ocr
# Paddleocr现在支撑的多言语语种能够经过修正lang参数进行切换
# 例如`ch`, `en`, `fr`, `german`, `korean`, `japan`
ocr = PaddleOCR(use_angle_cls=True, lang="ch")  # need to run only once to download and load model into memory
img_path = './doc/imgs_en/img_10.jpg'
result = ocr.ocr(img_path, cls=True)
for line in result:
    print(line)
# 显现成果
from PIL import Image
image = Image.open(img_path).convert('RGB')
boxes = [line[0] for line in result]
txts = [line[1][0] for line in result]
scores = [line[1][1] for line in result]
im_show = draw_ocr(image, boxes, txts, scores, font_path='./fonts/simfang.ttf')
im_show = Image.fromarray(im_show)
im_show.save('result.jpg')

开始运转：

红框的方位显现了详细的装备信息。检查成果：

ocr.ocr(img_path, cls=True)这个办法不只支撑传入图片的途径，还支撑ndarray和list类型。比如传入ndarray

import cv2
from paddleocr import PaddleOCR, draw_ocr
# Paddleocr现在支撑的多言语语种能够经过修正lang参数进行切换
# 例如`ch`, `en`, `fr`, `german`, `korean`, `japan`
ocr = PaddleOCR(use_angle_cls=True, lang="ch")  # need to run only once to download and load model into memory
img_path = './doc/imgs_en/img_10.jpg'
# 第一种运用读入图片转为ndarray
from PIL import Image
import numpy as np
img = Image.open(img_path)
img = np.array(img)
result = ocr.ocr(img, cls=True)
# 第二种运用cv2读入图片。
img=cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
result = ocr.ocr(img, cls=True)

上面这两种方法都是能够的，我们自行测验。

三模型列表及其对应的装备文件

1. 文本检测模型

1.1 中文检测模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
ch_PP-OCRv3_det_slim	【最新】slim量化+蒸馏版超轻量模型，支撑中英文、多语种文本检测	ch_PP-OCRv3_det_cml.yml	1.1M	推理模型 / 练习模型 / nb模型
ch_PP-OCRv3_det	【最新】原始超轻量模型，支撑中英文、多语种文本检测	ch_PP-OCRv3_det_cml.yml	3.8M	推理模型 / 练习模型
ch_PP-OCRv2_det_slim	slim量化+蒸馏版超轻量模型，支撑中英文、多语种文本检测	ch_PP-OCRv2_det_cml.yml	3M	推理模型
ch_PP-OCRv2_det	原始超轻量模型，支撑中英文、多语种文本检测	ch_PP-OCRv2_det_cml.yml	3M	推理模型 / 练习模型
ch_ppocr_mobile_slim_v2.0_det	slim裁剪版超轻量模型，支撑中英文、多语种文本检测	ch_det_mv3_db_v2.0.yml	2.6M	推理模型
ch_ppocr_mobile_v2.0_det	原始超轻量模型，支撑中英文、多语种文本检测	ch_det_mv3_db_v2.0.yml	3M	推理模型 / 练习模型
ch_ppocr_server_v2.0_det	通用模型，支撑中英文、多语种文本检测，比超轻量模型更大，但作用更好	ch_det_res18_db_v2.0.yml	47M	推理模型 / 练习模型

1.2 英文检测模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
en_PP-OCRv3_det_slim	【最新】slim量化版超轻量模型，支撑英文、数字检测	ch_PP-OCRv3_det_cml.yml	1.1M	推理模型 / 练习模型 / nb模型
en_PP-OCRv3_det	【最新】原始超轻量模型，支撑英文、数字检测	ch_PP-OCRv3_det_cml.yml	3.8M	推理模型 / 练习模型

注：英文检测模型与中文检测模型结构完全相同，只要练习数据不同，在此仅提供相同的装备文件。

1.3 多言语检测模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
ml_PP-OCRv3_det_slim	【最新】slim量化版超轻量模型，支撑多言语检测	ch_PP-OCRv3_det_cml.yml	1.1M	推理模型 / 练习模型 / nb模型
ml_PP-OCRv3_det	【最新】原始超轻量模型，支撑多言语检测	ch_PP-OCRv3_det_cml.yml	3.8M	推理模型 / 练习模型

注：多言语检测模型与中文检测模型结构完全相同，只要练习数据不同，在此仅提供相同的装备文件。

2. 文本辨认模型

2.1 中文辨认模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
ch_PP-OCRv3_rec_slim	【最新】slim量化版超轻量模型，支撑中英文、数字辨认	ch_PP-OCRv3_rec_distillation.yml	4.9M	推理模型 / 练习模型 / nb模型
ch_PP-OCRv3_rec	【最新】原始超轻量模型，支撑中英文、数字辨认	ch_PP-OCRv3_rec_distillation.yml	12.4M	推理模型 / 练习模型
ch_PP-OCRv2_rec_slim	slim量化版超轻量模型，支撑中英文、数字辨认	ch_PP-OCRv2_rec.yml	9M	推理模型 / 练习模型
ch_PP-OCRv2_rec	原始超轻量模型，支撑中英文、数字辨认	ch_PP-OCRv2_rec_distillation.yml	8.5M	推理模型 / 练习模型
ch_ppocr_mobile_slim_v2.0_rec	slim裁剪量化版超轻量模型，支撑中英文、数字辨认	rec_chinese_lite_train_v2.0.yml	6M	推理模型 / 练习模型
ch_ppocr_mobile_v2.0_rec	原始超轻量模型，支撑中英文、数字辨认	rec_chinese_lite_train_v2.0.yml	5.2M	推理模型 / 练习模型 / 预练习模型
ch_ppocr_server_v2.0_rec	通用模型，支撑中英文、数字辨认	rec_chinese_common_train_v2.0.yml	94.8M	推理模型 / 练习模型 / 预练习模型

阐明： 练习模型是依据预练习模型在实在数据与竖排合成文本数据上finetune得到的模型，在实在应用场景中有着更好的表现，预练习模型则是直接依据全量实在数据与合成数据练习得到，更适合用于在自己的数据集上finetune。

2.2 英文辨认模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
en_PP-OCRv3_rec_slim	【最新】slim量化版超轻量模型，支撑英文、数字辨认	en_PP-OCRv3_rec.yml	3.2M	推理模型 / 练习模型 / nb模型
en_PP-OCRv3_rec	【最新】原始超轻量模型，支撑英文、数字辨认	en_PP-OCRv3_rec.yml	9.6M	推理模型 / 练习模型
en_number_mobile_slim_v2.0_rec	slim裁剪量化版超轻量模型，支撑英文、数字辨认	rec_en_number_lite_train.yml	2.7M	推理模型 / 练习模型
en_number_mobile_v2.0_rec	原始超轻量模型，支撑英文、数字辨认	rec_en_number_lite_train.yml	2.6M	推理模型 / 练习模型

2.3 多言语辨认模型（更多言语持续更新中…）

模型称号	字典文件	模型简介	装备文件	推理模型巨细	下载地址
korean_PP-OCRv3_rec	ppocr/utils/dict/korean_dict.txt	韩文辨认	korean_PP-OCRv3_rec.yml	11M	推理模型 / 练习模型
japan_PP-OCRv3_rec	ppocr/utils/dict/japan_dict.txt	日文辨认	japan_PP-OCRv3_rec.yml	11M	推理模型 / 练习模型
chinese_cht_PP-OCRv3_rec	ppocr/utils/dict/chinese_cht_dict.txt	中文繁体辨认	chinese_cht_PP-OCRv3_rec.yml	12M	推理模型 / 练习模型
te_PP-OCRv3_rec	ppocr/utils/dict/te_dict.txt	泰卢固文辨认	te_PP-OCRv3_rec.yml	9.6M	推理模型 / 练习模型
ka_PP-OCRv3_rec	ppocr/utils/dict/ka_dict.txt	卡纳达文辨认	ka_PP-OCRv3_rec.yml	9.9M	推理模型 / 练习模型
ta_PP-OCRv3_rec	ppocr/utils/dict/ta_dict.txt	泰米尔文辨认	ta_PP-OCRv3_rec.yml	9.6M	推理模型 / 练习模型
latin_PP-OCRv3_rec	ppocr/utils/dict/latin_dict.txt	拉丁文辨认	latin_PP-OCRv3_rec.yml	9.7M	推理模型 / 练习模型
arabic_PP-OCRv3_rec	ppocr/utils/dict/arabic_dict.txt	阿拉伯字母	arabic_PP-OCRv3_rec.yml	9.6M	推理模型 / 练习模型
cyrillic_PP-OCRv3_rec	ppocr/utils/dict/cyrillic_dict.txt	斯拉夫字母	cyrillic_PP-OCRv3_rec.yml	9.6M	推理模型 / 练习模型
devanagari_PP-OCRv3_rec	ppocr/utils/dict/devanagari_dict.txt	梵文字母	devanagari_PP-OCRv3_rec.yml	9.9M	推理模型 / 练习模型

检查完好语种列表与运用教程请参阅: 多言语模型

3. 文本方向分类模型

模型称号	模型简介	装备文件	推理模型巨细	下载地址
ch_ppocr_mobile_slim_v2.0_cls	slim量化版模型，对检测到的文本行文字视点分类	cls_mv3.yml	2.1M	推理模型 / 练习模型 / nb模型
ch_ppocr_mobile_v2.0_cls	原始分类器模型，对检测到的文本行文字视点分类

四、标示东西PPOCRLabel

PPOCRLabel是一款适用于OCR领域的半主动化图形标示东西，内置PP-OCR模型对数据主动标示和从头辨认。运用Python3和PyQT5编写，支撑矩形框标示和四点标示方法，导出格局可直接用于PaddleOCR检测和辨认模型的练习。

因为PaddleOCR现已包括PPOCRLabel，能够直接运转，指令如下：

cd ./PPOCRLabel  # 切换到PPOCRLabel目录
python PPOCRLabel.py --lang ch

点击主动标示后就能看到主动标示的成果，用户依据自己的需求微谐和修正，非常简略。假如标示的成果和自己预想的不同比较大，能够在标示一定量的数据集后，运用标示的数据集练习出来一个模型，用来替换官方的模型。模型方位：

上图是我的模型的方位，我们能够试着找找自己模型的方位。更多的方法和留意事项，详见下面

1. 装置与运转

1.1 装置PaddlePaddle

pip3 install --upgrade pip
# 假如您的机器装置的是CUDA9或CUDA10，请运转以下指令装置
python3 -m pip install paddlepaddle-gpu -i https://mirror.baidu.com/pypi/simple
# 假如您的机器是CPU，请运转以下指令装置
python3 -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple

更多的版别需求，请参照装置文档中的阐明进行操作。

1.2 装置与运转PPOCRLabel

PPOCRLabel可经过whl包与Python脚本两种方法发动，whl包方法发动愈加便利，python脚本发动便于二次开发

1.2.1 经过whl包装置与运转

Windows

pip install PPOCRLabel  # 装置
PPOCRLabel --lang ch  # 运转

留意：经过whl包装置PPOCRLabel会主动下载 paddleocr whl包，其间shapely依靠可能会呈现 [winRrror 126] 找不到指定模块的问题。 的过错，主张从这里下载并装置

Ubuntu Linux

pip3 install PPOCRLabel
pip3 install trash-cli
PPOCRLabel --lang ch

MacOS

pip3 install PPOCRLabel
pip3 install opencv-contrib-python-headless==4.2.0.32 # 假如下载过慢请增加"-i https://mirror.baidu.com/pypi/simple"
PPOCRLabel --lang ch # 发动

假如上述装置呈现问题，能够参阅3.6节过错提示

1.2.2 本地构建whl包并装置

cd PaddleOCR/PPOCRLabel
python3 setup.py bdist_wheel 
pip3 install dist/PPOCRLabel-1.0.2-py2.py3-none-any.whl -i https://mirror.baidu.com/pypi/simple

1.2.3 经过Python脚本运转PPOCRLabel

假如您对PPOCRLabel文件有所更改，经过Python脚本运转会愈加方面的看到更改的成果

cd ./PPOCRLabel  # 切换到PPOCRLabel目录
python PPOCRLabel.py --lang ch

2. 运用

2.1 操作步骤

装置与运转：运用上述指令装置与运转程序。
翻开文件夹：在菜单栏点击 “文件” – “翻开目录” 挑选待符号图片的文件夹[1].
主动标示：点击 ”主动标示“，运用PPOCR超轻量模型对图片文件名前图片状况[2]为 “X” 的图片进行主动标示。
手动标示：点击 “矩形标示”（引荐直接在英文方法下点击键盘中的 “W”)，用户可对当时图片中模型未检出的部分进行手动制作符号框。点击键盘Q，则运用四点标示方法（或点击“修正” – “四点标示”），用户依次点击4个点后，双击左键表明标示完结。
符号框制作完结后，用户点击 “承认”，检测框会先被预分配一个 “待辨认” 标签。
从头辨认：将图片中的一切检测画制作/调整完结后，点击 “从头辨认”，PPOCR模型会对当时图片中的一切检测框从头辨认[3]。
内容更改：双击辨认成果，对不准确的辨认成果进行手动更改。
承认符号：点击 “承认”，图片状况切换为 “√”，跳转至下一张。
删去：点击 “删去图画”，图片将会被删去至回收站。
导出成果：用户能够经过菜单中“文件-导出符号成果”手动导出，一起也能够点击“文件 – 主动导出符号成果”敞开主动导出。手动承认过的符号将会被寄存在所翻开图片文件夹下的Label.txt中。在菜单栏点击 “文件” – “导出辨认成果”后，会将此类图片的辨认练习数据保存在crop_img文件夹下，辨认标签保存在rec_gt.txt中[4]。

2.2 留意

[1] PPOCRLabel以文件夹为基本符号单位，翻开待符号的图片文件夹后，不会在窗口栏中显现图片，而是在点击 “挑选文件夹” 之后直接将文件夹下的图片导入到程序中。

[2] 图片状况表明本张图片用户是否手动保存过，未手动保存过即为 “X”，手动保存过为 “√”。点击 “主动标示”按钮后，PPOCRLabel不会对状况为 “√” 的图片从头标示。

[3] 点击“从头辨认”后，模型会对图片中的辨认成果进行掩盖。因而假如在此之前手动更改正辨认成果，有可能在从头辨认后发生变化。

[4] PPOCRLabel发生的文件放置于符号图片文件夹下，包括一下几种，请勿手动更改其间内容，不然会引起程序呈现反常。

文件名	阐明
Label.txt	检测标签，可直接用于PPOCR检测模型练习。用户每承认5张检测成果后，程序会进行主动写入。当用户封闭应用程序或切换文件途径后同样会进行写入。
fileState.txt	图片状况符号文件，保存当时文件夹下现已被用户手动承认过的图片称号。
Cache.cach	缓存文件，保存模型主动辨认的成果。
rec_gt.txt	辨认标签。可直接用于PPOCR辨认模型练习。需用户手动点击菜单栏“文件” – “导出辨认成果”后发生。
crop_img	辨认数据。依照检测框切开后的图片。与rec_gt.txt一起发生。

3. 阐明

3.1 快捷键

快捷键	阐明
Ctrl + shift + R	对当时图片的一切符号从头辨认
W	新建矩形框
Q	新建四点框
Ctrl + E	修正所选框标签
Ctrl + R	从头辨认所选符号
Ctrl + C	仿制并张贴选中的符号框
Ctrl + 鼠标左键	多选符号框
Backspace	删去所选框
Ctrl + V	承认本张图片符号
Ctrl + Shift + d	删去本张图片
D	下一张图片
A	上一张图片
Ctrl++	缩小
Ctrl–	放大
↑→↓←	移动符号框

3.2 内置模型

默许模型：PPOCRLabel默许运用PaddleOCR中的中英文超轻量OCR模型，支撑中英文与数字辨认，多种言语检测。
模型言语切换：用户可经过菜单栏中 “PaddleOCR” – “挑选模型” 切换内置模型言语，现在支撑的言语包括法文、德文、韩文、日文。详细模型下载链接可参阅PaddleOCR模型列表.
自界说模型：假如用户想将内置模型更换为自己的推理模型，可依据自界说模型代码运用，经过修正PPOCRLabel.py中针对PaddleOCR类的实例化，经过修正PPOCRLabel.py中针对PaddleOCR类的实例化) 完结，例如指定检测模型：self.ocr = PaddleOCR(det=True, cls=True, use_gpu=gpu, lang=lang)，在 det_model_dir 中传入自己的模型即可。

3.3 导出符号成果

PPOCRLabel支撑三种导出方法：

主动导出：点击“文件 – 主动导出符号成果”后，用户每承认过一张图片，程序主动将符号成果写入Label.txt中。若未敞开此选项，则检测到用户手动承认过5张图片后进行主动导出。

默许情况下主动导出功能为封闭状况
手动导出：点击“文件 – 导出符号成果”手动导出符号。
封闭应用程序导出

3.4 导出部分辨认成果

针对部分难以辨认的数据，经过在辨认成果的复选框中撤销勾选相应的符号，其辨认成果不会被导出。被撤销勾选的辨认成果在符号文件 label.txt 中的 difficult 变量保存为 True 。

留意：辨认成果中的复选框状况仍需用户手动点击承认后才干保存

3.5 数据集区分

在终端中输入以下指令履行数据集区分脚本：

cd ./PPOCRLabel # 将目录切换到PPOCRLabel文件夹下
python gen_ocr_train_val_test.py --trainValTestRatio 6:2:2 --datasetRootPath ../train_data

参数阐明：

trainValTestRatio 是练习集、验证集、测验集的图画数量区分比例，依据实践情况设定，默许是6:2:2

datasetRootPath 是PPOCRLabel标示的完好数据集寄存途径。默许途径是 PaddleOCR/train_data 切割数据集前应有如下结构：

|-train_data
  |-crop_img
    |- word_001_crop_0.png
    |- word_002_crop_0.jpg
    |- word_003_crop_0.jpg
    | ...
  | Label.txt
  | rec_gt.txt
  |- word_001.png
  |- word_002.jpg
  |- word_003.jpg
  | ...

3.6 过错提示

假如一起运用whl包装置了paddleocr，其优先级大于经过paddleocr.py调用PaddleOCR类，whl包未更新时会导致程序反常。
PPOCRLabel不支撑对中文文件名的图片进行主动标示。
针对Linux用户：假如您在翻开软件进程中呈现**objc[XXXXX]**最初的过错，证明您的opencv版别太高，主张装置4.2版别：
```
pip install opencv-python==4.2.0.32
```
假如呈现 Missing string id 最初的过错，需求从头编译资源：
```
pyrcc5 -o libs/resources.py resources.qrc
```
假如呈现module 'cv2' has no attribute 'INTER_NEAREST'过错，需求首先删去一切opencv相关包，然后从头装置4.2.0.32版别的headless opencv
```
pip install opencv-contrib-python-headless==4.2.0.32
```

五、练习检测器

1、制作数据集

完结数据的标示就能够看是练习检测器了。找到Lable.txt,将其间一部分放到train_label.txt ，将一部分放到test_label.txt，将图片放到ppocr（这个文件夹的姓名和标示时的图片文件夹的姓名共同），如下：

PaddleOCR-release-2.5/train_data/icdar2015/text_localization/
  └─ ppocr/         图片寄存的方位
  └─ train_label.txt    icdar数据集的练习标示
  └─ test_label.txt     icdar数据集的测验标示

自界说切分数据集代码。我在这里没有运用官方给的切分方法，是自界说的切分方法。

import os
import shutil
from sklearn.model_selection import train_test_split
label_txt='./ppocr/Label.txt' #标示数据的途径
if not os.path.exists('tmp'):
    os.makedirs('tmp')
with open(label_txt, 'r') as f:
   txt_List=f.readlines()
   trainval_files, val_files = train_test_split(txt_List, test_size=0.1, random_state=42)
   print(trainval_files)
   f = open("train_label.txt", "w")
   f.writelines(trainval_files)
   f.close()
   f = open("test_label.txt", "w")
   f.writelines(val_files)
   f.close()
   for txt in txt_List:
       image_name=txt.split('\t')[0]
       new_path="./tmp/"+image_name.split('/')[1]
       shutil.move(image_name, new_path)
       print(image_name)

假如途径不存在，请手动创立。履行完结后将tmp文件夹里面的图片放到PaddleOCR-release-2.5/train_data/icdar2015/text_localization/ppocr/文件夹下面。假如不存在则自己创立。

2、下载预练习模型

然后下载预练习模型，将其放到pretrain_models文件夹中，指令如下：

# 依据backbone的不同挑选下载对应的预练习模型
# 下载MobileNetV3的预练习模型
wget -P ./pretrain_models/ https://paddleocr.bj.bcebos.com/pretrained/MobileNetV3_large_x0_5_pretrained.pdparams
# 或，下载ResNet18_vd的预练习模型
wget -P ./pretrain_models/ https://paddleocr.bj.bcebos.com/pretrained/ResNet18_vd_pretrained.pdparams
# 或，下载ResNet50_vd的预练习模型
wget -P ./pretrain_models/ https://paddleocr.bj.bcebos.com/pretrained/ResNet50_vd_ssld_pretrained.pdparams

不同的预练习模型对应不同的装备文件，详见第3节。这次我选用如下图的装备：

3、修正装备文件

然后修正该config文件，途径： configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml，翻开文件对里面的参数进行修正该。

依照自己界说的途径，修正练习集的途径。

依照自己界说的途径，修正验证集的途径。

对BatchSize的修正。假如练习出来的检测框偏小，能够修正参数unclip_ratio，将其调大即可。

4、敞开练习

完结上面的工作就能够发动练习了，在pycharm的Terminal中输入指令：

留意:在PaddleOCR的根目录履行指令。

# 单机单卡练习 
python tools/train.py -c configs/det/ch_PP-OCRv3/ch_PP-OCRv3_det_cml.yml  -o Global.pretrained_model=./pretrain_models/

更多的练习方法如下：

# 单机单卡练习 mv3_db 模型
python3 tools/train.py -c configs/det/det_mv3_db.yml \
     -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained

# 单机多卡练习，经过 --gpus 参数设置运用的GPU ID
python3 -m paddle.distributed.launch --gpus '0,1,2,3' tools/train.py -c configs/det/det_mv3_db.yml \
     -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained

# 多机多卡练习，经过 --ips 参数设置运用的机器IP地址，经过 --gpus 参数设置运用的GPU ID
python3 -m paddle.distributed.launch --ips="xx.xx.xx.xx,xx.xx.xx.xx" --gpus '0,1,2,3' tools/train.py -c configs/det/det_mv3_db.yml \
     -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained

4.1、断点练习

假如练习程序中止，假如期望加载练习中止的模型然后康复练习，能够经过指定Global.checkpoints指定要加载的模型途径：

python3 tools/train.py -c configs/det/det_mv3_db.yml -o Global.checkpoints=./your/trained/model

留意：Global.checkpoints的优先级高于Global.pretrained_model的优先级，即一起指定两个参数时，优先加载Global.checkpoints指定的模型，假如Global.checkpoints指定的模型途径有误，会加载Global.pretrained_model指定的模型。

4.2 混合精度练习

假如您想进一步加速练习速度，能够运用主动混合精度练习，以单机单卡为例，指令如下：

python3 tools/train.py -c configs/det/det_mv3_db.yml -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained Global.use_amp=True Global.scale_loss=1024.0 Global.use_dynamic_loss_scaling=True

4.3 分布式练习

多机多卡练习时，经过 --ips 参数设置运用的机器IP地址，经过 --gpus 参数设置运用的GPU ID：

python3 -m paddle.distributed.launch --ips="xx.xx.xx.xx,xx.xx.xx.xx" --gpus '0,1,2,3' tools/train.py -c configs/det/det_mv3_db.yml -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained

留意: 选用多机多卡练习时，需求替换上面指令中的ips值为您机器的地址，机器之间需求能够相互ping通。别的，练习时需求在多个机器上分别发动指令。检查机器ip地址的指令为ifconfig。分布式练习，我没有试过，主要是没有钞能力。

5、模型评价与猜测

5.1 目标评价

PaddleOCR核算三个OCR检测相关的目标，分别是：Precision、Recall、Hmean（F-Score）。

练习中模型参数默许保存在Global.save_model_dir目录下。在评价目标时，需求设置Global.checkpoints指向保存的参数文件。

python tools/eval.py -c configs/det/det_mv3_db.yml  -o Global.checkpoints="{path/to/weights}/best_accuracy"

5.2 测验检测作用

测验单张图画的检测作用：

python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/img_10.jpg" Global.pretrained_model="./output/det_db/best_accuracy"

测验DB模型时，调整后处理阈值：

python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/img_10.jpg" Global.pretrained_model="./output/det_db/best_accuracy"  PostProcess.box_thresh=0.6 PostProcess.unclip_ratio=2.0

注：box_thresh、unclip_ratio是DB后处理参数，其他检测模型不支撑。

测验文件夹下一切图画的检测作用：

python3 tools/infer_det.py -c configs/det/det_mv3_db.yml -o Global.infer_img="./doc/imgs_en/" Global.pretrained_model="./output/det_db/best_accuracy"

6. 模型导出与猜测

inference 模型（paddle.jit.save保存的模型）一般是模型练习，把模型结构和模型参数保存在文件中的固化模型，多用于猜测布置场景。练习进程中保存的模型是checkpoints模型，保存的只要模型的参数，多用于康复练习等。与checkpoints模型比较，inference 模型会额定保存模型的结构信息，在猜测布置、加速推理上性能优越，灵敏便利，适合于实践体系集成。

检测模型转inference 模型方法：官方的例子：

# 加载装备文件`det_mv3_db.yml`，从`output/det_db`目录下加载`best_accuracy`模型，inference模型保存在`./output/det_db_inference`目录下
python3 tools/export_model.py -c configs/det/det_mv3_db.yml -o Global.pretrained_model="./output/det_db/best_accuracy" Global.save_inference_dir="./output/det_db_inference/"

自己用的指令：

python tools/export_model.py -c output/db_mv3/config.yml -o Global.pretrained_model="./output/db_mv3/best_accuracy" Global.save_inference_dir="./output/det_db_inference/"

DB检测模型inference 模型猜测：

python3 tools/infer/predict_det.py --det_algorithm="DB" --det_model_dir="./output/det_db_inference/" --image_dir="./doc/imgs/" --use_gpu=True

五、练习辨认器

1、图片裁剪与数据集生成

在练习辨认器之间，我们还有一步要做，便是将标示的数据裁剪出来。裁剪代码如下：

import json
import os
import numpy as np
import cv2
def get_rotate_crop_image(img, points):
    '''
    img_height, img_width = img.shape[0:2]
    left = int(np.min(points[:, 0]))
    right = int(np.max(points[:, 0]))
    top = int(np.min(points[:, 1]))
    bottom = int(np.max(points[:, 1]))
    img_crop = img[top:bottom, left:right, :].copy()
    points[:, 0] = points[:, 0] - left
    points[:, 1] = points[:, 1] - top
    '''
    assert len(points) == 4, "shape of points must be 4*2"
    # 求范数，得到宽度
    img_crop_width = int(
        max(
            np.linalg.norm(points[0] - points[1]),
            np.linalg.norm(points[2] - points[3])))
    #  # 求范数，得到高度        
    img_crop_height = int(
        max(
            np.linalg.norm(points[0] - points[3]),
            np.linalg.norm(points[1] - points[2])))
    pts_std = np.float32([[0, 0], [img_crop_width, 0],
                          [img_crop_width, img_crop_height],
                          [0, img_crop_height]])
    #核算得到转化矩阵                      
    M = cv2.getPerspectiveTransform(points, pts_std)
    #完结透视改换
    dst_img = cv2.warpPerspective(
        img,
        M, (img_crop_width, img_crop_height),
        borderMode=cv2.BORDER_REPLICATE,
        flags=cv2.INTER_CUBIC)
    dst_img_height, dst_img_width = dst_img.shape[0:2]
    if dst_img_height * 1.0 / dst_img_width >= 1.5:
        dst_img = np.rot90(dst_img)
    return dst_img
def write_txt_img(src_path,label_txt):
    with open(src_path, 'r', encoding='utf-8') as f:
        for line in f.readlines():
            print(line)
            content = line.split('\t')
            print(content[0])
            imag_name = content[0].split('/')[1]
            image_path = './train_data/icdar2015/text_localization/' + content[0]
            img = cv2.imread(image_path)
            list_dict = json.loads(content[1])
            nsize = len(list_dict)
            print(nsize)
            num = 0
            for i in range(nsize):
                print(list_dict[i])
                lin = list_dict[i]
                info = lin['transcription']
                info=info.replace(" ","")
                points = lin['points']
                points = [list(x) for x in points]
                points = np.float32([list(map(float, item)) for item in points])
                imag_name=str(num)+"_"+imag_name
                save_path = './train_data/rec/train/' + imag_name
                dst_img = get_rotate_crop_image(img, points)
                cv2.imwrite(save_path, dst_img)
                label_txt.write('train/'+imag_name+'\t'+info+'\n')
                num=num+1
if not os.path.exists('train_data/rec/train/'):
    os.makedirs('train_data/rec/train/')
src_path = r"./train_data/icdar2015/text_localization/train_icdar2015_label.txt"
label_txt=r"./train_data/rec/rec_gt_train.txt"
src_test_path = r"./train_data/icdar2015/text_localization/test_icdar2015_label.txt"
label_test_txt=r"./train_data/rec/rec_gt_test.txt"
with open(label_txt, 'w') as w_label:
    write_txt_img(src_path,w_label)
with open(label_test_txt, 'w') as w_label:
    write_txt_img(src_test_path, w_label)

获取标示区域的图画主要用到了getPerspectiveTransform核算转化的矩阵和warpPerspective函数透视转化的组合。

获取到图画和标示的内容，生成文字辨认通用数据集（SimpleDataSet）。

数据集的格局：

留意： txt文件中默许请将图片途径和图片标签用 \t 切割，如用其他方法切割将造成练习报错。

" 图画文件名                 图画标示信息 "
train/word_001.jpg   简略可依靠
train/word_002.jpg   用科技让复杂的世界更简略

生成数据集的途径如下：

2、修正装备文件

修正装备文件，在configs/rec/中，用rec_icdar15_train.yml 举例：

设置练习集的途径。

设置验证集的途径。

调整练习集和验证集的图片尺寸

设置练习和验证的batchsize。

设置字典，依据任务不同设置的字典也不同。内置字典如下：

PaddleOCR内置了一部分字典，能够按需运用。 ppocr/utils/ppocr_keys_v1.txt 是一个包括6623个字符的中文字典 ppocr/utils/ic15_dict.txt 是一个包括36个字符的英文字典 ppocr/utils/dict/french_dict.txt 是一个包括118个字符的法文字典 ppocr/utils/dict/japan_dict.txt 是一个包括4399个字符的日文字典 ppocr/utils/dict/korean_dict.txt 是一个包括3636个字符的韩文字典 ppocr/utils/dict/german_dict.txt 是一个包括131个字符的德文字典 ppocr/utils/en_dict.txt 是一个包括96个字符的英文字典

3、敞开练习

完结上面的参数的设置，然后开始练习，指令如下：

python tools/train.py -c configs/rec/rec_icdar15_train.yml

更多的练习方法：

#单卡练习（练习周期长，不主张）
python3 tools/train.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.pretrained_model=./pretrain_models/en_PP-OCRv3_rec_train/best_accuracy
#多卡练习，经过--gpus参数指定卡号
python3 -m paddle.distributed.launch --gpus '0,1,2,3'  tools/train.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.pretrained_model=./pretrain_models/en_PP-OCRv3_rec_train/best_accuracy

3.1、断点练习

假如练习程序中止，假如期望加载练习中止的模型然后康复练习，能够经过指定Global.checkpoints指定要加载的模型途径：

python tools/train.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.checkpoints=./your/trained/model

例如：

python tools/train.py -c configs/rec/ch_ppocr_v2.0/rec_chinese_common_train_v2.0.yml -o Global.checkpoints=./output/rec_chinese_common_v2.0/best_accuracy

best_accuracy指的是红框中的三个模型。

3.2、混合精度练习

假如您想进一步加速练习速度，能够运用主动混合精度练习，以单机单卡为例，指令如下：

python3 tools/train.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml \
     -o Global.pretrained_model=./pretrain_models/en_PP-OCRv3_rec_train/best_accuracy \
     Global.use_amp=True Global.scale_loss=1024.0 Global.use_dynamic_loss_scaling=True

3.3、分布式练习

多机多卡练习时，经过 --ips 参数设置运用的机器IP地址，经过 --gpus 参数设置运用的GPU ID：

python3 -m paddle.distributed.launch --ips="xx.xx.xx.xx,xx.xx.xx.xx" --gpus '0,1,2,3' tools/train.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml \
     -o Global.pretrained_model=./pretrain_models/en_PP-OCRv3_rec_train/best_accuracy

留意: 选用多机多卡练习时，需求替换上面指令中的ips值为您机器的地址，机器之间需求能够相互ping通。别的，练习时需求在多个机器上分别发动指令。检查机器ip地址的指令为ifconfig。

4 模型评价与猜测

4.1、目标评价

练习中模型参数默许保存在Global.save_model_dir目录下。在评价目标时，需求设置Global.checkpoints指向保存的参数文件。评价数据集能够经过 configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml 修正Eval中的 label_file_path 设置。

# GPU 评价， Global.checkpoints 为待测权重
python -m paddle.distributed.launch --gpus '0' tools/eval.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.checkpoints={path/to/weights}/best_accuracy

4.2、测验辨认作用

运用 PaddleOCR 练习好的模型，能够经过以下脚本进行快速猜测。

默许猜测图片存储在 infer_img 里，经过 -o Global.checkpoints 加载练习好的参数文件：

依据装备文件中设置的 save_model_dir 和 save_epoch_step 字段，会有以下几种参数被保存下来：

output/rec/
├── best_accuracy.pdopt  
├── best_accuracy.pdparams  
├── best_accuracy.states  
├── config.yml  
├── iter_epoch_3.pdopt  
├── iter_epoch_3.pdparams  
├── iter_epoch_3.states  
├── latest.pdopt  
├── latest.pdparams  
├── latest.states  
└── train.log

其间 best_accuracy.* 是评价集上的最优模型；iter_epoch_3.* 是以 save_epoch_step 为间隔保存下来的模型；latest.* 是最后一个epoch的模型。

# 猜测英文成果
python tools/infer_rec.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.pretrained_model={path/to/weights}/best_accuracy  Global.infer_img=doc/imgs_words/en/word_1.png

猜测运用的装备文件有必要与练习共同，如您经过 python tools/train.py -c configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml 完结了中文模型的练习，您能够运用如下指令进行中文模型猜测。

# 猜测中文成果
python tools/infer_rec.py -c configs/rec/ch_ppocr_v2.0/rec_chinese_lite_train_v2.0.yml -o Global.pretrained_model={path/to/weights}/best_accuracy Global.infer_img=doc/imgs_words/ch/word_1.jpg

4. 模型导出与猜测

辨认模型转inference模型与检测的方法相同，如下：官方的例子：

# -c 后面设置练习算法的yml装备文件
# -o 装备可选参数
# Global.pretrained_model 参数设置待转化的练习模型地址，不必增加文件后缀 .pdmodel，.pdopt或.pdparams。
# Global.save_inference_dir参数设置转化的模型将保存的地址。
python tools/export_model.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.pretrained_model=./pretrain_models/en_PP-OCRv3_rec_train/best_accuracy  Global.save_inference_dir=./inference/en_PP-OCRv3_rec/

**留意：**假如您是在自己的数据集上练习的模型，并且调整了中文字符的字典文件，请留意修正装备文件中的character_dict_path为自界说字典文件。自己履行的指令：

python tools/export_model.py -c configs/rec/PP-OCRv3/en_PP-OCRv3_rec.yml -o Global.pretrained_model=./output/v3_en_mobile/best_accuracy  Global.save_inference_dir=./inference/en_PP-OCRv3_rec/

转化成功后，在目录下有三个文件：

inference/en_PP-OCRv3_rec/
    ├── inference.pdiparams         # 辨认inference模型的参数文件
    ├── inference.pdiparams.info    # 辨认inference模型的参数信息，可疏忽
    └── inference.pdmodel           # 辨认inference模型的program文件

自界说模型推理

假如练习时修正了文本的字典，在运用inference模型猜测时，需求经过--rec_char_dict_path指定运用的字典途径

python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png" --rec_model_dir="./your inference model" --rec_image_shape="3, 48, 320" --rec_char_dict_path="your text dict path"

六、hubserving布置

hubserving服务布置目录下包括文本检测、文本方向分类，文本辨认、文本检测+文本方向分类+文本辨认3阶段串联，表格辨认和PP-Structure六种服务包，请依据需求挑选相应的服务包进行装置和发动。目录结构如下：

deploy/hubserving/
  └─  ocr_cls     文本方向分类模块服务包
  └─  ocr_det     文本检测模块服务包
  └─  ocr_rec     文本辨认模块服务包
  └─  ocr_system  文本检测+文本方向分类+文本辨认串联服务包
  └─  structure_table  表格辨认服务包
  └─  structure_system  PP-Structure服务包

每个服务包下包括3个文件。以2阶段串联服务包为例，目录如下：

deploy/hubserving/ocr_system/
  └─  __init__.py    空文件，必选
  └─  config.json    装备文件，可选，运用装备发动服务时作为参数传入
  └─  module.py      主模块，必选，包括服务的完好逻辑
  └─  params.py      参数文件，必选，包括模型途径、前后处理参数等参数

1、预备环境

# 装置paddlehub
# paddlehub 需求 python>3.6.2
pip install paddlehub==2.1.0 --upgrade -i https://mirror.baidu.com/pypi/simple

2、装置服务模块

PaddleOCR提供5种服务模块，依据需求装置所需模块。

在Linux环境下，装置示例如下：

# 装置检测服务模块：
hub install deploy/hubserving/ocr_det/

# 或，装置分类服务模块：  
hub install deploy/hubserving/ocr_cls/

# 或，装置辨认服务模块：  
hub install deploy/hubserving/ocr_rec/

# 或，装置检测+辨认串联服务模块：  
hub install deploy/hubserving/ocr_system/

# 或，装置表格辨认服务模块：  
hub install deploy/hubserving/structure_table/

# 或，装置PP-Structure服务模块：  
hub install deploy/hubserving/structure_system/

在Windows环境下(文件夹的分隔符为“)，装置示例如下：

# 装置检测服务模块：
hub install deploy\hubserving\ocr_det\

# 或，装置分类服务模块：  
hub install deploy\hubserving\ocr_cls\

# 或，装置辨认服务模块：  
hub install deploy\hubserving\ocr_rec\

# 或，装置检测+辨认串联服务模块：
hub install deploy\hubserving\ocr_system\

# 或，装置表格辨认服务模块：
hub install deploy\hubserving\structure_table\

# 或，装置PP-Structure服务模块：  
hub install deploy\hubserving\structure_system\

我运用了检测+方向+辨认，所以只需求装置

hub install deploy/hubserving/ocr_system/

留意：在PaddleOCR-release-2.5目录下履行

3、发动服务

3.1. 指令行指令发动（仅支撑CPU，不引荐）

发动指令：

$ hub serving start --modules [Module1==Version1, Module2==Version2, ...] \
                    --port XXXX \
                    --use_multiprocess \
                    --workers \

参数：

参数	用途
–modules/-m	PaddleHub Serving预装置模型，以多个Module==Version键值对的方法列出 `当不指定Version时，默许挑选最新版别`
–port/-p	服务端口，默许为8866
–use_multiprocess	是否启用并发方法，默许为单进程方法，引荐多核CPU机器运用此方法 `Windows操作体系只支撑单进程方法`
–workers	在并发方法下指定的并发任务数，默许为`2*cpu_count-1`，其间`cpu_count`为CPU核数

如发动串联服务： hub serving start -m ocr_system

这样就完结了一个服务化API的布置，运用默许端口号8866。

3.2、装备文件发动（支撑CPU、GPU）

发动指令： hub serving start -c config.json

其间，config.json格局如下：

{
    "modules_info": {
        "ocr_system": {
            "init_args": {
                "version": "1.0.0",
                "use_gpu": true
            },
            "predict_args": {
            }
        }
    },
    "port": 8868,
    "use_multiprocess": false,
    "workers": 2
}

init_args中的可配参数与module.py中的_initialize函数接口共同。其间，当use_gpu为true时，表明运用GPU发动服务。
predict_args中的可配参数与module.py中的predict函数接口共同。

留意:

运用装备文件发动服务时，其他参数会被疏忽。
假如运用GPU猜测(即，use_gpu置为true)，则需求在发动服务之前，设置CUDA_VISIBLE_DEVICES环境变量，如：export CUDA_VISIBLE_DEVICES=0，不然不必设置。
use_gpu不可与use_multiprocess一起为true。

如，运用GPU 3号卡发动串联服务：

export CUDA_VISIBLE_DEVICES=3
hub serving start -c deploy/hubserving/ocr_system/config.json

4、发送猜测恳求

装备好服务端，可运用以下指令发送猜测恳求，获取猜测成果:

python tools/test_hubserving.py server_url image_path

test_hubserving.py代码：

# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(__dir__)
sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
from ppocr.utils.logging import get_logger
logger = get_logger()
import cv2
import numpy as np
import time
from PIL import Image
from ppocr.utils.utility import get_image_file_list
from tools.infer.utility import draw_ocr, draw_boxes, str2bool
from ppstructure.utility import draw_structure_result
from ppstructure.predict_system import to_excel
import requests
import json
import base64
def cv2_to_base64(image):
    return base64.b64encode(image).decode('utf8')
def draw_server_result(image_file, res):
    img = cv2.imread(image_file)
    image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    if len(res) == 0:
        return np.array(image)
    keys = res[0].keys()
    if 'text_region' not in keys:  # for ocr_rec, draw function is invalid 
        logger.info("draw function is invalid for ocr_rec!")
        return None
    elif 'text' not in keys:  # for ocr_det
        logger.info("draw text boxes only!")
        boxes = []
        for dno in range(len(res)):
            boxes.append(res[dno]['text_region'])
        boxes = np.array(boxes)
        draw_img = draw_boxes(image, boxes)
        return draw_img
    else:  # for ocr_system
        logger.info("draw boxes and texts!")
        boxes = []
        texts = []
        scores = []
        for dno in range(len(res)):
            boxes.append(res[dno]['text_region'])
            texts.append(res[dno]['text'])
            scores.append(res[dno]['confidence'])
        boxes = np.array(boxes)
        scores = np.array(scores)
        draw_img = draw_ocr(
            image, boxes, texts, scores, draw_txt=True, drop_score=0.5)
        return draw_img
def save_structure_res(res, save_folder, image_file):
    img = cv2.imread(image_file)
    excel_save_folder = os.path.join(save_folder, os.path.basename(image_file))
    os.makedirs(excel_save_folder, exist_ok=True)
    # save res
    with open(
            os.path.join(excel_save_folder, 'res.txt'), 'w',
            encoding='utf8') as f:
        for region in res:
            if region['type'] == 'Table':
                excel_path = os.path.join(excel_save_folder,
                                          '{}.xlsx'.format(region['bbox']))
                to_excel(region['res'], excel_path)
            elif region['type'] == 'Figure':
                x1, y1, x2, y2 = region['bbox']
                print(region['bbox'])
                roi_img = img[y1:y2, x1:x2, :]
                img_path = os.path.join(excel_save_folder,
                                        '{}.jpg'.format(region['bbox']))
                cv2.imwrite(img_path, roi_img)
            else:
                for text_result in region['res']:
                    f.write('{}\n'.format(json.dumps(text_result)))
def main(args):
    image_file_list = get_image_file_list(args.image_dir)
    is_visualize = False
    headers = {"Content-type": "application/json"}
    cnt = 0
    total_time = 0
    for image_file in image_file_list:
        img = open(image_file, 'rb').read()
        if img is None:
            logger.info("error in loading image:{}".format(image_file))
            continue
        img_name = os.path.basename(image_file)
        # seed http request
        starttime = time.time()
        data = {'images': [cv2_to_base64(img)]}
        r = requests.post(
            url=args.server_url, headers=headers, data=json.dumps(data))
        elapse = time.time() - starttime
        total_time += elapse
        logger.info("Predict time of %s: %.3fs" % (image_file, elapse))
        res = r.json()["results"][0]
        logger.info(res)
        if args.visualize:
            draw_img = None
            if 'structure_table' in args.server_url:
                to_excel(res['html'], './{}.xlsx'.format(img_name))
            elif 'structure_system' in args.server_url:
                save_structure_res(res['regions'], args.output, image_file)
            else:
                draw_img = draw_server_result(image_file, res)
            if draw_img is not None:
                if not os.path.exists(args.output):
                    os.makedirs(args.output)
                cv2.imwrite(
                    os.path.join(args.output, os.path.basename(image_file)),
                    draw_img[:, :, ::-1])
                logger.info("The visualized image saved in {}".format(
                    os.path.join(args.output, os.path.basename(image_file))))
        cnt += 1
        if cnt % 100 == 0:
            logger.info("{} processed".format(cnt))
    logger.info("avg time cost: {}".format(float(total_time) / cnt))
def parse_args():
    import argparse
    parser = argparse.ArgumentParser(description="args for hub serving")
    parser.add_argument("--server_url", type=str, required=True)
    parser.add_argument("--image_dir", type=str, required=True)
    parser.add_argument("--visualize", type=str2bool, default=False)
    parser.add_argument("--output", type=str, default='./hubserving_result')
    args = parser.parse_args()
    return args
if __name__ == '__main__':
    args = parse_args()
    main(args)

需求给脚本传递2个参数：

server_url：服务地址，格局为 http://[ip_address]:[port]/predict/[module_name] 例如，假如运用装备文件发动分类，检测、辨认，检测+分类+辨认3阶段，表格辨认和PP-Structure服务，那么发送恳求的url将分别是： http://127.0.0.1:8865/predict/ocr_det http://127.0.0.1:8866/predict/ocr_cls http://127.0.0.1:8867/predict/ocr_rec http://127.0.0.1:8868/predict/ocr_system http://127.0.0.1:8869/predict/structure_table http://127.0.0.1:8870/predict/structure_system
image_dir：测验图画途径，能够是单张图片途径，也能够是图画调集目录途径
visualize：是否可视化成果，默许为False
output：可视化成果保存途径，默许为./hubserving_result

访问示例： python tools/test_hubserving.py --server_url=http://127.0.0.1:8868/predict/ocr_system --image_dir=./doc/imgs/ --visualize=false

运转成果：

5、回来成果格局阐明

回来成果为列表（list），列表中的每一项为词典（dict），词典总共可能包括3种字段，信息如下：

字段称号	数据类型	意义
angle	str	文本视点
text	str	文本内容
confidence	float	文本辨认置信度或文本视点分类置信度
text_region	list	文本方位坐标
html	str	表格的html字符串
regions	list	版面剖析+表格辨认+OCR的成果，每一项为一个list，包括表明区域坐标的`bbox`，区域类型的`type`和区域成果的`res`三个字段

不同模块回来的字段不同，如，文本辨认服务模块回来成果不含text_region字段，详细信息如下：

字段名/模块名	ocr_det	ocr_cls	ocr_rec
angle	✔	✔
text	✔	✔	✔
confidence	✔	✔	✔
text_region	✔	✔	✔
html	✔	✔
regions	✔	✔

阐明： 假如需求增加、删去、修正回来字段，可在相应模块的module.py文件中进行修正，完好流程参阅下一节自界说修正服务模块。

PPv3-OCR自定义数据从训练到部署