code: def dropout(x, ratio=0.5, **kwargs):
      """dropout(x, ratio=.5, *, mask=None, return_mask=False)
  
      Drops elements of input variable randomly.
  
      This function drops input elements randomly with probability ``ratio`` and
      scales the remaining elements by factor ``1 / (1 - ratio)``. In testing
      mode (i.e., ``chainer.config.train`` is set to ``False``), it does nothing
      and just returns ``x``.
  
      Args:
          x (:class:`~chainer.Variable` or :ref:`ndarray`):
              Input variable. A :math:`(s_1, s_2, ..., s_N)` -shaped float array.
          ratio (float):
              Dropout ratio. The ``ratio`` must be ``0.0 <= ratio < 1.0``.
          mask (:ref:`ndarray` or None):
              The mask to be used for dropout.
              You do not have to specify this value, unless you need to make
              results deterministic.
              If ``mask`` is not specified or set to ``None``, a mask will be
              generated randomly according to the given ``ratio``.
              If ``mask`` is specified, ``ratio`` will be ignored.
              The shape and dtype must be the same as ``x`` and should be on the
              same device.
              Note that iDeep and cuDNN will not be used for this function if
              mask is specified, as iDeep and cuDNN do not support it.
          return_mask (bool):
              If ``True``, the mask used for dropout is returned together with
              the output variable.
              The returned mask can later be reused by passing it to ``mask``
              argument.
  
      Returns:
          ~chainer.Variable or tuple:
              When ``return_mask`` is ``False`` (default), returns the output
              variable.
              When ``True``, returns the tuple of the output variable and
              mask (:ref:`ndarray`). The mask will be on the same device as the
              input. The mask will become ``None`` when ``chainer.config.train``
              is set to ``False``.
  
      See the paper by G. Hinton: `Improving neural networks by preventing
      co-adaptation of feature detectors <https://arxiv.org/abs/1207.0580>`_.
  
      .. admonition:: Example
  
          >>> x = np.array([[-1, 0], [2, -3], [-2, 1]], np.float32)
          >>> with chainer.using_config('train', True):
          ...     y = F.dropout(x)
          >>> y.array
          array([[-2.,  0.],
                 [ 4., -6.],
                 [-0.,  2.]], dtype=float32)
          >>> with chainer.using_config('train', True):
          ...     y = F.dropout(x, ratio=0.0) \
  # dropout returns original input if ratio=0.0
          >>> (x == y.array).all()
          True
          >>> with chainer.using_config('train', False):
          ...     y = F.dropout(x) \
  # dropout in test mode returns original input
          >>> (x == y.array).all()
          True
  
      """
      mask = None
      return_mask = False
      if kwargs:
          mask, return_mask = argument.parse_kwargs(
              kwargs,
              ("mask", mask),
              ("return_mask", return_mask),
              train="train argument is not supported anymore. "
              "Use chainer.using_config",
          )
  
      if configuration.config.train:
          func = Dropout(ratio, mask, return_mask)
          (out,) = func.apply((x,))
          mask = func.mask
      else:
          out = chainer.as_variable(x)
          mask = None
  
      if return_mask:
          return out, mask
      return out
  
imports: import numpy
  import chainer
  from chainer.backends import cuda
  from chainer.backends import intel64
  from chainer import configuration
  from chainer import function_node
  from chainer.utils import argument
  from chainer.utils import type_check
label_desc: Use image node_id 1 for calling a global function with example usage: dropout(x, ratio) and returns: out, out,  mask