code: def instance_norm(
      inputs,
      center=True,
      scale=True,
      epsilon=1e-6,
      activation_fn=None,
      param_initializers=None,
      reuse=None,
      variables_collections=None,
      outputs_collections=None,
      trainable=True,
      data_format=DATA_FORMAT_NHWC,
      scope=None,
  ):
      """Functional interface for the instance normalization layer.
  
      Reference: https://arxiv.org/abs/1607.08022.
  
        "Instance Normalization: The Missing Ingredient for Fast Stylization"
        Dmitry Ulyanov, Andrea Vedaldi, Victor Lempitsky
  
      Args:
        inputs: A tensor with 2 or more dimensions, where the first dimension has
          `batch_size`. The normalization is over all but the last dimension if
          `data_format` is `NHWC` and the second dimension if `data_format` is
          `NCHW`.
        center: If True, add offset of `beta` to normalized tensor. If False, `beta`
          is ignored.
        scale: If True, multiply by `gamma`. If False, `gamma` is
          not used. When the next layer is linear (also e.g. `nn.relu`), this can be
          disabled since the scaling can be done by the next layer.
        epsilon: Small float added to variance to avoid dividing by zero.
        activation_fn: Activation function, default set to None to skip it and
          maintain a linear activation.
        param_initializers: Optional initializers for beta, gamma, moving mean and
          moving variance.
        reuse: Whether or not the layer and its variables should be reused. To be
          able to reuse the layer scope must be given.
        variables_collections: Optional collections for the variables.
        outputs_collections: Collections to add the outputs.
        trainable: If `True` also add variables to the graph collection
          `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
        data_format: A string. `NHWC` (default) and `NCHW` are supported.
        scope: Optional scope for `variable_scope`.
  
      Returns:
        A `Tensor` representing the output of the operation.
  
      Raises:
        ValueError: If `data_format` is neither `NHWC` nor `NCHW`.
        ValueError: If the rank of `inputs` is undefined.
        ValueError: If rank or channels dimension of `inputs` is undefined.
      """
      inputs = ops.convert_to_tensor(inputs)
      inputs_shape = inputs.shape
      inputs_rank = inputs.shape.ndims
      # For big endian, precision difference in last decimal values getting in
      # float32 Vs float64 data type is causing normalization_test failure.
      # The cast to float64 will calculate mean and variance correctly while
      # normalization of `inputs` tensor.
      if (
          sys.byteorder == "big"
          and inputs.dtype.base_dtype == dtypes.float32
      ):
          inputs = math_ops.cast(inputs, dtypes.float64)
  
      if inputs_rank is None:
          raise ValueError(
              "Inputs %s has undefined rank." % inputs.name
          )
      if data_format not in (DATA_FORMAT_NCHW, DATA_FORMAT_NHWC):
          raise ValueError("data_format has to be either NCHW or NHWC.")
  
      with variable_scope.variable_scope(
          scope, "InstanceNorm", [inputs], reuse=reuse
      ) as sc:
          if data_format == DATA_FORMAT_NCHW:
              reduction_axis = 1
              # For NCHW format, rather than relying on implicit broadcasting, we
              # explicitly reshape the params to params_shape_broadcast when computing
              # the moments and the batch normalization.
              params_shape_broadcast = list(
                  [1, inputs_shape[1].value]
                  + [1 for _ in range(2, inputs_rank)]
              )
          else:
              reduction_axis = inputs_rank - 1
              params_shape_broadcast = None
          moments_axes = list(range(inputs_rank))
          del moments_axes[reduction_axis]
          del moments_axes[0]
          params_shape = inputs_shape[
              reduction_axis : reduction_axis + 1
          ]
          if not params_shape.is_fully_defined():
              raise ValueError(
                  "Inputs %s has undefined channels dimension %s."
                  % (inputs.name, params_shape)
              )
  
          # Allocate parameters for the beta and gamma of the normalization.
          beta, gamma = None, None
          dtype = inputs.dtype.base_dtype
          if param_initializers is None:
              param_initializers = {}
          if center:
              beta_collections = utils.get_variable_collections(
                  variables_collections, "beta"
              )
              beta_initializer = param_initializers.get(
                  "beta", init_ops.zeros_initializer()
              )
              beta = variables.model_variable(
                  "beta",
                  shape=params_shape,
                  dtype=dtype,
                  initializer=beta_initializer,
                  collections=beta_collections,
                  trainable=trainable,
              )
              if params_shape_broadcast:
                  beta = array_ops.reshape(beta, params_shape_broadcast)
          if scale:
              gamma_collections = utils.get_variable_collections(
                  variables_collections, "gamma"
              )
              gamma_initializer = param_initializers.get(
                  "gamma", init_ops.ones_initializer()
              )
              gamma = variables.model_variable(
                  "gamma",
                  shape=params_shape,
                  dtype=dtype,
                  initializer=gamma_initializer,
                  collections=gamma_collections,
                  trainable=trainable,
              )
              if params_shape_broadcast:
                  gamma = array_ops.reshape(
                      gamma, params_shape_broadcast
                  )
  
          # Calculate the moments (instance activations).
          mean, variance = nn.moments(
              inputs, moments_axes, keep_dims=True
          )
  
          # Compute instance normalization.
          outputs = nn.batch_normalization(
              inputs,
              mean,
              variance,
              beta,
              gamma,
              epsilon,
              name="instancenorm",
          )
          if activation_fn is not None:
              outputs = activation_fn(outputs)
          return utils.collect_named_outputs(
              outputs_collections, sc.name, outputs
          )
  
file_path: tensornets/tensornets/contrib_layers/normalization.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import sys
  from ..contrib_framework import add_arg_scope
  from ..contrib_framework import variables
  from .None import utils
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import init_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import nn
  from tensorflow.python.ops import variable_scope
  from tensorflow.python.framework import dtypes
label_desc: Use image node_id 1 for calling a global function with example usage: instance_norm(inputs, center, scale, epsilon, activation_fn, param_initializers, reuse, variables_collections, outputs_collections, trainable, data_format, scope) and returns: utils