code: def __init__(
      self,
      cfg,
      cls_ch_squeeze,
      cls_ch_expand,
      multiplier=1.0,
      classes=1000,
      norm_kwargs=None,
      last_gamma=False,
      final_drop=0.0,
      use_global_stats=False,
      name_prefix="",
      norm_layer=BatchNorm,
  ):
      super(_MobileNetV3, self).__init__(prefix=name_prefix)
      norm_kwargs = norm_kwargs if norm_kwargs is not None else {}
      if use_global_stats:
          norm_kwargs["use_global_stats"] = True
      # initialize residual networks
      k = multiplier
      self.last_gamma = last_gamma
      self.norm_kwargs = norm_kwargs
      self.inplanes = 16
  
      with self.name_scope():
          self.features = nn.HybridSequential(prefix="")
          self.features.add(
              nn.Conv2D(
                  channels=make_divisible(k * self.inplanes),
                  kernel_size=3,
                  padding=1,
                  strides=2,
                  use_bias=False,
                  prefix="first-3x3-conv-conv2d_",
              )
          )
          self.features.add(
              norm_layer(prefix="first-3x3-conv-batchnorm_")
          )
          self.features.add(HardSwish())
          i = 0
          for layer_cfg in cfg:
              layer = self._make_layer(
                  kernel_size=layer_cfg[0],
                  exp_ch=make_divisible(k * layer_cfg[1]),
                  out_channel=make_divisible(k * layer_cfg[2]),
                  use_se=layer_cfg[3],
                  act_func=layer_cfg[4],
                  stride=layer_cfg[5],
                  prefix="seq-%d" % i,
              )
              self.features.add(layer)
              i += 1
          self.features.add(
              nn.Conv2D(
                  channels=make_divisible(k * cls_ch_squeeze),
                  kernel_size=1,
                  padding=0,
                  strides=1,
                  use_bias=False,
                  prefix="last-1x1-conv1-conv2d_",
              )
          )
          self.features.add(
              norm_layer(
                  prefix="last-1x1-conv1-batchnorm_",
                  **({} if norm_kwargs is None else norm_kwargs),
              )
          )
          self.features.add(HardSwish())
          self.features.add(nn.GlobalAvgPool2D())
          self.features.add(
              nn.Conv2D(
                  channels=cls_ch_expand,
                  kernel_size=1,
                  padding=0,
                  strides=1,
                  use_bias=False,
                  prefix="last-1x1-conv2-conv2d_",
              )
          )
          self.features.add(HardSwish())
  
          if final_drop > 0:
              self.features.add(nn.Dropout(final_drop))
          self.output = nn.HybridSequential(prefix="output_")
          with self.output.name_scope():
              self.output.add(
                  nn.Conv2D(
                      in_channels=cls_ch_expand,
                      channels=classes,
                      kernel_size=1,
                      prefix="fc_",
                  ),
                  nn.Flatten(),
              )
  
imports: from __future__ import division
  import numpy
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from mxnet.gluon.block import HybridBlock
  from mxnet.context import cpu
  from ..nn import ReLU6, HardSigmoid, HardSwish
label_desc: Use image node_id 1 to create a new _MobileNetV3 object from inherited base classes: HybridBlock with example: obj = _MobileNetV3(cfg, cls_ch_squeeze, cls_ch_expand, multiplier, classes, norm_kwargs, last_gamma, final_drop, use_global_stats, name_prefix, norm_layer)