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()
