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

paddlex/ppdet/modeling/heads/cascade_head.py

@@ -1,284 +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 paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn.initializer import Normal
-
-from paddlex.ppdet.core.workspace import register
-from .bbox_head import BBoxHead, TwoFCHead, XConvNormHead
-from .roi_extractor import RoIAlign
-from ..shape_spec import ShapeSpec
-from ..bbox_utils import delta2bbox, clip_bbox, nonempty_bbox
-
-__all__ = ['CascadeTwoFCHead', 'CascadeXConvNormHead', 'CascadeHead']
-
-
-@register
-class CascadeTwoFCHead(nn.Layer):
-    __shared__ = ['num_cascade_stage']
-    """
-    Cascade RCNN bbox head  with Two fc layers to extract feature
-
-    Args:
-        in_channel (int): Input channel which can be derived by from_config
-        out_channel (int): Output channel
-        resolution (int): Resolution of input feature map, default 7
-        num_cascade_stage (int): The number of cascade stage, default 3
-    """
-
-    def __init__(self,
-                 in_channel=256,
-                 out_channel=1024,
-                 resolution=7,
-                 num_cascade_stage=3):
-        super(CascadeTwoFCHead, self).__init__()
-
-        self.in_channel = in_channel
-        self.out_channel = out_channel
-
-        self.head_list = []
-        for stage in range(num_cascade_stage):
-            head_per_stage = self.add_sublayer(
-                str(stage), TwoFCHead(in_channel, out_channel, resolution))
-            self.head_list.append(head_per_stage)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        s = input_shape
-        s = s[0] if isinstance(s, (list, tuple)) else s
-        return {'in_channel': s.channels}
-
-    @property
-    def out_shape(self):
-        return [ShapeSpec(channels=self.out_channel, )]
-
-    def forward(self, rois_feat, stage=0):
-        out = self.head_list[stage](rois_feat)
-        return out
-
-
-@register
-class CascadeXConvNormHead(nn.Layer):
-    __shared__ = ['norm_type', 'freeze_norm', 'num_cascade_stage']
-    """
-    Cascade RCNN bbox head with serveral convolution layers
-
-    Args:
-        in_channel (int): Input channels which can be derived by from_config
-        num_convs (int): The number of conv layers
-        conv_dim (int): The number of channels for the conv layers
-        out_channel (int): Output channels
-        resolution (int): Resolution of input feature map
-        norm_type (string): Norm type, bn, gn, sync_bn are available,
-            default `gn`
-        freeze_norm (bool): Whether to freeze the norm
-        num_cascade_stage (int): The number of cascade stage, default 3
-    """
-
-    def __init__(self,
-                 in_channel=256,
-                 num_convs=4,
-                 conv_dim=256,
-                 out_channel=1024,
-                 resolution=7,
-                 norm_type='gn',
-                 freeze_norm=False,
-                 num_cascade_stage=3):
-        super(CascadeXConvNormHead, self).__init__()
-        self.in_channel = in_channel
-        self.out_channel = out_channel
-
-        self.head_list = []
-        for stage in range(num_cascade_stage):
-            head_per_stage = self.add_sublayer(
-                str(stage),
-                XConvNormHead(
-                    in_channel,
-                    num_convs,
-                    conv_dim,
-                    out_channel,
-                    resolution,
-                    norm_type,
-                    freeze_norm,
-                    stage_name='stage{}_'.format(stage)))
-            self.head_list.append(head_per_stage)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        s = input_shape
-        s = s[0] if isinstance(s, (list, tuple)) else s
-        return {'in_channel': s.channels}
-
-    @property
-    def out_shape(self):
-        return [ShapeSpec(channels=self.out_channel, )]
-
-    def forward(self, rois_feat, stage=0):
-        out = self.head_list[stage](rois_feat)
-        return out
-
-
-@register
-class CascadeHead(BBoxHead):
-    __shared__ = ['num_classes', 'num_cascade_stages']
-    __inject__ = ['bbox_assigner', 'bbox_loss']
-    """
-    Cascade RCNN bbox head
-
-    Args:
-        head (nn.Layer): Extract feature in bbox head
-        in_channel (int): Input channel after RoI extractor
-        roi_extractor (object): The module of RoI Extractor
-        bbox_assigner (object): The module of Box Assigner, label and sample the
-            box.
-        num_classes (int): The number of classes
-        bbox_weight (List[List[float]]): The weight to get the decode box and the
-            length of weight is the number of cascade stage
-        num_cascade_stages (int): THe number of stage to refine the box
-    """
-
-    def __init__(self,
-                 head,
-                 in_channel,
-                 roi_extractor=RoIAlign().__dict__,
-                 bbox_assigner='BboxAssigner',
-                 num_classes=80,
-                 bbox_weight=[[10., 10., 5., 5.], [20.0, 20.0, 10.0, 10.0],
-                              [30.0, 30.0, 15.0, 15.0]],
-                 num_cascade_stages=3,
-                 bbox_loss=None):
-        nn.Layer.__init__(self, )
-        self.head = head
-        self.roi_extractor = roi_extractor
-        if isinstance(roi_extractor, dict):
-            self.roi_extractor = RoIAlign(**roi_extractor)
-        self.bbox_assigner = bbox_assigner
-
-        self.num_classes = num_classes
-        self.bbox_weight = bbox_weight
-        self.num_cascade_stages = num_cascade_stages
-        self.bbox_loss = bbox_loss
-
-        self.bbox_score_list = []
-        self.bbox_delta_list = []
-        for i in range(num_cascade_stages):
-            score_name = 'bbox_score_stage{}'.format(i)
-            delta_name = 'bbox_delta_stage{}'.format(i)
-            bbox_score = self.add_sublayer(
-                score_name,
-                nn.Linear(
-                    in_channel,
-                    self.num_classes + 1,
-                    weight_attr=paddle.ParamAttr(initializer=Normal(
-                        mean=0.0, std=0.01))))
-
-            bbox_delta = self.add_sublayer(
-                delta_name,
-                nn.Linear(
-                    in_channel,
-                    4,
-                    weight_attr=paddle.ParamAttr(initializer=Normal(
-                        mean=0.0, std=0.001))))
-            self.bbox_score_list.append(bbox_score)
-            self.bbox_delta_list.append(bbox_delta)
-        self.assigned_label = None
-        self.assigned_rois = None
-
-    def forward(self, body_feats=None, rois=None, rois_num=None, inputs=None):
-        """
-        body_feats (list[Tensor]): Feature maps from backbone
-        rois (Tensor): RoIs generated from RPN module
-        rois_num (Tensor): The number of RoIs in each image
-        inputs (dict{Tensor}): The ground-truth of image
-        """
-        targets = []
-        if self.training:
-            rois, rois_num, targets = self.bbox_assigner(rois, rois_num,
-                                                         inputs)
-            targets_list = [targets]
-            self.assigned_rois = (rois, rois_num)
-            self.assigned_targets = targets
-
-        pred_bbox = None
-        head_out_list = []
-        for i in range(self.num_cascade_stages):
-            if i > 0:
-                rois, rois_num = self._get_rois_from_boxes(pred_bbox,
-                                                           inputs['im_shape'])
-                if self.training:
-                    rois, rois_num, targets = self.bbox_assigner(
-                        rois, rois_num, inputs, i, is_cascade=True)
-                    targets_list.append(targets)
-
-            rois_feat = self.roi_extractor(body_feats, rois, rois_num)
-            bbox_feat = self.head(rois_feat, i)
-            scores = self.bbox_score_list[i](bbox_feat)
-            deltas = self.bbox_delta_list[i](bbox_feat)
-            head_out_list.append([scores, deltas, rois])
-            pred_bbox = self._get_pred_bbox(deltas, rois, self.bbox_weight[i])
-
-        if self.training:
-            loss = {}
-            for stage, value in enumerate(zip(head_out_list, targets_list)):
-                (scores, deltas, rois), targets = value
-                loss_stage = self.get_loss(scores, deltas, targets, rois,
-                                           self.bbox_weight[stage])
-                for k, v in loss_stage.items():
-                    loss[k + "_stage{}".format(
-                        stage)] = v / self.num_cascade_stages
-
-            return loss, bbox_feat
-        else:
-            scores, deltas, self.refined_rois = self.get_prediction(
-                head_out_list)
-            return (deltas, scores), self.head
-
-    def _get_rois_from_boxes(self, boxes, im_shape):
-        rois = []
-        for i, boxes_per_image in enumerate(boxes):
-            clip_box = clip_bbox(boxes_per_image, im_shape[i])
-            if self.training:
-                keep = nonempty_bbox(clip_box)
-                if keep.shape[0] == 0:
-                    keep = paddle.zeros([1], dtype='int32')
-                clip_box = paddle.gather(clip_box, keep)
-            rois.append(clip_box)
-        rois_num = paddle.concat([paddle.shape(r)[0] for r in rois])
-        return rois, rois_num
-
-    def _get_pred_bbox(self, deltas, proposals, weights):
-        pred_proposals = paddle.concat(proposals) if len(
-            proposals) > 1 else proposals[0]
-        pred_bbox = delta2bbox(deltas, pred_proposals, weights)
-        pred_bbox = paddle.reshape(pred_bbox, [-1, deltas.shape[-1]])
-        num_prop = []
-        for p in proposals:
-            num_prop.append(p.shape[0])
-        return pred_bbox.split(num_prop)
-
-    def get_prediction(self, head_out_list):
-        """
-        head_out_list(List[Tensor]): scores, deltas, rois
-        """
-        pred_list = []
-        scores_list = [F.softmax(head[0]) for head in head_out_list]
-        scores = paddle.add_n(scores_list) / self.num_cascade_stages
-        # Get deltas and rois from the last stage
-        _, deltas, rois = head_out_list[-1]
-        return scores, deltas, rois
-
-    def get_refined_rois(self, ):
-        return self.refined_rois

paddlex/ppdet/modeling/heads/centernet_head.py

@@ -1,292 +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 math
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle.nn.initializer import Constant, Uniform
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling.losses import CTFocalLoss, GIoULoss
-
-
-class ConvLayer(nn.Layer):
-    def __init__(self,
-                 ch_in,
-                 ch_out,
-                 kernel_size,
-                 stride=1,
-                 padding=0,
-                 dilation=1,
-                 groups=1,
-                 bias=False):
-        super(ConvLayer, self).__init__()
-        bias_attr = False
-        fan_in = ch_in * kernel_size**2
-        bound = 1 / math.sqrt(fan_in)
-        param_attr = paddle.ParamAttr(initializer=Uniform(-bound, bound))
-        if bias:
-            bias_attr = paddle.ParamAttr(initializer=Constant(0.))
-        self.conv = nn.Conv2D(
-            in_channels=ch_in,
-            out_channels=ch_out,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            groups=groups,
-            weight_attr=param_attr,
-            bias_attr=bias_attr)
-
-    def forward(self, inputs):
-        out = self.conv(inputs)
-        return out
-
-
-@register
-class CenterNetHead(nn.Layer):
-    """
-    Args:
-        in_channels (int): the channel number of input to CenterNetHead.
-        num_classes (int): the number of classes, 80 (COCO dataset) by default.
-        head_planes (int): the channel number in all head, 256 by default.
-        heatmap_weight (float): the weight of heatmap loss, 1 by default.
-        regress_ltrb (bool): whether to regress left/top/right/bottom or
-            width/height for a box, true by default
-        size_weight (float): the weight of box size loss, 0.1 by default.
-        size_loss (): the type of size regression loss, 'L1 loss' by default.
-        offset_weight (float): the weight of center offset loss, 1 by default.
-        iou_weight (float): the weight of iou head loss, 0 by default.
-    """
-
-    __shared__ = ['num_classes']
-
-    def __init__(self,
-                 in_channels,
-                 num_classes=80,
-                 head_planes=256,
-                 heatmap_weight=1,
-                 regress_ltrb=True,
-                 size_weight=0.1,
-                 size_loss='L1',
-                 offset_weight=1,
-                 iou_weight=0):
-        super(CenterNetHead, self).__init__()
-        self.regress_ltrb = regress_ltrb
-        self.weights = {
-            'heatmap': heatmap_weight,
-            'size': size_weight,
-            'offset': offset_weight,
-            'iou': iou_weight
-        }
-
-        # heatmap head
-        self.heatmap = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes,
-                num_classes,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                bias=True))
-        with paddle.no_grad():
-            self.heatmap[2].conv.bias[:] = -2.19
-
-        # size(ltrb or wh) head
-        self.size = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes,
-                4 if regress_ltrb else 2,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                bias=True))
-        self.size_loss = size_loss
-
-        # offset head
-        self.offset = nn.Sequential(
-            ConvLayer(
-                in_channels, head_planes, kernel_size=3, padding=1, bias=True),
-            nn.ReLU(),
-            ConvLayer(
-                head_planes, 2, kernel_size=1, stride=1, padding=0, bias=True))
-
-        # iou head (optinal)
-        if iou_weight > 0:
-            self.iou = nn.Sequential(
-                ConvLayer(
-                    in_channels,
-                    head_planes,
-                    kernel_size=3,
-                    padding=1,
-                    bias=True),
-                nn.ReLU(),
-                ConvLayer(
-                    head_planes,
-                    4 if regress_ltrb else 2,
-                    kernel_size=1,
-                    stride=1,
-                    padding=0,
-                    bias=True))
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        if isinstance(input_shape, (list, tuple)):
-            input_shape = input_shape[0]
-        return {'in_channels': input_shape.channels}
-
-    def forward(self, feat, inputs):
-        heatmap = self.heatmap(feat)
-        size = self.size(feat)
-        offset = self.offset(feat)
-        iou = self.iou(feat) if hasattr(self, 'iou_weight') else None
-
-        if self.training:
-            loss = self.get_loss(
-                inputs, self.weights, heatmap, size, offset, iou=iou)
-            return loss
-        else:
-            heatmap = F.sigmoid(heatmap)
-            head_outs = {'heatmap': heatmap, 'size': size, 'offset': offset}
-            if iou is not None:
-                head_outs.update({'iou': iou})
-            return head_outs
-
-    def get_loss(self, inputs, weights, heatmap, size, offset, iou=None):
-        # heatmap head loss: CTFocalLoss
-        heatmap_target = inputs['heatmap']
-        heatmap = paddle.clip(F.sigmoid(heatmap), 1e-4, 1 - 1e-4)
-        ctfocal_loss = CTFocalLoss()
-        heatmap_loss = ctfocal_loss(heatmap, heatmap_target)
-
-        # size head loss: L1 loss or GIoU loss
-        index = inputs['index']
-        mask = inputs['index_mask']
-        size = paddle.transpose(size, perm=[0, 2, 3, 1])
-        size_n, size_h, size_w, size_c = size.shape
-        size = paddle.reshape(size, shape=[size_n, -1, size_c])
-        index = paddle.unsqueeze(index, 2)
-        batch_inds = list()
-        for i in range(size_n):
-            batch_ind = paddle.full(
-                shape=[1, index.shape[1], 1], fill_value=i, dtype='int64')
-            batch_inds.append(batch_ind)
-        batch_inds = paddle.concat(batch_inds, axis=0)
-        index = paddle.concat(x=[batch_inds, index], axis=2)
-        pos_size = paddle.gather_nd(size, index=index)
-        mask = paddle.unsqueeze(mask, axis=2)
-        size_mask = paddle.expand_as(mask, pos_size)
-        size_mask = paddle.cast(size_mask, dtype=pos_size.dtype)
-        pos_num = size_mask.sum()
-        size_mask.stop_gradient = True
-        if self.size_loss == 'L1':
-            if self.regress_ltrb:
-                size_target = inputs['size']
-                # shape: [bs, max_per_img, 4]
-            else:
-                if inputs['size'].shape[-1] == 2:
-                    # inputs['size'] is wh, and regress as wh
-                    # shape: [bs, max_per_img, 2]
-                    size_target = inputs['size']
-                else:
-                    # inputs['size'] is ltrb, but regress as wh
-                    # shape: [bs, max_per_img, 4]
-                    size_target = inputs['size'][:, :, 0:2] + inputs[
-                        'size'][:, :, 2:]
-
-            size_target.stop_gradient = True
-            size_loss = F.l1_loss(
-                pos_size * size_mask, size_target * size_mask, reduction='sum')
-            size_loss = size_loss / (pos_num + 1e-4)
-        elif self.size_loss == 'giou':
-            size_target = inputs['bbox_xys']
-            size_target.stop_gradient = True
-            centers_x = (size_target[:, :, 0:1] + size_target[:, :, 2:3]) / 2.0
-            centers_y = (size_target[:, :, 1:2] + size_target[:, :, 3:4]) / 2.0
-            x1 = centers_x - pos_size[:, :, 0:1]
-            y1 = centers_y - pos_size[:, :, 1:2]
-            x2 = centers_x + pos_size[:, :, 2:3]
-            y2 = centers_y + pos_size[:, :, 3:4]
-            pred_boxes = paddle.concat([x1, y1, x2, y2], axis=-1)
-            giou_loss = GIoULoss(reduction='sum')
-            size_loss = giou_loss(
-                pred_boxes * size_mask,
-                size_target * size_mask,
-                iou_weight=size_mask,
-                loc_reweight=None)
-            size_loss = size_loss / (pos_num + 1e-4)
-
-        # offset head loss: L1 loss
-        offset_target = inputs['offset']
-        offset = paddle.transpose(offset, perm=[0, 2, 3, 1])
-        offset_n, offset_h, offset_w, offset_c = offset.shape
-        offset = paddle.reshape(offset, shape=[offset_n, -1, offset_c])
-        pos_offset = paddle.gather_nd(offset, index=index)
-        offset_mask = paddle.expand_as(mask, pos_offset)
-        offset_mask = paddle.cast(offset_mask, dtype=pos_offset.dtype)
-        pos_num = offset_mask.sum()
-        offset_mask.stop_gradient = True
-        offset_target.stop_gradient = True
-        offset_loss = F.l1_loss(
-            pos_offset * offset_mask,
-            offset_target * offset_mask,
-            reduction='sum')
-        offset_loss = offset_loss / (pos_num + 1e-4)
-
-        # iou head loss: GIoU loss
-        if iou is not None:
-            iou = paddle.transpose(iou, perm=[0, 2, 3, 1])
-            iou_n, iou_h, iou_w, iou_c = iou.shape
-            iou = paddle.reshape(iou, shape=[iou_n, -1, iou_c])
-            pos_iou = paddle.gather_nd(iou, index=index)
-            iou_mask = paddle.expand_as(mask, pos_iou)
-            iou_mask = paddle.cast(iou_mask, dtype=pos_iou.dtype)
-            pos_num = iou_mask.sum()
-            iou_mask.stop_gradient = True
-            gt_bbox_xys = inputs['bbox_xys']
-            gt_bbox_xys.stop_gradient = True
-            centers_x = (gt_bbox_xys[:, :, 0:1] + gt_bbox_xys[:, :, 2:3]) / 2.0
-            centers_y = (gt_bbox_xys[:, :, 1:2] + gt_bbox_xys[:, :, 3:4]) / 2.0
-            x1 = centers_x - pos_size[:, :, 0:1]
-            y1 = centers_y - pos_size[:, :, 1:2]
-            x2 = centers_x + pos_size[:, :, 2:3]
-            y2 = centers_y + pos_size[:, :, 3:4]
-            pred_boxes = paddle.concat([x1, y1, x2, y2], axis=-1)
-            giou_loss = GIoULoss(reduction='sum')
-            iou_loss = giou_loss(
-                pred_boxes * iou_mask,
-                gt_bbox_xys * iou_mask,
-                iou_weight=iou_mask,
-                loc_reweight=None)
-            iou_loss = iou_loss / (pos_num + 1e-4)
-
-        losses = {
-            'heatmap_loss': heatmap_loss,
-            'size_loss': size_loss,
-            'offset_loss': offset_loss,
-        }
-        det_loss = weights['heatmap'] * heatmap_loss + weights[
-            'size'] * size_loss + weights['offset'] * offset_loss
-
-        if iou is not None:
-            losses.update({'iou_loss': iou_loss})
-            det_loss = det_loss + weights['iou'] * iou_loss
-        losses.update({'det_loss': det_loss})
-        return losses