From 47f1fb5992cea8e55ce735fdf95c93e023bd2339 Mon Sep 17 00:00:00 2001 From: MissPenguin Date: Thu, 29 Oct 2020 15:50:26 +0800 Subject: [PATCH] update pdserving --- deploy/pdserving/clas_local_server.py | 14 +- deploy/pdserving/clas_rpc_server.py | 14 +- deploy/pdserving/det_local_server.py | 10 +- deploy/pdserving/det_rpc_server.py | 10 +- deploy/pdserving/inference_to_serving.py | 32 ++ deploy/pdserving/ocr_local_server.py | 19 +- deploy/pdserving/ocr_rpc_server.py | 25 +- deploy/pdserving/ocr_web_client.py | 40 --- deploy/pdserving/params.py | 11 +- deploy/pdserving/pdserving_client.py | 117 +++++++ deploy/pdserving/readme.md | 195 +++++++++++ deploy/pdserving/rec_local_server.py | 14 +- deploy/pdserving/rec_rpc_server.py | 14 +- doc/doc_ch/inference.md | 397 ----------------------- 14 files changed, 419 insertions(+), 493 deletions(-) create mode 100644 deploy/pdserving/inference_to_serving.py delete mode 100644 deploy/pdserving/ocr_web_client.py create mode 100644 deploy/pdserving/pdserving_client.py create mode 100644 deploy/pdserving/readme.md delete mode 100644 doc/doc_ch/inference.md diff --git a/deploy/pdserving/clas_local_server.py b/deploy/pdserving/clas_local_server.py index 10de66ce..f823ae5a 100644 --- a/deploy/pdserving/clas_local_server.py +++ b/deploy/pdserving/clas_local_server.py @@ -13,7 +13,6 @@ # limitations under the License. from paddle_serving_client import Client -from paddle_serving_app.reader import OCRReader import cv2 import sys import numpy as np @@ -90,7 +89,6 @@ class TextClassifierHelper(TextClassifier): class OCRService(WebService): def init_rec(self): - self.ocr_reader = OCRReader() self.text_classifier = TextClassifierHelper(global_args) def preprocess(self, feed=[], fetch=[]): @@ -109,16 +107,18 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] _, rec_res = self.text_classifier.postprocess(outputs, self.tmp_args) - res = { - "pred_text": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + res.append({ + "direction": rec_res[i][0], + "confidence": float(rec_res[i][1]) + }) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.cls_model_dir) + ocr_service.load_model_config(global_args.cls_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/clas_rpc_server.py b/deploy/pdserving/clas_rpc_server.py index 9939ba45..cd480031 100644 --- a/deploy/pdserving/clas_rpc_server.py +++ b/deploy/pdserving/clas_rpc_server.py @@ -13,7 +13,6 @@ # limitations under the License. from paddle_serving_client import Client -from paddle_serving_app.reader import OCRReader import cv2 import sys import numpy as np @@ -95,7 +94,6 @@ class TextClassifierHelper(TextClassifier): class OCRService(WebService): def init_rec(self): - self.ocr_reader = OCRReader() self.text_classifier = TextClassifierHelper(global_args) def preprocess(self, feed=[], fetch=[]): @@ -115,16 +113,18 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] _, rec_res = self.text_classifier.postprocess(outputs, self.tmp_args) - res = { - "direction": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + res.append({ + "direction": rec_res[i][0], + "confidence": float(rec_res[i][1]) + }) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.cls_model_dir) + ocr_service.load_model_config(global_args.cls_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/det_local_server.py b/deploy/pdserving/det_local_server.py index 8659dd5b..1ddb2d9a 100644 --- a/deploy/pdserving/det_local_server.py +++ b/deploy/pdserving/det_local_server.py @@ -90,13 +90,15 @@ class DetService(WebService): def postprocess(self, feed={}, fetch=[], fetch_map=None): outputs = [fetch_map[x] for x in fetch] - res = self.text_detector.postprocess(outputs, self.tmp_args) - return {"boxes": res.tolist()} - + det_res = self.text_detector.postprocess(outputs, self.tmp_args) + res = [] + for i in range(len(det_res)): + res.append({"text_region": det_res[i].tolist()}) + return res if __name__ == "__main__": ocr_service = DetService(name="ocr") - ocr_service.load_model_config(global_args.det_model_dir) + ocr_service.load_model_config(global_args.det_server_dir) ocr_service.init_det() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/det_rpc_server.py b/deploy/pdserving/det_rpc_server.py index 3bc0579d..96b9493e 100644 --- a/deploy/pdserving/det_rpc_server.py +++ b/deploy/pdserving/det_rpc_server.py @@ -89,13 +89,15 @@ class DetService(WebService): def postprocess(self, feed={}, fetch=[], fetch_map=None): outputs = [fetch_map[x] for x in fetch] - res = self.text_detector.postprocess(outputs, self.tmp_args) - return {"boxes": res.tolist()} - + det_res = self.text_detector.postprocess(outputs, self.tmp_args) + res = [] + for i in range(len(det_res)): + res.append({"text_region": det_res[i].tolist()}) + return res if __name__ == "__main__": ocr_service = DetService(name="ocr") - ocr_service.load_model_config(global_args.det_model_dir) + ocr_service.load_model_config(global_args.det_server_dir) ocr_service.init_det() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/inference_to_serving.py b/deploy/pdserving/inference_to_serving.py new file mode 100644 index 00000000..5b895f07 --- /dev/null +++ b/deploy/pdserving/inference_to_serving.py @@ -0,0 +1,32 @@ +# 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 argparse +from paddle_serving_client.io import inference_model_to_serving +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--model_dir", type=str) + parser.add_argument("--server_dir", type=str, default="serving_server_dir") + parser.add_argument("--client_dir", type=str, default="serving_client_dir") + return parser.parse_args() + +args = parse_args() +inference_model_dir = args.model_dir +serving_client_dir = os.path.join(args.model_dir, args.server_dir) +serving_server_dir = os.path.join(args.model_dir, args.client_dir) +feed_var_names, fetch_var_names = inference_model_to_serving( + inference_model_dir, serving_client_dir, serving_server_dir, model_filename="model", params_filename="params") + +print("success!") \ No newline at end of file diff --git a/deploy/pdserving/ocr_local_server.py b/deploy/pdserving/ocr_local_server.py index 27631a18..14b7525a 100644 --- a/deploy/pdserving/ocr_local_server.py +++ b/deploy/pdserving/ocr_local_server.py @@ -45,11 +45,11 @@ class TextSystemHelper(TextSystem): if self.use_angle_cls: self.clas_client = Debugger() self.clas_client.load_model_config( - global_args.cls_model_dir, gpu=True, profile=False) + global_args.cls_server_dir, gpu=True, profile=False) self.text_classifier = TextClassifierHelper(args) self.det_client = Debugger() self.det_client.load_model_config( - global_args.det_model_dir, gpu=True, profile=False) + global_args.det_server_dir, gpu=True, profile=False) self.fetch = ["save_infer_model/scale_0.tmp_0", "save_infer_model/scale_1.tmp_0"] def preprocess(self, img): @@ -61,6 +61,7 @@ class TextSystemHelper(TextSystem): return None, None img_crop_list = [] dt_boxes = sorted_boxes(dt_boxes) + self.dt_boxes = dt_boxes for bno in range(len(dt_boxes)): tmp_box = copy.deepcopy(dt_boxes[bno]) img_crop = self.get_rotate_crop_image(img, tmp_box) @@ -101,16 +102,20 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] rec_res = self.text_system.postprocess(outputs, self.tmp_args) - res = { - "pred_text": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + tmp_res = { + "text_region": self.text_system.dt_boxes[i].tolist(), + "text": rec_res[i][0], + "confidence": float(rec_res[i][1]) + } + res.append(tmp_res) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.rec_model_dir) + ocr_service.load_model_config(global_args.rec_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/ocr_rpc_server.py b/deploy/pdserving/ocr_rpc_server.py index 5567b225..83a4a428 100644 --- a/deploy/pdserving/ocr_rpc_server.py +++ b/deploy/pdserving/ocr_rpc_server.py @@ -43,12 +43,14 @@ class TextSystemHelper(TextSystem): if self.use_angle_cls: self.clas_client = Client() self.clas_client.load_client_config( - "cls_infer_client/serving_client_conf.prototxt") + os.path.join(args.cls_client_dir, "serving_client_conf.prototxt") + ) self.clas_client.connect(["127.0.0.1:9294"]) self.text_classifier = TextClassifierHelper(args) self.det_client = Client() self.det_client.load_client_config( - "det_infer_client/serving_client_conf.prototxt") + os.path.join(args.det_client_dir, "serving_client_conf.prototxt") + ) self.det_client.connect(["127.0.0.1:9293"]) self.fetch = ["save_infer_model/scale_0.tmp_0", "save_infer_model/scale_1.tmp_0"] @@ -57,11 +59,12 @@ class TextSystemHelper(TextSystem): fetch_map = self.det_client.predict(feed, fetch) outputs = [fetch_map[x] for x in fetch] dt_boxes = self.text_detector.postprocess(outputs, self.tmp_args) - print(dt_boxes) + # print(dt_boxes) if dt_boxes is None: return None, None img_crop_list = [] dt_boxes = sorted_boxes(dt_boxes) + self.dt_boxes = dt_boxes for bno in range(len(dt_boxes)): tmp_box = copy.deepcopy(dt_boxes[bno]) img_crop = self.get_rotate_crop_image(img, tmp_box) @@ -70,7 +73,7 @@ class TextSystemHelper(TextSystem): feed, fetch, self.tmp_args = self.text_classifier.preprocess( img_crop_list) fetch_map = self.clas_client.predict(feed, fetch) - print(fetch_map) + # print(fetch_map) outputs = [fetch_map[x] for x in self.text_classifier.fetch] for x in fetch_map.keys(): if ".lod" in x: @@ -103,16 +106,20 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] rec_res = self.text_system.postprocess(outputs, self.tmp_args) - res = { - "pred_text": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + tmp_res = { + "text_region": self.text_system.dt_boxes[i].tolist(), + "text": rec_res[i][0], + "confidence": float(rec_res[i][1]) + } + res.append(tmp_res) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.rec_model_dir) + ocr_service.load_model_config(global_args.rec_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/ocr_web_client.py b/deploy/pdserving/ocr_web_client.py deleted file mode 100644 index 4324406b..00000000 --- a/deploy/pdserving/ocr_web_client.py +++ /dev/null @@ -1,40 +0,0 @@ -# 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. -# -*- coding: utf-8 -*- - -import requests -import json -import cv2 -import base64 -import os, sys -import time - - -def cv2_to_base64(image): - #data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(image).decode( - 'utf8') #data.tostring()).decode('utf8') - - -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:9292/ocr/prediction" -test_img_dir = "../../doc/imgs/" -for img_file in os.listdir(test_img_dir): - with open(os.path.join(test_img_dir, img_file), 'rb') as file: - image_data1 = file.read() - image = cv2_to_base64(image_data1) - data = {"feed": [{"image": image}], "fetch": ["res"]} - r = requests.post(url=url, headers=headers, data=json.dumps(data)) - rjson = r.json() - print(rjson) diff --git a/deploy/pdserving/params.py b/deploy/pdserving/params.py index 9d0b082f..0cb3d62e 100644 --- a/deploy/pdserving/params.py +++ b/deploy/pdserving/params.py @@ -14,7 +14,8 @@ def read_params(): #params for text detector cfg.det_algorithm = "DB" - cfg.det_model_dir = "./det_infer_server/" + cfg.det_server_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_det_infer/serving_server_dir" + cfg.det_client_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_det_infer/serving_client_dir" cfg.det_max_side_len = 960 #DB parmas @@ -29,19 +30,21 @@ def read_params(): #params for text recognizer cfg.rec_algorithm = "CRNN" - cfg.rec_model_dir = "./rec_infer_server/" + cfg.rec_server_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_rec_infer/serving_server_dir" + cfg.rec_client_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_rec_infer/serving_client_dir" cfg.rec_image_shape = "3, 32, 320" cfg.rec_char_type = 'ch' cfg.rec_batch_num = 30 cfg.max_text_length = 25 - cfg.rec_char_dict_path = "./ppocr_keys_v1.txt" + cfg.rec_char_dict_path = "../../ppocr/utils/ppocr_keys_v1.txt" cfg.use_space_char = True #params for text classifier cfg.use_angle_cls = True - cfg.cls_model_dir = "./cls_infer_server/" + cfg.cls_server_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_cls_infer/serving_server_dir" + cfg.cls_client_dir = "../../ch_lite/ch_ppocr_mobile_v1.1_cls_infer/serving_client_dir" cfg.cls_image_shape = "3, 48, 192" cfg.label_list = ['0', '180'] cfg.cls_batch_num = 30 diff --git a/deploy/pdserving/pdserving_client.py b/deploy/pdserving/pdserving_client.py new file mode 100644 index 00000000..f3effb95 --- /dev/null +++ b/deploy/pdserving/pdserving_client.py @@ -0,0 +1,117 @@ +# 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__, '..'))) +sys.path.append(os.path.abspath(os.path.join(__dir__, '../../'))) + +from ppocr.utils.utility import initial_logger +logger = initial_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 + +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 rec or clas, draw function is invalid + logger.info("draw function is invalid for rec or clas!") + 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, drop_score=0.5, font_path="../../doc/simfang.ttf") + return draw_img + + +def main(image_path): + image_file_list = get_image_file_list(image_path) + is_visualize = True + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:9292/ocr/prediction" + 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 + + # 发送HTTP请求 + starttime = time.time() + data = {"feed": [{"image": cv2_to_base64(img)}], "fetch": ["res"]} + r = requests.post(url=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()['result'] + logger.info(res) + + if is_visualize: + draw_img = draw_server_result(image_file, res) + if draw_img is not None: + draw_img_save = "./server_results/" + if not os.path.exists(draw_img_save): + os.makedirs(draw_img_save) + cv2.imwrite( + os.path.join(draw_img_save, os.path.basename(image_file)), + draw_img[:, :, ::-1]) + logger.info("The visualized image saved in {}".format( + os.path.join(draw_img_save, 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)) + + +if __name__ == '__main__': + if len(sys.argv) != 2: + logger.info("Usage: %s image_path" % sys.argv[0]) + else: + image_path = sys.argv[1] + main(image_path) diff --git a/deploy/pdserving/readme.md b/deploy/pdserving/readme.md new file mode 100644 index 00000000..52f88d9f --- /dev/null +++ b/deploy/pdserving/readme.md @@ -0,0 +1,195 @@ +[English](readme_en.md) | 简体中文 + +PaddleOCR提供2种服务部署方式： +- 基于PaddleHub Serving的部署：代码路径为"`./deploy/hubserving`"，使用方法参考[文档](../hubserving/readme.md)。 +- 基于PaddleServing的部署：代码路径为"`./deploy/pdserving`"，按照本教程使用。 + +# Paddle Serving 服务部署 +本教程将介绍基于[Paddle Serving](https://github.com/PaddlePaddle/Serving)部署PaddleOCR在线预测服务的详细步骤。 +- [快速启动服务](#快速启动服务) + - [1. 准备环境](#准备环境) + - [2. 转换模型](#转换模型) + - [3. 启动服务](#启动服务) +- [发送预测请求](#发送预测请求) + +pdserving服务部署目录下包括`检测`、`识别`、`2阶段串联`三种服务部署工具，请根据需求选择相应的服务。目录结构如下： +``` +deploy/pdserving/ + └─ det_local_server.py 快速版 检测 服务端 + └─ det_rpc_server.py 标准版 检测 服务端 + └─ rec_local_server.py 快速版 识别 服务端 + └─ rec_rpc_server.py 标准版 识别 服务端 + └─ ocr_local_server.py 快速版 串联 服务端 + └─ ocr_rpc_server.py 标准版 串联 服务端 + └─ ocr_web_client.py 客户端 + └─ params.py 配置文件 +``` + + +## 快速启动服务 + + +### 1. 准备环境 +环境版本要求： +- **CUDA版本：9.X/10.X** +- **CUDNN版本：7.X** +- **操作系统版本：Linux/Windows** +- **Python版本： 2.7/3.5/3.6/3.7** + +**Python操作指南：** + +目前Serving用于OCR的部分功能还在测试当中，因此在这里我们给出[Servnig latest package](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md) +大家根据自己的环境选择需要安装的whl包即可，例如以Python 3.6为例，执行下列命令： +``` +# 安装服务端，CPU/GPU版本选择一个 +# GPU版本服务端 +# CUDA 9 +python -m pip install -U https://paddle-serving.bj.bcebos.com/whl/paddle_serving_server_gpu-0.0.0.post9-py3-none-any.whl +# CUDA 10 +python -m pip install -U https://paddle-serving.bj.bcebos.com/whl/paddle_serving_server_gpu-0.0.0.post10-py3-none-any.whl +# CPU版本服务端 +python -m pip install -U https://paddle-serving.bj.bcebos.com/whl/paddle_serving_server-0.0.0-py3-none-any.whl + +# 安装客户端和App包，CPU、GPU通用 +python -m pip install -U https://paddle-serving.bj.bcebos.com/whl/paddle_serving_client-0.0.0-cp35-none-any.whl https://paddle-serving.bj.bcebos.com/whl/paddle_serving_app-0.0.0-py3-none-any.whl + +# 安装其他依赖 +pip3.6 install func-timeout +``` + + +## 2. 转换模型 + +Paddle Serving无法直接用训练模型（checkpoints 模型）或推理模型（inference 模型）进行部署。Serving模型由两个文件夹构成，用于存放客户端和服务端的配置。本节介绍如何将推理模型转换为Paddle Serving可部署的模型。 + +**以文本检测模型`ch_ppocr_mobile_v1.1_det_infer`为例，文本识别模型和方向分类器的转换同理。** + +首先下载推理模型： +```shell +wget -P ./inference/ https://paddleocr.bj.bcebos.com/20-09-22/mobile/det/ch_ppocr_mobile_v1.1_det_infer.tar && tar xf ./inference/ch_ppocr_mobile_v1.1_det_infer.tar -C ./inference/ +``` +然后运行如下python脚本进行转换，其中，使用参数`model_dir`指定待转换的推理模型路径： +``` +python deploy/pdserving/inference_to_serving.py --model_dir ./inference/ch_ppocr_mobile_v1.1_det_infer +``` +最终会在`ch_ppocr_mobile_v1.1_det_infer`目录下生成客户端和服务端的模型配置，结构如下： +``` +/ch_ppocr_mobile_v1.1_det_infer/ +├── serving_client_dir # 客户端配置文件夹 +└── serving_server_dir # 服务端配置文件夹 +``` + + +## 3. 启动服务 + +启动服务可以根据实际需求选择启动`标准版`或者`快速版`，两种方式的对比如下表： + +|版本|特点|适用场景| +|-|-|-| +|标准版|稳定性高，分布式部署|适用于吞吐量大，需要跨机房部署的情况，只能用于Linux平台| +|快速版|部署方便，预测速度快|适用于对预测速度要求高，迭代速度快的场景，可以支持Linux/Windows| + + +**step 1. 配置环境变量** + +``` +# 以下两步的顺序不能反 +export PYTHONPATH=$PWD:$PYTHONPATH +cd deploy/pdserving +``` + +**step 2. 修改配置参数** + +配置参数在`params.py`中，具体内容如下所示，可根据需要修改相关参数，如修改模型路径、修改后处理参数等。 + +``` +def read_params(): + cfg = Config() + #use gpu + cfg.use_gpu = False #是否使用GPU，False代表使用CPU + cfg.use_pdserving = True #使用paddle serving部署时必须为True + + #params for text detector + cfg.det_algorithm = "DB" + cfg.det_server_dir = "../../inference/ch_ppocr_mobile_v1.1_det_infer/serving_server_dir" + cfg.det_client_dir = "../../inference/ch_ppocr_mobile_v1.1_det_infer/serving_client_dir" + cfg.det_max_side_len = 960 + + #DB parmas + cfg.det_db_thresh =0.3 + cfg.det_db_box_thresh =0.5 + cfg.det_db_unclip_ratio =2.0 + + #EAST parmas + cfg.det_east_score_thresh = 0.8 + cfg.det_east_cover_thresh = 0.1 + cfg.det_east_nms_thresh = 0.2 + + #params for text recognizer + cfg.rec_algorithm = "CRNN" + cfg.rec_server_dir = "../../inference/ch_ppocr_mobile_v1.1_rec_infer/serving_server_dir" + cfg.rec_client_dir = "../../inference/ch_ppocr_mobile_v1.1_rec_infer/serving_client_dir" + + cfg.rec_image_shape = "3, 32, 320" + cfg.rec_char_type = 'ch' + cfg.rec_batch_num = 30 + cfg.max_text_length = 25 + + cfg.rec_char_dict_path = "../../ppocr/utils/ppocr_keys_v1.txt" + cfg.use_space_char = True + + #params for text classifier + cfg.use_angle_cls = True + cfg.cls_server_dir = "../../inference/ch_ppocr_mobile_v1.1_cls_infer/serving_server_dir" + cfg.cls_client_dir = "../../inference/ch_ppocr_mobile_v1.1_cls_infer/serving_client_dir" + cfg.cls_image_shape = "3, 48, 192" + cfg.label_list = ['0', '180'] + cfg.cls_batch_num = 30 + cfg.cls_thresh = 0.9 + + return cfg +``` + +**step 3_1. 启动独立的检测服务或识别服务** + +如果只需要搭建检测服务或识别服务，一行命令即可，检测服务的启动方式如下，识别同理。检测+识别的串联服务请直接跳至step 3_2。 + +``` +# 启动文本检测服务，标准版/快速版 二选一 +python det_rpc_server.py #标准版，Linux用户 +python det_local_server.py #快速版，Windows/Linux用户 +``` + +**step 3_2. 启动文本检测、识别串联的服务** + +如果需要搭建检测+识别的串联服务，快速版与step 3_1中的独立服务启动方式相同，但标准版略有不同，具体步骤如下： + +``` +# 标准版，Linux用户 +# GPU用户 +# 启动检测服务 +python -m paddle_serving_server_gpu.serve --model inference/ch_ppocr_mobile_v1.1_det_infer/serving_server_dir/ --port 9293 --gpu_id 0 +# 启动方向分类器服务 +python -m paddle_serving_server_gpu.serve --model inference/ch_ppocr_mobile_v1.1_cls_infer/serving_server_dir/ --port 9294 --gpu_id 0 +# 启动串联服务 +python ocr_rpc_server.py + +# CPU用户 +# 启动检测服务 +python -m paddle_serving_server.serve --model inference/ch_ppocr_mobile_v1.1_det_infer/serving_server_dir/ --port 9293 +# 启动方向分类器服务 +python -m paddle_serving_server.serve --model ch_ppocr_mobile_v1.1_cls_infer/serving_server_dir/ --port 9294 +# 启动串联服务 +python ocr_rpc_server.py + +# 快速版，Windows/Linux用户 +python ocr_local_server.py +``` + + +## 发送预测请求 +以上所有单独或串联的服务均可使用如下客户端进行访问： +``` +python pdserving_client.py image_path +``` + diff --git a/deploy/pdserving/rec_local_server.py b/deploy/pdserving/rec_local_server.py index 40266e31..72a40f3a 100644 --- a/deploy/pdserving/rec_local_server.py +++ b/deploy/pdserving/rec_local_server.py @@ -13,7 +13,6 @@ # limitations under the License. from paddle_serving_client import Client -from paddle_serving_app.reader import OCRReader import cv2 import sys import numpy as np @@ -135,7 +134,6 @@ class TextRecognizerHelper(TextRecognizer): class OCRService(WebService): def init_rec(self): - self.ocr_reader = OCRReader() self.text_recognizer = TextRecognizerHelper(global_args) def preprocess(self, feed=[], fetch=[]): @@ -155,16 +153,18 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] rec_res = self.text_recognizer.postprocess(outputs, self.tmp_args) - res = { - "pred_text": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + res.append({ + "text": rec_res[i][0], + "confidence": float(rec_res[i][1]) + }) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.rec_model_dir) + ocr_service.load_model_config(global_args.rec_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/deploy/pdserving/rec_rpc_server.py b/deploy/pdserving/rec_rpc_server.py index cb43eb99..63bbee3c 100644 --- a/deploy/pdserving/rec_rpc_server.py +++ b/deploy/pdserving/rec_rpc_server.py @@ -13,7 +13,6 @@ # limitations under the License. from paddle_serving_client import Client -from paddle_serving_app.reader import OCRReader import cv2 import sys import numpy as np @@ -140,7 +139,6 @@ class TextRecognizerHelper(TextRecognizer): class OCRService(WebService): def init_rec(self): - self.ocr_reader = OCRReader() self.text_recognizer = TextRecognizerHelper(global_args) def preprocess(self, feed=[], fetch=[]): @@ -160,16 +158,18 @@ class OCRService(WebService): if ".lod" in x: self.tmp_args[x] = fetch_map[x] rec_res = self.text_recognizer.postprocess(outputs, self.tmp_args) - res = { - "pred_text": [x[0] for x in rec_res], - "score": [str(x[1]) for x in rec_res] - } + res = [] + for i in range(len(rec_res)): + res.append({ + "text": rec_res[i][0], + "confidence": float(rec_res[i][1]) + }) return res if __name__ == "__main__": ocr_service = OCRService(name="ocr") - ocr_service.load_model_config(global_args.rec_model_dir) + ocr_service.load_model_config(global_args.rec_server_dir) ocr_service.init_rec() if global_args.use_gpu: ocr_service.prepare_server( diff --git a/doc/doc_ch/inference.md b/doc/doc_ch/inference.md deleted file mode 100644 index 9e6143ef..00000000 --- a/doc/doc_ch/inference.md +++ /dev/null @@ -1,397 +0,0 @@ - -# 基于Python预测引擎推理 - -inference 模型（`fluid.io.save_inference_model`保存的模型） -一般是模型训练完成后保存的固化模型，多用于预测部署。训练过程中保存的模型是checkpoints模型，保存的是模型的参数，多用于恢复训练等。 -与checkpoints模型相比，inference 模型会额外保存模型的结构信息，在预测部署、加速推理上性能优越，灵活方便，适合与实际系统集成。更详细的介绍请参考文档[分类预测框架](https://github.com/PaddlePaddle/PaddleClas/blob/master/docs/zh_CN/extension/paddle_inference.md). - -接下来首先介绍如何将训练的模型转换成inference模型，然后将依次介绍文本检测、文本识别以及两者串联基于预测引擎推理。 - - -- [一、训练模型转inference模型](#训练模型转inference模型) - - [检测模型转inference模型](#检测模型转inference模型) - - [识别模型转inference模型](#识别模型转inference模型) - - [方向分类模型转inference模型](#方向分类模型转inference模型) - -- [二、文本检测模型推理](#文本检测模型推理) - - [1. 超轻量中文检测模型推理](#超轻量中文检测模型推理) - - [2. DB文本检测模型推理](#DB文本检测模型推理) - - [3. EAST文本检测模型推理](#EAST文本检测模型推理) - - [4. SAST文本检测模型推理](#SAST文本检测模型推理) - -- [三、文本识别模型推理](#文本识别模型推理) - - [1. 超轻量中文识别模型推理](#超轻量中文识别模型推理) - - [2. 基于CTC损失的识别模型推理](#基于CTC损失的识别模型推理) - - [3. 基于Attention损失的识别模型推理](#基于Attention损失的识别模型推理) - - [4. 基于SRN损失的识别模型推理](#基于SRN损失的识别模型推理) - - [5. 自定义文本识别字典的推理](#自定义文本识别字典的推理) - - [6. 多语言模型的推理](#多语言模型的推理) - -- [四、方向分类模型推理](#方向识别模型推理) - - [1. 方向分类模型推理](#方向分类模型推理) - -- [五、文本检测、方向分类和文字识别串联推理](#文本检测、方向分类和文字识别串联推理) - - [1. 超轻量中文OCR模型推理](#超轻量中文OCR模型推理) - - [2. 其他模型推理](#其他模型推理) - - - -## 一、训练模型转inference模型 - -### 检测模型转inference模型 - -下载超轻量级中文检测模型： -``` -wget -P ./ch_lite/ https://paddleocr.bj.bcebos.com/20-09-22/mobile/det/ch_ppocr_mobile_v1.1_det_train.tar && tar xf ./ch_lite/ch_ppocr_mobile_v1.1_det_train.tar -C ./ch_lite/ -``` -上述模型是以MobileNetV3为backbone训练的DB算法，将训练好的模型转换成inference模型只需要运行如下命令： -``` -# -c后面设置训练算法的yml配置文件 -# -o配置可选参数 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/det/det_mv3_db_v1.1.yml -o Global.checkpoints=./ch_lite/ch_ppocr_mobile_v1.1_det_train/best_accuracy Global.save_inference_dir=./inference/det_db/ -``` -转inference模型时，使用的配置文件和训练时使用的配置文件相同。另外，还需要设置配置文件中的`Global.checkpoints`、`Global.save_inference_dir`参数。 -其中`Global.checkpoints`指向训练中保存的模型参数文件，`Global.save_inference_dir`是生成的inference模型要保存的目录。 -转换成功后，在`save_inference_dir`目录下有两个文件： -``` -inference/det_db/ - └─ model 检测inference模型的program文件 - └─ params 检测inference模型的参数文件 -``` - - -### 识别模型转inference模型 - -下载超轻量中文识别模型： -``` -wget -P ./ch_lite/ https://paddleocr.bj.bcebos.com/20-09-22/mobile/rec/ch_ppocr_mobile_v1.1_rec_train.tar && tar xf ./ch_lite/ch_ppocr_mobile_v1.1_rec_train.tar -C ./ch_lite/ -``` - -识别模型转inference模型与检测的方式相同，如下： -``` -# -c后面设置训练算法的yml配置文件 -# -o配置可选参数 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/rec/ch_ppocr_v1.1/rec_chinese_lite_train_v1.1.yml -o Global.checkpoints=./ch_lite/ch_ppocr_mobile_v1.1_rec_train/best_accuracy \ - Global.save_inference_dir=./inference/rec_crnn/ -``` - -**注意：**如果您是在自己的数据集上训练的模型，并且调整了中文字符的字典文件，请注意修改配置文件中的`character_dict_path`是否是所需要的字典文件。 - -转换成功后，在目录下有两个文件： -``` -/inference/rec_crnn/ - └─ model 识别inference模型的program文件 - └─ params 识别inference模型的参数文件 -``` - - -### 方向分类模型转inference模型 - -下载方向分类模型： -``` -wget -P ./ch_lite/ https://paddleocr.bj.bcebos.com/20-09-22/cls/ch_ppocr_mobile_v1.1_cls_train.tar && tar xf ./ch_lite/ch_ppocr_mobile_v1.1_cls_train.tar -C ./ch_lite/ -``` - -方向分类模型转inference模型与检测的方式相同，如下： -``` -# -c后面设置训练算法的yml配置文件 -# -o配置可选参数 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/cls/cls_mv3.yml -o Global.checkpoints=./ch_lite/ch_ppocr_mobile_v1.1_cls_train/best_accuracy \ - Global.save_inference_dir=./inference/cls/ -``` - -转换成功后，在目录下有两个文件： -``` -/inference/cls/ - └─ model 识别inference模型的program文件 - └─ params 识别inference模型的参数文件 -``` - - -## 二、文本检测模型推理 - -文本检测模型推理，默认使用DB模型的配置参数。当不使用DB模型时，在推理时，需要通过传入相应的参数进行算法适配，细节参考下文。 - - -### 1. 超轻量中文检测模型推理 - -超轻量中文检测模型推理，可以执行如下命令： - -``` -python3 tools/infer/predict_det.py --image_dir="./doc/imgs/2.jpg" --det_model_dir="./inference/det_db/" -``` - -可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下： - -![](../imgs_results/det_res_2.jpg) - -通过设置参数`det_max_side_len`的大小，改变检测算法中图片规范化的最大值。当图片的长宽都小于`det_max_side_len`，则使用原图预测，否则将图片等比例缩放到最大值，进行预测。该参数默认设置为`det_max_side_len=960`。 如果输入图片的分辨率比较大，而且想使用更大的分辨率预测，可以执行如下命令： - -``` -python3 tools/infer/predict_det.py --image_dir="./doc/imgs/2.jpg" --det_model_dir="./inference/det_db/" --det_max_side_len=1200 -``` - -如果想使用CPU进行预测，执行命令如下 -``` -python3 tools/infer/predict_det.py --image_dir="./doc/imgs/2.jpg" --det_model_dir="./inference/det_db/" --use_gpu=False -``` - - -### 2. DB文本检测模型推理 - -首先将DB文本检测训练过程中保存的模型，转换成inference model。以基于Resnet50_vd骨干网络，在ICDAR2015英文数据集训练的模型为例（[模型下载地址](https://paddleocr.bj.bcebos.com/det_r50_vd_db.tar))，可以使用如下命令进行转换： - -``` -# -c后面设置训练算法的yml配置文件 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/det/det_r50_vd_db.yml -o Global.checkpoints="./models/det_r50_vd_db/best_accuracy" Global.save_inference_dir="./inference/det_db" -``` - -DB文本检测模型推理，可以执行如下命令： - -``` -python3 tools/infer/predict_det.py --image_dir="./doc/imgs_en/img_10.jpg" --det_model_dir="./inference/det_db/" -``` - -可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下： - -![](../imgs_results/det_res_img_10_db.jpg) - -**注意**：由于ICDAR2015数据集只有1000张训练图像，且主要针对英文场景，所以上述模型对中文文本图像检测效果会比较差。 - - -### 3. EAST文本检测模型推理 - -首先将EAST文本检测训练过程中保存的模型，转换成inference model。以基于Resnet50_vd骨干网络，在ICDAR2015英文数据集训练的模型为例（[模型下载地址](https://paddleocr.bj.bcebos.com/det_r50_vd_east.tar))，可以使用如下命令进行转换： - -``` -# -c后面设置训练算法的yml配置文件 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/det/det_r50_vd_east.yml -o Global.checkpoints="./models/det_r50_vd_east/best_accuracy" Global.save_inference_dir="./inference/det_east" -``` - -**EAST文本检测模型推理，需要设置参数`--det_algorithm="EAST"`**，可以执行如下命令： - -``` -python3 tools/infer/predict_det.py --det_algorithm="EAST" --image_dir="./doc/imgs_en/img_10.jpg" --det_model_dir="./inference/det_east/" -``` -可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下： - -![](../imgs_results/det_res_img_10_east.jpg) - -**注意**：本代码库中，EAST后处理Locality-Aware NMS有python和c++两种版本，c++版速度明显快于python版。由于c++版本nms编译版本问题，只有python3.5环境下会调用c++版nms，其他情况将调用python版nms。 - - - -### 4. SAST文本检测模型推理 -#### (1). 四边形文本检测模型（ICDAR2015） -首先将SAST文本检测训练过程中保存的模型，转换成inference model。以基于Resnet50_vd骨干网络，在ICDAR2015英文数据集训练的模型为例([模型下载地址](https://paddleocr.bj.bcebos.com/SAST/sast_r50_vd_icdar2015.tar))，可以使用如下命令进行转换： -``` -python3 tools/export_model.py -c configs/det/det_r50_vd_sast_icdar15.yml -o Global.checkpoints="./models/sast_r50_vd_icdar2015/best_accuracy" Global.save_inference_dir="./inference/det_sast_ic15" -``` -**SAST文本检测模型推理，需要设置参数`--det_algorithm="SAST"`**，可以执行如下命令： -``` -python3 tools/infer/predict_det.py --det_algorithm="SAST" --image_dir="./doc/imgs_en/img_10.jpg" --det_model_dir="./inference/det_sast_ic15/" -``` -可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下： - -![](../imgs_results/det_res_img_10_sast.jpg) - -#### (2). 弯曲文本检测模型（Total-Text） -首先将SAST文本检测训练过程中保存的模型，转换成inference model。以基于Resnet50_vd骨干网络，在Total-Text英文数据集训练的模型为例（[模型下载地址](https://paddleocr.bj.bcebos.com/SAST/sast_r50_vd_total_text.tar))，可以使用如下命令进行转换： - -``` -python3 tools/export_model.py -c configs/det/det_r50_vd_sast_totaltext.yml -o Global.checkpoints="./models/sast_r50_vd_total_text/best_accuracy" Global.save_inference_dir="./inference/det_sast_tt" -``` - -**SAST文本检测模型推理，需要设置参数`--det_algorithm="SAST"`，同时，还需要增加参数`--det_sast_polygon=True`，**可以执行如下命令： -``` -python3 tools/infer/predict_det.py --det_algorithm="SAST" --image_dir="./doc/imgs_en/img623.jpg" --det_model_dir="./inference/det_sast_tt/" --det_sast_polygon=True -``` -可视化文本检测结果默认保存到`./inference_results`文件夹里面，结果文件的名称前缀为'det_res'。结果示例如下： - -![](../imgs_results/det_res_img623_sast.jpg) - -**注意**：本代码库中，SAST后处理Locality-Aware NMS有python和c++两种版本，c++版速度明显快于python版。由于c++版本nms编译版本问题，只有python3.5环境下会调用c++版nms，其他情况将调用python版nms。 - - - -## 三、文本识别模型推理 - -下面将介绍超轻量中文识别模型推理、基于CTC损失的识别模型推理和基于Attention损失的识别模型推理。对于中文文本识别，建议优先选择基于CTC损失的识别模型，实践中也发现基于Attention损失的效果不如基于CTC损失的识别模型。此外，如果训练时修改了文本的字典，请参考下面的自定义文本识别字典的推理。 - - - -### 1. 超轻量中文识别模型推理 - -超轻量中文识别模型推理，可以执行如下命令： - -``` -python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words/ch/word_4.jpg" --rec_model_dir="./inference/rec_crnn/" -``` - -![](../imgs_words/ch/word_4.jpg) - -执行命令后，上面图像的预测结果（识别的文本和得分）会打印到屏幕上，示例如下： - -Predicts of ./doc/imgs_words/ch/word_4.jpg:['实力活力', 0.89552695] - - - -### 2. 基于CTC损失的识别模型推理 - -我们以STAR-Net为例，介绍基于CTC损失的识别模型推理。 CRNN和Rosetta使用方式类似，不用设置识别算法参数rec_algorithm。 - -首先将STAR-Net文本识别训练过程中保存的模型，转换成inference model。以基于Resnet34_vd骨干网络，使用MJSynth和SynthText两个英文文本识别合成数据集训练 -的模型为例（[模型下载地址](https://paddleocr.bj.bcebos.com/rec_r34_vd_tps_bilstm_ctc.tar))，可以使用如下命令进行转换： - -``` -# -c后面设置训练算法的yml配置文件 -# Global.checkpoints参数设置待转换的训练模型地址，不用添加文件后缀.pdmodel，.pdopt或.pdparams。 -# Global.save_inference_dir参数设置转换的模型将保存的地址。 - -python3 tools/export_model.py -c configs/rec/rec_r34_vd_tps_bilstm_ctc.yml -o Global.checkpoints="./models/rec_r34_vd_tps_bilstm_ctc/best_accuracy" Global.save_inference_dir="./inference/starnet" -``` - -STAR-Net文本识别模型推理，可以执行如下命令： - -``` -python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png" --rec_model_dir="./inference/starnet/" --rec_image_shape="3, 32, 100" --rec_char_type="en" -``` - - -### 3. 基于Attention损失的识别模型推理 - -基于Attention损失的识别模型与ctc不同，需要额外设置识别算法参数 --rec_algorithm="RARE" - -RARE 文本识别模型推理，可以执行如下命令： -``` -python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png" --rec_model_dir="./inference/rare/" --rec_image_shape="3, 32, 100" --rec_char_type="en" --rec_algorithm="RARE" -``` - -![](../imgs_words_en/word_336.png) - -执行命令后，上面图像的识别结果如下： - -Predicts of ./doc/imgs_words_en/word_336.png:['super', 0.9999555] - -**注意**：由于上述模型是参考[DTRB](https://arxiv.org/abs/1904.01906)文本识别训练和评估流程，与超轻量级中文识别模型训练有两方面不同： - -- 训练时采用的图像分辨率不同，训练上述模型采用的图像分辨率是[3，32，100]，而中文模型训练时，为了保证长文本的识别效果，训练时采用的图像分辨率是[3, 32, 320]。预测推理程序默认的的形状参数是训练中文采用的图像分辨率，即[3, 32, 320]。因此，这里推理上述英文模型时，需要通过参数rec_image_shape设置识别图像的形状。 - -- 字符列表，DTRB论文中实验只是针对26个小写英文本母和10个数字进行实验，总共36个字符。所有大小字符都转成了小写字符，不在上面列表的字符都忽略，认为是空格。因此这里没有输入字符字典，而是通过如下命令生成字典.因此在推理时需要设置参数rec_char_type，指定为英文"en"。 - -``` -self.character_str = "0123456789abcdefghijklmnopqrstuvwxyz" -dict_character = list(self.character_str) -``` - -### 4. 基于SRN损失的识别模型推理 - -基于SRN损失的识别模型，需要额外设置识别算法参数 --rec_algorithm="SRN"。 同时需要保证预测shape与训练时一致，如： --rec_image_shape="1, 64, 256" - -``` -python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words_en/word_336.png" \ - --rec_model_dir="./inference/srn/" \ - --rec_image_shape="1, 64, 256" \ - --rec_char_type="en" \ - --rec_algorithm="SRN" -``` - - -### 5. 自定义文本识别字典的推理 -如果训练时修改了文本的字典，在使用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, 32, 100" --rec_char_type="en" --rec_char_dict_path="your text dict path" -``` - - -### 6. 多语言模型的推理 -如果您需要预测的是其他语言模型，在使用inference模型预测时，需要通过`--rec_char_dict_path`指定使用的字典路径, 同时为了得到正确的可视化结果， -需要通过 `--vis_font_path` 指定可视化的字体路径，`doc/` 路径下有默认提供的小语种字体，例如韩文识别： - -``` -python3 tools/infer/predict_rec.py --image_dir="./doc/imgs_words/korean/1.jpg" --rec_model_dir="./your inference model" --rec_char_type="korean" --rec_char_dict_path="ppocr/utils/korean_dict.txt" --vis_font_path="doc/korean.ttf" -``` -![](../imgs_words/korean/1.jpg) - -执行命令后，上图的预测结果为： -``` text -2020-09-19 16:15:05,076-INFO: index: [205 206 38 39] -2020-09-19 16:15:05,077-INFO: word : 바탕으로 -2020-09-19 16:15:05,077-INFO: score: 0.9171358942985535 -``` - - -## 四、方向分类模型推理 - -下面将介绍方向分类模型推理。 - - -### 1. 方向分类模型推理 - -方向分类模型推理，可以执行如下命令： - -``` -python3 tools/infer/predict_cls.py --image_dir="./doc/imgs_words/ch/word_4.jpg" --cls_model_dir="./inference/cls/" -``` - -![](../imgs_words/ch/word_4.jpg) - -执行命令后，上面图像的预测结果（分类的方向和得分）会打印到屏幕上，示例如下： - -Predicts of ./doc/imgs_words/ch/word_4.jpg:['0', 0.9999963] - - -## 五、文本检测、方向分类和文字识别串联推理 - -### 1. 超轻量中文OCR模型推理 - -在执行预测时，需要通过参数`image_dir`指定单张图像或者图像集合的路径、参数`det_model_dir`,`cls_model_dir`和`rec_model_dir`分别指定检测，方向分类和识别的inference模型路径。参数`use_angle_cls`用于控制是否启用方向分类模型。可视化识别结果默认保存到 ./inference_results 文件夹里面。 - -``` -# 使用方向分类器 -python3 tools/infer/predict_system.py --image_dir="./doc/imgs/2.jpg" --det_model_dir="./inference/det_db/" --cls_model_dir="./inference/cls/" --rec_model_dir="./inference/rec_crnn/" --use_angle_cls=true - -# 不使用方向分类器 -python3 tools/infer/predict_system.py --image_dir="./doc/imgs/2.jpg" --det_model_dir="./inference/det_db/" --rec_model_dir="./inference/rec_crnn/" --use_angle_cls=false -``` - - - - - -执行命令后，识别结果图像如下： - -![](../imgs_results/2.jpg) - - -### 2. 其他模型推理 - -如果想尝试使用其他检测算法或者识别算法，请参考上述文本检测模型推理和文本识别模型推理，更新相应配置和模型。 - -**注意：由于检测框矫正逻辑的局限性，暂不支持使用SAST弯曲文本检测模型（即，使用参数`--det_sast_polygon=True`时）进行模型串联。** - -下面给出基于EAST文本检测和STAR-Net文本识别执行命令： - -``` -python3 tools/infer/predict_system.py --image_dir="./doc/imgs_en/img_10.jpg" --det_model_dir="./inference/det_east/" --det_algorithm="EAST" --rec_model_dir="./inference/starnet/" --rec_image_shape="3, 32, 100" --rec_char_type="en" -``` - -执行命令后，识别结果图像如下： - -![](../imgs_results/img_10.jpg) -- GitLab