class_docstr: A layer that applies a randomized leaky rectify nonlinearity to its input.
  
  The randomized leaky rectifier was first proposed and used in the Kaggle
  NDSB Competition, and later evaluated in [1]_. Compared to the standard
  leaky rectifier :func:`leaky_rectify`, it has a randomly sampled slope
  for negative input during training, and a fixed slope during evaluation.
  
  Equation for the randomized rectifier linear unit during training:
  :math:`\varphi(x) = \max((\sim U(lower, upper)) \cdot x, x)`
  
  During evaluation, the factor is fixed to the arithmetic mean of `lower`
  and `upper`.
  
  Parameters
  ----------
  incoming : a :class:`Layer` instance or a tuple
      The layer feeding into this layer, or the expected input shape
  
  lower : Theano shared variable, expression, or constant
      The lower bound for the randomly chosen slopes.
  
  upper : Theano shared variable, expression, or constant
      The upper bound for the randomly chosen slopes.
  
  shared_axes : 'auto', 'all', int or tuple of int
      The axes along which the random slopes of the rectifier units are
      going to be shared. If ``'auto'`` (the default), share over all axes
      except for the second - this will share the random slope over the
      minibatch dimension for dense layers, and additionally over all
      spatial dimensions for convolutional layers. If ``'all'``, share over
      all axes, thus using a single random slope.
  
  **kwargs
      Any additional keyword arguments are passed to the `Layer` superclass.
  
   References
  ----------
  .. [1] Bing Xu, Naiyan Wang et al. (2015):
     Empirical Evaluation of Rectified Activations in Convolutional Network,
     http://arxiv.org/abs/1505.00853
code: def __init__(
      self, incoming, lower=0.3, upper=0.8, shared_axes="auto", **kwargs
  ):
      super(RandomizedRectifierLayer, self).__init__(incoming, **kwargs)
      self._srng = RandomStreams(get_rng().randint(1, 2147462579))
      self.lower = lower
      self.upper = upper
  
      if (
          not isinstance(lower > upper, theano.Variable)
          and lower > upper
      ):
          raise ValueError(
              "Upper bound for RandomizedRectifierLayer needs "
              "to be higher than lower bound."
          )
  
      if shared_axes == "auto":
          self.shared_axes = (0,) + tuple(
              range(2, len(self.input_shape))
          )
      elif shared_axes == "all":
          self.shared_axes = tuple(range(len(self.input_shape)))
      elif isinstance(shared_axes, int_types):
          self.shared_axes = (shared_axes,)
      else:
          self.shared_axes = shared_axes
  
imports: import theano
  import theano.tensor
  import numpy
  from ..None import init
  from ..None import nonlinearities
  from ..utils import as_tuple, floatX, int_types
  from ..random import get_rng
  from .base import Layer, MergeLayer
  from theano.sandbox.rng_mrg import MRG_RandomStreams
label_desc: Use image node_id 1 to create a new RandomizedRectifierLayer object from inherited base classes: Layer with example: obj = RandomizedRectifierLayer(incoming, lower, upper, shared_axes)