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

paddlex/ppdet/modeling/losses/gfocal_loss.py

@@ -1,217 +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.
-
-# The code is based on:
-# https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/losses/gfocal_loss.py
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import numpy as np
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.modeling import ops
-
-__all__ = ['QualityFocalLoss', 'DistributionFocalLoss']
-
-
-def quality_focal_loss(pred, target, beta=2.0, use_sigmoid=True):
-    """
-    Quality Focal Loss (QFL) is from `Generalized Focal Loss: Learning
-    Qualified and Distributed Bounding Boxes for Dense Object Detection
-    <https://arxiv.org/abs/2006.04388>`_.
-    Args:
-        pred (Tensor): Predicted joint representation of classification
-            and quality (IoU) estimation with shape (N, C), C is the number of
-            classes.
-        target (tuple([Tensor])): Target category label with shape (N,)
-            and target quality label with shape (N,).
-        beta (float): The beta parameter for calculating the modulating factor.
-            Defaults to 2.0.
-    Returns:
-        Tensor: Loss tensor with shape (N,).
-    """
-    assert len(target) == 2, """target for QFL must be a tuple of two elements,
-        including category label and quality label, respectively"""
-    # label denotes the category id, score denotes the quality score
-    label, score = target
-    if use_sigmoid:
-        func = F.binary_cross_entropy_with_logits
-    else:
-        func = F.binary_cross_entropy
-
-    # negatives are supervised by 0 quality score
-    pred_sigmoid = F.sigmoid(pred) if use_sigmoid else pred
-    scale_factor = pred_sigmoid
-    zerolabel = paddle.zeros(pred.shape, dtype='float32')
-    loss = func(pred, zerolabel, reduction='none') * scale_factor.pow(beta)
-
-    # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
-    bg_class_ind = pred.shape[1]
-    pos = paddle.logical_and((label >= 0),
-                             (label < bg_class_ind)).nonzero().squeeze(1)
-    if pos.shape[0] == 0:
-        return loss.sum(axis=1)
-    pos_label = paddle.gather(label, pos, axis=0)
-    pos_mask = np.zeros(pred.shape, dtype=np.int32)
-    pos_mask[pos.numpy(), pos_label.numpy()] = 1
-    pos_mask = paddle.to_tensor(pos_mask, dtype='bool')
-    score = score.unsqueeze(-1).expand([-1, pred.shape[1]]).cast('float32')
-    # positives are supervised by bbox quality (IoU) score
-    scale_factor_new = score - pred_sigmoid
-
-    loss_pos = func(
-        pred, score, reduction='none') * scale_factor_new.abs().pow(beta)
-    loss = loss * paddle.logical_not(pos_mask) + loss_pos * pos_mask
-    loss = loss.sum(axis=1)
-    return loss
-
-
-def distribution_focal_loss(pred, label):
-    """Distribution Focal Loss (DFL) is from `Generalized Focal Loss: Learning
-    Qualified and Distributed Bounding Boxes for Dense Object Detection
-    <https://arxiv.org/abs/2006.04388>`_.
-    Args:
-        pred (Tensor): Predicted general distribution of bounding boxes
-            (before softmax) with shape (N, n+1), n is the max value of the
-            integral set `{0, ..., n}` in paper.
-        label (Tensor): Target distance label for bounding boxes with
-            shape (N,).
-    Returns:
-        Tensor: Loss tensor with shape (N,).
-    """
-    dis_left = label.cast('int64')
-    dis_right = dis_left + 1
-    weight_left = dis_right.cast('float32') - label
-    weight_right = label - dis_left.cast('float32')
-    loss = F.cross_entropy(pred, dis_left, reduction='none') * weight_left \
-        + F.cross_entropy(pred, dis_right, reduction='none') * weight_right
-    return loss
-
-
-@register
-@serializable
-class QualityFocalLoss(nn.Layer):
-    r"""Quality Focal Loss (QFL) is a variant of `Generalized Focal Loss:
-    Learning Qualified and Distributed Bounding Boxes for Dense Object
-    Detection <https://arxiv.org/abs/2006.04388>`_.
-    Args:
-        use_sigmoid (bool): Whether sigmoid operation is conducted in QFL.
-            Defaults to True.
-        beta (float): The beta parameter for calculating the modulating factor.
-            Defaults to 2.0.
-        reduction (str): Options are "none", "mean" and "sum".
-        loss_weight (float): Loss weight of current loss.
-    """
-
-    def __init__(self,
-                 use_sigmoid=True,
-                 beta=2.0,
-                 reduction='mean',
-                 loss_weight=1.0):
-        super(QualityFocalLoss, self).__init__()
-        self.use_sigmoid = use_sigmoid
-        self.beta = beta
-        assert reduction in ('none', 'mean', 'sum')
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self, pred, target, weight=None, avg_factor=None):
-        """Forward function.
-        Args:
-            pred (Tensor): Predicted joint representation of
-                classification and quality (IoU) estimation with shape (N, C),
-                C is the number of classes.
-            target (tuple([Tensor])): Target category label with shape
-                (N,) and target quality label with shape (N,).
-            weight (Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-        """
-
-        loss = self.loss_weight * quality_focal_loss(
-            pred, target, beta=self.beta, use_sigmoid=self.use_sigmoid)
-
-        if weight is not None:
-            loss = loss * weight
-        if avg_factor is None:
-            if self.reduction == 'none':
-                return loss
-            elif self.reduction == 'mean':
-                return loss.mean()
-            elif self.reduction == 'sum':
-                return loss.sum()
-        else:
-            # if reduction is mean, then average the loss by avg_factor
-            if self.reduction == 'mean':
-                loss = loss.sum() / avg_factor
-            # if reduction is 'none', then do nothing, otherwise raise an error
-            elif self.reduction != 'none':
-                raise ValueError(
-                    'avg_factor can not be used with reduction="sum"')
-        return loss
-
-
-@register
-@serializable
-class DistributionFocalLoss(nn.Layer):
-    """Distribution Focal Loss (DFL) is a variant of `Generalized Focal Loss:
-    Learning Qualified and Distributed Bounding Boxes for Dense Object
-    Detection <https://arxiv.org/abs/2006.04388>`_.
-    Args:
-        reduction (str): Options are `'none'`, `'mean'` and `'sum'`.
-        loss_weight (float): Loss weight of current loss.
-    """
-
-    def __init__(self, reduction='mean', loss_weight=1.0):
-        super(DistributionFocalLoss, self).__init__()
-        assert reduction in ('none', 'mean', 'sum')
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self, pred, target, weight=None, avg_factor=None):
-        """Forward function.
-        Args:
-            pred (Tensor): Predicted general distribution of bounding
-                boxes (before softmax) with shape (N, n+1), n is the max value
-                of the integral set `{0, ..., n}` in paper.
-            target (Tensor): Target distance label for bounding boxes
-                with shape (N,).
-            weight (Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-        """
-        loss = self.loss_weight * distribution_focal_loss(pred, target)
-        if weight is not None:
-            loss = loss * weight
-        if avg_factor is None:
-            if self.reduction == 'none':
-                return loss
-            elif self.reduction == 'mean':
-                return loss.mean()
-            elif self.reduction == 'sum':
-                return loss.sum()
-        else:
-            # if reduction is mean, then average the loss by avg_factor
-            if self.reduction == 'mean':
-                loss = loss.sum() / avg_factor
-            # if reduction is 'none', then do nothing, otherwise raise an error
-            elif self.reduction != 'none':
-                raise ValueError(
-                    'avg_factor can not be used with reduction="sum"')
-        return loss

paddlex/ppdet/modeling/losses/iou_aware_loss.py

@@ -1,47 +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.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-from .iou_loss import IouLoss
-from ..bbox_utils import bbox_iou
-
-
-@register
-@serializable
-class IouAwareLoss(IouLoss):
-    """
-    iou aware loss, see https://arxiv.org/abs/1912.05992
-    Args:
-        loss_weight (float): iou aware loss weight, default is 1.0
-        max_height (int): max height of input to support random shape input
-        max_width (int): max width of input to support random shape input
-    """
-
-    def __init__(self, loss_weight=1.0, giou=False, diou=False, ciou=False):
-        super(IouAwareLoss, self).__init__(
-            loss_weight=loss_weight, giou=giou, diou=diou, ciou=ciou)
-
-    def __call__(self, ioup, pbox, gbox):
-        iou = bbox_iou(
-            pbox, gbox, giou=self.giou, diou=self.diou, ciou=self.ciou)
-        iou.stop_gradient = True
-        loss_iou_aware = F.binary_cross_entropy_with_logits(
-            ioup, iou, reduction='none')
-        loss_iou_aware = loss_iou_aware * self.loss_weight
-        return loss_iou_aware

paddlex/ppdet/modeling/losses/iou_loss.py

@@ -1,210 +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 numpy as np
-
-import paddle
-
-from paddlex.ppdet.core.workspace import register, serializable
-from ..bbox_utils import bbox_iou
-
-__all__ = ['IouLoss', 'GIoULoss', 'DIouLoss']
-
-
-@register
-@serializable
-class IouLoss(object):
-    """
-    iou loss, see https://arxiv.org/abs/1908.03851
-    loss = 1.0 - iou * iou
-    Args:
-        loss_weight (float): iou loss weight, default is 2.5
-        max_height (int): max height of input to support random shape input
-        max_width (int): max width of input to support random shape input
-        ciou_term (bool): whether to add ciou_term
-        loss_square (bool): whether to square the iou term
-    """
-
-    def __init__(self,
-                 loss_weight=2.5,
-                 giou=False,
-                 diou=False,
-                 ciou=False,
-                 loss_square=True):
-        self.loss_weight = loss_weight
-        self.giou = giou
-        self.diou = diou
-        self.ciou = ciou
-        self.loss_square = loss_square
-
-    def __call__(self, pbox, gbox):
-        iou = bbox_iou(
-            pbox, gbox, giou=self.giou, diou=self.diou, ciou=self.ciou)
-        if self.loss_square:
-            loss_iou = 1 - iou * iou
-        else:
-            loss_iou = 1 - iou
-
-        loss_iou = loss_iou * self.loss_weight
-        return loss_iou
-
-
-@register
-@serializable
-class GIoULoss(object):
-    """
-    Generalized Intersection over Union, see https://arxiv.org/abs/1902.09630
-    Args:
-        loss_weight (float): giou loss weight, default as 1
-        eps (float): epsilon to avoid divide by zero, default as 1e-10
-        reduction (string): Options are "none", "mean" and "sum". default as none
-    """
-
-    def __init__(self, loss_weight=1., eps=1e-10, reduction='none'):
-        self.loss_weight = loss_weight
-        self.eps = eps
-        assert reduction in ('none', 'mean', 'sum')
-        self.reduction = reduction
-
-    def bbox_overlap(self, box1, box2, eps=1e-10):
-        """calculate the iou of box1 and box2
-        Args:
-            box1 (Tensor): box1 with the shape (..., 4)
-            box2 (Tensor): box1 with the shape (..., 4)
-            eps (float): epsilon to avoid divide by zero
-        Return:
-            iou (Tensor): iou of box1 and box2
-            overlap (Tensor): overlap of box1 and box2
-            union (Tensor): union of box1 and box2
-        """
-        x1, y1, x2, y2 = box1
-        x1g, y1g, x2g, y2g = box2
-
-        xkis1 = paddle.maximum(x1, x1g)
-        ykis1 = paddle.maximum(y1, y1g)
-        xkis2 = paddle.minimum(x2, x2g)
-        ykis2 = paddle.minimum(y2, y2g)
-        w_inter = (xkis2 - xkis1).clip(0)
-        h_inter = (ykis2 - ykis1).clip(0)
-        overlap = w_inter * h_inter
-
-        area1 = (x2 - x1) * (y2 - y1)
-        area2 = (x2g - x1g) * (y2g - y1g)
-        union = area1 + area2 - overlap + eps
-        iou = overlap / union
-
-        return iou, overlap, union
-
-    def __call__(self, pbox, gbox, iou_weight=1., loc_reweight=None):
-        x1, y1, x2, y2 = paddle.split(pbox, num_or_sections=4, axis=-1)
-        x1g, y1g, x2g, y2g = paddle.split(gbox, num_or_sections=4, axis=-1)
-        box1 = [x1, y1, x2, y2]
-        box2 = [x1g, y1g, x2g, y2g]
-        iou, overlap, union = self.bbox_overlap(box1, box2, self.eps)
-        xc1 = paddle.minimum(x1, x1g)
-        yc1 = paddle.minimum(y1, y1g)
-        xc2 = paddle.maximum(x2, x2g)
-        yc2 = paddle.maximum(y2, y2g)
-
-        area_c = (xc2 - xc1) * (yc2 - yc1) + self.eps
-        miou = iou - ((area_c - union) / area_c)
-        if loc_reweight is not None:
-            loc_reweight = paddle.reshape(loc_reweight, shape=(-1, 1))
-            loc_thresh = 0.9
-            giou = 1 - (1 - loc_thresh
-                        ) * miou - loc_thresh * miou * loc_reweight
-        else:
-            giou = 1 - miou
-        if self.reduction == 'none':
-            loss = giou
-        elif self.reduction == 'sum':
-            loss = paddle.sum(giou * iou_weight)
-        else:
-            loss = paddle.mean(giou * iou_weight)
-        return loss * self.loss_weight
-
-
-@register
-@serializable
-class DIouLoss(GIoULoss):
-    """
-    Distance-IoU Loss, see https://arxiv.org/abs/1911.08287
-    Args:
-        loss_weight (float): giou loss weight, default as 1
-        eps (float): epsilon to avoid divide by zero, default as 1e-10
-        use_complete_iou_loss (bool): whether to use complete iou loss
-    """
-
-    def __init__(self, loss_weight=1., eps=1e-10, use_complete_iou_loss=True):
-        super(DIouLoss, self).__init__(loss_weight=loss_weight, eps=eps)
-        self.use_complete_iou_loss = use_complete_iou_loss
-
-    def __call__(self, pbox, gbox, iou_weight=1.):
-        x1, y1, x2, y2 = paddle.split(pbox, num_or_sections=4, axis=-1)
-        x1g, y1g, x2g, y2g = paddle.split(gbox, num_or_sections=4, axis=-1)
-        cx = (x1 + x2) / 2
-        cy = (y1 + y2) / 2
-        w = x2 - x1
-        h = y2 - y1
-
-        cxg = (x1g + x2g) / 2
-        cyg = (y1g + y2g) / 2
-        wg = x2g - x1g
-        hg = y2g - y1g
-
-        x2 = paddle.maximum(x1, x2)
-        y2 = paddle.maximum(y1, y2)
-
-        # A and B
-        xkis1 = paddle.maximum(x1, x1g)
-        ykis1 = paddle.maximum(y1, y1g)
-        xkis2 = paddle.minimum(x2, x2g)
-        ykis2 = paddle.minimum(y2, y2g)
-
-        # A or B
-        xc1 = paddle.minimum(x1, x1g)
-        yc1 = paddle.minimum(y1, y1g)
-        xc2 = paddle.maximum(x2, x2g)
-        yc2 = paddle.maximum(y2, y2g)
-
-        intsctk = (xkis2 - xkis1) * (ykis2 - ykis1)
-        intsctk = intsctk * paddle.greater_than(
-            xkis2, xkis1) * paddle.greater_than(ykis2, ykis1)
-        unionk = (x2 - x1) * (y2 - y1) + (x2g - x1g) * (y2g - y1g
-                                                        ) - intsctk + self.eps
-        iouk = intsctk / unionk
-
-        # DIOU term
-        dist_intersection = (cx - cxg) * (cx - cxg) + (cy - cyg) * (cy - cyg)
-        dist_union = (xc2 - xc1) * (xc2 - xc1) + (yc2 - yc1) * (yc2 - yc1)
-        diou_term = (dist_intersection + self.eps) / (dist_union + self.eps)
-
-        # CIOU term
-        ciou_term = 0
-        if self.use_complete_iou_loss:
-            ar_gt = wg / hg
-            ar_pred = w / h
-            arctan = paddle.atan(ar_gt) - paddle.atan(ar_pred)
-            ar_loss = 4. / np.pi / np.pi * arctan * arctan
-            alpha = ar_loss / (1 - iouk + ar_loss + self.eps)
-            alpha.stop_gradient = True
-            ciou_term = alpha * ar_loss
-
-        diou = paddle.mean((1 - iouk + ciou_term + diou_term) * iou_weight)
-
-        return diou * self.loss_weight

paddlex/ppdet/modeling/losses/jde_loss.py

@@ -1,193 +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
-
-__all__ = ['JDEDetectionLoss', 'JDEEmbeddingLoss', 'JDELoss']
-
-
-@register
-class JDEDetectionLoss(nn.Layer):
-    __shared__ = ['num_classes']
-
-    def __init__(self, num_classes=1, for_mot=True):
-        super(JDEDetectionLoss, self).__init__()
-        self.num_classes = num_classes
-        self.for_mot = for_mot
-
-    def det_loss(self, p_det, anchor, t_conf, t_box):
-        pshape = paddle.shape(p_det)
-        pshape.stop_gradient = True
-        nB, nGh, nGw = pshape[0], pshape[-2], pshape[-1]
-        nA = len(anchor)
-        p_det = paddle.reshape(
-            p_det, [nB, nA, self.num_classes + 5, nGh, nGw]).transpose(
-                (0, 1, 3, 4, 2))
-
-        # 1. loss_conf: cross_entropy
-        p_conf = p_det[:, :, :, :, 4:6]
-        p_conf_flatten = paddle.reshape(p_conf, [-1, 2])
-        t_conf_flatten = t_conf.flatten()
-        t_conf_flatten = paddle.cast(t_conf_flatten, dtype="int64")
-        t_conf_flatten.stop_gradient = True
-        loss_conf = F.cross_entropy(
-            p_conf_flatten, t_conf_flatten, ignore_index=-1, reduction='mean')
-        loss_conf.stop_gradient = False
-
-        # 2. loss_box: smooth_l1_loss
-        p_box = p_det[:, :, :, :, :4]
-        p_box_flatten = paddle.reshape(p_box, [-1, 4])
-        t_box_flatten = paddle.reshape(t_box, [-1, 4])
-        fg_inds = paddle.nonzero(t_conf_flatten > 0).flatten()
-        if fg_inds.numel() > 0:
-            reg_delta = paddle.gather(p_box_flatten, fg_inds)
-            reg_target = paddle.gather(t_box_flatten, fg_inds)
-        else:
-            reg_delta = paddle.to_tensor([0, 0, 0, 0], dtype='float32')
-            reg_delta.stop_gradient = False
-            reg_target = paddle.to_tensor([0, 0, 0, 0], dtype='float32')
-        reg_target.stop_gradient = True
-        loss_box = F.smooth_l1_loss(
-            reg_delta, reg_target, reduction='mean', delta=1.0)
-        loss_box.stop_gradient = False
-
-        return loss_conf, loss_box
-
-    def forward(self, det_outs, targets, anchors):
-        """
-        Args:
-            det_outs (list[Tensor]): output from detection head, each one
-                is a 4-D Tensor with shape [N, C, H, W].
-            targets (dict): contains 'im_id', 'gt_bbox', 'gt_ide', 'image',
-                'im_shape', 'scale_factor' and 'tbox', 'tconf', 'tide' of
-                each FPN level.
-            anchors (list[list]): anchor setting of JDE model, N row M col, N is
-                the anchor levels(FPN levels), M is the anchor scales each
-                level.
-        """
-        assert len(det_outs) == len(anchors)
-        loss_confs = []
-        loss_boxes = []
-        for i, (p_det, anchor) in enumerate(zip(det_outs, anchors)):
-            t_conf = targets['tconf{}'.format(i)]
-            t_box = targets['tbox{}'.format(i)]
-
-            loss_conf, loss_box = self.det_loss(p_det, anchor, t_conf, t_box)
-            loss_confs.append(loss_conf)
-            loss_boxes.append(loss_box)
-        if self.for_mot:
-            return {'loss_confs': loss_confs, 'loss_boxes': loss_boxes}
-        else:
-            jde_conf_losses = sum(loss_confs)
-            jde_box_losses = sum(loss_boxes)
-            jde_det_losses = {
-                "loss_conf": jde_conf_losses,
-                "loss_box": jde_box_losses,
-                "loss": jde_conf_losses + jde_box_losses,
-            }
-            return jde_det_losses
-
-
-@register
-class JDEEmbeddingLoss(nn.Layer):
-    def __init__(self, ):
-        super(JDEEmbeddingLoss, self).__init__()
-        self.phony = self.create_parameter(shape=[1], dtype="float32")
-
-    def emb_loss(self, p_ide, t_conf, t_ide, emb_scale, classifier):
-        emb_dim = p_ide.shape[1]
-        p_ide = p_ide.transpose((0, 2, 3, 1))
-        p_ide_flatten = paddle.reshape(p_ide, [-1, emb_dim])
-        mask = t_conf > 0
-        mask = paddle.cast(mask, dtype="int64")
-        mask.stop_gradient = True
-        emb_mask = mask.max(1).flatten()
-        emb_mask_inds = paddle.nonzero(emb_mask > 0).flatten()
-        emb_mask_inds.stop_gradient = True
-        # use max(1) to decide the id, TODO: more reseanable strategy
-        t_ide_flatten = t_ide.max(1).flatten()
-        t_ide_flatten = paddle.cast(t_ide_flatten, dtype="int64")
-        valid_inds = paddle.nonzero(t_ide_flatten != -1).flatten()
-
-        if emb_mask_inds.numel() == 0 or valid_inds.numel() == 0:
-            # loss_ide = paddle.to_tensor([0]) # will be error in gradient backward
-            loss_ide = self.phony * 0  # todo
-        else:
-            embedding = paddle.gather(p_ide_flatten, emb_mask_inds)
-            embedding = emb_scale * F.normalize(embedding)
-            logits = classifier(embedding)
-
-            ide_target = paddle.gather(t_ide_flatten, emb_mask_inds)
-
-            loss_ide = F.cross_entropy(
-                logits, ide_target, ignore_index=-1, reduction='mean')
-        loss_ide.stop_gradient = False
-
-        return loss_ide
-
-    def forward(self, ide_outs, targets, emb_scale, classifier):
-        loss_ides = []
-        for i, p_ide in enumerate(ide_outs):
-            t_conf = targets['tconf{}'.format(i)]
-            t_ide = targets['tide{}'.format(i)]
-
-            loss_ide = self.emb_loss(p_ide, t_conf, t_ide, emb_scale,
-                                     classifier)
-            loss_ides.append(loss_ide)
-        return loss_ides
-
-
-@register
-class JDELoss(nn.Layer):
-    def __init__(self):
-        super(JDELoss, self).__init__()
-
-    def forward(self, loss_confs, loss_boxes, loss_ides, loss_params_cls,
-                loss_params_reg, loss_params_ide, targets):
-        assert len(loss_confs) == len(loss_boxes) == len(loss_ides)
-        assert len(loss_params_cls) == len(loss_params_reg) == len(
-            loss_params_ide)
-        assert len(loss_confs) == len(loss_params_cls)
-
-        batchsize = targets['gt_bbox'].shape[0]
-        nTargets = paddle.nonzero(paddle.sum(targets['gt_bbox'],
-                                             axis=2)).shape[0] / batchsize
-        nTargets = paddle.to_tensor(nTargets, dtype='float32')
-        nTargets.stop_gradient = True
-
-        jde_losses = []
-        for i, (loss_conf, loss_box, loss_ide, l_conf_p, l_box_p,
-                l_ide_p) in enumerate(
-                    zip(loss_confs, loss_boxes, loss_ides, loss_params_cls,
-                        loss_params_reg, loss_params_ide)):
-
-            jde_loss = l_conf_p(loss_conf) + l_box_p(loss_box) + l_ide_p(
-                loss_ide)
-            jde_losses.append(jde_loss)
-
-        loss_all = {
-            "loss_conf": sum(loss_confs),
-            "loss_box": sum(loss_boxes),
-            "loss_ide": sum(loss_ides),
-            "loss": sum(jde_losses),
-            "nTargets": nTargets,
-        }
-        return loss_all