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

pyxlpr/ppocr/tools/test_hubserving.py

@@ -1,117 +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.
-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 pyxlpr.ppocr.utils.logging import get_logger
-logger = get_logger()
-
-import cv2
-import numpy as np
-import time
-from PIL import Image
-from pyxlpr.ppocr.utils.utility import get_image_file_list
-from pyxlpr.ppocr.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 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 main(url, image_path):
-    image_file_list = get_image_file_list(image_path)
-    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
-
-        # 发送HTTP请求
-        starttime = time.time()
-        data = {'images': [cv2_to_base64(img)]}
-        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()["results"][0]
-        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) != 3:
-        logger.info("Usage: %s server_url image_path" % sys.argv[0])
-    else:
-        server_url = sys.argv[1]
-        image_path = sys.argv[2]
-        main(server_url, image_path)

pyxlpr/ppocr/tools/train.py

@@ -1,163 +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 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__, '..')))
-
-import yaml
-import paddle
-import paddle.distributed as dist
-
-paddle.seed(2)
-
-from pyxlpr.ppocr.data import build_dataloader
-from pyxlpr.ppocr.modeling.architectures import build_model
-from pyxlpr.ppocr.losses import build_loss
-from pyxlpr.ppocr.optimizer import build_optimizer
-from pyxlpr.ppocr.postprocess import build_post_process
-from pyxlpr.ppocr.metrics import build_metric
-from pyxlpr.ppocr.utils.save_load import load_model
-import pyxlpr.ppocr.tools.program as program
-
-dist.get_world_size()
-
-
-def main(config, device, logger, vdl_writer):
-    # init dist environment
-    if config['Global']['distributed']:
-        dist.init_parallel_env()
-
-    global_config = config['Global']
-
-    # 1 创建训练、验证集的dataloader，build dataloader
-    train_dataloader = build_dataloader(config, 'Train', device, logger)
-    if len(train_dataloader) == 0:
-        logger.error(
-            "No Images in train dataset, please ensure\n" +
-            "\t1. The images num in the train label_file_list should be larger than or equal with batch size.\n"
-            +
-            "\t2. The annotation file and path in the configuration file are provided normally."
-        )
-        return
-
-    # Eval数据集是可选的，可以不设置
-    if config['Eval']:
-        valid_dataloader = build_dataloader(config, 'Eval', device, logger)
-    else:
-        valid_dataloader = None
-
-    # print('train_dataloader', len(train_dataloader))
-    # exit()
-    # 2 创建后处理方法，build post process
-    post_process_class = build_post_process(config['PostProcess'],
-                                            global_config)
-
-    # 3 build model
-    # for rec algorithm
-    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'])
-    if config['Global']['distributed']:
-        model = paddle.DataParallel(model)
-
-    # 4 build loss
-    loss_class = build_loss(config['Loss'])
-
-    # 5 build optim
-    optimizer, lr_scheduler = build_optimizer(
-        config['Optimizer'],
-        epochs=config['Global']['epoch_num'],
-        step_each_epoch=len(train_dataloader),
-        parameters=model.parameters())
-
-    # 6 build metric
-    eval_class = build_metric(config['Metric'])
-    # load pretrain model
-    pre_best_model_dict = load_model(config, model, optimizer)
-    logger.info('train dataloader has {} iters'.format(len(train_dataloader)))
-    if valid_dataloader is not None:
-        logger.info('valid dataloader has {} iters'.format(
-            len(valid_dataloader)))
-
-    use_amp = config["Global"].get("use_amp", False)
-    if use_amp:
-        AMP_RELATED_FLAGS_SETTING = {
-            'FLAGS_cudnn_batchnorm_spatial_persistent': 1,
-            'FLAGS_max_inplace_grad_add': 8,
-        }
-        paddle.fluid.set_flags(AMP_RELATED_FLAGS_SETTING)
-        scale_loss = config["Global"].get("scale_loss", 1.0)
-        use_dynamic_loss_scaling = config["Global"].get(
-            "use_dynamic_loss_scaling", False)
-        scaler = paddle.amp.GradScaler(
-            init_loss_scaling=scale_loss,
-            use_dynamic_loss_scaling=use_dynamic_loss_scaling)
-    else:
-        scaler = None
-
-    # start train
-    program.train(config, train_dataloader, valid_dataloader, device, model,
-                  loss_class, optimizer, lr_scheduler, post_process_class,
-                  eval_class, pre_best_model_dict, logger, vdl_writer, scaler)
-
-
-def test_reader(config, device, logger):
-    loader = build_dataloader(config, 'Train', device, logger)
-    import time
-    starttime = time.time()
-    count = 0
-    try:
-        for data in loader():
-            count += 1
-            if count % 1 == 0:
-                batch_time = time.time() - starttime
-                starttime = time.time()
-                logger.info("reader: {}, {}, {}".format(
-                    count, len(data[0]), batch_time))
-    except Exception as e:
-        logger.info(e)
-    logger.info("finish reader: {}, Success!".format(count))
-
-
-if __name__ == '__main__':
-    r""" 示例用法
-    脚本：D:\slns\PaddleOCR\tools\train.py
-    参数：
-        -c configs/det/det_mv3_db.yml
-        -o Global.pretrained_model=./pretrain_models/MobileNetV3_large_x0_5_pretrained
-    工作目录：D:\home\chenkunze\pp
-    """
-
-    # 用于获取配置、设备、日志、visualdl相关信息
-    config, device, logger, vdl_writer = program.preprocess(is_train=True)
-
-    # 如果不想用配置文件，只要能在内存设置好这几个对象，也可以直接调用main
-    main(config, device, logger, vdl_writer)
-    # test_reader(config, device, logger)