code: def backward_impl(self, inputs, outputs, propagate_down, accum):
      g_dx0 = nn.Variable(outputs[self.x0_idx - 1].shape).apply(
          data=outputs[0].grad
      )
      g_db0 = (
          nn.Variable(outputs[self.b0_idx - 1].shape).apply(
              data=outputs[self.b0_idx - 1].grad
          )
          if not self.no_bias
          else 0
      )
      g_dg0 = (
          nn.Variable(outputs[self.g0_idx - 1].shape).apply(
              data=outputs[self.g0_idx - 1].grad
          )
          if not self.no_scale
          else 0
      )
      dy = nn.Variable(inputs[0].shape).apply(
          data=inputs[0].data, need_grad=True
      )
      x0 = nn.Variable(inputs[1].shape).apply(
          data=inputs[1].data, need_grad=True
      )
      b0 = (
          nn.Variable(inputs[self.b0_idx].shape).apply(
              data=inputs[self.b0_idx].data, need_grad=True
          )
          if not self.no_bias
          else 0
      )
      g0 = (
          nn.Variable(inputs[self.g0_idx].shape).apply(
              data=inputs[self.g0_idx].data, need_grad=True
          )
          if not self.no_scale
          else 1
      )
      rm = nn.Variable(inputs[self.rm_idx].shape).apply(
          data=inputs[self.rm_idx].data
      )
      rv = nn.Variable(inputs[self.rv_idx].shape).apply(
          data=inputs[self.rv_idx].data
      )
  
      double_backward = (
          double_backward_for_batch
          if self.batch_stat
          else double_backward_for_global
      )
      with nn.auto_forward():
          g_dy_, g_x0_, g_b0_, g_g0_ = double_backward(
              g_dx0,
              g_db0,
              g_dg0,
              dy,
              x0,
              b0,
              g0,
              rm,
              rv,
              self.axes,
              self.decay_rate,
              self.eps,
          )
      g_dy = inputs[0].grad
      g_x0 = inputs[1].grad
      g_g0 = inputs[self.g0_idx].grad if not self.no_scale else 0
      # wrt dy
      if propagate_down[0]:
          if accum[0]:
              g_dy += g_dy_.data
          else:
              g_dy.copy_from(g_dy_.data)
      # wrt x
      if propagate_down[1]:
          if accum[1]:
              g_x0 += g_x0_.data
          else:
              g_x0.copy_from(g_x0_.data)
      # wrt g
      if not self.no_scale and propagate_down[self.g0_idx]:
          if accum[self.g0_idx]:
              g_g0 += g_g0_.data
          else:
              g_g0.copy_from(g_g0_.data)
  
imports: from functools import partial
  import nnabla
  import nnabla.function
  import nnabla.functions
  import numpy
  from nnabla.function import PythonFunction
  from .utils import force_tuple
label_desc: Use image node_id 11 for calling the BatchNormalizationBackward obj's underlying member method code with example usage: obj.backward_impl(inputs, outputs, propagate_down, accum) without return types