code: def test_head_loss(self, transform_method="moment"):
      cfg = ConfigDict(
          dict(
              num_classes=2,
              in_channels=32,
              point_feat_channels=10,
              num_points=9,
              gradient_mul=0.1,
              point_strides=[8, 16, 32, 64, 128],
              point_base_scale=4,
              loss_cls=dict(
                  type="FocalLoss",
                  use_sigmoid=True,
                  gamma=2.0,
                  alpha=0.25,
                  loss_weight=1.0,
              ),
              loss_bbox_init=dict(
                  type="SmoothL1Loss", beta=1.0 / 9.0, loss_weight=0.5
              ),
              loss_bbox_refine=dict(
                  type="SmoothL1Loss", beta=1.0 / 9.0, loss_weight=1.0
              ),
              use_grid_points=False,
              center_init=True,
              transform_method=transform_method,
              moment_mul=0.01,
              init_cfg=dict(
                  type="Normal",
                  layer="Conv2d",
                  std=0.01,
                  override=dict(
                      type="Normal",
                      name="reppoints_cls_out",
                      std=0.01,
                      bias_prob=0.01,
                  ),
              ),
              train_cfg=dict(
                  init=dict(
                      assigner=dict(
                          type="PointAssigner", scale=4, pos_num=1
                      ),
                      allowed_border=-1,
                      pos_weight=-1,
                      debug=False,
                  ),
                  refine=dict(
                      assigner=dict(
                          type="MaxIoUAssigner",
                          pos_iou_thr=0.5,
                          neg_iou_thr=0.4,
                          min_pos_iou=0,
                          ignore_iof_thr=-1,
                      ),
                      allowed_border=-1,
                      pos_weight=-1,
                      debug=False,
                  ),
              ),
              test_cfg=dict(
                  nms_pre=1000,
                  min_bbox_size=0,
                  score_thr=0.05,
                  nms=dict(type="nms", iou_threshold=0.5),
                  max_per_img=100,
              ),
          )
      )
      reppoints_head = RepPointsHead(**cfg)
      s = 256
      img_metas = [
          {
              "img_shape": (s, s),
              "scale_factor": (1, 1),
              "pad_shape": (s, s),
              "batch_input_shape": (s, s),
          }
      ]
      x = [
          torch.rand(1, 32, s // 2 ** (i + 2), s // 2 ** (i + 2))
          for i in range(5)
      ]
  
      # Test that empty ground truth encourages the network to
      # predict background
      gt_instances = InstanceData()
      gt_instances.bboxes = torch.empty((0, 4))
      gt_instances.labels = torch.LongTensor([])
      gt_bboxes_ignore = None
  
      reppoints_head.train()
      forward_outputs = reppoints_head.forward(x)
      empty_gt_losses = reppoints_head.loss_by_feat(
          *forward_outputs, [gt_instances], img_metas, gt_bboxes_ignore
      )
      # When there is no truth, the cls loss should be nonzero but there
      # should be no pts loss.
      for key, losses in empty_gt_losses.items():
          for loss in losses:
              if "cls" in key:
                  self.assertGreater(
                      loss.item(), 0, "cls loss should be non-zero"
                  )
              elif "pts" in key:
                  self.assertEqual(
                      loss.item(),
                      0,
                      "there should be no reg loss when no ground true boxes",
                  )
  
      # When truth is non-empty then both cls and pts loss should be nonzero
      # for random inputs
      gt_instances = InstanceData()
      gt_instances.bboxes = torch.Tensor(
          [[23.6667, 23.8757, 238.6326, 151.8874]]
      )
      gt_instances.labels = torch.LongTensor([2])
      one_gt_losses = reppoints_head.loss_by_feat(
          *forward_outputs, [gt_instances], img_metas, gt_bboxes_ignore
      )
      # loss_cls should all be non-zero
      self.assertTrue(
          all([loss.item() > 0 for loss in one_gt_losses["loss_cls"]])
      )
      # only one level loss_pts_init is non-zero
      cnt_non_zero = 0
      for loss in one_gt_losses["loss_pts_init"]:
          if loss.item() != 0:
              cnt_non_zero += 1
      self.assertEqual(cnt_non_zero, 1)
  
      # only one level loss_pts_refine is non-zero
      cnt_non_zero = 0
      for loss in one_gt_losses["loss_pts_init"]:
          if loss.item() != 0:
              cnt_non_zero += 1
      self.assertEqual(cnt_non_zero, 1)
  
      # test loss
      samples = DetDataSample()
      samples.set_metainfo(img_metas[0])
      samples.gt_instances = gt_instances
      reppoints_head.loss(x, [samples])
      # test only predict
      reppoints_head.eval()
      reppoints_head.predict(x, [samples], rescale=True)
  
file_path: mmdetection/tests/test_models/test_dense_heads/test_reppoints_head.py
imports: import unittest
  import torch
  from mmengine.config import ConfigDict
  from mmengine.structures import InstanceData
  from parameterized import parameterized
  from mmdet.models.dense_heads import RepPointsHead
  from mmdet.structures import DetDataSample
label_desc: Use image node_id 1 for calling the TestRepPointsHead obj's underlying member method code with example usage: obj.test_head_loss(transform_method) without return types