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

paddlex/ppdet/modeling/losses/__init__.py

@@ -1,35 +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 .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 *

paddlex/ppdet/modeling/losses/ctfocal_loss.py

@@ -1,67 +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__ = ['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) * bg_map
-        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
-        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/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 numpy as np
-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

paddlex/ppdet/modeling/losses/iou_aware_loss.py

@@ -1,48 +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
-from .iou_loss import IouLoss
-from ..bbox_utils import xywh2xyxy, 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
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-from ..bbox_utils import xywh2xyxy, 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