class_docstr: StandardUpdater(iterator, optimizer, converter=convert.concat_examples, device=None, loss_func=None, loss_scale=None, auto_new_epoch=True, *, input_device=None)
  
  Standard implementation of Updater.
  
  This is the standard implementation of :class:`~chainer.training.Updater`.
  It accepts one or more training datasets and one or more optimizers.
  The default update routine assumes that there is only one training dataset
  and one optimizer. Users can override this update routine by inheriting
  this class and overriding the :meth:`update_core` method. Each batch is
  converted to input arrays by :func:`chainer.dataset.concat_examples` by
  default, which can also be manually set by ``converter`` argument.
  
  Args:
      iterator: Dataset iterator for the training dataset. It can also be a
          dictionary that maps strings to iterators.
          If this is just an iterator, then the
          iterator is registered by the name ``'main'``.
      optimizer: Optimizer to update parameters. It can also be a dictionary
          that maps strings to optimizers.
          If this is just an optimizer, then the optimizer is
          registered by the name ``'main'``.
      converter: Converter function to build input arrays. Each batch
          extracted by the main iterator and the ``device`` option are passed
          to this function. :func:`chainer.dataset.concat_examples` is used
          by default.
      device(device specifier): Device to which the model is sent.
          If ``None``, the device of the model will stay unchanged.
      loss_func: Loss function. The target link of the main optimizer is used
          by default.
      loss_scale (float): Loss scaling factor. Loss scaling is a usefull
          technique to mitigate vanishing gradient issue that tends to happen
          when low precision data type like float16 is used during training.
          If you set loss scaling factor, gradients of loss values are to be
          multiplied by the factor before backprop starts. The factor is
          propagated to whole gradients in a computational graph along the
          backprop. The gradients of parameters are divided by the factor
          just before the parameters are to be updated.
      auto_new_epoch (bool): If ``True``,
          :meth:`~chainer.Optimizer.new_epoch` of the main optimizer is
          automatically called when the ``is_new_epoch`` attribute of the
          main iterator is ``True``.
      input_device (device specifier):
          Device to which the training data is sent.
          If ``input_device`` is omitted, it will match the ``device``
          argument.
  
  Attributes:
      converter: Converter function.
      loss_func: Loss function. If it is ``None``, the target link of the
                 main optimizer is used instead.
      device: Device to which the model is sent.
      input_device: Device to which the training data is sent.
      iteration: Current number of completed updates.
      auto_new_epoch: If ``True``, :meth:`~chainer.Optimizer.new_epoch` is
          automatically called by :meth:`update_core`. In this case, the
          :attr:`~chainer.Optimizer.use_auto_new_epoch` attribute of each
          optimizer is also set to ``True``. If :meth:`update_core` is
          overridden, the implementation should correctly call
          :meth:`~chainer.Optimizer.new_epoch` of each optimizer.
code: def input_device(self):
      return self._input_device
  
imports: import warnings
  import six
  import chainer
  from chainer.backends import cuda
  from chainer.dataset import convert
  from chainer.dataset import iterator
  from chainer import device_resident
  from chainer.training import _updater
  from chainer.utils import argument
label_desc: Use image node_id 3 for calling the StandardUpdater obj's underlying member method code with example usage: obj.input_device() and returns: self