code: def lstm_cell(num_hidden, batch_size=1, dtype="float32", name=""):
      """Long-Short Term Memory (LSTM) network cell.
  
      Parameters
      ----------
      num_hidden : int
          Number of units in output symbol.
  
      batch_size : int
          Batch size (length of states).
  
      Returns
      -------
      result : tvm.relay.Function
          A Relay function that evaluates an LSTM cell.
          The function takes in a tensor of input data, a tuple of two
          states, and weights and biases for dense operations on the
          inputs and on the state. It returns a tuple with two members,
          an output tensor and a tuple of two new states.
      """
      builder = relay.ScopeBuilder()
  
      input_type = relay.TensorType((batch_size, num_hidden), dtype)
      weight_type = relay.TensorType(
          (4 * num_hidden, num_hidden), dtype
      )
      bias_type = relay.TensorType((4 * num_hidden,), dtype)
  
      dense_type = relay.TensorType((batch_size, 4 * num_hidden), dtype)
      slice_type = relay.TupleType(
          [input_type, input_type, input_type, input_type]
      )
      ret_type = relay.TupleType(
          [input_type, relay.TupleType([input_type, input_type])]
      )
  
      inputs = relay.Var("inputs", input_type)
      states = relay.Var(
          "states", relay.TupleType([input_type, input_type])
      )
  
      i2h_weight = relay.Var("i2h_weight", weight_type)
      i2h_bias = relay.Var("i2h_bias", bias_type)
  
      h2h_weight = relay.Var("h2h_weight", weight_type)
      h2h_bias = relay.Var("h2h_bias", bias_type)
  
      i2h = builder.let(
          ("i2h", dense_type),
          layers.dense_add_bias(
              data=inputs,
              units=num_hidden * 4,
              weight=i2h_weight,
              bias=i2h_bias,
              name=f"{name}i2h",
          ),
      )
      h2h = builder.let(
          ("h2h", dense_type),
          layers.dense_add_bias(
              data=relay.TupleGetItem(states, 0),
              units=num_hidden * 4,
              weight=h2h_weight,
              bias=h2h_bias,
              name=f"{name}h2h",
          ),
      )
  
      gates = builder.let(("gates", dense_type), relay.add(i2h, h2h))
      slice_gates = builder.let(
          ("slice_gates", slice_type),
          relay.split(gates, indices_or_sections=4, axis=1).astuple(),
      )
  
      in_gate = builder.let(
          ("in_gate", input_type),
          relay.sigmoid(relay.TupleGetItem(slice_gates, 0)),
      )
      forget_gate = builder.let(
          ("forget_gate", input_type),
          relay.sigmoid(relay.TupleGetItem(slice_gates, 1)),
      )
      in_transform = builder.let(
          ("in_transform", input_type),
          relay.tanh(relay.TupleGetItem(slice_gates, 2)),
      )
      out_gate = builder.let(
          ("out_gate", input_type),
          relay.sigmoid(relay.TupleGetItem(slice_gates, 3)),
      )
  
      next_c = builder.let(
          ("next_c", input_type),
          relay.add(
              relay.multiply(
                  forget_gate, relay.TupleGetItem(states, 1)
              ),
              relay.multiply(in_gate, in_transform),
          ),
      )
      next_h = builder.let(
          ("next_h", input_type),
          relay.multiply(out_gate, relay.tanh(next_c)),
      )
      ret = builder.let(
          ("ret", ret_type),
          relay.Tuple([next_h, relay.Tuple([next_h, next_c])]),
      )
      builder.ret(ret)
  
      body = builder.get()
  
      return relay.Function(
          [inputs, states, i2h_weight, i2h_bias, h2h_weight, h2h_bias],
          body,
          ret_type,
      )
  
imports: from tvm import relay
  from .None import layers
  from .init import create_workload
label_desc: Use image node_id 1 for calling a global function with example usage: lstm_cell(num_hidden, batch_size, dtype, name) and returns: relay