code: def get_arguments():
      """Parse all the arguments provided from the CLI.
  
      Returns:
        A list of parsed arguments.
      """
      parser = argparse.ArgumentParser(description="Training Network")
      # Data Preference
      parser.add_argument(
          "--data-dir",
          type=str,
          default="./datasets",
          help="Path to the directory containing the dataset.",
      )
      parser.add_argument(
          "--train-dataset",
          type=str,
          default="train",
          choices=["train", "valid", "test"],
          help="Path to the file listing the images in the dataset.",
      )
      parser.add_argument(
          "--valid-dataset",
          type=str,
          default="test",
          choices=["valid", "test_resize", "test"],
          help="Path to the file listing the images in the dataset.",
      )
      parser.add_argument(
          "--batch-size",
          type=int,
          default=8,
          help="Number of images sent to the network in one step.",
      )
      parser.add_argument(
          "--input-size",
          type=str,
          default="473,473",
          help="Comma-separated string with height and width of images.",
      )
      parser.add_argument(
          "--num-classes",
          type=int,
          default=11,
          help="Number of classes to predict (including background).",
      )
      parser.add_argument(
          "--edge-classes",
          type=int,
          default=2,
          help="Number of classes to predict (including background).",
      )
      parser.add_argument(
          "--ignore-label",
          type=int,
          default=255,
          help="The index of the label to ignore during the training.",
      )
      parser.add_argument(
          "--random-mirror",
          action="store_true",
          help="Whether to randomly mirror the inputs during the training.",
      )
      parser.add_argument(
          "--random-scale",
          action="store_true",
          help="Whether to randomly scale the inputs during the training.",
      )
      parser.add_argument(
          "--random-seed",
          type=int,
          default=1234,
          help="Random seed to have reproducible results.",
      )
      # Model
      parser.add_argument(
          "--restore-from",
          type=str,
          default=None,
          help="Where restore model parameters from.",
      )
      parser.add_argument(
          "--snapshot-dir",
          type=str,
          default="./snapshots/",
          help="Where to save snapshots of the model.",
      )
      # Training Strategy
      parser.add_argument(
          "--save-num-images",
          type=int,
          default=2,
          help="How many images to save.",
      )
      parser.add_argument(
          "--learning-rate",
          type=float,
          default=1e-3,
          help="Base learning rate for training with polynomial decay.",
      )
      parser.add_argument(
          "--momentum",
          type=float,
          default=0.9,
          help="Momentum component of the optimiser.",
      )
      parser.add_argument(
          "--weight-decay",
          type=float,
          default=0.0005,
          help="Regularisation parameter for L2-loss.",
      )
      parser.add_argument(
          "--power",
          type=float,
          default=0.9,
          help="Decay parameter to compute the learning rate.",
      )
      parser.add_argument(
          "--eval_epochs",
          type=int,
          default=1,
          help="Number of classes to predict (including background).",
      )
      parser.add_argument(
          "--start-epoch",
          type=int,
          default=0,
          help="choose the number of recurrence.",
      )
      parser.add_argument(
          "--epochs",
          type=int,
          default=150,
          help="choose the number of recurrence.",
      )
      # Distributed Training
      parser.add_argument(
          "--gpu", type=str, default="None", help="choose gpu numbers"
      )
      parser.add_argument(
          "--local_rank", type=int, default=0, help="choose gpu numbers"
      )
      parser.add_argument(
          "--dist-backend",
          default="nccl",
          type=str,
          help="distributed backend",
      )
      # self correlation training
      parser.add_argument(
          "--schp-start", type=int, default=100, help="schp start epoch"
      )
      parser.add_argument(
          "--cycle-epochs",
          type=int,
          default=10,
          help="schp cyclical epoch",
      )
      parser.add_argument(
          "--schp-restore",
          type=str,
          default=None,
          help="Where restore schp model parameters from.",
      )
      parser.add_argument(
          "--lambda-s",
          type=float,
          default=1,
          help="segmentation loss weight",
      )
      parser.add_argument(
          "--lambda-e", type=float, default=1, help="edge loss weight"
      )
      parser.add_argument(
          "--lambda-c",
          type=float,
          default=0.1,
          help="segmentation-edge consistency loss weight",
      )
      return parser.parse_args()
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import argparse
  import os
  import os.path
  import timeit
  import torch
  import torch.nn
  import torch.backends.cudnn
  import torch.distributed
  import torch.optim
  import torchvision.transforms
  import torchvision.utils
  import utils.schp
  from datetime import datetime
  from tensorboardX import SummaryWriter
  from torch.utils.data.distributed import DistributedSampler
  from inplace_abn import InPlaceABNSync
  from inplace_abn import InPlaceABN
  from dataset import datasets
  from networks import dml_csr
  from utils.logging import get_root_logger
  from utils.utils import decode_parsing, inv_preprocess, SingleGPU
  from utils.encoding import DataParallelModel, DataParallelCriterion
  from utils.miou import compute_mean_ioU
  from utils.warmup_scheduler import SGDRScheduler
  from loss.criterion import Criterion
  from test import valid
label_desc: Use image node_id 2 for calling a global function with example usage: get_arguments() and returns: parser