class_docstr: Batch normalization layer that can use the whole batch stats.
  
  When using chainer.link.BatchNormalization, batch mean and std are
  computed independently for the local batch in each worker. When local
  batch size is too small, training is unstable due to unreliable batch
  stats.
  
  In contrast, when using this MultiNodeBatchNormalization, workers
  communicate to conduct 'correct' batch normalization (e.g., obtaining
  mean and std for the whole global batch).
  
  This link works only with Chainer >= 2.0.0.
  
  Args:
      size (int or tuple of ints): Size (or shape) of channel
          dimensions.
      comm (ChainerMN communicator): communicator to share
          the batch stats.
      decay (float): Decay rate of moving average. It is used on training.
      eps (float): Epsilon value for numerical stability.
      dtype (numpy.dtype): Type to use in computing.
      use_gamma (bool): If ``True``, use scaling parameter. Otherwise, use
          unit(1) which makes no effect.
      use_beta (bool): If ``True``, use shifting parameter. Otherwise, use
          unit(0) which makes no effect.
      communication_backend (str): ``mpi``, ``nccl`` or ``auto``. It is used
          to determine communication backend. If ``auto``, use the best
          communication backend for each communicator.
code: def __call__(self, x, finetune=False):
      if hasattr(self, "gamma"):
          gamma = self.gamma
      else:
          with cuda.get_device_from_id(self._device_id):
              gamma = variable.Variable(
                  self.xp.ones(
                      self.avg_mean.shape, dtype=self._highprec_dtype
                  )
              )
      if hasattr(self, "beta"):
          beta = self.beta
      else:
          with cuda.get_device_from_id(self._device_id):
              beta = variable.Variable(
                  self.xp.zeros(
                      self.avg_mean.shape, dtype=self._highprec_dtype
                  )
              )
  
      if chainer.configuration.config.train:
          if finetune:
              self.N += 1
              decay = 1.0 - 1.0 / self.N
          else:
              decay = self.decay
  
          func = batch_normalization.BatchNormalization(
              self.eps,
              self.avg_mean,
              self.avg_var,
              decay,
              impl_selector=(
                  chainermn_batch_normalization.MultiNodeBNImplSelector(
                      self.comm, self._communication_backend
                  )
              ),
          )
  
          ret = func.apply((x, gamma, beta))[0]
  
          self.avg_mean[:] = func.running_mean
          self.avg_var[:] = func.running_var
      else:
          # Use running average statistics or fine-tuned statistics.
          mean = variable.Variable(self.avg_mean)
          var = variable.Variable(self.avg_var)
          ret = batch_normalization.fixed_batch_normalization(
              x, gamma, beta, mean, var, self.eps
          )
      return ret
  
file_path: chainer/chainermn/links/batch_normalization.py
imports: import chainer
  from chainer.backends import cuda
  from chainer.functions.normalization import batch_normalization
  from chainer import initializers
  from chainer import link
  import chainer.utils
  from chainer import variable
  from chainermn.functions import batch_normalization
  import numpy
  import copy
label_desc: Use image node_id 2 for calling the MultiNodeBatchNormalization obj's underlying member method code with example usage: obj.__call__(x, finetune) and returns: ret