class_docstr: GFLHead
  Args:
      conv_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
      loss_class (object): Instance of QualityFocalLoss.
      loss_dfl (object): Instance of DistributionFocalLoss.
      loss_bbox (object): Instance of bbox loss.
      reg_max: Max value of integral set :math: `{0, ..., reg_max}`
              n QFL setting. Default: 16.
code: def __init__(
      self,
      conv_feat="FCOSFeat",
      dgqp_module=None,
      num_classes=80,
      fpn_stride=[8, 16, 32, 64, 128],
      prior_prob=0.01,
      loss_class="QualityFocalLoss",
      loss_dfl="DistributionFocalLoss",
      loss_bbox="GIoULoss",
      reg_max=16,
      feat_in_chan=256,
      nms=None,
      nms_pre=1000,
      cell_offset=0,
  ):
      super(GFLHead, self).__init__()
      self.conv_feat = conv_feat
      self.dgqp_module = dgqp_module
      self.num_classes = num_classes
      self.fpn_stride = fpn_stride
      self.prior_prob = prior_prob
      self.loss_qfl = loss_class
      self.loss_dfl = loss_dfl
      self.loss_bbox = loss_bbox
      self.reg_max = reg_max
      self.feat_in_chan = feat_in_chan
      self.nms = nms
      self.nms_pre = nms_pre
      self.cell_offset = cell_offset
      self.use_sigmoid = self.loss_qfl.use_sigmoid
      if self.use_sigmoid:
          self.cls_out_channels = self.num_classes
      else:
          self.cls_out_channels = self.num_classes + 1
  
      conv_cls_name = "gfl_head_cls"
      bias_init_value = -math.log(
          (1 - self.prior_prob) / self.prior_prob
      )
      self.gfl_head_cls = self.add_sublayer(
          conv_cls_name,
          nn.Conv2D(
              in_channels=self.feat_in_chan,
              out_channels=self.cls_out_channels,
              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 = "gfl_head_reg"
      self.gfl_head_reg = self.add_sublayer(
          conv_reg_name,
          nn.Conv2D(
              in_channels=self.feat_in_chan,
              out_channels=4 * (self.reg_max + 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)
  
      self.distribution_project = Integral(self.reg_max)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import numpy
  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.bbox_utils import distance2bbox, bbox2distance, batch_distance2bbox
  from ppdet.data.transform.atss_assigner import bbox_overlaps
label_desc: Use image node_id 1 to create a new GFLHead object from inherited base classes: nn with example: obj = GFLHead(conv_feat, dgqp_module, num_classes, fpn_stride, prior_prob, loss_class, loss_dfl, loss_bbox, reg_max, feat_in_chan, nms, nms_pre, cell_offset)