code: def main():
      archs = {
          "alex": alex.Alex,
          "googlenet": googlenet.GoogLeNet,
          "googlenetbn": googlenetbn.GoogLeNetBN,
          "nin": nin.NIN,
          "resnet50": resnet50.ResNet50,
          "resnext50": resnext50.ResNeXt50,
          "resnet50_nhwc": resnet50.ResNet50_Nhwc,
      }
  
      dtypes = {
          "float16": np.float16,
          "float32": np.float32,
          "float64": np.float64,
      }
  
      parser = argparse.ArgumentParser(
          description="Learning convnet from ILSVRC2012 dataset"
      )
      parser.add_argument(
          "train", help="Path to training image-label list file"
      )
      parser.add_argument(
          "val", help="Path to validation image-label list file"
      )
      parser.add_argument(
          "--arch",
          "-a",
          choices=archs.keys(),
          default="nin",
          help="Convnet architecture",
      )
      parser.add_argument(
          "--batchsize",
          "-B",
          type=int,
          default=32,
          help="Learning minibatch size",
      )
      parser.add_argument(
          "--dtype",
          choices=dtypes,
          help="Specify the dtype "
          "used. If not supplied, the default dtype is used",
      )
      parser.add_argument(
          "--epoch",
          "-E",
          type=int,
          default=10,
          help="Number of epochs to train",
      )
      parser.add_argument(
          "--device",
          "-d",
          type=str,
          default="-1",
          help="Device specifier. Either ChainerX device "
          "specifier or an integer. If non-negative integer, "
          "CuPy arrays with specified device id are used. If "
          "negative integer, NumPy arrays are used",
      )
      parser.add_argument(
          "--initmodel", help="Initialize the model from given file"
      )
      parser.add_argument(
          "--loaderjob",
          "-j",
          type=int,
          help="Number of parallel data loading processes",
      )
      parser.add_argument(
          "--mean",
          "-m",
          default="mean.npy",
          help="Mean file (computed by compute_mean.py)",
      )
      parser.add_argument(
          "--resume",
          "-r",
          default="",
          help="Initialize the trainer from given file",
      )
      parser.add_argument(
          "--out", "-o", default="result", help="Output directory"
      )
      parser.add_argument(
          "--root",
          "-R",
          default=".",
          help="Root directory path of image files",
      )
      parser.add_argument(
          "--val_batchsize",
          "-b",
          type=int,
          default=250,
          help="Validation minibatch size",
      )
      parser.add_argument("--test", action="store_true")
      parser.set_defaults(test=False)
      parser.add_argument("--dali", action="store_true")
      parser.set_defaults(dali=False)
      group = parser.add_argument_group("deprecated arguments")
      group.add_argument(
          "--gpu",
          "-g",
          dest="device",
          type=int,
          nargs="?",
          const=0,
          help="GPU ID (negative value indicates CPU)",
      )
      args = parser.parse_args()
  
      device = chainer.get_device(args.device)
  
      # Set the dtype if supplied.
      if args.dtype is not None:
          chainer.config.dtype = args.dtype
  
      print("Device: {}".format(device))
      print("Dtype: {}".format(chainer.config.dtype))
      print("# Minibatch-size: {}".format(args.batchsize))
      print("# epoch: {}".format(args.epoch))
      print("")
  
      # Initialize the model to train
      model = archs[args.arch]()
      if args.initmodel:
          print("Load model from {}".format(args.initmodel))
          chainer.serializers.load_npz(args.initmodel, model)
      model.to_device(device)
      device.use()
  
      # Load the mean file
      mean = np.load(args.mean)
      if args.dali:
          if not dali_util._dali_available:
              raise RuntimeError(
                  "DALI seems not available on your system."
              )
          if device.xp is not chainer.backend.cuda.cupy:
              raise RuntimeError(
                  "Using DALI requires GPU device. Please "
                  "specify it with --device option."
              )
          n_threads = args.loaderjob
          if n_threads is None or n_threads <= 0:
              n_threads = 1
          ch_mean = list(np.average(mean, axis=(1, 2)))
          ch_std = [255.0, 255.0, 255.0]
          # Setup DALI pipelines
          train_pipe = dali_util.DaliPipelineTrain(
              args.train,
              args.root,
              model.insize,
              args.batchsize,
              n_threads,
              device.device.id,
              True,
              mean=ch_mean,
              std=ch_std,
          )
          val_pipe = dali_util.DaliPipelineVal(
              args.val,
              args.root,
              model.insize,
              args.val_batchsize,
              n_threads,
              device.device.id,
              False,
              mean=ch_mean,
              std=ch_std,
          )
          train_iter = chainer.iterators.DaliIterator(train_pipe)
          val_iter = chainer.iterators.DaliIterator(
              val_pipe, repeat=False
          )
          # converter = dali_converter
          converter = dali_util.DaliConverter(
              mean=mean, crop_size=model.insize
          )
      else:
          # Load the dataset files
          train = PreprocessedDataset(
              args.train, args.root, mean, model.insize
          )
          val = PreprocessedDataset(
              args.val, args.root, mean, model.insize, False
          )
          # These iterators load the images with subprocesses running in parallel
          # to the training/validation.
          train_iter = chainer.iterators.MultiprocessIterator(
              train, args.batchsize, n_processes=args.loaderjob
          )
          val_iter = chainer.iterators.MultiprocessIterator(
              val,
              args.val_batchsize,
              repeat=False,
              n_processes=args.loaderjob,
          )
          converter = dataset.concat_examples
  
      # Set up an optimizer
      optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
      optimizer.setup(model)
  
      # Set up a trainer
      updater = training.updaters.StandardUpdater(
          train_iter, optimizer, converter=converter, device=device
      )
      trainer = training.Trainer(
          updater, (args.epoch, "epoch"), args.out
      )
  
      val_interval = (100000, "iteration")
      log_interval = (1000, "iteration")
      if args.test:
          val_interval = (1, "iteration")
          log_interval = (1, "iteration")
  
      trainer.extend(
          extensions.Evaluator(
              val_iter, model, converter=converter, device=device
          ),
          trigger=val_interval,
      )
      # TODO(sonots): Temporarily disabled for chainerx. Fix it.
      if device.xp is not chainerx:
          trainer.extend(extensions.DumpGraph("main/loss"))
      trainer.extend(extensions.snapshot(), trigger=val_interval)
      trainer.extend(
          extensions.snapshot_object(
              model, "model_iter_{.updater.iteration}"
          ),
          trigger=val_interval,
      )
      # Be careful to pass the interval directly to LogReport
      # (it determines when to emit log rather than when to read observations)
      trainer.extend(extensions.LogReport(trigger=log_interval))
      trainer.extend(extensions.observe_lr(), trigger=log_interval)
      trainer.extend(
          extensions.PrintReport(
              [
                  "epoch",
                  "iteration",
                  "main/loss",
                  "validation/main/loss",
                  "main/accuracy",
                  "validation/main/accuracy",
                  "lr",
              ]
          ),
          trigger=log_interval,
      )
      trainer.extend(extensions.ProgressBar(update_interval=10))
  
      if args.resume:
          chainer.serializers.load_npz(args.resume, trainer)
  
      trainer.run()
  
file_path: chainer/examples/imagenet/train_imagenet.py
imports: import argparse
  import numpy
  import chainer
  from chainer import dataset
  from chainer import training
  from chainer.training import extensions
  import chainerx
  import dali_util
  from dataset_util import PreprocessedDataset
  import alex
  import googlenet
  import googlenetbn
  import nin
  import resnet50
  import resnext50
label_desc: Use image node_id 1 for calling a global function with example usage: main() without return types