code: def GRUCell(
      hidden_size,
      gate_activation=None,
      activation=None,
      dtype="float32",
      name=None,
  ):
      """
      Return a function that creates a paddle.fluid.layers.GRUCell.
      """
      default_name = "GRUCell"
      if name is None:
          name = default_name
      w_name = unique_name.generate(name + "_param")
      b_name = unique_name.generate(name + "_bias")
  
      param_gate_attr = ParamAttr(name=w_name + "_gate")
      param_candidate_attr = ParamAttr(name=w_name + "_candidate")
      bias_gate_attr = ParamAttr(name=b_name + "_gate")
      bias_candidate_attr = ParamAttr(name=b_name + "_candidate")
  
      class GRUCell_(GRULayerFunc):
          def __init__(self):
              super(GRUCell_, self).__init__(
                  AttrHolder(
                      param_gate_attr=param_gate_attr,
                      param_candidate_attr=param_candidate_attr,
                      bias_gate_attr=bias_gate_attr,
                      bias_candidate_attr=bias_candidate_attr,
                  )
              )
  
          def __call__(self, inputs, states):
              # get the prefix name of the parameters first
              param_name_idx = (
                  self.attr_holder.param_gate_attr.name.find("_gate")
              )
              bias_name_idx = self.attr_holder.bias_gate_attr.name.find(
                  "_gate"
              )
              assert (
                  param_name_idx is not -1 and bias_name_idx is not -1
              )
              param_name = self.attr_holder.param_gate_attr.name[
                  :param_name_idx
              ]
              bias_name = self.attr_holder.bias_gate_attr.name[
                  :bias_name_idx
              ]
              param_attr = ParamAttr(name=param_name)
              bias_attr = ParamAttr(name=bias_name)
              gru_cell = layers.GRUCell(
                  hidden_size=hidden_size,
                  param_attr=param_attr,
                  bias_attr=bias_attr,
                  gate_activation=gate_activation,
                  activation=activation,
                  dtype=dtype,
              )
              return gru_cell(inputs, states)
  
      return GRUCell_()
  
imports: import inspect
  import paddle.fluid.layers
  import paddle.fluid.unique_name
  import paddle.fluid
  import six
  from copy import deepcopy
  from paddle.fluid.executor import _fetch_var
  from paddle.fluid.framework import Variable
  from paddle.fluid.layers import *
  from paddle.fluid.param_attr import ParamAttr
  from parl.core.fluid.layers.attr_holder import AttrHolder
  from parl.utils import get_fluid_version
label_desc: Use image node_id 3 for calling a global function with example usage: GRUCell(hidden_size, gate_activation, activation, dtype, name) and returns: GRUCell_, gru_cell