code: def rrelu(x, l=1.0 / 8, u=1.0 / 3, **kwargs):
      """rrelu(x, l=1. / 8, u=1. / 3, *, r=None, return_r=False)
  
      Randomized Leaky Rectified Liner Unit function.
  
      This function is expressed as
  
      .. math:: f(x)=\\max(x, rx),
  
      where :math:`r` is a random number sampled from a uniform distribution
      :math:`U(l, u)`.
  
      .. note::
  
          The :math:`r` corresponds to :math:`a` in the original
          paper (https://arxiv.org/pdf/1505.00853.pdf).
  
      Args:
          x (:class:`~chainer.Variable` or :ref:`ndarray`):
              Input variable. A :math:`(s_1, s_2, ..., s_N)`-shaped float array.
          l (float): The lower bound of the uniform distribution.
          u (float): The upper bound of the uniform distribution.
          r (:ref:`ndarray` or None):
              The r to be used for rrelu.
              The shape and dtype must be the same as ``x[0]`` and should be on
              the same device.
              If ``r``  is not specified or set to ``None``, an ``r`` will be
              generated randomly according to the given ``l`` and ``u``.
              If ``r`` is specified, ``l`` and ``u`` will be ignored.
          return_r (bool):
              If ``True``, the r used for rrelu is returned altogether with
              the output variable.
              The returned ``r`` can latter be reused by passing it to ``r``
              argument.
  
      Returns:
          ~chainer.Variable or tuple:
              When ``return_r`` is ``False`` (default), return the output
              variable. Otherwise returnes the tuple of the output variable and
              ``r`` (:ref:`ndarray`). The ``r`` will be on the same device as
              the input.
              A :math:`(s_1, s_2, ..., s_N)`-shaped float array.
  
      .. admonition:: Example
  
          >>> x = np.array([[-1, 0], [2, -3], [-2, 1]], np.float32)
          >>> x
          array([[-1.,  0.],
                 [ 2., -3.],
                 [-2.,  1.]], dtype=float32)
          >>> F.rrelu(x).array # doctest: +SKIP
          array([[-0.24850948,  0.        ],
                 [ 2.        , -0.50844127],
                 [-0.598535  ,  1.        ]], dtype=float32)
      """
      r = None
      return_r = False
      if kwargs:
          r, return_r = argument.parse_kwargs(
              kwargs,
              ("r", r),
              ("return_r", r),
              train="train argument is not supported anymore. "
              "Use chainer.using_config",
          )
  
      func = RReLU(l, u, r)
      (out,) = func.apply((x,))
      r = func.r
  
      if return_r:
          return out, r
      return out
  
imports: import numpy
  import chainer
  from chainer.backends import cuda
  from chainer import function_node
  from chainer.utils import argument
  from chainer.utils import type_check
label_desc: Use image node_id 2 for calling a global function with example usage: rrelu(x, l, u) and returns: out, out,  r