code: def _get_retinanet_blobs(
      foas, all_anchors, gt_boxes, gt_classes, im_width, im_height
  ):
      total_anchors = all_anchors.shape[0]
      logger.debug(
          "Getting mad blobs: im_height {} im_width: {}".format(
              im_height, im_width
          )
      )
  
      inds_inside = np.arange(all_anchors.shape[0])
      anchors = all_anchors
      num_inside = len(inds_inside)
  
      logger.debug("total_anchors: {}".format(total_anchors))
      logger.debug("inds_inside: {}".format(num_inside))
      logger.debug("anchors.shape: {}".format(anchors.shape))
  
      # Compute anchor labels:
      # label=1 is positive, 0 is negative, -1 is don't care (ignore)
      labels = np.empty((num_inside,), dtype=np.float32)
      labels.fill(-1)
      if len(gt_boxes) > 0:
          # Compute overlaps between the anchors and the gt boxes overlaps
          anchor_by_gt_overlap = box_utils.bbox_overlaps(
              anchors, gt_boxes
          )
          # Map from anchor to gt box that has highest overlap
          anchor_to_gt_argmax = anchor_by_gt_overlap.argmax(axis=1)
          # For each anchor, amount of overlap with most overlapping gt box
          anchor_to_gt_max = anchor_by_gt_overlap[
              np.arange(num_inside), anchor_to_gt_argmax
          ]
  
          # Map from gt box to an anchor that has highest overlap
          gt_to_anchor_argmax = anchor_by_gt_overlap.argmax(axis=0)
          # For each gt box, amount of overlap with most overlapping anchor
          gt_to_anchor_max = anchor_by_gt_overlap[
              gt_to_anchor_argmax,
              np.arange(anchor_by_gt_overlap.shape[1]),
          ]
          # Find all anchors that share the max overlap amount
          # (this includes many ties)
          anchors_with_max_overlap = np.where(
              anchor_by_gt_overlap == gt_to_anchor_max
          )[0]
  
          # Fg label: for each gt use anchors with highest overlap
          # (including ties)
          gt_inds = anchor_to_gt_argmax[anchors_with_max_overlap]
          labels[anchors_with_max_overlap] = gt_classes[gt_inds]
          # Fg label: above threshold IOU
          inds = anchor_to_gt_max >= cfg.RETINANET.POSITIVE_OVERLAP
          gt_inds = anchor_to_gt_argmax[inds]
          labels[inds] = gt_classes[gt_inds]
  
      fg_inds = np.where(labels >= 1)[0]
      bg_inds = np.where(
          anchor_to_gt_max < cfg.RETINANET.NEGATIVE_OVERLAP
      )[0]
      labels[bg_inds] = 0
      num_fg, num_bg = len(fg_inds), len(bg_inds)
  
      bbox_targets = np.zeros((num_inside, 4), dtype=np.float32)
      bbox_targets[fg_inds, :] = data_utils.compute_targets(
          anchors[fg_inds, :], gt_boxes[anchor_to_gt_argmax[fg_inds], :]
      )
  
      # Map up to original set of anchors
      labels = data_utils.unmap(
          labels, total_anchors, inds_inside, fill=-1
      )
      bbox_targets = data_utils.unmap(
          bbox_targets, total_anchors, inds_inside, fill=0
      )
  
      # Split the generated labels, etc. into labels per each field of anchors
      blobs_out = []
      start_idx = 0
      for foa in foas:
          H = foa.field_size
          W = foa.field_size
          end_idx = start_idx + H * W
          _labels = labels[start_idx:end_idx]
          _bbox_targets = bbox_targets[start_idx:end_idx, :]
          start_idx = end_idx
  
          # labels output with shape (1, height, width)
          _labels = _labels.reshape((1, 1, H, W))
          # bbox_targets output with shape (1, 4 * A, height, width)
          _bbox_targets = _bbox_targets.reshape((1, H, W, 4)).transpose(
              0, 3, 1, 2
          )
          stride = foa.stride
          w = int(im_width / stride)
          h = int(im_height / stride)
  
          # data for select_smooth_l1 loss
          num_classes = cfg.MODEL.NUM_CLASSES - 1
          inds_4d = np.where(_labels > 0)
          M = len(inds_4d)
          _roi_bbox_targets = np.zeros((0, 4))
          _roi_fg_bbox_locs = np.zeros((0, 4))
          if M > 0:
              im_inds, y, x = inds_4d[0], inds_4d[2], inds_4d[3]
              _roi_bbox_targets = np.zeros((len(im_inds), 4))
              _roi_fg_bbox_locs = np.zeros((len(im_inds), 4))
              lbls = _labels[im_inds, :, y, x]
              for i, lbl in enumerate(lbls):
                  l = lbl[0] - 1
                  if not cfg.RETINANET.CLASS_SPECIFIC_BBOX:
                      l = 0
                  assert (
                      l >= 0 and l < num_classes
                  ), "label out of the range"
                  _roi_bbox_targets[i, :] = _bbox_targets[
                      :, :, y[i], x[i]
                  ]
                  _roi_fg_bbox_locs[i, :] = np.array(
                      [[0, l, y[i], x[i]]]
                  )
          blobs_out.append(
              dict(
                  retnet_cls_labels=_labels[:, :, 0:h, 0:w].astype(
                      np.int32
                  ),
                  retnet_roi_bbox_targets=_roi_bbox_targets.astype(
                      np.float32
                  ),
                  retnet_roi_fg_bbox_locs=_roi_fg_bbox_locs.astype(
                      np.float32
                  ),
              )
          )
      out_num_fg = np.array([num_fg + 1.0], dtype=np.float32)
      out_num_bg = np.array([num_bg + 1.0]) * (
          cfg.MODEL.NUM_CLASSES - 1
      ) + out_num_fg * (cfg.MODEL.NUM_CLASSES - 2)
      return blobs_out, out_num_fg, out_num_bg
  
file_path: dense-pose/detectron/roi_data/retinanet.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  import numpy
  import logging
  import detectron.utils.boxes
  import detectron.roi_data.data_utils
  from detectron.core.config import cfg
label_desc: Use image node_id 3 for calling a global function with example usage: _get_retinanet_blobs(foas, all_anchors, gt_boxes, gt_classes, im_width, im_height) and returns: blobs_out,  out_num_fg,  out_num_bg