code: def fused_batch_normalization(
      inp,
      z=None,
      axes=[1],
      decay_rate=0.9,
      eps=1e-5,
      batch_stat=True,
      nonlinearity="relu",
      output_stat=False,
      fix_parameters=False,
      param_init=None,
      no_scale=False,
      no_bias=False,
  ):
      """
      Batch normalization layer fused with the following add2 operation of a
      residual input and an nonlinear activation.
  
      Args:
          inp (~nnabla.Variable): N-D array of input.
          z (~nnabla.Variable, optional):
              A residual input. By specifying None, the activation function will
              follow immediately after BN operation.
          axes (:obj:`tuple` of :obj:`int`):
              Mean and variance for each element in ``axes`` are calculated using
              elements on the rest axes. For example, if an input is 4 dimensions,
              and ``axes`` is ``[1]``,  batch mean is calculated as
              ``np.mean(inp.d, axis=(0, 2, 3), keepdims=True)``
              (using numpy expression as an example).
          decay_rate (float): Decay rate of running mean and variance.
          eps (float): Tiny value to avoid zero division by std.
          batch_stat (bool): Use mini-batch statistics rather than running ones.
          nonlinearity (string): Activation function. The default is 'relu'.
          output_stat (bool): Output batch mean and variance.
          fix_parameters (bool): When set to `True`, the beta and gamma will not be updated.
          no_scale (bool): If `True`, the scale term is omitted.
          no_bias (bool): If `True`, the bias term is omitted.
  
      Returns:
          :class:`~nnabla.Variable`: N-D array.
  
      """
      from .normalization_functions import _init_beta_gamma
  
      shape_stat = [1 for _ in inp.shape]
      for i in range(len(axes)):
          shape_stat[axes[i]] = inp.shape[axes[i]]
  
      if param_init is None:
          param_init = {}
  
      beta, gamma = _init_beta_gamma(
          shape_stat, fix_parameters, param_init, no_bias, no_scale
      )
  
      mean_init = param_init.get("mean", ConstantInitializer(0))
      var_init = param_init.get("var", ConstantInitializer(1))
      mean = get_parameter_or_create(
          "mean", shape_stat, mean_init, False
      )
      var = get_parameter_or_create("var", shape_stat, var_init, False)
      return F.fused_batch_normalization(
          inp,
          beta,
          gamma,
          mean,
          var,
          z,
          axes,
          decay_rate,
          eps,
          batch_stat,
          nonlinearity,
          output_stat,
      )
  
imports: from six import exec_
  import numpy
  import nnabla
  import nnabla.functions
  from nnabla.parameter import get_parameter_or_create, get_parameter
  from nnabla.initializer import calc_uniform_lim_glorot, ConstantInitializer, NormalInitializer, UniformInitializer, WeightNormalizationScaleInitializer
label_desc: Use image node_id 20 for calling a global function with example usage: fused_batch_normalization(inp, z, axes, decay_rate, eps, batch_stat, nonlinearity, output_stat, fix_parameters, param_init, no_scale, no_bias) and returns: F