def test_models(model_name, input_shape, output_shape): """ Tests Googlenet model for both onnx import and export""" model_path, inputs, outputs = get_test_files(model_name) logging.info("Translating model from ONNX model zoo to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) params = {} params.update(arg_params) params.update(aux_params) dir_path = os.path.dirname(model_path) new_model_name = "exported_" + model_name + ".onnx" onnx_file = os.path.join(dir_path, new_model_name) logging.info("Translating converted model from mxnet to ONNX") converted_model_path = onnx_mxnet.export_model(sym, params, [input_shape], np.float32, onnx_file) sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model_path) metadata = onnx_mxnet.get_model_metadata(converted_model_path) assert len(metadata) == 2 assert metadata.get('input_tensor_data') assert metadata.get('input_tensor_data')[0][1] == input_shape assert metadata.get('output_tensor_data') assert metadata.get('output_tensor_data')[0][1] == output_shape data_names = [input_name[0] for input_name in metadata.get('input_tensor_data')] logging.info("Running inference on onnx re-import model in mxnet") # run test for each test file for input_data, output_data in zip(inputs, outputs): result = forward_pass(sym, arg_params, aux_params, data_names, input_data) # verify the results npt.assert_equal(result.shape, output_data.shape) npt.assert_almost_equal(output_data, result, decimal=3) logging.info(model_name + " conversion successful")
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a model """ onnx_path = os.path.join(model_dir, "model.onnx") ctx = mx.cpu() # todo: pass into function # load onnx model symbol and parameters sym, arg_params, aux_params = onnx_mxnet.import_model(onnx_path) model_metadata = onnx_mxnet.get_model_metadata(onnx_path) # first index is name, second index is shape input_names = [inputs[0] for inputs in model_metadata.get('input_tensor_data')] input_symbols = [mx.sym.var(i) for i in input_names] net = gluon.nn.SymbolBlock(outputs=sym, inputs=input_symbols) net_params = net.collect_params() # set parameters (on correct context) for param in arg_params: if param in net_params: net_params[param]._load_init(arg_params[param], ctx=ctx) for param in aux_params: if param in net_params: net_params[param]._load_init(aux_params[param], ctx=ctx) # hybridize for increase performance net.hybridize() return net
def test_bvlc_rcnn_ilsvrc13(): """Tests the bvlc rcnn model""" model_path, inputs, outputs = get_test_files('bvlc_reference_rcnn_ilsvrc13') logging.info("Translating rcnn_ilsvrc13 model from ONNX to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) metadata = onnx_mxnet.get_model_metadata(model_path) assert len(metadata) == 2 assert metadata.get('input_tensor_data') assert metadata.get('input_tensor_data') == [(u'data_0', (1, 3, 224, 224))] assert metadata.get('output_tensor_data') assert metadata.get('output_tensor_data') == [(u'fc-rcnn_1', (1, 200))] data_names = [input_name[0] for input_name in metadata.get('input_tensor_data')] # run test for each test file for input_data, output_data in zip(inputs, outputs): # create module mod = mx.mod.Module(symbol=sym, data_names=data_names, context=mx.cpu(), label_names=None) mod.bind(for_training=False, data_shapes=[(data_names[0], input_data.shape)], label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) # run inference batch = namedtuple('Batch', ['data']) mod.forward(batch([mx.nd.array(input_data)]), is_train=False) # verify the results npt.assert_equal(mod.get_outputs()[0].shape, output_data.shape) npt.assert_almost_equal(output_data, mod.get_outputs()[0].asnumpy(), decimal=3) logging.info("rcnn_ilsvrc13 model conversion Successful")
def test_bvlc_rcnn_ilsvrc13(): """Tests the bvlc rcnn model""" model_path, inputs, outputs = get_test_files('bvlc_reference_rcnn_ilsvrc13') logging.info("Translating rcnn_ilsvrc13 model from ONNX to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) metadata = onnx_mxnet.get_model_metadata(model_path) assert len(metadata) == 2 assert metadata.get('input_tensor_data') assert metadata.get('input_tensor_data') == [(u'data_0', (1, 3, 224, 224))] assert metadata.get('output_tensor_data') assert metadata.get('output_tensor_data') == [(u'fc-rcnn_1', (1, 200))] data_names = [input_name[0] for input_name in metadata.get('input_tensor_data')] # run test for each test file for input_data, output_data in zip(inputs, outputs): # create module mod = mx.mod.Module(symbol=sym, data_names=data_names, context=mx.cpu(), label_names=None) mod.bind(for_training=False, data_shapes=[(data_names[0], input_data.shape)], label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) # run inference batch = namedtuple('Batch', ['data']) mod.forward(batch([mx.nd.array(input_data)]), is_train=False) # verify the results npt.assert_equal(mod.get_outputs()[0].shape, output_data.shape) npt.assert_almost_equal(output_data, mod.get_outputs()[0].asnumpy(), decimal=3) logging.info("rcnn_ilsvrc13 model conversion Successful")
def test_square(): input1 = np.random.randint(1, 10, (2, 3)).astype("float32") ipsym = mx.sym.Variable("input1") square = mx.sym.square(data=ipsym) model = mx.mod.Module(symbol=square, data_names=['input1'], label_names=None) model.bind(for_training=False, data_shapes=[('input1', np.shape(input1))], label_shapes=None) model.init_params() args, auxs = model.get_params() params = {} params.update(args) params.update(auxs) converted_model = onnx_mxnet.export_model(square, params, [np.shape(input1)], np.float32, "square.onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['input1'], input1) numpy_op = np.square(input1) npt.assert_almost_equal(result, numpy_op)
def test_softmax(): input1 = np.random.rand(1000, 1000).astype("float32") label1 = np.random.rand(1000) input_nd = mx.nd.array(input1) label_nd = mx.nd.array(label1) ipsym = mx.sym.Variable("ipsym") label = mx.sym.Variable('label') sym = mx.sym.SoftmaxOutput(data=ipsym, label=label, ignore_label=0, use_ignore=False) ex = sym.bind(ctx=mx.cpu(0), args={'ipsym': input_nd, 'label': label_nd}) ex.forward(is_train=True) softmax_out = ex.outputs[0].asnumpy() converted_model = onnx_mxnet.export_model(sym, {}, [(1000, 1000), (1000, )], np.float32, "softmaxop.onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['ipsym'], input1) # Comparing result of forward pass before using onnx export, import npt.assert_almost_equal(result, softmax_out)
def get_model(ctx=-1, model_path='./bestmodel.onnx'): onnx_file = model_path sym, arg, aux = onnx_mxnet.import_model(onnx_file) # ### Get input data names data_names = [ graph_input for graph_input in sym.list_inputs() if graph_input not in arg and graph_input not in aux ] Batch = namedtuple('Batch', ['data']) test_image = np.random.rand(1, 3, 224, 224).astype('float32') if ctx == -1: context = mx.cpu() else: context = mx.gpu(ctx) mod = mx.mod.Module(symbol=sym, data_names=data_names, context=context, label_names=None) mod.bind(for_training=False, data_shapes=[(data_names[0], test_image.shape)], label_shapes=None) mod.set_params(arg_params=arg, aux_params=aux, allow_missing=True, allow_extra=True) return mod
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a model """ onnx_path = os.path.join(model_dir, "model.onnx") ctx = mx.cpu() # todo: pass into function # load onnx model symbol and parameters sym, arg_params, aux_params = onnx_mxnet.import_model(onnx_path) model_metadata = onnx_mxnet.get_model_metadata(onnx_path) # first index is name, second index is shape input_names = [inputs[0] for inputs in model_metadata.get('input_tensor_data')] input_symbols = [mx.sym.var(i) for i in input_names] net = gluon.nn.SymbolBlock(outputs=sym, inputs=input_symbols) net_params = net.collect_params() # set parameters (on correct context) for param in arg_params: if param in net_params: net_params[param]._load_init(arg_params[param], ctx=ctx) for param in aux_params: if param in net_params: net_params[param]._load_init(aux_params[param], ctx=ctx) # hybridize for increase performance net.hybridize() return net
def _check_onnx_export(net, group_outputs=False, shape_type=tuple, extra_params={}): net.initialize() data = nd.random.uniform(0, 1, (1, 1024)) output = _force_list(net(data)) # initialize weights net_sym = _optional_group(net(sym.Variable('data')), group_outputs) net_params = { name: param._reduce() for name, param in net.collect_params().items() } net_params.update(extra_params) with tempfile.TemporaryDirectory() as tmpdirname: onnx_file_path = os.path.join(tmpdirname, 'net.onnx') export_path = onnx_mxnet.export_model( sym=net_sym, params=net_params, input_shape=[shape_type(data.shape)], onnx_file_path=onnx_file_path) assert export_path == onnx_file_path # Try importing the model to symbol _assert_sym_equal(net_sym, onnx_mxnet.import_model(export_path)[0]) # Try importing the model to gluon imported_net = onnx_mxnet.import_to_gluon(export_path, ctx=None) _assert_sym_equal( net_sym, _optional_group(imported_net(sym.Variable('data')), group_outputs)) # Confirm network outputs are the same imported_net_output = _force_list(imported_net(data)) for out, imp_out in zip(output, imported_net_output): mx.test_utils.assert_almost_equal(out.asnumpy(), imp_out.asnumpy())
def _check_onnx_export(net, group_outputs=False, shape_type=tuple, extra_params={}): net.initialize() data = nd.random.uniform(0, 1, (1, 1024)) output = _force_list(net(data)) # initialize weights net_sym = _optional_group(net(sym.Variable('data')), group_outputs) net_params = {name:param._reduce() for name, param in net.collect_params().items()} net_params.update(extra_params) with tempfile.TemporaryDirectory() as tmpdirname: onnx_file_path = os.path.join(tmpdirname, 'net.onnx') export_path = onnx_mxnet.export_model( sym=net_sym, params=net_params, input_shape=[shape_type(data.shape)], onnx_file_path=onnx_file_path) assert export_path == onnx_file_path # Try importing the model to symbol _assert_sym_equal(net_sym, onnx_mxnet.import_model(export_path)[0]) # Try importing the model to gluon imported_net = onnx_mxnet.import_to_gluon(export_path, ctx=None) _assert_sym_equal(net_sym, _optional_group(imported_net(sym.Variable('data')), group_outputs)) # Confirm network outputs are the same imported_net_output = _force_list(imported_net(data)) for out, imp_out in zip(output, imported_net_output): mx.test_utils.assert_almost_equal(out.asnumpy(), imp_out.asnumpy())
def model_fn(model_dir): sym, arg_params, aux_params = onnx_mxnet.import_model( os.path.join(model_dir, 'model.onnx')) mod = mx.mod.Module(symbol=sym, data_names=['data'], label_names=None) mod.bind(for_training=False, data_shapes=[('data', [100, 1, 28, 28])]) mod.set_params(arg_params=arg_params, aux_params=aux_params) return mod
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a model """ if len(mx.test_utils.list_gpus()) == 0: ctx = mx.cpu() else: ctx = mx.gpu(0) det_threshold = [0.6, 0.7, 0.8] detector = MtcnnDetector( model_folder=f"{model_dir}/mtcnn-model", ctx=mx.cpu(), num_worker=1, accurate_landmark=True, threshold=det_threshold, ) image_size = (112, 112) sym, arg_params, aux_params = onnx_mxnet.import_model(f"{model_dir}/resnet100.onnx") # create module mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None) mod.bind( for_training=False, data_shapes=[("data", (1, 3, image_size[0], image_size[1]))] ) mod.set_params(arg_params=arg_params, aux_params=aux_params) return (detector, mod)
def test_model_accuracy(model_name, input_shape): """ Imports ONNX model, runs inference, exports and imports back run inference, compare result with the previous inference result""" model_path, inputs, outputs = get_test_files(model_name) logging.info("Translating model from ONNX model zoo to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) metadata = onnx_mxnet.get_model_metadata(model_path) data_names = [ input_name[0] for input_name in metadata.get('input_tensor_data') ] expected_result = [] for input_data, output_data in zip(inputs, outputs): result = forward_pass(sym, arg_params, aux_params, data_names, input_data) expected_result.append(result) params = {} params.update(arg_params) params.update(aux_params) dir_path = os.path.dirname(model_path) new_model_name = "exported_" + model_name + ".onnx" onnx_file = os.path.join(dir_path, new_model_name) logging.info("Translating converted model from mxnet to ONNX") converted_model_path = onnx_mxnet.export_model(sym, params, [input_shape], np.float32, onnx_file) sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model_path) metadata = onnx_mxnet.get_model_metadata(converted_model_path) data_names = [ input_name[0] for input_name in metadata.get('input_tensor_data') ] actual_result = [] for input_data, output_data in zip(inputs, outputs): result = forward_pass(sym, arg_params, aux_params, data_names, input_data) actual_result.append(result) # verify the results for expected, actual in zip(expected_result, actual_result): npt.assert_equal(expected.shape, actual.shape) npt.assert_almost_equal(expected, actual, decimal=3)
def test_import_export(self): for test in test_cases: test_name, mxnet_op, onnx_name, inputs, attrs, mxnet_specific, fix_attrs, check_value, check_shape = test with self.subTest(test_name): names, input_tensors, inputsym = get_input_tensors(inputs) if inputs: test_op = mxnet_op(*inputsym, **attrs) mxnet_output = forward_pass(test_op, None, None, names, inputs) outputshape = np.shape(mxnet_output) else: test_op = mxnet_op(**attrs) shape = attrs.get('shape', (1,)) x = mx.nd.zeros(shape, dtype='float32') xgrad = mx.nd.zeros(shape, dtype='float32') exe = test_op.bind(ctx=mx.cpu(), args={'x': x}, args_grad={'x': xgrad}) mxnet_output = exe.forward(is_train=False)[0].asnumpy() outputshape = np.shape(mxnet_output) if mxnet_specific: onnxmodelfile = onnx_mxnet.export_model(test_op, {}, [np.shape(ip) for ip in inputs], np.float32, onnx_name + ".onnx") onnxmodel = load_model(onnxmodelfile) else: onnx_attrs = _fix_attributes(attrs, fix_attrs) onnxmodel = get_onnx_graph(test_name, names, input_tensors, onnx_name, outputshape, onnx_attrs) bkd_rep = backend.prepare(onnxmodel, operation='export') output = bkd_rep.run(inputs) if check_value: npt.assert_almost_equal(output[0], mxnet_output) if check_shape: npt.assert_equal(output[0].shape, outputshape) input1 = get_rnd((1, 10, 2, 3)) ipsym = mx.sym.Variable("input1") for test in test_scalar_ops: if test == 'Add': outsym = 2 + ipsym if test == "Sub": outsym = ipsym - 2 if test == "rSub": outsym = ipsym.__rsub__(2) if test == "Mul": outsym = 2 * ipsym if test == "Div": outsym = ipsym / 2 if test == "Pow": outsym = ipsym ** 2 forward_op = forward_pass(outsym, None, None, ['input1'], input1) converted_model = onnx_mxnet.export_model(outsym, {}, [np.shape(input1)], np.float32, onnx_file_path=outsym.name + ".onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['input1'], input1) npt.assert_almost_equal(result, forward_op)
def test_import_export(self): for test in test_cases: test_name, mxnet_op, onnx_name, inputs, attrs, mxnet_specific, fix_attrs, check_value, check_shape = test with self.subTest(test_name): names, input_tensors, inputsym = get_input_tensors(inputs) if inputs: test_op = mxnet_op(*inputsym, **attrs) mxnet_output = forward_pass(test_op, None, None, names, inputs) outputshape = np.shape(mxnet_output) else: test_op = mxnet_op(**attrs) shape = attrs.get('shape', (1,)) x = mx.nd.zeros(shape, dtype='float32') xgrad = mx.nd.zeros(shape, dtype='float32') exe = test_op.bind(ctx=mx.cpu(), args={'x': x}, args_grad={'x': xgrad}) mxnet_output = exe.forward(is_train=False)[0].asnumpy() outputshape = np.shape(mxnet_output) if mxnet_specific: onnxmodelfile = onnx_mxnet.export_model(test_op, {}, [np.shape(ip) for ip in inputs], np.float32, onnx_name + ".onnx") onnxmodel = load_model(onnxmodelfile) else: onnx_attrs = _fix_attributes(attrs, fix_attrs) onnxmodel = get_onnx_graph(test_name, names, input_tensors, onnx_name, outputshape, onnx_attrs) bkd_rep = backend.prepare(onnxmodel, operation='export') output = bkd_rep.run(inputs) if check_value: npt.assert_almost_equal(output[0], mxnet_output) if check_shape: npt.assert_equal(output[0].shape, outputshape) input1 = get_rnd((1, 10, 2, 3)) ipsym = mx.sym.Variable("input1") for test in test_scalar_ops: if test == 'Add': outsym = 2 + ipsym if test == "Sub": outsym = ipsym - 2 if test == "rSub": outsym = ipsym.__rsub__(2) if test == "Mul": outsym = 2 * ipsym if test == "Div": outsym = ipsym / 2 if test == "Pow": outsym = ipsym ** 2 forward_op = forward_pass(outsym, None, None, ['input1'], input1) converted_model = onnx_mxnet.export_model(outsym, {}, [np.shape(input1)], np.float32, onnx_file_path=outsym.name + ".onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['input1'], input1) npt.assert_almost_equal(result, forward_op)
def import_onnx(): """Import the onnx model into mxnet""" model_url = 'https://s3.amazonaws.com/onnx-mxnet/examples/super_resolution.onnx' download(model_url, 'super_resolution.onnx') LOGGER.info("Converting onnx format to mxnet's symbol and params...") sym, arg_params, aux_params = onnx_mxnet.import_model('super_resolution.onnx') LOGGER.info("Successfully Converted onnx format to mxnet's symbol and params...") return sym, arg_params, aux_params
def import_onnx(): """Import the onnx model into mxnet""" model_url = 'https://s3.amazonaws.com/onnx-mxnet/examples/super_resolution.onnx' download(model_url, 'super_resolution.onnx') LOGGER.info("Converting onnx format to mxnet's symbol and params...") sym, arg_params, aux_params = onnx_mxnet.import_model('super_resolution.onnx') LOGGER.info("Successfully Converted onnx format to mxnet's symbol and params...") return sym, arg_params, aux_params
def get_model(): ctx = mx.gpu(0) sym, arg_params, aux_params = onnx_mxnet.import_model('zface.onnx') all_layers = sym.get_internals() sym = all_layers['fc1_output'] model = mx.mod.Module(sym, context=ctx, label_names=None) model.bind(data_shapes=[('data', (1, 3, 112, 112))]) model.set_params(arg_params, aux_params) return model
def onnx(): # Import the ONNX model into MXNet's symbolic interface sym, arg, aux = onnx_mxnet.import_model("torch.onnx") print("Loaded torch_model.onnx!") print(sym.get_internals()) sym.save("./model/torch.json") save_dict = {('arg:%s' % k): v.as_in_context(mx.cpu(0)) for k, v in arg.items()} save_dict.update({('aux:%s' % k): v.as_in_context(mx.cpu(0)) for k, v in aux.items()}) mx.nd.save("./model/torch.params", save_dict)
def test_nodims_import(): # Download test model without dims mentioned in params test_model = download(test_model_path, dirname=CURR_PATH.__str__()) input_data = np.array([0.2, 0.5]) nd_data = mx.nd.array(input_data).expand_dims(0) sym, arg_params, aux_params = onnx_mxnet.import_model(test_model) model_metadata = onnx_mxnet.get_model_metadata(test_model) input_names = [inputs[0] for inputs in model_metadata.get('input_tensor_data')] output_data = forward_pass(sym, arg_params, aux_params, input_names, nd_data) assert(output_data.shape == (1,1))
def get_model_results(modelpath): symbol, args, aux = onnx_mxnet.import_model(modelpath) data = onnx_mxnet.get_model_metadata(modelpath) data_names = [input_name[0] for input_name in data.get('input_tensor_data')] result = [] for input_data, output_data in zip(inputs, outputs): output = forward_pass(symbol, args, aux, data_names, input_data) result.append(output) return symbol, args, aux, result, data
def test_model_accuracy(model_name, input_shape): """ Imports ONNX model, runs inference, exports and imports back run inference, compare result with the previous inference result""" model_path, inputs, outputs = get_test_files(model_name) logging.info("Translating model from ONNX model zoo to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) metadata = onnx_mxnet.get_model_metadata(model_path) data_names = [input_name[0] for input_name in metadata.get('input_tensor_data')] expected_result= [] for input_data, output_data in zip(inputs, outputs): result = forward_pass(sym, arg_params, aux_params, data_names, input_data) expected_result.append(result) params = {} params.update(arg_params) params.update(aux_params) dir_path = os.path.dirname(model_path) new_model_name = "exported_" + model_name + ".onnx" onnx_file = os.path.join(dir_path, new_model_name) logging.info("Translating converted model from mxnet to ONNX") converted_model_path = onnx_mxnet.export_model(sym, params, [input_shape], np.float32, onnx_file) sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model_path) metadata = onnx_mxnet.get_model_metadata(converted_model_path) data_names = [input_name[0] for input_name in metadata.get('input_tensor_data')] actual_result = [] for input_data, output_data in zip(inputs, outputs): result = forward_pass(sym, arg_params, aux_params, data_names, input_data) actual_result.append(result) # verify the results for expected, actual in zip(expected_result, actual_result): npt.assert_equal(expected.shape, actual.shape) npt.assert_almost_equal(expected, actual, decimal=3)
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a Module object """ sym, arg_params, aux_params = onnx_mxnet.import_model('%s/resnet50v2.onnx' % model_dir) # create module mod = mx.mod.Module(symbol=sym, data_names=['data'], label_names=None) mod.bind(for_training=False, data_shapes=[('data', [1, 3, 224, 224])], label_shapes=mod._label_shapes) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) return mod
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a model """ sym, arg_params, aux_params = onnx_mxnet.import_model('%s/super_resolution.onnx' % model_dir) # create module mod = mx.mod.Module(symbol=sym, data_names=['1'], label_names=None) mod.bind(for_training=False, data_shapes=[('1', [1, 1, 224, 224])]) mod.set_params(arg_params=arg_params, aux_params=aux_params) return mod
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a Module object """ sym, arg_params, aux_params = onnx_mxnet.import_model('%s/resnet152v1.onnx' % model_dir) # create module mod = mx.mod.Module(symbol=sym, data_names=['data'], label_names=None) mod.bind(for_training=False, data_shapes=[('data', [1, 3, 224, 224])], label_shapes=mod._label_shapes) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) return mod
def model_fn(model_dir): """ Load the onnx model. Called once when hosting service starts. :param: model_dir The directory where model files are stored. :return: a model """ sym, arg_params, aux_params = onnx_mxnet.import_model( "%s/super_resolution.onnx" % model_dir) # create module mod = mx.mod.Module(symbol=sym, data_names=["1"], label_names=None) mod.bind(for_training=False, data_shapes=[("1", [1, 1, 224, 224])]) mod.set_params(arg_params=arg_params, aux_params=aux_params) return mod
def test_fully_connected(): def random_arrays(*shapes): """Generate some random numpy arrays.""" arrays = [np.random.randn(*s).astype("float32") for s in shapes] if len(arrays) == 1: return arrays[0] return arrays data_names = ['x', 'w', 'b'] dim_in, dim_out = (3, 4) input_data = random_arrays((4, dim_in), (dim_out, dim_in), (dim_out, )) ipsym = [] data_shapes = [] data_forward = [] for idx in range(len(data_names)): val = input_data[idx] data_shapes.append((data_names[idx], np.shape(val))) data_forward.append(mx.nd.array(val)) ipsym.append(mx.sym.Variable(data_names[idx])) op = mx.sym.FullyConnected(data=ipsym[0], weight=ipsym[1], bias=ipsym[2], num_hidden=dim_out, name='FC') model = mx.mod.Module(op, data_names=data_names, label_names=None) model.bind(for_training=False, data_shapes=data_shapes, label_shapes=None) model.init_params() args, auxs = model.get_params() params = {} params.update(args) params.update(auxs) converted_model = onnx_mxnet.export_model( op, params, [shape[1] for shape in data_shapes], np.float32, "fc.onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, data_names, input_data) numpy_op = np.dot(input_data[0], input_data[1].T) + input_data[2] npt.assert_almost_equal(result, numpy_op)
def get_model(ctx, model_path): # import ONNX model into MXNet symbols and params sym, arg, aux = import_model(model_path) # define network module mod = mx.mod.Module(symbol=sym, data_names=['data'], context=ctx, label_names=None) # bind parameters to the network mod.bind(for_training=False, data_shapes=[('data', (1, 3, im.shape[0], im.shape[1]))], label_shapes=mod._label_shapes) mod.set_params(arg_params=arg, aux_params=aux, allow_missing=True, allow_extra=True) return mod
def convertToMxNetAndBack(fileName, outputFileName, inputs): from mxnet.gluon.model_zoo import vision import mxnet.contrib.onnx as onnx_mxnet import mxnet ret = None if "resnet" in fileName: model = vision.resnet50_v2(pretrained=True) model.hybridize() ret = [model(mxnet.nd.array(inputs[0][0]))] model.export("mxnet-model") sym = "./mxnet-model-symbol.json" arg = "./mxnet-model-0000.params" else: sym, arg, aux = onnx_mxnet.import_model(fileName) onnx_mxnet.export_model(sym, arg, getOnnxInputShapes(fileName), np.float32, outputFileName) return ret
def convert_onnx_model(model_path, onnx_file): """ Util to convert onnx model to MXNet model :param model_path: :param onnx_file: :return: """ from mxnet.contrib import onnx as onnx_mxnet import onnx model_name = os.path.splitext(os.path.basename(onnx_file))[0] symbol_file = '%s-symbol.json' % model_name params_file = '%s-0000.params' % model_name signature_file = 'signature.json' # Find input symbol name and shape model_proto = onnx.load(os.path.join(model_path, onnx_file)) graph = model_proto.graph _params = set() for tensor_vals in graph.initializer: _params.add(tensor_vals.name) input_data = [] for graph_input in graph.input: shape = [] if graph_input.name not in _params: for val in graph_input.type.tensor_type.shape.dim: shape.append(val.dim_value) input_data.append((graph_input.name, tuple(shape))) sym, arg_params, aux_params = onnx_mxnet.import_model(os.path.join(model_path, onnx_file)) # UNION of argument and auxillary parameters params = dict(arg_params, **aux_params) # rewrite input data_name correctly with open(os.path.join(model_path, signature_file), 'r') as f: data = json.loads(f.read()) data['inputs'][0]['data_name'] = input_data[0][0] with open(os.path.join(model_path, signature_file), 'w') as f: f.write(json.dumps(data, indent=2)) with open(os.path.join(model_path, symbol_file), 'w') as f: f.write(sym.tojson()) save_dict = {('arg:%s' % k): v.as_in_context(mx.cpu()) for k, v in params.items()} mx.nd.save(os.path.join(model_path, params_file), save_dict) return symbol_file, params_file
def mod_inference(matrix): random_input = np.random.rand(batch_size, channel, single_sentence_length, embedding_size) sym, arg_params, aux_params = onnx_mxnet.import_model('kim_model.onnx') mod = mx.mod.Module(symbol=sym, data_names=['1'], context=mx.cpu(), label_names=None) mod.bind(for_training=False, data_shapes=[('1', random_input.shape)], label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True) Batch = namedtuple('Batch', ['data']) mod.forward(Batch([mx.nd.array(matrix)])) output = mod.get_outputs()[0] return output
def test_softmax(): input1 = np.random.rand(1000, 1000).astype("float32") label1 = np.random.rand(1000) input_nd = mx.nd.array(input1) label_nd = mx.nd.array(label1) ipsym = mx.sym.Variable("ipsym") label = mx.sym.Variable('label') sym = mx.sym.SoftmaxOutput(data=ipsym, label=label, ignore_label=0, use_ignore=False) ex = sym.bind(ctx=mx.cpu(0), args={'ipsym': input_nd, 'label': label_nd}) ex.forward(is_train=True) softmax_out = ex.outputs[0].asnumpy() converted_model = onnx_mxnet.export_model(sym, {}, [(1000, 1000), (1000,)], np.float32, "softmaxop.onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['ipsym'], input1) # Comparing result of forward pass before using onnx export, import npt.assert_almost_equal(result, softmax_out)
def test_square(): input1 = np.random.randint(1, 10, (2, 3)).astype("float32") ipsym = mx.sym.Variable("input1") square = mx.sym.square(data=ipsym) model = mx.mod.Module(symbol=square, data_names=['input1'], label_names=None) model.bind(for_training=False, data_shapes=[('input1', np.shape(input1))], label_shapes=None) model.init_params() args, auxs = model.get_params() params = {} params.update(args) params.update(auxs) converted_model = onnx_mxnet.export_model(square, params, [np.shape(input1)], np.float32, "square.onnx") sym, arg_params, aux_params = onnx_mxnet.import_model(converted_model) result = forward_pass(sym, arg_params, aux_params, ['input1'], input1) numpy_op = np.square(input1) npt.assert_almost_equal(result, numpy_op)
def test_bvlc_rcnn_ilsvrc13(): """Tests the bvlc rcnn model""" model_path, inputs, outputs = get_test_files('bvlc_reference_rcnn_ilsvrc13') logging.info("Translating rcnn_ilsvrc13 model from ONNX to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) # run test for each test file for input_data, output_data in zip(inputs, outputs): # create module data_names = [graph_input for graph_input in sym.list_inputs() if graph_input not in arg_params and graph_input not in aux_params] mod = mx.mod.Module(symbol=sym, data_names=data_names, context=mx.cpu(), label_names=None) mod.bind(for_training=False, data_shapes=[(data_names[0], input_data.shape)], label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) # run inference batch = namedtuple('Batch', ['data']) mod.forward(batch([mx.nd.array(input_data)]), is_train=False) # verify the results npt.assert_equal(mod.get_outputs()[0].shape, output_data.shape) npt.assert_almost_equal(output_data, mod.get_outputs()[0].asnumpy(), decimal=3) logging.info("rcnn_ilsvrc13 model conversion Successful")
def test_bvlc_rcnn_ilsvrc13(): """Tests the bvlc rcnn model""" model_path, inputs, outputs = get_test_files('bvlc_reference_rcnn_ilsvrc13') logging.info("Translating rcnn_ilsvrc13 model from ONNX to Mxnet") sym, arg_params, aux_params = onnx_mxnet.import_model(model_path) # run test for each test file for input_data, output_data in zip(inputs, outputs): # create module data_names = [graph_input for graph_input in sym.list_inputs() if graph_input not in arg_params and graph_input not in aux_params] mod = mx.mod.Module(symbol=sym, data_names=data_names, context=mx.cpu(), label_names=None) mod.bind(for_training=False, data_shapes=[(data_names[0], input_data.shape)], label_shapes=None) mod.set_params(arg_params=arg_params, aux_params=aux_params, allow_missing=True, allow_extra=True) # run inference batch = namedtuple('Batch', ['data']) mod.forward(batch([mx.nd.array(input_data)]), is_train=False) # verify the results npt.assert_equal(mod.get_outputs()[0].shape, output_data.shape) npt.assert_almost_equal(output_data, mod.get_outputs()[0].asnumpy(), decimal=3) logging.info("rcnn_ilsvrc13 model conversion Successful")
def test_convert_and_compare_prediction(self): # get data iterators and set basic hyperparams num_epochs = 10 mnist = mx.test_utils.get_mnist() batch_size = 1000 train_iter = mx.io.NDArrayIter(mnist['train_data'], mnist['train_label'], batch_size, shuffle=True) val_iter = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size) test_iter = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size) model_name = 'lenet5' model_file = '%s-symbol.json' % model_name params_file = '%s-%04d.params' % (model_name, num_epochs) onnx_file = "%s.onnx" % model_name test_gpu_id = 0 gpu_id = check_gpu_id(test_gpu_id) if not gpu_id: print("\nWARNING: GPU id %d is invalid on this machine" % test_gpu_id) gpu_id = None # If trained model exists, re-use cached version. Otherwise, train model. if not (os.path.exists(model_file) and os.path.exists(params_file)): print("\n\nTraining LeNet-5 on MNIST data") trained_lenet = train_lenet5(num_epochs, gpu_id, train_iter, val_iter, test_iter, batch_size) print("Training finished. Saving model") trained_lenet.save_checkpoint(model_name, num_epochs) # delete object so we can verify correct loading of the checkpoint from disk del trained_lenet else: print("\n\nTrained model exists. Skipping training.") # Load serialized MxNet model (model-symbol.json + model-epoch.params) trained_lenet = mx.mod.Module.load(model_name, num_epochs) trained_lenet.bind(data_shapes=test_iter.provide_data, label_shapes=None, for_training=False, force_rebind=True) # Run inference in MxNet from json/params serialized model test_iter = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size) pred_softmax = trained_lenet.predict(test_iter).asnumpy() pred_classes = np.argmax(pred_softmax, axis=1) # Create and save ONNX model print("\nConverting trained MxNet model to ONNX") model = from_mxnet(model_file, params_file, [1, 1, 28, 28], np.float32, log=True) with open(onnx_file, "wb") as f: serialized = model.SerializeToString() f.write(serialized) print("\nONNX file %s serialized to disk" % onnx_file) print( "\nLoading ONNX file and comparing results to original MxNet output." ) # ONNX load and inference step onnx_sym, onnx_arg_params, onnx_aux_params = import_model(onnx_file) onnx_mod = mx.mod.Module(symbol=onnx_sym, data_names=['data'], context=mx.cpu(), label_names=None) # Need to rename data argument from 'data' to 'input_0' because that's how # the MxNet ONNX importer expects it by default test_iter = mx.io.NDArrayIter(data={'data': mnist['test_data']}, label=None, batch_size=batch_size) onnx_mod.bind(data_shapes=test_iter.provide_data, label_shapes=None, for_training=False, force_rebind=True) onnx_mod.set_params(arg_params=onnx_arg_params, aux_params=onnx_aux_params, allow_missing=True) onnx_pred_softmax = onnx_mod.predict(test_iter).asnumpy() onnx_pred_classes = np.argmax(pred_softmax, axis=1) pred_matches = onnx_pred_classes == pred_classes pred_match_ct = pred_matches.sum() pred_total_ct = np.size(pred_matches) pct_match = 100.0 * pred_match_ct / pred_total_ct print( "\nOriginal MxNet predictions and ONNX-based predictions after export and re-import:" ) print("Total examples tested: %d" % pred_total_ct) print("Matches: %d" % pred_match_ct) print("Percent match: %.2f\n" % pct_match) assert pred_match_ct == pred_total_ct, "Not all predictions from the ONNX representation match"
import mxnet as mx import numpy as np import logging import pprint import mxnet.contrib.onnx as onnx_mxnet from model import Model from collections import namedtuple import sys import os import random import numpy as np logger = logging.getLogger() logger.setLevel(logging.DEBUG) sym, arg_params, aux_params = onnx_mxnet.import_model('test.onnx') word_to_ix = {"hello": 0, "world": 1} lookup_tensor = np.array([word_to_ix["hello"]]) print(sym) mx.viz.plot_network(sym, shape={"input_0": lookup_tensor.shape}, node_attrs={ "shape": 'oval', "fixedsize": 'false' })
# Convert an ONNX model to MXNet model import mxnet as mx from mxnet.contrib import onnx as onnx_mxnet import numpy as np import os curr_dir = os.path.dirname(__file__) # Import the ONNX model into MXNet's symbolic interface sym, arg, aux = onnx_mxnet.import_model(curr_dir + "/vgg16.onnx") print("Loaded vgg16.onnx!") print(sym.get_internals())
def convert_onnx_model(model_path, onnx_file, model_name): """ Util to convert onnx model to MXNet model :param model_name: :param model_path: :param onnx_file: :return: """ try: import mxnet as mx from mxnet.contrib import onnx as onnx_mxnet except ImportError: raise ModelArchiverError("MXNet package is not installed. Run command: pip install mxnet to install it.") try: import onnx except ImportError: raise ModelArchiverError("Onnx package is not installed. Run command: pip install onnx to install it.") symbol_file = '%s-symbol.json' % model_name params_file = '%s-0000.params' % model_name signature_file = 'signature.json' # Find input symbol name and shape try: model_proto = onnx.load(os.path.join(model_path, onnx_file)) except: logging.error("Failed to load the %s model. Verify if the model file is valid", onnx_file) raise graph = model_proto.graph _params = set() for tensor_vals in graph.initializer: _params.add(tensor_vals.name) input_data = [] for graph_input in graph.input: shape = [] if graph_input.name not in _params: for val in graph_input.type.tensor_type.shape.dim: shape.append(val.dim_value) input_data.append((graph_input.name, tuple(shape))) try: sym, arg_params, aux_params = onnx_mxnet.import_model(os.path.join(model_path, onnx_file)) # UNION of argument and auxillary parameters params = dict(arg_params, **aux_params) except: logging.error("Failed to import %s file to onnx. Verify if the model file is valid", onnx_file) raise try: # rewrite input data_name correctly with open(os.path.join(model_path, signature_file), 'r') as f: data = json.loads(f.read()) data['inputs'][0]['data_name'] = input_data[0][0] data['inputs'][0]['data_shape'] = [int(i) for i in input_data[0][1]] with open(os.path.join(model_path, signature_file), 'w') as f: f.write(json.dumps(data, indent=2)) with open(os.path.join(model_path, symbol_file), 'w') as f: f.write(sym.tojson()) except: logging.error("Failed to write the signature or symbol files for %s model", onnx_file) raise save_dict = {('arg:%s' % k): v.as_in_context(mx.cpu()) for k, v in params.items()} mx.nd.save(os.path.join(model_path, params_file), save_dict) return symbol_file, params_file
def load_net_params_mxnet(net, params_path): # Import the ONNX model into MXNet's symbolic interface sym, arg_params, aux_params = onnx_mxnet.import_model(params_path) print("Loaded torch_model.onnx!") net_params = net.collect_params() ctx = mx.gpu(0) for param in aux_params: temp = param param = 'resnetv10_' + param.replace('.', '_').replace( 'bias', 'beta').replace('bn', 'batchnorm') # .replace() if 'batchnorm' in param: param = param.replace( 'batchnorm' + param.split('batchnorm')[1][0], 'batchnorm' + str(int(param.split('batchnorm')[1][0]) - 1)) if 'layer' in param: param = param.replace('layer', 'stage') i, j = map(int, param.split('stage')[1].split('_')[:2]) if i < 2 and j == 1: t = 2 if i >= 2 and j == 1: t = 3 if j == 1: if 'batchnorm' in param: param = param.replace( 'batchnorm' + param.split('batchnorm')[1][0], 'batchnorm' + str(int(param.split('batchnorm')[1][0]) + t)) if 'downsample_1' in param: param = param.replace('downsample_1', 'batchnorm2') param = '_'.join(param.split('_%d_' % j)) net_params[param]._load_init(aux_params[temp], ctx=ctx) for param in arg_params: temp = param param = 'resnetv10_' + param.replace('.', '_').replace( 'bias', 'beta').replace('bn', 'batchnorm') #.replace() if 'conv' in param: param = param.replace( 'conv' + param.split('conv')[1][0], 'conv' + str(int(param.split('conv')[1][0]) - 1)) if 'batchnorm' in param: param = param.replace( 'batchnorm' + param.split('batchnorm')[1][0], 'batchnorm' + str(int(param.split('batchnorm')[1][0]) - 1)) param = param.replace('weight', 'gamma') if 'layer' in param: param = param.replace('layer', 'stage') i, j = map(int, param.split('stage')[1].split('_')[:2]) if i < 2 and j == 1: t = 2 if i >= 2 and j == 1: t = 3 if j == 1: if 'conv' in param: param = param.replace( 'conv' + param.split('conv')[1][0], 'conv' + str(int(param.split('conv')[1][0]) + t)) if 'batchnorm' in param: param = param.replace( 'batchnorm' + param.split('batchnorm')[1][0], 'batchnorm' + str(int(param.split('batchnorm')[1][0]) + t)) param = param.replace('weight', 'gamma') if 'downsample' in param: if 'downsample_0' in param: param = param.replace('downsample_0', 'conv2') if 'downsample_1' in param: if 'weight' in param: param = param.replace('downsample_1_weight', 'batchnorm2_gamma') if 'beta' in param: param = param.replace('downsample_1_beta', 'batchnorm2_beta') param = '_'.join(param.split('_%d_' % j)) if 'fc' in param: param = param.replace('fc_weight', 'dense0_weight').replace( 'fc_beta', 'dense0_bias') net_params[param]._load_init(arg_params[temp], ctx=ctx) net.hybridize() return net
'use_random_crop': False, 'use_mirror': False, 'ds_rate': 8, 'convert_label': True, 'multi_thread': False, 'cell_width': 2, 'random_bound': [120, 120], } val_dataloader = loader('val.lst', val_args) # ### Load ONNX model # In[5]: # import ONNX model into MXNet symbols and params sym, arg, aux = import_model(model_path) # define network module mod = mx.mod.Module(symbol=sym, data_names=['data'], context=ctx, label_names=None) # bind parameters to the network mod.bind(for_training=False, data_shapes=[('data', (batch_size, 3, 800, 800))], label_shapes=mod._label_shapes) mod.set_params(arg_params=arg, aux_params=aux, allow_missing=True, allow_extra=True) # ### Compute evaluations