code: def prelu(x, W):
      """Parametric ReLU function.
  
      It accepts two arguments: an input ``x`` and a weight array ``W``
      and computes the output as
  
      .. math::
          PReLU(x_i) = \\begin{cases}
          x_i & (x_i>0) \\\\ W_i * x_i & (otherwise)\\end{cases}
  
      Args:
          x (:class:`~chainer.Variable` or :ref:`ndarray`): Input variable.
              Its first axis is assumed to be the minibatch dimension.
          W (:class:`~chainer.Variable` or :ref:`ndarray`): Weight variable.
  
      Returns:
          ~chainer.Variable: Output variable
  
      .. admonition:: Example
  
          >>> x = np.arange(-3, 3, dtype=np.float32).reshape((2, 3))
          >>> x
          array([[-3., -2., -1.],
                 [ 0.,  1.,  2.]], dtype=float32)
          >>> W = np.array([0.01, 0.1, 1], dtype=np.float32)
          >>> W
          array([0.01, 0.1 , 1.  ], dtype=float32)
          >>> F.prelu(x, W)
          variable([[-0.03, -0.2 , -1.  ],
                    [ 0.  ,  1.  ,  2.  ]])
  
      .. note::
          When the PReLU function is combined with two-dimensional convolution,
          the elements of parameter :math:`W` are typically shared across the
          same filter of different pixels. In order to support such usage,
          this function supports the shape of parameter array that indicates
          leading dimensions of input arrays except the batch dimension.
  
          For example, if :math:`W` has the shape of :math:`(2, 3, 4)`,
          :math:`x` must have the shape of :math:`(B, 2, 3, 4, S_1, ..., S_N)`
          where :math:`B` is the batch size and the number of trailing
          :math:`S`'s :math:`N` is an arbitrary non-negative integer.
  
      .. warning::
          :math:`W` is a trainable parameter in the original paper
          (https://arxiv.org/abs/1502.01852). To train :math:`W`, use
          :class:`chainer.links.PReLU` instead.
  
      .. seealso::
          :class:`chainer.links.PReLU` to manage the model parameter ``W``.
  
      """
      return PReLUFunction().apply((x, W))[0]
  
imports: import numpy
  import chainer
  from chainer.backends import cuda
  from chainer import function_node
  from chainer.utils import type_check
label_desc: Use image node_id 4 for calling a global function with example usage: prelu(x, W) and returns: PReLUFunction