pyxllib 0.3.96__py3-none-any.whl → 0.3.200__py3-none-any.whl

pyxlpr/ppocr/tools/infer_cls.py

@@ -1,83 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-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__, '..')))
-
-os.environ["FLAGS_allocator_strategy"] = 'auto_growth'
-
-import paddle
-
-from pyxlpr.ppocr.data import create_operators, transform
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.postprocess import build_post_process
-from pyxlpr.ppocr.utils.save_load import load_model
-from pyxlpr.ppocr.utils.utility import get_image_file_list
-import pyxlpr.ppocr.tools.program as program
-
-
-def main():
-    global_config = config['Global']
-
-    # build post process
-    post_process_class = build_post_process(config['PostProcess'],
-                                            global_config)
-
-    # build model
-    model = build_model(config['Architecture'])
-
-    load_model(config, model)
-
-    # create data ops
-    transforms = []
-    for op in config['Eval']['dataset']['transforms']:
-        op_name = list(op)[0]
-        if 'Label' in op_name:
-            continue
-        elif op_name == 'KeepKeys':
-            op[op_name]['keep_keys'] = ['image']
-        transforms.append(op)
-    global_config['infer_mode'] = True
-    ops = create_operators(transforms, global_config)
-
-    model.eval()
-    for file in get_image_file_list(config['Global']['infer_img']):
-        logger.info("infer_img: {}".format(file))
-        with open(file, 'rb') as f:
-            img = f.read()
-            data = {'image': img}
-        batch = transform(data, ops)
-
-        images = np.expand_dims(batch[0], axis=0)
-        images = paddle.to_tensor(images)
-        preds = model(images)
-        post_result = post_process_class(preds)
-        for rec_reuslt in post_result:
-            logger.info('\t result: {}'.format(rec_reuslt))
-    logger.info("success!")
-
-
-if __name__ == '__main__':
-    config, device, logger, vdl_writer = program.preprocess()
-    main()

pyxlpr/ppocr/tools/infer_det.py

@@ -1,134 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-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__, '..')))
-
-os.environ["FLAGS_allocator_strategy"] = 'auto_growth'
-
-import cv2
-import json
-import paddle
-
-from pyxlpr.ppocr.data import create_operators, transform
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.postprocess import build_post_process
-from pyxlpr.ppocr.utils.save_load import load_model
-from pyxlpr.ppocr.utils.utility import get_image_file_list
-import pyxlpr.ppocr.tools.program as program
-
-
-def draw_det_res(dt_boxes, config, img, img_name, save_path):
-    if len(dt_boxes) > 0:
-        import cv2
-        src_im = img
-        for box in dt_boxes:
-            box = box.astype(np.int32).reshape((-1, 1, 2))
-            cv2.polylines(src_im, [box], True, color=(255, 255, 0), thickness=2)
-        if not os.path.exists(save_path):
-            os.makedirs(save_path)
-        save_path = os.path.join(save_path, os.path.basename(img_name))
-        cv2.imwrite(save_path, src_im)
-        logger.info("The detected Image saved in {}".format(save_path))
-
-
-@paddle.no_grad()
-def main(config, logger):
-    global_config = config['Global']
-
-    # build model
-    model = build_model(config['Architecture'])
-
-    load_model(config, model)
-    # build post process
-    post_process_class = build_post_process(config['PostProcess'])
-
-    # create data ops
-    transforms = []
-    for op in config['Eval']['dataset']['transforms']:
-        op_name = list(op)[0]
-        if 'Label' in op_name:
-            continue
-        elif op_name == 'KeepKeys':
-            op[op_name]['keep_keys'] = ['image', 'shape']
-        transforms.append(op)
-
-    ops = create_operators(transforms, global_config)
-
-    save_res_path = config['Global']['save_res_path']
-    if not os.path.exists(os.path.dirname(save_res_path)):
-        os.makedirs(os.path.dirname(save_res_path))
-
-    model.eval()
-    with open(save_res_path, "wb") as fout:
-        for file in get_image_file_list(config['Global']['infer_img']):
-            logger.info("infer_img: {}".format(file))
-            with open(file, 'rb') as f:
-                img = f.read()
-                data = {'image': img}
-            batch = transform(data, ops)
-
-            images = np.expand_dims(batch[0], axis=0)
-            shape_list = np.expand_dims(batch[1], axis=0)
-            images = paddle.to_tensor(images)
-            preds = model(images)
-            post_result = post_process_class(preds, shape_list)
-
-            src_img = cv2.imread(file)
-
-            dt_boxes_json = []
-            # parser boxes if post_result is dict
-            if isinstance(post_result, dict):
-                det_box_json = {}
-                for k in post_result.keys():
-                    boxes = post_result[k][0]['points']
-                    dt_boxes_list = []
-                    for box in boxes:
-                        tmp_json = {"transcription": ""}
-                        tmp_json['points'] = box.tolist()
-                        dt_boxes_list.append(tmp_json)
-                    det_box_json[k] = dt_boxes_list
-                    save_det_path = os.path.dirname(config['Global'][
-                        'save_res_path']) + "/det_results_{}/".format(k)
-                    draw_det_res(boxes, config, src_img, file, save_det_path)
-            else:
-                boxes = post_result[0]['points']
-                dt_boxes_json = []
-                # write result
-                for box in boxes:
-                    tmp_json = {"transcription": ""}
-                    tmp_json['points'] = box.tolist()
-                    dt_boxes_json.append(tmp_json)
-                save_det_path = os.path.dirname(config['Global'][
-                    'save_res_path']) + "/det_results/"
-                draw_det_res(boxes, config, src_img, file, save_det_path)
-            otstr = file + "\t" + json.dumps(dt_boxes_json) + "\n"
-            fout.write(otstr.encode())
-
-    logger.info("success!")
-
-
-if __name__ == '__main__':
-    config, device, logger, vdl_writer = program.preprocess()
-    main(config, logger)

pyxlpr/ppocr/tools/infer_e2e.py

@@ -1,122 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-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__, '..')))
-
-os.environ["FLAGS_allocator_strategy"] = 'auto_growth'
-
-import cv2
-import json
-import paddle
-
-from pyxlpr.ppocr.data import create_operators, transform
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.postprocess import build_post_process
-from pyxlpr.ppocr.utils.save_load import load_model
-from pyxlpr.ppocr.utils.utility import get_image_file_list
-import pyxlpr.ppocr.tools.program as program
-
-
-def draw_e2e_res(dt_boxes, strs, config, img, img_name):
-    if len(dt_boxes) > 0:
-        src_im = img
-        for box, str in zip(dt_boxes, strs):
-            box = box.astype(np.int32).reshape((-1, 1, 2))
-            cv2.polylines(src_im, [box], True, color=(255, 255, 0), thickness=2)
-            cv2.putText(
-                src_im,
-                str,
-                org=(int(box[0, 0, 0]), int(box[0, 0, 1])),
-                fontFace=cv2.FONT_HERSHEY_COMPLEX,
-                fontScale=0.7,
-                color=(0, 255, 0),
-                thickness=1)
-        save_det_path = os.path.dirname(config['Global'][
-            'save_res_path']) + "/e2e_results/"
-        if not os.path.exists(save_det_path):
-            os.makedirs(save_det_path)
-        save_path = os.path.join(save_det_path, os.path.basename(img_name))
-        cv2.imwrite(save_path, src_im)
-        logger.info("The e2e Image saved in {}".format(save_path))
-
-
-def main():
-    global_config = config['Global']
-
-    # build model
-    model = build_model(config['Architecture'])
-
-    load_model(config, model)
-
-    # build post process
-    post_process_class = build_post_process(config['PostProcess'],
-                                            global_config)
-
-    # create data ops
-    transforms = []
-    for op in config['Eval']['dataset']['transforms']:
-        op_name = list(op)[0]
-        if 'Label' in op_name:
-            continue
-        elif op_name == 'KeepKeys':
-            op[op_name]['keep_keys'] = ['image', 'shape']
-        transforms.append(op)
-
-    ops = create_operators(transforms, global_config)
-
-    save_res_path = config['Global']['save_res_path']
-    if not os.path.exists(os.path.dirname(save_res_path)):
-        os.makedirs(os.path.dirname(save_res_path))
-
-    model.eval()
-    with open(save_res_path, "wb") as fout:
-        for file in get_image_file_list(config['Global']['infer_img']):
-            logger.info("infer_img: {}".format(file))
-            with open(file, 'rb') as f:
-                img = f.read()
-                data = {'image': img}
-            batch = transform(data, ops)
-            images = np.expand_dims(batch[0], axis=0)
-            shape_list = np.expand_dims(batch[1], axis=0)
-            images = paddle.to_tensor(images)
-            preds = model(images)
-            post_result = post_process_class(preds, shape_list)
-            points, strs = post_result['points'], post_result['texts']
-            # write resule
-            dt_boxes_json = []
-            for poly, str in zip(points, strs):
-                tmp_json = {"transcription": str}
-                tmp_json['points'] = poly.tolist()
-                dt_boxes_json.append(tmp_json)
-            otstr = file + "\t" + json.dumps(dt_boxes_json) + "\n"
-            fout.write(otstr.encode())
-            src_img = cv2.imread(file)
-            draw_e2e_res(points, strs, config, src_img, file)
-    logger.info("success!")
-
-
-if __name__ == '__main__':
-    config, device, logger, vdl_writer = program.preprocess()
-    main()

pyxlpr/ppocr/tools/infer_kie.py

@@ -1,153 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import paddle.nn.functional as F
-
-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__, '..')))
-
-os.environ["FLAGS_allocator_strategy"] = 'auto_growth'
-
-import cv2
-import paddle
-
-from pyxlpr.ppocr.data import create_operators, transform
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.utils.save_load import load_model
-import pyxlpr.ppocr.tools.program as program
-import time
-
-
-def read_class_list(filepath):
-    dict = {}
-    with open(filepath, "r") as f:
-        lines = f.readlines()
-        for line in lines:
-            key, value = line.split(" ")
-            dict[key] = value.rstrip()
-    return dict
-
-
-def draw_kie_result(batch, node, idx_to_cls, count):
-    img = batch[6].copy()
-    boxes = batch[7]
-    h, w = img.shape[:2]
-    pred_img = np.ones((h, w * 2, 3), dtype=np.uint8) * 255
-    max_value, max_idx = paddle.max(node, -1), paddle.argmax(node, -1)
-    node_pred_label = max_idx.numpy().tolist()
-    node_pred_score = max_value.numpy().tolist()
-
-    for i, box in enumerate(boxes):
-        if i >= len(node_pred_label):
-            break
-        new_box = [[box[0], box[1]], [box[2], box[1]], [box[2], box[3]],
-                   [box[0], box[3]]]
-        Pts = np.array([new_box], np.int32)
-        cv2.polylines(
-            img, [Pts.reshape((-1, 1, 2))],
-            True,
-            color=(255, 255, 0),
-            thickness=1)
-        x_min = int(min([point[0] for point in new_box]))
-        y_min = int(min([point[1] for point in new_box]))
-
-        pred_label = str(node_pred_label[i])
-        if pred_label in idx_to_cls:
-            pred_label = idx_to_cls[pred_label]
-        pred_score = '{:.2f}'.format(node_pred_score[i])
-        text = pred_label + '(' + pred_score + ')'
-        cv2.putText(pred_img, text, (x_min * 2, y_min),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
-    vis_img = np.ones((h, w * 3, 3), dtype=np.uint8) * 255
-    vis_img[:, :w] = img
-    vis_img[:, w:] = pred_img
-    save_kie_path = os.path.dirname(config['Global'][
-        'save_res_path']) + "/kie_results/"
-    if not os.path.exists(save_kie_path):
-        os.makedirs(save_kie_path)
-    save_path = os.path.join(save_kie_path, str(count) + ".png")
-    cv2.imwrite(save_path, vis_img)
-    logger.info("The Kie Image saved in {}".format(save_path))
-
-
-def main():
-    global_config = config['Global']
-
-    # build model
-    model = build_model(config['Architecture'])
-    load_model(config, model)
-
-    # create data ops
-    transforms = []
-    for op in config['Eval']['dataset']['transforms']:
-        transforms.append(op)
-
-    data_dir = config['Eval']['dataset']['data_dir']
-
-    ops = create_operators(transforms, global_config)
-
-    save_res_path = config['Global']['save_res_path']
-    class_path = config['Global']['class_path']
-    idx_to_cls = read_class_list(class_path)
-    if not os.path.exists(os.path.dirname(save_res_path)):
-        os.makedirs(os.path.dirname(save_res_path))
-
-    model.eval()
-
-    warmup_times = 0
-    count_t = []
-    with open(save_res_path, "wb") as fout:
-        with open(config['Global']['infer_img'], "rb") as f:
-            lines = f.readlines()
-            for index, data_line in enumerate(lines):
-                if index == 10:
-                    warmup_t = time.time()
-                data_line = data_line.decode('utf-8')
-                substr = data_line.strip("\n").split("\t")
-                img_path, label = data_dir + "/" + substr[0], substr[1]
-                data = {'img_path': img_path, 'label': label}
-                with open(data['img_path'], 'rb') as f:
-                    img = f.read()
-                    data['image'] = img
-                st = time.time()
-                batch = transform(data, ops)
-                batch_pred = [0] * len(batch)
-                for i in range(len(batch)):
-                    batch_pred[i] = paddle.to_tensor(
-                        np.expand_dims(
-                            batch[i], axis=0))
-                st = time.time()
-                node, edge = model(batch_pred)
-                node = F.softmax(node, -1)
-                count_t.append(time.time() - st)
-                draw_kie_result(batch, node, idx_to_cls, index)
-    logger.info("success!")
-    logger.info("It took {} s for predict {} images.".format(
-        np.sum(count_t), len(count_t)))
-    ips = len(count_t[warmup_times:]) / np.sum(count_t[warmup_times:])
-    logger.info("The ips is {} images/s".format(ips))
-
-
-if __name__ == '__main__':
-    config, device, logger, vdl_writer = program.preprocess()
-    main()

pyxlpr/ppocr/tools/infer_rec.py

@@ -1,146 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-import os
-import sys
-import json
-
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(__dir__)
-sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
-
-os.environ["FLAGS_allocator_strategy"] = 'auto_growth'
-
-import paddle
-
-from pyxlpr.ppocr.data import create_operators, transform
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.postprocess import build_post_process
-from pyxlpr.ppocr.utils.save_load import load_model
-from pyxlpr.ppocr.utils.utility import get_image_file_list
-import pyxlpr.ppocr.tools.program as program
-
-
-def main():
-    global_config = config['Global']
-
-    # build post process
-    post_process_class = build_post_process(config['PostProcess'],
-                                            global_config)
-
-    # build model
-    if hasattr(post_process_class, 'character'):
-        char_num = len(getattr(post_process_class, 'character'))
-        if config['Architecture']["algorithm"] in ["Distillation",
-                                                   ]:  # distillation model
-            for key in config['Architecture']["Models"]:
-                config['Architecture']["Models"][key]["Head"][
-                    'out_channels'] = char_num
-        else:  # base rec model
-            config['Architecture']["Head"]['out_channels'] = char_num
-
-    model = build_model(config['Architecture'])
-
-    load_model(config, model)
-
-    # create data ops
-    transforms = []
-    for op in config['Eval']['dataset']['transforms']:
-        op_name = list(op)[0]
-        if 'Label' in op_name:
-            continue
-        elif op_name in ['RecResizeImg']:
-            op[op_name]['infer_mode'] = True
-        elif op_name == 'KeepKeys':
-            if config['Architecture']['algorithm'] == "SRN":
-                op[op_name]['keep_keys'] = [
-                    'image', 'encoder_word_pos', 'gsrm_word_pos',
-                    'gsrm_slf_attn_bias1', 'gsrm_slf_attn_bias2'
-                ]
-            elif config['Architecture']['algorithm'] == "SAR":
-                op[op_name]['keep_keys'] = ['image', 'valid_ratio']
-            else:
-                op[op_name]['keep_keys'] = ['image']
-        transforms.append(op)
-    global_config['infer_mode'] = True
-    ops = create_operators(transforms, global_config)
-
-    save_res_path = config['Global'].get('save_res_path',
-                                         "./output/rec/predicts_rec.txt")
-    if not os.path.exists(os.path.dirname(save_res_path)):
-        os.makedirs(os.path.dirname(save_res_path))
-
-    model.eval()
-
-    with open(save_res_path, "w") as fout:
-        for file in get_image_file_list(config['Global']['infer_img']):
-            logger.info("infer_img: {}".format(file))
-            with open(file, 'rb') as f:
-                img = f.read()
-                data = {'image': img}
-            batch = transform(data, ops)
-            if config['Architecture']['algorithm'] == "SRN":
-                encoder_word_pos_list = np.expand_dims(batch[1], axis=0)
-                gsrm_word_pos_list = np.expand_dims(batch[2], axis=0)
-                gsrm_slf_attn_bias1_list = np.expand_dims(batch[3], axis=0)
-                gsrm_slf_attn_bias2_list = np.expand_dims(batch[4], axis=0)
-
-                others = [
-                    paddle.to_tensor(encoder_word_pos_list),
-                    paddle.to_tensor(gsrm_word_pos_list),
-                    paddle.to_tensor(gsrm_slf_attn_bias1_list),
-                    paddle.to_tensor(gsrm_slf_attn_bias2_list)
-                ]
-            if config['Architecture']['algorithm'] == "SAR":
-                valid_ratio = np.expand_dims(batch[-1], axis=0)
-                img_metas = [paddle.to_tensor(valid_ratio)]
-
-            images = np.expand_dims(batch[0], axis=0)
-            images = paddle.to_tensor(images)
-            if config['Architecture']['algorithm'] == "SRN":
-                preds = model(images, others)
-            elif config['Architecture']['algorithm'] == "SAR":
-                preds = model(images, img_metas)
-            else:
-                preds = model(images)
-            post_result = post_process_class(preds)
-            info = None
-            if isinstance(post_result, dict):
-                rec_info = dict()
-                for key in post_result:
-                    if len(post_result[key][0]) >= 2:
-                        rec_info[key] = {
-                            "label": post_result[key][0][0],
-                            "score": float(post_result[key][0][1]),
-                        }
-                info = json.dumps(rec_info)
-            else:
-                if len(post_result[0]) >= 2:
-                    info = post_result[0][0] + "\t" + str(post_result[0][1])
-
-            if info is not None:
-                logger.info("\t result: {}".format(info))
-                fout.write(file + "\t" + info)
-    logger.info("success!")
-
-
-if __name__ == '__main__':
-    config, device, logger, vdl_writer = program.preprocess()
-    main()