def verify_upsampling3d(dshape, scale_d, scale_h, scale_w, layout, method, coord_trans="half_pixel"): if layout == "NCDHW": (n, c, d, h, w) = dshape x_data = np.random.uniform(size=(n, c, d, h, w)).astype("float32") elif layout == "NDHWC": (n, d, h, w, c) = dshape x_data = np.random.uniform(size=(n, d, h, w, c)).astype("float32") if method == "nearest_neighbor": ref_res = tvm.topi.testing.upsampling3d_python(x_data, (scale_d, scale_h, scale_w), layout) else: ref_res = tvm.topi.testing.trilinear_resize3d_python(x_data, (int(round(d*scale_d)), int(round(h*scale_h)), int(round(w*scale_w))), layout) x = relay.Var("x", relay.TensorType(dshape, "float32")) scale_d_var = relay.var("scale_d", relay.TensorType((), "float32")) scale_h_var = relay.var("scale_h", relay.TensorType((), "float32")) scale_w_var = relay.var("scale_h", relay.TensorType((), "float32")) z = relay.nn.upsampling3d(x, scale_d_var, scale_h_var, scale_w_var, method=method, layout=layout, coordinate_transformation_mode=coord_trans) zz = run_infer_type(z) func = relay.Function([x, scale_d_var, scale_h_var, scale_w_var], z) for target, ctx in enabled_targets(): for kind in ["vm", "debug"]: mod = tvm.ir.IRModule.from_expr(func) intrp = relay.create_executor(kind, mod=mod, ctx=ctx, target=target) op_res = intrp.evaluate()(x_data, np.array(scale_d).astype("float32"), np.array(scale_h).astype("float32"), np.array(scale_w).astype("float32")) tvm.testing.assert_allclose(op_res.asnumpy(), ref_res, rtol=1e-4, atol=1e-6)
def verify_upsampling3d(dshape, scale_d, scale_h, scale_w, layout, method, coord_trans="asymmetric"): if layout == "NCDHW": (n, c, d, h, w) = dshape x_data = np.random.uniform(size=(n, c, d, h, w)).astype("float32") elif layout == "NDHWC": (n, d, h, w, c) = dshape x_data = np.random.uniform(size=(n, d, h, w, c)).astype("float32") ref_res = tvm.topi.testing.resize3d_python( x_data, (scale_d, scale_h, scale_w), layout, method[3:] if method[0:3] == "tri" else method, coord_trans, ) x = relay.Var("x", relay.TensorType(dshape, "float32")) scale_d_var = relay.var("scale_d", relay.TensorType((), "float32")) scale_h_var = relay.var("scale_h", relay.TensorType((), "float32")) scale_w_var = relay.var("scale_h", relay.TensorType((), "float32")) z = relay.nn.upsampling3d( x, scale_d_var, scale_h_var, scale_w_var, method=method, layout=layout, coordinate_transformation_mode=coord_trans, ) zz = run_infer_type(z) func = relay.Function([x, scale_d_var, scale_h_var, scale_w_var], z) for target, dev in enabled_targets(): for kind in ["vm", "debug"]: mod = tvm.ir.IRModule.from_expr(func) intrp = relay.create_executor(kind, mod=mod, device=dev, target=target) op_res = intrp.evaluate()( x_data, np.array(scale_d).astype("float32"), np.array(scale_h).astype("float32"), np.array(scale_w).astype("float32"), ) tvm.testing.assert_allclose(op_res.numpy(), ref_res, rtol=1e-4, atol=1e-6)
def check_tensor_array(ta_mod, ref_res, *args, dtype="float32", rtol=1e-5): for kind in ["debug", "vm"]: for target, ctx in testing.enabled_targets(): if kind == "debug" and ctx.device_type != tvm.cpu().device_type: continue ex = relay.create_executor(kind, mod=ta_mod, ctx=ctx, target=target) result = ex.evaluate()(*args) got = vmobj_to_list(result, dtype) tvm.testing.assert_allclose(ref_res, got, rtol=rtol, atol=rtol)
def test_dynamic_bcast(): dtype = "float32" x = relay.var("x", shape=(relay.Any(), 2), dtype=dtype) y = relay.var("y", shape=(3, 2), dtype=dtype) mod = tvm.IRModule() mod["main"] = relay.Function([x, y], relay.add(x, y)) x_data = np.random.uniform(size=(1, 2)).astype(dtype) y_data = np.random.uniform(size=(3, 2)).astype(dtype) res_np = np.add(x_data, y_data) for target, ctx in testing.enabled_targets(): res = get_serialized_output(mod, *(x_data, y_data), target=target, ctx=ctx) tvm.testing.assert_allclose(res.asnumpy(), res_np)
def test_dynamic_bcast(): import pytest import numpy as np import tvm from tvm.runtime import vm as _vm from tvm.relay import vm as rly_vm from tvm import relay from tvm.relay.scope_builder import ScopeBuilder from tvm.relay import transform from tvm.relay.prelude import Prelude from tvm.relay import testing def create_exec(f, target="llvm", params=None): if isinstance(f, relay.Expr): mod = tvm.IRModule() mod["main"] = f executable = rly_vm.compile(mod, target=target, params=params) return executable else: assert isinstance(f, tvm.IRModule), "expected mod as tvm.IRModule" executable = rly_vm.compile(f, target=target, params=params) return executable def get_serialized_output(mod, *data, params=None, target="llvm", ctx=tvm.cpu()): exe = create_exec(mod, target, params=params) code, lib = exe.save() des_exec = _vm.Executable.load_exec(code, lib) des_vm = _vm.VirtualMachine(des_exec, ctx) result = des_vm.run(*data) print(result) return result dtype = "float32" x = relay.var("x", shape=(1, 2), dtype=dtype) y = relay.var("y", shape=(relay.Any(), 2), dtype=dtype) mod = tvm.IRModule() mod["main"] = relay.Function([x, y], relay.add(x, y)) x_data = np.random.uniform(size=(1, 2)).astype(dtype) y_data = np.random.uniform(size=(4, 2)).astype(dtype) res_np = np.add(x_data, y_data) for target, ctx in testing.enabled_targets(): res = get_serialized_output(mod, *(x_data, y_data), target=target, ctx=ctx) tvm.testing.assert_allclose(res.asnumpy(), res_np)
def test_basic(): mod, params = resnet.get_workload() if not profiler_vm.enabled(): return for target, dev in enabled_targets(): exe = relay.vm.compile(mod, target, params=params) vm = profiler_vm.VirtualMachineProfiler(exe, dev) data = np.random.rand(1, 3, 224, 224).astype("float32") res = vm.invoke("main", [data]) print("\n{}".format(vm.get_stat())) print("\n{}".format(vm.get_stat(False)))
def benchmark_execution(mod, params, measure=True, data_shape=(1, 3, 224, 224), out_shape=(1, 1000), dtype='float32', model="unknown"): def get_graph_runtime_output(mod, data, params, target, ctx, dtype='float32', number=2, repeat=20): with tvm.transform.PassContext(opt_level=3): graph, lib, params = relay.build(mod, target, params=params) m = graph_runtime.create(graph, lib, ctx) # set inputs m.set_input("data", data) m.set_input(**params) m.run() out = m.get_output(0, tvm.nd.empty(out_shape, dtype)) if measure: print("Evaluate graph runtime inference cost of {} on " "{}".format(model, repr(ctx))) ftimer = m.module.time_evaluator("run", ctx, number=1, repeat=20) # Measure in millisecond. prof_res = np.array(ftimer().results) * 1000 print( "Mean graph runtime inference time (std dev): %.2f ms (%.2f ms)" % (np.mean(prof_res), np.std(prof_res))) return out.asnumpy() def get_vm_output(mod, data, params, target, ctx, dtype='float32', number=2, repeat=20): with tvm.transform.PassContext(opt_level=3): exe = vm.compile(mod, target, params=params) rly_vm = vm_rt.VirtualMachine(exe, ctx) result = rly_vm.run(data) if measure: print("Evaluate vm inference cost of {} on {}".format( model, repr(ctx))) ftimer = rly_vm.module.time_evaluator("invoke", ctx, number=number, repeat=repeat) # Measure in millisecond. prof_res = np.array(ftimer("main", data).results) * 1000 print("Mean vm inference time (std dev): %.2f ms (%.2f ms)" % (np.mean(prof_res), np.std(prof_res))) return result.asnumpy().astype(dtype) # random input data = np.random.uniform(size=data_shape).astype(dtype) for target, ctx in testing.enabled_targets(): tvm_out = get_graph_runtime_output(mod, tvm.nd.array(data.astype(dtype)), params, target, ctx, dtype) vm_out = get_vm_output(mod, tvm.nd.array(data.astype(dtype)), params, target, ctx, dtype) tvm.testing.assert_allclose(vm_out, tvm_out, rtol=1e-5, atol=1e-5)