code: def instance_normalization(
      inp,
      channel_axis=1,
      batch_axis=0,
      eps=1e-05,
      output_stat=False,
      fix_parameters=False,
      param_init=None,
      no_scale=False,
      no_bias=False,
  ):
      r"""
      Applies Instance Normalization over an input variable, which is defined as:
  
      .. math::
        \begin{eqnarray}
          \mu^i &=& \frac{1}{H} \sum_{i=1}^{H} x_i^i \\
          \sigma^i &=& \sqrt{\frac{1}{H} \sum_{i=1}^{H} \left(x_i^i - \mu^i\right)^2} \\
          y &=& \frac{x - \mu^i}{\sigma^ + \epsilon} \gamma + \beta
        \end{eqnarray}
  
      where :math:`x` and :math:`y` are input and output variable,
      :math:`\mu^i` and :math:`\sigma^i` are the mean and std of each instance which is separately calculated for each batch and channel,
      and :math:`\gamma` and :math:`\beta` are adaptive gains and biases.
  
      If the input shape is [B, C, H, W] (= channel_axis=1, batch_axis=0), the shape of calculated mean and std are [B, C, 1, 1]
  
      References:
  
          * `Dmitry Ulyanov, Andrea Vedaldi, Victor Lempitsky, Instance Normalization: The Missing Ingredient for Fast Stylization.
            <https://arxiv.org/abs/1607.08022>`_
  
      Args:
          inp (Variable): An input variable.
          channel_axis (int or repeated int): Channel axes.
          batch_axis (int or repeated int): Batch axes.
          eps (float): Tiny value to avoid zero division by std.
          output_stat(bool): It `True`, the batch statistics of mean and variance.
          fix_parameters (bool): If `True`, the beta and gamma will not be updated.
          param_init (dict):
              Parameter initializers can be set with a dict. A key of the dict must
              be ``'gamma'``, ``'beta'``.
              A value of the dict must be an :obj:`~nnabla.initializer.Initializer`
              or a :obj:`numpy.ndarray`.
              E.g. ``{'gamma': np.ones(...) * 2, 'beta': ConstantInitializer(0)}``.
          no_scale (bool): If `True`, the scale term is omitted.
          no_bias (bool): If `True`, the bias term is omitted.
  
          Returns:
              * :obj:`~nnabla.Variable`: Normalized output variable.
              * :obj:`~nnabla.Variable`: Mean (if `output_stat=True`)
              * :obj:`~nnabla.Variable`: Std (if `output_stat=True`)
          """
      from nnabla.normalization_functions import _init_beta_gamma
  
      shape_stat = [1 for _ in range(len(inp.shape))]
      shape_stat[channel_axis] = inp.shape[channel_axis]
  
      if param_init is None:
          param_init = {}
  
      beta, gamma = _init_beta_gamma(
          shape_stat, fix_parameters, param_init, no_bias, no_scale
      )
  
      return F.instance_normalization(
          inp,
          beta,
          gamma,
          channel_axis=channel_axis,
          batch_axis=batch_axis,
          eps=eps,
          output_stat=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 25 for calling a global function with example usage: instance_normalization(inp, channel_axis, batch_axis, eps, output_stat, fix_parameters, param_init, no_scale, no_bias) and returns: F