示例#1
0
    def get_all_proposal(self, rois, bbox_pred, im_info):
        if self._proposal is not None:
            return self._proposal

        p = self.p
        stage = self.stage
        batch_image = p.batch_image
        bbox_mean = p.regress_target.mean
        bbox_std = p.regress_target.std
        num_class = p.num_class
        class_agnostic = p.regress_target.class_agnostic
        num_reg_class = 2 if class_agnostic else num_class

        bbox_pred = X.reshape(bbox_pred,
                              shape=(batch_image, -1, 4 * num_reg_class),
                              name='bbox_delta_reshape_' + stage)

        proposal = X.decode_bbox(rois=rois,
                                 bbox_pred=bbox_pred,
                                 im_info=im_info,
                                 name='decode_bbox_' + stage,
                                 bbox_mean=bbox_mean,
                                 bbox_std=bbox_std,
                                 class_agnostic=class_agnostic)

        # append None for dummy proposal score
        proposal = (proposal, None)

        self._proposal = proposal

        return proposal
示例#2
0
    def get_prediction(self, conv_feat, im_info, proposal):
        p = self.p
        bbox_mean = p.regress_target.mean
        bbox_std = p.regress_target.std
        batch_image = p.batch_image
        num_class = p.num_class
        class_agnostic = p.regress_target.class_agnostic
        num_reg_class = 2 if class_agnostic else num_class

        cls_logit, bbox_delta = self.get_output(conv_feat)

        bbox_delta = X.reshape(bbox_delta,
                               shape=(batch_image, -1, 4 * num_reg_class),
                               name='bbox_delta_reshape')

        bbox_xyxy = X.decode_bbox(rois=proposal,
                                  bbox_pred=bbox_delta,
                                  im_info=im_info,
                                  name='decode_bbox',
                                  bbox_mean=bbox_mean,
                                  bbox_std=bbox_std,
                                  class_agnostic=class_agnostic)
        cls_score = X.softmax(cls_logit, axis=-1, name='bbox_cls_score')
        cls_score = X.reshape(cls_score,
                              shape=(batch_image, -1, num_class),
                              name='bbox_cls_score_reshape')
        return cls_score, bbox_xyxy
示例#3
0
    def get_prediction(self,
                       rois,
                       roi_feat,
                       fpn_conv_feats,
                       im_info,
                       play=False):
        '''
        Args:
            rois: [batch_image, image_roi, 4]
            roi_feat: [batch_image * image_roi, 256, roi_size, roi_size]
            fpn_conv_feats: dict of FPN features, each [batch_image, in_channels, fh, fw]
            im_info: ...
        Returns:
            cls_score: [batch_image, image_roi, num_class]
            bbox_xyxy: [batch_image, image_roi, num_class*4]
        '''
        p = self.p
        assert not p.regress_target.class_agnostic

        bbox_mean = p.regress_target.mean
        bbox_std = p.regress_target.std
        batch_image = p.batch_image
        num_class = p.num_class
        class_agnostic = p.regress_target.class_agnostic
        num_reg_class = num_class

        assert batch_image == 1

        cls_logit, bbox_delta, tsd_cls_logit, tsd_bbox_delta, delta_c, delta_r = self.get_output(
            fpn_conv_feats, roi_feat, rois, is_train=False)
        rois_r = self._get_delta_r_box(delta_r, rois)

        bbox_xyxy = X.decode_bbox(
            rois=rois_r,
            bbox_pred=X.reshape(tsd_bbox_delta,
                                (batch_image, -1, 4 * num_reg_class)),
            im_info=im_info,
            name='decode_bbox',
            bbox_mean=bbox_mean,
            bbox_std=bbox_std,
            class_agnostic=False)
        cls_score = X.reshape(X.softmax(tsd_cls_logit,
                                        axis=-1,
                                        name='bbox_cls_score'),
                              shape=(batch_image, -1, num_class),
                              name='bbox_cls_score_reshape')

        if not play:
            return cls_score, bbox_xyxy
        else:
            return cls_score, bbox_xyxy, rois, rois_r
示例#4
0
    def get_prediction(self, conv_feat, im_info, proposal):
        p = self.p
        bbox_mean = p.regress_target.mean
        bbox_std = p.regress_target.std
        batch_image = p.batch_image
        num_class = p.num_class
        class_agnostic = p.regress_target.class_agnostic
        num_reg_class = 2 if class_agnostic else num_class

        cls_logit, bbox_delta, cls_sec_logit, bbox_sec_delta, roi_feature = self.get_output(
            conv_feat)
        if p.refine_mode:
            refine_cls_logit, refine_bbox_delta, refine_cls_sec_logit, refine_bbox_sec_delta = \
                                self.get_refine_output(roi_feature, cls_logit, bbox_delta, cls_sec_logit, bbox_sec_delta)
            bbox_delta = refine_bbox_delta
            bbox_sec_delta = refine_bbox_sec_delta
            cls_logit = refine_cls_logit
            cls_sec_logit = refine_cls_sec_logit

        bbox_delta = X.reshape(bbox_delta,
                               shape=(batch_image, -1, 4 * num_reg_class),
                               name='bbox_delta_reshape')
        bbox_sec_delta = X.reshape(
            bbox_sec_delta,
            shape=(batch_image, -1, 4 * num_reg_class),
            name='bbox_sec_delta_reshape',
        )

        bbox_xyxy = X.decode_bbox(rois=proposal,
                                  bbox_pred=bbox_delta,
                                  im_info=im_info,
                                  name='decode_bbox',
                                  bbox_mean=bbox_mean,
                                  bbox_std=bbox_std,
                                  class_agnostic=class_agnostic)

        bbox_sec_xyxy = X.decode_bbox(
            rois=proposal,
            bbox_pred=bbox_sec_delta,
            im_info=im_info,
            name='decode_bbox_sec',
            bbox_mean=bbox_mean,
            bbox_std=bbox_std,
            class_agnostic=class_agnostic,
        )

        # NOTE: avoid name conflicts(potential bug from X.decode_bbox?)
        bbox_sec_xyxy = bbox_sec_xyxy * mx.sym.ones_like(bbox_sec_xyxy)

        cls_score = X.softmax(cls_logit, axis=-1, name='bbox_cls_score')
        cls_score = X.reshape(cls_score,
                              shape=(batch_image, -1, num_class),
                              name='bbox_cls_score_reshape')
        cls_sec_score = X.softmax(
            cls_sec_logit,
            axis=-1,
            name='bbox_cls_sec_score',
        )
        cls_sec_score = X.reshape(cls_sec_score,
                                  shape=(batch_image, -1, num_class),
                                  name='bbox_cls_sec_score_reshape')
        return cls_score, bbox_xyxy, cls_sec_score, bbox_sec_xyxy