class_docstr: FCOSHead of ARSL for semi-det(ssod)
  Args:
      fcos_feat (object): Instance of 'FCOSFeat'
      num_classes (int): Number of classes
      fpn_stride (list): The stride of each FPN Layer
      prior_prob (float): Used to set the bias init for the class prediction layer
      fcos_loss (object): Instance of 'FCOSLoss'
      norm_reg_targets (bool): Normalization the regression target if true
      centerness_on_reg (bool): The prediction of centerness on regression or clssification branch
      nms (object): Instance of 'MultiClassNMS'
      trt (bool): Whether to use trt in nms of deploy
code: def __init__(
      self,
      num_classes=80,
      fcos_feat="FCOSFeat",
      fpn_stride=[8, 16, 32, 64, 128],
      prior_prob=0.01,
      multiply_strides_reg_targets=False,
      norm_reg_targets=True,
      centerness_on_reg=True,
      num_shift=0.5,
      sqrt_score=False,
      fcos_loss="FCOSLossMILC",
      nms="MultiClassNMS",
      trt=False,
  ):
      super(FCOSHead_ARSL, self).__init__()
      self.fcos_feat = fcos_feat
      self.num_classes = num_classes
      self.fpn_stride = fpn_stride
      self.prior_prob = prior_prob
      self.fcos_loss = fcos_loss
      self.norm_reg_targets = norm_reg_targets
      self.centerness_on_reg = centerness_on_reg
      self.multiply_strides_reg_targets = multiply_strides_reg_targets
      self.num_shift = num_shift
      self.nms = nms
      if isinstance(self.nms, MultiClassNMS) and trt:
          self.nms.trt = trt
      self.sqrt_score = sqrt_score
  
      conv_cls_name = "fcos_head_cls"
      bias_init_value = -math.log(
          (1 - self.prior_prob) / self.prior_prob
      )
      self.fcos_head_cls = self.add_sublayer(
          conv_cls_name,
          nn.Conv2D(
              in_channels=256,
              out_channels=self.num_classes,
              kernel_size=3,
              stride=1,
              padding=1,
              weight_attr=ParamAttr(
                  initializer=Normal(mean=0.0, std=0.01)
              ),
              bias_attr=ParamAttr(
                  initializer=Constant(value=bias_init_value)
              ),
          ),
      )
  
      conv_reg_name = "fcos_head_reg"
      self.fcos_head_reg = self.add_sublayer(
          conv_reg_name,
          nn.Conv2D(
              in_channels=256,
              out_channels=4,
              kernel_size=3,
              stride=1,
              padding=1,
              weight_attr=ParamAttr(
                  initializer=Normal(mean=0.0, std=0.01)
              ),
              bias_attr=ParamAttr(initializer=Constant(value=0)),
          ),
      )
  
      conv_centerness_name = "fcos_head_centerness"
      self.fcos_head_centerness = self.add_sublayer(
          conv_centerness_name,
          nn.Conv2D(
              in_channels=256,
              out_channels=1,
              kernel_size=3,
              stride=1,
              padding=1,
              weight_attr=ParamAttr(
                  initializer=Normal(mean=0.0, std=0.01)
              ),
              bias_attr=ParamAttr(initializer=Constant(value=0)),
          ),
      )
  
      self.scales_regs = []
      for i in range(len(self.fpn_stride)):
          lvl = int(math.log(int(self.fpn_stride[i]), 2))
          feat_name = "p{}_feat".format(lvl)
          scale_reg = self.add_sublayer(feat_name, ScaleReg())
          self.scales_regs.append(scale_reg)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle import ParamAttr
  from paddle.nn.initializer import Normal, Constant
  from ppdet.core.workspace import register
  from ppdet.modeling.layers import ConvNormLayer, MultiClassNMS
label_desc: Use image node_id 1 to create a new FCOSHead_ARSL object from inherited base classes: FCOSHead with example: obj = FCOSHead_ARSL(num_classes, fcos_feat, fpn_stride, prior_prob, multiply_strides_reg_targets, norm_reg_targets, centerness_on_reg, num_shift, sqrt_score, fcos_loss, nms, trt)