code: def backward(self, indexes, grad_outputs):
      # Double backprop is not allowed
      if chainer.config.enable_backprop:
          raise RuntimeError(
              "double backpropagation in functions.forget is "
              "not allowed."
          )
  
      inputs = self.get_retained_inputs()
      # Create new variables that have no creators
      dummy_inputs = tuple(
          [variable.Variable(inp.array) for inp in inputs]
      )
  
      with function.force_backprop_mode(), chainer.using_config(
          "in_recomputing", True
      ):
          outs = _call_func(self.func, dummy_inputs)
          assert len(outs) == len(grad_outputs)
  
      output_tuples = []
      for out, grad_output in zip(outs, grad_outputs):
          if grad_output is not None:
              output_tuples.append((out.node, grad_output))
      # TODO(kataoka): use outer backward's `retain_grad` and `loss_scale`
      chainer._backprop._backprop_to_all(output_tuples, False, None)
  
      return tuple([inp.grad_var for inp in dummy_inputs])
  
file_path: chainer/chainer/functions/util/forget.py
imports: import chainer
  from chainer import function
  from chainer import function_node
  from chainer import variable
label_desc: Use image node_id 3 for calling the Forget obj's underlying member method code with example usage: obj.backward(indexes, grad_outputs) and returns: tuple