docstr: Tests condinst bboxhead loss when truth is empty and non-empty.
docstr_tok: ["Tests","condinst","bboxhead","loss","when","truth","is","empty","and","non-empty","."]
code: def test_condinst_bboxhead_loss(self):
      """Tests condinst bboxhead loss when truth is empty and non-empty."""
      s = 256
      img_metas = [
          {
              "img_shape": (s, s, 3),
              "pad_shape": (s, s, 3),
              "scale_factor": 1,
          }
      ]
      condinst_bboxhead = CondInstBboxHead(
          num_classes=4,
          in_channels=1,
          feat_channels=1,
          stacked_convs=1,
          norm_cfg=None,
      )
  
      # Fcos head expects a multiple levels of features per image
      feats = (
          torch.rand(1, 1, s // stride[1], s // stride[0])
          for stride in condinst_bboxhead.prior_generator.strides
      )
      (
          cls_scores,
          bbox_preds,
          centernesses,
          param_preds,
      ) = condinst_bboxhead.forward(feats)
  
      # 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_instances.masks = _rand_masks(
          0, gt_instances.bboxes.numpy(), s, s
      )
  
      empty_gt_losses = condinst_bboxhead.loss_by_feat(
          cls_scores,
          bbox_preds,
          centernesses,
          param_preds,
          [gt_instances],
          img_metas,
      )
      # When there is no truth, the cls loss should be nonzero but
      # box loss and centerness loss should be zero
      empty_cls_loss = empty_gt_losses["loss_cls"].item()
      empty_box_loss = empty_gt_losses["loss_bbox"].item()
      empty_ctr_loss = empty_gt_losses["loss_centerness"].item()
      self.assertGreater(
          empty_cls_loss, 0, "cls loss should be non-zero"
      )
      self.assertEqual(
          empty_box_loss,
          0,
          "there should be no box loss when there are no true boxes",
      )
      self.assertEqual(
          empty_ctr_loss,
          0,
          "there should be no centerness loss when there are no true boxes",
      )
  
      # When truth is non-empty then all cls, box loss and centerness 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])
      gt_instances.masks = _rand_masks(
          1, gt_instances.bboxes.numpy(), s, s
      )
  
      one_gt_losses = condinst_bboxhead.loss_by_feat(
          cls_scores,
          bbox_preds,
          centernesses,
          param_preds,
          [gt_instances],
          img_metas,
      )
      onegt_cls_loss = one_gt_losses["loss_cls"].item()
      onegt_box_loss = one_gt_losses["loss_bbox"].item()
      onegt_ctr_loss = one_gt_losses["loss_centerness"].item()
      self.assertGreater(
          onegt_cls_loss, 0, "cls loss should be non-zero"
      )
      self.assertGreater(
          onegt_box_loss, 0, "box loss should be non-zero"
      )
      self.assertGreater(
          onegt_ctr_loss, 0, "centerness loss should be non-zero"
      )
  
      # Test the `center_sampling` works fine.
      condinst_bboxhead.center_sampling = True
      ctrsamp_losses = condinst_bboxhead.loss_by_feat(
          cls_scores,
          bbox_preds,
          centernesses,
          param_preds,
          [gt_instances],
          img_metas,
      )
      ctrsamp_cls_loss = ctrsamp_losses["loss_cls"].item()
      ctrsamp_box_loss = ctrsamp_losses["loss_bbox"].item()
      ctrsamp_ctr_loss = ctrsamp_losses["loss_centerness"].item()
      self.assertGreater(
          ctrsamp_cls_loss, 0, "cls loss should be non-zero"
      )
      self.assertGreater(
          ctrsamp_box_loss, 0, "box loss should be non-zero"
      )
      self.assertGreater(
          ctrsamp_ctr_loss, 0, "centerness loss should be non-zero"
      )
  
      # Test the `norm_on_bbox` works fine.
      condinst_bboxhead.norm_on_bbox = True
      normbox_losses = condinst_bboxhead.loss_by_feat(
          cls_scores,
          bbox_preds,
          centernesses,
          param_preds,
          [gt_instances],
          img_metas,
      )
      normbox_cls_loss = normbox_losses["loss_cls"].item()
      normbox_box_loss = normbox_losses["loss_bbox"].item()
      normbox_ctr_loss = normbox_losses["loss_centerness"].item()
      self.assertGreater(
          normbox_cls_loss, 0, "cls loss should be non-zero"
      )
      self.assertGreater(
          normbox_box_loss, 0, "box loss should be non-zero"
      )
      self.assertGreater(
          normbox_ctr_loss, 0, "centerness loss should be non-zero"
      )
  
file_path: mmdetection/tests/test_models/test_dense_heads/test_condinst_head.py
imports: from unittest import TestCase
  import numpy
  import torch
  from mmengine.config import ConfigDict
  from mmengine.structures import InstanceData
  from mmdet.models.dense_heads import CondInstBboxHead, CondInstMaskHead
  from mmdet.structures.mask import BitmapMasks
label_desc: Use image node_id 1 for calling the TestCondInstHead obj's underlying member method code with example usage: obj.test_condinst_bboxhead_loss() without return types