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

paddlex/deploy.py

@@ -1,268 +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.path as osp
-import numpy as np
-from paddle.inference import Config
-from paddle.inference import create_predictor
-from paddle.inference import PrecisionType
-from paddlex.cv.models import load_model
-from paddlex.utils import logging, Timer
-
-
-class Predictor(object):
-    def __init__(self,
-                 model_dir,
-                 use_gpu=False,
-                 gpu_id=0,
-                 cpu_thread_num=1,
-                 use_mkl=True,
-                 mkl_thread_num=4,
-                 use_trt=False,
-                 use_glog=False,
-                 memory_optimize=True,
-                 max_trt_batch_size=1,
-                 trt_precision_mode='float32'):
-        """ 创建Paddle Predictor
-            Args:
-                model_dir: 模型路径（必须是导出的部署或量化模型）
-                use_gpu: 是否使用gpu，默认False
-                gpu_id: 使用gpu的id，默认0
-                cpu_thread_num：使用cpu进行预测时的线程数，默认为1
-                use_mkl: 是否使用mkldnn计算库，CPU情况下使用，默认False
-                mkl_thread_num: mkldnn计算线程数，默认为4
-                use_trt: 是否使用TensorRT，默认False
-                use_glog: 是否启用glog日志, 默认False
-                memory_optimize: 是否启动内存优化，默认True
-                max_trt_batch_size: 在使用TensorRT时配置的最大batch size，默认1
-                trt_precision_mode：在使用TensorRT时采用的精度，可选值['float32', 'float16']。默认'float32',
-        """
-        self.model_dir = model_dir
-        self._model = load_model(model_dir, with_net=False)
-
-        if trt_precision_mode.lower() == 'float32':
-            trt_precision_mode = PrecisionType.Float32
-        elif trt_precision_mode.lower() == 'float16':
-            trt_precision_mode = PrecisionType.Float16
-        else:
-            logging.error(
-                "TensorRT precision mode {} is invalid. Supported modes are float32 and float16."
-                .format(trt_precision_mode),
-                exit=True)
-
-        self.predictor = self.create_predictor(
-            use_gpu=use_gpu,
-            gpu_id=gpu_id,
-            cpu_thread_num=cpu_thread_num,
-            use_mkl=use_mkl,
-            mkl_thread_num=mkl_thread_num,
-            use_trt=use_trt,
-            use_glog=use_glog,
-            memory_optimize=memory_optimize,
-            max_trt_batch_size=max_trt_batch_size,
-            trt_precision_mode=trt_precision_mode)
-        self.timer = Timer()
-
-    def create_predictor(self,
-                         use_gpu=True,
-                         gpu_id=0,
-                         cpu_thread_num=1,
-                         use_mkl=True,
-                         mkl_thread_num=4,
-                         use_trt=False,
-                         use_glog=False,
-                         memory_optimize=True,
-                         max_trt_batch_size=1,
-                         trt_precision_mode=PrecisionType.Float32):
-        config = Config(
-            osp.join(self.model_dir, 'model.pdmodel'),
-            osp.join(self.model_dir, 'model.pdiparams'))
-
-        if use_gpu:
-            # 设置GPU初始显存(单位M)和Device ID
-            config.enable_use_gpu(200, gpu_id)
-            config.switch_ir_optim(True)
-            if use_trt:
-                if self._model.model_type == 'segmenter':
-                    logging.warning(
-                        "Semantic segmentation models do not support TensorRT acceleration, "
-                        "TensorRT is forcibly disabled.")
-                elif 'RCNN' in self._model.__class__.__name__:
-                    logging.warning(
-                        "RCNN models do not support TensorRT acceleration, "
-                        "TensorRT is forcibly disabled.")
-                else:
-                    config.enable_tensorrt_engine(
-                        workspace_size=1 << 10,
-                        max_batch_size=max_trt_batch_size,
-                        min_subgraph_size=3,
-                        precision_mode=trt_precision_mode,
-                        use_static=False,
-                        use_calib_mode=False)
-        else:
-            config.disable_gpu()
-            config.set_cpu_math_library_num_threads(cpu_thread_num)
-            if use_mkl:
-                if self._model.__class__.__name__ == 'MaskRCNN':
-                    logging.warning(
-                        "MaskRCNN does not support MKL-DNN, MKL-DNN is forcibly disabled"
-                    )
-                else:
-                    try:
-                        # 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(mkl_thread_num)
-                    except Exception as e:
-                        logging.warning(
-                            "The current environment does not support MKL-DNN, MKL-DNN is disabled."
-                        )
-                        pass
-
-        if not use_glog:
-            config.disable_glog_info()
-        if memory_optimize:
-            config.enable_memory_optim()
-        config.switch_use_feed_fetch_ops(False)
-        predictor = create_predictor(config)
-        return predictor
-
-    def preprocess(self, images, transforms):
-        preprocessed_samples = self._model._preprocess(
-            images, transforms, to_tensor=False)
-        if self._model.model_type == 'classifier':
-            preprocessed_samples = {'image': preprocessed_samples[0]}
-        elif self._model.model_type == 'segmenter':
-            preprocessed_samples = {
-                'image': preprocessed_samples[0],
-                'ori_shape': preprocessed_samples[1]
-            }
-        elif self._model.model_type == 'detector':
-            pass
-        else:
-            logging.error(
-                "Invalid model type {}".format(self._model.model_type),
-                exit=True)
-        return preprocessed_samples
-
-    def postprocess(self, net_outputs, topk=1, ori_shape=None,
-                    transforms=None):
-        if self._model.model_type == 'classifier':
-            true_topk = min(self._model.num_classes, topk)
-            preds = self._model._postprocess(net_outputs[0], true_topk)
-        elif self._model.model_type == 'segmenter':
-            label_map, score_map = self._model._postprocess(
-                net_outputs,
-                batch_origin_shape=ori_shape,
-                transforms=transforms.transforms)
-            preds = [{
-                'label_map': l,
-                'score_map': s
-            } for l, s in zip(label_map, score_map)]
-        elif self._model.model_type == 'detector':
-            net_outputs = {
-                k: v
-                for k, v in zip(['bbox', 'bbox_num', 'mask'], net_outputs)
-            }
-            preds = self._model._postprocess(net_outputs)
-        else:
-            logging.error(
-                "Invalid model type {}.".format(self._model.model_type),
-                exit=True)
-
-        return preds
-
-    def raw_predict(self, inputs):
-        """ 接受预处理过后的数据进行预测
-            Args:
-                inputs(dict): 预处理过后的数据
-        """
-        input_names = self.predictor.get_input_names()
-        for name in input_names:
-            input_tensor = self.predictor.get_input_handle(name)
-            input_tensor.copy_from_cpu(inputs[name])
-
-        self.predictor.run()
-        output_names = self.predictor.get_output_names()
-        net_outputs = list()
-        for name in output_names:
-            output_tensor = self.predictor.get_output_handle(name)
-            net_outputs.append(output_tensor.copy_to_cpu())
-
-        return net_outputs
-
-    def _run(self, images, topk=1, transforms=None):
-        self.timer.preprocess_time_s.start()
-        preprocessed_input = self.preprocess(images, transforms)
-        self.timer.preprocess_time_s.end(iter_num=len(images))
-
-        self.timer.inference_time_s.start()
-        net_outputs = self.raw_predict(preprocessed_input)
-        self.timer.inference_time_s.end(iter_num=1)
-
-        self.timer.postprocess_time_s.start()
-        results = self.postprocess(
-            net_outputs,
-            topk,
-            ori_shape=preprocessed_input.get('ori_shape', None),
-            transforms=transforms)
-        self.timer.postprocess_time_s.end(iter_num=len(images))
-
-        return results
-
-    def predict(self,
-                img_file,
-                topk=1,
-                transforms=None,
-                warmup_iters=0,
-                repeats=1):
-        """ 图片预测
-            Args:
-                img_file(List[np.ndarray or str], str or np.ndarray):
-                    图像路径；或者是解码后的排列格式为（H, W, C）且类型为float32且为BGR格式的数组。
-                topk(int): 分类预测时使用，表示预测前topk的结果。默认值为1。
-                transforms (paddlex.transforms): 数据预处理操作。默认值为None, 即使用`model.yml`中保存的数据预处理操作。
-                warmup_iters (int): 预热轮数，用于评估模型推理以及前后处理速度。若大于1，会预先重复预测warmup_iters，而后才开始正式的预测及其速度评估。默认为0。
-                repeats (int): 重复次数，用于评估模型推理以及前后处理速度。若大于1，会预测repeats次取时间平均值。默认值为1。
-        """
-        if repeats < 1:
-            logging.error("`repeats` must be greater than 1.", exit=True)
-        if transforms is None and not hasattr(self._model, 'test_transforms'):
-            raise Exception("Transforms need to be defined, now is None.")
-        if transforms is None:
-            transforms = self._model.test_transforms
-        if isinstance(img_file, (str, np.ndarray)):
-            images = [img_file]
-        else:
-            images = img_file
-
-        for _ in range(warmup_iters):
-            self._run(images=images, topk=topk, transforms=transforms)
-        self.timer.reset()
-
-        for _ in range(repeats):
-            results = self._run(
-                images=images, topk=topk, transforms=transforms)
-
-        self.timer.repeats = repeats
-        self.timer.img_num = len(images)
-        self.timer.info(average=True)
-
-        if isinstance(img_file, (str, np.ndarray)):
-            results = results[0]
-
-        return results
-
-    def batch_predict(self, image_list, **params):
-        return self.predict(img_file=image_list, **params)

paddlex/det.py

@@ -1,49 +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 sys
-from . import cv
-from .cv.models.utils.visualize import visualize_detection, draw_pr_curve
-from .cv.models.utils.det_metrics.coco_utils import coco_error_analysis
-
-
-message = 'Your script can be run normally only under PaddleX<2.0.0 ' + \
-    'but the installed PaddleX version is greater than or equal to 2.0.0, ' + \
-    'the solution is writen in the link {}, please refer to this link ro solve this issue.'.format(
-        'https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/train#%E7%89%88%E6%9C%AC%E5%8D%87%E7%BA%A7'
-    )
-
-
-def __getattr__(attr):
-    if attr == 'transforms':
-
-        print("\033[1;31;40m{}\033[0m".format(message).encode("utf-8")
-              .decode("latin1"))
-        sys.exit(-1)
-
-
-visualize = visualize_detection
-draw_pr_curve = draw_pr_curve
-coco_error_analysis = coco_error_analysis
-
-# detection
-YOLOv3 = cv.models.YOLOv3
-FasterRCNN = cv.models.FasterRCNN
-PPYOLO = cv.models.PPYOLO
-PPYOLOTiny = cv.models.PPYOLOTiny
-PPYOLOv2 = cv.models.PPYOLOv2
-PicoDet = cv.models.PicoDet
-
-# instance segmentation
-MaskRCNN = cv.models.MaskRCNN

paddlex/paddleseg/__init__.py

@@ -1,17 +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 . import models, datasets, transforms
-
-__version__ = '2.1.0'

paddlex/paddleseg/core/__init__.py

@@ -1,20 +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 .train import train
-from .val import evaluate
-from .predict import predict
-from . import infer
-
-__all__ = ['train', 'evaluate', 'predict']

paddlex/paddleseg/core/infer.py

@@ -1,289 +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 collections.abc
-from itertools import combinations
-
-import numpy as np
-import cv2
-import paddle
-import paddle.nn.functional as F
-
-
-def get_reverse_list(ori_shape, transforms):
-    """
-    get reverse list of transform.
-
-    Args:
-        ori_shape (list): Origin shape of image.
-        transforms (list): List of transform.
-
-    Returns:
-        list: List of tuple, there are two format:
-            ('resize', (h, w)) The image shape before resize,
-            ('padding', (h, w)) The image shape before padding.
-    """
-    reverse_list = []
-    h, w = ori_shape[0], ori_shape[1]
-    for op in transforms:
-        if op.__class__.__name__ in ['Resize']:
-            reverse_list.append(('resize', (h, w)))
-            h, w = op.target_size[0], op.target_size[1]
-        if op.__class__.__name__ in ['ResizeByLong']:
-            reverse_list.append(('resize', (h, w)))
-            long_edge = max(h, w)
-            short_edge = min(h, w)
-            short_edge = int(round(short_edge * op.long_size / long_edge))
-            long_edge = op.long_size
-            if h > w:
-                h = long_edge
-                w = short_edge
-            else:
-                w = long_edge
-                h = short_edge
-        if op.__class__.__name__ in ['Padding']:
-            reverse_list.append(('padding', (h, w)))
-            w, h = op.target_size[0], op.target_size[1]
-        if op.__class__.__name__ in ['PaddingByAspectRatio']:
-            reverse_list.append(('padding', (h, w)))
-            ratio = w / h
-            if ratio == op.aspect_ratio:
-                pass
-            elif ratio > op.aspect_ratio:
-                h = int(w / op.aspect_ratio)
-            else:
-                w = int(h * op.aspect_ratio)
-        if op.__class__.__name__ in ['LimitLong']:
-            long_edge = max(h, w)
-            short_edge = min(h, w)
-            if ((op.max_long is not None) and (long_edge > op.max_long)):
-                reverse_list.append(('resize', (h, w)))
-                long_edge = op.max_long
-                short_edge = int(round(short_edge * op.max_long / long_edge))
-            elif ((op.min_long is not None) and (long_edge < op.min_long)):
-                reverse_list.append(('resize', (h, w)))
-                long_edge = op.min_long
-                short_edge = int(round(short_edge * op.min_long / long_edge))
-            if h > w:
-                h = long_edge
-                w = short_edge
-            else:
-                w = long_edge
-                h = short_edge
-    return reverse_list
-
-
-def reverse_transform(pred, ori_shape, transforms, mode='nearest'):
-    """recover pred to origin shape"""
-    reverse_list = get_reverse_list(ori_shape, transforms)
-    for item in reverse_list[::-1]:
-        if item[0] == 'resize':
-            h, w = item[1][0], item[1][1]
-            if paddle.get_device() == 'cpu':
-                pred = paddle.cast(pred, 'uint8')
-                pred = F.interpolate(pred, (h, w), mode=mode)
-                pred = paddle.cast(pred, 'int32')
-            else:
-                pred = F.interpolate(pred, (h, w), mode=mode)
-        elif item[0] == 'padding':
-            h, w = item[1][0], item[1][1]
-            pred = pred[:, :, 0:h, 0:w]
-        else:
-            raise Exception("Unexpected info '{}' in im_info".format(item[0]))
-    return pred
-
-
-def flip_combination(flip_horizontal=False, flip_vertical=False):
-    """
-    Get flip combination.
-
-    Args:
-        flip_horizontal (bool): Whether to flip horizontally. Default: False.
-        flip_vertical (bool): Whether to flip vertically. Default: False.
-
-    Returns:
-        list: List of tuple. The first element of tuple is whether to flip horizontally,
-            and the second is whether to flip vertically.
-    """
-
-    flip_comb = [(False, False)]
-    if flip_horizontal:
-        flip_comb.append((True, False))
-    if flip_vertical:
-        flip_comb.append((False, True))
-        if flip_horizontal:
-            flip_comb.append((True, True))
-    return flip_comb
-
-
-def tensor_flip(x, flip):
-    """Flip tensor according directions"""
-    if flip[0]:
-        x = x[:, :, :, ::-1]
-    if flip[1]:
-        x = x[:, :, ::-1, :]
-    return x
-
-
-def slide_inference(model, im, crop_size, stride):
-    """
-    Infer by sliding window.
-
-    Args:
-        model (paddle.nn.Layer): model to get logits of image.
-        im (Tensor): the input image.
-        crop_size (tuple|list). The size of sliding window, (w, h).
-        stride (tuple|list). The size of stride, (w, h).
-
-    Return:
-        Tensor: The logit of input image.
-    """
-    h_im, w_im = im.shape[-2:]
-    w_crop, h_crop = crop_size
-    w_stride, h_stride = stride
-    # calculate the crop nums
-    rows = np.int(np.ceil(1.0 * (h_im - h_crop) / h_stride)) + 1
-    cols = np.int(np.ceil(1.0 * (w_im - w_crop) / w_stride)) + 1
-    # prevent negative sliding rounds when imgs after scaling << crop_size
-    rows = 1 if h_im <= h_crop else rows
-    cols = 1 if w_im <= w_crop else cols
-    # TODO 'Tensor' object does not support item assignment. If support, use tensor to calculation.
-    final_logit = None
-    count = np.zeros([1, 1, h_im, w_im])
-    for r in range(rows):
-        for c in range(cols):
-            h1 = r * h_stride
-            w1 = c * w_stride
-            h2 = min(h1 + h_crop, h_im)
-            w2 = min(w1 + w_crop, w_im)
-            h1 = max(h2 - h_crop, 0)
-            w1 = max(w2 - w_crop, 0)
-            im_crop = im[:, :, h1:h2, w1:w2]
-            logits = model(im_crop)
-            if not isinstance(logits, collections.abc.Sequence):
-                raise TypeError(
-                    "The type of logits must be one of collections.abc.Sequence, e.g. list, tuple. But received {}"
-                    .format(type(logits)))
-            logit = logits[0].numpy()
-            if final_logit is None:
-                final_logit = np.zeros([1, logit.shape[1], h_im, w_im])
-            final_logit[:, :, h1:h2, w1:w2] += logit[:, :, :h2 - h1, :w2 - w1]
-            count[:, :, h1:h2, w1:w2] += 1
-    if np.sum(count == 0) != 0:
-        raise RuntimeError(
-            'There are pixel not predicted. It is possible that stride is greater than crop_size'
-        )
-    final_logit = final_logit / count
-    final_logit = paddle.to_tensor(final_logit)
-    return final_logit
-
-
-def inference(model,
-              im,
-              ori_shape=None,
-              transforms=None,
-              is_slide=False,
-              stride=None,
-              crop_size=None):
-    """
-    Inference for image.
-
-    Args:
-        model (paddle.nn.Layer): model to get logits of image.
-        im (Tensor): the input image.
-        ori_shape (list): Origin shape of image.
-        transforms (list): Transforms for image.
-        is_slide (bool): Whether to infer by sliding window. Default: False.
-        crop_size (tuple|list). The size of sliding window, (w, h). It should be probided if is_slide is True.
-        stride (tuple|list). The size of stride, (w, h). It should be probided if is_slide is True.
-
-    Returns:
-        Tensor: If ori_shape is not None, a prediction with shape (1, 1, h, w) is returned.
-            If ori_shape is None, a logit with shape (1, num_classes, h, w) is returned.
-    """
-    if not is_slide:
-        logits = model(im)
-        if not isinstance(logits, collections.abc.Sequence):
-            raise TypeError(
-                "The type of logits must be one of collections.abc.Sequence, e.g. list, tuple. But received {}"
-                .format(type(logits)))
-        logit = logits[0]
-    else:
-        logit = slide_inference(model, im, crop_size=crop_size, stride=stride)
-    if ori_shape is not None:
-        pred = paddle.argmax(logit, axis=1, keepdim=True, dtype='int32')
-        pred = reverse_transform(pred, ori_shape, transforms)
-        return pred
-    else:
-        return logit
-
-
-def aug_inference(model,
-                  im,
-                  ori_shape,
-                  transforms,
-                  scales=1.0,
-                  flip_horizontal=False,
-                  flip_vertical=False,
-                  is_slide=False,
-                  stride=None,
-                  crop_size=None):
-    """
-    Infer with augmentation.
-
-    Args:
-        model (paddle.nn.Layer): model to get logits of image.
-        im (Tensor): the input image.
-        ori_shape (list): Origin shape of image.
-        transforms (list): Transforms for image.
-        scales (float|tuple|list):  Scales for resize. Default: 1.
-        flip_horizontal (bool): Whether to flip horizontally. Default: False.
-        flip_vertical (bool): Whether to flip vertically. Default: False.
-        is_slide (bool): Whether to infer by sliding wimdow. Default: False.
-        crop_size (tuple|list). The size of sliding window, (w, h). It should be probided if is_slide is True.
-        stride (tuple|list). The size of stride, (w, h). It should be probided if is_slide is True.
-
-    Returns:
-        Tensor: Prediction of image with shape (1, 1, h, w) is returned.
-    """
-    if isinstance(scales, float):
-        scales = [scales]
-    elif not isinstance(scales, (tuple, list)):
-        raise TypeError(
-            '`scales` expects float/tuple/list type, but received {}'.format(
-                type(scales)))
-    final_logit = 0
-    h_input, w_input = im.shape[-2], im.shape[-1]
-    flip_comb = flip_combination(flip_horizontal, flip_vertical)
-    for scale in scales:
-        h = int(h_input * scale + 0.5)
-        w = int(w_input * scale + 0.5)
-        im = F.interpolate(im, (h, w), mode='bilinear')
-        for flip in flip_comb:
-            im_flip = tensor_flip(im, flip)
-            logit = inference(
-                model,
-                im_flip,
-                is_slide=is_slide,
-                crop_size=crop_size,
-                stride=stride)
-            logit = tensor_flip(logit, flip)
-            logit = F.interpolate(logit, (h_input, w_input), mode='bilinear')
-
-            logit = F.softmax(logit, axis=1)
-            final_logit = final_logit + logit
-
-    pred = paddle.argmax(final_logit, axis=1, keepdim=True, dtype='int32')
-    pred = reverse_transform(pred, ori_shape, transforms)
-    return pred