code: def parse_args():
      """parameter test."""
      parser = argparse.ArgumentParser(
          description="siamrpn tracking test result"
      )
      parser.add_argument(
          "--model-name",
          type=str,
          default="siamrpn_alexnet_v2_otb15",
          help="name of model.",
      )
      parser.add_argument(
          "--use-pretrained",
          action="store_true",
          default=False,
          help="enable using pretrained model from gluon.",
      )
      parser.add_argument(
          "--dtype",
          type=str,
          default="float32",
          help="data type for training. default is float32",
      )
      parser.add_argument(
          "--save-dir",
          type=str,
          default="params",
          help="directory of saved models",
      )
      parser.add_argument(
          "--batch-size",
          type=int,
          default=128,
          help="training batch size per device (CPU/GPU).",
      )
      parser.add_argument(
          "--ngpus", type=int, default=8, help="number of gpus to use."
      )
      parser.add_argument(
          "--resume-params",
          type=str,
          default=None,
          help="path of parameters to load from.",
      )
      parser.add_argument(
          "--logging-file",
          type=str,
          default="train.log",
          help="name of training log file",
      )
      parser.add_argument(
          "-j",
          "--num-data-workers",
          dest="num_workers",
          default=32,
          type=int,
          help="number of preprocessing workers",
      )
      parser.add_argument(
          "--epochs",
          type=int,
          default=50,
          help="number of training epochs.",
      )
      parser.add_argument(
          "--start-epoch",
          type=int,
          default=0,
          help="training start epochs.",
      )
      parser.add_argument(
          "--lr-mode", type=str, default="step", help="lr mode"
      )
      parser.add_argument(
          "--base-lr", type=float, default=0.005, help="base lr"
      )
      parser.add_argument(
          "--warmup-epochs",
          type=int,
          default=5,
          help="warmup epochs number",
      )
      parser.add_argument(
          "--weight-decay",
          type=float,
          default=1e-4,
          metavar="M",
          help="w-decay (default: 1e-4)",
      )
      parser.add_argument(
          "--momentum",
          type=float,
          default=0.9,
          metavar="M",
          help="momentum (default: 0.9)",
      )
      parser.add_argument(
          "--lr",
          type=float,
          default=1e-3,
          metavar="LR",
          help="learning rate (default: 1e-3)",
      )
      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(
          "--cls-weight",
          type=float,
          default=1.0,
          help="cls weight (default: 1e-3)",
      )
      parser.add_argument(
          "--loc-weight",
          type=float,
          default=1.2,
          help="loc weight (default: 1e-3)",
      )
      parser.add_argument(
          "--log-interval",
          type=int,
          default=128,
          help="Logging mini-batch interval. Default is 128.",
      )
      parser.add_argument(
          "--no-cuda",
          action="store_true",
          default=False,
          help="disables CUDA training",
      )
      parser.add_argument(
          "--syncbn",
          action="store_true",
          default=False,
          help="using Synchronized Cross-GPU BatchNorm",
      )
      parser.add_argument(
          "--accumulate",
          type=int,
          default=1,
          help="new step to accumulate gradient. If >1, the batch size is enlarged.",
      )
      parser.add_argument(
          "--use-amp",
          action="store_true",
          help="whether to use automatic mixed precision.",
      )
      parser.add_argument(
          "--no-val",
          action="store_true",
          default=True,
          help="skip validation during training",
      )
      parser.add_argument(
          "--mode",
          type=str,
          default="hybrid",
          help="mode in which to train the model. options are symbolic, hybrid",
      )
      parser.add_argument(
          "--is-train",
          type=str,
          default=True,
          help="whether to train the model. options are True, False",
      )
      opt = parser.parse_args()
  
      if opt.no_cuda:
          print("Using CPU")
          opt.ctx = [mx.cpu(0)]
      else:
          print("Number of GPUs:", opt.ngpus)
          assert (
              opt.ngpus > 0
          ), "No GPUs found, please enable --no-cuda for CPU mode."
          opt.ctx = [mx.gpu(i) for i in range(opt.ngpus)]
  
      # logging and checkpoint saving
      if not os.path.exists(opt.save_dir):
          os.makedirs(opt.save_dir)
  
      # Synchronized BatchNorm
      opt.norm_layer = (
          mx.gluon.contrib.nn.SyncBatchNorm
          if opt.syncbn
          else mx.gluon.nn.BatchNorm
      )
      opt.norm_kwargs = {"num_devices": opt.ngpus} if opt.syncbn else {}
      return opt
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  import argparse
  import logging
  import os
  import time
  import numpy
  import mxnet
  from mxnet import gluon, nd, autograd
  from mxnet.contrib import amp
  from gluoncv.utils import LRScheduler, LRSequential, split_and_load
  from gluoncv.data.tracking_data.track import TrkDataset
  from gluoncv.model_zoo import get_model
  from gluoncv.loss import SiamRPNLoss
label_desc: Use image node_id 1 for calling a global function with example usage: parse_args() and returns: opt