code: def uniform_scaling(
      shape=None, factor=1.0, dtype=tf.float32, seed=None
  ):
      """Uniform Scaling.
  
      Initialization with random values from uniform distribution without scaling
      variance.
  
      When initializing a deep network, it is in principle advantageous to keep
      the scale of the input variance constant, so it does not explode or diminish
      by reaching the final layer. If the input is `x` and the operation `x * W`,
      and we want to initialize `W` uniformly at random, we need to pick `W` from
  
        [-sqrt(3) / sqrt(dim), sqrt(3) / sqrt(dim)]
  
      to keep the scale intact, where `dim = W.shape[0]` (the size of the input).
      A similar calculation for convolutional networks gives an analogous result
      with `dim` equal to the product of the first 3 dimensions.  When
      nonlinearities are present, we need to multiply this by a constant `factor`.
      See [Sussillo et al., 2014](https://arxiv.org/abs/1412.6558)
      ([pdf](http://arxiv.org/pdf/1412.6558.pdf)) for deeper motivation, experiments
      and the calculation of constants. In section 2.3 there, the constants were
      numerically computed: for a linear layer it's 1.0, relu: ~1.43, tanh: ~1.15.
  
      Arguments:
          shape: List of `int`. A shape to initialize a Tensor (optional).
          factor: `float`. A multiplicative factor by which the values will be
              scaled.
          dtype: The tensor data type. Only float are supported.
          seed: `int`. Used to create a random seed for the distribution.
  
      Returns:
          The Initializer, or an initialized `Tensor` if shape is specified.
  
      """
      if shape:
          input_size = 1.0
          for dim in shape[:-1]:
              input_size *= float(dim)
          max_val = math.sqrt(3 / input_size) * factor
          return tf.random_ops.random_uniform(
              shape, -max_val, max_val, dtype, seed=seed
          )
      else:
          return tf.uniform_unit_scaling_initializer(
              seed=seed, dtype=dtype
          )
  
file_path: tflearn/tflearn/initializations.py
imports: from __future__ import division, print_function, absolute_import
  import math
  import tensorflow.compat.v1
  from .utils import get_from_module
label_desc: Use image node_id 4 for calling a global function with example usage: uniform_scaling(shape, factor, dtype, seed) and returns: tf, tf