class_docstr: Stateless Gated Recurrent Unit function (GRU).
  
  GRU function has six parameters :math:`W_r`, :math:`W_z`, :math:`W`,
  :math:`U_r`, :math:`U_z`, and :math:`U`.
  The three parameters :math:`W_r`, :math:`W_z`, and :math:`W` are
  :math:`n \times m` matrices, and the others :math:`U_r`, :math:`U_z`,
  and :math:`U` are :math:`n \times n` matrices, where :math:`m` is the
  length of input vectors and :math:`n` is the length of hidden vectors.
  
  Given two inputs a previous hidden vector :math:`h` and an input vector
  :math:`x`, GRU returns the next hidden vector :math:`h'` defined as
  
  .. math::
  
     r &=& \sigma(W_r x + U_r h), \\
     z &=& \sigma(W_z x + U_z h), \\
     \bar{h} &=& \tanh(W x + U (r \odot h)), \\
     h' &=& (1 - z) \odot h + z \odot \bar{h},
  
  where :math:`\sigma` is the sigmoid function, and :math:`\odot` is the
  element-wise product.
  
  As the name indicates, :class:`~chainer.links.StatelessGRU` is *stateless*,
  meaning that it does not hold the value of
  hidden vector :math:`h`.
  For a *stateful* GRU, use :class:`~chainer.links.StatefulGRU`.
  
  Args:
      in_size(int): Dimension of input vector :math:`x`.
          If ``None``, parameter initialization will be deferred
          until the first forward data pass
          at which time the size will be determined.
      out_size(int): Dimension of hidden vector :math:`h`,
          :math:`\bar{h}` and :math:`h'`.
  
  See:
      - `On the Properties of Neural Machine Translation: Encoder-Decoder
        Approaches <https://www.aclweb.org/anthology/W14-4012>`_
        [Cho+, SSST2014].
      - `Empirical Evaluation of Gated Recurrent Neural Networks on Sequence
        Modeling <https://arxiv.org/abs/1412.3555>`_
        [Chung+NIPS2014 DLWorkshop].
  
  
  .. seealso:: :class:`~chainer.links.StatefulGRU`
  
  .. admonition:: Example
  
      There are several ways to make a ``StatelessGRU`` link.
      Let ``x`` be a two-dimensional input array:
  
      >>> in_size = 10
      >>> out_size = 20
      >>> x = np.zeros((1, in_size), dtype=np.float32)
      >>> h = np.zeros((1, out_size), dtype=np.float32)
  
      1. Give both  ``in_size`` and ``out_size`` arguments:
  
          >>> l = L.StatelessGRU(in_size, out_size)
          >>> h_new = l(h, x)
          >>> h_new.shape
          (1, 20)
  
      2. Omit ``in_size`` argument or fill it with ``None``:
  
          >>> l = L.StatelessGRU(None, out_size)
          >>> h_new = l(h, x)
          >>> h_new.shape
          (1, 20)
code: def forward(self, h, x):
      r = sigmoid.sigmoid(self.W_r(x) + self.U_r(h))
      z = sigmoid.sigmoid(self.W_z(x) + self.U_z(h))
      h_bar = tanh.tanh(self.W(x) + self.U(r * h))
      h_new = linear_interpolate.linear_interpolate(z, h_bar, h)
      return h_new
  
imports: from chainer.functions.activation import sigmoid
  from chainer.functions.activation import tanh
  from chainer.functions.math import linear_interpolate
  from chainer import link
  from chainer.links.connection import linear
  from chainer import variable
label_desc: Use image node_id 1 for calling the StatelessGRU obj's underlying member method code with example usage: obj.forward(h, x) and returns: h_new