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

paddlex/ppdet/modeling/proposal_generator/__init__.py

@@ -1,2 +0,0 @@
-from . import rpn_head
-from .rpn_head import *

paddlex/ppdet/modeling/proposal_generator/anchor_generator.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.
-
-# The code is based on
-# https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/anchor_generator.py
-
-import math
-
-import paddle
-import paddle.nn as nn
-
-from paddlex.ppdet.core.workspace import register
-
-
-@register
-class AnchorGenerator(nn.Layer):
-    """
-    Generate anchors according to the feature maps
-
-    Args:
-        anchor_sizes (list[float] | list[list[float]]): The anchor sizes at
-            each feature point. list[float] means all feature levels share the
-            same sizes. list[list[float]] means the anchor sizes for
-            each level. The sizes stand for the scale of input size.
-        aspect_ratios (list[float] | list[list[float]]): The aspect ratios at
-            each feature point. list[float] means all feature levels share the
-            same ratios. list[list[float]] means the aspect ratios for
-            each level.
-        strides (list[float]): The strides of feature maps which generate
-            anchors
-        offset (float): The offset of the coordinate of anchors, default 0.
-
-    """
-
-    def __init__(self,
-                 anchor_sizes=[32, 64, 128, 256, 512],
-                 aspect_ratios=[0.5, 1.0, 2.0],
-                 strides=[16.0],
-                 variance=[1.0, 1.0, 1.0, 1.0],
-                 offset=0.):
-        super(AnchorGenerator, self).__init__()
-        self.anchor_sizes = anchor_sizes
-        self.aspect_ratios = aspect_ratios
-        self.strides = strides
-        self.variance = variance
-        self.cell_anchors = self._calculate_anchors(len(strides))
-        self.offset = offset
-
-    def _broadcast_params(self, params, num_features):
-        if not isinstance(params[0], (list, tuple)):  # list[float]
-            return [params] * num_features
-        if len(params) == 1:
-            return list(params) * num_features
-        return params
-
-    def generate_cell_anchors(self, sizes, aspect_ratios):
-        anchors = []
-        for size in sizes:
-            area = size**2.0
-            for aspect_ratio in aspect_ratios:
-                w = math.sqrt(area / aspect_ratio)
-                h = aspect_ratio * w
-                x0, y0, x1, y1 = -w / 2.0, -h / 2.0, w / 2.0, h / 2.0
-                anchors.append([x0, y0, x1, y1])
-        return paddle.to_tensor(anchors, dtype='float32')
-
-    def _calculate_anchors(self, num_features):
-        sizes = self._broadcast_params(self.anchor_sizes, num_features)
-        aspect_ratios = self._broadcast_params(self.aspect_ratios,
-                                               num_features)
-        cell_anchors = [
-            self.generate_cell_anchors(s, a)
-            for s, a in zip(sizes, aspect_ratios)
-        ]
-        [
-            self.register_buffer(
-                t.name, t, persistable=False) for t in cell_anchors
-        ]
-        return cell_anchors
-
-    def _create_grid_offsets(self, size, stride, offset):
-        grid_height, grid_width = size[0], size[1]
-        shifts_x = paddle.arange(
-            offset * stride, grid_width * stride, step=stride, dtype='float32')
-        shifts_y = paddle.arange(
-            offset * stride,
-            grid_height * stride,
-            step=stride,
-            dtype='float32')
-        shift_y, shift_x = paddle.meshgrid(shifts_y, shifts_x)
-        shift_x = paddle.reshape(shift_x, [-1])
-        shift_y = paddle.reshape(shift_y, [-1])
-        return shift_x, shift_y
-
-    def _grid_anchors(self, grid_sizes):
-        anchors = []
-        for size, stride, base_anchors in zip(grid_sizes, self.strides,
-                                              self.cell_anchors):
-            shift_x, shift_y = self._create_grid_offsets(size, stride,
-                                                         self.offset)
-            shifts = paddle.stack((shift_x, shift_y, shift_x, shift_y), axis=1)
-            shifts = paddle.reshape(shifts, [-1, 1, 4])
-            base_anchors = paddle.reshape(base_anchors, [1, -1, 4])
-
-            anchors.append(paddle.reshape(shifts + base_anchors, [-1, 4]))
-
-        return anchors
-
-    def forward(self, input):
-        grid_sizes = [paddle.shape(feature_map)[-2:] for feature_map in input]
-        anchors_over_all_feature_maps = self._grid_anchors(grid_sizes)
-        return anchors_over_all_feature_maps
-
-    @property
-    def num_anchors(self):
-        """
-        Returns:
-            int: number of anchors at every pixel
-                location, on that feature map.
-                For example, if at every pixel we use anchors of 3 aspect
-                ratios and 5 sizes, the number of anchors is 15.
-                For FPN models, `num_anchors` on every feature map is the same.
-        """
-        return len(self.cell_anchors[0])

paddlex/ppdet/modeling/proposal_generator/proposal_generator.py

@@ -1,77 +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
-
-from paddlex.ppdet.core.workspace import register, serializable
-from .. import ops
-
-
-@register
-@serializable
-class ProposalGenerator(object):
-    """
-    Proposal generation module
-
-    For more details, please refer to the document of generate_proposals
-    in ppdet/modeing/ops.py
-
-    Args:
-        pre_nms_top_n (int): Number of total bboxes to be kept per
-            image before NMS. default 6000
-        post_nms_top_n (int): Number of total bboxes to be kept per
-            image after NMS. default 1000
-        nms_thresh (float): Threshold in NMS. default 0.5
-        min_size (flaot): Remove predicted boxes with either height or
-             width < min_size. default 0.1
-        eta (float): Apply in adaptive NMS, if adaptive `threshold > 0.5`,
-             `adaptive_threshold = adaptive_threshold * eta` in each iteration.
-             default 1.
-        topk_after_collect (bool): whether to adopt topk after batch
-             collection. If topk_after_collect is true, box filter will not be
-             used after NMS at each image in proposal generation. default false
-    """
-
-    def __init__(self,
-                 pre_nms_top_n=12000,
-                 post_nms_top_n=2000,
-                 nms_thresh=.5,
-                 min_size=.1,
-                 eta=1.,
-                 topk_after_collect=False):
-        super(ProposalGenerator, self).__init__()
-        self.pre_nms_top_n = pre_nms_top_n
-        self.post_nms_top_n = post_nms_top_n
-        self.nms_thresh = nms_thresh
-        self.min_size = min_size
-        self.eta = eta
-        self.topk_after_collect = topk_after_collect
-
-    def __call__(self, scores, bbox_deltas, anchors, im_shape):
-
-        top_n = self.pre_nms_top_n if self.topk_after_collect else self.post_nms_top_n
-        variances = paddle.ones_like(anchors)
-        rpn_rois, rpn_rois_prob, rpn_rois_num = ops.generate_proposals(
-            scores,
-            bbox_deltas,
-            im_shape,
-            anchors,
-            variances,
-            pre_nms_top_n=self.pre_nms_top_n,
-            post_nms_top_n=top_n,
-            nms_thresh=self.nms_thresh,
-            min_size=self.min_size,
-            eta=self.eta,
-            return_rois_num=True)
-        return rpn_rois, rpn_rois_prob, rpn_rois_num, self.post_nms_top_n

paddlex/ppdet/modeling/proposal_generator/rpn_head.py

@@ -1,260 +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 .anchor_generator import AnchorGenerator
-from .target_layer import RPNTargetAssign
-from .proposal_generator import ProposalGenerator
-
-
-class RPNFeat(nn.Layer):
-    """
-    Feature extraction in RPN head
-
-    Args:
-        in_channel (int): Input channel
-        out_channel (int): Output channel
-    """
-
-    def __init__(self, in_channel=1024, out_channel=1024):
-        super(RPNFeat, self).__init__()
-        # rpn feat is shared with each level
-        self.rpn_conv = nn.Conv2D(
-            in_channels=in_channel,
-            out_channels=out_channel,
-            kernel_size=3,
-            padding=1,
-            weight_attr=paddle.ParamAttr(initializer=Normal(
-                mean=0., std=0.01)))
-        self.rpn_conv.skip_quant = True
-
-    def forward(self, feats):
-        rpn_feats = []
-        for feat in feats:
-            rpn_feats.append(F.relu(self.rpn_conv(feat)))
-        return rpn_feats
-
-
-@register
-class RPNHead(nn.Layer):
-    """
-    Region Proposal Network
-
-    Args:
-        anchor_generator (dict): configure of anchor generation
-        rpn_target_assign (dict): configure of rpn targets assignment
-        train_proposal (dict): configure of proposals generation
-            at the stage of training
-        test_proposal (dict): configure of proposals generation
-            at the stage of prediction
-        in_channel (int): channel of input feature maps which can be
-            derived by from_config
-    """
-
-    def __init__(self,
-                 anchor_generator=AnchorGenerator().__dict__,
-                 rpn_target_assign=RPNTargetAssign().__dict__,
-                 train_proposal=ProposalGenerator(12000, 2000).__dict__,
-                 test_proposal=ProposalGenerator().__dict__,
-                 in_channel=1024):
-        super(RPNHead, self).__init__()
-        self.anchor_generator = anchor_generator
-        self.rpn_target_assign = rpn_target_assign
-        self.train_proposal = train_proposal
-        self.test_proposal = test_proposal
-        if isinstance(anchor_generator, dict):
-            self.anchor_generator = AnchorGenerator(**anchor_generator)
-        if isinstance(rpn_target_assign, dict):
-            self.rpn_target_assign = RPNTargetAssign(**rpn_target_assign)
-        if isinstance(train_proposal, dict):
-            self.train_proposal = ProposalGenerator(**train_proposal)
-        if isinstance(test_proposal, dict):
-            self.test_proposal = ProposalGenerator(**test_proposal)
-
-        num_anchors = self.anchor_generator.num_anchors
-        self.rpn_feat = RPNFeat(in_channel, in_channel)
-        # rpn head is shared with each level
-        # rpn roi classification scores
-        self.rpn_rois_score = nn.Conv2D(
-            in_channels=in_channel,
-            out_channels=num_anchors,
-            kernel_size=1,
-            padding=0,
-            weight_attr=paddle.ParamAttr(initializer=Normal(
-                mean=0., std=0.01)))
-        self.rpn_rois_score.skip_quant = True
-
-        # rpn roi bbox regression deltas
-        self.rpn_rois_delta = nn.Conv2D(
-            in_channels=in_channel,
-            out_channels=4 * num_anchors,
-            kernel_size=1,
-            padding=0,
-            weight_attr=paddle.ParamAttr(initializer=Normal(
-                mean=0., std=0.01)))
-        self.rpn_rois_delta.skip_quant = True
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        # FPN share same rpn head
-        if isinstance(input_shape, (list, tuple)):
-            input_shape = input_shape[0]
-        return {'in_channel': input_shape.channels}
-
-    def forward(self, feats, inputs):
-        rpn_feats = self.rpn_feat(feats)
-        scores = []
-        deltas = []
-
-        for rpn_feat in rpn_feats:
-            rrs = self.rpn_rois_score(rpn_feat)
-            rrd = self.rpn_rois_delta(rpn_feat)
-            scores.append(rrs)
-            deltas.append(rrd)
-
-        anchors = self.anchor_generator(rpn_feats)
-
-        rois, rois_num = self._gen_proposal(scores, deltas, anchors, inputs)
-        if self.training:
-            loss = self.get_loss(scores, deltas, anchors, inputs)
-            return rois, rois_num, loss
-        else:
-            return rois, rois_num, None
-
-    def _gen_proposal(self, scores, bbox_deltas, anchors, inputs):
-        """
-        scores (list[Tensor]): Multi-level scores prediction
-        bbox_deltas (list[Tensor]): Multi-level deltas prediction
-        anchors (list[Tensor]): Multi-level anchors
-        inputs (dict): ground truth info
-        """
-        prop_gen = self.train_proposal if self.training else self.test_proposal
-        im_shape = inputs['im_shape']
-
-        # Collect multi-level proposals for each batch
-        # Get 'topk' of them as final output
-        bs_rois_collect = []
-        bs_rois_num_collect = []
-        batch_size = paddle.slice(paddle.shape(im_shape), [0], [0], [1])
-
-        # Generate proposals for each level and each batch.
-        # Discard batch-computing to avoid sorting bbox cross different batches.
-        for i in range(batch_size):
-            rpn_rois_list = []
-            rpn_prob_list = []
-            rpn_rois_num_list = []
-
-            for rpn_score, rpn_delta, anchor in zip(scores, bbox_deltas,
-                                                    anchors):
-                rpn_rois, rpn_rois_prob, rpn_rois_num, post_nms_top_n = prop_gen(
-                    scores=rpn_score[i:i + 1],
-                    bbox_deltas=rpn_delta[i:i + 1],
-                    anchors=anchor,
-                    im_shape=im_shape[i:i + 1])
-                if rpn_rois.shape[0] > 0:
-                    rpn_rois_list.append(rpn_rois)
-                    rpn_prob_list.append(rpn_rois_prob)
-                    rpn_rois_num_list.append(rpn_rois_num)
-
-            if len(scores) > 1:
-                rpn_rois = paddle.concat(rpn_rois_list)
-                rpn_prob = paddle.concat(rpn_prob_list).flatten()
-
-                if rpn_prob.shape[0] > post_nms_top_n:
-                    topk_prob, topk_inds = paddle.topk(rpn_prob,
-                                                       post_nms_top_n)
-                    topk_rois = paddle.gather(rpn_rois, topk_inds)
-                else:
-                    topk_rois = rpn_rois
-                    topk_prob = rpn_prob
-            else:
-                topk_rois = rpn_rois_list[0]
-                topk_prob = rpn_prob_list[0].flatten()
-
-            bs_rois_collect.append(topk_rois)
-            bs_rois_num_collect.append(paddle.shape(topk_rois)[0])
-
-        bs_rois_num_collect = paddle.concat(bs_rois_num_collect)
-
-        return bs_rois_collect, bs_rois_num_collect
-
-    def get_loss(self, pred_scores, pred_deltas, anchors, inputs):
-        """
-        pred_scores (list[Tensor]): Multi-level scores prediction
-        pred_deltas (list[Tensor]): Multi-level deltas prediction
-        anchors (list[Tensor]): Multi-level anchors
-        inputs (dict): ground truth info, including im, gt_bbox, gt_score
-        """
-        anchors = [paddle.reshape(a, shape=(-1, 4)) for a in anchors]
-        anchors = paddle.concat(anchors)
-
-        scores = [
-            paddle.reshape(
-                paddle.transpose(
-                    v, perm=[0, 2, 3, 1]),
-                shape=(v.shape[0], -1, 1)) for v in pred_scores
-        ]
-        scores = paddle.concat(scores, axis=1)
-
-        deltas = [
-            paddle.reshape(
-                paddle.transpose(
-                    v, perm=[0, 2, 3, 1]),
-                shape=(v.shape[0], -1, 4)) for v in pred_deltas
-        ]
-        deltas = paddle.concat(deltas, axis=1)
-
-        score_tgt, bbox_tgt, loc_tgt, norm = self.rpn_target_assign(inputs,
-                                                                    anchors)
-
-        scores = paddle.reshape(x=scores, shape=(-1, ))
-        deltas = paddle.reshape(x=deltas, shape=(-1, 4))
-
-        score_tgt = paddle.concat(score_tgt)
-        score_tgt.stop_gradient = True
-
-        pos_mask = score_tgt == 1
-        pos_ind = paddle.nonzero(pos_mask)
-
-        valid_mask = score_tgt >= 0
-        valid_ind = paddle.nonzero(valid_mask)
-
-        # cls loss
-        if valid_ind.shape[0] == 0:
-            loss_rpn_cls = paddle.zeros([1], dtype='float32')
-        else:
-            score_pred = paddle.gather(scores, valid_ind)
-            score_label = paddle.gather(score_tgt, valid_ind).cast('float32')
-            score_label.stop_gradient = True
-            loss_rpn_cls = F.binary_cross_entropy_with_logits(
-                logit=score_pred, label=score_label, reduction="sum")
-
-        # reg loss
-        if pos_ind.shape[0] == 0:
-            loss_rpn_reg = paddle.zeros([1], dtype='float32')
-        else:
-            loc_pred = paddle.gather(deltas, pos_ind)
-            loc_tgt = paddle.concat(loc_tgt)
-            loc_tgt = paddle.gather(loc_tgt, pos_ind)
-            loc_tgt.stop_gradient = True
-            loss_rpn_reg = paddle.abs(loc_pred - loc_tgt).sum()
-        return {
-            'loss_rpn_cls': loss_rpn_cls / norm,
-            'loss_rpn_reg': loss_rpn_reg / norm
-        }