def load_parameters(uuid_map=None, parameters_file=None, variable_constants_file=None, mxnet_constants_file=None, context=None, dtype=None, current_params=None): """ Loads back a sest of InferenceParameters from files. :param parameters_file: These are the parameters of the previous inference algorithm. These are in a {uuid: mx.nd.array} mapping. :type mxnet_constants_file: file saved down with mx.nd.save(), so a {uuid: mx.nd.array} mapping saved in a binary format. :param mxnet_constants_file: These are the constants in mxnet format from the previous inference algorithm. These are in a {uuid: mx.nd.array} mapping. :type mxnet_constants_file: file saved down with mx.nd.save(), so a {uuid: mx.nd.array} mapping saved in a binary format. :param variable_constants_file: These are the constants in primitive format from the previous inference algorithm. :type variable_constants_file: json dict of {uuid: constant_primitive} """ def with_uuid_map(item, uuid_map): if uuid_map is not None: return uuid_map[item] else: return item ip = InferenceParameters(context=context, dtype=dtype) if parameters_file is not None: old_params = ndarray.load(parameters_file) mapped_params = { with_uuid_map(k, uuid_map): v for k, v in old_params.items() } new_paramdict = ParameterDict() if current_params is not None: new_paramdict.update(current_params) # Do this because we need to map the uuids to the new Model # before loading them into the ParamDict for name, mapped_param in mapped_params.items(): new_paramdict[name]._load_init(mapped_param, ip.mxnet_context) ip._params = new_paramdict new_mxnet_constants = {} new_variable_constants = {} if variable_constants_file is not None: import json with open(variable_constants_file) as f: old_constants = json.load(f) new_variable_constants = { with_uuid_map(k, uuid_map): v for k, v in old_constants.items() } if mxnet_constants_file is not None: new_mxnet_constants = { with_uuid_map(k, uuid_map): v for k, v in ndarray.load(mxnet_constants_file).items() } ip._constants = {} ip._constants.update(new_variable_constants) ip._constants.update(new_mxnet_constants) return ip
def get_conv_names(modelname): conv_name_dct_old = {} weight_thresh = {} myfile = path.expanduser('~/tvm-cvm/cvm/models/' + modelname + '_mid.ini') for k, v in [v.split(':') for v in load_file(myfile)]: wname = k.strip() thresh = float(v.replace(',', '').strip()) weight_thresh[wname] = thresh myfile = path.expanduser('~/tvm-cvm/cvm/models/' + modelname + '_normal.ini') weight_normal = [v.strip() for v in load_file(myfile)] sym_file = path.expanduser('~/tvm-cvm/data/' + modelname + '.prepare.json') params_file = path.expanduser('~/tvm-cvm/data/' + modelname + '.prepare.params') sym = mx.sym.load(sym_file) params = nd.load(params_file) weight_2_conv = [] for sym in sutils.topo_sort(sym, params): if sym.attr('op_name') == 'Convolution': name = sym.attr('name') wname = sutils.sym_iter(sym.get_children())[1].attr('name') if wname in weight_thresh or wname in weight_normal: continue weight_2_conv.append((wname, name)) return weight_2_conv
def resnet18_v1b_89(pretrained=False, root='~/.mxnet/models', ctx=cpu(0), **kwargs): """Constructs a ResNetV1b-18_2.6x model. Uses resnet18_v1b construction from resnetv1b.py Parameters ---------- pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. root : str, default '~/.mxnet/models' Location for keeping the model parameters. ctx : Context, default CPU The context in which to load the pretrained weights. """ model = ResNetV1b(BasicBlockV1b, [2, 2, 2, 2], name_prefix='resnetv1b_', **kwargs) dirname = os.path.dirname(__file__) json_filename = os.path.join(dirname, 'resnet%d_v%db_%.1fx' % (18, 1, 2.6) + ".json") with open(json_filename, "r") as jsonFile: params_shapes = json.load(jsonFile) if pretrained: from ..model_store import get_model_file params_file = get_model_file('resnet%d_v%db_%.1fx' % (18, 1, 2.6), tag=pretrained, root=root) prune_gluon_block(model, model.name, params_shapes, params=ndarray.load(params_file), pretrained=True, ctx=ctx) else: prune_gluon_block(model, model.name, params_shapes, params=None, pretrained=False, ctx=ctx) if pretrained: from ...data import ImageNet1kAttr attrib = ImageNet1kAttr() model.synset = attrib.synset model.classes = attrib.classes model.classes_long = attrib.classes_long return model
def load_data_3(modelname, input_size=224, batch_size=1, layout='NHWC', quantized=False): if quantized: data = nd.load(path.expanduser('~/data/' + modelname + '_qdata'))[0].asnumpy() else: data = nd.load(path.expanduser('~/data/' + modelname + '_data'))[0].asnumpy() label = nd.load(path.expanduser('~/data/' + modelname + '_label'))[0].asnumpy() if layout == 'NHWC': data = np.transpose(data, axes=[0, 2, 3, 1]) return data, label
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 load_vgg_encoder_params(self): """load from vggbn16 params,initialize the vgg conv1 for alpha zero""" vgg_file = get_model_file('vgg%d%s' % (16, '_bn')) loaded = ndarray.load(vgg_file) params = self._collect_params_with_prefix() for name in loaded: if name in params: params[name]._load_init(loaded[name])
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("_darknet53_voc", "mrt.all.quantize", True) sym, params = mx.sym.load(sym_file), nd.load(param_file) inputs_ext, _ = sim.load_ext(ext_file) nnvm_sym, nnvm_params = spass.mxnet_to_nnvm(sym, params, inputs_ext) spass.cvm_build(nnvm_sym, nnvm_params, inputs_ext, *load_fname("_darknet53_voc", "nnvm"))
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("_darknet53_voc", "all.quantize", True) dump_sym, dump_params = load_fname("_darknet53_voc", "all.nnvm.compile") sym, params = mx.sym.load(sym_file), nd.load(param_file) inputs_ext, _ = sim.load_ext(ext_file) spass.mxnet_to_nnvm(sym, params, inputs_ext, dump_sym, dump_params)
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 pull(url, is_lambda=True): fname = url.split('/')[-1] fname = fname.split('.')[0] if is_lambda: fpath = '/tmp/%s' % fname else: fpath = './%s' % fname s3 = boto3.resource('s3') s3.meta.client.download_file('ps-lambda-mxnet', fname, fpath) return nd.load(fpath)
def load_params(prefix, epoch): save_dict = nd.load('%s-%04d.params' % (prefix, epoch)) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params
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 load_params(prefix, epoch): save_dict = nd.load('%s-%04d.params' % (prefix, epoch)) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params
def data_process(quantize_flag, input_shape, gpu_flag, num_test): if quantize_flag: symbol = mx.sym.load('/home/test/tvm-cvm/data/ssd_512_mobilenet1.0_coco.all.quantize.json') params = nd.load('/home/test/tvm-cvm/data/ssd_512_mobilenet1.0_coco.all.quantize.params') pfx = 'quant_' else: symbol = mx.sym.load('/home/test/tvm-cvm/data/ssd_512_mobilenet1.0_coco.json') params = nd.load('/home/test/tvm-cvm/data/ssd_512_mobilenet1.0_coco.params') pfx = 'org_' if gpu_flag: ctx = mx.gpu(3) pfx += 'gpu_' else: ctx = mx.cpu() pfx += 'cpu_' params = convert_params_dtype(params, dest_dtype="float32") utils.log_init() logger = logging.getLogger('main') stimes = {} for iter_num in range(num_test): for opn, dct in get_mxnet_outs(symbol, params, input_shape, ctx, gpu_flag, logger, iter_num).items(): if opn not in stimes: stimes[opn] = {'sample_total': []} stimes[opn]['sample_total'].append(dct['total']) for opn, dct in stimes.items(): stimes[opn]['mean_total'] = sum(dct['sample_total'][1:]) / len(dct['sample_total'][1:]) arr = sorted([(stimes[opn]['mean_total'], opn) for opn in stimes], reverse=True) total = sum([dct['mean_total'] for opn, dct in stimes.items()]) s = 'total forward time: %s second\n'%total s += '\n' for _, opn in arr: dct = stimes[opn] # s += 'op_name: %s\nmin: %s second\nmax: %s second\nmean: %s second\nstd: %s second\ntotal: %s second\n'%\ # (opn, dct['max'], dct['min'], dct['mean'], dct['std'], dct['total']) s += 'op: %s\ntotal: %s second\n'%(opn, dct['mean_total']) s += '---------------------------\n' s += '---------------------------\n' s += '\n' filename = '/home/test/'+pfx+'test.txt' with open(filename, 'w') as f: f.write(s)
def resnet101_v1d_73(pretrained=False, root='~/.mxnet/models', ctx=cpu(0), **kwargs): """Constructs a ResNetV1d-101_2.2x model. Uses resnet101_v1d construction from resnetv1b.py Parameters ---------- pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. root : str, default '~/.mxnet/models' Location for keeping the model parameters. ctx : Context, default CPU The context in which to load the pretrained weights. """ model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], deep_stem=True, avg_down=True, name_prefix='resnetv1d_', **kwargs) dirname = os.path.dirname(__file__) json_filename = os.path.join( dirname, 'resnet%d_v%dd_%.1fx' % (101, 1, 2.2) + ".json") with open(json_filename, "r") as jsonFile: params_shapes = json.load(jsonFile) if pretrained: from ..model_store import get_model_file params_file = get_model_file('resnet%d_v%dd_%.1fx' % (101, 1, 2.2), tag=pretrained, root=root) prune_gluon_block(model, model.name, params_shapes, params=ndarray.load(params_file), pretrained=True, ctx=ctx) else: prune_gluon_block(model, model.name, params_shapes, params=None, pretrained=False, ctx=ctx) if pretrained: from ...data import ImageNet1kAttr attrib = ImageNet1kAttr() model.synset = attrib.synset model.classes = attrib.classes model.classes_long = attrib.classes_long return model
def load_params(self, fname): save_dict = ndarray.load(fname) arg_params = {} aux_params = {} for k, value in save_dict.items(): arg_type, name = k.split(':', 1) if arg_type == 'arg': arg_params[name] = value elif arg_type == 'aux': aux_params[name] = value else: raise ValueError("Invalid param file " + fname) self.set_params(arg_params, aux_params)
def load_params(prefix, epoch): #save_dict = nd.load('%s-%04d.params' % (prefix, epoch)) save_dict = nd.load( "b32_q50_qa200_m20_std0.1_lr0.05_gn50.0_f50_s224-0160.params") arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params
def load_params(dir_path="", epoch=None, name=""): prefix = os.path.join(dir_path, name) _, param_loading_path, _ = get_saving_path(prefix, epoch) while not os.path.isfile(param_loading_path): logging.info("in load_param, %s Not Found!" % param_loading_path) time.sleep(60) save_dict = nd.load(param_loading_path) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params, param_loading_path
def load_params(dir_path="", epoch=None, name=""): prefix = os.path.join(dir_path, name) _, param_loading_path, _ = get_saving_path(prefix, epoch) while not os.path.isfile(param_loading_path): logging.info("in load_param, %s Not Found!" % param_loading_path) time.sleep(60) save_dict = nd.load(param_loading_path) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params, param_loading_path
def _try_load_parameters(self, filename=None, model=None, ctx=None, allow_missing=False, ignore_extra=False): def getblock(parent, name): if len(name) == 1: if name[0].isnumeric(): return parent[int(name[0])] else: return getattr(parent, name[0]) else: if name[0].isnumeric(): return getblock(parent[int(name[0])], name[1:]) else: return getblock(getattr(parent, name[0]), name[1:]) if filename is not None: loaded = ndarray.load(filename) else: loaded = model._collect_params_with_prefix() params = self._collect_params_with_prefix() if not loaded and not params: return if not any('.' in i for i in loaded.keys()): # legacy loading del loaded self.collect_params().load(filename, ctx, allow_missing, ignore_extra, self.prefix) return ''' for name in params.keys(): if name not in loaded: name_split = name.split('.') block = getblock(self, name_split) block.initialize(ctx=ctx) ''' for name in loaded: if name in params: if params[name].shape != loaded[name].shape: continue params[name]._load_init(loaded[name], ctx)
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")
def test_sym_nnvm(batch_size=10, iter_num=10): logger = logging.getLogger("log.test.nnvm") logger.info("=== Log Test NNVM ===") target = "llvm" tvm_ctx = tvm.context(target, 1) mx_ctx = mx.gpu(2) inputs_ext = { 'data': { 'shape': (batch_size, 3, 224, 224), } } inputs = [mx.sym.var(name) for name in inputs_ext] inputs_shape = {k: v['shape'] for k, v in inputs_ext.items()} data_iter = load_dataset(batch_size) def data_iter_func(): data = data_iter.next() return data.data[0], data.label[0] data_iter_func() version = "" dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True) (inputs_ext, ) = sim.load_ext(dump_ext) sym, params = mx.sym.load(dump_sym), nd.load(dump_params) # sim.load_ins_ext(params, inputs_ext) # nnvm_sym, _ = nnvm.frontend.from_mxnet(sym) # with open('debug_nnvm_sym_after_load_from_mxnet.json', 'w') as fout: # fout.write(nnvm_sym.debug_str()) dump_sym, dump_params = load_fname(version, "nnvm.compile", False) spass.mxnet_to_nnvm(sym, params, inputs_ext, dump_sym, dump_params, target='llvm')
def load_checkpoint(prefix, epoch): """ Parameters ---------- prefix: str directory prefix of checkpoint epoch: int Returns ------- arg_params: mxnet.ndarray aux_params: mxnet.ndarray """ save_dict = nd.load('%s-%04d.params' % (prefix, epoch)) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params
def read_mxnet_weights(path, show=False): # assert os.path.exists(path), "path erro: {}".format(path) name_MxnetArray_dict = nd.load(path) name_array_dict = {} for name in sorted(name_MxnetArray_dict.keys()): mxnet_array = name_MxnetArray_dict[name] array = mxnet_array.asnumpy() if show: print ("name: {} || shape: {} || dtype: {}".format(name, array.shape, array.dtype)) if name.endswith("weight"): if name.endswith("fc.weight"): array = np.transpose(array, [1, 0]) else: array = np.transpose(array, [2, 3, 1, 0]) # (out_channel, in_channel, k, k)(mxnet) --> (k, k, in_channel, out_channel)(tf) # (32, 3, 3, 3)-->(3, 3, 3, 32) name_array_dict[name] = array return name_array_dict
def load_params(prefix, epoch): """ Parameters ---------- prefix : str epoch : int Returns ------- arg_params : dict aux_params : dict """ import mxnet.ndarray as nd save_dict = nd.load('%s-%04d.params' % (prefix, epoch)) arg_params = {} aux_params = {} for k, v in save_dict.items(): tp, name = k.split(':', 1) if tp == 'arg': arg_params[name] = v if tp == 'aux': aux_params[name] = v return arg_params, aux_params
from mxnet import ndarray as nd features = nd.load('./pig/features_train_vgg11.nd')[0] labels = nd.load('./pig/labels.nd')[0] # print(features) print(labels[550:60])
acc_top5.update(label, res) _, top5 = acc_top5.get() return "top1={:6.2%} top5={:6.2%}".format(top1, top5) # 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,
mlp_model = mx.mod.Module(symbol=mlp, context=mx.cpu()) # pass train/test data to allocate model (bind state) MLP_train_iter = mx.io.NDArrayIter(Z_train, yZ_train, batch_size, shuffle=False) mlp_model.bind(MLP_train_iter.provide_data, MLP_train_iter.provide_label) mlp_model.init_params() mlp_model.init_optimizer() mlp_model_params = mlp_model.get_params()[0] # update parameters based on optimal found during cv Training from mxnet import ndarray params_dict = ndarray.load( os.path.join(save_to, 'mlp_model_params_z{}_mu{}.arg'.format(znum, num_centers))) arg_params = {} aux_params = {} for k, value in params_dict.items(): arg_type, name = k.split(':', 1) if arg_type == 'arg': arg_params[name] = value elif arg_type == 'aux': aux_params[name] = value else: raise ValueError("Invalid param file ") # order of params: [(128L, 266L),(128L,),(32L, 128L),(32L,),(2L, 32L),(2L,)] # organize weights and biases l1 = [v.asnumpy().shape for k, v in mlp_model_params.iteritems()]
def data_iter_func(): return next(data_iter) data, label = data_iter_func() sym_file, param_file = load_fname() net1 = utils.load_model(sym_file, param_file, inputs, ctx=ctx) def trec(data): res = net1(data.as_in_context(ctx)) return res sym, params = mx.sym.load(sym_file), nd.load(param_file) sym, params = spass.sym_quant_prepare(sym, params, inputs_ext) if True: mrt = _mrt.MRT(sym, params, inputs_ext) mrt.set_data('data', data) mrt.calibrate(ctx=ctx) mrt.set_input_prec('data', 16) mrt.set_fixed('data') mrt.set_output_prec(8) qsym, qparams, inputs_ext = mrt.quantize() else: inputs_ext['data']['data'] = data th_dict = calib.sym_calibrate(sym, params, inputs_ext, ctx=ctx) qsym, qparams, _ = calib.pure_int8_quantize(sym, params, inputs_ext, th_dict) net2 = gluon.nn.SymbolBlock(qsym, inputs)
def test_sym_pass(batch_size=10, iter_num=10, quantize=True): logger = logging.getLogger("log.test.sym.pass") calib_ctx = mx.gpu(2) ctx = [mx.gpu(int(i)) for i in "1,2,3,4".split(',') if i.strip()] input_size = 299 version = "v3" h, w = input_size, input_size inputs_ext = { 'data': { 'shape': (batch_size, 3, h, w), } } inputs = [mx.sym.var(name) for name in inputs_ext] logger.info("load dataset, symbol and parameters") 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] net1 = utils.load_model(*load_fname(version), inputs, ctx=ctx) acc_top1 = mx.metric.Accuracy() acc_top5 = mx.metric.TopKAccuracy(5) acc_top1.reset() acc_top5.reset() def inception_v3(data, label): data = gluon.utils.split_and_load(data, ctx_list=ctx, batch_axis=0, even_split=False) res = [net1.forward(d) for d in data] res = nd.concatenate(res) acc_top1.update(label, res) _, top1 = acc_top1.get() acc_top5.update(label, res) _, top5 = acc_top5.get() return "top1={:6.2%} top5={:6.2%}".format(top1, top5) if quantize: sym_file, param_file = load_fname(version) sym, params = mx.sym.load(sym_file), nd.load(param_file) sym, params = spass.sym_quant_prepare(sym, params, inputs_ext) data, _ = data_iter_func() if True: dump_sym, dump_params, dump_ext = load_fname(version, "mrt", True) mrt = _mrt.MRT(sym, params, inputs_ext) mrt.set_data('data', data) mrt.calibrate(ctx=calib_ctx) mrt.set_output_prec(8) qsym, qparams, inputs_ext = mrt.quantize() else: dump_sym, dump_params, dump_ext = load_fname( version, "sym.quantize", True) inputs_ext['data']['data'] = data th_dict = calib.sym_calibrate(sym, params, inputs_ext, ctx=calib_ctx) qsym, qparams, precs, _ = calib.sym_simulate( sym, params, inputs_ext, th_dict) qsym, qparams = calib.sym_realize(qsym, qparams, inputs_ext, precs) 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, "mrt", True) (inputs_ext, ) = sim.load_ext(dump_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) res = [net2.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(inception_v3, data_iter_func, cvm_quantize, iter_num=iter_num, logger=logger)
kernel=(4, 4), pad=(1, 1), stride=(2, 2), num_filter=32, name='deconv1') data = mx.sym.BatchNorm(data=data, momentum=0.9, name='dcbn1') data = mx.sym.Activation(data=data, act_type='relu') data = mx.sym.Convolution(data=data, num_filter=3, kernel=(9, 9), pad=(4, 4), name='lastconv') return data arg = nd.load("data/style_model/the_scream_args.nd") aux = nd.load("data/style_model/the_scream_auxs.nd") sym_mx = generator_symbol() x = imread('data/style_model/tubingen.jpg') x = np.transpose(x, axes=(2, 0, 1)).astype(np.float32) x[0, :] -= 123.68 x[1, :] -= 116.779 x[2, :] -= 103.939 x = np.expand_dims(x, axis=0) print("input shape", x.shape) arg["data"] = nd.array(x, ctx=mx.cpu()) import nnvm sym, params = nnvm.frontend.from_mxnet(sym_mx, arg, aux)
def test_sym_pass(batch_size=10, iter_num=10, quantize=True): logger = logging.getLogger("log.test.sym.pass") calib_ctx = mx.gpu(1) ctx = [mx.gpu(int(i)) for i in "1,2,3,4".split(',') if i.strip()] inputs_ext = { 'data': { 'shape': (batch_size, 3, 224, 224), } } inputs = [mx.sym.var(name) for name in inputs_ext] logger.info("load dataset, symbol and parameters") # load dataset and iter function data_iter = ds.load_imagenet_rec(batch_size) def data_iter_func(): data = data_iter.next() return data.data[0], data.label[0] data, _ = data_iter_func() # load original model for accuracy net1 = utils.load_model(*load_fname(version), inputs, ctx=ctx) acc_top1 = mx.metric.Accuracy() acc_top5 = mx.metric.TopKAccuracy(5) acc_top1.reset() acc_top5.reset() def shufflenet(data, label): data = gluon.utils.split_and_load(data, ctx_list=ctx, batch_axis=0, even_split=False) res = [net1.forward(d) for d in data] res = nd.concatenate(res) acc_top1.update(label, res) _, top1 = acc_top1.get() acc_top5.update(label, res) _, top5 = acc_top5.get() return "top1={:6.2%} top5={:6.2%}".format(top1, top5) if quantize: # load original model sym_fname, param_fname = load_fname(version) sym, params = mx.sym.load(sym_fname), nd.load(param_fname) sym, params = spass.sym_quant_prepare(sym, params, inputs_ext) # quantize process mrt = _mrt.MRT(sym, params, inputs_ext) # initialize mrt.set_data('data', data) # set input data mrt.calibrate(ctx=calib_ctx) # calibration mrt.set_output_prec(8) # set output prec, do nothing by default qsym, qparams, inputs_ext = mrt.quantize() # quantization # dump quantized model 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()) if False: # convert to cvm executor model inputs_ext['data']['shape'] = (1, 3, 224, 224) nnvm_sym, nnvm_params = spass.mxnet_to_nnvm(qsym, qparams, inputs_ext) spass.cvm_build(nnvm_sym, nnvm_params, inputs_ext, *load_fname(version, "nnvm")) # load quantized model for accuracy dump_sym, dump_params, dump_ext = load_fname(version, "sym.quantize", True) (inputs_ext, ) = sim.load_ext(dump_ext) inputs = [mx.sym.var(n) for n in inputs_ext] net3 = utils.load_model(dump_sym, dump_params, inputs, ctx=ctx) # net3 = mx.gluon.nn.SymbolBlock(qsym, inputs) # utils.load_parameters(net3, qparams, 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) # compare accuracy between models utils.multi_validate(shufflenet, data_iter_func, cvm_quantize, iter_num=iter_num, logger=logger)