code: def get_net(iterations, num_hidden, batch_size=1, dtype="float32"):
      """Constructs an unrolled RNN with LSTM cells"""
      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)
  
      state_type = relay.TupleType([input_type, input_type])
      cell_type = relay.TupleType([input_type, state_type])
  
      builder = relay.ScopeBuilder()
  
      zeros = builder.let(
          ("zeros", input_type),
          relay.zeros((batch_size, num_hidden), dtype),
      )
      init_states = builder.let(
          ("init_states", state_type), relay.Tuple([zeros, zeros])
      )
  
      states = init_states
      out = None
  
      for i in range(iterations):
          inputs = relay.Var("data", input_type)
          i2h_weight = relay.Var(f"i2h_{i}_weight", weight_type)
          i2h_bias = relay.Var(f"i2h_{i}_bias", bias_type)
          h2h_weight = relay.Var(f"h2h_{i}_weight", weight_type)
          h2h_bias = relay.Var(f"h2h_{i}_bias", bias_type)
  
          cell_fn = lstm_cell(
              num_hidden, batch_size, dtype, f"lstm_{i}"
          )
  
          call = builder.let(
              (f"call_{i}", cell_type),
              relay.Call(
                  cell_fn,
                  [
                      inputs,
                      states,
                      i2h_weight,
                      i2h_bias,
                      h2h_weight,
                      h2h_bias,
                  ],
              ),
          )
          new_out = builder.let(
              (f"out_{i}", input_type), relay.TupleGetItem(call, 0)
          )
          new_states = builder.let(
              (f"states_{i}", state_type), relay.TupleGetItem(call, 1)
          )
          states = new_states
          out = new_out
  
      builder.ret(out)
      body = builder.get()
      args = relay.analysis.free_vars(body)
      return relay.Function(args, body, input_type)
  
imports: from tvm import relay
  from .None import layers
  from .init import create_workload
label_desc: Use image node_id 2 for calling a global function with example usage: get_net(iterations, num_hidden, batch_size, dtype) and returns: relay