class_docstr: lasagne.layers.ParametricRectifierLayer(incoming,
  alpha=init.Constant(0.25), shared_axes='auto', **kwargs)
  
  A layer that applies parametric rectify nonlinearity to its input
  following [1]_.
  
  Equation for the parametric rectifier linear unit:
  :math:`\varphi(x) = \max(x,0) + \alpha \min(x,0)`
  
  Parameters
  ----------
  incoming : a :class:`Layer` instance or a tuple
      The layer feeding into this layer, or the expected input shape
  
  alpha : Theano shared variable, expression, numpy array or callable
      Initial value, expression or initializer for the alpha values. The
      shape must match the incoming shape, skipping those axes the alpha
      values are shared over (see the example below).
      See :func:`lasagne.utils.create_param` for more information.
  
  shared_axes : 'auto', 'all', int or tuple of int
      The axes along which the parameters 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 parameter over the
      minibatch dimension for dense layers, and additionally over all
      spatial dimensions for convolutional layers. If ``'all'``, share over
      all axes, which corresponds to a single scalar parameter.
  
  **kwargs
      Any additional keyword arguments are passed to the `Layer` superclass.
  
   References
  ----------
  .. [1] K He, X Zhang et al. (2015):
     Delving Deep into Rectifiers: Surpassing Human-Level Performance on
     ImageNet Classification,
     http://arxiv.org/abs/1502.01852
  
  Notes
  -----
  The alpha parameter dimensionality is the input dimensionality minus the
  number of axes it is shared over, which matches the same convention as
  the :class:`BiasLayer`.
  
  >>> layer = ParametricRectifierLayer((20, 3, 28, 28), shared_axes=(0, 3))
  >>> layer.alpha.get_value().shape
  (3, 28)
code: def __init__(
      self,
      incoming,
      alpha=init.Constant(0.25),
      shared_axes="auto",
      **kwargs,
  ):
      super(ParametricRectifierLayer, self).__init__(incoming, **kwargs)
      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
  
      shape = [
          size
          for axis, size in enumerate(self.input_shape)
          if axis not in self.shared_axes
      ]
      if any(size is None for size in shape):
          raise ValueError(
              "ParametricRectifierLayer needs input sizes for "
              "all axes that alpha's are not shared over."
          )
      self.alpha = self.add_param(
          alpha, shape, name="alpha", regularizable=False
      )
  
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 ParametricRectifierLayer object from inherited base classes: Layer with example: obj = ParametricRectifierLayer(incoming, alpha, shared_axes)