code: def _create_quantized_models(name, sym_prefix):
      def func(
          pretrained=False,
          tag=None,
          root="~/.mxnet/models",
          ctx=cpu(0),
          **kwargs,
      ):
          r"""Quantized model.
  
          Parameters
          ----------
          pretrained : bool or str
              Boolean value controls whether to load the default pretrained weights for model.
              String value represents the hashtag for a certain version of pretrained weights.
          tag : str, default is None
              Optional length-8 sha1sum of parameter file. If `None`, best parameter file
              will be used.
          ctx : Context, default CPU
              The context in which to load the pretrained weights.
          root : str, default $MXNET_HOME/models
              Location for keeping the model parameters.
          """
          from ..model_zoo import get_model
          from ..model_store import get_model_file
  
          curr_dir = os.path.abspath(os.path.dirname(__file__))
          model_name = name.replace("mobilenet1_", "mobilenet1.")
          model_name = model_name.replace("mobilenet0_", "mobilenet0.")
          with warnings.catch_warnings(record=True) as w:
              warnings.simplefilter("always")
              import tempfile
  
              if (
                  "fcn" in model_name
                  or "psp" in model_name
                  or "deeplab" in model_name
                  or "simple_pose" in model_name
                  or "ucf" in model_name
                  or "kinetics" in model_name
              ):
                  model_json = get_compressed_model(
                      model_name, _compressed_int8_json
                  )
                  fd, path = tempfile.mkstemp(
                      dir=curr_dir, suffix=".json", text=True
                  )
                  with open(path, "w") as f:
                      f.write(model_json)
                  sym_net = SymbolBlock.imports(
                      path, ["data"], None, ctx=ctx
                  )
                  os.close(fd)
                  try:
                      os.remove(path)
                  except:
                      pass
              else:
                  json_file = os.path.join(
                      curr_dir, "{}-symbol.json".format(model_name)
                  )
                  sym_net = SymbolBlock.imports(
                      json_file, ["data"], None, ctx=ctx
                  )
              base_name = "_".join(model_name.split("_")[:-1])
              param_file = (
                  get_model_file(base_name, tag=tag, root=root)
                  if pretrained
                  else None
              )
              kw = {}
              if "deeplab" not in base_name:
                  kw.update({"prefix": sym_prefix})
              net = get_model(
                  "_".join(model_name.split("_")[:-1]), **kw
              )
              classes = getattr(net, "classes", [])
              if param_file:
                  # directly imports weights saved by save_parameters is not applicable
                  # so we hack it by load and export once to a temporary params file
                  net.load_params(param_file)
                  net.hybridize()
                  if "512" in base_name:
                      net(mx.nd.zeros((1, 3, 512, 512)))
                  elif "300" in base_name:
                      net(mx.nd.zeros((1, 3, 300, 300)))
                  elif "psp" in base_name or "deeplab" in base_name:
                      net(mx.nd.zeros((1, 3, 480, 480)))
                  elif "inceptionv3" in base_name:
                      net(mx.nd.zeros((1, 3, 299, 299)))
                  else:
                      net(mx.nd.zeros((1, 3, 224, 224)))
                  with tempfile.TemporaryDirectory() as tmpdirname:
                      prefix = os.path.join(tmpdirname, "tmp")
                      net.export(prefix, epoch=0)
                      param_prefix = prefix + "-0000.params"
                      sym_net.collect_params().load(param_prefix)
          sym_net.classes = classes
          sym_net.reset_class = _not_impl
          sym_net.set_nms = _not_impl
          return sym_net
  
      func.__name__ = name
      globals()[name] = func
  
imports: import os
  import warnings
  import mxnet
  from mxnet.context import cpu
  from mxnet.gluon import SymbolBlock
  from gluoncv.utils.compress_json import get_compressed_model
label_desc: Use image node_id 2 for calling a global function with example usage: _create_quantized_models(name, sym_prefix) and returns: sym_net