code: def main_worker(gpu, ngpus_per_node, args):
      global best_acc1
      args.gpu = gpu
  
      if args.gpu is not None:
          print("Use GPU: {} for training".format(args.gpu))
  
      if args.distributed:
          if args.dist_url == "env://" and args.rank == -1:
              args.rank = int(os.environ["RANK"])
          if args.multiprocessing_distributed:
              # For multiprocessing distributed training, rank needs to be the
              # global rank among all the processes
              args.rank = args.rank * ngpus_per_node + gpu
          dist.init_process_group(
              backend=args.dist_backend,
              init_method=args.dist_url,
              world_size=args.world_size,
              rank=args.rank,
          )
      # create model
      if "efficientnet" in args.arch:  # NEW
          if args.pretrained:
              model = EfficientNet.from_pretrained(
                  args.arch, advprop=args.advprop
              )
              print("=> using pre-trained model '{}'".format(args.arch))
          else:
              print("=> creating model '{}'".format(args.arch))
              model = EfficientNet.from_name(args.arch)
  
      else:
          if args.pretrained:
              print("=> using pre-trained model '{}'".format(args.arch))
              model = models.__dict__[args.arch](pretrained=True)
          else:
              print("=> creating model '{}'".format(args.arch))
              model = models.__dict__[args.arch]()
  
      if args.distributed:
          # For multiprocessing distributed, DistributedDataParallel constructor
          # should always set the single device scope, otherwise,
          # DistributedDataParallel will use all available devices.
          if args.gpu is not None:
              torch.cuda.set_device(args.gpu)
              model.cuda(args.gpu)
              # When using a single GPU per process and per
              # DistributedDataParallel, we need to divide the batch size
              # ourselves based on the total number of GPUs we have
              args.batch_size = int(args.batch_size / ngpus_per_node)
              args.workers = int(args.workers / ngpus_per_node)
              model = torch.nn.parallel.DistributedDataParallel(
                  model, device_ids=[args.gpu]
              )
          else:
              model.cuda()
              # DistributedDataParallel will divide and allocate batch_size to all
              # available GPUs if device_ids are not set
              model = torch.nn.parallel.DistributedDataParallel(model)
      elif args.gpu is not None:
          torch.cuda.set_device(args.gpu)
          model = model.cuda(args.gpu)
      else:
          # DataParallel will divide and allocate batch_size to all available GPUs
          if args.arch.startswith("alexnet") or args.arch.startswith(
              "vgg"
          ):
              model.features = torch.nn.DataParallel(model.features)
              model.cuda()
          else:
              model = torch.nn.DataParallel(model).cuda()
  
      # define loss function (criterion) and optimizer
      criterion = nn.CrossEntropyLoss().cuda(args.gpu)
  
      optimizer = torch.optim.SGD(
          model.parameters(),
          args.lr,
          momentum=args.momentum,
          weight_decay=args.weight_decay,
      )
  
      # optionally resume from a checkpoint
      if args.resume:
          if os.path.isfile(args.resume):
              print("=> loading checkpoint '{}'".format(args.resume))
              checkpoint = torch.load(args.resume)
              args.start_epoch = checkpoint["epoch"]
              best_acc1 = checkpoint["best_acc1"]
              if args.gpu is not None:
                  # best_acc1 may be from a checkpoint from a different GPU
                  best_acc1 = best_acc1.to(args.gpu)
              model.load_state_dict(checkpoint["state_dict"])
              optimizer.load_state_dict(checkpoint["optimizer"])
              print(
                  "=> loaded checkpoint '{}' (epoch {})".format(
                      args.resume, checkpoint["epoch"]
                  )
              )
          else:
              print(
                  "=> no checkpoint found at '{}'".format(args.resume)
              )
  
      cudnn.benchmark = True
  
      # Data loading code
      traindir = os.path.join(args.data, "train")
      valdir = os.path.join(args.data, "val")
      if args.advprop:
          normalize = transforms.Lambda(lambda img: img * 2.0 - 1.0)
      else:
          normalize = transforms.Normalize(
              mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
          )
  
      if "efficientnet" in args.arch:
          image_size = EfficientNet.get_image_size(args.arch)
      else:
          image_size = args.image_size
  
      train_dataset = datasets.ImageFolder(
          traindir,
          transforms.Compose(
              [
                  transforms.RandomResizedCrop(image_size),
                  transforms.RandomHorizontalFlip(),
                  transforms.ToTensor(),
                  normalize,
              ]
          ),
      )
  
      if args.distributed:
          train_sampler = (
              torch.utils.data.distributed.DistributedSampler(
                  train_dataset
              )
          )
      else:
          train_sampler = None
  
      train_loader = torch.utils.data.DataLoader(
          train_dataset,
          batch_size=args.batch_size,
          shuffle=(train_sampler is None),
          num_workers=args.workers,
          pin_memory=True,
          sampler=train_sampler,
      )
  
      val_transforms = transforms.Compose(
          [
              transforms.Resize(
                  image_size, interpolation=PIL.Image.BICUBIC
              ),
              transforms.CenterCrop(image_size),
              transforms.ToTensor(),
              normalize,
          ]
      )
      print("Using image size", image_size)
  
      val_loader = torch.utils.data.DataLoader(
          datasets.ImageFolder(valdir, val_transforms),
          batch_size=args.batch_size,
          shuffle=False,
          num_workers=args.workers,
          pin_memory=True,
      )
  
      if args.evaluate:
          res = validate(val_loader, model, criterion, args)
          with open("res.txt", "w") as f:
              print(res, file=f)
          return
  
      for epoch in range(args.start_epoch, args.epochs):
          if args.distributed:
              train_sampler.set_epoch(epoch)
          adjust_learning_rate(optimizer, epoch, args)
  
          # train for one epoch
          train(train_loader, model, criterion, optimizer, epoch, args)
  
          # evaluate on validation set
          acc1 = validate(val_loader, model, criterion, args)
  
          # remember best acc@1 and save checkpoint
          is_best = acc1 > best_acc1
          best_acc1 = max(acc1, best_acc1)
  
          if not args.multiprocessing_distributed or (
              args.multiprocessing_distributed
              and args.rank % ngpus_per_node == 0
          ):
              save_checkpoint(
                  {
                      "epoch": epoch + 1,
                      "arch": args.arch,
                      "state_dict": model.state_dict(),
                      "best_acc1": best_acc1,
                      "optimizer": optimizer.state_dict(),
                  },
                  is_best,
              )
  
imports: import argparse
  import os
  import random
  import shutil
  import time
  import warnings
  import PIL
  import torch
  import torch.nn
  import torch.nn.parallel
  import torch.backends.cudnn
  import torch.distributed
  import torch.optim
  import torch.multiprocessing
  import torch.utils.data
  import torch.utils.data.distributed
  import torchvision.transforms
  import torchvision.datasets
  import torchvision.models
  from efficientnet_pytorch import EfficientNet
label_desc: Use image node_id 2 for calling a global function with example usage: main_worker(gpu, ngpus_per_node, args) without return types