code: def no_backprop_mode():
      """Make a context manager which disables back-propagation.
  
      In this context, Chainer does not make a computational graph. It has the
      benefit of reducing memory consumption. However, a
      :class:`~chainer.Variable` created in this context does not hold a
      reference to the :class:`~chainer.FunctionNode` that created itself so no
      gradients are accumulated by :func:`~chainer.Variable.backward`.
  
      In the following example, ``y`` is created in this context, which means
      that calling :func:`~chainer.Variable.backward` on ``y`` has no effect on
      the gradients of ``x``.
  
      >>> x = chainer.Variable(np.array([1,], np.float32))
      >>> with chainer.no_backprop_mode():
      ...     y = x + 1
      >>> y.backward()
      >>> x.grad is None
      True
  
      .. note::
  
         ``chainer.no_backprop_mode()`` implicitly applies ChainerX's
         counterpart :func:`chainerx.no_backprop_mode()`, but not vice versa.
         Also, setting ``enable_backprop`` :ref:`configuration <configuration>`
         does not affect ChainerX.
  
      .. seealso::
  
         See :func:`chainer.force_backprop_mode` for details on how to override
         this context.
  
      """
      c = configuration.using_config("enable_backprop", False)
      if chainerx.is_available():
          return _BackpropModeContext((c, chainerx.no_backprop_mode()))
      return _BackpropModeContext((c,))
  
imports: from __future__ import absolute_import
  import warnings
  import weakref
  import six
  import chainer
  from chainer import backend
  from chainer.backends import cuda
  from chainer import configuration
  from chainer.function_hook import FunctionHook
  from chainer import function_node
  from chainer import variable
  import chainerx
label_desc: Use image node_id 1 for calling a global function with example usage: no_backprop_mode() and returns: _BackpropModeContext, _BackpropModeContext