code: def get_input_info(graph_str: str, params: Dict[str, tvm.nd.NDArray]):
      """Return the 'shape' and 'dtype' dictionaries for the input
      tensors of a compiled module.
  
      .. note::
          We can't simply get the input tensors from a TVM graph
          because weight tensors are treated equivalently. Therefore, to
          find the input tensors we look at the 'arg_nodes' in the graph
          (which are either weights or inputs) and check which ones don't
          appear in the params (where the weights are stored). These nodes
          are therefore inferred to be input tensors.
  
      .. note::
          There exists a more recent API to retrieve the input information
          directly from the module. However, this isn't supported when using
          with RPC due to a lack of support for Array and Map datatypes.
          Therefore, this function exists only as a fallback when RPC is in
          use. If RPC isn't being used, please use the more recent API.
  
      Parameters
      ----------
      graph_str : str
          JSON graph of the module serialized as a string.
      params : dict
          Parameter dictionary mapping name to value.
  
      Returns
      -------
      shape_dict : dict
          Shape dictionary - {input_name: tuple}.
      dtype_dict : dict
          dtype dictionary - {input_name: dtype}.
      """
  
      shape_dict = {}
      dtype_dict = {}
      params_dict = load_param_dict(params)
      param_names = [k for (k, v) in params_dict.items()]
      graph = json.loads(graph_str)
      for node_id in graph["arg_nodes"]:
          node = graph["nodes"][node_id]
          # If a node is not in the params, infer it to be an input node
          name = node["name"]
          if name not in param_names:
              shape_dict[name] = graph["attrs"]["shape"][1][node_id]
              dtype_dict[name] = graph["attrs"]["dltype"][1][node_id]
  
      return shape_dict, dtype_dict
  
imports: from contextlib import ExitStack
  import logging
  import pathlib
  from typing import Dict, Optional, Union
  from tarfile import ReadError
  import argparse
  import sys
  import json
  import numpy
  import tvm
  from tvm import rpc
  from tvm.runtime import vm
  from tvm.autotvm.measure import request_remote
  from tvm.contrib import graph_executor
  from tvm.contrib.debugger import debug_executor
  from tvm.runtime import profiler_vm
  from tvm.relay.param_dict import load_param_dict
  from .None import TVMCException
  from .arguments import TVMCSuppressedArgumentParser
  from .project import get_project_options, get_and_check_options, get_project_dir
  from .main import register_parser
  from .model import TVMCPackage, TVMCResult
  from .result_utils import get_top_results
  from .tracker import tracker_host_port_from_cli
label_desc: Use image node_id 3 for calling a global function with example usage: get_input_info(graph_str, params) and returns: shape_dict,  dtype_dict