code: def uniform_unit_scaling(tensor, nonlinearity="linear"):
      """
      An initaliser which preserves output variance for approximately gaussian
      distributed inputs. This boils down to initialising layers using a uniform
      distribution in the range ``(-sqrt(3/dim[0]) * scale, sqrt(3 / dim[0]) * scale)``, where
      ``dim[0]`` is equal to the input dimension of the parameter and the ``scale``
      is a constant scaling factor which depends on the non-linearity used.
  
      See `Random Walk Initialisation for Training Very Deep Feedforward Networks
      <https://www.semanticscholar.org/paper/Random-Walk-Initialization-for-Training-Very-Deep-Sussillo-Abbott/be9728a0728b6acf7a485225b1e41592176eda0b>`_
      for more information.
  
      Parameters
      ----------
      tensor : ``torch.Tensor``, required.
          The tensor to initialise.
      nonlinearity : ``str``, optional (default = "linear")
          The non-linearity which is performed after the projection that this
          tensor is involved in. This must be the name of a function contained
          in the ``torch.nn.functional`` package.
  
      Returns
      -------
      The initialised tensor.
      """
      size = 1.0
      # Estimate the input size. This won't work perfectly,
      # but it covers almost all use cases where this initialiser
      # would be expected to be useful, i.e in large linear and
      # convolutional layers, as the last dimension will almost
      # always be the output size.
      for dimension in list(tensor.size())[:-1]:
          size *= dimension
  
      activation_scaling = torch.nn.init.calculate_gain(
          nonlinearity, tensor
      )
      max_value = math.sqrt(3 / size) * activation_scaling
  
      return tensor.uniform_(-max_value, max_value)
  
imports: from __future__ import division
  from __future__ import absolute_import
  import logging
  import re
  import math
  import itertools
  import torch
  import torch.nn.init
  from allennlp.common import Registrable
  from allennlp.common.params import Params
  from allennlp.common.checks import ConfigurationError
label_desc: Use image node_id 1 for calling a global function with example usage: uniform_unit_scaling(tensor, nonlinearity) and returns: tensor