paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/ppdet/modeling/losses/jde_loss.py

@@ -1,182 +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):
-        super(JDEDetectionLoss, self).__init__()
-        self.num_classes = num_classes
-
-    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)
-        return {'loss_confs': loss_confs, 'loss_boxes': loss_boxes}
-
-
-@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

paddlex/ppdet/modeling/losses/keypoint_loss.py

@@ -1,228 +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
-
-from itertools import cycle, islice
-from collections import abc
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-
-__all__ = ['HrHRNetLoss', 'KeyPointMSELoss']
-
-
-@register
-@serializable
-class KeyPointMSELoss(nn.Layer):
-    def __init__(self, use_target_weight=True):
-        """
-        KeyPointMSELoss layer
-
-        Args:
-            use_target_weight (bool): whether to use target weight
-        """
-        super(KeyPointMSELoss, self).__init__()
-        self.criterion = nn.MSELoss(reduction='mean')
-        self.use_target_weight = use_target_weight
-
-    def forward(self, output, records):
-        target = records['target']
-        target_weight = records['target_weight']
-        batch_size = output.shape[0]
-        num_joints = output.shape[1]
-        heatmaps_pred = output.reshape(
-            (batch_size, num_joints, -1)).split(num_joints, 1)
-        heatmaps_gt = target.reshape(
-            (batch_size, num_joints, -1)).split(num_joints, 1)
-        loss = 0
-
-        for idx in range(num_joints):
-            heatmap_pred = heatmaps_pred[idx].squeeze()
-            heatmap_gt = heatmaps_gt[idx].squeeze()
-            if self.use_target_weight:
-                loss += 0.5 * self.criterion(
-                    heatmap_pred.multiply(target_weight[:, idx]),
-                    heatmap_gt.multiply(target_weight[:, idx]))
-            else:
-                loss += 0.5 * self.criterion(heatmap_pred, heatmap_gt)
-        keypoint_losses = dict()
-        keypoint_losses['loss'] = loss / num_joints
-        return keypoint_losses
-
-
-@register
-@serializable
-class HrHRNetLoss(nn.Layer):
-    def __init__(self, num_joints, swahr):
-        """
-        HrHRNetLoss layer
-
-        Args:
-            num_joints (int): number of keypoints
-        """
-        super(HrHRNetLoss, self).__init__()
-        if swahr:
-            self.heatmaploss = HeatMapSWAHRLoss(num_joints)
-        else:
-            self.heatmaploss = HeatMapLoss()
-        self.aeloss = AELoss()
-        self.ziploss = ZipLoss(
-            [self.heatmaploss, self.heatmaploss, self.aeloss])
-
-    def forward(self, inputs, records):
-        targets = []
-        targets.append([records['heatmap_gt1x'], records['mask_1x']])
-        targets.append([records['heatmap_gt2x'], records['mask_2x']])
-        targets.append(records['tagmap'])
-        keypoint_losses = dict()
-        loss = self.ziploss(inputs, targets)
-        keypoint_losses['heatmap_loss'] = loss[0] + loss[1]
-        keypoint_losses['pull_loss'] = loss[2][0]
-        keypoint_losses['push_loss'] = loss[2][1]
-        keypoint_losses['loss'] = recursive_sum(loss)
-        return keypoint_losses
-
-
-class HeatMapLoss(object):
-    def __init__(self, loss_factor=1.0):
-        super(HeatMapLoss, self).__init__()
-        self.loss_factor = loss_factor
-
-    def __call__(self, preds, targets):
-        heatmap, mask = targets
-        loss = ((preds - heatmap)**2 * mask.cast('float').unsqueeze(1))
-        loss = paddle.clip(loss, min=0, max=2).mean()
-        loss *= self.loss_factor
-        return loss
-
-
-class HeatMapSWAHRLoss(object):
-    def __init__(self, num_joints, loss_factor=1.0):
-        super(HeatMapSWAHRLoss, self).__init__()
-        self.loss_factor = loss_factor
-        self.num_joints = num_joints
-
-    def __call__(self, preds, targets):
-        heatmaps_gt, mask = targets
-        heatmaps_pred = preds[0]
-        scalemaps_pred = preds[1]
-
-        heatmaps_scaled_gt = paddle.where(
-            heatmaps_gt > 0, 0.5 * heatmaps_gt *
-            (1 + (1 +
-                  (scalemaps_pred - 1.) * paddle.log(heatmaps_gt + 1e-10))**2),
-            heatmaps_gt)
-
-        regularizer_loss = paddle.mean(
-            paddle.pow((scalemaps_pred - 1.) * (heatmaps_gt > 0).astype(float),
-                       2))
-        omiga = 0.01
-        # thres = 2**(-1/omiga), threshold for positive weight
-        hm_weight = heatmaps_scaled_gt**(
-            omiga
-        ) * paddle.abs(1 - heatmaps_pred) + paddle.abs(heatmaps_pred) * (
-            1 - heatmaps_scaled_gt**(omiga))
-
-        loss = (((heatmaps_pred - heatmaps_scaled_gt)**2) *
-                mask.cast('float').unsqueeze(1)) * hm_weight
-        loss = loss.mean()
-        loss = self.loss_factor * (loss + 1.0 * regularizer_loss)
-        return loss
-
-
-class AELoss(object):
-    def __init__(self, pull_factor=0.001, push_factor=0.001):
-        super(AELoss, self).__init__()
-        self.pull_factor = pull_factor
-        self.push_factor = push_factor
-
-    def apply_single(self, pred, tagmap):
-        if tagmap.numpy()[:, :, 3].sum() == 0:
-            return (paddle.zeros([1]), paddle.zeros([1]))
-        nonzero = paddle.nonzero(tagmap[:, :, 3] > 0)
-        if nonzero.shape[0] == 0:
-            return (paddle.zeros([1]), paddle.zeros([1]))
-        p_inds = paddle.unique(nonzero[:, 0])
-        num_person = p_inds.shape[0]
-        if num_person == 0:
-            return (paddle.zeros([1]), paddle.zeros([1]))
-
-        pull = 0
-        tagpull_num = 0
-        embs_all = []
-        person_unvalid = 0
-        for person_idx in p_inds.numpy():
-            valid_single = tagmap[person_idx.item()]
-            validkpts = paddle.nonzero(valid_single[:, 3] > 0)
-            valid_single = paddle.index_select(valid_single, validkpts)
-            emb = paddle.gather_nd(pred, valid_single[:, :3])
-            if emb.shape[0] == 1:
-                person_unvalid += 1
-            mean = paddle.mean(emb, axis=0)
-            embs_all.append(mean)
-            pull += paddle.mean(paddle.pow(emb - mean, 2), axis=0)
-            tagpull_num += emb.shape[0]
-        pull /= max(num_person - person_unvalid, 1)
-        if num_person < 2:
-            return pull, paddle.zeros([1])
-
-        embs_all = paddle.stack(embs_all)
-        A = embs_all.expand([num_person, num_person])
-        B = A.transpose([1, 0])
-        diff = A - B
-
-        diff = paddle.pow(diff, 2)
-        push = paddle.exp(-diff)
-        push = paddle.sum(push) - num_person
-
-        push /= 2 * num_person * (num_person - 1)
-        return pull, push
-
-    def __call__(self, preds, tagmaps):
-        bs = preds.shape[0]
-        losses = [
-            self.apply_single(preds[i:i + 1].squeeze(),
-                              tagmaps[i:i + 1].squeeze()) for i in range(bs)
-        ]
-        pull = self.pull_factor * sum(loss[0] for loss in losses) / len(losses)
-        push = self.push_factor * sum(loss[1] for loss in losses) / len(losses)
-        return pull, push
-
-
-class ZipLoss(object):
-    def __init__(self, loss_funcs):
-        super(ZipLoss, self).__init__()
-        self.loss_funcs = loss_funcs
-
-    def __call__(self, inputs, targets):
-        assert len(self.loss_funcs) == len(targets) >= len(inputs)
-
-        def zip_repeat(*args):
-            longest = max(map(len, args))
-            filled = [islice(cycle(x), longest) for x in args]
-            return zip(*filled)
-
-        return tuple(
-            fn(x, y)
-            for x, y, fn in zip_repeat(inputs, targets, self.loss_funcs))
-
-
-def recursive_sum(inputs):
-    if isinstance(inputs, abc.Sequence):
-        return sum([recursive_sum(x) for x in inputs])
-    return inputs

paddlex/ppdet/modeling/losses/solov2_loss.py

@@ -1,101 +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.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-
-__all__ = ['SOLOv2Loss']
-
-
-@register
-@serializable
-class SOLOv2Loss(object):
-    """
-    SOLOv2Loss
-    Args:
-        ins_loss_weight (float): Weight of instance loss.
-        focal_loss_gamma (float): Gamma parameter for focal loss.
-        focal_loss_alpha (float): Alpha parameter for focal loss.
-    """
-
-    def __init__(self,
-                 ins_loss_weight=3.0,
-                 focal_loss_gamma=2.0,
-                 focal_loss_alpha=0.25):
-        self.ins_loss_weight = ins_loss_weight
-        self.focal_loss_gamma = focal_loss_gamma
-        self.focal_loss_alpha = focal_loss_alpha
-
-    def _dice_loss(self, input, target):
-        input = paddle.reshape(input, shape=(paddle.shape(input)[0], -1))
-        target = paddle.reshape(target, shape=(paddle.shape(target)[0], -1))
-        a = paddle.sum(input * target, axis=1)
-        b = paddle.sum(input * input, axis=1) + 0.001
-        c = paddle.sum(target * target, axis=1) + 0.001
-        d = (2 * a) / (b + c)
-        return 1 - d
-
-    def __call__(self, ins_pred_list, ins_label_list, cate_preds, cate_labels,
-                 num_ins):
-        """
-        Get loss of network of SOLOv2.
-        Args:
-            ins_pred_list (list): Variable list of instance branch output.
-            ins_label_list (list): List of instance labels pre batch.
-            cate_preds (list): Concat Variable list of categroy branch output.
-            cate_labels (list): Concat list of categroy labels pre batch.
-            num_ins (int): Number of positive samples in a mini-batch.
-        Returns:
-            loss_ins (Variable): The instance loss Variable of SOLOv2 network.
-            loss_cate (Variable): The category loss Variable of SOLOv2 network.
-        """
-
-        #1. Ues dice_loss to calculate instance loss
-        loss_ins = []
-        total_weights = paddle.zeros(shape=[1], dtype='float32')
-        for input, target in zip(ins_pred_list, ins_label_list):
-            if input is None:
-                continue
-            target = paddle.cast(target, 'float32')
-            target = paddle.reshape(
-                target,
-                shape=[-1, paddle.shape(input)[-2], paddle.shape(input)[-1]])
-            weights = paddle.cast(
-                paddle.sum(target, axis=[1, 2]) > 0, 'float32')
-            input = F.sigmoid(input)
-            dice_out = paddle.multiply(self._dice_loss(input, target), weights)
-            total_weights += paddle.sum(weights)
-            loss_ins.append(dice_out)
-        loss_ins = paddle.sum(paddle.concat(loss_ins)) / total_weights
-        loss_ins = loss_ins * self.ins_loss_weight
-
-        #2. Ues sigmoid_focal_loss to calculate category loss
-        # expand onehot labels
-        num_classes = cate_preds.shape[-1]
-        cate_labels_bin = F.one_hot(cate_labels, num_classes=num_classes + 1)
-        cate_labels_bin = cate_labels_bin[:, 1:]
-
-        loss_cate = F.sigmoid_focal_loss(
-            cate_preds,
-            label=cate_labels_bin,
-            normalizer=num_ins + 1.,
-            gamma=self.focal_loss_gamma,
-            alpha=self.focal_loss_alpha)
-
-        return loss_ins, loss_cate

paddlex/ppdet/modeling/losses/ssd_loss.py

@@ -1,163 +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 ..ops import iou_similarity
-from ..bbox_utils import bbox2delta
-
-__all__ = ['SSDLoss']
-
-
-@register
-class SSDLoss(nn.Layer):
-    """
-    SSDLoss
-
-    Args:
-        overlap_threshold (float32, optional): IoU threshold for negative bboxes
-            and positive bboxes, 0.5 by default.
-        neg_pos_ratio (float): The ratio of negative samples / positive samples.
-        loc_loss_weight (float): The weight of loc_loss.
-        conf_loss_weight (float): The weight of conf_loss.
-        prior_box_var (list): Variances corresponding to prior box coord, [0.1,
-            0.1, 0.2, 0.2] by default.
-    """
-
-    def __init__(self,
-                 overlap_threshold=0.5,
-                 neg_pos_ratio=3.0,
-                 loc_loss_weight=1.0,
-                 conf_loss_weight=1.0,
-                 prior_box_var=[0.1, 0.1, 0.2, 0.2]):
-        super(SSDLoss, self).__init__()
-        self.overlap_threshold = overlap_threshold
-        self.neg_pos_ratio = neg_pos_ratio
-        self.loc_loss_weight = loc_loss_weight
-        self.conf_loss_weight = conf_loss_weight
-        self.prior_box_var = [1. / a for a in prior_box_var]
-
-    def _bipartite_match_for_batch(self, gt_bbox, gt_label, prior_boxes,
-                                   bg_index):
-        """
-        Args:
-            gt_bbox (Tensor): [B, N, 4]
-            gt_label (Tensor): [B, N, 1]
-            prior_boxes (Tensor): [A, 4]
-            bg_index (int): Background class index
-        """
-        batch_size, num_priors = gt_bbox.shape[0], prior_boxes.shape[0]
-        ious = iou_similarity(gt_bbox.reshape((-1, 4)), prior_boxes).reshape(
-            (batch_size, -1, num_priors))
-
-        # Calculate the number of object per sample.
-        num_object = (ious.sum(axis=-1) > 0).astype('int64').sum(axis=-1)
-
-        # For each prior box, get the max IoU of all GTs.
-        prior_max_iou, prior_argmax_iou = ious.max(axis=1), ious.argmax(axis=1)
-        # For each GT, get the max IoU of all prior boxes.
-        gt_max_iou, gt_argmax_iou = ious.max(axis=2), ious.argmax(axis=2)
-
-        # Gather target bbox and label according to 'prior_argmax_iou' index.
-        batch_ind = paddle.arange(
-            0, batch_size, dtype='int64').unsqueeze(-1).tile([1, num_priors])
-        prior_argmax_iou = paddle.stack([batch_ind, prior_argmax_iou], axis=-1)
-        targets_bbox = paddle.gather_nd(gt_bbox, prior_argmax_iou)
-        targets_label = paddle.gather_nd(gt_label, prior_argmax_iou)
-        # Assign negative
-        bg_index_tensor = paddle.full([batch_size, num_priors, 1], bg_index,
-                                      'int64')
-        targets_label = paddle.where(
-            prior_max_iou.unsqueeze(-1) < self.overlap_threshold,
-            bg_index_tensor, targets_label)
-
-        # Ensure each GT can match the max IoU prior box.
-        for i in range(batch_size):
-            if num_object[i] > 0:
-                targets_bbox[i] = paddle.scatter(
-                    targets_bbox[i], gt_argmax_iou[i, :int(num_object[i])],
-                    gt_bbox[i, :int(num_object[i])])
-                targets_label[i] = paddle.scatter(
-                    targets_label[i], gt_argmax_iou[i, :int(num_object[i])],
-                    gt_label[i, :int(num_object[i])])
-
-        # Encode box
-        prior_boxes = prior_boxes.unsqueeze(0).tile([batch_size, 1, 1])
-        targets_bbox = bbox2delta(
-            prior_boxes.reshape([-1, 4]),
-            targets_bbox.reshape([-1, 4]), self.prior_box_var)
-        targets_bbox = targets_bbox.reshape([batch_size, -1, 4])
-
-        return targets_bbox, targets_label
-
-    def _mine_hard_example(self, conf_loss, targets_label, bg_index):
-        pos = (targets_label != bg_index).astype(conf_loss.dtype)
-        num_pos = pos.sum(axis=1, keepdim=True)
-        neg = (targets_label == bg_index).astype(conf_loss.dtype)
-
-        conf_loss = conf_loss.clone() * neg
-        loss_idx = conf_loss.argsort(axis=1, descending=True)
-        idx_rank = loss_idx.argsort(axis=1)
-        num_negs = []
-        for i in range(conf_loss.shape[0]):
-            cur_num_pos = num_pos[i]
-            num_neg = paddle.clip(
-                cur_num_pos * self.neg_pos_ratio, max=pos.shape[1])
-            num_negs.append(num_neg)
-        num_neg = paddle.stack(num_negs).expand_as(idx_rank)
-        neg_mask = (idx_rank < num_neg).astype(conf_loss.dtype)
-
-        return (neg_mask + pos).astype('bool')
-
-    def forward(self, boxes, scores, gt_bbox, gt_label, prior_boxes):
-        boxes = paddle.concat(boxes, axis=1)
-        scores = paddle.concat(scores, axis=1)
-        gt_label = gt_label.unsqueeze(-1).astype('int64')
-        prior_boxes = paddle.concat(prior_boxes, axis=0)
-        bg_index = scores.shape[-1] - 1
-
-        # Match bbox and get targets.
-        targets_bbox, targets_label = \
-            self._bipartite_match_for_batch(gt_bbox, gt_label, prior_boxes, bg_index)
-        targets_bbox.stop_gradient = True
-        targets_label.stop_gradient = True
-
-        # Compute regression loss.
-        # Select positive samples.
-        bbox_mask = (targets_label != bg_index).astype(boxes.dtype)
-        loc_loss = bbox_mask * F.smooth_l1_loss(
-            boxes, targets_bbox, reduction='none')
-        loc_loss = loc_loss.sum() * self.loc_loss_weight
-
-        # Compute confidence loss.
-        conf_loss = F.softmax_with_cross_entropy(scores, targets_label)
-        # Mining hard examples.
-        label_mask = self._mine_hard_example(
-            conf_loss.squeeze(-1), targets_label.squeeze(-1), bg_index)
-        conf_loss = conf_loss * label_mask.unsqueeze(-1).astype(
-            conf_loss.dtype)
-        conf_loss = conf_loss.sum() * self.conf_loss_weight
-
-        # Compute overall weighted loss.
-        normalizer = (targets_label != bg_index).astype('float32').sum().clip(
-            min=1)
-        loss = (conf_loss + loc_loss) / (normalizer + 1e-9)
-
-        return loss