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

paddlex/ppdet/modeling/architectures/keypoint_hrnet.py

@@ -1,267 +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 paddle
-import numpy as np
-import math
-import cv2
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-from ..keypoint_utils import transform_preds
-from .. import layers as L
-
-__all__ = ['TopDownHRNet']
-
-
-@register
-class TopDownHRNet(BaseArch):
-    __category__ = 'architecture'
-    __inject__ = ['loss']
-
-    def __init__(self,
-                 width,
-                 num_joints,
-                 backbone='HRNet',
-                 loss='KeyPointMSELoss',
-                 post_process='HRNetPostProcess',
-                 flip_perm=None,
-                 flip=True,
-                 shift_heatmap=True,
-                 use_dark=True):
-        """
-        HRNet network, see https://arxiv.org/abs/1902.09212
-
-        Args:
-            backbone (nn.Layer): backbone instance
-            post_process (object): `HRNetPostProcess` instance
-            flip_perm (list): The left-right joints exchange order list
-            use_dark(bool): Whether to use DARK in post processing
-        """
-        super(TopDownHRNet, self).__init__()
-        self.backbone = backbone
-        self.post_process = HRNetPostProcess(use_dark)
-        self.loss = loss
-        self.flip_perm = flip_perm
-        self.flip = flip
-        self.final_conv = L.Conv2d(width, num_joints, 1, 1, 0, bias=True)
-        self.shift_heatmap = shift_heatmap
-        self.deploy = False
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        # backbone
-        backbone = create(cfg['backbone'])
-
-        return {'backbone': backbone, }
-
-    def _forward(self):
-        feats = self.backbone(self.inputs)
-        hrnet_outputs = self.final_conv(feats[0])
-
-        if self.training:
-            return self.loss(hrnet_outputs, self.inputs)
-        elif self.deploy:
-            outshape = hrnet_outputs.shape
-            max_idx = paddle.argmax(
-                hrnet_outputs.reshape(
-                    (outshape[0], outshape[1], outshape[2] * outshape[3])),
-                axis=-1)
-            return hrnet_outputs, max_idx
-        else:
-            if self.flip:
-                self.inputs['image'] = self.inputs['image'].flip([3])
-                feats = self.backbone(self.inputs)
-                output_flipped = self.final_conv(feats[0])
-                output_flipped = self.flip_back(output_flipped.numpy(),
-                                                self.flip_perm)
-                output_flipped = paddle.to_tensor(output_flipped.copy())
-                if self.shift_heatmap:
-                    output_flipped[:, :, :, 1:] = output_flipped.clone(
-                    )[:, :, :, 0:-1]
-                hrnet_outputs = (hrnet_outputs + output_flipped) * 0.5
-            imshape = (self.inputs['im_shape'].numpy()
-                       )[:, ::-1] if 'im_shape' in self.inputs else None
-            center = self.inputs['center'].numpy(
-            ) if 'center' in self.inputs else np.round(imshape / 2.)
-            scale = self.inputs['scale'].numpy(
-            ) if 'scale' in self.inputs else imshape / 200.
-            outputs = self.post_process(hrnet_outputs, center, scale)
-            return outputs
-
-    def get_loss(self):
-        return self._forward()
-
-    def get_pred(self):
-        res_lst = self._forward()
-        outputs = {'keypoint': res_lst}
-        return outputs
-
-    def flip_back(self, output_flipped, matched_parts):
-        assert output_flipped.ndim == 4,\
-                'output_flipped should be [batch_size, num_joints, height, width]'
-
-        output_flipped = output_flipped[:, :, :, ::-1]
-
-        for pair in matched_parts:
-            tmp = output_flipped[:, pair[0], :, :].copy()
-            output_flipped[:, pair[0], :, :] = output_flipped[:, pair[1], :, :]
-            output_flipped[:, pair[1], :, :] = tmp
-
-        return output_flipped
-
-
-class HRNetPostProcess(object):
-    def __init__(self, use_dark=True):
-        self.use_dark = use_dark
-
-    def get_max_preds(self, heatmaps):
-        '''get predictions from score maps
-
-        Args:
-            heatmaps: numpy.ndarray([batch_size, num_joints, height, width])
-
-        Returns:
-            preds: numpy.ndarray([batch_size, num_joints, 2]), keypoints coords
-            maxvals: numpy.ndarray([batch_size, num_joints, 2]), the maximum confidence of the keypoints
-        '''
-        assert isinstance(heatmaps,
-                          np.ndarray), 'heatmaps should be numpy.ndarray'
-        assert heatmaps.ndim == 4, 'batch_images should be 4-ndim'
-
-        batch_size = heatmaps.shape[0]
-        num_joints = heatmaps.shape[1]
-        width = heatmaps.shape[3]
-        heatmaps_reshaped = heatmaps.reshape((batch_size, num_joints, -1))
-        idx = np.argmax(heatmaps_reshaped, 2)
-        maxvals = np.amax(heatmaps_reshaped, 2)
-
-        maxvals = maxvals.reshape((batch_size, num_joints, 1))
-        idx = idx.reshape((batch_size, num_joints, 1))
-
-        preds = np.tile(idx, (1, 1, 2)).astype(np.float32)
-
-        preds[:, :, 0] = (preds[:, :, 0]) % width
-        preds[:, :, 1] = np.floor((preds[:, :, 1]) / width)
-
-        pred_mask = np.tile(np.greater(maxvals, 0.0), (1, 1, 2))
-        pred_mask = pred_mask.astype(np.float32)
-
-        preds *= pred_mask
-
-        return preds, maxvals
-
-    def gaussian_blur(self, heatmap, kernel):
-        border = (kernel - 1) // 2
-        batch_size = heatmap.shape[0]
-        num_joints = heatmap.shape[1]
-        height = heatmap.shape[2]
-        width = heatmap.shape[3]
-        for i in range(batch_size):
-            for j in range(num_joints):
-                origin_max = np.max(heatmap[i, j])
-                dr = np.zeros((height + 2 * border, width + 2 * border))
-                dr[border:-border, border:-border] = heatmap[i, j].copy()
-                dr = cv2.GaussianBlur(dr, (kernel, kernel), 0)
-                heatmap[i, j] = dr[border:-border, border:-border].copy()
-                heatmap[i, j] *= origin_max / np.max(heatmap[i, j])
-        return heatmap
-
-    def dark_parse(self, hm, coord):
-        heatmap_height = hm.shape[0]
-        heatmap_width = hm.shape[1]
-        px = int(coord[0])
-        py = int(coord[1])
-        if 1 < px < heatmap_width - 2 and 1 < py < heatmap_height - 2:
-            dx = 0.5 * (hm[py][px + 1] - hm[py][px - 1])
-            dy = 0.5 * (hm[py + 1][px] - hm[py - 1][px])
-            dxx = 0.25 * (hm[py][px + 2] - 2 * hm[py][px] + hm[py][px - 2])
-            dxy = 0.25 * (hm[py+1][px+1] - hm[py-1][px+1] - hm[py+1][px-1] \
-                + hm[py-1][px-1])
-            dyy = 0.25 * (
-                hm[py + 2 * 1][px] - 2 * hm[py][px] + hm[py - 2 * 1][px])
-            derivative = np.matrix([[dx], [dy]])
-            hessian = np.matrix([[dxx, dxy], [dxy, dyy]])
-            if dxx * dyy - dxy**2 != 0:
-                hessianinv = hessian.I
-                offset = -hessianinv * derivative
-                offset = np.squeeze(np.array(offset.T), axis=0)
-                coord += offset
-        return coord
-
-    def dark_postprocess(self, hm, coords, kernelsize):
-        '''DARK postpocessing, Zhang et al. Distribution-Aware Coordinate
-        Representation for Human Pose Estimation (CVPR 2020).
-        '''
-
-        hm = self.gaussian_blur(hm, kernelsize)
-        hm = np.maximum(hm, 1e-10)
-        hm = np.log(hm)
-        for n in range(coords.shape[0]):
-            for p in range(coords.shape[1]):
-                coords[n, p] = self.dark_parse(hm[n][p], coords[n][p])
-        return coords
-
-    def get_final_preds(self, heatmaps, center, scale, kernelsize=3):
-        """the highest heatvalue location with a quarter offset in the
-        direction from the highest response to the second highest response.
-
-        Args:
-            heatmaps (numpy.ndarray): The predicted heatmaps
-            center (numpy.ndarray): The boxes center
-            scale (numpy.ndarray): The scale factor
-
-        Returns:
-            preds: numpy.ndarray([batch_size, num_joints, 2]), keypoints coords
-            maxvals: numpy.ndarray([batch_size, num_joints, 1]), the maximum confidence of the keypoints
-        """
-        coords, maxvals = self.get_max_preds(heatmaps)
-
-        heatmap_height = heatmaps.shape[2]
-        heatmap_width = heatmaps.shape[3]
-
-        if self.use_dark:
-            coords = self.dark_postprocess(heatmaps, coords, kernelsize)
-        else:
-            for n in range(coords.shape[0]):
-                for p in range(coords.shape[1]):
-                    hm = heatmaps[n][p]
-                    px = int(math.floor(coords[n][p][0] + 0.5))
-                    py = int(math.floor(coords[n][p][1] + 0.5))
-                    if 1 < px < heatmap_width - 1 and 1 < py < heatmap_height - 1:
-                        diff = np.array([
-                            hm[py][px + 1] - hm[py][px - 1],
-                            hm[py + 1][px] - hm[py - 1][px]
-                        ])
-                        coords[n][p] += np.sign(diff) * .25
-        preds = coords.copy()
-
-        # Transform back
-        for i in range(coords.shape[0]):
-            preds[i] = transform_preds(coords[i], center[i], scale[i],
-                                       [heatmap_width, heatmap_height])
-
-        return preds, maxvals
-
-    def __call__(self, output, center, scale):
-        preds, maxvals = self.get_final_preds(output.numpy(), center, scale)
-        outputs = [[
-            np.concatenate(
-                (preds, maxvals), axis=-1), np.mean(
-                    maxvals, axis=1)
-        ]]
-        return outputs

paddlex/ppdet/modeling/architectures/mask_rcnn.py

@@ -1,135 +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 paddle
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['MaskRCNN']
-
-
-@register
-class MaskRCNN(BaseArch):
-    """
-    Mask R-CNN network, see https://arxiv.org/abs/1703.06870
-
-    Args:
-        backbone (object): backbone instance
-        rpn_head (object): `RPNHead` instance
-        bbox_head (object): `BBoxHead` instance
-        mask_head (object): `MaskHead` instance
-        bbox_post_process (object): `BBoxPostProcess` instance
-        mask_post_process (object): `MaskPostProcess` instance
-        neck (object): 'FPN' instance
-    """
-
-    __category__ = 'architecture'
-    __inject__ = [
-        'bbox_post_process',
-        'mask_post_process',
-    ]
-
-    def __init__(self,
-                 backbone,
-                 rpn_head,
-                 bbox_head,
-                 mask_head,
-                 bbox_post_process,
-                 mask_post_process,
-                 neck=None):
-        super(MaskRCNN, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.rpn_head = rpn_head
-        self.bbox_head = bbox_head
-        self.mask_head = mask_head
-
-        self.bbox_post_process = bbox_post_process
-        self.mask_post_process = mask_post_process
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = cfg['neck'] and create(cfg['neck'], **kwargs)
-
-        out_shape = neck and neck.out_shape or backbone.out_shape
-        kwargs = {'input_shape': out_shape}
-        rpn_head = create(cfg['rpn_head'], **kwargs)
-        bbox_head = create(cfg['bbox_head'], **kwargs)
-
-        out_shape = neck and out_shape or bbox_head.get_head().out_shape
-        kwargs = {'input_shape': out_shape}
-        mask_head = create(cfg['mask_head'], **kwargs)
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "rpn_head": rpn_head,
-            "bbox_head": bbox_head,
-            "mask_head": mask_head,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        if self.neck is not None:
-            body_feats = self.neck(body_feats)
-
-        if self.training:
-            rois, rois_num, rpn_loss = self.rpn_head(body_feats, self.inputs)
-            bbox_loss, bbox_feat = self.bbox_head(body_feats, rois, rois_num,
-                                                  self.inputs)
-            rois, rois_num = self.bbox_head.get_assigned_rois()
-            bbox_targets = self.bbox_head.get_assigned_targets()
-            # Mask Head needs bbox_feat in Mask RCNN
-            mask_loss = self.mask_head(body_feats, rois, rois_num, self.inputs,
-                                       bbox_targets, bbox_feat)
-            return rpn_loss, bbox_loss, mask_loss
-        else:
-            rois, rois_num, _ = self.rpn_head(body_feats, self.inputs)
-            preds, feat_func = self.bbox_head(body_feats, rois, rois_num, None)
-
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-
-            bbox, bbox_num = self.bbox_post_process(preds, (rois, rois_num),
-                                                    im_shape, scale_factor)
-            mask_out = self.mask_head(
-                body_feats, bbox, bbox_num, self.inputs, feat_func=feat_func)
-
-            # rescale the prediction back to origin image
-            bbox_pred = self.bbox_post_process.get_pred(bbox, bbox_num,
-                                                        im_shape, scale_factor)
-            origin_shape = self.bbox_post_process.get_origin_shape()
-            mask_pred = self.mask_post_process(mask_out[:, 0, :, :], bbox_pred,
-                                               bbox_num, origin_shape)
-            return bbox_pred, bbox_num, mask_pred
-
-    def get_loss(self, ):
-        bbox_loss, mask_loss, rpn_loss = self._forward()
-        loss = {}
-        loss.update(rpn_loss)
-        loss.update(bbox_loss)
-        loss.update(mask_loss)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        bbox_pred, bbox_num, mask_pred = self._forward()
-        output = {'bbox': bbox_pred, 'bbox_num': bbox_num, 'mask': mask_pred}
-        return output

paddlex/ppdet/modeling/architectures/meta_arch.py

@@ -1,128 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import paddle
-import paddle.nn as nn
-import typing
-
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling.post_process import nms
-
-__all__ = ['BaseArch']
-
-
-@register
-class BaseArch(nn.Layer):
-    def __init__(self, data_format='NCHW'):
-        super(BaseArch, self).__init__()
-        self.data_format = data_format
-        self.inputs = {}
-        self.fuse_norm = False
-
-    def load_meanstd(self, cfg_transform):
-        self.scale = 1.
-        self.mean = paddle.to_tensor([0.485, 0.456, 0.406]).reshape(
-            (1, 3, 1, 1))
-        self.std = paddle.to_tensor([0.229, 0.224, 0.225]).reshape(
-            (1, 3, 1, 1))
-        for item in cfg_transform:
-            if 'NormalizeImage' in item:
-                self.mean = paddle.to_tensor(item['NormalizeImage'][
-                    'mean']).reshape((1, 3, 1, 1))
-                self.std = paddle.to_tensor(item['NormalizeImage'][
-                    'std']).reshape((1, 3, 1, 1))
-                if item['NormalizeImage'].get('is_scale', True):
-                    self.scale = 1. / 255.
-                break
-        if self.data_format == 'NHWC':
-            self.mean = self.mean.reshape(1, 1, 1, 3)
-            self.std = self.std.reshape(1, 1, 1, 3)
-
-    def forward(self, inputs):
-        if self.data_format == 'NHWC':
-            image = inputs['image']
-            inputs['image'] = paddle.transpose(image, [0, 2, 3, 1])
-
-        if self.fuse_norm:
-            image = inputs['image']
-            self.inputs['image'] = (image * self.scale - self.mean) / self.std
-            self.inputs['im_shape'] = inputs['im_shape']
-            self.inputs['scale_factor'] = inputs['scale_factor']
-        else:
-            self.inputs = inputs
-
-        self.model_arch()
-
-        if self.training:
-            out = self.get_loss()
-        else:
-            inputs_list = []
-            # multi-scale input
-            if not isinstance(inputs, typing.Sequence):
-                inputs_list.append(inputs)
-            else:
-                inputs_list.extend(inputs)
-
-            outs = []
-            for inp in inputs_list:
-                self.inputs = inp
-                outs.append(self.get_pred())
-
-            # multi-scale test
-            if len(outs) > 1:
-                out = self.merge_multi_scale_predictions(outs)
-            else:
-                out = outs[0]
-        return out
-
-    def merge_multi_scale_predictions(self, outs):
-        # default values for architectures not included in following list
-        num_classes = 80
-        nms_threshold = 0.5
-        keep_top_k = 100
-
-        if self.__class__.__name__ in ('CascadeRCNN', 'FasterRCNN', 'MaskRCNN'
-                                       ):
-            num_classes = self.bbox_head.num_classes
-            keep_top_k = self.bbox_post_process.nms.keep_top_k
-            nms_threshold = self.bbox_post_process.nms.nms_threshold
-        else:
-            raise Exception(
-                "Multi scale test only supports CascadeRCNN, FasterRCNN and MaskRCNN for now"
-            )
-
-        final_boxes = []
-        all_scale_outs = paddle.concat([o['bbox'] for o in outs]).numpy()
-        for c in range(num_classes):
-            idxs = all_scale_outs[:, 0] == c
-            if np.count_nonzero(idxs) == 0:
-                continue
-            r = nms(all_scale_outs[idxs, 1:], nms_threshold)
-            final_boxes.append(
-                np.concatenate([np.full((r.shape[0], 1), c), r], 1))
-        out = np.concatenate(final_boxes)
-        out = np.concatenate(sorted(
-            out, key=lambda e: e[1])[-keep_top_k:]).reshape((-1, 6))
-        out = {
-            'bbox': paddle.to_tensor(out),
-            'bbox_num': paddle.to_tensor(np.array([out.shape[0], ]))
-        }
-
-        return out
-
-    def build_inputs(self, data, input_def):
-        inputs = {}
-        for i, k in enumerate(input_def):
-            inputs[k] = data[i]
-        return inputs
-
-    def model_arch(self, ):
-        pass
-
-    def get_loss(self, ):
-        raise NotImplementedError("Should implement get_loss method!")
-
-    def get_pred(self, ):
-        raise NotImplementedError("Should implement get_pred method!")

paddlex/ppdet/modeling/architectures/picodet.py

@@ -1,91 +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 paddle
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['PicoDet']
-
-
-@register
-class PicoDet(BaseArch):
-    """
-    Generalized Focal Loss network, see https://arxiv.org/abs/2006.04388
-
-    Args:
-        backbone (object): backbone instance
-        neck (object): 'FPN' instance
-        head (object): 'PicoHead' instance
-    """
-
-    __category__ = 'architecture'
-
-    def __init__(self, backbone, neck, head='PicoHead'):
-        super(PicoDet, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.head = head
-        self.deploy = False
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = create(cfg['neck'], **kwargs)
-
-        kwargs = {'input_shape': neck.out_shape}
-        head = create(cfg['head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "head": head,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        fpn_feats = self.neck(body_feats)
-        head_outs = self.head(fpn_feats, self.deploy)
-        if self.training or self.deploy:
-            return head_outs, None
-        else:
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-            bboxes, bbox_num = self.head.post_process(head_outs, im_shape,
-                                                      scale_factor)
-            return bboxes, bbox_num
-
-    def get_loss(self, ):
-        loss = {}
-
-        head_outs, _ = self._forward()
-        loss_gfl = self.head.get_loss(head_outs, self.inputs)
-        loss.update(loss_gfl)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        if self.deploy:
-            return {'picodet': self._forward()[0]}
-        else:
-            bbox_pred, bbox_num = self._forward()
-            output = {'bbox': bbox_pred, 'bbox_num': bbox_num}
-            return output