code: def parse_args():
      parser = argparse.ArgumentParser(
          description="Opacus Imagenet Benchmark"
      )
      parser.add_argument(
          "-j",
          "--workers",
          default=20,
          type=int,
          metavar="N",
          help="number of data loading workers",
      )
      parser.add_argument(
          "--steps",
          default=100,
          type=int,
          help="Number of steps",
      )
      parser.add_argument(
          "--benchmark-data-loader",
          action="store_true",
          default=False,
          help="Also benchmark data loader",
      )
      parser.add_argument(
          "-b",
          "--batch-size",
          default=128,
          type=int,
          metavar="N",
          help="mini-batch size for test dataset, this is the total "
          "batch size of all GPUs on the current node when "
          "using Data Parallel or Distributed Data Parallel",
      )
      parser.add_argument(
          "--height",
          default=224,
          type=int,
      )
      parser.add_argument(
          "--width",
          default=224,
          type=int,
      )
      parser.add_argument(
          "--lr",
          "--learning-rate",
          default=0.1,
          type=float,
          metavar="LR",
          help="initial learning rate",
          dest="lr",
      )
      parser.add_argument(
          "--momentum",
          default=0.9,
          type=float,
          metavar="M",
          help="SGD momentum",
      )
      parser.add_argument(
          "--wd",
          "--weight-decay",
          default=0,
          type=float,
          metavar="W",
          help="SGD weight decay",
          dest="weight_decay",
      )
  
      parser.add_argument(
          "--gn-groups",
          type=int,
          default=8,
          help="Number of groups in GroupNorm",
      )
  
      parser.add_argument(
          "--sigma",
          type=float,
          default=1.5,
          metavar="S",
          help="Noise multiplier (default 1.0)",
      )
      parser.add_argument(
          "-c",
          "--max-per-sample-grad_norm",
          type=float,
          default=10.0,
          metavar="C",
          help="Clip per-sample gradients to this norm (default 1.0)",
      )
      parser.add_argument(
          "--disable-dp",
          action="store_true",
          default=False,
          help="Disable privacy training and just train with vanilla SGD",
      )
      parser.add_argument(
          "--secure-mode",
          action="store_true",
          default=False,
          help="Enable Secure mode to have trustworthy privacy guarantees. Comes at a performance cost",
      )
      parser.add_argument(
          "--delta",
          type=float,
          default=1e-5,
          metavar="D",
          help="Target delta (default: 1e-5)",
      )
  
      parser.add_argument(
          "--architecture",
          type=str,
          default="resnet18",
          help="path to save check points",
      )
  
      parser.add_argument(
          "--optim",
          type=str,
          default="SGD",
          help="Optimizer to use (Adam, RMSprop, SGD)",
      )
  
      parser.add_argument(
          "--device",
          type=str,
          default="cpu",
          help="Device on which to run the code.",
      )
      parser.add_argument(
          "--local_rank",
          type=int,
          default=-1,
          help="Local rank if multi-GPU training, -1 for single GPU training. Will be overridden by the environment variables if running on a Slurm cluster.",
      )
  
      parser.add_argument(
          "--clip_per_layer",
          action="store_true",
          default=False,
          help="Use static per-layer clipping with the same clipping threshold for each layer. Necessary for DDP. If `False` (default), uses flat clipping.",
      )
  
      return parser.parse_args()
  
file_path: opacus/examples/vision_benchmark.py
imports: import argparse
  import time
  import numpy
  import torch
  import torch.nn
  import torch.optim
  import torch.utils.data
  import torch.utils.data.distributed
  from opacus import PrivacyEngine
  from opacus.distributed import DifferentiallyPrivateDistributedDataParallel
  from torch.nn.parallel import DistributedDataParallel
  from torch.utils.data import TensorDataset
  from torchvision import models
  from tqdm import tqdm
label_desc: Use image node_id 3 for calling a global function with example usage: parse_args() and returns: parser