def get_data(batch_size): """ Load MNIST data (training and test sets) """ mnist_data = mx.test_utils.get_mnist() train_iter = NDArrayIter(mnist_data['train_data'], mnist_data['train_label'], batch_size, shuffle=True) test_iter = NDArrayIter(mnist_data['test_data'], mnist_data['test_label'], batch_size) return train_iter, test_iter
def run(num_gpus, batch_size, lr): # the list of GPUs will be used ctx = [mx.gpu(i) for i in range(num_gpus)] print('Running on {}'.format(ctx)) # data iterator mnist = get_mnist() train_data = NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size) valid_data = NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size) print('Batch size is {}'.format(batch_size)) net.collect_params().initialize(force_reinit=True, ctx=ctx) trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr}) for epoch in range(10): # train start = time() train_data.reset() for batch in train_data: train_batch(batch, ctx, net, trainer) nd.waitall( ) # wait until all computations are finished to benchmark the time print('Epoch %d, training time = %.1f sec' % (epoch, time() - start)) # validating valid_data.reset() correct, num = 0.0, 0.0 for batch in valid_data: correct += valid_batch(batch, ctx, net) num += batch.data[0].shape[0] print(' validation accuracy = %.4f' % (correct / num))
def check_quantize_model(qdtype): def check_params(params, qparams, qsym=None): if qsym is None: assert len(params) == len(qparams) for k, v in params.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) else: qparams_ground_truth = mx.contrib.quant._quantize_params(qsym, params) assert len(qparams) == len(qparams_ground_truth) for k, v in qparams_ground_truth.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) def check_qsym_calibrated(qsym): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('requantize_') != -1: assert 'min_calib_range' in v assert 'max_calib_range' in v def check_qsym_qdtype(qsym, qdtype): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('_quantize') != -1: assert 'out_type' in v assert v['out_type'] == qdtype sym = get_fp32_sym() mod = Module(symbol=sym) batch_size = 4 data_shape = (batch_size, 4, 10, 10) label_shape = (batch_size, 10) mod.bind(data_shapes=[('data', data_shape)], label_shapes=[('softmax_label', label_shape)]) mod.init_params() arg_params, aux_params = mod.get_params() qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model(sym=sym, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='none') check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) calib_data = mx.nd.random.uniform(shape=data_shape) calib_data = NDArrayIter(data=calib_data) calib_data = DummyIter(calib_data) qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model(sym=sym, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='naive', calib_data=calib_data, num_calib_examples=20) check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_calibrated(qsym) check_qsym_qdtype(qsym, qdtype)
def testIter(): print(imgs.shape) itr = NDArrayIter(imgs) for batch in itr: print(type(batch)) print(len(batch.data)) print(batch.data[0].shape)
def check_quantize(sym, data_shape, out_type, name='conv', check_calibration=True, gluon_forward=False): sg_pass_name = config[name][SG_PASS_NAME] post_sg_pass_name = config[name][POST_SG_PASS_NAME] fc = mx.sym.FullyConnected(data=sym, num_hidden=10, flatten=True, name='fc_softmax') if gluon_forward == True: sym = fc sym_sg = sym.get_backend_symbol(sg_pass_name) mod = Module(symbol=sym, label_names=[]) mod.bind(for_training=False, data_shapes=[('data', data_shape)]) else: sym = mx.sym.SoftmaxOutput(data=fc, name='softmax') sym_sg = sym.get_backend_symbol(sg_pass_name) label_shape = (data_shape[0], 10) mod = Module(symbol=sym) mod.bind(for_training=False, data_shapes=[('data', data_shape)], label_shapes=[('softmax_label', label_shape)]) mod.init_params(mx.init.Normal(0.5)) arg_params, aux_params = mod.get_params() data = [mx.random.uniform(-1, 1, shape=shape, ctx=mx.current_context()) for _, shape in mod.data_shapes] batch = mx.io.DataBatch(data, []) mod.forward(batch, is_train=False) for output in mod.get_outputs(): output.wait_to_read() ref_out = mod.get_outputs() excluded_sym_names = [] if mx.current_context() == mx.cpu() and gluon_forward == True: excluded_sym_names += ['sg_mkldnn_fully_connected_0'] excluded_sym_names += ['fc_softmax'] calib_data = mx.nd.random.uniform(shape=data_shape) calib_data = NDArrayIter(data=calib_data) calib_data = DummyIter(calib_data) calib_layer = lambda name: name.endswith('_output') qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model(sym=sym_sg, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), excluded_sym_names=excluded_sym_names, quantized_dtype=out_type, calib_mode='naive', calib_data=calib_data, calib_layer=calib_layer, num_calib_examples=5) qsym = qsym.get_backend_symbol(post_sg_pass_name) if check_calibration: check_qsym_calibrated(qsym, out_type, name=name) if gluon_forward == True: check_qsym_gluon_forward(qsym, qarg_params, qaux_params, data_shape) else: check_qsym_dummy_forward(qsym, batch, data_shape, label_shape) quantized_out = check_qsym_forward(qsym, qarg_params, qaux_params, batch, data_shape, label_shape) for i in range(len(ref_out)): assert_almost_equal(ref_out[i].asnumpy(), quantized_out[i].asnumpy(), atol = 1)
def check_quantize(sym, data_shape, check_conv=True): fc = mx.sym.FullyConnected(data=sym, num_hidden=10, flatten=True, name='fc') sym = mx.sym.SoftmaxOutput(data=fc, name='softmax') sym_sg = sym.get_backend_symbol("MKLDNN") label_shape = (data_shape[0], 10) mod = Module(symbol=sym) mod.bind(for_training=False, data_shapes=[('data', data_shape)], label_shapes=[('softmax_label', label_shape)]) mod.init_params(mx.init.Normal(0.5)) arg_params, aux_params = mod.get_params() data = [ mx.random.uniform(-1, 1, shape=shape, ctx=mx.current_context()) for _, shape in mod.data_shapes ] batch = mx.io.DataBatch(data, []) mod.forward(batch, is_train=False) for output in mod.get_outputs(): output.wait_to_read() ref_out = mod.get_outputs() excluded_sym_names = [] if mx.current_context() == mx.cpu(): excluded_sym_names += ['fc'] calib_data = mx.nd.random.uniform(shape=data_shape) calib_data = NDArrayIter(data=calib_data) calib_data = DummyIter(calib_data) calib_layer = lambda name: name.endswith('_output') qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=sym_sg, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), excluded_sym_names=excluded_sym_names, quantized_dtype='uint8', calib_mode='naive', calib_data=calib_data, calib_layer=calib_layer, calib_quantize_op=True, num_calib_examples=5) qsym = qsym.get_backend_symbol("MKLDNN_POST_QUANTIZE") if check_conv: check_qsym_calibrated(qsym) quantized_out = check_qsym_forward(qsym, qarg_params, qaux_params, batch, data_shape, label_shape) for i in range(len(ref_out)): assert_almost_equal(ref_out[i].asnumpy(), quantized_out[i].asnumpy(), atol=1) check_qsym_dummy_forward(qsym, batch, data_shape, label_shape)
def main(): model = RNNNet() x_train, y_train = data_gen(10000) x_test, y_test = data_gen(1000) train_dataiter = NDArrayIter(x_train, y_train, batch_size=100, shuffle=True) test_dataiter = NDArrayIter(x_test, y_test, batch_size=100, shuffle=False) solver = Solver(model, train_dataiter, test_dataiter, num_epochs=10, init_rule='xavier', update_rule='adam', verbose=True, print_every=20) solver.init() solver.train()
def check_quantize_whole_model(out_type): batch_size = 4 data_shape = (batch_size, 4, 10, 10) data = mx.sym.Variable('data') conv0 = mx.sym.Convolution(data, kernel=(1, 1), num_filter=16, name='conv0') sym = mx.sym.Convolution(conv0, kernel=(1, 1), num_filter=16, name='conv1') sym_sg = sym.get_backend_symbol('MKLDNN') mod = Module(symbol=sym, label_names=[]) mod.bind(for_training=False, data_shapes=[('data', data_shape)]) mod.init_params(mx.init.Normal(0.5)) arg_params, aux_params = mod.get_params() excluded_sym_names = [] calib_data = mx.nd.random.uniform(shape=data_shape) calib_data = NDArrayIter(data=calib_data) calib_data = DummyIter(calib_data) calib_layer = lambda name: name.endswith('_output') qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=sym_sg, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), excluded_sym_names=excluded_sym_names, quantized_dtype=out_type, calib_mode='naive', calib_data=calib_data, calib_layer=calib_layer, num_calib_examples=5) qsym = qsym.get_backend_symbol('MKLDNN_POST_QUANTIZE') check_qsym_forward(qsym, qarg_params, qaux_params, data_shape)
def check_quantize_model(qdtype): if is_test_for_native_cpu(): print( 'skipped testing test_quantize_model_with_forward for native cpu since it is not supported yet' ) return elif qdtype == 'int8' and is_test_for_mkldnn(): print( 'skipped testing test_quantize_model_with_forward for mkldnn cpu int8 since it is not supported yet' ) return elif qdtype == 'uint8' and is_test_for_gpu(): print( 'skipped testing test_quantize_model_with_forward for gpu uint8 since it is not supported yet' ) return def check_params(params, qparams, qsym=None): if qsym is None: assert len(params) == len(qparams) for k, v in params.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) else: qparams_ground_truth = mx.contrib.quant._quantize_params( qsym, params, th_dict={}) assert len(qparams) == len(qparams_ground_truth) for k, v in qparams_ground_truth.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) def check_qsym_calibrated(qsym): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('requantize_') != -1: assert 'min_calib_range' in v assert 'max_calib_range' in v def check_qsym_qdtype(qsym, qdtype): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('_quantize') != -1: assert 'out_type' in v assert v['out_type'] == qdtype def check_qsym_forward(qsym, qarg_params, qaux_params, data_shape): mod = mx.mod.Module(symbol=qsym, label_names=None, context=mx.current_context()) mod.bind(for_training=False, data_shapes=[('data', data_shape)]) mod.set_params(qarg_params, qaux_params) data = [ mx.random.uniform(-1.0, 1.0, shape=shape) for _, shape in mod.data_shapes ] batch = mx.io.DataBatch(data, []) mod.forward(batch, is_train=False) for output in mod.get_outputs(): output.wait_to_read() batch_size = 4 dshape = (batch_size, 4, 10, 10) data = mx.sym.Variable('data') sym = mx.sym.Convolution(data, kernel=(1, 1), num_filter=16, name='conv0') mod = Module(symbol=sym, label_names=None) mod.bind(data_shapes=[('data', dshape)]) mod.init_params() arg_params, aux_params = mod.get_params() excluded_sym_names = [] qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=sym, arg_params=arg_params, aux_params=aux_params, excluded_sym_names=excluded_sym_names, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='none') check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_forward(qsym, qarg_params, qaux_params, dshape) calib_data = mx.nd.random.uniform(shape=dshape) calib_data = NDArrayIter(data=calib_data, batch_size=batch_size) calib_data = DummyIter(calib_data) qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=sym, arg_params=arg_params, aux_params=aux_params, excluded_sym_names=excluded_sym_names, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='naive', calib_data=calib_data, num_calib_examples=20) check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_calibrated(qsym) check_qsym_qdtype(qsym, qdtype) check_qsym_forward(qsym, qarg_params, qaux_params, dshape)
def check_quantize_model(qdtype): if is_test_for_native_cpu(): print( 'skipped testing quantize_model for native cpu since it is not supported yet' ) return elif qdtype == 'int8' and is_test_for_mkldnn(): print( 'skipped testing quantize_model for mkldnn cpu int8 since it is not supported yet' ) return elif qdtype == 'uint8' and is_test_for_gpu(): print( 'skipped testing quantize_model for gpu uint8 since it is not supported yet' ) return def check_params(params, qparams, qsym=None): if qsym is None: assert len(params) == len(qparams) for k, v in params.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) else: qparams_ground_truth = mx.contrib.quant._quantize_params( qsym, params, th_dict={}) assert len(qparams) == len(qparams_ground_truth) for k, v in qparams_ground_truth.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) def check_qsym_calibrated(qsym): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('requantize_') != -1: assert 'min_calib_range' in v assert 'max_calib_range' in v def check_qsym_qdtype(qsym, qdtype): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('_quantize') != -1: assert 'out_type' in v assert v['out_type'] == qdtype sym = get_fp32_sym() batch_size = 4 label_shape = (batch_size, 10) data_shape = (batch_size, 4, 10, 10) length = batch_size # specify num of outputs from split op msym = get_fp32_sym_with_multiple_outputs(length) msym_label_shape = (length, 10) msym_data_shape = (length, 4, 4, 10, 10) for s, dshape, lshape in zip((sym, msym), (data_shape, msym_data_shape), (label_shape, msym_label_shape)): mod = Module(symbol=s) mod.bind(data_shapes=[('data', dshape)], label_shapes=[('softmax_label', lshape)]) mod.init_params() arg_params, aux_params = mod.get_params() qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=s, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='none') check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) calib_data = mx.nd.random.uniform(shape=dshape) calib_data = NDArrayIter(data=calib_data, batch_size=batch_size) calib_data = DummyIter(calib_data) qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=s, arg_params=arg_params, aux_params=aux_params, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='naive', calib_data=calib_data, num_calib_examples=20) check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_calibrated(qsym) check_qsym_qdtype(qsym, qdtype)
print('updating net...') # print 'copy array' em = array(em, ctx=mx.cpu()) # print 'copy array done' net.collect_params()['sequential0_embedding0_weight'].set_data(em) net.collect_params().reset_ctx(ctx) print net.collect_params() print_batches = 1000 shuffle_idx = np.random.permutation(train_data.shape[0]) train_data = train_data[shuffle_idx] train_label = train_label[shuffle_idx] # print em.shape data_iter = NDArrayIter(data=train_data[:-10000], label=train_label[:-10000], batch_size=args.batch_size, shuffle=True) val_data_iter = NDArrayIter(data=train_data[-10000:], label=train_label[-10000:], batch_size=args.batch_size, shuffle=False) trainer = Trainer(net.collect_params(), 'adam', {'learning_rate': 0.001}) # trainer = Trainer(net.collect_params(),'RMSProp', {'learning_rate': 0.001}) # utils.train(data_iter, val_data_iter, net, EntropyLoss, # trainer, ctx, num_epochs=args.epochs, print_batches=print_batches) utils.train_multi(data_iter, val_data_iter, args.kfold, net, EntropyLoss, trainer,
args = parser.parse_args() context = mx.cpu() if args.gpu_index < 0 else mx.gpu(args.gpu_index) Context.default_ctx = context # Create model. gnet_model = Generative(ngf, nc, no_bias) dnetwork = Discriminative(ndf, no_bias) # Prepare data ''' from data_utilities import load_mnist X_training, _, X_test, _, _, _ = load_mnist(path=args.path, normalize=True, shape=(1, 56, 56)) ''' X_training, X_test = fetch_and_get_mnist() real_data = NDArrayIter(X_training, np.ones(X_training.shape[0]), batch_size=batch_size) random_data = RandIter(batch_size, Z) gnet_updater = Updater(gnet_model, update_rule='sgd_momentum', lr=0.1, momentum=0.9) dnet_updater = Updater(dnetwork, update_rule='sgd_momentum', lr=0.1, momentum=0.9) # Training epoch_number = 0 iteration_number = 0 terminated = False while not terminated: epoch_number += 1 real_data.reset() i = 0 for real_batch in real_data:
if __name__ == "__main__": # setting the hyper parameters parser = argparse.ArgumentParser() parser.add_argument('--batch_size', default=128, type=int) parser.add_argument('--epochs', default=100, type=int) parser.add_argument('--gpu', default=0, type=int) args = parser.parse_args() # ctx = mx.cpu()# gpu(7) ctx = mx.gpu(args.gpu) net = net_define_eu() # net = net_define() net.collect_params().reset_ctx(ctx) net.load_params('net0.params', ctx) test_data, test_id = fetch_test_data() data_iter = NDArrayIter(data=test_data, batch_size=args.batch_size, shuffle=False) with open('result.csv', 'w') as f: f.write('id,toxic,severe_toxic,obscene,threat,insult,identity_hate\n') for i, d in enumerate(data_iter): print(i) output = net(d.data[0].as_in_context(ctx)).asnumpy() for j in range(args.batch_size): if i * args.batch_size + j < test_id.shape[0]: str_out = ','.join([str(test_id[i * args.batch_size + j])] + [str(v) for v in output[j]]) + '\n' f.write(str_out)
kf_label[:, i] = 2**i kf_label = np.sum(kf_label, axis=1) kf = StratifiedKFold(n_splits=args.kfold, shuffle=True) for i, (inTr, inTe) in enumerate(kf.split(train_data, kf_label)): print('training fold: ', i) # ctx = [mx.gpu(0), mx.gpu(1)]# , mx.gpu(4), mx.gpu(5)] ctx = [utils.try_gpu(), utils.try_gpu()] net = net_define_eu() xtr = train_data[inTr] xte = train_data[inTe] ytr = train_label[inTr] yte = train_label[inTe] data_iter = NDArrayIter(data=xtr, label=ytr, batch_size=args.batch_size, shuffle=True) val_data_iter = NDArrayIter(data=xte, label=yte, batch_size=args.batch_size, shuffle=False) # print net.collect_params() net.collect_params().reset_ctx(ctx) net.collect_params()['sequential' + str(i) + '_embedding0_weight'].set_data(em) net.collect_params()['sequential' + str(i) + '_embedding0_weight'].grad_req = 'null' trainer = Trainer(net.collect_params(), 'adam', {'learning_rate': 0.001}) # trainer = Trainer(net.collect_params(),'RMSProp', {'learning_rate': 0.001})
args = {key: mx.nd.zeros_like(value) for key, value in args.items()} aux_states = { key: mx.nd.zeros_like(value) for key, value in aux_states.items() } inference_executor = network.bind(context, args, aux_states=aux_states) from data_utilities import load_mnist original = load_mnist(path='stretched_canvas_mnist', scale=1, shape=(1, 56, 56)) stretched = load_mnist(path='stretched_mnist', scale=1, shape=(1, 56, 56)) from mxnet.io import NDArrayIter training_data = NDArrayIter(original[0], original[1], configs.batch_size, True) validation_data = NDArrayIter(stretched[2], stretched[3], configs.batch_size, False, 'discard') test_data = NDArrayIter(stretched[4], stretched[5], configs.batch_size, False, 'discard') unpack = lambda batch: (batch.data[0], batch.label[0]) for epoch in range(configs.n_epochs): for batch in training_data: data, labels = unpack(batch) print 'unpacked' executor.arg_dict['data'][:] = data executor.arg_dict['softmax_label'][:] = labels executor.forward(is_train=True) executor.backward()
def check_quantize_model(qdtype): if is_test_for_native_cpu(): print( 'skipped testing test_quantize_model_with_forward for native cpu since it is not supported yet' ) return elif qdtype == 'int8' and is_test_for_mkldnn(): print( 'skipped testing test_quantize_model_with_forward for mkldnn cpu int8 since it is not supported yet' ) return elif qdtype == 'uint8' and is_test_for_gpu(): print( 'skipped testing test_quantize_model_with_forward for gpu uint8 since it is not supported yet' ) return def check_params(params, qparams, qsym=None): if qsym is None: assert len(params) == len(qparams) for k, v in params.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) else: qparams_ground_truth = mx.contrib.quant._quantize_params( qsym, params, th_dict={}) assert len(qparams) == len(qparams_ground_truth) for k, v in qparams_ground_truth.items(): assert k in qparams assert same(v.asnumpy(), qparams[k].asnumpy()) def check_qsym_calibrated(qsym): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('requantize_') != -1: assert 'min_calib_range' in v assert 'max_calib_range' in v def check_qsym_qdtype(qsym, qdtype): attrs = qsym.attr_dict() for k, v in attrs.items(): if k.find('_quantize') != -1: assert 'out_type' in v assert v['out_type'] == qdtype def check_qsym_forward(qsym, qarg_params, qaux_params, data_shape, label_shape): mod = mx.mod.Module(symbol=qsym, context=mx.current_context()) mod.bind(for_training=False, data_shapes=[('data', data_shape)], label_shapes=[('softmax_label', label_shape)]) mod.set_params(qarg_params, qaux_params) data = [ mx.random.uniform(-1.0, 1.0, shape=shape) for _, shape in mod.data_shapes ] batch = mx.io.DataBatch(data, []) mod.forward(batch, is_train=False) for output in mod.get_outputs(): output.wait_to_read() sym = get_fp32_residual() batch_size = 4 data_shape = (batch_size, 4, 10, 10) label_shape = (batch_size, 10) length = batch_size # specify num of outputs from split op msym = get_fp32_sym_with_multiple_outputs(length) msym_label_shape = (length, 10) msym_data_shape = (length, 4, 4, 10, 10) for s, dshape, lshape in zip((sym, msym), (data_shape, msym_data_shape), (label_shape, msym_label_shape)): mod = Module(symbol=s) mod.bind(data_shapes=[('data', dshape)], label_shapes=[('softmax_label', lshape)]) mod.init_params() arg_params, aux_params = mod.get_params() excluded_names = [] if mx.current_context() == mx.cpu(): excluded_names += ['fc'] excluded_names += ['concat'] optional_names = ['pool0'] for skip_optional_names in [False, True]: exclude_sym_names = [] if skip_optional_names: excluded_sym_names = excluded_names else: excluded_sym_names = excluded_names + optional_names qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=s, arg_params=arg_params, aux_params=aux_params, excluded_sym_names=excluded_sym_names, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='none') check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_forward(qsym, qarg_params, qaux_params, dshape, lshape) calib_data = mx.nd.random.uniform(shape=dshape) calib_data = NDArrayIter(data=calib_data, batch_size=batch_size) calib_data = DummyIter(calib_data) qsym, qarg_params, qaux_params = mx.contrib.quant.quantize_model( sym=s, arg_params=arg_params, aux_params=aux_params, excluded_sym_names=excluded_sym_names, ctx=mx.current_context(), quantized_dtype=qdtype, calib_mode='naive', calib_data=calib_data, num_calib_examples=20) check_params(arg_params, qarg_params, qsym) check_params(aux_params, qaux_params) check_qsym_calibrated(qsym) check_qsym_qdtype(qsym, qdtype) check_qsym_forward(qsym, qarg_params, qaux_params, dshape, lshape)
args = parser.parse_args() import mxnet as mx from mxnet.context import Context context = mx.cpu() if args.gpu_index < 0 else mx.gpu(args.gpu_index) Context.default_ctx = context unpack_batch = lambda batch : \ (batch.data[0].as_in_context(context), batch.label[0].as_in_context(context)) from data_utilities import load_mnist data = load_mnist(path=args.path, normalize=True, shape=(1, 112, 112)) # data = load_mnist(path=args.path, normalize=True, shape=(1, 56, 56)) from mxnet.io import NDArrayIter training_data = NDArrayIter(data[0], data[1], batch_size=args.batch_size) validation_data = NDArrayIter(data[2], data[3], batch_size=args.batch_size) test_data = NDArrayIter(data[4], data[5], batch_size=args.batch_size) model = MSPCNN(args.n_layers, args.n_filters, args.n_scales, args.n_units) updater = Updater(model, update_rule='adam', lr=args.lr) # updater = Updater(model, update_rule='sgd_momentum', lr=1e-1, momentum=0.9) import numpy as np from mxnet.contrib.autograd import compute_gradient import minpy.nn.utils as utils validation_accuracy = [] for epoch in range(args.n_epochs): training_data.reset()