paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

PaddleClas/deploy/utils/config.py

@@ -1,197 +0,0 @@
-# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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 copy
-import argparse
-import yaml
-
-from utils import logger
-
-__all__ = ['get_config']
-
-
-class AttrDict(dict):
-    def __getattr__(self, key):
-        return self[key]
-
-    def __setattr__(self, key, value):
-        if key in self.__dict__:
-            self.__dict__[key] = value
-        else:
-            self[key] = value
-
-    def __deepcopy__(self, content):
-        return copy.deepcopy(dict(self))
-
-
-def create_attr_dict(yaml_config):
-    from ast import literal_eval
-    for key, value in yaml_config.items():
-        if type(value) is dict:
-            yaml_config[key] = value = AttrDict(value)
-        if isinstance(value, str):
-            try:
-                value = literal_eval(value)
-            except BaseException:
-                pass
-        if isinstance(value, AttrDict):
-            create_attr_dict(yaml_config[key])
-        else:
-            yaml_config[key] = value
-
-
-def parse_config(cfg_file):
-    """Load a config file into AttrDict"""
-    with open(cfg_file, 'r') as fopen:
-        yaml_config = AttrDict(yaml.load(fopen, Loader=yaml.SafeLoader))
-    create_attr_dict(yaml_config)
-    return yaml_config
-
-
-def print_dict(d, delimiter=0):
-    """
-    Recursively visualize a dict and
-    indenting acrrording by the relationship of keys.
-    """
-    placeholder = "-" * 60
-    for k, v in sorted(d.items()):
-        if isinstance(v, dict):
-            logger.info("{}{} : ".format(delimiter * " ",
-                                         logger.coloring(k, "HEADER")))
-            print_dict(v, delimiter + 4)
-        elif isinstance(v, list) and len(v) >= 1 and isinstance(v[0], dict):
-            logger.info("{}{} : ".format(delimiter * " ",
-                                         logger.coloring(str(k), "HEADER")))
-            for value in v:
-                print_dict(value, delimiter + 4)
-        else:
-            logger.info("{}{} : {}".format(delimiter * " ",
-                                           logger.coloring(k, "HEADER"),
-                                           logger.coloring(v, "OKGREEN")))
-        if k.isupper():
-            logger.info(placeholder)
-
-
-def print_config(config):
-    """
-    visualize configs
-    Arguments:
-        config: configs
-    """
-    logger.advertise()
-    print_dict(config)
-
-
-def override(dl, ks, v):
-    """
-    Recursively replace dict of list
-    Args:
-        dl(dict or list): dict or list to be replaced
-        ks(list): list of keys
-        v(str): value to be replaced
-    """
-
-    def str2num(v):
-        try:
-            return eval(v)
-        except Exception:
-            return v
-
-    assert isinstance(dl, (list, dict)), ("{} should be a list or a dict")
-    assert len(ks) > 0, ('lenght of keys should larger than 0')
-    if isinstance(dl, list):
-        k = str2num(ks[0])
-        if len(ks) == 1:
-            assert k < len(dl), ('index({}) out of range({})'.format(k, dl))
-            dl[k] = str2num(v)
-        else:
-            override(dl[k], ks[1:], v)
-    else:
-        if len(ks) == 1:
-            # assert ks[0] in dl, ('{} is not exist in {}'.format(ks[0], dl))
-            if not ks[0] in dl:
-                logger.warning('A new filed ({}) detected!'.format(ks[0], dl))
-            dl[ks[0]] = str2num(v)
-        else:
-            override(dl[ks[0]], ks[1:], v)
-
-
-def override_config(config, options=None):
-    """
-    Recursively override the config
-    Args:
-        config(dict): dict to be replaced
-        options(list): list of pairs(key0.key1.idx.key2=value)
-            such as: [
-                'topk=2',
-                'VALID.transforms.1.ResizeImage.resize_short=300'
-            ]
-    Returns:
-        config(dict): replaced config
-    """
-    if options is not None:
-        for opt in options:
-            assert isinstance(opt, str), (
-                "option({}) should be a str".format(opt))
-            assert "=" in opt, (
-                "option({}) should contain a ="
-                "to distinguish between key and value".format(opt))
-            pair = opt.split('=')
-            assert len(pair) == 2, ("there can be only a = in the option")
-            key, value = pair
-            keys = key.split('.')
-            override(config, keys, value)
-    return config
-
-
-def get_config(fname, overrides=None, show=True):
-    """
-    Read config from file
-    """
-    assert os.path.exists(fname), (
-        'config file({}) is not exist'.format(fname))
-    config = parse_config(fname)
-    override_config(config, overrides)
-    if show:
-        print_config(config)
-    # check_config(config)
-    return config
-
-
-def parser():
-    parser = argparse.ArgumentParser("generic-image-rec train script")
-    parser.add_argument(
-        '-c',
-        '--config',
-        type=str,
-        default='configs/config.yaml',
-        help='config file path')
-    parser.add_argument(
-        '-o',
-        '--override',
-        action='append',
-        default=[],
-        help='config options to be overridden')
-    parser.add_argument(
-        '-v',
-        '--verbose',
-        action='store_true',
-        help='wheather print the config info')
-    return parser
-
-
-def parse_args():
-    args = parser().parse_args()
-    return args

PaddleClas/deploy/utils/draw_bbox.py

@@ -1,61 +0,0 @@
-# Copyright (c) 2021 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 numpy as np
-import cv2
-from PIL import Image, ImageDraw, ImageFont
-
-
-def draw_bbox_results(image,
-                      results,
-                      input_path,
-                      font_path="./utils/simfang.ttf",
-                      save_dir=None):
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
-    draw = ImageDraw.Draw(image)
-    font_size = 18
-    font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
-
-    color = (0, 102, 255)
-
-    for result in results:
-        # empty results
-        if result["rec_docs"] is None:
-            continue
-
-        xmin, ymin, xmax, ymax = result["bbox"]
-        text = "{}, {:.2f}".format(result["rec_docs"], result["rec_scores"])
-        th = font_size
-        tw = font.getsize(text)[0]
-        # tw = int(len(result["rec_docs"]) * font_size) + 60
-        start_y = max(0, ymin - th)
-
-        draw.rectangle(
-            [(xmin + 1, start_y), (xmin + tw + 1, start_y + th)], fill=color)
-
-        draw.text((xmin + 1, start_y), text, fill=(255, 255, 255), font=font)
-
-        draw.rectangle(
-            [(xmin, ymin), (xmax, ymax)], outline=(255, 0, 0), width=2)
-
-    image_name = os.path.basename(input_path)
-    if save_dir is None:
-        save_dir = "output"
-    os.makedirs(save_dir, exist_ok=True)
-    output_path = os.path.join(save_dir, image_name)
-
-    image.save(output_path, quality=95)
-    return np.array(image)

PaddleClas/deploy/utils/encode_decode.py

@@ -1,31 +0,0 @@
-# Copyright (c) 2021 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 base64
-
-import numpy as np
-
-
-def np_to_b64(images):
-    img_str = base64.b64encode(images).decode('utf8')
-    return img_str, images.shape
-
-
-def b64_to_np(b64str, revert_params):
-    shape = revert_params["shape"]
-    dtype = revert_params["dtype"]
-    dtype = getattr(np, dtype) if isinstance(str, type(dtype)) else dtype
-    data = base64.b64decode(b64str.encode('utf8'))
-    data = np.fromstring(data, dtype).reshape(shape)
-    return data

PaddleClas/deploy/utils/get_image_list.py

@@ -1,49 +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 argparse
-import base64
-import numpy as np
-
-
-def get_image_list(img_file):
-    imgs_lists = []
-    if img_file is None or not os.path.exists(img_file):
-        raise Exception("not found any img file in {}".format(img_file))
-
-    img_end = ['jpg', 'png', 'jpeg', 'JPEG', 'JPG', 'bmp']
-    if os.path.isfile(img_file) and img_file.split('.')[-1] in img_end:
-        imgs_lists.append(img_file)
-    elif os.path.isdir(img_file):
-        for single_file in os.listdir(img_file):
-            if single_file.split('.')[-1] in img_end:
-                imgs_lists.append(os.path.join(img_file, single_file))
-    if len(imgs_lists) == 0:
-        raise Exception("not found any img file in {}".format(img_file))
-    imgs_lists = sorted(imgs_lists)
-    return imgs_lists
-
-
-def get_image_list_from_label_file(image_path, label_file_path):
-    imgs_lists = []
-    gt_labels = []
-    with open(label_file_path, "r") as fin:
-        lines = fin.readlines()
-        for line in lines:
-            image_name, label = line.strip("\n").split()
-            label = int(label)
-            imgs_lists.append(os.path.join(image_path, image_name))
-            gt_labels.append(int(label))
-    return imgs_lists, gt_labels

PaddleClas/deploy/utils/logger.py

@@ -1,120 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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 logging
-import os
-import datetime
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s %(levelname)s: %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S")
-
-
-def time_zone(sec, fmt):
-    real_time = datetime.datetime.now()
-    return real_time.timetuple()
-
-
-logging.Formatter.converter = time_zone
-_logger = logging.getLogger(__name__)
-
-Color = {
-    'RED': '\033[31m',
-    'HEADER': '\033[35m',  # deep purple
-    'PURPLE': '\033[95m',  # purple
-    'OKBLUE': '\033[94m',
-    'OKGREEN': '\033[92m',
-    'WARNING': '\033[93m',
-    'FAIL': '\033[91m',
-    'ENDC': '\033[0m'
-}
-
-
-def coloring(message, color="OKGREEN"):
-    assert color in Color.keys()
-    if os.environ.get('PADDLECLAS_COLORING', False):
-        return Color[color] + str(message) + Color["ENDC"]
-    else:
-        return message
-
-
-def anti_fleet(log):
-    """
-    logs will print multi-times when calling Fleet API.
-    Only display single log and ignore the others.
-    """
-
-    def wrapper(fmt, *args):
-        if int(os.getenv("PADDLE_TRAINER_ID", 0)) == 0:
-            log(fmt, *args)
-
-    return wrapper
-
-
-@anti_fleet
-def info(fmt, *args):
-    _logger.info(fmt, *args)
-
-
-@anti_fleet
-def warning(fmt, *args):
-    _logger.warning(coloring(fmt, "RED"), *args)
-
-
-@anti_fleet
-def error(fmt, *args):
-    _logger.error(coloring(fmt, "FAIL"), *args)
-
-
-def scaler(name, value, step, writer):
-    """
-    This function will draw a scalar curve generated by the visualdl.
-    Usage: Install visualdl: pip3 install visualdl==2.0.0b4
-           and then:
-           visualdl --logdir ./scalar --host 0.0.0.0 --port 8830 
-           to preview loss corve in real time.
-    """
-    writer.add_scalar(tag=name, step=step, value=value)
-
-
-def advertise():
-    """
-    Show the advertising message like the following:
-
-    ===========================================================
-    ==        PaddleClas is powered by PaddlePaddle !        ==
-    ===========================================================
-    ==                                                       ==
-    ==   For more info please go to the following website.   ==
-    ==                                                       ==
-    ==       https://github.com/PaddlePaddle/PaddleClas      ==
-    ===========================================================
-
-    """
-    copyright = "PaddleClas is powered by PaddlePaddle !"
-    ad = "For more info please go to the following website."
-    website = "https://github.com/PaddlePaddle/PaddleClas"
-    AD_LEN = 6 + len(max([copyright, ad, website], key=len))
-
-    info(
-        coloring("\n{0}\n{1}\n{2}\n{3}\n{4}\n{5}\n{6}\n{7}\n".format(
-            "=" * (AD_LEN + 4),
-            "=={}==".format(copyright.center(AD_LEN)),
-            "=" * (AD_LEN + 4),
-            "=={}==".format(' ' * AD_LEN),
-            "=={}==".format(ad.center(AD_LEN)),
-            "=={}==".format(' ' * AD_LEN),
-            "=={}==".format(website.center(AD_LEN)),
-            "=" * (AD_LEN + 4), ), "RED"))

PaddleClas/deploy/utils/predictor.py

@@ -1,71 +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 argparse
-import base64
-import shutil
-import cv2
-import numpy as np
-
-from paddle.inference import Config
-from paddle.inference import create_predictor
-
-
-class Predictor(object):
-    def __init__(self, args, inference_model_dir=None):
-        # HALF precission predict only work when using tensorrt
-        if args.use_fp16 is True:
-            assert args.use_tensorrt is True
-        self.args = args
-        self.paddle_predictor, self.config = self.create_paddle_predictor(
-            args, inference_model_dir)
-
-    def predict(self, image):
-        raise NotImplementedError
-
-    def create_paddle_predictor(self, args, inference_model_dir=None):
-        if inference_model_dir is None:
-            inference_model_dir = args.inference_model_dir
-        params_file = os.path.join(inference_model_dir, "inference.pdiparams")
-        model_file = os.path.join(inference_model_dir, "inference.pdmodel")
-        config = Config(model_file, params_file)
-
-        if args.use_gpu:
-            config.enable_use_gpu(args.gpu_mem, 0)
-        else:
-            config.disable_gpu()
-            if args.enable_mkldnn:
-                # cache 10 different shapes for mkldnn to avoid memory leak
-                config.set_mkldnn_cache_capacity(10)
-                config.enable_mkldnn()
-        config.set_cpu_math_library_num_threads(args.cpu_num_threads)
-
-        if args.enable_profile:
-            config.enable_profile()
-        config.disable_glog_info()
-        config.switch_ir_optim(args.ir_optim)  # default true
-        if args.use_tensorrt:
-            config.enable_tensorrt_engine(
-                precision_mode=Config.Precision.Half
-                if args.use_fp16 else Config.Precision.Float32,
-                max_batch_size=args.batch_size,
-                workspace_size=1 << 30,
-                min_subgraph_size=30)
-
-        config.enable_memory_optim()
-        # use zero copy
-        config.switch_use_feed_fetch_ops(False)
-        predictor = create_predictor(config)
-
-        return predictor, config

PaddleClas/deploy/vector_search/__init__.py

@@ -1 +0,0 @@
-from .interface import Graph_Index