class_docstr: Used in RetinaNet proposed in paper https://arxiv.org/pdf/1708.02002.pdf
      
class_docstr_tok: ["Used","in","RetinaNet","proposed","in","paper","https",":","\/\/arxiv.org\/pdf\/1708.02002.pdf"]
docstr: Here we calculate loss for a batch of images.
  We assign anchors to gts in each image and gather all the assigned
  postive and negative samples. Then loss is calculated on the gathered
  samples.
docstr_tok: ["Here","we","calculate","loss","for","a","batch","of","images",".","We","assign","anchors","to","gts","in","each","image","and","gather","all","the","assigned","postive","and","negative","samples",".","Then","loss","is","calculated","on","the","gathered","samples","."]
code: def get_loss(self, head_outputs, targets):
      """Here we calculate loss for a batch of images.
      We assign anchors to gts in each image and gather all the assigned
      postive and negative samples. Then loss is calculated on the gathered
      samples.
      """
      cls_logits_list, bboxes_reg_list = head_outputs
      anchors = self.anchor_generator(cls_logits_list)
      anchors = paddle.concat(anchors)
  
      # matches: contain gt_inds
      # match_labels: -1(ignore), 0(neg) or 1(pos)
      matches_list, match_labels_list = [], []
      # assign anchors to gts, no sampling is involved
      for gt_bbox in targets["gt_bbox"]:
          matches, match_labels = self.bbox_assigner(anchors, gt_bbox)
          matches_list.append(matches)
          match_labels_list.append(match_labels)
  
      # reshape network outputs
      cls_logits = [
          _.transpose([0, 2, 3, 1]).reshape([0, -1, self.num_classes])
          for _ in cls_logits_list
      ]
      bboxes_reg = [
          _.transpose([0, 2, 3, 1]).reshape([0, -1, 4])
          for _ in bboxes_reg_list
      ]
      cls_logits = paddle.concat(cls_logits, axis=1)
      bboxes_reg = paddle.concat(bboxes_reg, axis=1)
  
      cls_pred_list, cls_tar_list = [], []
      reg_pred_list, reg_tar_list = [], []
      # find and gather preds and targets in each image
      for (
          matches,
          match_labels,
          cls_logit,
          bbox_reg,
          gt_bbox,
          gt_class,
      ) in zip(
          matches_list,
          match_labels_list,
          cls_logits,
          bboxes_reg,
          targets["gt_bbox"],
          targets["gt_class"],
      ):
          pos_mask = match_labels == 1
          neg_mask = match_labels == 0
          chosen_mask = paddle.logical_or(pos_mask, neg_mask)
  
          gt_class = gt_class.reshape([-1])
          bg_class = paddle.to_tensor(
              [self.num_classes], dtype=gt_class.dtype
          )
          # a trick to assign num_classes to negative targets
          gt_class = paddle.concat([gt_class, bg_class], axis=-1)
          matches = paddle.where(
              neg_mask,
              paddle.full_like(matches, gt_class.size - 1),
              matches,
          )
  
          cls_pred = cls_logit[chosen_mask]
          cls_tar = gt_class[matches[chosen_mask]]
          reg_pred = bbox_reg[pos_mask].reshape([-1, 4])
          reg_tar = gt_bbox[matches[pos_mask]].reshape([-1, 4])
          reg_tar = bbox2delta(anchors[pos_mask], reg_tar, self.weights)
          cls_pred_list.append(cls_pred)
          cls_tar_list.append(cls_tar)
          reg_pred_list.append(reg_pred)
          reg_tar_list.append(reg_tar)
      cls_pred = paddle.concat(cls_pred_list)
      cls_tar = paddle.concat(cls_tar_list)
      reg_pred = paddle.concat(reg_pred_list)
      reg_tar = paddle.concat(reg_tar_list)
  
      avg_factor = max(1.0, reg_pred.shape[0])
      cls_loss = (
          self.loss_class(cls_pred, cls_tar, reduction="sum")
          / avg_factor
      )
  
      if reg_pred.shape[0] == 0:
          reg_loss = paddle.zeros([1])
          reg_loss.stop_gradient = False
      else:
          reg_loss = (
              self.loss_bbox(reg_pred, reg_tar, reduction="sum")
              / avg_factor
          )
  
      loss = cls_loss + reg_loss
      out_dict = {
          "loss_cls": cls_loss,
          "loss_reg": reg_loss,
          "loss": loss,
      }
      return out_dict
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle import ParamAttr
  from paddle.nn.initializer import Normal, Constant
  from ppdet.modeling.bbox_utils import bbox2delta, delta2bbox
  from ppdet.modeling.heads.fcos_head import FCOSFeat
  from ppdet.core.workspace import register
label_desc: Use image node_id 3 for calling the RetinaHead obj's underlying member method code with example usage: obj.get_loss(head_outputs, targets) and returns: out_dict