code: def get_symbol(num_classes, image_shape, **kwargs):
      image_shape = [int(l) for l in image_shape.split(",")]
      (nchannel, height, width) = image_shape
      # attr = {'force_mirroring': 'true'}
      attr = {}
  
      # data
      data = mx.symbol.Variable(name="data")
      if height <= 28:
          # a simper version
          conv1 = ConvFactory(
              data=data,
              kernel=(3, 3),
              pad=(1, 1),
              name="1",
              num_filter=96,
              attr=attr,
          )
          in3a = SimpleFactory(conv1, 32, 32, "in3a", attr)
          in3b = SimpleFactory(in3a, 32, 48, "in3b", attr)
          in3c = DownsampleFactory(in3b, 80, "in3c", attr)
          in4a = SimpleFactory(in3c, 112, 48, "in4a", attr)
          in4b = SimpleFactory(in4a, 96, 64, "in4b", attr)
          in4c = SimpleFactory(in4b, 80, 80, "in4c", attr)
          in4d = SimpleFactory(in4c, 48, 96, "in4d", attr)
          in4e = DownsampleFactory(in4d, 96, "in4e", attr)
          in5a = SimpleFactory(in4e, 176, 160, "in5a", attr)
          in5b = SimpleFactory(in5a, 176, 160, "in5b", attr)
          pool = mx.symbol.Pooling(
              data=in5b,
              pool_type="avg",
              kernel=(7, 7),
              name="global_pool",
              attr=attr,
          )
      else:
          # stage 1
          conv1 = ConvFactory(
              data=data,
              num_filter=64,
              kernel=(7, 7),
              stride=(2, 2),
              pad=(3, 3),
              name="1",
          )
          pool1 = mx.symbol.Pooling(
              data=conv1,
              kernel=(3, 3),
              stride=(2, 2),
              name="pool_1",
              pool_type="max",
          )
          # stage 2
          conv2red = ConvFactory(
              data=pool1,
              num_filter=64,
              kernel=(1, 1),
              stride=(1, 1),
              name="2_red",
          )
          conv2 = ConvFactory(
              data=conv2red,
              num_filter=192,
              kernel=(3, 3),
              stride=(1, 1),
              pad=(1, 1),
              name="2",
          )
          pool2 = mx.symbol.Pooling(
              data=conv2,
              kernel=(3, 3),
              stride=(2, 2),
              name="pool_2",
              pool_type="max",
          )
          # stage 2
          in3a = InceptionFactoryA(
              pool2, 64, 64, 64, 64, 96, "avg", 32, "3a"
          )
          in3b = InceptionFactoryA(
              in3a, 64, 64, 96, 64, 96, "avg", 64, "3b"
          )
          in3c = InceptionFactoryB(in3b, 128, 160, 64, 96, "3c")
          # stage 3
          in4a = InceptionFactoryA(
              in3c, 224, 64, 96, 96, 128, "avg", 128, "4a"
          )
          in4b = InceptionFactoryA(
              in4a, 192, 96, 128, 96, 128, "avg", 128, "4b"
          )
          in4c = InceptionFactoryA(
              in4b, 160, 128, 160, 128, 160, "avg", 128, "4c"
          )
          in4d = InceptionFactoryA(
              in4c, 96, 128, 192, 160, 192, "avg", 128, "4d"
          )
          in4e = InceptionFactoryB(in4d, 128, 192, 192, 256, "4e")
          # stage 4
          in5a = InceptionFactoryA(
              in4e, 352, 192, 320, 160, 224, "avg", 128, "5a"
          )
          in5b = InceptionFactoryA(
              in5a, 352, 192, 320, 192, 224, "max", 128, "5b"
          )
          # global avg pooling
          pool = mx.symbol.Pooling(
              data=in5b,
              kernel=(7, 7),
              stride=(1, 1),
              name="global_pool",
              pool_type="avg",
          )
  
      # linear classifier
      flatten = mx.symbol.Flatten(data=pool)
      fc1 = mx.symbol.FullyConnected(
          data=flatten, num_hidden=num_classes
      )
      softmax = mx.symbol.SoftmaxOutput(data=fc1, name="softmax")
      return softmax
  
imports: import mxnet
label_desc: Use image node_id 6 for calling a global function with example usage: get_symbol(num_classes, image_shape) and returns: softmax