code: def get_args_parser(add_help=True):
      import argparse
  
      parser = argparse.ArgumentParser(
          description="PyTorch Video Classification Training",
          add_help=add_help,
      )
  
      parser.add_argument(
          "--data-path",
          default="/datasets01_101/kinetics/070618/",
          type=str,
          help="dataset path",
      )
      parser.add_argument(
          "--kinetics-version",
          default="400",
          type=str,
          choices=["400", "600"],
          help="Select kinetics version",
      )
      parser.add_argument(
          "--model", default="r2plus1d_18", type=str, help="model name"
      )
      parser.add_argument(
          "--device",
          default="cuda",
          type=str,
          help="device (Use cuda or cpu Default: cuda)",
      )
      parser.add_argument(
          "--clip-len",
          default=16,
          type=int,
          metavar="N",
          help="number of frames per clip",
      )
      parser.add_argument(
          "--frame-rate",
          default=15,
          type=int,
          metavar="N",
          help="the frame rate",
      )
      parser.add_argument(
          "--clips-per-video",
          default=5,
          type=int,
          metavar="N",
          help="maximum number of clips per video to consider",
      )
      parser.add_argument(
          "-b",
          "--batch-size",
          default=24,
          type=int,
          help="images per gpu, the total batch size is $NGPU x batch_size",
      )
      parser.add_argument(
          "--epochs",
          default=45,
          type=int,
          metavar="N",
          help="number of total epochs to run",
      )
      parser.add_argument(
          "-j",
          "--workers",
          default=10,
          type=int,
          metavar="N",
          help="number of data loading workers (default: 10)",
      )
      parser.add_argument(
          "--lr", default=0.64, 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-milestones",
          nargs="+",
          default=[20, 30, 40],
          type=int,
          help="decrease lr on milestones",
      )
      parser.add_argument(
          "--lr-gamma",
          default=0.1,
          type=float,
          help="decrease lr by a factor of lr-gamma",
      )
      parser.add_argument(
          "--lr-warmup-epochs",
          default=10,
          type=int,
          help="the number of epochs to warmup (default: 10)",
      )
      parser.add_argument(
          "--lr-warmup-method",
          default="linear",
          type=str,
          help="the warmup method (default: linear)",
      )
      parser.add_argument(
          "--lr-warmup-decay",
          default=0.001,
          type=float,
          help="the decay for lr",
      )
      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(
          "--use-deterministic-algorithms",
          action="store_true",
          help="Forces the use of deterministic algorithms only.",
      )
  
      # 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(
          "--val-resize-size",
          default=(128, 171),
          nargs="+",
          type=int,
          help="the resize size used for validation (default: (128, 171))",
      )
      parser.add_argument(
          "--val-crop-size",
          default=(112, 112),
          nargs="+",
          type=int,
          help="the central crop size used for validation (default: (112, 112))",
      )
      parser.add_argument(
          "--train-resize-size",
          default=(128, 171),
          nargs="+",
          type=int,
          help="the resize size used for training (default: (128, 171))",
      )
      parser.add_argument(
          "--train-crop-size",
          default=(112, 112),
          nargs="+",
          type=int,
          help="the random crop size used for training (default: (112, 112))",
      )
  
      parser.add_argument(
          "--weights",
          default=None,
          type=str,
          help="the weights enum name to load",
      )
  
      # Mixed precision training parameters
      parser.add_argument(
          "--amp",
          action="store_true",
          help="Use torch.cuda.amp for mixed precision training",
      )
  
      return parser
  
file_path: vision/references/video_classification/train.py
imports: import datetime
  import os
  import time
  import warnings
  import datasets
  import presets
  import torch
  import torch.utils.data
  import torchvision
  import torchvision.datasets.video_utils
  import utils
  from torch import nn
  from torch.utils.data.dataloader import default_collate
  from torchvision.datasets.samplers import DistributedSampler, RandomClipSampler, UniformClipSampler
label_desc: Use image node_id 6 for calling a global function with example usage: get_args_parser(add_help) and returns: parser