code: def backward(self, inputs, grad_outputs):
      x, gamma, _ = inputs
      gy = grad_outputs[0]
      head_ndim = gamma.ndim + 1
      expander = (None, Ellipsis) + (None,) * (x.ndim - head_ndim)
      m = gamma.dtype.type(x.size // gamma.size)
      axis = (0,) + tuple(range(head_ndim, x.ndim))
      xp = backend.get_array_module(x)
  
      # Note: we must be in train mode.
      assert configuration.config.train
      # NOTE(tommi): cuDNN is not used since it does not support
      # batch renormalization
      gbeta = gy.sum(axis=axis, dtype=gamma.dtype)
      ggamma = (gy * self.x_hat_renorm).sum(axis=axis)
      gsigma_batch = (gy * self.x_hat).sum(axis=axis)
      if xp is numpy:
          scale = (self.r * gamma / self.std)[expander]
          gx = scale * (
              gy
              - (self.x_hat * gsigma_batch[expander] + gbeta[expander])
              / m
          )
          gx = gx.astype(dtype=x.dtype)
      else:
          inv_m = numpy.float32(1) / m
          gx = cuda.elementwise(
              "T gy, U x_hat, U gamma, U std, U gsigma_batch, U gbeta, \
                  U inv_m, U r",
              "T gx",
              "gx = (r * gamma / std) * (gy - (x_hat * gsigma_batch + gbeta) * \
                  inv_m)",
              "brn_bwd",
          )(
              gy,
              self.x_hat,
              gamma[expander],
              self.std[expander],
              gsigma_batch[expander],
              gbeta[expander],
              inv_m,
              self.r[expander],
          )
      return gx, ggamma, gbeta
  
imports: import warnings
  import numpy
  from chainer import backend
  from chainer.backends import cuda
  from chainer import configuration
  from chainer import function
  from chainer.functions.normalization import batch_normalization
  from chainer.utils import type_check
label_desc: Use image node_id 7 for calling the BatchRenormalizationFunction obj's underlying member method code with example usage: obj.backward(inputs, grad_outputs) and returns: gx,  ggamma,  gbeta