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

paddlex/ppdet/modeling/architectures/__init__.py

@@ -1,40 +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
-from . import meta_arch
-from . import faster_rcnn
-from . import mask_rcnn
-from . import yolo
-from . import cascade_rcnn
-from . import ssd
-from . import fcos
-from . import solov2
-from . import ttfnet
-from . import s2anet
-from . import keypoint_hrhrnet
-from . import keypoint_hrnet
-from . import jde
-from . import deepsort
-from . import fairmot
-from . import centernet
-
-from .meta_arch import *
-from .faster_rcnn import *
-from .mask_rcnn import *
-from .yolo import *
-from .cascade_rcnn import *
-from .ssd import *
-from .fcos import *
-from .solov2 import *
-from .ttfnet import *
-from .s2anet import *
-from .keypoint_hrhrnet import *
-from .keypoint_hrnet import *
-from .jde import *
-from .deepsort import *
-from .fairmot import *
-from .centernet import *

paddlex/ppdet/modeling/architectures/cascade_rcnn.py

@@ -1,144 +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__ = ['CascadeRCNN']
-
-
-@register
-class CascadeRCNN(BaseArch):
-    """
-    Cascade R-CNN network, see https://arxiv.org/abs/1712.00726
-
-    Args:
-        backbone (object): backbone instance
-        rpn_head (object): `RPNHead` instance
-        bbox_head (object): `BBoxHead` instance
-        bbox_post_process (object): `BBoxPostProcess` instance
-        neck (object): 'FPN' instance
-        mask_head (object): `MaskHead` instance
-        mask_post_process (object): `MaskPostProcess` instance
-    """
-    __category__ = 'architecture'
-    __inject__ = [
-        'bbox_post_process',
-        'mask_post_process',
-    ]
-
-    def __init__(self,
-                 backbone,
-                 rpn_head,
-                 bbox_head,
-                 bbox_post_process,
-                 neck=None,
-                 mask_head=None,
-                 mask_post_process=None):
-        super(CascadeRCNN, self).__init__()
-        self.backbone = backbone
-        self.rpn_head = rpn_head
-        self.bbox_head = bbox_head
-        self.bbox_post_process = bbox_post_process
-        self.neck = neck
-        self.mask_head = mask_head
-        self.mask_post_process = mask_post_process
-        self.with_mask = mask_head is not None
-
-    @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 = cfg['mask_head'] and 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()
-            if self.with_mask:
-                mask_loss = self.mask_head(body_feats, rois, rois_num,
-                                           self.inputs, bbox_targets,
-                                           bbox_feat)
-                return rpn_loss, bbox_loss, mask_loss
-            else:
-                return rpn_loss, bbox_loss, {}
-        else:
-            rois, rois_num, _ = self.rpn_head(body_feats, self.inputs)
-            preds, _ = self.bbox_head(body_feats, rois, rois_num, self.inputs)
-            refined_rois = self.bbox_head.get_refined_rois()
-
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-
-            bbox, bbox_num = self.bbox_post_process(
-                preds, (refined_rois, rois_num), im_shape, scale_factor)
-            # rescale the prediction back to origin image
-            bbox_pred = self.bbox_post_process.get_pred(bbox, bbox_num,
-                                                        im_shape, scale_factor)
-            if not self.with_mask:
-                return bbox_pred, bbox_num, None
-            mask_out = self.mask_head(body_feats, bbox, bbox_num, self.inputs)
-            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, ):
-        rpn_loss, bbox_loss, mask_loss = self._forward()
-        loss = {}
-        loss.update(rpn_loss)
-        loss.update(bbox_loss)
-        if self.with_mask:
-            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,
-        }
-        if self.with_mask:
-            output.update({'mask': mask_pred})
-        return output

paddlex/ppdet/modeling/architectures/centernet.py

@@ -1,103 +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__ = ['CenterNet']
-
-
-@register
-class CenterNet(BaseArch):
-    """
-    CenterNet network, see http://arxiv.org/abs/1904.07850
-
-    Args:
-        backbone (object): backbone instance
-        neck (object): 'CenterDLAFPN' instance
-        head (object): 'CenterHead' instance
-        post_process (object): 'CenterNetPostProcess' instance
-        for_mot (bool): whether return other features used in tracking model
-
-    """
-    __category__ = 'architecture'
-    __inject__ = ['post_process']
-
-    def __init__(self,
-                 backbone='DLA',
-                 neck='CenterDLAFPN',
-                 head='CenterHead',
-                 post_process='CenterNetPostProcess',
-                 for_mot=False):
-        super(CenterNet, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.head = head
-        self.post_process = post_process
-        self.for_mot = for_mot
-
-    @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)
-        neck_feat = self.neck(body_feats)
-        head_out = self.head(neck_feat, self.inputs)
-        if self.for_mot:
-            head_out.update({'neck_feat': neck_feat})
-        return head_out
-
-    def get_pred(self):
-        head_out = self._forward()
-        if self.for_mot:
-            bbox, bbox_inds = self.post_process(
-                head_out['heatmap'],
-                head_out['size'],
-                head_out['offset'],
-                im_shape=self.inputs['im_shape'],
-                scale_factor=self.inputs['scale_factor'])
-            output = {
-                "bbox": bbox,
-                "bbox_inds": bbox_inds,
-                "neck_feat": head_out['neck_feat']
-            }
-        else:
-            bbox, bbox_num = self.post_process(
-                head_out['heatmap'],
-                head_out['size'],
-                head_out['offset'],
-                im_shape=self.inputs['im_shape'],
-                scale_factor=self.inputs['scale_factor'])
-            output = {
-                "bbox": bbox,
-                "bbox_num": bbox_num,
-            }
-        return output
-
-    def get_loss(self):
-        return self._forward()

paddlex/ppdet/modeling/architectures/deepsort.py

@@ -1,111 +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
-from paddlex.ppdet.modeling.mot.utils import Detection, get_crops, scale_coords, clip_box
-
-__all__ = ['DeepSORT']
-
-
-@register
-class DeepSORT(BaseArch):
-    """
-    DeepSORT network, see https://arxiv.org/abs/1703.07402
-
-    Args:
-        detector (object): detector model instance
-        reid (object): reid model instance
-        tracker (object): tracker instance
-    """
-    __category__ = 'architecture'
-
-    def __init__(self,
-                 detector='YOLOv3',
-                 reid='PCBPyramid',
-                 tracker='DeepSORTTracker'):
-        super(DeepSORT, self).__init__()
-        self.detector = detector
-        self.reid = reid
-        self.tracker = tracker
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        if cfg['detector'] != 'None':
-            detector = create(cfg['detector'])
-        else:
-            detector = None
-        reid = create(cfg['reid'])
-        tracker = create(cfg['tracker'])
-
-        return {
-            "detector": detector,
-            "reid": reid,
-            "tracker": tracker,
-        }
-
-    def _forward(self):
-        assert 'ori_image' in self.inputs
-        load_dets = 'pred_bboxes' in self.inputs and 'pred_scores' in self.inputs
-
-        ori_image = self.inputs['ori_image']
-        input_shape = self.inputs['image'].shape[2:]
-        im_shape = self.inputs['im_shape']
-        scale_factor = self.inputs['scale_factor']
-
-        if self.detector and not load_dets:
-            outs = self.detector(self.inputs)
-            if outs['bbox_num'] > 0:
-                pred_bboxes = scale_coords(outs['bbox'][:, 2:], input_shape,
-                                           im_shape, scale_factor)
-                pred_scores = outs['bbox'][:, 1:2]
-            else:
-                pred_bboxes = []
-                pred_scores = []
-        else:
-            pred_bboxes = self.inputs['pred_bboxes']
-            pred_scores = self.inputs['pred_scores']
-
-        if len(pred_bboxes) > 0:
-            pred_bboxes = clip_box(pred_bboxes, input_shape, im_shape,
-                                   scale_factor)
-            bbox_tlwh = paddle.concat(
-                (pred_bboxes[:, 0:2],
-                 pred_bboxes[:, 2:4] - pred_bboxes[:, 0:2] + 1),
-                axis=1)
-
-            crops, pred_scores = get_crops(
-                pred_bboxes, ori_image, pred_scores, w=64, h=192)
-
-            if len(crops) > 0:
-                features = self.reid(paddle.to_tensor(crops))
-                detections = [Detection(bbox_tlwh[i], conf, features[i])\
-                                        for i, conf in enumerate(pred_scores)]
-            else:
-                detections = []
-        else:
-            detections = []
-
-        self.tracker.predict()
-        online_targets = self.tracker.update(detections)
-
-        return online_targets
-
-    def get_pred(self):
-        return self._forward()

paddlex/ppdet/modeling/architectures/fairmot.py

@@ -1,107 +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__ = ['FairMOT']
-
-
-@register
-class FairMOT(BaseArch):
-    """
-    FairMOT network, see http://arxiv.org/abs/2004.01888
-
-    Args:
-        detector (object): 'CenterNet' instance
-        reid (object): 'FairMOTEmbeddingHead' instance
-        tracker (object): 'JDETracker' instance
-        loss (object): 'FairMOTLoss' instance
-
-    """
-
-    __category__ = 'architecture'
-    __inject__ = ['loss']
-
-    def __init__(self,
-                 detector='CenterNet',
-                 reid='FairMOTEmbeddingHead',
-                 tracker='JDETracker',
-                 loss='FairMOTLoss'):
-        super(FairMOT, self).__init__()
-        self.detector = detector
-        self.reid = reid
-        self.tracker = tracker
-        self.loss = loss
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        detector = create(cfg['detector'])
-
-        kwargs = {'input_shape': detector.neck.out_shape}
-        reid = create(cfg['reid'], **kwargs)
-        loss = create(cfg['loss'])
-        tracker = create(cfg['tracker'])
-
-        return {
-            'detector': detector,
-            'reid': reid,
-            'loss': loss,
-            'tracker': tracker
-        }
-
-    def _forward(self):
-        loss = dict()
-        # det_outs keys:
-        # train: det_loss, heatmap_loss, size_loss, offset_loss, neck_feat
-        # eval/infer: bbox, bbox_inds, neck_feat
-        det_outs = self.detector(self.inputs)
-        neck_feat = det_outs['neck_feat']
-        if self.training:
-            reid_loss = self.reid(neck_feat, self.inputs)
-
-            det_loss = det_outs['det_loss']
-            loss = self.loss(det_loss, reid_loss)
-            loss.update({
-                'heatmap_loss': det_outs['heatmap_loss'],
-                'size_loss': det_outs['size_loss'],
-                'offset_loss': det_outs['offset_loss'],
-                'reid_loss': reid_loss
-            })
-            return loss
-        else:
-            embedding = self.reid(neck_feat, self.inputs)
-            bbox_inds = det_outs['bbox_inds']
-            embedding = paddle.transpose(embedding, [0, 2, 3, 1])
-            embedding = paddle.reshape(embedding,
-                                       [-1, paddle.shape(embedding)[-1]])
-            id_feature = paddle.gather(embedding, bbox_inds)
-            dets = det_outs['bbox']
-            id_feature = id_feature
-            # Note: the tracker only considers batch_size=1 and num_classses=1
-            online_targets = self.tracker.update(dets, id_feature)
-            return online_targets
-
-    def get_pred(self):
-        output = self._forward()
-        return output
-
-    def get_loss(self):
-        loss = self._forward()
-        return loss

paddlex/ppdet/modeling/architectures/faster_rcnn.py

@@ -1,106 +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__ = ['FasterRCNN']
-
-
-@register
-class FasterRCNN(BaseArch):
-    """
-    Faster R-CNN network, see https://arxiv.org/abs/1506.01497
-
-    Args:
-        backbone (object): backbone instance
-        rpn_head (object): `RPNHead` instance
-        bbox_head (object): `BBoxHead` instance
-        bbox_post_process (object): `BBoxPostProcess` instance
-        neck (object): 'FPN' instance
-    """
-    __category__ = 'architecture'
-    __inject__ = ['bbox_post_process']
-
-    def __init__(self,
-                 backbone,
-                 rpn_head,
-                 bbox_head,
-                 bbox_post_process,
-                 neck=None):
-        super(FasterRCNN, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.rpn_head = rpn_head
-        self.bbox_head = bbox_head
-        self.bbox_post_process = bbox_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)
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "rpn_head": rpn_head,
-            "bbox_head": bbox_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, _ = self.bbox_head(body_feats, rois, rois_num,
-                                          self.inputs)
-            return rpn_loss, bbox_loss
-        else:
-            rois, rois_num, _ = self.rpn_head(body_feats, self.inputs)
-            preds, _ = 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)
-
-            # rescale the prediction back to origin image
-            bbox_pred = self.bbox_post_process.get_pred(bbox, bbox_num,
-                                                        im_shape, scale_factor)
-            return bbox_pred, bbox_num
-
-    def get_loss(self, ):
-        rpn_loss, bbox_loss = self._forward()
-        loss = {}
-        loss.update(rpn_loss)
-        loss.update(bbox_loss)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        bbox_pred, bbox_num = self._forward()
-        output = {'bbox': bbox_pred, 'bbox_num': bbox_num}
-        return output