except FileExistsError:
pass
print("building...")
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(net, target, target_host=target_host, params=params)
print("dumping lib...")
lib.export_library(output_path_str + '/' + 'deploy_lib_cpu.so', ndk.create_shared)
net, params, input_shape, output_shape = get_network(network, batch_size=1)
print_progress("%-20s building..." % network)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(
net, target=target, target_host=target_host, params=params)
def benchmark(network, target):
net, params, input_shape, output_shape = get_network(network, batch_size=1)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(net, target=target, params=params)
# create runtime
net, params, input_shape, output_shape = get_network(network, batch_size=1, dtype=dtype)
print_progress("%-20s building..." % network)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(
net, target=target, target_host=target_host, params=params)
func = mod["main"]
func = relay.Function(func.params, relay.nn.softmax(func.body), None, func.type_params, func.attrs)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(
func, 'llvm --system-lib', params=params)
net, params = relay.testing.resnet.get_workload(
layers=18, batch_size=dshape[0], image_shape=dshape[1:])
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(
net, 'llvm --system-lib', params=params)
# under the License.
import os
-from tvm import relay
+from tvm import relay, transform
from tvm.contrib.download import download_testdata
target = 'llvm'
# Build with Relay
-with relay.build_config(opt_level=3):
+with transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(
mod, target, params=params)
assert all(var.name_hint in params.keys() for var in analysis.free_vars(
input_val)), "All inputs to infer must be available in params."
func = _function.Function(analysis.free_vars(input_val), input_val)
- with tvm.relay.build_config(opt_level=0):
+ with tvm.transform.PassContext(opt_level=0):
graph, lib, params = tvm.relay.build(func, target="llvm", params=params)
ctx = tvm.cpu(0)
m = graph_runtime.create(graph, lib, ctx)
from .. import op as _op
from .. import expr as _expr
from .. import analysis as _analysis
-from .. import transform as _transform
from .. import build_module as _build_module
from ...contrib import graph_runtime
from .kl_divergence import _find_scale_by_kl
target = 'llvm'
ctx = tvm.context(target)
- with _transform.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = _build_module.build(func, target=target)
runtime = graph_runtime.create(graph, lib, ctx)
runtime.set_input(**params)
import types
import inspect
import functools
+import warnings
import tvm.ir
from tvm import te
required_pass=None,
disabled_pass=None,
trace=None):
- """Configure the build behavior by setting config variables.
+ """Configure the build behavior by setting config variables. This function
+ will be deprecated in TVM v0.7. Instead, we should directly use
+ tvm.transform.PassContext.
Parameters
----------
pass_context: PassContext
The pass context for optimizations.
"""
- return tvm.ir.transform.PassContext(opt_level, required_pass,
- disabled_pass, trace)
+ warnings.warn("relay.build_config will be deprecated. Please use \
+ tvm.transform.PassContext directly", DeprecationWarning)
+ return tvm.transform.PassContext(opt_level, required_pass, disabled_pass, trace)
@tvm._ffi.register_object("relay.FunctionPass")
num_layers=18, batch_size=batch_size, image_shape=image_shape)
# compile the model
- with relay.build_config(opt_level=opt_level):
- graph, lib, params = relay.build_module.build(net, target, params=params)
+ with tvm.transform.PassContext(opt_level=opt_level):
+ graph, lib, params = relay.build_module.build(net, target, params=params)
# save the model artifacts
lib.save(deploy_lib)
// Handle heterogeneous compilation.
transform::PassContext pass_ctx = PassContext::Current();
if (targets_.size() > 1) {
- Optional<IntImm> opt_fallback_dev =
- pass_ctx->GetConfig("relay.fallback_device_type",
- IntImm(runtime::DataType::Int(32), static_cast<int>(kDLCPU)));
+ Optional<Integer> opt_fallback_dev =
+ pass_ctx->GetConfig("relay.fallback_device_type", Integer(static_cast<int>(kDLCPU)));
auto fallback_dev = opt_fallback_dev.value();
CHECK_GT(fallback_dev->value, 0U);
relay_module = RunDeviceAnnotationPass(relay_module, fallback_dev->value);
auto mod = IRModule::FromExpr(func);
auto pass_ctx = relay::transform::PassContext::Create();
pass_ctx->opt_level = 3;
- pass_ctx->config.Set("relay.fallback_device_type", IntImm(DataType::Int(32), 1));
+ pass_ctx->config.Set("relay.fallback_device_type", Integer(1));
{
tvm::With<relay::transform::PassContext> ctx_scope(pass_ctx);
tvm::With<tvm::Target> tctx(tvm::Target::Create("llvm"));
dtype_dict = {input_names: input_data.dtype}
mod, params = relay.frontend.from_caffe2(
model.init_net, model.predict_net, shape_dict, dtype_dict)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
m = graph_runtime.create(graph, lib, ctx)
def get_tvm_output(func, x, params, target, ctx,
out_shape=(1, 1000), input_name='image', dtype='float32'):
- with relay.transform.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(func, target, params=params)
m = graph_runtime.create(graph, lib, ctx)
# set inputs
dtype_dict = {input_name: input_data.dtype}
mod, params = relay.frontend.from_coreml(coreml_model, shape_dict)
- with relay.transform.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
from tvm.contrib import graph_runtime
def get_tvm_output(xs, target, ctx, dtype='float32'):
shape_dict = {name: x.shape for (name, x) in zip(keras_model.input_names, xs)}
mod, params = relay.frontend.from_keras(keras_model, shape_dict, layout=layout)
- with relay.transform.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
graph, lib, params = relay.build(mod,
target,
params=params)
shape_dict,
arg_params=args,
aux_params=auxs)
- with relay.build_config(opt_level=3):
+ 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
# specific language governing permissions and limitations
# under the License.
-import tvm
import numpy as np
+import tvm
from tvm import relay
from tvm.contrib import graph_runtime
from tvm.relay.frontend.mxnet_qnn_op_utils import dequantize_mxnet_min_max, \
in_dtype=in_dtype)
mod = relay.Function(relay.analysis.free_vars(dequantized_output), dequantized_output)
mod = tvm.IRModule.from_expr(mod)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm", params=None)
rt_mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
rt_mod.set_input(input_data=in_data)
out_dtype=out_dtype)
mod = relay.Function(relay.analysis.free_vars(quantized_output), quantized_output)
mod = tvm.IRModule.from_expr(mod)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm", params=None)
rt_mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
rt_mod.set_input(input_data=in_data)
mod, params = relay.frontend.from_onnx(graph_def, shape_dict, opset=opset)
- with relay.build_config(opt_level=1):
+ with tvm.transform.PassContext(opt_level=1):
graph, lib, params = relay.build(mod,
target,
params=params)
input_shapes = [(input_name, ishape)]
mod, params = relay.frontend.from_pytorch(script_module, input_shapes)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
# test on only cpu for now, torch cannot run quant models on cuda
# also not to make CI too slow
json, lib, params = relay.build(mod, target="llvm", params=params)
compiled_input = dict(zip(input_names,
[inp.cpu().numpy() for inp in baseline_input]))
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
for target, ctx in ctx_list:
relay_graph, relay_lib, relay_params = relay.build(mod, target=target, params=params)
relay_model = graph_runtime.create(relay_graph, relay_lib, ctx)
# ----------------------------
target = 'llvm'
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
relay_graph, relay_lib, relay_params = relay.build(mod, target=target, params=params)
######################################################################
continue
mod, params = relay.frontend.from_tensorflow(constant_graph,
outputs=['output'])
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod,
target=device,
params=params)
result = ex.evaluate()(*inputs)
return vmobj_to_list(result)
else:
- with relay.build_config(opt_level=opt_level):
+ with tvm.transform.PassContext(opt_level=opt_level):
graph, lib, params = relay.build(mod, target, target_host, params)
ctx = tvm.context(target, 0)
'Model/RNN/RNN/multi_rnn_cell/cell_0/lstm_cell/LSTMBlockCell_c': 'float32',
'Model/RNN/RNN/multi_rnn_cell/cell_0/lstm_cell/LSTMBlockCell_h': 'float32'}
target = 'llvm'
- with relay.build_config(opt_level=0):
+ with tvm.transform.PassContext(opt_level=0):
graph, lib, params = relay.build(mod,
target,
params=params)
shape_dict=shape_dict,
dtype_dict=dtype_dict)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
ctx = tvm.context(target, 0)
mod, params = relay.frontend.from_mxnet(gluon_model, {"data": data_shape})
net = mod['main']
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
qfunc = relay.quantize.prerequisite_optimize(net, params=params)
logging.debug('original')
logging.debug(qfunc.astext(show_meta_data=False))
def eval_acc(model, dataset, batch_fn, target=tvm.target.cuda(), ctx=tvm.gpu(), log_interval=100):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(model, target)
# create runtime module
m = tvm.contrib.graph_runtime.create(graph, lib, ctx)
model="unknown"):
def get_graph_runtime_output(mod, data, params, target, ctx,
dtype='float32', number=2, repeat=20):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
m = graph_runtime.create(graph, lib, ctx)
def get_vm_output(mod, data, params, target, ctx, dtype='float32',
number=2, repeat=20):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
exe = vm.compile(mod, target, params=params)
rly_vm = vm_rt.VirtualMachine(exe)
rly_vm.init(ctx)
z = relay.var("z", shape=(2, 3))
result = relay.Tuple([x, relay.op.concatenate([y, z], axis=0)])
func = relay.Function(relay.analysis.free_vars(result), result)
- with relay.build_config(opt_level=0):
+ with tvm.transform.PassContext(opt_level=0):
graph, lib, params = relay.build(tvm.IRModule.from_expr(func), 'llvm')
z = unit(rnn_dim)
for target, ctx in ctx_list():
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
graph, lib, params = relay.build(tvm.IRModule.from_expr(z), target)
m = graph_runtime.create(graph, lib, ctx)
m.set_input("X", tvm.nd.array(x.astype(dtype)))
X = tvm.nd.array(n * np.random.randn(n).astype(src) - n / 2)
# build
- with relay.build_config(opt_level=1):
+ with tvm.transform.PassContext(opt_level=1):
g_json, mmod, params = relay.build(tvm.IRModule.from_expr(func), tgt)
# test
return lib
def check_vm_result():
- with relay.build_config(opt_level=3, disabled_pass=["AlterOpLayout"]):
+ with tvm.transform.PassContext(opt_level=3,
+ disabled_pass=["AlterOpLayout"]):
exe = relay.vm.compile(mod, target=target)
code, lib = exe.save()
lib = update_lib(lib)
tvm.testing.assert_allclose(out.asnumpy(), result, rtol=tol, atol=tol)
def check_graph_runtime_result():
- with relay.build_config(opt_level=3, disabled_pass=["AlterOpLayout"]):
+ with tvm.transform.PassContext(opt_level=3,
+ disabled_pass=["AlterOpLayout"]):
json, lib, _ = relay.build(mod, target=target)
lib = update_lib(lib)
rt_mod = tvm.contrib.graph_runtime.create(json, lib, ctx)
no_plan_result = ex.evaluate(mod['main'])(*args)
# Compute with memory planning.
- with relay.build_config(opt_level=1, disabled_pass=["MemoryPlan"]):
+ with tvm.transform.PassContext(opt_level=1, disabled_pass=["MemoryPlan"]):
plan_result = ex.evaluate(mod['main'])(*args)
# Compute Python result.
func = relay.Function([x], y)
mod = tvm.IRModule.from_expr(func)
- with relay.build_config(opt_level=3, required_pass=['FastMath']):
+ with tvm.transform.PassContext(opt_level=3, required_pass=['FastMath']):
graph, lib, params = relay.build(mod, target="llvm", params=None)
# Check that the op related to fast math have been convered to function in lib
with open(temp.relpath("temp.log"), "w") as log_file:
log_file.write(test_schedule)
with autotvm.apply_history_best(temp.relpath("temp.log")):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
print('Compiling...')
graph_json, mod, params = tvm.relay.build(mod, target="llvm -device=arm_cpu")
data.astype(out_dtype), kernel.astype(out_dtype), 1, padding,
groups=groups)
- with WinogradFallback(), relay.build_config(opt_level=3):
+ with WinogradFallback(), tvm.transform.PassContext(opt_level=3):
for target, ctx in ctx_list():
if target != 'cuda':
continue
data.astype(out_dtype), kernel.astype(out_dtype), 1, padding,
groups=groups)
- with WinogradFallback(), relay.build_config(opt_level=3):
+ with WinogradFallback(), tvm.transform.PassContext(opt_level=3):
for target, ctx in ctx_list():
if target != 'cuda':
continue
wdata = np.random.rand(*kernel_shape) * 10
parameters = {"weight": tvm.nd.array(wdata.astype(weight_dtype))}
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(func, target, params=parameters)
assembly = lib.get_source("asm")
llvm_version = tvm.target.codegen.llvm_version_major()
for target in targets:
if llvm_version >= 8:
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(func, target, params=parameters)
def get_output(func, golden_inputs):
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
golden_data, golden_weight = golden_inputs
params = {'kernel': golden_weight}
graph, lib, params = relay.build(func, "llvm", params=params)
golden_data = np.full(data_shape, 127).astype('uint8')
golden_weight = np.full(kernel_shape, 127).astype('uint8')
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
params = {'kernel': golden_weight}
graph, lib, params = relay.build(qnn_func, "llvm", params=params)
mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
-1, -1, 1, 1)).reshape(kernel_shape)
golden_weight = golden_weight.astype('uint8')
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
params = {'kernel': golden_weight}
graph, lib, params = relay.build(qnn_func, "llvm", params=params)
mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
golden_weight = np.array((129, 131, 133, 135)).reshape(kernel_shape)
golden_weight = golden_weight.astype('uint8')
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
params = {'kernel': golden_weight}
graph, lib, params = relay.build(qnn_func, "llvm", params=params)
mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
func = relay.add(func, bias)
func = relay.Function(relay.analysis.free_vars(func), func)
mod = tvm.IRModule.from_expr(func)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm -mcpu=skylake-avx512")
def test_depthwise_depth_multiplier():
mod = relay.Function(relay.analysis.free_vars(mod), mod)
mod = tvm.IRModule.from_expr(mod)
mod = relay.qnn.transform.CanonicalizeOps()(mod)
- with relay.build_config(opt_level=2):
+ with tvm.transform.PassContext(opt_level=2):
graph, lib, params = relay.build(mod, "llvm", params=None)
mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
mod.set_input(quantized_data_name, test_configuration[quantized_data_name])
input_zero_point=input_zero_point)
mod = relay.Function(relay.analysis.free_vars(quantized_output), quantized_output)
mod = tvm.IRModule.from_expr(mod)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm", params=None)
rt_mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
rt_mod.set_input(input_data=in_data)
out_dtype=out_dtype)
mod = relay.Function(relay.analysis.free_vars(quantized_output), quantized_output)
mod = tvm.IRModule.from_expr(mod)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm", params=None)
rt_mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
rt_mod.set_input(input_data=in_data)
roundings = ["UPWARD", "TONEAREST"]
def verify(mod, goldens):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, "llvm", params=None)
golden_data, golden_output = goldens
rt_mod = graph_runtime.create(graph, lib, ctx=tvm.cpu(0))
return lib
def check_vm_result():
- with relay.build_config(opt_level=3, disabled_pass=["AlterOpLayout"]):
+ with tvm.transform.PassContext(opt_level=3, disabled_pass=["AlterOpLayout"]):
exe = relay.vm.compile(mod, target=target, params=params)
code, lib = exe.save()
lib = update_lib(lib)
tvm.testing.assert_allclose(out.asnumpy(), result, rtol=tol, atol=tol)
def check_graph_runtime_result():
- with relay.build_config(opt_level=3, disabled_pass=["AlterOpLayout"]):
+ with tvm.transform.PassContext(opt_level=3, disabled_pass=["AlterOpLayout"]):
json, lib, param = relay.build(mod, target=target, params=params)
lib = update_lib(lib)
rt_mod = tvm.contrib.graph_runtime.create(json, lib, ctx)
assert "fast_exp" in fast_mod.astext()
# Check that FastMath option works for relay.build.
- with relay.build_config(opt_level=3, required_pass=['FastMath']):
+ with tvm.transform.PassContext(opt_level=3, required_pass=['FastMath']):
fast_mod = relay.optimize(mod, target='llvm', params=None)
assert "fast_exp" in fast_mod[0].astext()
assert "fast_tanh" in fast_mod.astext()
# Check that FastMath option works for relay.build.
- with relay.build_config(opt_level=3, required_pass=['FastMath']):
+ with tvm.transform.PassContext(opt_level=3, required_pass=['FastMath']):
fast_mod = relay.optimize(mod, target='llvm', params=None)
assert "fast_tanh" in fast_mod[0].astext()
mod, params = create_workload(bn_output[0], initializer)
mod["main"] = bind_params_by_name(mod["main"], params)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
mod = remove_bn_pass(mod)
expect = run_infer_type(expected())
def test_only_module_pass():
passes = [module_pass]
sequential = tvm.transform.Sequential(opt_level=1, passes=passes)
- with relay.build_config(required_pass=["mod_transform"]):
+ with tvm.transform.PassContext(required_pass=["mod_transform"]):
ret_mod = sequential(mod)
# Check the subtract function.
sub_var, new_sub = extract_var_func(ret_mod, v_sub.name_hint)
# Check the subtract function.
passes = [function_pass]
sequential = tvm.transform.Sequential(opt_level=1, passes=passes)
- with relay.build_config(required_pass=["func_transform"]):
+ with tvm.transform.PassContext(required_pass=["func_transform"]):
ret_mod = sequential(mod)
_, new_sub = extract_var_func(ret_mod, v_sub.name_hint)
check_func(new_sub, get_ref_sub())
passes = [module_pass, function_pass]
sequential = tvm.transform.Sequential(opt_level=1, passes=passes)
required = ["mod_transform", "func_transform"]
- with relay.build_config(required_pass=required):
+ with tvm.transform.PassContext(required_pass=required):
ret_mod = sequential(mod)
# Check the abs function is added.
])
mod = tvm.IRModule({"main": before()})
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
with tvm.target.create("llvm"):
mod = seq(mod)
])
mod = tvm.IRModule({"main": func})
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
mod = seq(mod)
out = capfd.readouterr().err
assert __TRACE_COUNTER__ == 0
mod = tvm.IRModule({"main": func})
- with relay.build_config(opt_level=3, trace=_tracer):
+ with tvm.transform.PassContext(opt_level=3, trace=_tracer):
mod = seq(mod)
assert __TRACE_COUNTER__ == 3
def check_vm_result():
compile_engine.get().clear()
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
exe = relay.vm.compile(mod, target=target, params=params)
code, lib = exe.save()
lib = update_lib(lib)
def check_graph_runtime_result():
compile_engine.get().clear()
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
json, lib, param = relay.build(mod, target=target, params=params)
lib = update_lib(lib)
rt_mod = tvm.contrib.graph_runtime.create(json, lib, ctx)
transform.AlterOpLayout(),
])
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
mod = opt_pass(mod)
return mod
transform.Inline(),
])
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
mod = opt_pass(mod)
return mod
transform.PartitionGraph()
])
- with relay.build_config(opt_level=3, disabled_pass=["AlterOpLayout"]):
+ with tvm.transform.PassContext(opt_level=3,
+ disabled_pass=["AlterOpLayout"]):
return composite_partition(mod)
def test_detect_pattern(pattern_table, include_bn, include_sigmoid,
from tvm.relay.data_dep_optimization import simplify_fc_transpose
def run_func(func, params, x):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, new_params = relay.build(func, "llvm", params=params)
from tvm.contrib import graph_runtime
return s
def run_func(func, params, x):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, new_params = relay.build(func, "llvm", params=params)
from tvm.contrib import graph_runtime
resnet18_mod, resnet18_params = relay.testing.resnet.get_workload(num_layers=18)
resnet50_mod, resnet50_params = relay.testing.resnet.get_workload(num_layers=50)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
_, resnet18_gpu_lib, _ = relay.build_module.build(resnet18_mod, "cuda", params=resnet18_params)
_, resnet50_cpu_lib, _ = relay.build_module.build(resnet50_mod, "llvm", params=resnet50_params)
return
resnet18_mod, resnet18_params = relay.testing.resnet.get_workload(num_layers=18)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
_, resnet18_cpu_lib, _ = relay.build_module.build(resnet18_mod, "llvm", params=resnet18_params)
A = te.placeholder((1024,), name='A')
return
resnet18_mod, resnet18_params = relay.testing.resnet.get_workload(num_layers=18)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
_, resnet18_cpu_lib, _ = relay.build_module.build(resnet18_mod, "llvm", params=resnet18_params)
A = te.placeholder((1024,), name='A')
def verify(data):
mod, params = relay.testing.resnet.get_workload(num_layers=18)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, graph_params = relay.build_module.build(mod, "llvm", params=params)
ctx = tvm.cpu()
module = graph_runtime.create(graph, lib, ctx)
return out
resnet18_mod, resnet18_params = relay.testing.resnet.get_workload(num_layers=18)
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, resnet18_gpu_lib, graph_params = relay.build_module.build(resnet18_mod, "cuda", params=resnet18_params)
from tvm.contrib import util
# compile kernels with history best records
with autotvm.apply_history_best(log_file):
print("Compile...")
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(
mod, target=target, params=params)
# compile kernels with history best records
with autotvm.apply_history_best(log_file):
print("Compile...")
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(
mod, target=target, params=params)
# compile kernels with history best records
with autotvm.apply_history_best(log_file):
print("Compile...")
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(
mod, target=target, params=params, target_host=target_host)
# export library
# compile kernels with graph-level best records
with autotvm.apply_graph_best(graph_opt_sch_file):
print("Compile...")
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(
mod, target=target, params=params)
# however, provides a configuration interface
# for users to customize the optimization level that they want to execute.
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
mod2 = seq(mod)
print(mod2)
# EliminateCommonSubexpr as following. The printed module will again show two
# identical addition operations.
-with relay.build_config(opt_level=3, disabled_pass=["EliminateCommonSubexpr"]):
+with tvm.transform.PassContext(opt_level=3, disabled_pass=["EliminateCommonSubexpr"]):
mod3 = seq(mod)
print(mod3)
# provides a means to make pass target-aware. For example, the layout
# alteration pass falls in such category.
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
mod4 = seq(mod)
print(mod4)
seq1 = tvm.transform.Sequential([relay.transform.AlterOpLayout()])
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
with tvm.target.create("llvm"):
mod5 = seq1(mod)
print(mod5)
relay.transform.EliminateCommonSubexpr(),
relay.transform.FuseOps(),
tvm.transform.PrintIR()])
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
mod = seq(mod)
print("done")
mod = tvm.IRModule()
mod["main"] = func
# Build with Relay
-with relay.build_config(opt_level=0): # Currently only support opt_level=0
+with tvm.transform.PassContext(opt_level=0): # Currently only support opt_level=0
graph, lib, params = relay.build(mod, target, params=params)
# Generate graph runtime
shape_dict = {input_name: x.shape}
mod, params = relay.frontend.from_keras(keras_mobilenet_v2, shape_dict)
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target=target,
target_host=target_host, params=params)
# The above line is a simple form of
# target = tvm.target.create('llvm -device=arm_cpu -model=bcm2837 -target=armv7l-linux-gnueabihf -mattr=+neon')
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(func, target, params=params)
# After `relay.build`, you will get three return values: graph,
def run_tvm_model(mod, params, input_name, inp, target="llvm"):
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
json, lib, params = relay.build(mod, target=target, params=params)
runtime = tvm.contrib.graph_runtime.create(json, lib, tvm.context(target, 0))
# Lets now the compile the Relay module. We use the "llvm" target here. Please replace it with the
# target platform that you are interested in.
target = 'llvm'
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build_module.build(mod, target=target,
params=params)
def build(target):
mod, params = relay.frontend.from_mxnet(block, {"data": dshape})
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
return graph, lib, params
dtype_dict = {input_name: data.dtype}
# parse Caffe2 model and convert into Relay computation graph
-from tvm import relay
+from tvm import relay, transform
mod, params = relay.frontend.from_caffe2(resnet50.init_net, resnet50.predict_net, shape_dict, dtype_dict)
# compile the model
# target x86 CPU
target = 'llvm'
-with relay.build_config(opt_level=3):
+with transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
######################################################################
# Parse CoreML model and convert into Relay computation graph
mod, params = relay.frontend.from_coreml(mlmodel, shape_dict)
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod,
target,
params=params)
data = np.empty([batch_size, net.c, net.h, net.w], dtype)
shape = {'data': data.shape}
print("Compiling the model...")
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod,
target=target,
target_host=target_host,
# compile the model
target = 'cuda'
ctx = tvm.gpu(0)
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
executor = relay.build_module.create_executor('graph', mod, ctx, target)
######################################################################
######################################################################
# now compile the graph
target = 'cuda'
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(func, target, params=params)
######################################################################
shape_dict = {input_name: x.shape}
mod, params = relay.frontend.from_onnx(onnx_model, shape_dict)
-with relay.build_config(opt_level=1):
+with tvm.transform.PassContext(opt_level=1):
intrp = relay.build_module.create_executor('graph', mod, tvm.cpu(0), target)
######################################################################
target = 'llvm'
target_host = 'llvm'
ctx = tvm.cpu(0)
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod,
target=target,
target_host=target_host,
# params: final params after compilation.
# lib: target library which can be deployed on target with TVM runtime.
-with relay.build_config(opt_level=3):
+with tvm.transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod,
target=target,
target_host=target_host,
input_dtype = "float32"
# Parse TFLite model and convert it to a Relay module
-from tvm import relay
+from tvm import relay, transform
mod, params = relay.frontend.from_tflite(tflite_model,
shape_dict={input_tensor: input_shape},
dtype_dict={input_tensor: input_dtype})
# Build the module against to x86 CPU
target = "llvm"
-with relay.build_config(opt_level=3):
+with transform.PassContext(opt_level=3):
graph, lib, params = relay.build(mod, target, params=params)
######################################################################
opt_level = 3
target = tvm.target.cuda()
-with relay.build_config(opt_level=opt_level):
+with tvm.transform.PassContext(opt_level=opt_level):
graph, lib, params = relay.build(mod, target, params=params)
#####################################################################
# Perform quantization in Relay
# Note: We set opt_level to 3 in order to fold batch norm
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
with relay.quantize.qconfig(global_scale=8.0,
skip_conv_layers=[0]):
relay_prog = relay.quantize.quantize(mod["main"], params=params)
# Compile network
print("Compiling network with best tuning parameters...")
if target.device_name != "vta":
- with relay.build_config(opt_level=3, disabled_pass={"AlterOpLayout"}):
+ with tvm.transform.PassContext(opt_level=3, disabled_pass={"AlterOpLayout"}):
graph, lib, params = relay.build(
relay_prog, target=target,
params=params, target_host=env.target_host)
# Perform quantization in Relay
# Note: We set opt_level to 3 in order to fold batch norm
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
with relay.quantize.qconfig(global_scale=8.0, skip_conv_layers=[0]):
mod = relay.quantize.quantize(mod, params=params)
if target.device_name == "vta":
# Perform quantization in Relay
# Note: We set opt_level to 3 in order to fold batch norm
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
with relay.quantize.qconfig(global_scale=8.0,
skip_conv_layers=[0]):
mod = relay.quantize.quantize(mod, params=params)
if target.device_name == "vta":
# Perform quantization in Relay
# Note: We set opt_level to 3 in order to fold batch norm
- with relay.build_config(opt_level=3):
+ with tvm.transform.PassContext(opt_level=3):
with relay.quantize.qconfig(global_scale=33.0,
skip_conv_layers=[0],
store_lowbit_output=True,
projects / platform / upstream / tvm.git / commitdiff