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

PaddleClas/deploy/python/det_preprocess.py

@@ -1,205 +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 cv2
-import numpy as np
-
-
-def decode_image(im_file, im_info):
-    """read rgb image
-    Args:
-        im_file (str|np.ndarray): input can be image path or np.ndarray
-        im_info (dict): info of image
-    Returns:
-        im (np.ndarray):  processed image (np.ndarray)
-        im_info (dict): info of processed image
-    """
-    if isinstance(im_file, str):
-        with open(im_file, 'rb') as f:
-            im_read = f.read()
-        data = np.frombuffer(im_read, dtype='uint8')
-        im = cv2.imdecode(data, 1)  # BGR mode, but need RGB mode
-        im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
-    else:
-        im = im_file
-    im_info['im_shape'] = np.array(im.shape[:2], dtype=np.float32)
-    im_info['scale_factor'] = np.array([1., 1.], dtype=np.float32)
-    return im, im_info
-
-
-class DetResize(object):
-    """resize image by target_size and max_size
-    Args:
-        target_size (int): the target size of image
-        keep_ratio (bool): whether keep_ratio or not, default true
-        interp (int): method of resize
-    """
-
-    def __init__(
-            self,
-            target_size,
-            keep_ratio=True,
-            interp=cv2.INTER_LINEAR, ):
-        if isinstance(target_size, int):
-            target_size = [target_size, target_size]
-        self.target_size = target_size
-        self.keep_ratio = keep_ratio
-        self.interp = interp
-
-    def __call__(self, im, im_info):
-        """
-        Args:
-            im (np.ndarray): image (np.ndarray)
-            im_info (dict): info of image
-        Returns:
-            im (np.ndarray):  processed image (np.ndarray)
-            im_info (dict): info of processed image
-        """
-        assert len(self.target_size) == 2
-        assert self.target_size[0] > 0 and self.target_size[1] > 0
-        im_channel = im.shape[2]
-        im_scale_y, im_scale_x = self.generate_scale(im)
-        # set image_shape
-        im_info['input_shape'][1] = int(im_scale_y * im.shape[0])
-        im_info['input_shape'][2] = int(im_scale_x * im.shape[1])
-        im = cv2.resize(
-            im,
-            None,
-            None,
-            fx=im_scale_x,
-            fy=im_scale_y,
-            interpolation=self.interp)
-        im_info['im_shape'] = np.array(im.shape[:2]).astype('float32')
-        im_info['scale_factor'] = np.array(
-            [im_scale_y, im_scale_x]).astype('float32')
-        return im, im_info
-
-    def generate_scale(self, im):
-        """
-        Args:
-            im (np.ndarray): image (np.ndarray)
-        Returns:
-            im_scale_x: the resize ratio of X
-            im_scale_y: the resize ratio of Y
-        """
-        origin_shape = im.shape[:2]
-        im_c = im.shape[2]
-        if self.keep_ratio:
-            im_size_min = np.min(origin_shape)
-            im_size_max = np.max(origin_shape)
-            target_size_min = np.min(self.target_size)
-            target_size_max = np.max(self.target_size)
-            im_scale = float(target_size_min) / float(im_size_min)
-            if np.round(im_scale * im_size_max) > target_size_max:
-                im_scale = float(target_size_max) / float(im_size_max)
-            im_scale_x = im_scale
-            im_scale_y = im_scale
-        else:
-            resize_h, resize_w = self.target_size
-            im_scale_y = resize_h / float(origin_shape[0])
-            im_scale_x = resize_w / float(origin_shape[1])
-        return im_scale_y, im_scale_x
-
-
-class DetNormalizeImage(object):
-    """normalize image
-    Args:
-        mean (list): im - mean
-        std (list): im / std
-        is_scale (bool): whether need im / 255
-        is_channel_first (bool): if True: image shape is CHW, else: HWC
-    """
-
-    def __init__(self, mean, std, is_scale=True):
-        self.mean = mean
-        self.std = std
-        self.is_scale = is_scale
-
-    def __call__(self, im, im_info):
-        """
-        Args:
-            im (np.ndarray): image (np.ndarray)
-            im_info (dict): info of image
-        Returns:
-            im (np.ndarray):  processed image (np.ndarray)
-            im_info (dict): info of processed image
-        """
-        im = im.astype(np.float32, copy=False)
-        mean = np.array(self.mean)[np.newaxis, np.newaxis, :]
-        std = np.array(self.std)[np.newaxis, np.newaxis, :]
-
-        if self.is_scale:
-            im = im / 255.0
-
-        im -= mean
-        im /= std
-        return im, im_info
-
-
-class DetPermute(object):
-    """permute image
-    Args:
-        to_bgr (bool): whether convert RGB to BGR 
-        channel_first (bool): whether convert HWC to CHW
-    """
-
-    def __init__(self, ):
-        super().__init__()
-
-    def __call__(self, im, im_info):
-        """
-        Args:
-            im (np.ndarray): image (np.ndarray)
-            im_info (dict): info of image
-        Returns:
-            im (np.ndarray):  processed image (np.ndarray)
-            im_info (dict): info of processed image
-        """
-        im = im.transpose((2, 0, 1)).copy()
-        return im, im_info
-
-
-class DetPadStride(object):
-    """ padding image for model with FPN , instead PadBatch(pad_to_stride, pad_gt) in original config
-    Args:
-        stride (bool): model with FPN need image shape % stride == 0 
-    """
-
-    def __init__(self, stride=0):
-        self.coarsest_stride = stride
-
-    def __call__(self, im, im_info):
-        """
-        Args:
-            im (np.ndarray): image (np.ndarray)
-            im_info (dict): info of image
-        Returns:
-            im (np.ndarray):  processed image (np.ndarray)
-            im_info (dict): info of processed image
-        """
-        coarsest_stride = self.coarsest_stride
-        if coarsest_stride <= 0:
-            return im, im_info
-        im_c, im_h, im_w = im.shape
-        pad_h = int(np.ceil(float(im_h) / coarsest_stride) * coarsest_stride)
-        pad_w = int(np.ceil(float(im_w) / coarsest_stride) * coarsest_stride)
-        padding_im = np.zeros((im_c, pad_h, pad_w), dtype=np.float32)
-        padding_im[:, :im_h, :im_w] = im
-        return padding_im, im_info
-
-
-def det_preprocess(im, im_info, preprocess_ops):
-    for operator in preprocess_ops:
-        im, im_info = operator(im, im_info)
-    return im, im_info

PaddleClas/deploy/python/postprocess.py

@@ -1,161 +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 shutil
-from functools import partial
-import importlib
-import numpy as np
-import paddle
-import paddle.nn.functional as F
-
-
-def build_postprocess(config):
-    if config is None:
-        return None
-
-    mod = importlib.import_module(__name__)
-    config = copy.deepcopy(config)
-
-    main_indicator = config.pop(
-        "main_indicator") if "main_indicator" in config else None
-    main_indicator = main_indicator if main_indicator else ""
-
-    func_list = []
-    for func in config:
-        func_list.append(getattr(mod, func)(**config[func]))
-    return PostProcesser(func_list, main_indicator)
-
-
-class PostProcesser(object):
-    def __init__(self, func_list, main_indicator="Topk"):
-        self.func_list = func_list
-        self.main_indicator = main_indicator
-
-    def __call__(self, x, image_file=None):
-        rtn = None
-        for func in self.func_list:
-            tmp = func(x, image_file)
-            if type(func).__name__ in self.main_indicator:
-                rtn = tmp
-        return rtn
-
-
-class Topk(object):
-    def __init__(self, topk=1, class_id_map_file=None):
-        assert isinstance(topk, (int, ))
-        self.class_id_map = self.parse_class_id_map(class_id_map_file)
-        self.topk = topk
-
-    def parse_class_id_map(self, class_id_map_file):
-        if class_id_map_file is None:
-            return None
-
-        if not os.path.exists(class_id_map_file):
-            print(
-                "Warning: If want to use your own label_dict, please input legal path!\nOtherwise label_names will be empty!"
-            )
-            return None
-
-        try:
-            class_id_map = {}
-            with open(class_id_map_file, "r") as fin:
-                lines = fin.readlines()
-                for line in lines:
-                    partition = line.split("\n")[0].partition(" ")
-                    class_id_map[int(partition[0])] = str(partition[-1])
-        except Exception as ex:
-            print(ex)
-            class_id_map = None
-        return class_id_map
-
-    def __call__(self, x, file_names=None, multilabel=False):
-        if file_names is not None:
-            assert x.shape[0] == len(file_names)
-        y = []
-        for idx, probs in enumerate(x):
-            index = probs.argsort(axis=0)[-self.topk:][::-1].astype(
-                "int32") if not multilabel else np.where(
-                    probs >= 0.5)[0].astype("int32")
-            clas_id_list = []
-            score_list = []
-            label_name_list = []
-            for i in index:
-                clas_id_list.append(i.item())
-                score_list.append(probs[i].item())
-                if self.class_id_map is not None:
-                    label_name_list.append(self.class_id_map[i.item()])
-            result = {
-                "class_ids": clas_id_list,
-                "scores": np.around(
-                    score_list, decimals=5).tolist(),
-            }
-            if file_names is not None:
-                result["file_name"] = file_names[idx]
-            if label_name_list is not None:
-                result["label_names"] = label_name_list
-            y.append(result)
-        return y
-
-
-class MultiLabelTopk(Topk):
-    def __init__(self, topk=1, class_id_map_file=None):
-        super().__init__()
-
-    def __call__(self, x, file_names=None):
-        return super().__call__(x, file_names, multilabel=True)
-
-
-class SavePreLabel(object):
-    def __init__(self, save_dir):
-        if save_dir is None:
-            raise Exception(
-                "Please specify save_dir if SavePreLabel specified.")
-        self.save_dir = partial(os.path.join, save_dir)
-
-    def __call__(self, x, file_names=None):
-        if file_names is None:
-            return
-        assert x.shape[0] == len(file_names)
-        for idx, probs in enumerate(x):
-            index = probs.argsort(axis=0)[-1].astype("int32")
-            self.save(index, file_names[idx])
-
-    def save(self, id, image_file):
-        output_dir = self.save_dir(str(id))
-        os.makedirs(output_dir, exist_ok=True)
-        shutil.copy(image_file, output_dir)
-
-
-class Binarize(object):
-    def __init__(self, method="round"):
-        self.method = method
-        self.unit = np.array([[128, 64, 32, 16, 8, 4, 2, 1]]).T
-
-    def __call__(self, x, file_names=None):
-        if self.method == "round":
-            x = np.round(x + 1).astype("uint8") - 1
-
-        if self.method == "sign":
-            x = ((np.sign(x) + 1) / 2).astype("uint8")
-
-        embedding_size = x.shape[1]
-        assert embedding_size % 8 == 0, "The Binary index only support vectors with sizes multiple of 8"
-
-        byte = np.zeros([x.shape[0], embedding_size // 8], dtype=np.uint8)
-        for i in range(embedding_size // 8):
-            byte[:, i:i + 1] = np.dot(x[:, i * 8:(i + 1) * 8], self.unit)
-
-        return byte

PaddleClas/deploy/python/predict_cls.py

@@ -1,142 +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 python.preprocess import create_operators
-from python.postprocess import build_postprocess
-
-
-class ClsPredictor(Predictor):
-    def __init__(self, config):
-        super().__init__(config["Global"])
-
-        self.preprocess_ops = []
-        self.postprocess = None
-        if "PreProcess" in config:
-            if "transform_ops" in config["PreProcess"]:
-                self.preprocess_ops = create_operators(config["PreProcess"][
-                    "transform_ops"])
-        if "PostProcess" in config:
-            self.postprocess = build_postprocess(config["PostProcess"])
-
-        # for whole_chain project to test each repo of paddle
-        self.benchmark = config["Global"].get("benchmark", False)
-        if self.benchmark:
-            import auto_log
-            import os
-            pid = os.getpid()
-            size = config["PreProcess"]["transform_ops"][1]["CropImage"][
-                "size"]
-            self.auto_logger = auto_log.AutoLogger(
-                model_name=config["Global"].get("model_name", "cls"),
-                model_precision='fp16'
-                if config["Global"]["use_fp16"] else 'fp32',
-                batch_size=config["Global"].get("batch_size", 1),
-                data_shape=[3, size, size],
-                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):
-        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 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):
-    cls_predictor = ClsPredictor(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 = cls_predictor.predict(batch_imgs)
-            for number, result_dict in enumerate(batch_results):
-                filename = batch_names[number]
-                clas_ids = result_dict["class_ids"]
-                scores_str = "[{}]".format(", ".join("{:.2f}".format(
-                    r) for r in result_dict["scores"]))
-                label_names = result_dict["label_names"]
-                print("{}:\tclass id(s): {}, score(s): {}, label_name(s): {}".
-                      format(filename, clas_ids, scores_str, label_names))
-            batch_imgs = []
-            batch_names = []
-    if cls_predictor.benchmark:
-        cls_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_det.py

@@ -1,158 +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__, '../')))
-
-from utils import logger
-from utils import config
-from utils.predictor import Predictor
-from utils.get_image_list import get_image_list
-from det_preprocess import det_preprocess
-from preprocess import create_operators
-
-import os
-import argparse
-import time
-import yaml
-import ast
-from functools import reduce
-import cv2
-import numpy as np
-import paddle
-
-
-class DetPredictor(Predictor):
-    def __init__(self, config):
-        super().__init__(config["Global"],
-                         config["Global"]["det_inference_model_dir"])
-
-        self.preprocess_ops = create_operators(config["DetPreProcess"][
-            "transform_ops"])
-        self.config = config
-
-    def preprocess(self, img):
-        im_info = {
-            'scale_factor': np.array(
-                [1., 1.], dtype=np.float32),
-            'im_shape': np.array(
-                img.shape[:2], dtype=np.float32),
-            'input_shape': self.config["Global"]["image_shape"],
-            "scale_factor": np.array(
-                [1., 1.], dtype=np.float32)
-        }
-        im, im_info = det_preprocess(img, im_info, self.preprocess_ops)
-        inputs = self.create_inputs(im, im_info)
-        return inputs
-
-    def create_inputs(self, im, im_info):
-        """generate input for different model type
-        Args:
-            im (np.ndarray): image (np.ndarray)
-            im_info (dict): info of image
-            model_arch (str): model type
-        Returns:
-            inputs (dict): input of model
-        """
-        inputs = {}
-        inputs['image'] = np.array((im, )).astype('float32')
-        inputs['im_shape'] = np.array(
-            (im_info['im_shape'], )).astype('float32')
-        inputs['scale_factor'] = np.array(
-            (im_info['scale_factor'], )).astype('float32')
-
-        return inputs
-
-    def parse_det_results(self, pred, threshold, label_list):
-        max_det_results = self.config["Global"]["max_det_results"]
-        keep_indexes = pred[:, 1].argsort()[::-1][:max_det_results]
-        results = []
-        for idx in keep_indexes:
-            single_res = pred[idx]
-            class_id = int(single_res[0])
-            score = single_res[1]
-            bbox = single_res[2:]
-            if score < threshold:
-                continue
-            label_name = label_list[class_id]
-            results.append({
-                "class_id": class_id,
-                "score": score,
-                "bbox": bbox,
-                "label_name": label_name,
-            })
-        return results
-
-    def predict(self, image, threshold=0.5, run_benchmark=False):
-        '''
-        Args:
-            image (str/np.ndarray): path of image/ np.ndarray read by cv2
-            threshold (float): threshold of predicted box' score
-        Returns:
-            results (dict): include 'boxes': np.ndarray: shape:[N,6], N: number of box,
-                            matix element:[class, score, x_min, y_min, x_max, y_max]
-                            MaskRCNN's results include 'masks': np.ndarray:
-                            shape: [N, im_h, im_w]
-        '''
-        inputs = self.preprocess(image)
-        np_boxes = None
-        input_names = self.paddle_predictor.get_input_names()
-
-        for i in range(len(input_names)):
-            input_tensor = self.paddle_predictor.get_input_handle(input_names[
-                i])
-            input_tensor.copy_from_cpu(inputs[input_names[i]])
-
-        t1 = time.time()
-        self.paddle_predictor.run()
-        output_names = self.paddle_predictor.get_output_names()
-        boxes_tensor = self.paddle_predictor.get_output_handle(output_names[0])
-        np_boxes = boxes_tensor.copy_to_cpu()
-        t2 = time.time()
-
-        print("Inference: {} ms per batch image".format((t2 - t1) * 1000.0))
-
-        # do not perform postprocess in benchmark mode
-        results = []
-        if reduce(lambda x, y: x * y, np_boxes.shape) < 6:
-            print('[WARNNING] No object detected.')
-            results = np.array([])
-        else:
-            results = np_boxes
-
-        results = self.parse_det_results(results,
-                                         self.config["Global"]["threshold"],
-                                         self.config["Global"]["labe_list"])
-        return results
-
-
-def main(config):
-    det_predictor = DetPredictor(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 = det_predictor.predict(img)
-        print(output)
-
-    return
-
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(args.config, overrides=args.override, show=True)
-    main(config)