class_docstr: A mask point head use in PointRend.
  
  ``PointHead`` use shared multi-layer perceptron (equivalent to
  nn.Conv1d) to predict the logit of input points. The fine-grained feature
  and coarse feature will be concatenate together for predication.
  
  Args:
      num_fcs (int): Number of fc layers in the head. Default: 3.
      in_channels (int): Number of input channels. Default: 256.
      fc_channels (int): Number of fc channels. Default: 256.
      num_classes (int): Number of classes for logits. Default: 80.
      class_agnostic (bool): Whether use class agnostic classification.
          If so, the output channels of logits will be 1. Default: False.
      coarse_pred_each_layer (bool): Whether concatenate coarse feature with
          the output of each fc layer. Default: True.
      conv_cfg (dict|None): Dictionary to construct and config conv layer.
          Default: dict(type='Conv1d'))
      norm_cfg (dict|None): Dictionary to construct and config norm layer.
          Default: None.
      loss_point (dict): Dictionary to construct and config loss layer of
          point head. Default: dict(type='CrossEntropyLoss', use_mask=True,
          loss_weight=1.0).
code: def __init__(
      self,
      num_fcs=3,
      coarse_pred_each_layer=True,
      conv_cfg=dict(type="Conv1d"),
      norm_cfg=None,
      act_cfg=dict(type="ReLU", inplace=False),
      **kwargs,
  ):
      super(PointHead, self).__init__(
          input_transform="multiple_select",
          conv_cfg=conv_cfg,
          norm_cfg=norm_cfg,
          act_cfg=act_cfg,
          **kwargs,
      )
  
      self.num_fcs = num_fcs
      self.coarse_pred_each_layer = coarse_pred_each_layer
  
      fc_in_channels = sum(self.in_channels) + self.num_classes
      fc_channels = self.channels
      self.fcs = nn.ModuleList()
      for k in range(num_fcs):
          fc = ConvModule(
              fc_in_channels,
              fc_channels,
              kernel_size=1,
              stride=1,
              padding=0,
              conv_cfg=conv_cfg,
              norm_cfg=norm_cfg,
              act_cfg=act_cfg,
          )
          self.fcs.append(fc)
          fc_in_channels = fc_channels
          fc_in_channels += (
              self.num_classes if self.coarse_pred_each_layer else 0
          )
      self.fc_seg = nn.Conv1d(
          fc_in_channels,
          self.num_classes,
          kernel_size=1,
          stride=1,
          padding=0,
      )
      if self.dropout_ratio > 0:
          self.dropout = nn.Dropout(self.dropout_ratio)
      delattr(self, "conv_seg")
  
imports: import torch
  import torch.nn
  from annotator.uniformer.mmcv.cnn import ConvModule, normal_init
  from annotator.uniformer.mmcv.ops import point_sample
  from annotator.uniformer.mmseg.models.builder import HEADS
  from annotator.uniformer.mmseg.ops import resize
  from ..losses import accuracy
  from .cascade_decode_head import BaseCascadeDecodeHead
label_desc: Use image node_id 1 to create a new PointHead object from inherited base classes: BaseCascadeDecodeHead with example: obj = PointHead(num_fcs, coarse_pred_each_layer, conv_cfg, norm_cfg, act_cfg)