code: def _run(self):
      # Run a forward pass for backward gradients.
      # Uninitialized parameters may be initialized.
      # If self.gys is None, it is also updated with 1s.
      # This must be done before sampling a direction vector, because
      # otherwise the shapes of uninitialized parameters wouldn't be
      # determined.
      (
          xs_backward,
          ys,
          params_backward,
      ) = self._forward_for_backward_gradients()
      # Keep output arrays to save computation in numerical gradients
      ys0 = tuple([None if y is None else y.array for y in ys])
  
      # If gys is not given, generate the all-1 gradients.
      if self.gys is None:
          if not (len(ys) == 1 and ys[0].shape == ()):
              raise ValueError(
                  "y_grad argument cannot be omitted if the target function "
                  "is not a loss function, which has a single output with "
                  "shape ().\n"
                  "Actual output shapes: {}".format(
                      ", ".join([str(y.shape) for y in ys])
                  )
              )
  
          self.gys = tuple([_ones_like(y.array) for y in ys])
      else:
          _check_outputs_and_grad_outputs(ys, self.gys)
  
      # Strike out gys corresponding to None y
      self.gys = tuple(
          [None if y is None else gy for gy, y in zip(self.gys, ys0)]
      )
  
      # Sample a direction vector.
      directions = self._sample_directions()
  
      # Compute backward gradients by running a backward pass.
      gx_backward = self._directional_backward_gradients(
          xs_backward, ys, params_backward, directions
      )
  
      # Compute numeric gradients
      gx_numeric = self._directional_numeric_gradients(directions, ys0)
  
      # Compare the resulted gradients
      self._compare_gradients(gx_numeric, gx_backward, directions)
  
imports: from __future__ import absolute_import
  import warnings
  import numpy
  import six
  import chainer
  from chainer import backend
  from chainer.backends import _cpu
  from chainer.backends import cuda
  from chainer import configuration
  from chainer import testing
  from chainer import utils
  from chainer import variable
  import chainerx
label_desc: Use image node_id 3 for calling the _CheckBackward obj's underlying member method code with example usage: obj._run() without return types