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

PaddleClas/deploy/python/predict_rec.py

@@ -1,138 +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(os.path.abspath(os.path.join(__dir__, '../')))
-
-import cv2
-import numpy as np
-
-from utils import logger
-from utils import config
-from utils.predictor import Predictor
-from utils.get_image_list import get_image_list
-from preprocess import create_operators
-from postprocess import build_postprocess
-
-
-class RecPredictor(Predictor):
-    def __init__(self, config):
-        super().__init__(config["Global"],
-                         config["Global"]["rec_inference_model_dir"])
-        self.preprocess_ops = create_operators(config["RecPreProcess"][
-            "transform_ops"])
-        self.postprocess = build_postprocess(config["RecPostProcess"])
-        self.benchmark = config["Global"].get("benchmark", False)
-
-        if self.benchmark:
-            import auto_log
-            pid = os.getpid()
-            self.auto_logger = auto_log.AutoLogger(
-                model_name=config["Global"].get("model_name", "rec"),
-                model_precision='fp16'
-                if config["Global"]["use_fp16"] else 'fp32',
-                batch_size=config["Global"].get("batch_size", 1),
-                data_shape=[3, 224, 224],
-                save_path=config["Global"].get("save_log_path",
-                                               "./auto_log.log"),
-                inference_config=self.config,
-                pids=pid,
-                process_name=None,
-                gpu_ids=None,
-                time_keys=[
-                    'preprocess_time', 'inference_time', 'postprocess_time'
-                ],
-                warmup=2)
-
-    def predict(self, images, feature_normalize=True):
-        input_names = self.paddle_predictor.get_input_names()
-        input_tensor = self.paddle_predictor.get_input_handle(input_names[0])
-
-        output_names = self.paddle_predictor.get_output_names()
-        output_tensor = self.paddle_predictor.get_output_handle(output_names[
-            0])
-
-        if self.benchmark:
-            self.auto_logger.times.start()
-        if not isinstance(images, (list, )):
-            images = [images]
-        for idx in range(len(images)):
-            for ops in self.preprocess_ops:
-                images[idx] = ops(images[idx])
-        image = np.array(images)
-        if self.benchmark:
-            self.auto_logger.times.stamp()
-
-        input_tensor.copy_from_cpu(image)
-        self.paddle_predictor.run()
-        batch_output = output_tensor.copy_to_cpu()
-        if self.benchmark:
-            self.auto_logger.times.stamp()
-
-        if feature_normalize:
-            feas_norm = np.sqrt(
-                np.sum(np.square(batch_output), axis=1, keepdims=True))
-            batch_output = np.divide(batch_output, feas_norm)
-
-        if self.postprocess is not None:
-            batch_output = self.postprocess(batch_output)
-
-        if self.benchmark:
-            self.auto_logger.times.end(stamp=True)
-        return batch_output
-
-
-def main(config):
-    rec_predictor = RecPredictor(config)
-    image_list = get_image_list(config["Global"]["infer_imgs"])
-
-    batch_imgs = []
-    batch_names = []
-    cnt = 0
-    for idx, img_path in enumerate(image_list):
-        img = cv2.imread(img_path)
-        if img is None:
-            logger.warning(
-                "Image file failed to read and has been skipped. The path: {}".
-                format(img_path))
-        else:
-            img = img[:, :, ::-1]
-            batch_imgs.append(img)
-            img_name = os.path.basename(img_path)
-            batch_names.append(img_name)
-            cnt += 1
-
-        if cnt % config["Global"]["batch_size"] == 0 or (idx + 1
-                                                         ) == len(image_list):
-            if len(batch_imgs) == 0:
-                continue
-
-            batch_results = rec_predictor.predict(batch_imgs)
-            for number, result_dict in enumerate(batch_results):
-                filename = batch_names[number]
-                print("{}:\t{}".format(filename, result_dict))
-            batch_imgs = []
-            batch_names = []
-    if rec_predictor.benchmark:
-        rec_predictor.auto_logger.report()
-
-    return
-
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(args.config, overrides=args.override, show=True)
-    main(config)

PaddleClas/deploy/python/predict_system.py

@@ -1,144 +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 sys
-
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))
-
-import copy
-import cv2
-import numpy as np
-import faiss
-import pickle
-
-from python.predict_rec import RecPredictor
-from python.predict_det import DetPredictor
-
-from utils import logger
-from utils import config
-from utils.get_image_list import get_image_list
-from utils.draw_bbox import draw_bbox_results
-
-
-class SystemPredictor(object):
-    def __init__(self, config):
-
-        self.config = config
-        self.rec_predictor = RecPredictor(config)
-        self.det_predictor = DetPredictor(config)
-
-        assert 'IndexProcess' in config.keys(), "Index config not found ... "
-        self.return_k = self.config['IndexProcess']['return_k']
-
-        index_dir = self.config["IndexProcess"]["index_dir"]
-        assert os.path.exists(os.path.join(
-            index_dir, "vector.index")), "vector.index not found ..."
-        assert os.path.exists(os.path.join(
-            index_dir, "id_map.pkl")), "id_map.pkl not found ... "
-        
-        if config['IndexProcess'].get("binary_index", False):
-            self.Searcher = faiss.read_index_binary(
-                os.path.join(index_dir, "vector.index"))
-        else:
-            self.Searcher = faiss.read_index(
-                os.path.join(index_dir, "vector.index"))
-                
-        with open(os.path.join(index_dir, "id_map.pkl"), "rb") as fd:
-            self.id_map = pickle.load(fd)
-
-    def append_self(self, results, shape):
-        results.append({
-            "class_id": 0,
-            "score": 1.0,
-            "bbox":
-            np.array([0, 0, shape[1], shape[0]]),  # xmin, ymin, xmax, ymax
-            "label_name": "foreground",
-        })
-        return results
-
-    def nms_to_rec_results(self, results, thresh=0.1):
-        filtered_results = []
-        x1 = np.array([r["bbox"][0] for r in results]).astype("float32")
-        y1 = np.array([r["bbox"][1] for r in results]).astype("float32")
-        x2 = np.array([r["bbox"][2] for r in results]).astype("float32")
-        y2 = np.array([r["bbox"][3] for r in results]).astype("float32")
-        scores = np.array([r["rec_scores"] for r in results])
-
-        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-        order = scores.argsort()[::-1]
-        while order.size > 0:
-            i = order[0]
-            xx1 = np.maximum(x1[i], x1[order[1:]])
-            yy1 = np.maximum(y1[i], y1[order[1:]])
-            xx2 = np.minimum(x2[i], x2[order[1:]])
-            yy2 = np.minimum(y2[i], y2[order[1:]])
-
-            w = np.maximum(0.0, xx2 - xx1 + 1)
-            h = np.maximum(0.0, yy2 - yy1 + 1)
-            inter = w * h
-            ovr = inter / (areas[i] + areas[order[1:]] - inter)
-            inds = np.where(ovr <= thresh)[0]
-            order = order[inds + 1]
-            filtered_results.append(results[i])
-
-        return filtered_results
-
-    def predict(self, img):
-        output = []
-        # st1: get all detection results
-        results = self.det_predictor.predict(img)
-
-        # st2: add the whole image for recognition to improve recall
-        results = self.append_self(results, img.shape)
-
-        # st3: recognition process, use score_thres to ensure accuracy
-        for result in results:
-            preds = {}
-            xmin, ymin, xmax, ymax = result["bbox"].astype("int")
-            crop_img = img[ymin:ymax, xmin:xmax, :].copy()
-            rec_results = self.rec_predictor.predict(crop_img)
-            preds["bbox"] = [xmin, ymin, xmax, ymax]
-            scores, docs = self.Searcher.search(rec_results, self.return_k)
-            
-            # just top-1 result will be returned for the final
-            if scores[0][0] >= self.config["IndexProcess"]["score_thres"]:
-                preds["rec_docs"] = self.id_map[docs[0][0]].split()[1]
-                preds["rec_scores"] = scores[0][0]
-                output.append(preds)
-
-        # st5: nms to the final results to avoid fetching duplicate results
-        output = self.nms_to_rec_results(
-            output, self.config["Global"]["rec_nms_thresold"])
-
-        return output
-
-
-def main(config):
-    system_predictor = SystemPredictor(config)
-    image_list = get_image_list(config["Global"]["infer_imgs"])
-
-    assert config["Global"]["batch_size"] == 1
-    for idx, image_file in enumerate(image_list):
-        img = cv2.imread(image_file)[:, :, ::-1]
-        output = system_predictor.predict(img)
-        draw_bbox_results(img, output, image_file)
-        print(output)
-    return
-
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(args.config, overrides=args.override, show=True)
-    main(config)

PaddleClas/deploy/python/preprocess.py

@@ -1,337 +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
-from __future__ import unicode_literals
-
-from functools import partial
-import six
-import math
-import random
-import cv2
-import numpy as np
-import importlib
-from PIL import Image
-
-from python.det_preprocess import DetNormalizeImage, DetPadStride, DetPermute, DetResize
-
-
-def create_operators(params):
-    """
-    create operators based on the config
-
-    Args:
-        params(list): a dict list, used to create some operators
-    """
-    assert isinstance(params, list), ('operator config should be a list')
-    mod = importlib.import_module(__name__)
-    ops = []
-    for operator in params:
-        assert isinstance(operator,
-                          dict) and len(operator) == 1, "yaml format error"
-        op_name = list(operator)[0]
-        param = {} if operator[op_name] is None else operator[op_name]
-        op = getattr(mod, op_name)(**param)
-        ops.append(op)
-
-    return ops
-
-
-class UnifiedResize(object):
-    def __init__(self, interpolation=None, backend="cv2"):
-        _cv2_interp_from_str = {
-            'nearest': cv2.INTER_NEAREST,
-            'bilinear': cv2.INTER_LINEAR,
-            'area': cv2.INTER_AREA,
-            'bicubic': cv2.INTER_CUBIC,
-            'lanczos': cv2.INTER_LANCZOS4
-        }
-        _pil_interp_from_str = {
-            'nearest': Image.NEAREST,
-            'bilinear': Image.BILINEAR,
-            'bicubic': Image.BICUBIC,
-            'box': Image.BOX,
-            'lanczos': Image.LANCZOS,
-            'hamming': Image.HAMMING
-        }
-
-        def _pil_resize(src, size, resample):
-            pil_img = Image.fromarray(src)
-            pil_img = pil_img.resize(size, resample)
-            return np.asarray(pil_img)
-
-        if backend.lower() == "cv2":
-            if isinstance(interpolation, str):
-                interpolation = _cv2_interp_from_str[interpolation.lower()]
-            # compatible with opencv < version 4.4.0
-            elif interpolation is None:
-                interpolation = cv2.INTER_LINEAR
-            self.resize_func = partial(cv2.resize, interpolation=interpolation)
-        elif backend.lower() == "pil":
-            if isinstance(interpolation, str):
-                interpolation = _pil_interp_from_str[interpolation.lower()]
-            self.resize_func = partial(_pil_resize, resample=interpolation)
-        else:
-            logger.warning(
-                f"The backend of Resize only support \"cv2\" or \"PIL\". \"f{backend}\" is unavailable. Use \"cv2\" instead."
-            )
-            self.resize_func = cv2.resize
-
-    def __call__(self, src, size):
-        return self.resize_func(src, size)
-
-
-class OperatorParamError(ValueError):
-    """ OperatorParamError
-    """
-    pass
-
-
-class DecodeImage(object):
-    """ decode image """
-
-    def __init__(self, to_rgb=True, to_np=False, channel_first=False):
-        self.to_rgb = to_rgb
-        self.to_np = to_np  # to numpy
-        self.channel_first = channel_first  # only enabled when to_np is True
-
-    def __call__(self, img):
-        if six.PY2:
-            assert type(img) is str and len(
-                img) > 0, "invalid input 'img' in DecodeImage"
-        else:
-            assert type(img) is bytes and len(
-                img) > 0, "invalid input 'img' in DecodeImage"
-        data = np.frombuffer(img, dtype='uint8')
-        img = cv2.imdecode(data, 1)
-        if self.to_rgb:
-            assert img.shape[2] == 3, 'invalid shape of image[%s]' % (
-                img.shape)
-            img = img[:, :, ::-1]
-
-        if self.channel_first:
-            img = img.transpose((2, 0, 1))
-
-        return img
-
-
-class ResizeImage(object):
-    """ resize image """
-
-    def __init__(self,
-                 size=None,
-                 resize_short=None,
-                 interpolation=None,
-                 backend="cv2"):
-        if resize_short is not None and resize_short > 0:
-            self.resize_short = resize_short
-            self.w = None
-            self.h = None
-        elif size is not None:
-            self.resize_short = None
-            self.w = size if type(size) is int else size[0]
-            self.h = size if type(size) is int else size[1]
-        else:
-            raise OperatorParamError("invalid params for ReisizeImage for '\
-                'both 'size' and 'resize_short' are None")
-
-        self._resize_func = UnifiedResize(
-            interpolation=interpolation, backend=backend)
-
-    def __call__(self, img):
-        img_h, img_w = img.shape[:2]
-        if self.resize_short is not None:
-            percent = float(self.resize_short) / min(img_w, img_h)
-            w = int(round(img_w * percent))
-            h = int(round(img_h * percent))
-        else:
-            w = self.w
-            h = self.h
-        return self._resize_func(img, (w, h))
-
-
-class CropImage(object):
-    """ crop image """
-
-    def __init__(self, size):
-        if type(size) is int:
-            self.size = (size, size)
-        else:
-            self.size = size  # (h, w)
-
-    def __call__(self, img):
-        w, h = self.size
-        img_h, img_w = img.shape[:2]
-
-        if img_h < h or img_w < w:
-            raise Exception(
-                f"The size({h}, {w}) of CropImage must be greater than size({img_h}, {img_w}) of image. Please check image original size and size of ResizeImage if used."
-            )
-
-        w_start = (img_w - w) // 2
-        h_start = (img_h - h) // 2
-
-        w_end = w_start + w
-        h_end = h_start + h
-        return img[h_start:h_end, w_start:w_end, :]
-
-
-class RandCropImage(object):
-    """ random crop image """
-
-    def __init__(self,
-                 size,
-                 scale=None,
-                 ratio=None,
-                 interpolation=None,
-                 backend="cv2"):
-        if type(size) is int:
-            self.size = (size, size)  # (h, w)
-        else:
-            self.size = size
-
-        self.scale = [0.08, 1.0] if scale is None else scale
-        self.ratio = [3. / 4., 4. / 3.] if ratio is None else ratio
-
-        self._resize_func = UnifiedResize(
-            interpolation=interpolation, backend=backend)
-
-    def __call__(self, img):
-        size = self.size
-        scale = self.scale
-        ratio = self.ratio
-
-        aspect_ratio = math.sqrt(random.uniform(*ratio))
-        w = 1. * aspect_ratio
-        h = 1. / aspect_ratio
-
-        img_h, img_w = img.shape[:2]
-
-        bound = min((float(img_w) / img_h) / (w**2),
-                    (float(img_h) / img_w) / (h**2))
-        scale_max = min(scale[1], bound)
-        scale_min = min(scale[0], bound)
-
-        target_area = img_w * img_h * random.uniform(scale_min, scale_max)
-        target_size = math.sqrt(target_area)
-        w = int(target_size * w)
-        h = int(target_size * h)
-
-        i = random.randint(0, img_w - w)
-        j = random.randint(0, img_h - h)
-
-        img = img[j:j + h, i:i + w, :]
-
-        return self._resize_func(img, size)
-
-
-class RandFlipImage(object):
-    """ random flip image
-        flip_code:
-            1: Flipped Horizontally
-            0: Flipped Vertically
-            -1: Flipped Horizontally & Vertically
-    """
-
-    def __init__(self, flip_code=1):
-        assert flip_code in [-1, 0, 1
-                             ], "flip_code should be a value in [-1, 0, 1]"
-        self.flip_code = flip_code
-
-    def __call__(self, img):
-        if random.randint(0, 1) == 1:
-            return cv2.flip(img, self.flip_code)
-        else:
-            return img
-
-
-class AutoAugment(object):
-    def __init__(self):
-        self.policy = ImageNetPolicy()
-
-    def __call__(self, img):
-        from PIL import Image
-        img = np.ascontiguousarray(img)
-        img = Image.fromarray(img)
-        img = self.policy(img)
-        img = np.asarray(img)
-
-
-class NormalizeImage(object):
-    """ normalize image such as substract mean, divide std
-    """
-
-    def __init__(self,
-                 scale=None,
-                 mean=None,
-                 std=None,
-                 order='chw',
-                 output_fp16=False,
-                 channel_num=3):
-        if isinstance(scale, str):
-            scale = eval(scale)
-        assert channel_num in [
-            3, 4
-        ], "channel number of input image should be set to 3 or 4."
-        self.channel_num = channel_num
-        self.output_dtype = 'float16' if output_fp16 else 'float32'
-        self.scale = np.float32(scale if scale is not None else 1.0 / 255.0)
-        self.order = order
-        mean = mean if mean is not None else [0.485, 0.456, 0.406]
-        std = std if std is not None else [0.229, 0.224, 0.225]
-
-        shape = (3, 1, 1) if self.order == 'chw' else (1, 1, 3)
-        self.mean = np.array(mean).reshape(shape).astype('float32')
-        self.std = np.array(std).reshape(shape).astype('float32')
-
-    def __call__(self, img):
-        from PIL import Image
-        if isinstance(img, Image.Image):
-            img = np.array(img)
-
-        assert isinstance(img,
-                          np.ndarray), "invalid input 'img' in NormalizeImage"
-
-        img = (img.astype('float32') * self.scale - self.mean) / self.std
-
-        if self.channel_num == 4:
-            img_h = img.shape[1] if self.order == 'chw' else img.shape[0]
-            img_w = img.shape[2] if self.order == 'chw' else img.shape[1]
-            pad_zeros = np.zeros(
-                (1, img_h, img_w)) if self.order == 'chw' else np.zeros(
-                    (img_h, img_w, 1))
-            img = (np.concatenate(
-                (img, pad_zeros), axis=0)
-                   if self.order == 'chw' else np.concatenate(
-                       (img, pad_zeros), axis=2))
-        return img.astype(self.output_dtype)
-
-
-class ToCHWImage(object):
-    """ convert hwc image to chw image
-    """
-
-    def __init__(self):
-        pass
-
-    def __call__(self, img):
-        from PIL import Image
-        if isinstance(img, Image.Image):
-            img = np.array(img)
-
-        return img.transpose((2, 0, 1))

PaddleClas/deploy/utils/__init__.py

@@ -1,5 +0,0 @@
-from . import logger
-from . import config
-from . import get_image_list
-from . import predictor
-from . import encode_decode