code: def n_step_rnn_base(
      n_layers,
      dropout_ratio,
      hx,
      ws,
      bs,
      xs,
      activation,
      use_bi_direction,
      **kwargs,
  ):
      """n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs, activation, \
  use_bi_direction)
  
      Base function for Stack RNN/BiRNN functions.
  
      This function is used at  :func:`chainer.functions.n_step_birnn` and
      :func:`chainer.functions.n_step_rnn`.
      This function's behavior depends on following arguments,
      ``activation`` and ``use_bi_direction``.
  
      Args:
          n_layers(int): Number of layers.
          dropout_ratio(float): Dropout ratio.
          hx (:class:`~chainer.Variable`):
              Variable holding stacked hidden states.
              Its shape is ``(S, B, N)`` where ``S`` is number of layers and is
              equal to ``n_layers``, ``B`` is mini-batch size, and ``N`` is
              dimension of hidden units.
          ws (list of list of :class:`~chainer.Variable`): Weight matrices.
              ``ws[i]`` represents weights for i-th layer.
              Each ``ws[i]`` is a list containing two matrices.
              ``ws[i][j]`` is corresponding with ``W_j`` in the equation.
              Only ``ws[0][j]`` where ``0 <= j < 1`` is ``(N, I)`` shape as they
              are multiplied with input variables. All other matrices has
              ``(N, N)`` shape.
          bs (list of list of :class:`~chainer.Variable`): Bias vectors.
              ``bs[i]`` represnents biases for i-th layer.
              Each ``bs[i]`` is a list containing two vectors.
              ``bs[i][j]`` is corresponding with ``b_j`` in the equation.
              Shape of each matrix is ``(N,)`` where ``N`` is dimension of
              hidden units.
          xs (list of :class:`~chainer.Variable`):
              A list of :class:`~chainer.Variable` holding input values.
              Each element ``xs[t]`` holds input value
              for time ``t``. Its shape is ``(B_t, I)``, where ``B_t`` is
              mini-batch size for time ``t``, and ``I`` is size of input units.
              Note that this function supports variable length sequences.
              When sequneces has different lengths, sort sequences in descending
              order by length, and transpose the sorted sequence.
              :func:`~chainer.functions.transpose_sequence` transpose a list
              of :func:`~chainer.Variable` holding sequence.
              So ``xs`` needs to satisfy
              ``xs[t].shape[0] >= xs[t + 1].shape[0]``.
          activation (str): Activation function name.
              Please select ``tanh`` or ``relu``.
          use_bi_direction (bool): If ``True``, this function uses
              Bi-directional RNN.
  
      Returns:
          tuple: This function returns a tuple containing three elements,
              ``hy`` and ``ys``.
  
              - ``hy`` is an updated hidden states whose shape is same as ``hx``.
              - ``ys`` is a list of :class:`~chainer.Variable` . Each element
                ``ys[t]`` holds hidden states of the last layer corresponding
                to an input ``xs[t]``. Its shape is ``(B_t, N)`` where ``B_t``
                is mini-batch size for time ``t``, and ``N`` is size of hidden
                units. Note that ``B_t`` is the same value as ``xs[t]``.
  
      .. seealso::
         :func:`chainer.functions.n_step_rnn`
         :func:`chainer.functions.n_step_birnn`
  
      """
      if kwargs:
          argument.check_unexpected_kwargs(
              kwargs,
              train="train argument is not supported anymore. "
              "Use chainer.using_config",
              use_cudnn="use_cudnn argument is not supported anymore. "
              "Use chainer.using_config",
          )
          argument.assert_kwargs_empty(kwargs)
  
      activation_list = ["tanh", "relu"]
      if activation not in activation_list:
          candidate = ",".join(activation_list)
          raise ValueError(
              'Invalid activation: "%s". Please select from [%s]'
              % (activation, candidate)
          )
  
      # Check input size consistency with xs and ws.
      x_in = xs[0].shape[1]
      w_in = ws[0][0].shape[1]
      if x_in != w_in:
          raise ValueError(
              "Inconsistent input size in input values and weight "
              "parameters: {} != {}".format(x_in, w_in)
          )
  
      xp = backend.get_array_module(hx)
      directions = 1
      if use_bi_direction:
          directions = 2
  
      combined = _combine_inputs(hx, ws, bs, xs, n_layers, directions)
      has_chainerx_array, combined = _extract_apply_in_data(combined)
      hx_chx, ws_chx, bs_chx, xs_chx = _seperate_inputs(
          combined, n_layers, len(xs), directions
      )
  
      if has_chainerx_array and xp is chainerx and dropout_ratio == 0:
          if use_bi_direction:
              hy, ys = chainerx.n_step_birnn(
                  n_layers, hx_chx, ws_chx, bs_chx, xs_chx, activation
              )
          else:
              hy, ys = chainerx.n_step_rnn(
                  n_layers, hx_chx, ws_chx, bs_chx, xs_chx, activation
              )
          hy = variable.Variable._init_unchecked(
              hy,
              requires_grad=hy.is_backprop_required(),
              is_chainerx_array=True,
          )
          ys = [
              variable.Variable._init_unchecked(
                  y,
                  requires_grad=y.is_backprop_required(),
                  is_chainerx_array=True,
              )
              for y in ys
          ]
          return hy, ys
      if xp is cuda.cupy and chainer.should_use_cudnn(">=auto", 5000):
          lengths = [len(x) for x in xs]
          xs = chainer.functions.concat(xs, axis=0)
          with chainer.using_device(xs.device):
              states = cuda.get_cudnn_dropout_states()
              states.set_dropout_ratio(dropout_ratio)
  
          rnn_mode = "rnn_%s" % activation
          w = cudnn_rnn_weight_concat(
              n_layers, states, use_bi_direction, rnn_mode, ws, bs
          )
  
          if use_bi_direction:
              # Bi-directional RNN
              if activation == "tanh":
                  rnn = NStepBiRNNTanh
              elif activation == "relu":
                  rnn = NStepBiRNNReLU
          else:
              # Uni-directional RNN
              if activation == "tanh":
                  rnn = NStepRNNTanh
              elif activation == "relu":
                  rnn = NStepRNNReLU
  
          hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)
          sections = numpy.cumsum(lengths[:-1])
          ys = chainer.functions.split_axis(ys, sections, 0)
          return hy, ys
  
      else:
  
          def f(x, h, c, w, b):
              xw, hw = w
              xb, hb = b
              rnn_in = linear.linear(x, xw, xb) + linear.linear(
                  h, hw, hb
              )
              if activation == "tanh":
                  return tanh.tanh(rnn_in), None
              elif activation == "relu":
                  return relu.relu(rnn_in), None
  
          hy, _, ys = n_step_rnn_impl(
              f,
              n_layers,
              dropout_ratio,
              hx,
              None,
              ws,
              bs,
              xs,
              use_bi_direction,
          )
          return hy, ys
  
imports: import itertools
  import numpy
  import six
  import chainer
  import chainerx
  from chainer import backend
  from chainer import variable
  from chainer.backends import cuda
  from chainer import configuration
  from chainer import function
  from chainer.functions.activation import relu
  from chainer.functions.activation import tanh
  from chainer.functions.array import concat
  from chainer.functions.array import split_axis
  from chainer.functions.array import stack
  from chainer.functions.connection import linear
  from chainer.functions.noise import dropout
  from chainer.utils import argument
  from chainer.utils import type_check
label_desc: Use image node_id 7 for calling a global function with example usage: n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs, activation, use_bi_direction) and returns: hy,  ys, hy,  ys, hy,  ys, tanh,  None, relu,  None