code: def get_args_parser(add_help=True):
      import argparse
  
      parser = argparse.ArgumentParser(
          description="PyTorch Quantized Classification Training",
          add_help=add_help,
      )
  
      parser.add_argument(
          "--data-path",
          default="/datasets01/imagenet_full_size/061417/",
          type=str,
          help="dataset path",
      )
      parser.add_argument(
          "--model", default="mobilenet_v2", type=str, help="model name"
      )
      parser.add_argument(
          "--qbackend",
          default="qnnpack",
          type=str,
          help="Quantized backend: fbgemm or qnnpack",
      )
      parser.add_argument(
          "--device",
          default="cuda",
          type=str,
          help="device (Use cuda or cpu Default: cuda)",
      )
  
      parser.add_argument(
          "-b",
          "--batch-size",
          default=32,
          type=int,
          help="images per gpu, the total batch size is $NGPU x batch_size",
      )
      parser.add_argument(
          "--eval-batch-size",
          default=128,
          type=int,
          help="batch size for evaluation",
      )
      parser.add_argument(
          "--epochs",
          default=90,
          type=int,
          metavar="N",
          help="number of total epochs to run",
      )
      parser.add_argument(
          "--num-observer-update-epochs",
          default=4,
          type=int,
          metavar="N",
          help="number of total epochs to update observers",
      )
      parser.add_argument(
          "--num-batch-norm-update-epochs",
          default=3,
          type=int,
          metavar="N",
          help="number of total epochs to update batch norm stats",
      )
      parser.add_argument(
          "--num-calibration-batches",
          default=32,
          type=int,
          metavar="N",
          help="number of batches of training set for \
                                observer calibration ",
      )
  
      parser.add_argument(
          "-j",
          "--workers",
          default=16,
          type=int,
          metavar="N",
          help="number of data loading workers (default: 16)",
      )
      parser.add_argument(
          "--lr",
          default=0.0001,
          type=float,
          help="initial learning rate",
      )
      parser.add_argument(
          "--momentum",
          default=0.9,
          type=float,
          metavar="M",
          help="momentum",
      )
      parser.add_argument(
          "--wd",
          "--weight-decay",
          default=1e-4,
          type=float,
          metavar="W",
          help="weight decay (default: 1e-4)",
          dest="weight_decay",
      )
      parser.add_argument(
          "--lr-step-size",
          default=30,
          type=int,
          help="decrease lr every step-size epochs",
      )
      parser.add_argument(
          "--lr-gamma",
          default=0.1,
          type=float,
          help="decrease lr by a factor of lr-gamma",
      )
      parser.add_argument(
          "--print-freq", default=10, type=int, help="print frequency"
      )
      parser.add_argument(
          "--output-dir",
          default=".",
          type=str,
          help="path to save outputs",
      )
      parser.add_argument(
          "--resume", default="", type=str, help="path of checkpoint"
      )
      parser.add_argument(
          "--start-epoch",
          default=0,
          type=int,
          metavar="N",
          help="start epoch",
      )
      parser.add_argument(
          "--cache-dataset",
          dest="cache_dataset",
          help="Cache the datasets for quicker initialization. \
               It also serializes the transforms",
          action="store_true",
      )
      parser.add_argument(
          "--sync-bn",
          dest="sync_bn",
          help="Use sync batch norm",
          action="store_true",
      )
      parser.add_argument(
          "--test-only",
          dest="test_only",
          help="Only test the model",
          action="store_true",
      )
      parser.add_argument(
          "--post-training-quantize",
          dest="post_training_quantize",
          help="Post training quantize the model",
          action="store_true",
      )
  
      # distributed training parameters
      parser.add_argument(
          "--world-size",
          default=1,
          type=int,
          help="number of distributed processes",
      )
      parser.add_argument(
          "--dist-url",
          default="env://",
          type=str,
          help="url used to set up distributed training",
      )
  
      parser.add_argument(
          "--interpolation",
          default="bilinear",
          type=str,
          help="the interpolation method (default: bilinear)",
      )
      parser.add_argument(
          "--val-resize-size",
          default=256,
          type=int,
          help="the resize size used for validation (default: 256)",
      )
      parser.add_argument(
          "--val-crop-size",
          default=224,
          type=int,
          help="the central crop size used for validation (default: 224)",
      )
      parser.add_argument(
          "--train-crop-size",
          default=224,
          type=int,
          help="the random crop size used for training (default: 224)",
      )
      parser.add_argument(
          "--clip-grad-norm",
          default=None,
          type=float,
          help="the maximum gradient norm (default None)",
      )
      parser.add_argument(
          "--weights",
          default=None,
          type=str,
          help="the weights enum name to load",
      )
  
      parser.add_argument(
          "--backend",
          default="PIL",
          type=str.lower,
          help="PIL or tensor - case insensitive",
      )
      parser.add_argument(
          "--use-v2", action="store_true", help="Use V2 transforms"
      )
  
      return parser
  
file_path: vision/references/classification/train_quantization.py
imports: import copy
  import datetime
  import os
  import time
  import torch
  import torch.ao.quantization
  import torch.utils.data
  import torchvision
  import utils
  from torch import nn
  from train import evaluate, load_data, train_one_epoch
label_desc: Use image node_id 2 for calling a global function with example usage: get_args_parser(add_help) and returns: parser