def test_sym_nnvm(batch_size, iter_num):
logger = logging.getLogger("log.test.nnvm")
logger.info("=== Log Test NNVM ===")
sym_file, param_file, ext_file = load_fname("mrt.all.quantize", True)
sym, params = mx.sym.load(sym_file), nd.load(param_file)
inputs_ext, _ = sim.load_ext(ext_file)
val_data = dataset.load_voc(1, 512)
val_data_iter = iter(val_data)
data, _ = next(val_data_iter)
if False:
data = sim.load_real_data(data, 'data', inputs_ext)
inputs_ext['data']['data'] = data
spass.sym_dump_ops(sym,
params,
inputs_ext,
datadir="/data/wlt",
ctx=mx.gpu(1),
cleanDir=True,
ops=[
"broadcast_div0",
])
else:
_mrt.std_dump(sym, params, inputs_ext, data, "ssd_ryt", max_num=100)
def test_sym_nnvm(batch_size=10):
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
data_iter = utils.load_dataset(batch_size)
data = data_iter.next().data[0]
_mrt.std_dump(sym, params, inputs_ext, data, "resnet" + version)
def test_nnvm_pass(iter_num=10):
logger = logging.getLogger("log.test.nnvm")
logger.info("=== Log Test NNVM ===")
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext,) = sim.load_ext(dump_ext)
data_iter = iter(val_loader)
data, _ = next(data_iter)
_mrt.std_dump(sym, params, inputs_ext, data, "cvm_mnist")
def test_sym_nnvm(batch_size=10, iter_num=10):
logger = logging.getLogger("log.test.nnvm")
logger.info("=== Log Test NNVM ===")
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
data_iter = ds.load_imagenet_rec(batch_size, 224)
data = data_iter.next().data[0]
_mrt.std_dump(sym, params, inputs_ext, data, "shufflenet", max_num=100)
def test_sym_nnvm():
logger = logging.getLogger("log.test.nnvm")
logger.info("=== Log Test NNVM ===")
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext,) = sim.load_ext(dump_ext)
data_iter = ds.load_imagenet_rec(1)
data = data_iter.next().data[0]
_mrt.std_dump(sym, params, inputs_ext, data, "mobilenet"+version)
def test_sym_nnvm(batch_size=10, iter_num=10):
logger = logging.getLogger("log.test.nnvm")
logger.info("=== Log Test NNVM ===")
version = "v3"
dump_sym, dump_params, dump_ext = load_fname(version, "mrt", True)
'''
byr---------
./data/tf_inceptionv3.mrt.json
./data/tf_inceptionv3.mrt.params
./data/tf_inceptionv3.mrt.ext
byr--------
'''
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
data_iter = ds.load_imagenet_rec(batch_size, 299)
data = data_iter.next().data[0]
_mrt.std_dump(sym, params, inputs_ext, data, "inception_v3")
# sym, params = mx.sym.load(sym_file), nd.load(param_file)
# sym, params = spass.sym_quant_prepare(sym, params, inputs_ext)
# qsym, qparams, precs, _ = calib.sym_simulate(sym, params, inputs_ext, data, ctx)
# qsym, qparams = calib.sym_realize(qsym, qparams, inputs_ext, precs, "cvm")
# dump_sym, dump_params, dump_ext = load_fname("", "sym.quantize", True)
# sim.save_ext(dump_ext, inputs_ext)
# nd.save(dump_params, qparams)
# open(dump_sym, "w").write(qsym.tojson())
dump_sym, dump_params, dump_ext = load_fname("", "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
if True:
_mrt.std_dump(sym, params, inputs_ext, data, "alexnet", is_mxnet=True)
exit()
inputs = [mx.sym.var(n) for n in inputs_ext]
net2 = utils.load_model(dump_sym, dump_params, inputs, ctx=ctx)
qacc_top1 = mx.metric.Accuracy()
qacc_top5 = mx.metric.TopKAccuracy(5)
qacc_top1.reset()
qacc_top5.reset()
def cvm_quantize(data, label):
data = sim.load_real_data(data, 'data', inputs_ext)
data = gluon.utils.split_and_load(data,
ctx_list=ctx,
batch_axis=0,
even_split=False)
data = sim.load_real_data(data, 'data', inputs_ext)
res = net2(data.as_in_context(ctx))
return res
quant_sym, quant_params, quant_ext = load_fname("sym.quantize", with_ext=True)
open(quant_sym, "w").write(qsym.tojson())
if False:
inputs_ext['data']['shape'] = (38, 1)
data = data[:, 0].reshape(38, 1)
_mrt.std_dump(qsym,
qparams,
inputs_ext,
data,
"trec",
batch=True,
data_dtype="int32",
max_num=1000,
dump_ops=["sentimentnet0_embedding0_fwd"])
opg.dump_file("take", [
"/data/std_out/trec/sentimentnet0_embedding0_fwd_0.mrt.dump.in.npy",
"/data/std_out/trec/sentimentnet0_embedding0_fwd_1.mrt.dump.in.npy"
], ["/data/std_out/trec/sentimentnet0_embedding0_fwd_0.mrt.dump.out.npy"],
"/data/std_out/trec/sentimentnet0_embedding0_fwd.attr")
exit()
if False:
while True:
data, _ = next(data_iter)
data = sim.load_real_data(data, 'data', inputs_ext)
data_iter = ds.load_imagenet_rec(batch_size, input_size)
def data_iter_func():
data = data_iter.next()
return data.data[0], data.label[0]
data, _ = data_iter_func()
if False:
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
_mrt.std_dump(sym, params, inputs_ext, data, "squeezenet1.0")
exit()
sym_file, param_file = load_fname(version)
net1 = utils.load_model(sym_file, param_file, inputs, ctx=ctx)
acc_top1 = mx.metric.Accuracy()
acc_top5 = mx.metric.TopKAccuracy(5)
acc_top1.reset()
acc_top5.reset()
def squeezenet(data, label):
data = gluon.utils.split_and_load(data,
ctx_list=ctx,
batch_axis=0,
even_split=False)
def quickdraw(data, label):
res = net1.forward(data.as_in_context(ctx))
acc.update(label, res)
return "accuracy={:6.2%}".format(acc.get()[1])
if True:
sym, params = mx.sym.load(sym_file), nd.load(prm_file)
sym, params = spass.sym_quant_prepare(sym, params, inputs_ext)
mrt = _mrt.MRT(sym, params, inputs_ext)
mrt.set_data('data', data)
mrt.calibrate(ctx=ctx)
mrt.set_output_prec(8)
qsym, qparams, inputs_ext = mrt.quantize()
net2 = mx.gluon.nn.SymbolBlock(qsym, inputs)
utils.load_parameters(net2, qparams, ctx=ctx)
qacc = mx.metric.Accuracy()
def cvm_quantize(data, label):
data = sim.load_real_data(data, 'data', inputs_ext)
res = net2.forward(data.as_in_context(ctx))
qacc.update(label, res)
return "accuracy={:6.2%}".format(qacc.get()[1])
if False:
_mrt.std_dump(qsym, qparams, inputs_ext, data, "wlt_animal10")
exit()
utils.multi_validate(quickdraw, data_iter_func,
cvm_quantize,
iter_num=100000)
qsym, qparams, precs, _ = calib.sym_simulate(sym, params, inputs_ext,
th_dict)
qsym, qparams = calib.sym_realize(qsym, qparams, inputs_ext, precs,
"cvm")
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sim.save_ext(dump_ext, inputs_ext)
nd.save(dump_params, qparams)
open(dump_sym, "w").write(qsym.tojson())
dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True)
sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
(inputs_ext, ) = sim.load_ext(dump_ext)
if False:
# data = data[0, :].reshape((1, 1, input_size, input_size))
_mrt.std_dump(sym, params, inputs_ext, data, "animal_10", batch=False)
# dump_ops=["cifarresnetv215_stage1_bn_conv2_fwd"])
# opg.dump_file("conv2d",
# ["cifarresnetv215_stage1_bn_conv2_fwd_0.mrt.dump.in.npy",
# "cifarresnetv215_stage1_bn_conv2_fwd_1.mrt.dump.in.npy",
# "cifarresnetv215_stage1_bn_conv2_fwd_2.mrt.dump.in.npy"],
# ["cifarresnetv215_stage1_bn_conv2_fwd_0.mrt.dump.out.npy"],
# "cifarresnetv215_stage1_bn_conv2_fwd.attr",
# root="/data/std_out/qd10_resnet20_v2")
exit()
inputs = [mx.sym.var(n) for n in inputs_ext]
net2 = utils.load_model(dump_sym, dump_params, inputs, ctx=ctx)
qacc_top1 = mx.metric.Accuracy()
qacc_top5 = mx.metric.TopKAccuracy(5)
qacc_top1.reset()
