class_docstr: Head of `VarifocalNet (VFNet): An IoU-aware Dense Object
  Detector.<https://arxiv.org/abs/2008.13367>`_.
  
  The VFNet predicts IoU-aware classification scores which mix the
  object presence confidence and object localization accuracy as the
  detection score. It is built on the FCOS architecture and uses ATSS
  for defining positive/negative training examples. The VFNet is trained
  with Varifocal Loss and empolys star-shaped deformable convolution to
  extract features for a bbox.
  
  Args:
      num_classes (int): Number of categories excluding the background
          category.
      in_channels (int): Number of channels in the input feature map.
      regress_ranges (tuple[tuple[int, int]]): Regress range of multiple
          level points.
      center_sampling (bool): If true, use center sampling. Default: False.
      center_sample_radius (float): Radius of center sampling. Default: 1.5.
      sync_num_pos (bool): If true, synchronize the number of positive
          examples across GPUs. Default: True
      gradient_mul (float): The multiplier to gradients from bbox refinement
          and recognition. Default: 0.1.
      bbox_norm_type (str): The bbox normalization type, 'reg_denom' or
          'stride'. Default: reg_denom
      loss_cls_fl (dict): Config of focal loss.
      use_vfl (bool): If true, use varifocal loss for training.
          Default: True.
      loss_cls (dict): Config of varifocal loss.
      loss_bbox (dict): Config of localization loss, GIoU Loss.
      loss_bbox (dict): Config of localization refinement loss, GIoU Loss.
      norm_cfg (dict): dictionary to construct and config norm layer.
          Default: norm_cfg=dict(type='GN', num_groups=32,
          requires_grad=True).
      use_atss (bool): If true, use ATSS to define positive/negative
          examples. Default: True.
      anchor_generator (dict): Config of anchor generator for ATSS.
  
  Example:
      >>> self = VFNetHead(11, 7)
      >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
      >>> cls_score, bbox_pred, bbox_pred_refine= self.forward(feats)
      >>> assert len(cls_score) == len(self.scales)
docstr: Compute the star deformable conv offsets.
  
  Args:
      bbox_pred (Tensor): Predicted bbox distance offsets (l, r, t, b).
      gradient_mul (float): Gradient multiplier.
      stride (int): The corresponding stride for feature maps,
          used to project the bbox onto the feature map.
  
  Returns:
      dcn_offsets (Tensor): The offsets for deformable convolution.
docstr_tok: ["Compute","the","star","deformable","conv","offsets",".","Args",":","bbox_pred","(","Tensor",")",":","Predicted","bbox","distance","offsets","(","l",",","r",",","t",",","b",")",".","gradient_mul","(","float",")",":","Gradient","multiplier",".","stride","(","int",")",":","The","corresponding","stride","for","feature","maps",",","used","to","project","the","bbox","onto","the","feature","map",".","Returns",":","dcn_offsets","(","Tensor",")",":","The","offsets","for","deformable","convolution","."]
code: def star_dcn_offset(self, bbox_pred, gradient_mul, stride):
      """Compute the star deformable conv offsets.
  
      Args:
          bbox_pred (Tensor): Predicted bbox distance offsets (l, r, t, b).
          gradient_mul (float): Gradient multiplier.
          stride (int): The corresponding stride for feature maps,
              used to project the bbox onto the feature map.
  
      Returns:
          dcn_offsets (Tensor): The offsets for deformable convolution.
      """
      dcn_base_offset = self.dcn_base_offset.type_as(bbox_pred)
      bbox_pred_grad_mul = (
          1 - gradient_mul
      ) * bbox_pred.detach() + gradient_mul * bbox_pred
      # map to the feature map scale
      bbox_pred_grad_mul = bbox_pred_grad_mul / stride
      N, C, H, W = bbox_pred.size()
  
      x1 = bbox_pred_grad_mul[:, 0, :, :]
      y1 = bbox_pred_grad_mul[:, 1, :, :]
      x2 = bbox_pred_grad_mul[:, 2, :, :]
      y2 = bbox_pred_grad_mul[:, 3, :, :]
      bbox_pred_grad_mul_offset = bbox_pred.new_zeros(
          N, 2 * self.num_dconv_points, H, W
      )
      bbox_pred_grad_mul_offset[:, 0, :, :] = -1.0 * y1  # -y1
      bbox_pred_grad_mul_offset[:, 1, :, :] = -1.0 * x1  # -x1
      bbox_pred_grad_mul_offset[:, 2, :, :] = -1.0 * y1  # -y1
      bbox_pred_grad_mul_offset[:, 4, :, :] = -1.0 * y1  # -y1
      bbox_pred_grad_mul_offset[:, 5, :, :] = x2  # x2
      bbox_pred_grad_mul_offset[:, 7, :, :] = -1.0 * x1  # -x1
      bbox_pred_grad_mul_offset[:, 11, :, :] = x2  # x2
      bbox_pred_grad_mul_offset[:, 12, :, :] = y2  # y2
      bbox_pred_grad_mul_offset[:, 13, :, :] = -1.0 * x1  # -x1
      bbox_pred_grad_mul_offset[:, 14, :, :] = y2  # y2
      bbox_pred_grad_mul_offset[:, 16, :, :] = y2  # y2
      bbox_pred_grad_mul_offset[:, 17, :, :] = x2  # x2
      dcn_offset = bbox_pred_grad_mul_offset - dcn_base_offset
  
      return dcn_offset
  
imports: import numpy
  import torch
  import torch.nn
  from mmcv.cnn import ConvModule, Scale, bias_init_with_prob, normal_init
  from mmcv.ops import DeformConv2d
  from mmcv.runner import force_fp32
  from mmdet.core import bbox2distance, bbox_overlaps, build_anchor_generator, build_assigner, build_sampler, distance2bbox, multi_apply, multiclass_nms, reduce_mean
  from ..builder import HEADS, build_loss
  from .atss_head import ATSSHead
  from .fcos_head import FCOSHead
label_desc: Use image node_id 6 for calling the VFNetHead obj's underlying member method code with example usage: obj.star_dcn_offset(bbox_pred, gradient_mul, stride) and returns: dcn_offset