paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/cv/models/slim/prune.py

@@ -1,55 +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 paddle
-import paddleslim
-
-FILTER_DIM = paddleslim.dygraph.prune.filter_pruner.FILTER_DIM
-
-
-def _pruner_eval_fn(model, eval_dataset, batch_size):
-    metric = model.evaluate(eval_dataset, batch_size=batch_size)
-    return metric[list(metric.keys())[0]]
-
-
-def _pruner_template_input(sample, model_type):
-    if model_type == 'detector':
-        template_input = [{
-            "image": paddle.ones(
-                shape=[1, 3] + list(sample["image"].shape[:2]),
-                dtype='float32'),
-            "im_shape": paddle.full(
-                [1, 2], 640, dtype='float32'),
-            "scale_factor": paddle.ones(
-                shape=[1, 2], dtype='float32')
-        }]
-    else:
-        template_input = [1] + list(sample[0].shape)
-
-    return template_input
-
-
-def sensitive_prune(pruner, pruned_flops, skip_vars=[], align=None):
-    # skip depthwise convolutions
-    for layer in pruner.model.sublayers():
-        if isinstance(layer,
-                      paddle.nn.layer.conv.Conv2D) and layer._groups > 1:
-            for param in layer.parameters(include_sublayers=False):
-                skip_vars.append(param.name)
-    pruner.restore()
-    ratios, pruned_flops = pruner.get_ratios_by_sensitivity(
-        pruned_flops, align=align, dims=FILTER_DIM, skip_vars=skip_vars)
-    pruner.plan = pruner.prune_vars(ratios, FILTER_DIM)
-    pruner.plan._pruned_flops = pruned_flops
-    return pruner.plan, ratios

paddlex/cv/models/utils/__init__.py

@@ -1,13 +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.

paddlex/cv/models/utils/det_metrics/__init__.py

@@ -1,15 +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.
-
-from .metrics import VOCMetric, COCOMetric

paddlex/cv/models/utils/det_metrics/coco_utils.py

@@ -1,217 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import sys
-import copy
-import numpy as np
-import itertools
-from paddlex.ppdet.metrics.map_utils import draw_pr_curve
-from paddlex.ppdet.metrics.json_results import get_det_res, get_det_poly_res, get_seg_res, get_solov2_segm_res
-import paddlex.utils.logging as logging
-
-
-def get_infer_results(outs, catid, bias=0):
-    """
-    Get result at the stage of inference.
-    The output format is dictionary containing bbox or mask result.
-
-    For example, bbox result is a list and each element contains
-    image_id, category_id, bbox and score.
-    """
-    if outs is None or len(outs) == 0:
-        raise ValueError(
-            'The number of valid detection result if zero. Please use reasonable model and check input data.'
-        )
-
-    im_id = outs['im_id']
-
-    infer_res = {}
-    if 'bbox' in outs:
-        if len(outs['bbox']) > 0 and len(outs['bbox'][0]) > 6:
-            infer_res['bbox'] = get_det_poly_res(
-                outs['bbox'], outs['bbox_num'], im_id, catid, bias=bias)
-        else:
-            infer_res['bbox'] = get_det_res(
-                outs['bbox'], outs['bbox_num'], im_id, catid, bias=bias)
-
-    if 'mask' in outs:
-        # mask post process
-        infer_res['mask'] = get_seg_res(outs['mask'], outs['bbox'],
-                                        outs['bbox_num'], im_id, catid)
-
-    if 'segm' in outs:
-        infer_res['segm'] = get_solov2_segm_res(outs, im_id, catid)
-
-    return infer_res
-
-
-def cocoapi_eval(anns,
-                 style,
-                 coco_gt=None,
-                 anno_file=None,
-                 max_dets=(100, 300, 1000),
-                 classwise=False):
-    """
-    Args:
-        anns: Evaluation result.
-        style (str): COCOeval style, can be `bbox` , `segm` and `proposal`.
-        coco_gt (str): Whether to load COCOAPI through anno_file,
-                 eg: coco_gt = COCO(anno_file)
-        anno_file (str): COCO annotations file.
-        max_dets (tuple): COCO evaluation maxDets.
-        classwise (bool): Whether per-category AP and draw P-R Curve or not.
-    """
-    assert coco_gt is not None or anno_file is not None
-    from pycocotools.coco import COCO
-    from pycocotools.cocoeval import COCOeval
-
-    if coco_gt is None:
-        coco_gt = COCO(anno_file)
-    logging.info("Start evaluate...")
-    coco_dt = loadRes(coco_gt, anns)
-    if style == 'proposal':
-        coco_eval = COCOeval(coco_gt, coco_dt, 'bbox')
-        coco_eval.params.useCats = 0
-        coco_eval.params.maxDets = list(max_dets)
-    else:
-        coco_eval = COCOeval(coco_gt, coco_dt, style)
-    coco_eval.evaluate()
-    coco_eval.accumulate()
-    coco_eval.summarize()
-    if classwise:
-        # Compute per-category AP and PR curve
-        try:
-            from terminaltables import AsciiTable
-        except Exception as e:
-            logging.error(
-                'terminaltables not found, plaese install terminaltables. '
-                'for example: `pip install terminaltables`.')
-            raise e
-        precisions = coco_eval.eval['precision']
-        cat_ids = coco_gt.getCatIds()
-        # precision: (iou, recall, cls, area range, max dets)
-        assert len(cat_ids) == precisions.shape[2]
-        results_per_category = []
-        for idx, catId in enumerate(cat_ids):
-            # area range index 0: all area ranges
-            # max dets index -1: typically 100 per image
-            nm = coco_gt.loadCats(catId)[0]
-            precision = precisions[:, :, idx, 0, -1]
-            precision = precision[precision > -1]
-            if precision.size:
-                ap = np.mean(precision)
-            else:
-                ap = float('nan')
-            results_per_category.append(
-                (str(nm["name"]), '{:0.3f}'.format(float(ap))))
-            pr_array = precisions[0, :, idx, 0, 2]
-            recall_array = np.arange(0.0, 1.01, 0.01)
-            draw_pr_curve(
-                pr_array,
-                recall_array,
-                out_dir=style + '_pr_curve',
-                file_name='{}_precision_recall_curve.jpg'.format(nm["name"]))
-
-        num_columns = min(6, len(results_per_category) * 2)
-        results_flatten = list(itertools.chain(*results_per_category))
-        headers = ['category', 'AP'] * (num_columns // 2)
-        results_2d = itertools.zip_longest(
-            * [results_flatten[i::num_columns] for i in range(num_columns)])
-        table_data = [headers]
-        table_data += [result for result in results_2d]
-        table = AsciiTable(table_data)
-        logging.info('Per-category of {} AP: \n{}'.format(style, table.table))
-        logging.info("per-category PR curve has output to {} folder.".format(
-            style + '_pr_curve'))
-    # flush coco evaluation result
-    sys.stdout.flush()
-    return coco_eval.stats
-
-
-def loadRes(coco_obj, anns):
-    """
-    Load result file and return a result api object.
-    :param   resFile (str)     : file name of result file
-    :return: res (obj)         : result api object
-    """
-
-    # This function has the same functionality as pycocotools.COCO.loadRes,
-    # except that the input anns is list of results rather than a json file.
-    # Refer to
-    # https://github.com/cocodataset/cocoapi/blob/8c9bcc3cf640524c4c20a9c40e89cb6a2f2fa0e9/PythonAPI/pycocotools/coco.py#L305,
-
-    # matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
-    # or matplotlib.backends is imported for the first time
-    # pycocotools import matplotlib
-    import matplotlib
-    matplotlib.use('Agg')
-    from pycocotools.coco import COCO
-    import pycocotools.mask as maskUtils
-    import time
-    res = COCO()
-    res.dataset['images'] = [img for img in coco_obj.dataset['images']]
-
-    tic = time.time()
-    assert type(anns) == list, 'results in not an array of objects'
-    annsImgIds = [ann['image_id'] for ann in anns]
-    assert set(annsImgIds) == (set(annsImgIds) & set(coco_obj.getImgIds())), \
-        'Results do not correspond to current coco set'
-    if 'caption' in anns[0]:
-        imgIds = set([img['id'] for img in res.dataset['images']]) & set(
-            [ann['image_id'] for ann in anns])
-        res.dataset['images'] = [
-            img for img in res.dataset['images'] if img['id'] in imgIds
-        ]
-        for id, ann in enumerate(anns):
-            ann['id'] = id + 1
-    elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:
-        res.dataset['categories'] = copy.deepcopy(coco_obj.dataset[
-            'categories'])
-        for id, ann in enumerate(anns):
-            bb = ann['bbox']
-            x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]
-            if not 'segmentation' in ann:
-                ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
-            ann['area'] = bb[2] * bb[3]
-            ann['id'] = id + 1
-            ann['iscrowd'] = 0
-    elif 'segmentation' in anns[0]:
-        res.dataset['categories'] = copy.deepcopy(coco_obj.dataset[
-            'categories'])
-        for id, ann in enumerate(anns):
-            # now only support compressed RLE format as segmentation results
-            ann['area'] = maskUtils.area(ann['segmentation'])
-            if not 'bbox' in ann:
-                ann['bbox'] = maskUtils.toBbox(ann['segmentation'])
-            ann['id'] = id + 1
-            ann['iscrowd'] = 0
-    elif 'keypoints' in anns[0]:
-        res.dataset['categories'] = copy.deepcopy(coco_obj.dataset[
-            'categories'])
-        for id, ann in enumerate(anns):
-            s = ann['keypoints']
-            x = s[0::3]
-            y = s[1::3]
-            x0, x1, y0, y1 = np.min(x), np.max(x), np.min(y), np.max(y)
-            ann['area'] = (x1 - x0) * (y1 - y0)
-            ann['id'] = id + 1
-            ann['bbox'] = [x0, y0, x1 - x0, y1 - y0]
-
-    res.dataset['annotations'] = anns
-    res.createIndex()
-    return res

paddlex/cv/models/utils/det_metrics/metrics.py

@@ -1,220 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import copy
-import sys
-from collections import OrderedDict
-import paddle
-import numpy as np
-from paddlex.ppdet.metrics.map_utils import prune_zero_padding, DetectionMAP
-from .coco_utils import get_infer_results, cocoapi_eval
-import paddlex.utils.logging as logging
-
-__all__ = ['Metric', 'VOCMetric', 'COCOMetric']
-
-
-class Metric(paddle.metric.Metric):
-    def name(self):
-        return self.__class__.__name__
-
-    def reset(self):
-        pass
-
-    def accumulate(self):
-        pass
-
-    # paddle.metric.Metric defined :metch:`update`, :meth:`accumulate`
-    # :metch:`reset`, in ppdet, we also need following 2 methods:
-
-    # abstract method for logging metric results
-    def log(self):
-        pass
-
-    # abstract method for getting metric results
-    def get_results(self):
-        pass
-
-
-class VOCMetric(Metric):
-    def __init__(self,
-                 labels,
-                 coco_gt,
-                 overlap_thresh=0.5,
-                 map_type='11point',
-                 is_bbox_normalized=False,
-                 evaluate_difficult=False,
-                 classwise=False):
-        self.cid2cname = {i: name for i, name in enumerate(labels)}
-        self.coco_gt = coco_gt
-        self.clsid2catid = {
-            i: cat['id']
-            for i, cat in enumerate(
-                self.coco_gt.loadCats(self.coco_gt.getCatIds()))
-        }
-        self.overlap_thresh = overlap_thresh
-        self.map_type = map_type
-        self.evaluate_difficult = evaluate_difficult
-        self.detection_map = DetectionMAP(
-            class_num=len(labels),
-            overlap_thresh=overlap_thresh,
-            map_type=map_type,
-            is_bbox_normalized=is_bbox_normalized,
-            evaluate_difficult=evaluate_difficult,
-            catid2name=self.cid2cname,
-            classwise=classwise)
-
-        self.reset()
-
-    def reset(self):
-        self.details = {'gt': copy.deepcopy(self.coco_gt.dataset), 'bbox': []}
-        self.detection_map.reset()
-
-    def update(self, inputs, outputs):
-        bbox_np = outputs['bbox'].numpy()
-        bboxes = bbox_np[:, 2:]
-        scores = bbox_np[:, 1]
-        labels = bbox_np[:, 0]
-        bbox_lengths = outputs['bbox_num'].numpy()
-
-        if bboxes.shape == (1, 1) or bboxes is None:
-            return
-        gt_boxes = inputs['gt_bbox']
-        gt_labels = inputs['gt_class']
-        difficults = inputs['difficult'] if not self.evaluate_difficult \
-            else None
-
-        scale_factor = inputs['scale_factor'].numpy(
-        ) if 'scale_factor' in inputs else np.ones(
-            (gt_boxes.shape[0], 2)).astype('float32')
-
-        bbox_idx = 0
-        for i in range(len(gt_boxes)):
-            gt_box = gt_boxes[i].numpy()
-            h, w = scale_factor[i]
-            gt_box = gt_box / np.array([w, h, w, h])
-            gt_label = gt_labels[i].numpy()
-            difficult = None if difficults is None \
-                else difficults[i].numpy()
-            bbox_num = bbox_lengths[i]
-            bbox = bboxes[bbox_idx:bbox_idx + bbox_num]
-            score = scores[bbox_idx:bbox_idx + bbox_num]
-            label = labels[bbox_idx:bbox_idx + bbox_num]
-            gt_box, gt_label, difficult = prune_zero_padding(gt_box, gt_label,
-                                                             difficult)
-            self.detection_map.update(bbox, score, label, gt_box, gt_label,
-                                      difficult)
-            bbox_idx += bbox_num
-
-            for l, s, b in zip(label, score, bbox):
-                xmin, ymin, xmax, ymax = b.tolist()
-                w = xmax - xmin
-                h = ymax - ymin
-                bbox = [xmin, ymin, w, h]
-                coco_res = {
-                    'image_id': int(inputs['im_id']),
-                    'category_id': self.clsid2catid[int(l)],
-                    'bbox': bbox,
-                    'score': float(s)
-                }
-                self.details['bbox'].append(coco_res)
-
-    def accumulate(self):
-        logging.info("Accumulating evaluatation results...")
-        self.detection_map.accumulate()
-
-    def log(self):
-        map_stat = 100. * self.detection_map.get_map()
-        logging.info("bbox_map = {:.2f}%".format(map_stat))
-
-    def get_results(self):
-        return {'bbox': [self.detection_map.get_map()]}
-
-    def get(self):
-        map_stat = 100. * self.detection_map.get_map()
-        stats = {"bbox_map": map_stat}
-        return stats
-
-
-class COCOMetric(Metric):
-    def __init__(self, coco_gt, **kwargs):
-        self.clsid2catid = {
-            i: cat['id']
-            for i, cat in enumerate(coco_gt.loadCats(coco_gt.getCatIds()))
-        }
-        self.coco_gt = coco_gt
-        self.classwise = kwargs.get('classwise', False)
-        self.bias = 0
-        self.reset()
-
-    def reset(self):
-        # only bbox and mask evaluation support currently
-        self.details = {
-            'gt': copy.deepcopy(self.coco_gt.dataset),
-            'bbox': [],
-            'mask': []
-        }
-        self.eval_stats = {}
-
-    def update(self, inputs, outputs):
-        outs = {}
-        # outputs Tensor -> numpy.ndarray
-        for k, v in outputs.items():
-            outs[k] = v.numpy() if isinstance(v, paddle.Tensor) else v
-
-        im_id = inputs['im_id']
-        outs['im_id'] = im_id.numpy() if isinstance(im_id,
-                                                    paddle.Tensor) else im_id
-
-        infer_results = get_infer_results(
-            outs, self.clsid2catid, bias=self.bias)
-        self.details['bbox'] += infer_results[
-            'bbox'] if 'bbox' in infer_results else []
-        self.details['mask'] += infer_results[
-            'mask'] if 'mask' in infer_results else []
-
-    def accumulate(self):
-        if len(self.details['bbox']) > 0:
-            bbox_stats = cocoapi_eval(
-                copy.deepcopy(self.details['bbox']),
-                'bbox',
-                coco_gt=self.coco_gt,
-                classwise=self.classwise)
-            self.eval_stats['bbox'] = bbox_stats
-            sys.stdout.flush()
-
-        if len(self.details['mask']) > 0:
-            seg_stats = cocoapi_eval(
-                copy.deepcopy(self.details['mask']),
-                'segm',
-                coco_gt=self.coco_gt,
-                classwise=self.classwise)
-            self.eval_stats['mask'] = seg_stats
-            sys.stdout.flush()
-
-    def log(self):
-        pass
-
-    def get(self):
-        if 'bbox' not in self.eval_stats:
-            return {'bbox_mmap': 0.}
-        if 'mask' in self.eval_stats:
-            return OrderedDict(
-                zip(['bbox_mmap', 'segm_mmap'],
-                    [self.eval_stats['bbox'][0], self.eval_stats['mask'][0]]))
-        else:
-            return {'bbox_mmap': self.eval_stats['bbox'][0]}

paddlex/cv/models/utils/ema.py

@@ -1,48 +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 paddle
-
-
-class ExponentialMovingAverage(object):
-    def __init__(self, decay, model, use_thres_step=False):
-        self.step = 0
-        self.decay = decay
-        self.shadow = dict()
-        for k, v in model.state_dict().items():
-            self.shadow[k] = paddle.zeros_like(v)
-        self.use_thres_step = use_thres_step
-
-    def update(self, model):
-        if self.use_thres_step:
-            decay = min(self.decay, (1 + self.step) / (10 + self.step))
-        else:
-            decay = self.decay
-        self._decay = decay
-        model_dict = model.state_dict()
-        for k, v in self.shadow.items():
-            v = decay * v + (1 - decay) * model_dict[k]
-            v.stop_gradient = True
-            self.shadow[k] = v
-        self.step += 1
-
-    def apply(self):
-        if self.step == 0:
-            return self.shadow
-        state_dict = dict()
-        for k, v in self.shadow.items():
-            v = v / (1 - self._decay**self.step)
-            v.stop_gradient = True
-            state_dict[k] = v
-        return state_dict

paddlex/cv/models/utils/seg_metrics.py

@@ -1,62 +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 numpy as np
-import paddle
-
-
-def loss_computation(logits_list, labels, losses):
-    loss_list = []
-    for i in range(len(logits_list)):
-        logits = logits_list[i]
-        loss_i = losses['types'][i]
-        loss_list.append(losses['coef'][i] * loss_i(logits, labels))
-
-    return loss_list
-
-
-def f1_score(intersect_area, pred_area, label_area):
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    label_area = label_area.numpy()
-    class_f1_sco = []
-    for i in range(len(intersect_area)):
-        if pred_area[i] + label_area[i] == 0:
-            f1_sco = 0
-        elif pred_area[i] == 0:
-            f1_sco = 0
-        else:
-            prec = intersect_area[i] / pred_area[i]
-            rec = intersect_area[i] / label_area[i]
-            f1_sco = 2 * prec * rec / (prec + rec)
-        class_f1_sco.append(f1_sco)
-    return np.array(class_f1_sco)
-
-
-def confusion_matrix(pred, label, num_classes, ignore_index=255):
-    label = paddle.transpose(label, (0, 2, 3, 1))
-    pred = paddle.transpose(pred, (0, 2, 3, 1))
-    mask = label != ignore_index
-
-    label = paddle.masked_select(label, mask)
-    pred = paddle.masked_select(pred, mask)
-
-    cat_matrix = num_classes * label + pred
-    conf_mat = paddle.histogram(
-        cat_matrix,
-        bins=num_classes * num_classes,
-        min=0,
-        max=num_classes * num_classes - 1).reshape([num_classes, num_classes])
-
-    return conf_mat