code: def tensor_normalization(
      x, axes, beta=None, gamma=None, eps=1e-05, output_stat=False
  ):
      r"""
      General tensor normalization.
      Input variable `x` is normalized by mean and std calculated by `x` itself.
      Mean and variance are calculated along `axes`.
      For example, if the input shape is (B, C, H, W) and axes is [0, 1],
       the shape of calculated mean and std are (B, C, 1 ,1).
  
      Note:
          Currently tensor_normalization is implemented not as cpp function
          but as wrapper function which just calls F.batch_normalization internally.
          That means F.reshape or F.transpose may be additionally called to satisfy the condition required by F.batch_normalization,
          and if you serialize graphs including tensor_normalization to nnp file,
          that nnp includes reshape, transpose and batch_normalization rather than tensor_normalization layer itself.
  
      Args:
          x (Variable): N-D array of input variable.
          axes (int or repeated int): Mean and variance are calculated along these axes.
          beta (Variable or None): An Adaptive biases. If None, the bias term is omitted.
          gamma (Variable or None): An Adaptive scales. If None, the scale term is omitted.
          eps (float): Tiny value to avoid zero division by std.
          output_stat(bool): It true, the batch statistics of mean and variance.
          will be returned as Variables. They are also differentiable.
  
      Returns:
          * :obj:`~nnabla.Variable`: Normalized output variable.
          * :obj:`~nnabla.Variable`: Mean (if ``output_stat=True`)
          * :obj:`~nnabla.Variable`: Std (if ``output_stat=True`)
  
      """
      # todo: should implement cpp function rather than just calling batch_normalization in python.
  
      return batch_normalization(
          x,
          beta,
          gamma,
          None,
          None,
          axes=axes,
          decay_rate=0.0,
          eps=eps,
          batch_stat=True,
          output_stat=output_stat,
      )
  
imports: from __future__ import absolute_import
  from .function_bases import *
  from six.moves import reduce
  import numpy
  import nnabla
label_desc: Use image node_id 11 for calling a global function with example usage: tensor_normalization(x, axes, beta, gamma, eps, output_stat) and returns: batch_normalization