code: def center_focal_loss(
      pred, gt, weight=None, mask=None, avg_factor=None, reduction=None
  ):
      """Modified focal loss. Exactly the same as CornerNet.
      Runs faster and costs a little bit more memory.
  
      Args:
          pred (Tensor): The prediction with shape [bs, c, h, w].
          gt (Tensor): The learning target of the prediction in gaussian
              distribution, with shape [bs, c, h, w].
          mask (Tensor): The valid mask. Defaults to None.
      """
      if not gt.astype("bool").any():
          return pred.sum() * 0
      pos_inds = gt.equal(1).astype("float32")
      if mask is None:
          neg_inds = gt.less_than(
              paddle.to_tensor([1], dtype="float32")
          ).astype("float32")
      else:
          neg_inds = gt.less_than(
              paddle.to_tensor([1], dtype="float32")
          ).astype("float32") * mask.equal(0).astype("float32")
  
      neg_weights = paddle.pow(1 - gt, 4)
  
      loss = 0
  
      pos_loss = paddle.log(pred) * paddle.pow(1 - pred, 2) * pos_inds
      neg_loss = (
          paddle.log(1 - pred)
          * paddle.pow(pred, 2)
          * neg_weights
          * neg_inds
      )
  
      num_pos = pos_inds.astype("float32").sum()
      pos_loss = pos_loss.sum()
      neg_loss = neg_loss.sum()
  
      if num_pos == 0:
          loss = loss - neg_loss
      else:
          loss = loss - (pos_loss + neg_loss) / num_pos
  
      if weight is not None:
          if weight.shape != loss.shape:
              if weight.shape[0] == loss.shape[0]:
                  # For most cases, weight is of shape (num_priors, ),
                  #  which means it does not have the second axis num_class
                  weight = weight.reshape((-1, 1))
              else:
                  # Sometimes, weight per anchor per class is also needed. e.g.
                  #  in FSAF. But it may be flattened of shape
                  #  (num_priors x num_class, ), while loss is still of shape
                  #  (num_priors, num_class).
                  assert weight.numel() == loss.numel()
                  weight = weight.reshape((loss.shape[0], -1))
          assert weight.ndim == loss.ndim
          loss = loss * weight
  
      # if avg_factor is not specified, just reduce the loss
      if avg_factor is None:
          if reduction == "mean":
              loss = loss.mean()
          elif reduction == "sum":
              loss = loss.sum()
      else:
          # if reduction is mean, then average the loss by avg_factor
          if reduction == "mean":
              # Avoid causing ZeroDivisionError when avg_factor is 0.0,
              # i.e., all labels of an image belong to ignore index.
              eps = 1e-10
              loss = loss.sum() / (avg_factor + eps)
          # if reduction is 'none', then do nothing, otherwise raise an error
          elif reduction != "none":
              raise ValueError(
                  'avg_factor can not be used with reduction="sum"'
              )
  
      return loss
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from itertools import cycle, islice
  from collections import abc
  import numpy
  import paddle
  import paddle.nn
  from ppdet.core.workspace import register, serializable
label_desc: Use image node_id 4 for calling a global function with example usage: center_focal_loss(pred, gt, weight, mask, avg_factor, reduction) and returns: loss, unknown