class_docstr: Product of array elements over a given axis.
class_docstr_tok: ["Product","of","array","elements","over","a","given","axis","."]
code: def backward(self, indexes, gy):
      (x,) = self.get_retained_inputs()
      (gy,) = gy
      F = chainer.functions
  
      if self.axis is None:
          axes = tuple(six.moves.range(x.ndim))
      else:
          axes = tuple(
              [
                  axis if axis >= 0 else axis + x.ndim
                  for axis in self.axis
              ]
          )
  
      if not self.keepdims:
          for axis in sorted(axes):
              gy = F.expand_dims(gy, axis=axis)
  
      # indices of axes that are not reduced
      axes_kept = tuple(
          a for a in six.moves.range(x.ndim) if a not in axes
      )
  
      n_reduced_elements = 1
      for axis in axes:
          n_reduced_elements *= x.shape[axis]
      transpose_axes = axes + axes_kept
  
      x = x.transpose(transpose_axes)
      transposed_shape = x.shape
      kept_shape = transposed_shape[len(axes) :]
      x = x.reshape((n_reduced_elements,) + kept_shape)
  
      def shifted_cumprod(a):
          a, _ = F.split_axis(
              F.concat([a.xp.ones((1,) + kept_shape, a.dtype), a], 0),
              (-1,),
              0,
          )
          return F.cumprod(a, 0)
  
      gx = shifted_cumprod(x) * F.flip(shifted_cumprod(F.flip(x, 0)), 0)
      gx = gx.reshape(transposed_shape)
      gx = gx.transpose(list(numpy.argsort(transpose_axes)))
      gx = gx * gy
      return (gx,)
  
file_path: chainer/chainer/functions/math/prod.py
imports: import numpy
  import six
  from chainer import backend
  from chainer import function_node
  import chainer.functions
  from chainer.utils import type_check
label_desc: Use image node_id 4 for calling the Prod obj's underlying member method code with example usage: obj.backward(indexes, gy) and returns: gx, F