code: 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
  
file_path: PaddleDetection/ppdet/modeling/losses/gfocal_loss.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import numpy
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from ppdet.core.workspace import register, serializable
  from ppdet.modeling import ops
label_desc: Use image node_id 1 for calling a global function with example usage: quality_focal_loss(pred, target, beta, use_sigmoid) and returns: loss, loss