code: def add_keypoint_losses(model):
      """Add Mask R-CNN keypoint specific losses."""
      # Reshape input from (N, K, H, W) to (NK, HW)
      model.net.Reshape(
          ["kps_score"],
          ["kps_score_reshaped", "_kps_score_old_shape"],
          shape=(-1, cfg.KRCNN.HEATMAP_SIZE * cfg.KRCNN.HEATMAP_SIZE),
      )
      # Softmax across **space** (woahh....space!)
      # Note: this is not what is commonly called "spatial softmax"
      # (i.e., softmax applied along the channel dimension at each spatial
      # location); This is softmax applied over a set of spatial locations (i.e.,
      # each spatial location is a "class").
      kps_prob, loss_kps = model.net.SoftmaxWithLoss(
          [
              "kps_score_reshaped",
              "keypoint_locations_int32",
              "keypoint_weights",
          ],
          ["kps_prob", "loss_kps"],
          scale=cfg.KRCNN.LOSS_WEIGHT / cfg.NUM_GPUS,
          spatial=0,
      )
      if not cfg.KRCNN.NORMALIZE_BY_VISIBLE_KEYPOINTS:
          # Discussion: the softmax loss above will average the loss by the sum of
          # keypoint_weights, i.e. the total number of visible keypoints. Since
          # the number of visible keypoints can vary significantly between
          # minibatches, this has the effect of up-weighting the importance of
          # minibatches with few visible keypoints. (Imagine the extreme case of
          # only one visible keypoint versus N: in the case of N, each one
          # contributes 1/N to the gradient compared to the single keypoint
          # determining the gradient direction). Instead, we can normalize the
          # loss by the total number of keypoints, if it were the case that all
          # keypoints were visible in a full minibatch. (Returning to the example,
          # this means that the one visible keypoint contributes as much as each
          # of the N keypoints.)
          model.StopGradient(
              "keypoint_loss_normalizer", "keypoint_loss_normalizer"
          )
          loss_kps = model.net.Mul(
              ["loss_kps", "keypoint_loss_normalizer"],
              "loss_kps_normalized",
          )
      loss_gradients = blob_utils.get_loss_gradients(model, [loss_kps])
      model.AddLosses(loss_kps)
      return loss_gradients
  
file_path: dense-pose/detectron/modeling/keypoint_rcnn_heads.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  from detectron.core.config import cfg
  from detectron.utils.c2 import const_fill
  from detectron.utils.c2 import gauss_fill
  import detectron.modeling.ResNet
  import detectron.utils.blob
label_desc: Use image node_id 2 for calling a global function with example usage: add_keypoint_losses(model) and returns: loss_gradients