docstr: scores (Tensor): scores from bbox head outputs
  deltas (Tensor): deltas from bbox head outputs
  targets (list[List[Tensor]]): bbox targets containing tgt_labels, tgt_bboxes and tgt_gt_inds
  rois (List[Tensor]): RoIs generated in each batch
docstr_tok: ["scores","(","Tensor",")",":","scores","from","bbox","head","outputs","deltas","(","Tensor",")",":","deltas","from","bbox","head","outputs","targets","(","list","[","List","[","Tensor","]","]",")",":","bbox","targets","containing","tgt_labels",",","tgt_bboxes","and","tgt_gt_inds","rois","(","List","[","Tensor","]",")",":","RoIs","generated","in","each","batch"]
code: def get_loss(
      self,
      scores,
      deltas,
      targets,
      rois,
      bbox_weight,
      loss_normalize_pos=False,
  ):
      """
      scores (Tensor): scores from bbox head outputs
      deltas (Tensor): deltas from bbox head outputs
      targets (list[List[Tensor]]): bbox targets containing tgt_labels, tgt_bboxes and tgt_gt_inds
      rois (List[Tensor]): RoIs generated in each batch
      """
      cls_name = "loss_bbox_cls"
      reg_name = "loss_bbox_reg"
      loss_bbox = {}
  
      # TODO: better pass args
      tgt_labels, tgt_bboxes, tgt_gt_inds = targets
  
      # bbox cls
      tgt_labels = (
          paddle.concat(tgt_labels)
          if len(tgt_labels) > 1
          else tgt_labels[0]
      )
      valid_inds = paddle.nonzero(tgt_labels >= 0).flatten()
      if valid_inds.shape[0] == 0:
          loss_bbox[cls_name] = paddle.zeros([1], dtype="float32")
      else:
          tgt_labels = tgt_labels.cast("int64")
          tgt_labels.stop_gradient = True
  
          if not loss_normalize_pos:
              loss_bbox_cls = F.cross_entropy(
                  input=scores, label=tgt_labels, reduction="mean"
              )
          else:
              loss_bbox_cls = F.cross_entropy(
                  input=scores, label=tgt_labels, reduction="none"
              ).sum() / (tgt_labels.shape[0] + 1e-7)
  
          loss_bbox[cls_name] = loss_bbox_cls
  
      # bbox reg
  
      cls_agnostic_bbox_reg = deltas.shape[1] == 4
  
      fg_inds = paddle.nonzero(
          paddle.logical_and(
              tgt_labels >= 0, tgt_labels < self.num_classes
          )
      ).flatten()
  
      if fg_inds.numel() == 0:
          loss_bbox[reg_name] = paddle.zeros([1], dtype="float32")
          return loss_bbox
  
      if cls_agnostic_bbox_reg:
          reg_delta = paddle.gather(deltas, fg_inds)
      else:
          fg_gt_classes = paddle.gather(tgt_labels, fg_inds)
  
          reg_row_inds = paddle.arange(
              fg_gt_classes.shape[0]
          ).unsqueeze(1)
          reg_row_inds = paddle.tile(reg_row_inds, [1, 4]).reshape(
              [-1, 1]
          )
  
          reg_col_inds = 4 * fg_gt_classes.unsqueeze(1) + paddle.arange(
              4
          )
  
          reg_col_inds = reg_col_inds.reshape([-1, 1])
          reg_inds = paddle.concat([reg_row_inds, reg_col_inds], axis=1)
  
          reg_delta = paddle.gather(deltas, fg_inds)
          reg_delta = paddle.gather_nd(reg_delta, reg_inds).reshape(
              [-1, 4]
          )
      rois = paddle.concat(rois) if len(rois) > 1 else rois[0]
      tgt_bboxes = (
          paddle.concat(tgt_bboxes)
          if len(tgt_bboxes) > 1
          else tgt_bboxes[0]
      )
  
      reg_target = bbox2delta(rois, tgt_bboxes, bbox_weight)
      reg_target = paddle.gather(reg_target, fg_inds)
      reg_target.stop_gradient = True
  
      if self.bbox_loss is not None:
          reg_delta = self.bbox_transform(reg_delta)
          reg_target = self.bbox_transform(reg_target)
  
          if not loss_normalize_pos:
              loss_bbox_reg = (
                  self.bbox_loss(reg_delta, reg_target).sum()
                  / tgt_labels.shape[0]
              )
              loss_bbox_reg *= self.num_classes
  
          else:
              loss_bbox_reg = self.bbox_loss(
                  reg_delta, reg_target
              ).sum() / (tgt_labels.shape[0] + 1e-7)
  
      else:
          loss_bbox_reg = (
              paddle.abs(reg_delta - reg_target).sum()
              / tgt_labels.shape[0]
          )
  
      loss_bbox[reg_name] = loss_bbox_reg
  
      return loss_bbox
  
imports: import numpy
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle.nn.initializer import Normal, XavierUniform, KaimingNormal
  from paddle.regularizer import L2Decay
  from ppdet.core.workspace import register, create
  from .roi_extractor import RoIAlign
  from ..shape_spec import ShapeSpec
  from ..bbox_utils import bbox2delta
  from ..cls_utils import _get_class_default_kwargs
  from ppdet.modeling.layers import ConvNormLayer
label_desc: Use image node_id 5 for calling the BBoxHead obj's underlying member method code with example usage: obj.get_loss(scores, deltas, targets, rois, bbox_weight, loss_normalize_pos) and returns: loss_bbox, loss_bbox