import gluon_zoo as gz
import mxnet as mx
from mxnet import ndarray as nd
from mxnet import gluon
import sym_pass as spass
import dataset as ds
import sym_calib as calib
import sim_quant_helper as sim
import utils
import mrt as _mrt
gz.save_model("alexnet")
def load_fname(version, suffix=None, with_ext=False):
suffix = "." + suffix if suffix is not None else ""
prefix = "./data/alexnet%s%s" % (version, suffix)
return utils.extend_fname(prefix, with_ext=with_ext)
batch_size = 700
input_size = 224
inputs_ext = {'data': {'shape': (batch_size, 3, input_size, input_size)}}
inputs = [mx.sym.var(n) for n in inputs_ext]
# ctx = mx.gpu(2)
ctx = [mx.gpu(int(i)) for i in "1,2,3,4,5,6,7".split(',') if i.strip()]
utils.log_init()
data_iter = ds.load_imagenet_rec(batch_size, input_size)
def validate_model(sym_path, prm_path, ctx, num_channel=3,
input_size=224, batch_size=16, iter_num=10,
ds_name='imagenet', from_scratch=0, lambd=None,
dump_model=False, input_shape=None):
from gluon_zoo import save_model
flag = [False]*from_scratch + [True]*(2-from_scratch)
model_name, _ = path.splitext(path.basename(sym_path))
model_dir = path.dirname(sym_path)
input_shape = input_shape if input_shape else \
(batch_size, num_channel, input_size, input_size)
logger = logging.getLogger("log.validate.%s"%model_name)
if not path.exists(sym_path) or not path.exists(prm_path):
save_model(model_name)
model = Model.load(sym_path, prm_path)
model.prepare(input_shape)
# model = init(model, input_shape)
print(tpass.collect_op_names(model.symbol, model.params))
data_iter_func = ds.data_iter(ds_name, batch_size, input_size=input_size)
data, _ = data_iter_func()
# prepare
mrt = model.get_mrt()
# mrt = MRT(model)
# calibrate
mrt.set_data(data)
prefix = path.join(model_dir, model_name+'.mrt.dict')
_, _, dump_ext = utils.extend_fname(prefix, True)
if flag[0]:
th_dict = mrt.calibrate(lambd=lambd)
sim.save_ext(dump_ext, th_dict)
else:
(th_dict,) = sim.load_ext(dump_ext)
mrt.set_th_dict(th_dict)
mrt.set_input_prec(8)
mrt.set_output_prec(8)
if flag[1]:
mrt.quantize()
mrt.save(model_name+".mrt.quantize", datadir=model_dir)
else:
mrt = MRT.load(model_name+".mrt.quantize", datadir=model_dir)
# dump model
if dump_model:
datadir = "/data/ryt"
model_name = model_name + "_tfm"
dump_shape = (1, num_channel, input_size, input_size)
mrt.current_model.to_cvm(
model_name, datadir=datadir, input_shape=input_shape)
data = data[0].reshape(dump_shape)
data = sim.load_real_data(
data.astype("float64"), 'data', mrt.get_inputs_ext())
np.save(datadir+"/"+model_name+"/data.npy", data.astype('int8').asnumpy())
sys.exit(0)
# validate
org_model = load_model(Model.load(sym_path, prm_path), ctx)
cvm_quantize = load_model(
mrt.current_model, ctx,
inputs_qext=mrt.get_inputs_ext())
utils.multi_validate(org_model, data_iter_func, cvm_quantize,
iter_num=iter_num,
logger=logging.getLogger('mrt.validate'))
logger.info("test %s finished.", model_name)
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", max_num=100)
# nnvm_sym, nnvm_params = spass.mxnet_to_nnvm(sym, params, inputs_ext)
# spass.cvm_build(nnvm_sym, nnvm_params, inputs_ext, *load_fname("nnvm"))
if __name__ == '__main__':
utils.log_init()
zoo.save_model('faster_rcnn_resnet50_v1b_voc')
# test_mrt_quant(1, 100)
# test_sym_nnvm(16, 0)
import gluon_zoo as gz
import mxnet as mx
from mxnet import ndarray as nd
from mxnet import gluon
import sym_pass as spass
import dataset as ds
import sym_calib as calib
import sim_quant_helper as sim
import utils
import mrt as _mrt
import logging
import os
version = "20_v1"
gz.save_model("cifar_resnet" + version)
#exit(0)
def load_fname(version, suffix=None, with_ext=False):
suffix = "." + suffix if suffix is not None else ""
prefix = "./data/cifar_resnet%s%s" % (version, suffix)
return utils.extend_fname(prefix, with_ext=with_ext)
batch_size = 16
input_size = 32
inputs_ext = {'data': {'shape': (batch_size, 3, input_size, input_size)}}
inputs = [mx.sym.var(n) for n in inputs_ext]
calib_ctx = mx.gpu(2)
ctx = [mx.gpu(int(i)) for i in "1,2,3,4,5".split(',') if i.strip()]
net3 = 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)
res = [net3.forward(d) for d in data]
res = nd.concatenate(res)
qacc_top1.update(label, res)
_, top1 = qacc_top1.get()
qacc_top5.update(label, res)
_, top5 = qacc_top5.get()
return "top1={:6.2%} top5={:6.2%}".format(top1, top5)
utils.multi_validate(vgg, data_iter_func,
cvm_quantize,
iter_num=iter_num, logger=logger)
if __name__ == "__main__":
utils.log_init()
zoo.save_model('vgg19')
test_sym_pass(batch_size=16, iter_num=100)
# test_sym_pass(batch_size=160, iter_num=100000)
# test_sym_nnvm(batch_size=1, iter_num=0)