class_docstr: Image Cascade Network (ICNet)
  
  Parameters
  ----------
  nclass : int
      Number of categories for the training dataset.
  backbone : string
      Pre-trained dilated backbone network type (default:'resnet50'; 'resnet50',
      'resnet101' or 'resnet152').
  norm_layer : object
      Normalization layer used in backbone network (default: :class:`mxnet.gluon.nn.BatchNorm`;
      for Synchronized Cross-GPU BachNormalization).
  norm_kwargs : dict
      Additional `norm_layer` arguments, for example `num_devices=4`
      for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`.
  pretrained_base : bool or str
      Refers to if the backbone is pretrained or not. If `True`,
      model weights of a model that was trained on ImageNet is loaded.
  
  Reference:
  
      Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi and Jiaya Jia.
      "ICNet for Real-Time Semantic Segmentation on High-Resolution Images." *ECCV*, 2018
  
  Examples
  --------
  >>> model = ICNet(nclass=19, backbone='resnet50')
  >>> print(model)
code: def __init__(
      self,
      nclass,
      backbone="resnet50",
      aux=False,
      ctx=cpu(),
      pretrained_base=True,
      height=None,
      width=None,
      base_size=520,
      crop_size=480,
      lr_mult=10,
      **kwargs,
  ):
      super(ICNet, self).__init__(
          nclass,
          aux=aux,
          backbone=backbone,
          ctx=ctx,
          base_size=base_size,
          crop_size=crop_size,
          pretrained_base=pretrained_base,
          **kwargs,
      )
  
      height = height if height is not None else crop_size
      width = width if width is not None else crop_size
      self._up_kwargs = {"height": height, "width": width}
      self.base_size = base_size
      self.crop_size = crop_size
  
      with self.name_scope():
          # large resolution branch
          self.conv_sub1 = nn.HybridSequential()
          with self.conv_sub1.name_scope():
              self.conv_sub1.add(
                  ConvBnRelu(3, 32, 3, 2, 1, **kwargs),
                  ConvBnRelu(32, 32, 3, 2, 1, **kwargs),
                  ConvBnRelu(32, 64, 3, 2, 1, **kwargs),
              )
          self.conv_sub1.initialize(ctx=ctx)
          self.conv_sub1.collect_params().setattr("lr_mult", lr_mult)
  
          # small and medium resolution branches, backbone comes from segbase.py
          self.psp_head = _PSPHead(
              nclass,
              feature_map_height=self._up_kwargs["height"] // 32,
              feature_map_width=self._up_kwargs["width"] // 32,
              **kwargs,
          )
          self.psp_head.block = self.psp_head.block[:-1]
          self.psp_head.initialize(ctx=ctx)
          self.psp_head.collect_params().setattr("lr_mult", lr_mult)
  
          # ICNet head
          self.head = _ICHead(
              nclass=nclass,
              height=self._up_kwargs["height"],
              width=self._up_kwargs["width"],
              **kwargs,
          )
          self.head.initialize(ctx=ctx)
          self.head.collect_params().setattr("lr_mult", lr_mult)
  
          # reduce conv
          self.conv_sub4 = ConvBnRelu(512, 256, 1, **kwargs)
          self.conv_sub4.initialize(ctx=ctx)
          self.conv_sub4.collect_params().setattr("lr_mult", lr_mult)
  
          self.conv_sub2 = ConvBnRelu(512, 256, 1, **kwargs)
          self.conv_sub2.initialize(ctx=ctx)
          self.conv_sub2.collect_params().setattr("lr_mult", lr_mult)
  
imports: from __future__ import division
  from mxnet.gluon import nn
  from mxnet.context import cpu
  from mxnet.gluon.nn import HybridBlock
  from gluoncv.model_zoo.segbase import SegBaseModel
  from gluoncv.model_zoo.pspnet import _PSPHead
label_desc: Use image node_id 1 to create a new ICNet object from inherited base classes: SegBaseModel with example: obj = ICNet(nclass, backbone, aux, ctx, pretrained_base, height, width, base_size, crop_size, lr_mult)