code: def make_inputs_dict(
      shape_dict: tvm.container.Map,
      dtype_dict: tvm.container.Map,
      inputs: Optional[Dict[str, np.ndarray]] = None,
      fill_mode: str = "random",
  ):
      """Make the inputs dictionary for a graph.
  
      Use data from 'inputs' where specified. For input tensors
      where no data has been given, generate data according to the
      chosen fill-mode.
  
      Parameters
      ----------
      shape_dict : Map
          Shape dictionary - {input_name: tuple}.
      dtype_dict : Map
          dtype dictionary - {input_name: dtype}.
      inputs : dict, optional
          A dictionary that maps input names to numpy values.
      fill_mode : str, optional
          The fill-mode to use when generating tensor data.
          Can be either "zeros", "ones" or "random".
  
      Returns
      -------
      inputs_dict : dict
          Complete inputs dictionary - {input_name: np.array}.
      """
      logger.debug("creating inputs dict")
  
      if inputs is None:
          inputs = {}
  
      # First check all the keys in inputs exist in the graph
      for input_name in inputs:
          if input_name not in shape_dict.keys():
              raise TVMCException(
                  "the input tensor '{}' is not in the graph. Expected inputs: '{}'".format(
                      input_name, list(shape_dict.keys())
                  )
              )
  
      # Now construct the input dict, generating tensors where no
      # data already exists in 'inputs'
      inputs_dict = {}
      for input_name in shape_dict:
          if input_name in inputs.keys():
              logger.debug(
                  "setting input '%s' with user input data", input_name
              )
              inputs_dict[input_name] = inputs[input_name]
          else:
              # container.ShapleTuple -> tuple
              shape = tuple(shape_dict[input_name])
              # container.String -> str
              dtype = str(dtype_dict[input_name])
  
              logger.debug(
                  "generating data for input '%s' (shape: %s, dtype: %s), using fill-mode '%s'",
                  input_name,
                  shape,
                  dtype,
                  fill_mode,
              )
              data = generate_tensor_data(shape, dtype, fill_mode)
              inputs_dict[input_name] = data
  
      return inputs_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 5 for calling a global function with example usage: make_inputs_dict(shape_dict, dtype_dict, inputs, fill_mode) and returns: inputs_dict