def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
GluonBackendRep : object
Returns object of GluonBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
if device == 'CPU':
ctx = mx.cpu()
else:
raise NotImplementedError("ONNX tests are run only for CPU context.")
net = graph.graph_to_gluon(model.graph, ctx)
return GluonBackendRep(net, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
metadata = graph.get_graph_metadata(model.graph)
input_data = metadata['input_tensor_data']
input_shape = [data[1] for data in input_data]
sym, arg_params, aux_params = MXNetBackend.perform_import_export(model.graph, input_shape)
return MXNetBackendRep(sym, arg_params, aux_params, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
metadata = graph.get_graph_metadata(model.graph)
input_data = metadata['input_tensor_data']
input_shape = [data[1] for data in input_data]
sym, arg_params, aux_params = MXNetBackend.perform_import_export(model.graph, input_shape)
return MXNetBackendRep(sym, arg_params, aux_params, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
GluonBackendRep : object
Returns object of GluonBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
if device == 'CPU':
ctx = mx.cpu()
else:
raise NotImplementedError(
"ONNX tests are run only for CPU context.")
net = graph.graph_to_gluon(model.graph, ctx)
return GluonBackendRep(net, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
backend = kwargs.get('backend', cls.backend)
operation = kwargs.get('operation', cls.operation)
graph = GraphProto()
if device == 'CPU':
ctx = mx.cpu()
else:
raise NotImplementedError(
"ONNX tests are run only for CPU context.")
# determine opset version model uses
model_opset_version = max([x.version for x in model.opset_import])
if backend == 'mxnet':
sym, arg_params, aux_params = graph.from_onnx(
model.graph, model_opset_version)
if operation == 'export':
metadata = graph.get_graph_metadata(model.graph)
input_data = metadata['input_tensor_data']
input_shape = [data[1] for data in input_data]
sym, arg_params, aux_params = MXNetBackend.perform_import_export(
sym, arg_params, aux_params, input_shape)
return MXNetBackendRep(sym, arg_params, aux_params, device)
elif backend == 'gluon':
if operation == 'import':
net = graph.graph_to_gluon(model.graph, ctx,
model_opset_version)
return GluonBackendRep(net, device)
elif operation == 'export':
raise NotImplementedError(
"Gluon->ONNX export not implemented.")
def perform_import_export(sym, arg_params, aux_params, input_shape):
""" Import ONNX model to mxnet model and then export to ONNX model
and then import it back to mxnet for verifying the result"""
graph = GraphProto()
params = {}
params.update(arg_params)
params.update(aux_params)
# exporting to onnx graph proto format
converter = MXNetGraph()
graph_proto = converter.create_onnx_graph_proto(sym, params, in_shape=input_shape,
in_type=mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('float32')])
# importing back to MXNET for verifying result.
sym, arg_params, aux_params = graph.from_onnx(graph_proto)
return sym, arg_params, aux_params
def perform_import_export(graph_proto, input_shape):
""" Import ONNX model to mxnet model and then export to ONNX model
and then import it back to mxnet for verifying the result"""
graph = GraphProto()
sym, arg_params, aux_params = graph.from_onnx(graph_proto)
params = {}
params.update(arg_params)
params.update(aux_params)
# exporting to onnx graph proto format
converter = MXNetGraph()
graph_proto = converter.create_onnx_graph_proto(sym, params, in_shape=input_shape, in_type=mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('float32')])
# importing back to MXNET for verifying result.
sym, arg_params, aux_params = graph.from_onnx(graph_proto)
return sym, arg_params, aux_params
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
backend = kwargs.get('backend', cls.backend)
operation = kwargs.get('operation', cls.operation)
graph = GraphProto()
if device == 'CPU':
ctx = mx.cpu()
else:
raise NotImplementedError("ONNX tests are run only for CPU context.")
if backend == 'mxnet':
sym, arg_params, aux_params = graph.from_onnx(model.graph)
if operation == 'export':
metadata = graph.get_graph_metadata(model.graph)
input_data = metadata['input_tensor_data']
input_shape = [data[1] for data in input_data]
sym, arg_params, aux_params = MXNetBackend.perform_import_export(sym, arg_params, aux_params,
input_shape)
return MXNetBackendRep(sym, arg_params, aux_params, device)
elif backend == 'gluon':
if operation == 'import':
net = graph.graph_to_gluon(model.graph, ctx)
return GluonBackendRep(net, device)
elif operation == 'export':
raise NotImplementedError("Gluon->ONNX export not implemented.")
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
sym, arg_params, aux_params = graph.from_onnx(model.graph)
return MXNetBackendRep(sym, arg_params, aux_params, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
MXNetBackendRep : object
Returns object of MXNetBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
sym, arg_params, aux_params = graph.from_onnx(model.graph)
return MXNetBackendRep(sym, arg_params, aux_params, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
GluonBackendRep : object
Returns object of GluonBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
net = graph.graph_to_gluon(model.graph, device)
return GluonBackendRep(net, device)
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
Parameters
----------
model : onnx ModelProto object
loaded onnx graph
device : 'CPU'
specifying device to run test on
kwargs :
other arguments
Returns
-------
GluonBackendRep : object
Returns object of GluonBackendRep class which will be in turn
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
net = graph.graph_to_gluon(model.graph, device)
return GluonBackendRep(net, device)