code: def get_symbol_compact(
      num_classes, alpha=1, resolution=224, **kwargs
  ):
      assert (
          alpha in alpha_values
      ), "Invalid alpha={0}, must be one of {1}".format(
          alpha, alpha_values
      )
      assert resolution % 32 == 0, "resolution must be multiple of 32"
  
      base = int(32 * alpha)
  
      data = mx.symbol.Variable(name="data")  # 224
      conv_1 = Conv(
          data,
          num_filter=base,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(2, 2),
          name="conv_1",
      )  # 32*alpha, 224/112
  
      conv_2_dw = Conv(
          conv_1,
          num_group=base,
          num_filter=base,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          name="conv_2_dw",
      )  # 112/112
      conv_2 = Conv(
          conv_2_dw,
          num_filter=base * 2,
          kernel=(1, 1),
          pad=(0, 0),
          stride=(1, 1),
          name="conv_2",
      )  # 32*alpha, 112/112
  
      conv_3_dpw = Conv_DPW(
          conv_2, depth=base * 2, stride=(2, 2), idx=3
      )  # 64*alpha, 112/56 => 56/56
      conv_4_dpw = Conv_DPW(
          conv_3_dpw, depth=base * 4, stride=(1, 1), idx=4
      )  # 128*alpha, 56/56 =>56/56
      conv_5_dpw = Conv_DPW(
          conv_4_dpw, depth=base * 4, stride=(2, 2), idx=5
      )  # 128*alpha, 56/28 => 28/28
      conv_6_dpw = Conv_DPW(
          conv_5_dpw, depth=base * 8, stride=(1, 1), idx=6
      )  # 256*alpha, 28/28 => 28/28
      conv_7_dpw = Conv_DPW(
          conv_6_dpw, depth=base * 8, stride=(2, 2), idx=7
      )  # 256*alpha, 28/14 => 14/14
      conv_dpw = conv_7_dpw
  
      for idx in range(8, 13):
          conv_dpw = Conv_DPW(
              conv_dpw, depth=base * 16, stride=(1, 1), idx=idx
          )  # 512*alpha, 14/14
  
      conv_12_dpw = conv_dpw
      conv_13_dpw = Conv_DPW(
          conv_12_dpw, depth=base * 16, stride=(2, 2), idx=13
      )  # 512*alpha, 14/7 => 7/7
      conv_14_dpw = Conv_DPW(
          conv_13_dpw, depth=base * 32, stride=(1, 1), idx=14
      )  # 1024*alpha, 7/7 => 7/7
  
      pool_size = int(resolution / 32)
      pool = mx.sym.Pooling(
          data=conv_14_dpw,
          kernel=(pool_size, pool_size),
          stride=(1, 1),
          pool_type="avg",
          name="global_pool",
      )
      flatten = mx.sym.Flatten(data=pool, name="flatten")
      fc = mx.symbol.FullyConnected(
          data=flatten, num_hidden=num_classes, name="fc"
      )
      softmax = mx.symbol.SoftmaxOutput(data=fc, name="softmax")
      return softmax
  
imports: import mxnet
label_desc: Use image node_id 3 for calling a global function with example usage: get_symbol_compact(num_classes, alpha, resolution) and returns: softmax