diff --git a/configs/fcos/_base_/fcos_r50_fpn.yml b/configs/fcos/_base_/fcos_r50_fpn.yml index cd22c229a1192ea384037848be1b7e6edc43741a..6ace6b51f17fcd9fc2015a549039b8919f312012 100644 --- a/configs/fcos/_base_/fcos_r50_fpn.yml +++ b/configs/fcos/_base_/fcos_r50_fpn.yml @@ -5,22 +5,21 @@ FCOS: backbone: ResNet neck: FPN fcos_head: FCOSHead - fcos_post_process: FCOSPostProcess ResNet: - # index 0 stands for res2 depth: 50 + variant: 'b' norm_type: bn - freeze_at: 0 - return_idx: [1,2,3] + freeze_at: 0 # res2 + return_idx: [1, 2, 3] num_stages: 4 FPN: out_channel: 256 spatial_scales: [0.125, 0.0625, 0.03125] extra_stage: 2 - has_extra_convs: true - use_c5: false + has_extra_convs: True + use_c5: False FCOSHead: fcos_feat: @@ -29,22 +28,18 @@ FCOSHead: feat_out: 256 num_convs: 4 norm_type: "gn" - use_dcn: false + use_dcn: False fpn_stride: [8, 16, 32, 64, 128] prior_prob: 0.01 - fcos_loss: FCOSLoss - norm_reg_targets: true - centerness_on_reg: true - -FCOSLoss: - loss_alpha: 0.25 - loss_gamma: 2.0 - iou_loss_type: "giou" - reg_weights: 1.0 - -FCOSPostProcess: - decode: - name: FCOSBox + norm_reg_targets: True + centerness_on_reg: True + num_shift: 0.5 + fcos_loss: + name: FCOSLoss + loss_alpha: 0.25 + loss_gamma: 2.0 + iou_loss_type: "giou" + reg_weights: 1.0 nms: name: MultiClassNMS nms_top_k: 1000 diff --git a/configs/fcos/_base_/fcos_reader.yml b/configs/fcos/_base_/fcos_reader.yml index 4aa343ad1779f7d3b9f950562fbcdf3aeaeb0b79..26f102602f505570330f01b974731d27a8ad7493 100644 --- a/configs/fcos/_base_/fcos_reader.yml +++ b/configs/fcos/_base_/fcos_reader.yml @@ -1,42 +1,41 @@ worker_num: 2 TrainReader: sample_transforms: - - Decode: {} - - RandomFlip: {prob: 0.5} - - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]} - - Resize: {target_size: [800, 1333], keep_ratio: true, interp: 1} - - Permute: {} + - Decode: {} + - Resize: {target_size: [800, 1333], keep_ratio: True, interp: 1} + - NormalizeImage: {mean: [0.485, 0.456, 0.406], std: [0.229, 0.224, 0.225], is_scale: True} + - RandomFlip: {} batch_transforms: - - PadBatch: {pad_to_stride: 128} - - Gt2FCOSTarget: - object_sizes_boundary: [64, 128, 256, 512] - center_sampling_radius: 1.5 - downsample_ratios: [8, 16, 32, 64, 128] - norm_reg_targets: True + - Permute: {} + - PadBatch: {pad_to_stride: 128} + - Gt2FCOSTarget: + object_sizes_boundary: [64, 128, 256, 512] + center_sampling_radius: 1.5 + downsample_ratios: [8, 16, 32, 64, 128] + norm_reg_targets: True batch_size: 2 - shuffle: true - drop_last: true + shuffle: True + drop_last: True EvalReader: sample_transforms: - - Decode: {} - - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]} - - Resize: {interp: 1, target_size: [800, 1333], keep_ratio: True} - - Permute: {} + - Decode: {} + - Resize: {target_size: [800, 1333], keep_ratio: True, interp: 1} + - NormalizeImage: {mean: [0.485, 0.456, 0.406], std: [0.229, 0.224, 0.225], is_scale: True} + - Permute: {} batch_transforms: - - PadBatch: {pad_to_stride: 128} + - PadBatch: {pad_to_stride: 128} batch_size: 1 - shuffle: false TestReader: sample_transforms: - - Decode: {} - - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]} - - Resize: {interp: 1, target_size: [800, 1333], keep_ratio: True} - - Permute: {} + - Decode: {} + - Resize: {target_size: [800, 1333], keep_ratio: True, interp: 1} + - NormalizeImage: {mean: [0.485, 0.456, 0.406], std: [0.229, 0.224, 0.225], is_scale: True} + - Permute: {} batch_transforms: - - PadBatch: {pad_to_stride: 128} + - PadBatch: {pad_to_stride: 128} batch_size: 1 - shuffle: false + fuse_normalize: True diff --git a/configs/fcos/fcos_dcn_r50_fpn_1x_coco.yml b/configs/fcos/fcos_dcn_r50_fpn_1x_coco.yml index fe454283fee96b7c047a481eff5695650b76715f..93ac2c0eb0dd7860259bf38549d3aa176b00cdc8 100644 --- a/configs/fcos/fcos_dcn_r50_fpn_1x_coco.yml +++ b/configs/fcos/fcos_dcn_r50_fpn_1x_coco.yml @@ -9,24 +9,8 @@ _BASE_: [ weights: output/fcos_dcn_r50_fpn_1x_coco/model_final ResNet: - depth: 50 - norm_type: bn - freeze_at: 0 - return_idx: [1,2,3] - num_stages: 4 - dcn_v2_stages: [1,2,3] + dcn_v2_stages: [1, 2, 3] FCOSHead: fcos_feat: - name: FCOSFeat - feat_in: 256 - feat_out: 256 - num_convs: 4 - norm_type: "gn" - use_dcn: true - num_classes: 80 - fpn_stride: [8, 16, 32, 64, 128] - prior_prob: 0.01 - fcos_loss: FCOSLoss - norm_reg_targets: true - centerness_on_reg: true + use_dcn: True diff --git a/configs/fcos/fcos_r50_fpn_multiscale_2x_coco.yml b/configs/fcos/fcos_r50_fpn_multiscale_2x_coco.yml index 291f8d8e98b3fe618c12382e7de899280605caf3..a0fdb09766a44cbc82667cda054f8270da2764b7 100644 --- a/configs/fcos/fcos_r50_fpn_multiscale_2x_coco.yml +++ b/configs/fcos/fcos_r50_fpn_multiscale_2x_coco.yml @@ -10,21 +10,21 @@ weights: output/fcos_r50_fpn_multiscale_2x_coco/model_final TrainReader: sample_transforms: - - Decode: {} - - RandomFlip: {prob: 0.5} - - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]} - - RandomResize: {target_size: [[640, 1333], [672, 1333], [704, 1333], [736, 1333], [768, 1333], [800, 1333]], keep_ratio: true, interp: 1} - - Permute: {} + - Decode: {} + - RandomResize: {target_size: [[640, 1333], [672, 1333], [704, 1333], [736, 1333], [768, 1333], [800, 1333]], keep_ratio: True, interp: 1} + - NormalizeImage: {mean: [0.485, 0.456, 0.406], std: [0.229, 0.224, 0.225], is_scale: True} + - RandomFlip: {} batch_transforms: - - PadBatch: {pad_to_stride: 128} - - Gt2FCOSTarget: - object_sizes_boundary: [64, 128, 256, 512] - center_sampling_radius: 1.5 - downsample_ratios: [8, 16, 32, 64, 128] - norm_reg_targets: True + - Permute: {} + - PadBatch: {pad_to_stride: 128} + - Gt2FCOSTarget: + object_sizes_boundary: [64, 128, 256, 512] + center_sampling_radius: 1.5 + downsample_ratios: [8, 16, 32, 64, 128] + norm_reg_targets: True batch_size: 2 - shuffle: true - drop_last: true + shuffle: True + drop_last: True epoch: 24 diff --git a/ppdet/modeling/architectures/fcos.py b/ppdet/modeling/architectures/fcos.py index 8fa5c569b72c3618f029d1307556504bf5c5e519..28cb7062c35f902efea5260389ccac4fdcef7863 100644 --- a/ppdet/modeling/architectures/fcos.py +++ b/ppdet/modeling/architectures/fcos.py @@ -32,22 +32,15 @@ class FCOS(BaseArch): backbone (object): backbone instance neck (object): 'FPN' instance fcos_head (object): 'FCOSHead' instance - post_process (object): 'FCOSPostProcess' instance """ __category__ = 'architecture' - __inject__ = ['fcos_post_process'] - def __init__(self, - backbone, - neck, - fcos_head='FCOSHead', - fcos_post_process='FCOSPostProcess'): + def __init__(self, backbone, neck='FPN', fcos_head='FCOSHead'): super(FCOS, self).__init__() self.backbone = backbone self.neck = neck self.fcos_head = fcos_head - self.fcos_post_process = fcos_post_process @classmethod def from_config(cls, cfg, *args, **kwargs): @@ -68,38 +61,18 @@ class FCOS(BaseArch): def _forward(self): body_feats = self.backbone(self.inputs) fpn_feats = self.neck(body_feats) - fcos_head_outs = self.fcos_head(fpn_feats, self.training) - if not self.training: - scale_factor = self.inputs['scale_factor'] - bboxes = self.fcos_post_process(fcos_head_outs, scale_factor) - return bboxes + + if self.training: + losses = self.fcos_head(fpn_feats, self.inputs) + return losses else: - return fcos_head_outs - - def get_loss(self, ): - loss = {} - tag_labels, tag_bboxes, tag_centerness = [], [], [] - for i in range(len(self.fcos_head.fpn_stride)): - # labels, reg_target, centerness - k_lbl = 'labels{}'.format(i) - if k_lbl in self.inputs: - tag_labels.append(self.inputs[k_lbl]) - k_box = 'reg_target{}'.format(i) - if k_box in self.inputs: - tag_bboxes.append(self.inputs[k_box]) - k_ctn = 'centerness{}'.format(i) - if k_ctn in self.inputs: - tag_centerness.append(self.inputs[k_ctn]) - - fcos_head_outs = self._forward() - loss_fcos = self.fcos_head.get_loss(fcos_head_outs, tag_labels, - tag_bboxes, tag_centerness) - loss.update(loss_fcos) - total_loss = paddle.add_n(list(loss.values())) - loss.update({'loss': total_loss}) - return loss + fcos_head_outs = self.fcos_head(fpn_feats) + bbox_pred, bbox_num = self.fcos_head.post_process( + fcos_head_outs, self.inputs['scale_factor']) + return {'bbox': bbox_pred, 'bbox_num': bbox_num} + + 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 + return self._forward() diff --git a/ppdet/modeling/heads/fcos_head.py b/ppdet/modeling/heads/fcos_head.py index 758b1bf8b3335d89f2d34bacf95405f2891f3b93..5c22244eed4525ee97e08864cf93f7d1ed519e66 100644 --- a/ppdet/modeling/heads/fcos_head.py +++ b/ppdet/modeling/heads/fcos_head.py @@ -24,7 +24,9 @@ from paddle import ParamAttr from paddle.nn.initializer import Normal, Constant from ppdet.core.workspace import register -from ppdet.modeling.layers import ConvNormLayer +from ppdet.modeling.layers import ConvNormLayer, MultiClassNMS + +__all__ = ['FCOSFeat', 'FCOSHead'] class ScaleReg(nn.Layer): @@ -115,25 +117,31 @@ class FCOSHead(nn.Layer): """ FCOSHead Args: - fcos_feat (object): Instance of 'FCOSFeat' num_classes (int): Number of classes + fcos_feat (object): Instance of 'FCOSFeat' fpn_stride (list): The stride of each FPN Layer prior_prob (float): Used to set the bias init for the class prediction layer - fcos_loss (object): Instance of 'FCOSLoss' norm_reg_targets (bool): Normalization the regression target if true centerness_on_reg (bool): The prediction of centerness on regression or clssification branch + num_shift (float): Relative offset between the center of the first shift and the top-left corner of img + fcos_loss (object): Instance of 'FCOSLoss' + nms (object): Instance of 'MultiClassNMS' + trt (bool): Whether to use trt in nms of deploy """ - __inject__ = ['fcos_feat', 'fcos_loss'] - __shared__ = ['num_classes'] + __inject__ = ['fcos_feat', 'fcos_loss', 'nms'] + __shared__ = ['num_classes', 'trt'] def __init__(self, - fcos_feat, num_classes=80, + fcos_feat='FCOSFeat', fpn_stride=[8, 16, 32, 64, 128], prior_prob=0.01, - fcos_loss='FCOSLoss', norm_reg_targets=True, - centerness_on_reg=True): + centerness_on_reg=True, + num_shift=0.5, + fcos_loss='FCOSLoss', + nms='MultiClassNMS', + trt=False): super(FCOSHead, self).__init__() self.fcos_feat = fcos_feat self.num_classes = num_classes @@ -142,6 +150,10 @@ class FCOSHead(nn.Layer): self.fcos_loss = fcos_loss self.norm_reg_targets = norm_reg_targets self.centerness_on_reg = centerness_on_reg + self.num_shift = num_shift + self.nms = nms + if isinstance(self.nms, MultiClassNMS) and trt: + self.nms.trt = trt conv_cls_name = "fcos_head_cls" bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob) @@ -191,7 +203,7 @@ class FCOSHead(nn.Layer): scale_reg = self.add_sublayer(feat_name, ScaleReg()) self.scales_regs.append(scale_reg) - def _compute_locations_by_level(self, fpn_stride, feature): + def _compute_locations_by_level(self, fpn_stride, feature, num_shift=0.5): """ Compute locations of anchor points of each FPN layer Args: @@ -200,25 +212,21 @@ class FCOSHead(nn.Layer): Return: Anchor points locations of current FPN feature map """ - shape_fm = paddle.shape(feature) - shape_fm.stop_gradient = True - h, w = shape_fm[2], shape_fm[3] + h, w = feature.shape[2], feature.shape[3] shift_x = paddle.arange(0, w * fpn_stride, fpn_stride) shift_y = paddle.arange(0, h * fpn_stride, fpn_stride) shift_x = paddle.unsqueeze(shift_x, axis=0) shift_y = paddle.unsqueeze(shift_y, axis=1) shift_x = paddle.expand(shift_x, shape=[h, w]) shift_y = paddle.expand(shift_y, shape=[h, w]) - shift_x.stop_gradient = True - shift_y.stop_gradient = True + shift_x = paddle.reshape(shift_x, shape=[-1]) shift_y = paddle.reshape(shift_y, shape=[-1]) location = paddle.stack( - [shift_x, shift_y], axis=-1) + float(fpn_stride) / 2 - location.stop_gradient = True + [shift_x, shift_y], axis=-1) + float(fpn_stride * num_shift) return location - def forward(self, fpn_feats, is_training): + def forward(self, fpn_feats, targets=None): assert len(fpn_feats) == len( self.fpn_stride ), "The size of fpn_feats is not equal to size of fpn_stride" @@ -236,7 +244,8 @@ class FCOSHead(nn.Layer): centerness = self.fcos_head_centerness(fcos_cls_feat) if self.norm_reg_targets: bbox_reg = F.relu(bbox_reg) - if not is_training: + if not self.training: + # eval or infer bbox_reg = bbox_reg * fpn_stride else: bbox_reg = paddle.exp(bbox_reg) @@ -244,17 +253,85 @@ class FCOSHead(nn.Layer): bboxes_reg_list.append(bbox_reg) centerness_list.append(centerness) - if not is_training: + if self.training: + losses = {} + fcos_head_outs = [cls_logits_list, bboxes_reg_list, centerness_list] + losses_fcos = self.get_loss(fcos_head_outs, targets) + losses.update(losses_fcos) + + total_loss = paddle.add_n(list(losses.values())) + losses.update({'loss': total_loss}) + return losses + else: + # eval or infer locations_list = [] for fpn_stride, feature in zip(self.fpn_stride, fpn_feats): - location = self._compute_locations_by_level(fpn_stride, feature) + location = self._compute_locations_by_level(fpn_stride, feature, + self.num_shift) locations_list.append(location) - return locations_list, cls_logits_list, bboxes_reg_list, centerness_list - else: - return cls_logits_list, bboxes_reg_list, centerness_list + fcos_head_outs = [ + locations_list, cls_logits_list, bboxes_reg_list, + centerness_list + ] + return fcos_head_outs - def get_loss(self, fcos_head_outs, tag_labels, tag_bboxes, tag_centerness): + def get_loss(self, fcos_head_outs, targets): cls_logits, bboxes_reg, centerness = fcos_head_outs - return self.fcos_loss(cls_logits, bboxes_reg, centerness, tag_labels, - tag_bboxes, tag_centerness) + + # get labels,reg_target,centerness + tag_labels, tag_bboxes, tag_centerness = [], [], [] + for i in range(len(self.fpn_stride)): + k_lbl = 'labels{}'.format(i) + if k_lbl in targets: + tag_labels.append(targets[k_lbl]) + k_box = 'reg_target{}'.format(i) + if k_box in targets: + tag_bboxes.append(targets[k_box]) + k_ctn = 'centerness{}'.format(i) + if k_ctn in targets: + tag_centerness.append(targets[k_ctn]) + + losses_fcos = self.fcos_loss(cls_logits, bboxes_reg, centerness, + tag_labels, tag_bboxes, tag_centerness) + return losses_fcos + + def _post_process_by_level(self, locations, box_cls, box_reg, box_ctn): + box_scores = F.sigmoid(box_cls).flatten(2).transpose([0, 2, 1]) + box_centerness = F.sigmoid(box_ctn).flatten(2).transpose([0, 2, 1]) + pred_scores = box_scores * box_centerness + + box_reg_ch_last = box_reg.flatten(2).transpose([0, 2, 1]) + box_reg_decoding = paddle.stack( + [ + locations[:, 0] - box_reg_ch_last[:, :, 0], + locations[:, 1] - box_reg_ch_last[:, :, 1], + locations[:, 0] + box_reg_ch_last[:, :, 2], + locations[:, 1] + box_reg_ch_last[:, :, 3] + ], + axis=1) + pred_boxes = box_reg_decoding.transpose([0, 2, 1]) + + return pred_scores, pred_boxes + + def post_process(self, fcos_head_outs, scale_factor): + locations, cls_logits, bboxes_reg, centerness = fcos_head_outs + pred_bboxes, pred_scores = [], [] + + for pts, cls, reg, ctn in zip(locations, cls_logits, bboxes_reg, + centerness): + scores, boxes = self._post_process_by_level(pts, cls, reg, ctn) + pred_scores.append(scores) + pred_bboxes.append(boxes) + pred_bboxes = paddle.concat(pred_bboxes, axis=1) + pred_scores = paddle.concat(pred_scores, axis=1) + + # scale bbox to origin + scale_y, scale_x = paddle.split(scale_factor, 2, axis=-1) + scale_factor = paddle.concat( + [scale_x, scale_y, scale_x, scale_y], axis=-1).reshape([-1, 1, 4]) + pred_bboxes /= scale_factor + + pred_scores = pred_scores.transpose([0, 2, 1]) + bbox_pred, bbox_num, _ = self.nms(pred_bboxes, pred_scores) + return bbox_pred, bbox_num diff --git a/ppdet/modeling/layers.py b/ppdet/modeling/layers.py index a3253df77485ae1aafec6cfc047db642a0067629..388be3cc9b93f46cdfb00bf942bf43e8fcfa79fd 100644 --- a/ppdet/modeling/layers.py +++ b/ppdet/modeling/layers.py @@ -703,98 +703,6 @@ class SSDBox(object): return output_boxes, output_scores -@register -@serializable -class FCOSBox(object): - __shared__ = ['num_classes'] - - def __init__(self, num_classes=80): - super(FCOSBox, self).__init__() - self.num_classes = num_classes - - def _merge_hw(self, inputs, ch_type="channel_first"): - """ - Merge h and w of the feature map into one dimension. - Args: - inputs (Tensor): Tensor of the input feature map - ch_type (str): "channel_first" or "channel_last" style - Return: - new_shape (Tensor): The new shape after h and w merged - """ - shape_ = paddle.shape(inputs) - bs, ch, hi, wi = shape_[0], shape_[1], shape_[2], shape_[3] - img_size = hi * wi - img_size.stop_gradient = True - if ch_type == "channel_first": - new_shape = paddle.concat([bs, ch, img_size]) - elif ch_type == "channel_last": - new_shape = paddle.concat([bs, img_size, ch]) - else: - raise KeyError("Wrong ch_type %s" % ch_type) - new_shape.stop_gradient = True - return new_shape - - def _postprocessing_by_level(self, locations, box_cls, box_reg, box_ctn, - scale_factor): - """ - Postprocess each layer of the output with corresponding locations. - Args: - locations (Tensor): anchor points for current layer, [H*W, 2] - box_cls (Tensor): categories prediction, [N, C, H, W], - C is the number of classes - box_reg (Tensor): bounding box prediction, [N, 4, H, W] - box_ctn (Tensor): centerness prediction, [N, 1, H, W] - scale_factor (Tensor): [h_scale, w_scale] for input images - Return: - box_cls_ch_last (Tensor): score for each category, in [N, C, M] - C is the number of classes and M is the number of anchor points - box_reg_decoding (Tensor): decoded bounding box, in [N, M, 4] - last dimension is [x1, y1, x2, y2] - """ - act_shape_cls = self._merge_hw(box_cls) - box_cls_ch_last = paddle.reshape(x=box_cls, shape=act_shape_cls) - box_cls_ch_last = F.sigmoid(box_cls_ch_last) - - act_shape_reg = self._merge_hw(box_reg) - box_reg_ch_last = paddle.reshape(x=box_reg, shape=act_shape_reg) - box_reg_ch_last = paddle.transpose(box_reg_ch_last, perm=[0, 2, 1]) - box_reg_decoding = paddle.stack( - [ - locations[:, 0] - box_reg_ch_last[:, :, 0], - locations[:, 1] - box_reg_ch_last[:, :, 1], - locations[:, 0] + box_reg_ch_last[:, :, 2], - locations[:, 1] + box_reg_ch_last[:, :, 3] - ], - axis=1) - box_reg_decoding = paddle.transpose(box_reg_decoding, perm=[0, 2, 1]) - - act_shape_ctn = self._merge_hw(box_ctn) - box_ctn_ch_last = paddle.reshape(x=box_ctn, shape=act_shape_ctn) - box_ctn_ch_last = F.sigmoid(box_ctn_ch_last) - - # recover the location to original image - im_scale = paddle.concat([scale_factor, scale_factor], axis=1) - im_scale = paddle.expand(im_scale, [box_reg_decoding.shape[0], 4]) - im_scale = paddle.reshape(im_scale, [box_reg_decoding.shape[0], -1, 4]) - box_reg_decoding = box_reg_decoding / im_scale - box_cls_ch_last = box_cls_ch_last * box_ctn_ch_last - return box_cls_ch_last, box_reg_decoding - - def __call__(self, locations, cls_logits, bboxes_reg, centerness, - scale_factor): - pred_boxes_ = [] - pred_scores_ = [] - for pts, cls, box, ctn in zip(locations, cls_logits, bboxes_reg, - centerness): - pred_scores_lvl, pred_boxes_lvl = self._postprocessing_by_level( - pts, cls, box, ctn, scale_factor) - pred_boxes_.append(pred_boxes_lvl) - pred_scores_.append(pred_scores_lvl) - pred_boxes = paddle.concat(pred_boxes_, axis=1) - pred_scores = paddle.concat(pred_scores_, axis=2) - return pred_boxes, pred_scores - - @register class TTFBox(object): __shared__ = ['down_ratio'] diff --git a/ppdet/modeling/post_process.py b/ppdet/modeling/post_process.py index 09b26feec14da1ac00049c9ac5ed24080ac36dc9..46b949574d3f632245ebbf279f286a38ad1d708f 100644 --- a/ppdet/modeling/post_process.py +++ b/ppdet/modeling/post_process.py @@ -26,9 +26,8 @@ except Exception: from collections import Sequence __all__ = [ - 'BBoxPostProcess', 'MaskPostProcess', 'FCOSPostProcess', - 'JDEBBoxPostProcess', 'CenterNetPostProcess', 'DETRBBoxPostProcess', - 'SparsePostProcess' + 'BBoxPostProcess', 'MaskPostProcess', 'JDEBBoxPostProcess', + 'CenterNetPostProcess', 'DETRBBoxPostProcess', 'SparsePostProcess' ] @@ -37,8 +36,12 @@ class BBoxPostProcess(object): __shared__ = ['num_classes', 'export_onnx', 'export_eb'] __inject__ = ['decode', 'nms'] - def __init__(self, num_classes=80, decode=None, nms=None, - export_onnx=False, export_eb=False): + def __init__(self, + num_classes=80, + decode=None, + nms=None, + export_onnx=False, + export_eb=False): super(BBoxPostProcess, self).__init__() self.num_classes = num_classes self.decode = decode @@ -279,26 +282,6 @@ class MaskPostProcess(object): return pred_result -@register -class FCOSPostProcess(object): - __inject__ = ['decode', 'nms'] - - def __init__(self, decode=None, nms=None): - super(FCOSPostProcess, self).__init__() - self.decode = decode - self.nms = nms - - def __call__(self, fcos_head_outs, scale_factor): - """ - Decode the bbox and do NMS in FCOS. - """ - locations, cls_logits, bboxes_reg, centerness = fcos_head_outs - bboxes, score = self.decode(locations, cls_logits, bboxes_reg, - centerness, scale_factor) - bbox_pred, bbox_num, _ = self.nms(bboxes, score) - return bbox_pred, bbox_num - - @register class JDEBBoxPostProcess(nn.Layer): __shared__ = ['num_classes']