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

paddlex/ppdet/metrics/coco_utils.py

@@ -1,184 +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
-
-import os
-import sys
-import numpy as np
-import itertools
-
-from paddlex.ppdet.metrics.json_results import get_det_res, get_det_poly_res, get_seg_res, get_solov2_segm_res, get_keypoint_res
-from paddlex.ppdet.metrics.map_utils import draw_pr_curve
-
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-
-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)
-
-    if 'keypoint' in outs:
-        infer_res['keypoint'] = get_keypoint_res(outs, im_id)
-        outs['bbox_num'] = [len(infer_res['keypoint'])]
-
-    return infer_res
-
-
-def cocoapi_eval(jsonfile,
-                 style,
-                 coco_gt=None,
-                 anno_file=None,
-                 max_dets=(100, 300, 1000),
-                 classwise=False,
-                 sigmas=None,
-                 use_area=True):
-    """
-    Args:
-        jsonfile (str): Evaluation json file, eg: bbox.json, mask.json.
-        style (str): COCOeval style, can be `bbox` , `segm` , `proposal`, `keypoints` and `keypoints_crowd`.
-        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.
-        sigmas (nparray): keypoint labelling sigmas.
-        use_area (bool): If gt annotations (eg. CrowdPose, AIC)
-                         do not have 'area', please set use_area=False.
-    """
-    assert coco_gt != None or anno_file != None
-    if style == 'keypoints_crowd':
-        #please install xtcocotools==1.6
-        from xtcocotools.coco import COCO
-        from xtcocotools.cocoeval import COCOeval
-    else:
-        from pycocotools.coco import COCO
-        from pycocotools.cocoeval import COCOeval
-
-    if coco_gt == None:
-        coco_gt = COCO(anno_file)
-    logger.info("Start evaluate...")
-    coco_dt = coco_gt.loadRes(jsonfile)
-    if style == 'proposal':
-        coco_eval = COCOeval(coco_gt, coco_dt, 'bbox')
-        coco_eval.params.useCats = 0
-        coco_eval.params.maxDets = list(max_dets)
-    elif style == 'keypoints_crowd':
-        coco_eval = COCOeval(coco_gt, coco_dt, style, sigmas, use_area)
-    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:
-            logger.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)
-        logger.info('Per-category of {} AP: \n{}'.format(style, table.table))
-        logger.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 json_eval_results(metric, json_directory, dataset):
-    """
-    cocoapi eval with already exists proposal.json, bbox.json or mask.json
-    """
-    assert metric == 'COCO'
-    anno_file = dataset.get_anno()
-    json_file_list = ['proposal.json', 'bbox.json', 'mask.json']
-    if json_directory:
-        assert os.path.exists(
-            json_directory), "The json directory:{} does not exist".format(
-                json_directory)
-        for k, v in enumerate(json_file_list):
-            json_file_list[k] = os.path.join(str(json_directory), v)
-
-    coco_eval_style = ['proposal', 'bbox', 'segm']
-    for i, v_json in enumerate(json_file_list):
-        if os.path.exists(v_json):
-            cocoapi_eval(v_json, coco_eval_style[i], anno_file=anno_file)
-        else:
-            logger.info("{} not exists!".format(v_json))

paddlex/ppdet/metrics/json_results.py

@@ -1,151 +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 six
-import os
-import numpy as np
-import cv2
-
-
-def get_det_res(bboxes, bbox_nums, image_id, label_to_cat_id_map, bias=0):
-    det_res = []
-    k = 0
-    for i in range(len(bbox_nums)):
-        cur_image_id = int(image_id[i][0])
-        det_nums = bbox_nums[i]
-        for j in range(det_nums):
-            dt = bboxes[k]
-            k = k + 1
-            num_id, score, xmin, ymin, xmax, ymax = dt.tolist()
-            if int(num_id) < 0:
-                continue
-            category_id = label_to_cat_id_map[int(num_id)]
-            w = xmax - xmin + bias
-            h = ymax - ymin + bias
-            bbox = [xmin, ymin, w, h]
-            dt_res = {
-                'image_id': cur_image_id,
-                'category_id': category_id,
-                'bbox': bbox,
-                'score': score
-            }
-            det_res.append(dt_res)
-    return det_res
-
-
-def get_det_poly_res(bboxes, bbox_nums, image_id, label_to_cat_id_map, bias=0):
-    det_res = []
-    k = 0
-    for i in range(len(bbox_nums)):
-        cur_image_id = int(image_id[i][0])
-        det_nums = bbox_nums[i]
-        for j in range(det_nums):
-            dt = bboxes[k]
-            k = k + 1
-            num_id, score, x1, y1, x2, y2, x3, y3, x4, y4 = dt.tolist()
-            if int(num_id) < 0:
-                continue
-            category_id = label_to_cat_id_map[int(num_id)]
-            rbox = [x1, y1, x2, y2, x3, y3, x4, y4]
-            dt_res = {
-                'image_id': cur_image_id,
-                'category_id': category_id,
-                'bbox': rbox,
-                'score': score
-            }
-            det_res.append(dt_res)
-    return det_res
-
-
-def get_seg_res(masks, bboxes, mask_nums, image_id, label_to_cat_id_map):
-    import pycocotools.mask as mask_util
-    seg_res = []
-    k = 0
-    for i in range(len(mask_nums)):
-        cur_image_id = int(image_id[i][0])
-        det_nums = mask_nums[i]
-        for j in range(det_nums):
-            mask = masks[k].astype(np.uint8)
-            score = float(bboxes[k][1])
-            label = int(bboxes[k][0])
-            k = k + 1
-            if label == -1:
-                continue
-            cat_id = label_to_cat_id_map[label]
-            rle = mask_util.encode(
-                np.array(
-                    mask[:, :, None], order="F", dtype="uint8"))[0]
-            if six.PY3:
-                if 'counts' in rle:
-                    rle['counts'] = rle['counts'].decode("utf8")
-            sg_res = {
-                'image_id': cur_image_id,
-                'category_id': cat_id,
-                'segmentation': rle,
-                'score': score
-            }
-            seg_res.append(sg_res)
-    return seg_res
-
-
-def get_solov2_segm_res(results, image_id, num_id_to_cat_id_map):
-    import pycocotools.mask as mask_util
-    segm_res = []
-    # for each batch
-    segms = results['segm'].astype(np.uint8)
-    clsid_labels = results['cate_label']
-    clsid_scores = results['cate_score']
-    lengths = segms.shape[0]
-    im_id = int(image_id[0][0])
-    if lengths == 0 or segms is None:
-        return None
-    # for each sample
-    for i in range(lengths - 1):
-        clsid = int(clsid_labels[i])
-        catid = num_id_to_cat_id_map[clsid]
-        score = float(clsid_scores[i])
-        mask = segms[i]
-        segm = mask_util.encode(np.array(mask[:, :, np.newaxis], order='F'))[0]
-        segm['counts'] = segm['counts'].decode('utf8')
-        coco_res = {
-            'image_id': im_id,
-            'category_id': catid,
-            'segmentation': segm,
-            'score': score
-        }
-        segm_res.append(coco_res)
-    return segm_res
-
-
-def get_keypoint_res(results, im_id):
-    anns = []
-    preds = results['keypoint']
-    for idx in range(im_id.shape[0]):
-        image_id = im_id[idx].item()
-        kpts, scores = preds[idx]
-        for kpt, score in zip(kpts, scores):
-            kpt = kpt.flatten()
-            ann = {
-                'image_id': image_id,
-                'category_id': 1,  # XXX hard code
-                'keypoints': kpt.tolist(),
-                'score': float(score)
-            }
-            x = kpt[0::3]
-            y = kpt[1::3]
-            x0, x1, y0, y1 = np.min(x).item(), np.max(x).item(), np.min(
-                y).item(), np.max(y).item()
-            ann['area'] = (x1 - x0) * (y1 - y0)
-            ann['bbox'] = [x0, y0, x1 - x0, y1 - y0]
-            anns.append(ann)
-    return anns

paddlex/ppdet/metrics/keypoint_metrics.py

@@ -1,202 +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 copy
-import os
-import json
-from collections import OrderedDict
-from collections import defaultdict
-import numpy as np
-from pycocotools.coco import COCO
-from pycocotools.cocoeval import COCOeval
-from ..modeling.keypoint_utils import oks_nms
-
-__all__ = ['KeyPointTopDownCOCOEval']
-
-
-class KeyPointTopDownCOCOEval(object):
-    def __init__(self,
-                 anno_file,
-                 num_samples,
-                 num_joints,
-                 output_eval,
-                 iou_type='keypoints',
-                 in_vis_thre=0.2,
-                 oks_thre=0.9):
-        super(KeyPointTopDownCOCOEval, self).__init__()
-        self.coco = COCO(anno_file)
-        self.num_samples = num_samples
-        self.num_joints = num_joints
-        self.iou_type = iou_type
-        self.in_vis_thre = in_vis_thre
-        self.oks_thre = oks_thre
-        self.output_eval = output_eval
-        self.res_file = os.path.join(output_eval, "keypoints_results.json")
-        self.reset()
-
-    def reset(self):
-        self.results = {
-            'all_preds': np.zeros(
-                (self.num_samples, self.num_joints, 3), dtype=np.float32),
-            'all_boxes': np.zeros((self.num_samples, 6)),
-            'image_path': []
-        }
-        self.eval_results = {}
-        self.idx = 0
-
-    def update(self, inputs, outputs):
-        kpts, _ = outputs['keypoint'][0]
-
-        num_images = inputs['image'].shape[0]
-        self.results['all_preds'][self.idx:self.idx + num_images, :, 0:
-                                  3] = kpts[:, :, 0:3]
-        self.results['all_boxes'][self.idx:self.idx + num_images, 0:
-                                  2] = inputs['center'].numpy()[:, 0:2]
-        self.results['all_boxes'][self.idx:self.idx + num_images, 2:
-                                  4] = inputs['scale'].numpy()[:, 0:2]
-        self.results['all_boxes'][self.idx:self.idx + num_images, 4] = np.prod(
-            inputs['scale'].numpy() * 200, 1)
-        self.results['all_boxes'][self.idx:self.idx + num_images,
-                                  5] = np.squeeze(inputs['score'].numpy())
-        self.results['image_path'].extend(inputs['im_id'].numpy())
-
-        self.idx += num_images
-
-    def _write_coco_keypoint_results(self, keypoints):
-        data_pack = [{
-            'cat_id': 1,
-            'cls': 'person',
-            'ann_type': 'keypoints',
-            'keypoints': keypoints
-        }]
-        results = self._coco_keypoint_results_one_category_kernel(data_pack[0])
-        if not os.path.exists(self.output_eval):
-            os.makedirs(self.output_eval)
-        with open(self.res_file, 'w') as f:
-            json.dump(results, f, sort_keys=True, indent=4)
-        try:
-            json.load(open(self.res_file))
-        except Exception:
-            content = []
-            with open(self.res_file, 'r') as f:
-                for line in f:
-                    content.append(line)
-            content[-1] = ']'
-            with open(self.res_file, 'w') as f:
-                for c in content:
-                    f.write(c)
-
-    def _coco_keypoint_results_one_category_kernel(self, data_pack):
-        cat_id = data_pack['cat_id']
-        keypoints = data_pack['keypoints']
-        cat_results = []
-
-        for img_kpts in keypoints:
-            if len(img_kpts) == 0:
-                continue
-
-            _key_points = np.array(
-                [img_kpts[k]['keypoints'] for k in range(len(img_kpts))])
-            _key_points = _key_points.reshape(_key_points.shape[0], -1)
-
-            result = [{
-                'image_id': img_kpts[k]['image'],
-                'category_id': cat_id,
-                'keypoints': _key_points[k].tolist(),
-                'score': img_kpts[k]['score'],
-                'center': list(img_kpts[k]['center']),
-                'scale': list(img_kpts[k]['scale'])
-            } for k in range(len(img_kpts))]
-            cat_results.extend(result)
-
-        return cat_results
-
-    def get_final_results(self, preds, all_boxes, img_path):
-        _kpts = []
-        for idx, kpt in enumerate(preds):
-            _kpts.append({
-                'keypoints': kpt,
-                'center': all_boxes[idx][0:2],
-                'scale': all_boxes[idx][2:4],
-                'area': all_boxes[idx][4],
-                'score': all_boxes[idx][5],
-                'image': int(img_path[idx])
-            })
-        # image x person x (keypoints)
-        kpts = defaultdict(list)
-        for kpt in _kpts:
-            kpts[kpt['image']].append(kpt)
-
-        # rescoring and oks nms
-        num_joints = preds.shape[1]
-        in_vis_thre = self.in_vis_thre
-        oks_thre = self.oks_thre
-        oks_nmsed_kpts = []
-        for img in kpts.keys():
-            img_kpts = kpts[img]
-            for n_p in img_kpts:
-                box_score = n_p['score']
-                kpt_score = 0
-                valid_num = 0
-                for n_jt in range(0, num_joints):
-                    t_s = n_p['keypoints'][n_jt][2]
-                    if t_s > in_vis_thre:
-                        kpt_score = kpt_score + t_s
-                        valid_num = valid_num + 1
-                if valid_num != 0:
-                    kpt_score = kpt_score / valid_num
-                # rescoring
-                n_p['score'] = kpt_score * box_score
-
-            keep = oks_nms([img_kpts[i] for i in range(len(img_kpts))],
-                           oks_thre)
-
-            if len(keep) == 0:
-                oks_nmsed_kpts.append(img_kpts)
-            else:
-                oks_nmsed_kpts.append([img_kpts[_keep] for _keep in keep])
-
-        self._write_coco_keypoint_results(oks_nmsed_kpts)
-
-    def accumulate(self):
-        self.get_final_results(self.results['all_preds'],
-                               self.results['all_boxes'],
-                               self.results['image_path'])
-        coco_dt = self.coco.loadRes(self.res_file)
-        coco_eval = COCOeval(self.coco, coco_dt, 'keypoints')
-        coco_eval.params.useSegm = None
-        coco_eval.evaluate()
-        coco_eval.accumulate()
-        coco_eval.summarize()
-
-        keypoint_stats = []
-        for ind in range(len(coco_eval.stats)):
-            keypoint_stats.append((coco_eval.stats[ind]))
-        self.eval_results['keypoint'] = keypoint_stats
-
-    def log(self):
-        stats_names = [
-            'AP', 'Ap .5', 'AP .75', 'AP (M)', 'AP (L)', 'AR', 'AR .5',
-            'AR .75', 'AR (M)', 'AR (L)'
-        ]
-        num_values = len(stats_names)
-        print(' '.join(['| {}'.format(name) for name in stats_names]) + ' |')
-        print('|---' * (num_values + 1) + '|')
-
-        print(' '.join([
-            '| {:.3f}'.format(value) for value in self.eval_results['keypoint']
-        ]) + ' |')
-
-    def get_results(self):
-        return self.eval_results