code: def parse_args(logger=None):
      def float_list(x):
          return list(map(float, x.split(",")))
  
      data_dir = "~/.mxnet/datasets/imagenet/"
      parser = argparse.ArgumentParser(
          description="Train a model for image classification."
      )
      parser.add_argument(
          "--data-backend",
          choices=("dali-gpu", "dali-cpu", "mxnet"),
          default="mxnet",
          help="set data loading & augmentation backend",
      )
      parser.add_argument(
          "--data-dir",
          type=str,
          default=data_dir,
          help="training and validation pictures to use.",
      )
      parser.add_argument(
          "--rec-train",
          type=str,
          default=data_dir + "rec/train.rec",
          help="the training data",
      )
      parser.add_argument(
          "--rec-train-idx",
          type=str,
          default=data_dir + "rec/train.idx",
          help="the index of training data",
      )
      parser.add_argument(
          "--rec-val",
          type=str,
          default=data_dir + "rec/val.rec",
          help="the validation data",
      )
      parser.add_argument(
          "--rec-val-idx",
          type=str,
          default=data_dir + "rec/val.idx",
          help="the index of validation data",
      )
      parser.add_argument(
          "--use-rec",
          action="store_true",
          help="use image record iter for data input. default is false.",
      )
      parser.add_argument(
          "--batch-size",
          type=int,
          default=32,
          help="training batch size per device (CPU/GPU).",
      )
      parser.add_argument(
          "--dtype",
          type=str,
          default="float32",
          help="data type for training. default is float32",
      )
      parser.add_argument(
          "--num-gpus",
          type=int,
          default=0,
          help="number of gpus to use.",
      )
      parser.add_argument(
          "-j",
          "--num-data-workers",
          dest="num_workers",
          default=4,
          type=int,
          help="number of preprocessing workers",
      )
      parser.add_argument(
          "--num-epochs",
          type=int,
          default=3,
          help="number of training epochs.",
      )
      parser.add_argument(
          "--lr",
          type=float,
          default=0.1,
          help="learning rate. default is 0.1.",
      )
      parser.add_argument(
          "--momentum",
          type=float,
          default=0.9,
          help="momentum value for optimizer, default is 0.9.",
      )
      parser.add_argument(
          "--wd",
          type=float,
          default=0.0001,
          help="weight decay rate. default is 0.0001.",
      )
      parser.add_argument(
          "--lr-mode",
          type=str,
          default="step",
          help="learning rate scheduler mode. options are step, poly and cosine.",
      )
      parser.add_argument(
          "--lr-decay",
          type=float,
          default=0.1,
          help="decay rate of learning rate. default is 0.1.",
      )
      parser.add_argument(
          "--lr-decay-period",
          type=int,
          default=0,
          help="interval for periodic learning rate decays. default is 0 to disable.",
      )
      parser.add_argument(
          "--lr-decay-epoch",
          type=str,
          default="40,60",
          help="epochs at which learning rate decays. default is 40,60.",
      )
      parser.add_argument(
          "--warmup-lr",
          type=float,
          default=0.0,
          help="starting warmup learning rate. default is 0.0.",
      )
      parser.add_argument(
          "--warmup-epochs",
          type=int,
          default=0,
          help="number of warmup epochs.",
      )
      parser.add_argument(
          "--last-gamma",
          action="store_true",
          help="whether to init gamma of the last BN layer in each bottleneck to 0.",
      )
      parser.add_argument(
          "--mode",
          type=str,
          help="mode in which to train the model. options are symbolic, imperative, hybrid",
      )
      parser.add_argument(
          "--model",
          type=str,
          required=True,
          help="type of model to use. see vision_model for options.",
      )
      parser.add_argument(
          "--input-size",
          type=int,
          default=224,
          help="size of the input image size. default is 224",
      )
      parser.add_argument(
          "--crop-ratio",
          type=float,
          default=0.875,
          help="Crop ratio during validation. default is 0.875",
      )
      parser.add_argument(
          "--use-pretrained",
          action="store_true",
          help="enable using pretrained model from gluon.",
      )
      parser.add_argument(
          "--use_se",
          action="store_true",
          help="use SE layers or not in resnext. default is false.",
      )
      parser.add_argument(
          "--mixup",
          action="store_true",
          help="whether train the model with mix-up. default is false.",
      )
      parser.add_argument(
          "--mixup-alpha",
          type=float,
          default=0.2,
          help="beta distribution parameter for mixup sampling, default is 0.2.",
      )
      parser.add_argument(
          "--mixup-off-epoch",
          type=int,
          default=0,
          help="how many last epochs to train without mixup, default is 0.",
      )
      parser.add_argument(
          "--label-smoothing",
          action="store_true",
          help="use label smoothing or not in training. default is false.",
      )
      parser.add_argument(
          "--no-wd",
          action="store_true",
          help="whether to remove weight decay on bias, and beta/gamma for batchnorm layers.",
      )
      parser.add_argument(
          "--teacher",
          type=str,
          default=None,
          help="teacher model for distillation training",
      )
      parser.add_argument(
          "--temperature",
          type=float,
          default=20,
          help="temperature parameter for distillation teacher model",
      )
      parser.add_argument(
          "--hard-weight",
          type=float,
          default=0.5,
          help="weight for the loss of one-hot label for distillation training",
      )
      parser.add_argument(
          "--batch-norm",
          action="store_true",
          help="enable batch normalization or not in vgg. default is false.",
      )
      parser.add_argument(
          "--save-frequency",
          type=int,
          default=10,
          help="frequency of model saving.",
      )
      parser.add_argument(
          "--save-dir",
          type=str,
          default="params",
          help="directory of saved models",
      )
      parser.add_argument(
          "--resume-epoch",
          type=int,
          default=0,
          help="epoch to resume training from.",
      )
      parser.add_argument(
          "--resume-params",
          type=str,
          default="",
          help="path of parameters to load from.",
      )
      parser.add_argument(
          "--resume-states",
          type=str,
          default="",
          help="path of trainer state to load from.",
      )
      parser.add_argument(
          "--log-interval",
          type=int,
          default=50,
          help="Number of batches to wait before logging.",
      )
      parser.add_argument(
          "--logging-file",
          type=str,
          default="train_imagenet.log",
          help="name of training log file",
      )
      parser.add_argument(
          "--use-gn",
          action="store_true",
          help="whether to use group norm.",
      )
      parser.add_argument(
          "--rgb-mean",
          type=float_list,
          default=[123.68, 116.779, 103.939],
          help="a tuple of size 3 for the mean rgb",
      )
      parser.add_argument(
          "--rgb-std",
          type=float_list,
          default=[58.393, 57.12, 57.375],
          help="a tuple of size 3 for the std rgb",
      )
      parser.add_argument(
          "--num-training-samples",
          type=int,
          default=1281167,
          help="Number of training samples",
      )
      if logger:
          # DALI is expected to be used
          dali_ver = "DALI_VER"
          dali_version = (
              os.environ.get(dali_ver)
              if dali_ver in os.environ
              else "nvidia-dali-cuda100"
          )
          stream = os.popen("pip list --format=columns | grep dali")
          if stream.read() == "":
              # DALI is not installed
              cmd_install = (
                  "pip install --extra-index-url https://developer.download.nvidia.com/compute/redist "
                  + dali_version
              )
              logger.info(
                  "DALI is supposed to be used, but it is not installed.\nWe can try to install it for you (and continue this test) OR\n"
                  "this test will be stopped and you can later restart it after installing DALI manually"
              )
              answer = input("Do you want to install DALI now? (Y/N):")
              if answer[0] == "Y" or answer[0] == "y":
                  logger.info(
                      "Trying to install DALI version '%s'"
                      % dali_version
                  )
                  ret = os.system(cmd_install)
                  if ret != 0:
                      logger.info(
                          "Cannot install DALI version '%s'.\n"
                          "Perhaps, the latest DALI version should be used.\n"
                          % dali_version
                      )
              else:
                  ret = 1
                  logger.info(
                      "To install DALI, please, use:\n" + cmd_install
                  )
              if ret != 0:
                  logger.info(
                      "Please, see documentation on "
                      "https://docs.nvidia.com/deeplearning/dali/user-guide/docs/installation.html\n"
                      "and set the environment variable %s to the appropriate version ID (default is '%s')"
                      % (dali_ver, dali_version)
                  )
                  raise RuntimeError("DALI is not installed")
          try:
              import dali
          except ImportError:
              raise ImportError("Unable to import modules dali.py")
  
          parser = dali.add_dali_args(parser)
          dali.add_data_args(parser)
      return parser.parse_args()
  
file_path: gluon-cv/scripts/classification/imagenet/train_imagenet.py
imports: import argparse, time, logging, os, math
  import numpy
  import mxnet
  from mxnet import gluon, nd
  from mxnet import autograd
  from mxnet.gluon.data.vision import transforms
  import gluoncv
  from gluoncv.data import imagenet
  from gluoncv.model_zoo import get_model
  from gluoncv.utils import makedirs, LRSequential, LRScheduler
label_desc: Use image node_id 1 for calling a global function with example usage: parse_args(logger) and returns: parser, list