code: def main():
      parser = argparse.ArgumentParser(
          description="ChainerMN example: DCGAN"
      )
      parser.add_argument(
          "--batchsize",
          "-b",
          type=int,
          default=50,
          help="Number of images in each mini-batch",
      )
      parser.add_argument(
          "--communicator",
          type=str,
          default="pure_nccl",
          help="Type of communicator",
      )
      parser.add_argument(
          "--epoch",
          "-e",
          type=int,
          default=1000,
          help="Number of sweeps over the dataset to train",
      )
      parser.add_argument(
          "--gpu", "-g", action="store_true", help="Use GPU"
      )
      parser.add_argument(
          "--dataset",
          "-i",
          default="",
          help="Directory of image files.  Default is cifar-10.",
      )
      parser.add_argument(
          "--out",
          "-o",
          default="result",
          help="Directory to output the result",
      )
      parser.add_argument(
          "--gen_model",
          "-r",
          default="",
          help="Use pre-trained generator for training",
      )
      parser.add_argument(
          "--dis_model",
          "-d",
          default="",
          help="Use pre-trained discriminator for training",
      )
      parser.add_argument(
          "--n_hidden",
          "-n",
          type=int,
          default=100,
          help="Number of hidden units (z)",
      )
      parser.add_argument(
          "--seed",
          type=int,
          default=0,
          help="Random seed of z at visualization stage",
      )
      parser.add_argument(
          "--snapshot_interval",
          type=int,
          default=1000,
          help="Interval of snapshot",
      )
      parser.add_argument(
          "--display_interval",
          type=int,
          default=100,
          help="Interval of displaying log to console",
      )
      args = parser.parse_args()
  
      # Prepare ChainerMN communicator.
  
      if args.gpu:
          if args.communicator == "naive":
              print(
                  "Error: 'naive' communicator does not support GPU.\n"
              )
              exit(-1)
          comm = chainermn.create_communicator(args.communicator)
          device = comm.intra_rank
      else:
          if args.communicator != "naive":
              print(
                  "Warning: using naive communicator "
                  "because only naive supports CPU-only execution"
              )
          comm = chainermn.create_communicator("naive")
          device = -1
  
      if comm.rank == 0:
          print("==========================================")
          print("Num process (COMM_WORLD): {}".format(comm.size))
          if args.gpu:
              print("Using GPUs")
          print("Using {} communicator".format(args.communicator))
          print("Num hidden unit: {}".format(args.n_hidden))
          print("Num Minibatch-size: {}".format(args.batchsize))
          print("Num epoch: {}".format(args.epoch))
          print("==========================================")
  
      # Set up a neural network to train
      gen = Generator(n_hidden=args.n_hidden)
      dis = Discriminator()
  
      if device >= 0:
          # Make a specified GPU current
          chainer.cuda.get_device_from_id(device).use()
          gen.to_gpu()  # Copy the model to the GPU
          dis.to_gpu()
  
      # Setup an optimizer
      def make_optimizer(model, comm, alpha=0.0002, beta1=0.5):
          # Create a multi node optimizer from a standard Chainer optimizer.
          optimizer = chainermn.create_multi_node_optimizer(
              chainer.optimizers.Adam(alpha=alpha, beta1=beta1), comm
          )
          optimizer.setup(model)
          optimizer.add_hook(
              chainer.optimizer.WeightDecay(0.0001), "hook_dec"
          )
          return optimizer
  
      opt_gen = make_optimizer(gen, comm)
      opt_dis = make_optimizer(dis, comm)
  
      # Split and distribute the dataset. Only worker 0 loads the whole dataset.
      # Datasets of worker 0 are evenly split and distributed to all workers.
      if comm.rank == 0:
          if args.dataset == "":
              # Load the CIFAR10 dataset if args.dataset is not specified
              train, _ = chainer.datasets.get_cifar10(
                  withlabel=False, scale=255.0
              )
          else:
              all_files = os.listdir(args.dataset)
              image_files = [
                  f for f in all_files if ("png" in f or "jpg" in f)
              ]
              print(
                  "{} contains {} image files".format(
                      args.dataset, len(image_files)
                  )
              )
              train = chainer.datasets.ImageDataset(
                  paths=image_files, root=args.dataset
              )
      else:
          train = None
  
      train = chainermn.scatter_dataset(train, comm)
  
      train_iter = chainer.iterators.SerialIterator(
          train, args.batchsize
      )
  
      # Set up a trainer
      updater = DCGANUpdater(
          models=(gen, dis),
          iterator=train_iter,
          optimizer={"gen": opt_gen, "dis": opt_dis},
          device=device,
      )
      trainer = training.Trainer(
          updater, (args.epoch, "epoch"), out=args.out
      )
  
      # Some display and output extensions are necessary only for one worker.
      # (Otherwise, there would just be repeated outputs.)
      if comm.rank == 0:
          snapshot_interval = (args.snapshot_interval, "iteration")
          display_interval = (args.display_interval, "iteration")
          # Save only model parameters.
          # `snapshot` extension will save all the trainer module's attribute,
          # including `train_iter`.
          # However, `train_iter` depends on scattered dataset, which means that
          # `train_iter` may be different in each process.
          # Here, instead of saving whole trainer module, only the network models
          # are saved.
          trainer.extend(
              extensions.snapshot_object(
                  gen, "gen_iter_{.updater.iteration}.npz"
              ),
              trigger=snapshot_interval,
          )
          trainer.extend(
              extensions.snapshot_object(
                  dis, "dis_iter_{.updater.iteration}.npz"
              ),
              trigger=snapshot_interval,
          )
          trainer.extend(extensions.LogReport(trigger=display_interval))
          trainer.extend(
              extensions.PrintReport(
                  [
                      "epoch",
                      "iteration",
                      "gen/loss",
                      "dis/loss",
                      "elapsed_time",
                  ]
              ),
              trigger=display_interval,
          )
          trainer.extend(extensions.ProgressBar(update_interval=10))
          trainer.extend(
              out_generated_image(
                  gen, dis, 10, 10, args.seed, args.out
              ),
              trigger=snapshot_interval,
          )
  
      # Start the training using pre-trained model, saved by snapshot_object
      if args.gen_model:
          chainer.serializers.load_npz(args.gen_model, gen)
      if args.dis_model:
          chainer.serializers.load_npz(args.dis_model, dis)
  
      # Run the training
      trainer.run()
  
file_path: chainer/examples/chainermn/dcgan/train_dcgan.py
imports: from __future__ import print_function
  import argparse
  import os
  import chainer
  from chainer import training
  from chainer.training import extensions
  from net import Discriminator
  from net import Generator
  from updater import DCGANUpdater
  from visualize import out_generated_image
  import chainermn
label_desc: Use image node_id 1 for calling a global function with example usage: main() and returns: optimizer