下面三个是定义在python/tvm/relay/testing/init.py的函数
    relay.testing.run_opt_pass
    relay.testing.run_infer_type
    relay.testing.rand

    1. # 运行pass
    2. def run_opt_pass(expr, opt_pass):
    3.     assert isinstance(opt_pass, transform.Pass)
    4.     mod = relay.Module.from_expr(expr)
    5.     mod = opt_pass(mod)
    6.     entry = mod["main"]
    7.     return entry if isinstance(expr, relay.Function) else entry.body
    9. # 推断类型
    10. def run_infer_type(expr):
    11.     return run_opt_pass(expr, transform.InferType())
    13. # 指定数据类型和形状，获取随机值
    14. def rand(dtype, *shape):
    15.     return tvm.nd.array(np.random.rand(*shape).astype(dtype))

    下面的是一些自定义的函数：

    1. # 绑定参数
    2. def bind_params(func, params):
    3.     name_dict = {}
    4.     for arg in func.params:
    5.         name = arg.name_hint
    6.         if name in name_dict:
    7.             name_dict[name] = None
    8.         else:
    9.             name_dict[name] = arg
    10.     bind_dict = {}
    11.     for k, v in params.items():
    12.         if k not in name_dict:
    13.             continue
    14.         arg = name_dict[k]
    15.         if arg is None:
    16.             raise ValueError("Multiple args in the function have name %s" % k)
    17.         bind_dict[arg] = tvm.relay.expr.const(v)
    18.     return tvm.relay.expr.bind(func, bind_dict)
    20. # 绑定参数，然后运行pass (用于测试那些需要处理参数的的pass)
    21. def run_opt_pass(expr, opt_pass, params):
    22.     assert isinstance(opt_pass, transform.Pass)
    23.     mod = relay.Module.from_expr(expr)
    24.     entry = bind_params(mod["main"], params)
    25.     mod = relay.Module.from_expr(entry)
    26.     mod = opt_pass(mod)
    27.     return mod
    29. # 绑定参数，编译，运行，获得运行结果
    30. def build_run(expr, params):
    31.     mod = expr if isinstance(expr, relay.Module) else relay.Module.from_expr(expr)
    32.     target = tvm.target.create("llvm")
    33.     ctx = tvm.cpu(0)
    34.     with relay.build_config(opt_level=2):
    35.         graph, lib, params = relay.build(mod, target=target, params=params)
    36.         module = graph_runtime.create(graph, lib, ctx)
    37.         module.set_input(**params)
    38.         module.run()
    39.         tvm_output = module.get_output(0)
    40.         return np.array(tvm_output.asnumpy())
    42. # 绑定参数（输入），编译，运行，获得运行结果
    43. def build_and_run_with_graph(graph_func, params, input=None, pass_only=False, build_only=False):
    44.   expr = graph_func(params)
    45.   mod = relay.Module.from_expr(expr)
    46.   entry = mod['main']
    47.   entry = bind_params(entry, params)
    49.   if pass_only:
    50.     mod = relay.Module({'main': entry})
    51.     seq = transform.Sequential([transform.InferType(), transform.VaccGroupConvPatch()])
    52.     with transform.PassContext():
    53.       mod = seq(mod)
    54.     print(mod)
    55.     print('\n')
    56.     return
    58.   # build
    59.   with relay.build_config(opt_level=2):
    60.     graph, lib, params = relay.build(entry,
    61.                                     target=target,
    62.                                     params=params)
    63.   if build_only:
    64.     print('Test case module built.')
    65.     return
    66.   # create runtime
    67.   m = graph_runtime.create(graph, lib, ctx)
    68.   # set param and input
    69.   m.set_input(**params
    70.   if input is not None:
    71.     m.set_input('data', tvm.nd.array(input))
    72.   # run
    73.   m.run()
    75. # 绑定参数，编译，运行，获得运行结果
    76. def get_tvm_output(func, x, params, target, ctx,
    77.                    out_shape=(1, 1000), input_name='image', dtype='float32'):
    78.     with relay.transform.build_config(opt_level=3):
    79.         graph, lib, params = relay.build(func, target, params=params)
    80.     m = graph_runtime.create(graph, lib, ctx)
    81.     # set inputs
    82.     m.set_input(input_name, tvm.nd.array(x.astype(dtype)))
    83.     m.set_input(**params)
    84.     m.run()
    85.     # get outputs
    86.     out = m.get_output(0, tvm.nd.empty(out_shape, dtype))
    87.     return out.asnumpy()