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

paddlex/ppdet/modeling/architectures/s2anet.py

@@ -1,102 +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__ = ['S2ANet']
-
-
-@register
-class S2ANet(BaseArch):
-    __category__ = 'architecture'
-    __inject__ = [
-        's2anet_head',
-        's2anet_bbox_post_process',
-    ]
-
-    def __init__(self, backbone, neck, s2anet_head, s2anet_bbox_post_process):
-        """
-        S2ANet, see https://arxiv.org/pdf/2008.09397.pdf
-
-        Args:
-            backbone (object): backbone instance
-            neck (object): `FPN` instance
-            s2anet_head (object): `S2ANetHead` instance
-            s2anet_bbox_post_process (object): `S2ANetBBoxPostProcess` instance
-        """
-        super(S2ANet, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.s2anet_head = s2anet_head
-        self.s2anet_bbox_post_process = s2anet_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}
-        s2anet_head = create(cfg['s2anet_head'], **kwargs)
-        s2anet_bbox_post_process = create(cfg['s2anet_bbox_post_process'],
-                                          **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "s2anet_head": s2anet_head,
-            "s2anet_bbox_post_process": s2anet_bbox_post_process,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        if self.neck is not None:
-            body_feats = self.neck(body_feats)
-        self.s2anet_head(body_feats)
-        if self.training:
-            loss = self.s2anet_head.get_loss(self.inputs)
-            total_loss = paddle.add_n(list(loss.values()))
-            loss.update({'loss': total_loss})
-            return loss
-        else:
-            im_shape = self.inputs['im_shape']
-            scale_factor = self.inputs['scale_factor']
-            nms_pre = self.s2anet_bbox_post_process.nms_pre
-            pred_scores, pred_bboxes = self.s2anet_head.get_prediction(nms_pre)
-
-            # post_process
-            pred_bboxes, bbox_num = self.s2anet_bbox_post_process(pred_scores,
-                                                                  pred_bboxes)
-            # rescale the prediction back to origin image
-            pred_bboxes = self.s2anet_bbox_post_process.get_pred(
-                pred_bboxes, bbox_num, im_shape, scale_factor)
-
-            # output
-            output = {'bbox': pred_bboxes, 'bbox_num': bbox_num}
-            return output
-
-    def get_loss(self, ):
-        loss = self._forward()
-        return loss
-
-    def get_pred(self):
-        output = self._forward()
-        return output

paddlex/ppdet/modeling/architectures/solov2.py

@@ -1,110 +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__ = ['SOLOv2']
-
-
-@register
-class SOLOv2(BaseArch):
-    """
-    SOLOv2 network, see https://arxiv.org/abs/2003.10152
-
-    Args:
-        backbone (object): an backbone instance
-        solov2_head (object): an `SOLOv2Head` instance
-        mask_head (object): an `SOLOv2MaskHead` instance
-        neck (object): neck of network, such as feature pyramid network instance
-    """
-
-    __category__ = 'architecture'
-
-    def __init__(self, backbone, solov2_head, mask_head, neck=None):
-        super(SOLOv2, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.solov2_head = solov2_head
-        self.mask_head = mask_head
-
-    @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}
-        solov2_head = create(cfg['solov2_head'], **kwargs)
-        mask_head = create(cfg['mask_head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            'solov2_head': solov2_head,
-            'mask_head': mask_head,
-        }
-
-    def model_arch(self):
-        body_feats = self.backbone(self.inputs)
-
-        body_feats = self.neck(body_feats)
-
-        self.seg_pred = self.mask_head(body_feats)
-
-        self.cate_pred_list, self.kernel_pred_list = self.solov2_head(
-            body_feats)
-
-    def get_loss(self, ):
-        loss = {}
-        # get gt_ins_labels, gt_cate_labels, etc.
-        gt_ins_labels, gt_cate_labels, gt_grid_orders = [], [], []
-        fg_num = self.inputs['fg_num']
-        for i in range(len(self.solov2_head.seg_num_grids)):
-            ins_label = 'ins_label{}'.format(i)
-            if ins_label in self.inputs:
-                gt_ins_labels.append(self.inputs[ins_label])
-            cate_label = 'cate_label{}'.format(i)
-            if cate_label in self.inputs:
-                gt_cate_labels.append(self.inputs[cate_label])
-            grid_order = 'grid_order{}'.format(i)
-            if grid_order in self.inputs:
-                gt_grid_orders.append(self.inputs[grid_order])
-
-        loss_solov2 = self.solov2_head.get_loss(
-            self.cate_pred_list, self.kernel_pred_list, self.seg_pred,
-            gt_ins_labels, gt_cate_labels, gt_grid_orders, fg_num)
-        loss.update(loss_solov2)
-        total_loss = paddle.add_n(list(loss.values()))
-        loss.update({'loss': total_loss})
-        return loss
-
-    def get_pred(self):
-        seg_masks, cate_labels, cate_scores, bbox_num = self.solov2_head.get_prediction(
-            self.cate_pred_list, self.kernel_pred_list, self.seg_pred,
-            self.inputs['im_shape'], self.inputs['scale_factor'])
-        outs = {
-            "segm": seg_masks,
-            "bbox_num": bbox_num,
-            'cate_label': cate_labels,
-            'cate_score': cate_scores
-        }
-        return outs

paddlex/ppdet/modeling/architectures/sparse_rcnn.py

@@ -1,99 +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
-
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ["SparseRCNN"]
-
-
-@register
-class SparseRCNN(BaseArch):
-    __category__ = 'architecture'
-    __inject__ = ["postprocess"]
-
-    def __init__(self,
-                 backbone,
-                 neck,
-                 head="SparsercnnHead",
-                 postprocess="SparsePostProcess"):
-        super(SparseRCNN, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.head = head
-        self.postprocess = postprocess
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        backbone = create(cfg['backbone'])
-
-        kwargs = {'input_shape': backbone.out_shape}
-        neck = create(cfg['neck'], **kwargs)
-
-        kwargs = {'roi_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.inputs["img_whwh"])
-
-        if not self.training:
-            bboxes = self.postprocess(
-                head_outs["pred_logits"], head_outs["pred_boxes"],
-                self.inputs["scale_factor_wh"], self.inputs["img_whwh"])
-            return bboxes
-        else:
-            return head_outs
-
-    def get_loss(self):
-        batch_gt_class = self.inputs["gt_class"]
-        batch_gt_box = self.inputs["gt_bbox"]
-        batch_whwh = self.inputs["img_whwh"]
-        targets = []
-
-        for i in range(len(batch_gt_class)):
-            boxes = batch_gt_box[i]
-            labels = batch_gt_class[i].squeeze(-1)
-            img_whwh = batch_whwh[i]
-            img_whwh_tgt = img_whwh.unsqueeze(0).tile([int(boxes.shape[0]), 1])
-            targets.append({
-                "boxes": boxes,
-                "labels": labels,
-                "img_whwh": img_whwh,
-                "img_whwh_tgt": img_whwh_tgt
-            })
-
-        outputs = self._forward()
-        loss_dict = self.head.get_loss(outputs, targets)
-        acc = loss_dict["acc"]
-        loss_dict.pop("acc")
-        total_loss = sum(loss_dict.values())
-        loss_dict.update({"loss": total_loss, "acc": acc})
-        return loss_dict
-
-    def get_pred(self):
-        bbox_pred, bbox_num = self._forward()
-        output = {'bbox': bbox_pred, 'bbox_num': bbox_num}
-        return output

paddlex/ppdet/modeling/architectures/ssd.py

@@ -1,93 +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
-
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['SSD']
-
-
-@register
-class SSD(BaseArch):
-    """
-    Single Shot MultiBox Detector, see https://arxiv.org/abs/1512.02325
-
-    Args:
-        backbone (nn.Layer): backbone instance
-        ssd_head (nn.Layer): `SSDHead` instance
-        post_process (object): `BBoxPostProcess` instance
-    """
-
-    __category__ = 'architecture'
-    __inject__ = ['post_process']
-
-    def __init__(self, backbone, ssd_head, post_process, r34_backbone=False):
-        super(SSD, self).__init__()
-        self.backbone = backbone
-        self.ssd_head = ssd_head
-        self.post_process = post_process
-        self.r34_backbone = r34_backbone
-        if self.r34_backbone:
-            from paddlex.ppdet.modeling.backbones.resnet import ResNet
-            assert isinstance(self.backbone, ResNet) and \
-                   self.backbone.depth == 34, \
-                "If you set r34_backbone=True, please use ResNet-34 as backbone."
-            self.backbone.res_layers[2].blocks[
-                0].branch2a.conv._stride = [1, 1]
-            self.backbone.res_layers[2].blocks[0].short.conv._stride = [1, 1]
-
-    @classmethod
-    def from_config(cls, cfg, *args, **kwargs):
-        # backbone
-        backbone = create(cfg['backbone'])
-
-        # head
-        kwargs = {'input_shape': backbone.out_shape}
-        ssd_head = create(cfg['ssd_head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            "ssd_head": ssd_head,
-        }
-
-    def _forward(self):
-        # Backbone
-        body_feats = self.backbone(self.inputs)
-
-        # SSD Head
-        if self.training:
-            return self.ssd_head(body_feats, self.inputs['image'],
-                                 self.inputs['gt_bbox'],
-                                 self.inputs['gt_class'])
-        else:
-            preds, anchors = self.ssd_head(body_feats, self.inputs['image'])
-            bbox, bbox_num = self.post_process(preds, anchors,
-                                               self.inputs['im_shape'],
-                                               self.inputs['scale_factor'])
-            return bbox, bbox_num
-
-    def get_loss(self, ):
-        return {"loss": self._forward()}
-
-    def get_pred(self):
-        bbox_pred, bbox_num = self._forward()
-        output = {
-            "bbox": bbox_pred,
-            "bbox_num": bbox_num,
-        }
-        return output

paddlex/ppdet/modeling/architectures/tood.py

@@ -1,78 +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
-
-from paddlex.ppdet.core.workspace import register, create
-from .meta_arch import BaseArch
-
-__all__ = ['TOOD']
-
-
-@register
-class TOOD(BaseArch):
-    """
-    TOOD: Task-aligned One-stage Object Detection, see https://arxiv.org/abs/2108.07755
-    Args:
-        backbone (nn.Layer): backbone instance
-        neck (nn.Layer): 'FPN' instance
-        head (nn.Layer): 'TOODHead' instance
-    """
-
-    __category__ = 'architecture'
-
-    def __init__(self, backbone, neck, head):
-        super(TOOD, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.head = head
-
-    @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)
-        if not self.training:
-            bboxes, bbox_num = self.head.post_process(
-                head_outs, self.inputs['im_shape'],
-                self.inputs['scale_factor'])
-            return bboxes, bbox_num
-        else:
-            loss = self.head.get_loss(head_outs, self.inputs)
-            return loss
-
-    def get_loss(self):
-        return self._forward()
-
-    def get_pred(self):
-        bbox_pred, bbox_num = self._forward()
-        output = {'bbox': bbox_pred, 'bbox_num': bbox_num}
-        return output

paddlex/ppdet/modeling/architectures/ttfnet.py

@@ -1,98 +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__ = ['TTFNet']
-
-
-@register
-class TTFNet(BaseArch):
-    """
-    TTFNet network, see https://arxiv.org/abs/1909.00700
-
-    Args:
-        backbone (object): backbone instance
-        neck (object): 'TTFFPN' instance
-        ttf_head (object): 'TTFHead' instance
-        post_process (object): 'BBoxPostProcess' instance
-    """
-
-    __category__ = 'architecture'
-    __inject__ = ['post_process']
-
-    def __init__(self,
-                 backbone='DarkNet',
-                 neck='TTFFPN',
-                 ttf_head='TTFHead',
-                 post_process='BBoxPostProcess'):
-        super(TTFNet, self).__init__()
-        self.backbone = backbone
-        self.neck = neck
-        self.ttf_head = ttf_head
-        self.post_process = post_process
-
-    @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}
-        ttf_head = create(cfg['ttf_head'], **kwargs)
-
-        return {
-            'backbone': backbone,
-            'neck': neck,
-            "ttf_head": ttf_head,
-        }
-
-    def _forward(self):
-        body_feats = self.backbone(self.inputs)
-        body_feats = self.neck(body_feats)
-        hm, wh = self.ttf_head(body_feats)
-        if self.training:
-            return hm, wh
-        else:
-            bbox, bbox_num = self.post_process(hm, wh, self.inputs['im_shape'],
-                                               self.inputs['scale_factor'])
-            return bbox, bbox_num
-
-    def get_loss(self, ):
-        loss = {}
-        heatmap = self.inputs['ttf_heatmap']
-        box_target = self.inputs['ttf_box_target']
-        reg_weight = self.inputs['ttf_reg_weight']
-        hm, wh = self._forward()
-        head_loss = self.ttf_head.get_loss(hm, wh, heatmap, box_target,
-                                           reg_weight)
-        loss.update(head_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