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

paddlex/ppdet/modeling/losses/__init__.py

@@ -1,43 +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 . import yolo_loss
-from . import iou_aware_loss
-from . import iou_loss
-from . import ssd_loss
-from . import fcos_loss
-from . import solov2_loss
-from . import ctfocal_loss
-from . import keypoint_loss
-from . import jde_loss
-from . import fairmot_loss
-from . import gfocal_loss
-from . import detr_loss
-from . import sparsercnn_loss
-from . import varifocal_loss
-
-from .yolo_loss import *
-from .iou_aware_loss import *
-from .iou_loss import *
-from .ssd_loss import *
-from .fcos_loss import *
-from .solov2_loss import *
-from .ctfocal_loss import *
-from .keypoint_loss import *
-from .jde_loss import *
-from .fairmot_loss import *
-from .gfocal_loss import *
-from .detr_loss import *
-from .sparsercnn_loss import *
-from .varifocal_loss import VarifocalLoss

paddlex/ppdet/modeling/losses/ctfocal_loss.py

@@ -1,68 +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, serializable
-
-__all__ = ['CTFocalLoss']
-
-
-@register
-@serializable
-class CTFocalLoss(object):
-    """
-    CTFocalLoss: CornerNet & CenterNet Focal Loss
-    Args:
-        loss_weight (float): loss weight
-        gamma (float): gamma parameter for Focal Loss
-    """
-
-    def __init__(self, loss_weight=1., gamma=2.0):
-        self.loss_weight = loss_weight
-        self.gamma = gamma
-
-    def __call__(self, pred, target):
-        """
-        Calculate the loss
-        Args:
-            pred (Tensor): heatmap prediction
-            target (Tensor): target for positive samples
-        Return:
-            ct_focal_loss (Tensor): Focal Loss used in CornerNet & CenterNet.
-                Note that the values in target are in [0, 1] since gaussian is
-                used to reduce the punishment and we treat [0, 1) as neg example.
-        """
-        fg_map = paddle.cast(target == 1, 'float32')
-        fg_map.stop_gradient = True
-        bg_map = paddle.cast(target < 1, 'float32')
-        bg_map.stop_gradient = True
-
-        neg_weights = paddle.pow(1 - target, 4)
-        pos_loss = 0 - paddle.log(pred) * paddle.pow(1 - pred,
-                                                     self.gamma) * fg_map
-
-        neg_loss = 0 - paddle.log(1 - pred) * paddle.pow(
-            pred, self.gamma) * neg_weights * bg_map
-        pos_loss = paddle.sum(pos_loss)
-        neg_loss = paddle.sum(neg_loss)
-
-        fg_num = paddle.sum(fg_map)
-        ct_focal_loss = (pos_loss + neg_loss) / (
-            fg_num + paddle.cast(fg_num == 0, 'float32'))
-        return ct_focal_loss * self.loss_weight

paddlex/ppdet/modeling/losses/detr_loss.py

@@ -1,233 +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
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register
-from .iou_loss import GIoULoss
-from ..transformers import bbox_cxcywh_to_xyxy, sigmoid_focal_loss
-
-__all__ = ['DETRLoss']
-
-
-@register
-class DETRLoss(nn.Layer):
-    __shared__ = ['num_classes', 'use_focal_loss']
-    __inject__ = ['matcher']
-
-    def __init__(self,
-                 num_classes=80,
-                 matcher='HungarianMatcher',
-                 loss_coeff={
-                     'class': 1,
-                     'bbox': 5,
-                     'giou': 2,
-                     'no_object': 0.1,
-                     'mask': 1,
-                     'dice': 1
-                 },
-                 aux_loss=True,
-                 use_focal_loss=False):
-        r"""
-        Args:
-            num_classes (int): The number of classes.
-            matcher (HungarianMatcher): It computes an assignment between the targets
-                and the predictions of the network.
-            loss_coeff (dict): The coefficient of loss.
-            aux_loss (bool): If 'aux_loss = True', loss at each decoder layer are to be used.
-            use_focal_loss (bool): Use focal loss or not.
-        """
-        super(DETRLoss, self).__init__()
-        self.num_classes = num_classes
-
-        self.matcher = matcher
-        self.loss_coeff = loss_coeff
-        self.aux_loss = aux_loss
-        self.use_focal_loss = use_focal_loss
-
-        if not self.use_focal_loss:
-            self.loss_coeff['class'] = paddle.full([num_classes + 1],
-                                                   loss_coeff['class'])
-            self.loss_coeff['class'][-1] = loss_coeff['no_object']
-        self.giou_loss = GIoULoss()
-
-    def _get_loss_class(self, logits, gt_class, match_indices, bg_index,
-                        num_gts):
-        # logits: [b, query, num_classes], gt_class: list[[n, 1]]
-        target_label = paddle.full(logits.shape[:2], bg_index, dtype='int64')
-        bs, num_query_objects = target_label.shape
-        if sum(len(a) for a in gt_class) > 0:
-            index, updates = self._get_index_updates(num_query_objects,
-                                                     gt_class, match_indices)
-            target_label = paddle.scatter(
-                target_label.reshape([-1, 1]), index, updates.astype('int64'))
-            target_label = target_label.reshape([bs, num_query_objects])
-        if self.use_focal_loss:
-            target_label = F.one_hot(target_label,
-                                     self.num_classes + 1)[:, :, :-1]
-        return {
-            'loss_class': self.loss_coeff['class'] * sigmoid_focal_loss(
-                logits, target_label, num_gts / num_query_objects)
-            if self.use_focal_loss else F.cross_entropy(
-                logits, target_label, weight=self.loss_coeff['class'])
-        }
-
-    def _get_loss_bbox(self, boxes, gt_bbox, match_indices, num_gts):
-        # boxes: [b, query, 4], gt_bbox: list[[n, 4]]
-        loss = dict()
-        if sum(len(a) for a in gt_bbox) == 0:
-            loss['loss_bbox'] = paddle.to_tensor([0.])
-            loss['loss_giou'] = paddle.to_tensor([0.])
-            return loss
-
-        src_bbox, target_bbox = self._get_src_target_assign(boxes, gt_bbox,
-                                                            match_indices)
-        loss['loss_bbox'] = self.loss_coeff['bbox'] * F.l1_loss(
-            src_bbox, target_bbox, reduction='sum') / num_gts
-        loss['loss_giou'] = self.giou_loss(
-            bbox_cxcywh_to_xyxy(src_bbox), bbox_cxcywh_to_xyxy(target_bbox))
-        loss['loss_giou'] = loss['loss_giou'].sum() / num_gts
-        loss['loss_giou'] = self.loss_coeff['giou'] * loss['loss_giou']
-        return loss
-
-    def _get_loss_mask(self, masks, gt_mask, match_indices, num_gts):
-        # masks: [b, query, h, w], gt_mask: list[[n, H, W]]
-        loss = dict()
-        if sum(len(a) for a in gt_mask) == 0:
-            loss['loss_mask'] = paddle.to_tensor([0.])
-            loss['loss_dice'] = paddle.to_tensor([0.])
-            return loss
-
-        src_masks, target_masks = self._get_src_target_assign(masks, gt_mask,
-                                                              match_indices)
-        src_masks = F.interpolate(
-            src_masks.unsqueeze(0),
-            size=target_masks.shape[-2:],
-            mode="bilinear")[0]
-        loss['loss_mask'] = self.loss_coeff['mask'] * F.sigmoid_focal_loss(
-            src_masks,
-            target_masks,
-            paddle.to_tensor(
-                [num_gts], dtype='float32'))
-        loss['loss_dice'] = self.loss_coeff['dice'] * self._dice_loss(
-            src_masks, target_masks, num_gts)
-        return loss
-
-    def _dice_loss(self, inputs, targets, num_gts):
-        inputs = F.sigmoid(inputs)
-        inputs = inputs.flatten(1)
-        targets = targets.flatten(1)
-        numerator = 2 * (inputs * targets).sum(1)
-        denominator = inputs.sum(-1) + targets.sum(-1)
-        loss = 1 - (numerator + 1) / (denominator + 1)
-        return loss.sum() / num_gts
-
-    def _get_loss_aux(self, boxes, logits, gt_bbox, gt_class, bg_index,
-                      num_gts):
-        loss_class = []
-        loss_bbox = []
-        loss_giou = []
-        for aux_boxes, aux_logits in zip(boxes, logits):
-            match_indices = self.matcher(aux_boxes, aux_logits, gt_bbox,
-                                         gt_class)
-            loss_class.append(
-                self._get_loss_class(aux_logits, gt_class, match_indices,
-                                     bg_index, num_gts)['loss_class'])
-            loss_ = self._get_loss_bbox(aux_boxes, gt_bbox, match_indices,
-                                        num_gts)
-            loss_bbox.append(loss_['loss_bbox'])
-            loss_giou.append(loss_['loss_giou'])
-        loss = {
-            'loss_class_aux': paddle.add_n(loss_class),
-            'loss_bbox_aux': paddle.add_n(loss_bbox),
-            'loss_giou_aux': paddle.add_n(loss_giou)
-        }
-        return loss
-
-    def _get_index_updates(self, num_query_objects, target, match_indices):
-        batch_idx = paddle.concat([
-            paddle.full_like(src, i)
-            for i, (src, _) in enumerate(match_indices)
-        ])
-        src_idx = paddle.concat([src for (src, _) in match_indices])
-        src_idx += (batch_idx * num_query_objects)
-        target_assign = paddle.concat([
-            paddle.gather(
-                t, dst, axis=0) for t, (_, dst) in zip(target, match_indices)
-        ])
-        return src_idx, target_assign
-
-    def _get_src_target_assign(self, src, target, match_indices):
-        src_assign = paddle.concat([
-            paddle.gather(
-                t, I, axis=0)
-            if len(I) > 0 else paddle.zeros([0, t.shape[-1]])
-            for t, (I, _) in zip(src, match_indices)
-        ])
-        target_assign = paddle.concat([
-            paddle.gather(
-                t, J, axis=0)
-            if len(J) > 0 else paddle.zeros([0, t.shape[-1]])
-            for t, (_, J) in zip(target, match_indices)
-        ])
-        return src_assign, target_assign
-
-    def forward(self,
-                boxes,
-                logits,
-                gt_bbox,
-                gt_class,
-                masks=None,
-                gt_mask=None):
-        r"""
-        Args:
-            boxes (Tensor): [l, b, query, 4]
-            logits (Tensor): [l, b, query, num_classes]
-            gt_bbox (List(Tensor)): list[[n, 4]]
-            gt_class (List(Tensor)): list[[n, 1]]
-            masks (Tensor, optional): [b, query, h, w]
-            gt_mask (List(Tensor), optional): list[[n, H, W]]
-        """
-        match_indices = self.matcher(boxes[-1].detach(), logits[-1].detach(),
-                                     gt_bbox, gt_class)
-        num_gts = sum(len(a) for a in gt_bbox)
-        try:
-            # TODO: Paddle does not have a "paddle.distributed.is_initialized()"
-            num_gts = paddle.to_tensor([num_gts], dtype=paddle.float32)
-            paddle.distributed.all_reduce(num_gts)
-            num_gts = paddle.clip(
-                num_gts / paddle.distributed.get_world_size(), min=1).item()
-        except:
-            num_gts = max(num_gts.item(), 1)
-        total_loss = dict()
-        total_loss.update(
-            self._get_loss_class(logits[-1], gt_class, match_indices,
-                                 self.num_classes, num_gts))
-        total_loss.update(
-            self._get_loss_bbox(boxes[-1], gt_bbox, match_indices, num_gts))
-        if masks is not None and gt_mask is not None:
-            total_loss.update(
-                self._get_loss_mask(masks, gt_mask, match_indices, num_gts))
-
-        if self.aux_loss:
-            total_loss.update(
-                self._get_loss_aux(boxes[:-1], logits[:-1], gt_bbox, gt_class,
-                                   self.num_classes, num_gts))
-
-        return total_loss

paddlex/ppdet/modeling/losses/fairmot_loss.py

@@ -1,41 +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
-import paddle.nn as nn
-from paddle.nn.initializer import Constant
-from paddlex.ppdet.core.workspace import register
-
-__all__ = ['FairMOTLoss']
-
-
-@register
-class FairMOTLoss(nn.Layer):
-    def __init__(self):
-        super(FairMOTLoss, self).__init__()
-        self.det_weight = self.create_parameter(
-            shape=[1], default_initializer=Constant(-1.85))
-        self.reid_weight = self.create_parameter(
-            shape=[1], default_initializer=Constant(-1.05))
-
-    def forward(self, det_loss, reid_loss):
-        loss = paddle.exp(-self.det_weight) * det_loss + paddle.exp(
-            -self.reid_weight) * reid_loss + (self.det_weight +
-                                              self.reid_weight)
-        loss *= 0.5
-        return {'loss': loss}

paddlex/ppdet/modeling/losses/fcos_loss.py

@@ -1,225 +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
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling import ops
-
-__all__ = ['FCOSLoss']
-
-
-def flatten_tensor(inputs, channel_first=False):
-    """
-    Flatten a Tensor
-    Args:
-        inputs (Tensor): 4-D Tensor with shape [N, C, H, W] or [N, H, W, C]
-        channel_first (bool): If true the dimension order of Tensor is
-            [N, C, H, W], otherwise is [N, H, W, C]
-    Return:
-        output_channel_last (Tensor): The flattened Tensor in channel_last style
-    """
-    if channel_first:
-        input_channel_last = paddle.transpose(inputs, perm=[0, 2, 3, 1])
-    else:
-        input_channel_last = inputs
-    output_channel_last = paddle.flatten(
-        input_channel_last, start_axis=0, stop_axis=2)
-    return output_channel_last
-
-
-@register
-class FCOSLoss(nn.Layer):
-    """
-    FCOSLoss
-    Args:
-        loss_alpha (float): alpha in focal loss
-        loss_gamma (float): gamma in focal loss
-        iou_loss_type (str): location loss type, IoU/GIoU/LINEAR_IoU
-        reg_weights (float): weight for location loss
-    """
-
-    def __init__(self,
-                 loss_alpha=0.25,
-                 loss_gamma=2.0,
-                 iou_loss_type="giou",
-                 reg_weights=1.0):
-        super(FCOSLoss, self).__init__()
-        self.loss_alpha = loss_alpha
-        self.loss_gamma = loss_gamma
-        self.iou_loss_type = iou_loss_type
-        self.reg_weights = reg_weights
-
-    def __iou_loss(self, pred, targets, positive_mask, weights=None):
-        """
-        Calculate the loss for location prediction
-        Args:
-            pred (Tensor): bounding boxes prediction
-            targets (Tensor): targets for positive samples
-            positive_mask (Tensor): mask of positive samples
-            weights (Tensor): weights for each positive samples
-        Return:
-            loss (Tensor): location loss
-        """
-        plw = pred[:, 0] * positive_mask
-        pth = pred[:, 1] * positive_mask
-        prw = pred[:, 2] * positive_mask
-        pbh = pred[:, 3] * positive_mask
-
-        tlw = targets[:, 0] * positive_mask
-        tth = targets[:, 1] * positive_mask
-        trw = targets[:, 2] * positive_mask
-        tbh = targets[:, 3] * positive_mask
-        tlw.stop_gradient = True
-        trw.stop_gradient = True
-        tth.stop_gradient = True
-        tbh.stop_gradient = True
-
-        ilw = paddle.minimum(plw, tlw)
-        irw = paddle.minimum(prw, trw)
-        ith = paddle.minimum(pth, tth)
-        ibh = paddle.minimum(pbh, tbh)
-
-        clw = paddle.maximum(plw, tlw)
-        crw = paddle.maximum(prw, trw)
-        cth = paddle.maximum(pth, tth)
-        cbh = paddle.maximum(pbh, tbh)
-
-        area_predict = (plw + prw) * (pth + pbh)
-        area_target = (tlw + trw) * (tth + tbh)
-        area_inter = (ilw + irw) * (ith + ibh)
-        ious = (area_inter + 1.0) / (
-            area_predict + area_target - area_inter + 1.0)
-        ious = ious * positive_mask
-
-        if self.iou_loss_type.lower() == "linear_iou":
-            loss = 1.0 - ious
-        elif self.iou_loss_type.lower() == "giou":
-            area_uniou = area_predict + area_target - area_inter
-            area_circum = (clw + crw) * (cth + cbh) + 1e-7
-            giou = ious - (area_circum - area_uniou) / area_circum
-            loss = 1.0 - giou
-        elif self.iou_loss_type.lower() == "iou":
-            loss = 0.0 - paddle.log(ious)
-        else:
-            raise KeyError
-        if weights is not None:
-            loss = loss * weights
-        return loss
-
-    def forward(self, cls_logits, bboxes_reg, centerness, tag_labels,
-                tag_bboxes, tag_center):
-        """
-        Calculate the loss for classification, location and centerness
-        Args:
-            cls_logits (list): list of Tensor, which is predicted
-                score for all anchor points with shape [N, M, C]
-            bboxes_reg (list): list of Tensor, which is predicted
-                offsets for all anchor points with shape [N, M, 4]
-            centerness (list): list of Tensor, which is predicted
-                centerness for all anchor points with shape [N, M, 1]
-            tag_labels (list): list of Tensor, which is category
-                targets for each anchor point
-            tag_bboxes (list): list of Tensor, which is bounding
-                boxes targets for positive samples
-            tag_center (list): list of Tensor, which is centerness
-                targets for positive samples
-        Return:
-            loss (dict): loss composed by classification loss, bounding box
-        """
-        cls_logits_flatten_list = []
-        bboxes_reg_flatten_list = []
-        centerness_flatten_list = []
-        tag_labels_flatten_list = []
-        tag_bboxes_flatten_list = []
-        tag_center_flatten_list = []
-        num_lvl = len(cls_logits)
-        for lvl in range(num_lvl):
-            cls_logits_flatten_list.append(
-                flatten_tensor(cls_logits[lvl], True))
-            bboxes_reg_flatten_list.append(
-                flatten_tensor(bboxes_reg[lvl], True))
-            centerness_flatten_list.append(
-                flatten_tensor(centerness[lvl], True))
-
-            tag_labels_flatten_list.append(
-                flatten_tensor(tag_labels[lvl], False))
-            tag_bboxes_flatten_list.append(
-                flatten_tensor(tag_bboxes[lvl], False))
-            tag_center_flatten_list.append(
-                flatten_tensor(tag_center[lvl], False))
-
-        cls_logits_flatten = paddle.concat(cls_logits_flatten_list, axis=0)
-        bboxes_reg_flatten = paddle.concat(bboxes_reg_flatten_list, axis=0)
-        centerness_flatten = paddle.concat(centerness_flatten_list, axis=0)
-
-        tag_labels_flatten = paddle.concat(tag_labels_flatten_list, axis=0)
-        tag_bboxes_flatten = paddle.concat(tag_bboxes_flatten_list, axis=0)
-        tag_center_flatten = paddle.concat(tag_center_flatten_list, axis=0)
-        tag_labels_flatten.stop_gradient = True
-        tag_bboxes_flatten.stop_gradient = True
-        tag_center_flatten.stop_gradient = True
-
-        mask_positive_bool = tag_labels_flatten > 0
-        mask_positive_bool.stop_gradient = True
-        mask_positive_float = paddle.cast(mask_positive_bool, dtype="float32")
-        mask_positive_float.stop_gradient = True
-
-        num_positive_fp32 = paddle.sum(mask_positive_float)
-        num_positive_fp32.stop_gradient = True
-        num_positive_int32 = paddle.cast(num_positive_fp32, dtype="int32")
-        num_positive_int32 = num_positive_int32 * 0 + 1
-        num_positive_int32.stop_gradient = True
-
-        normalize_sum = paddle.sum(tag_center_flatten * mask_positive_float)
-        normalize_sum.stop_gradient = True
-
-        # 1. cls_logits: sigmoid_focal_loss
-        # expand onehot labels
-        num_classes = cls_logits_flatten.shape[-1]
-        tag_labels_flatten = paddle.squeeze(tag_labels_flatten, axis=-1)
-        tag_labels_flatten_bin = F.one_hot(
-            tag_labels_flatten, num_classes=1 + num_classes)
-        tag_labels_flatten_bin = tag_labels_flatten_bin[:, 1:]
-        # sigmoid_focal_loss
-        cls_loss = F.sigmoid_focal_loss(
-            cls_logits_flatten, tag_labels_flatten_bin) / num_positive_fp32
-
-        # 2. bboxes_reg: giou_loss
-        mask_positive_float = paddle.squeeze(mask_positive_float, axis=-1)
-        tag_center_flatten = paddle.squeeze(tag_center_flatten, axis=-1)
-        reg_loss = self.__iou_loss(
-            bboxes_reg_flatten,
-            tag_bboxes_flatten,
-            mask_positive_float,
-            weights=tag_center_flatten)
-        reg_loss = reg_loss * mask_positive_float / normalize_sum
-
-        # 3. centerness: sigmoid_cross_entropy_with_logits_loss
-        centerness_flatten = paddle.squeeze(centerness_flatten, axis=-1)
-        ctn_loss = ops.sigmoid_cross_entropy_with_logits(centerness_flatten,
-                                                         tag_center_flatten)
-        ctn_loss = ctn_loss * mask_positive_float / num_positive_fp32
-
-        loss_all = {
-            "loss_centerness": paddle.sum(ctn_loss),
-            "loss_cls": paddle.sum(cls_loss),
-            "loss_box": paddle.sum(reg_loss)
-        }
-        return loss_all