class_docstr: Base class for classification and segmentation
      
class_docstr_tok: ["Base","class","for","classification","and","segmentation"]
code: def __init__(
      self,
      cfg,
      stage_interp_type="nearst",
      norm_layer=BatchNorm,
      norm_kwargs=None,
      **kwargs,
  ):
      self.stage_interp_type = stage_interp_type
      super(HighResolutionBaseNet, self).__init__()
  
      self.conv1 = nn.Conv2D(
          64, kernel_size=3, strides=2, padding=1, use_bias=False
      )
      self.bn1 = norm_layer(
          **({} if norm_kwargs is None else norm_kwargs)
      )
      self.conv2 = nn.Conv2D(
          64, kernel_size=3, strides=2, padding=1, use_bias=False
      )
      self.bn2 = norm_layer(
          **({} if norm_kwargs is None else norm_kwargs)
      )
  
      self.stage1_cfg = cfg[0]
      num_channels = self.stage1_cfg[3][0]
      block = BLOCKS_DICT[self.stage1_cfg[1]]
      num_blocks = self.stage1_cfg[2][0]
      self.layer1 = self._make_layer(
          block, num_channels, num_blocks, inplanes=64
      )
      stage1_out_channel = block.expansion * num_channels
  
      self.stage2_cfg = cfg[1]
      num_channels = self.stage2_cfg[3]
      block = BLOCKS_DICT[self.stage2_cfg[1]]
      num_channels = [
          num_channels[i] * block.expansion
          for i in range(len(num_channels))
      ]
      self.transition1 = self._make_transition_layer(
          [stage1_out_channel], num_channels, norm_layer, norm_kwargs
      )
      self.stage2, pre_stage_channels = self._make_stage(
          self.stage2_cfg, num_channels
      )
  
      self.stage3_cfg = cfg[2]
      num_channels = self.stage3_cfg[3]
      block = BLOCKS_DICT[self.stage3_cfg[1]]
      num_channels = [
          num_channels[i] * block.expansion
          for i in range(len(num_channels))
      ]
      self.transition2 = self._make_transition_layer(
          pre_stage_channels, num_channels, norm_layer, norm_kwargs
      )
      self.stage3, pre_stage_channels = self._make_stage(
          self.stage3_cfg, num_channels
      )
  
      self.stage4_cfg = cfg[3]
      num_channels = self.stage4_cfg[3]
      block = BLOCKS_DICT[self.stage4_cfg[1]]
      num_channels = [
          num_channels[i] * block.expansion
          for i in range(len(num_channels))
      ]
      self.transition3 = self._make_transition_layer(
          pre_stage_channels, num_channels, norm_layer, norm_kwargs
      )
      self.stage4, pre_stage_channels = self._make_stage(
          self.stage4_cfg, num_channels, multi_scale_output=True
      )
  
      self.pre_stage_channels = pre_stage_channels
  
imports: import numpy
  from mxnet.gluon import contrib
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from mxnet.context import cpu
  from .resnet import BasicBlockV1, BottleneckV1, _conv3x3
label_desc: Use image node_id 1 to create a new HighResolutionBaseNet object from inherited base classes: nn with example: obj = HighResolutionBaseNet(cfg, stage_interp_type, norm_layer, norm_kwargs)