You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by GitBox <gi...@apache.org> on 2018/03/23 22:14:12 UTC
[GitHub] anirudhacharya closed pull request #10216: [WIP] [DO NOT MERGE] Onnx Model Zoo tests
anirudhacharya closed pull request #10216: [WIP] [DO NOT MERGE] Onnx Model Zoo tests
URL: https://github.com/apache/incubator-mxnet/pull/10216
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/example/onnx/super_resolution.py b/example/onnx/super_resolution.py
index 1392b77715c..f7c7886d0df 100644
--- a/example/onnx/super_resolution.py
+++ b/example/onnx/super_resolution.py
@@ -37,9 +37,9 @@ def import_onnx():
download(model_url, 'super_resolution.onnx')
LOGGER.info("Converting onnx format to mxnet's symbol and params...")
- sym, params = onnx_mxnet.import_model('super_resolution.onnx')
+ 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, params
+ return sym, arg_params, aux_params
def get_test_image():
"""Download and process the test image"""
@@ -53,12 +53,12 @@ def get_test_image():
input_image = np.array(img_y)[np.newaxis, np.newaxis, :, :]
return input_image, img_cb, img_cr
-def perform_inference(sym, params, input_img, img_cb, img_cr):
+def perform_inference(sym, arg_params, aux_params, input_img, img_cb, img_cr):
"""Perform inference on image using mxnet"""
# create module
mod = mx.mod.Module(symbol=sym, data_names=['input_0'], label_names=None)
mod.bind(for_training=False, data_shapes=[('input_0', input_img.shape)])
- mod.set_params(arg_params=params, aux_params=None)
+ mod.set_params(arg_params=arg_params, aux_params=aux_params)
# run inference
batch = namedtuple('Batch', ['data'])
@@ -79,6 +79,6 @@ def perform_inference(sym, params, input_img, img_cb, img_cr):
return result_img
if __name__ == '__main__':
- MX_SYM, MX_PARAM = import_onnx()
+ MX_SYM, MX_ARG_PARAM, MX_AUX_PARAM = import_onnx()
INPUT_IMG, IMG_CB, IMG_CR = get_test_image()
- perform_inference(MX_SYM, MX_PARAM, INPUT_IMG, IMG_CB, IMG_CR)
+ perform_inference(MX_SYM, MX_ARG_PARAM, MX_AUX_PARAM, INPUT_IMG, IMG_CB, IMG_CR)
diff --git a/python/mxnet/contrib/onnx/_import/import_helper.py b/python/mxnet/contrib/onnx/_import/import_helper.py
index 80541ec3577..17e02937801 100644
--- a/python/mxnet/contrib/onnx/_import/import_helper.py
+++ b/python/mxnet/contrib/onnx/_import/import_helper.py
@@ -27,7 +27,7 @@
from .op_translations import global_avgpooling, global_maxpooling, linalg_gemm
from .op_translations import sigmoid, pad, relu, matrix_multiplication, batch_norm
from .op_translations import dropout, local_response_norm, conv, deconv
-from .op_translations import reshape, cast, split, _slice, transpose, squeeze
+from .op_translations import reshape, cast, split, _slice, transpose, squeeze, take, flatten
from .op_translations import reciprocal, squareroot, power, exponent, _log
from .op_translations import reduce_max, reduce_mean, reduce_min, reduce_sum
from .op_translations import reduce_prod, avg_pooling, max_pooling
@@ -83,6 +83,8 @@
'Slice' : _slice,
'Transpose' : transpose,
'Squeeze' : squeeze,
+ 'Gather' : take,
+ 'Flatten' : flatten,
#Powers
'Reciprocal' : reciprocal,
'Sqrt' : squareroot,
diff --git a/python/mxnet/contrib/onnx/_import/import_model.py b/python/mxnet/contrib/onnx/_import/import_model.py
index 1df429b4690..fa4a0bdffb0 100644
--- a/python/mxnet/contrib/onnx/_import/import_model.py
+++ b/python/mxnet/contrib/onnx/_import/import_model.py
@@ -23,16 +23,13 @@
def import_model(model_file):
"""Imports the ONNX model file passed as a parameter into MXNet symbol and parameters.
-
Parameters
----------
model_file : str
ONNX model file name
-
Returns
-------
Mxnet symbol and parameter objects.
-
sym : mxnet.symbol
Mxnet symbol
params : dict of str to mx.ndarray
@@ -46,5 +43,5 @@ def import_model(model_file):
except ImportError:
raise ImportError("Onnx and protobuf need to be installed")
model_proto = onnx.load(model_file)
- sym, params = graph.from_onnx(model_proto.graph)
- return sym, params
+ sym, arg_params, aux_params = graph.from_onnx(model_proto.graph)
+ return sym, arg_params, aux_params
diff --git a/python/mxnet/contrib/onnx/_import/import_onnx.py b/python/mxnet/contrib/onnx/_import/import_onnx.py
index 56181c777be..4adbdd35534 100644
--- a/python/mxnet/contrib/onnx/_import/import_onnx.py
+++ b/python/mxnet/contrib/onnx/_import/import_onnx.py
@@ -39,7 +39,6 @@ def _convert_operator(self, node_name, op_name, attrs, inputs):
"""Convert from onnx operator to mxnet operator.
The converter must specify conversions explicitly for incompatible name, and
apply handlers to operator attributes.
-
Parameters
----------
:param node_name : str
@@ -61,12 +60,12 @@ def _convert_operator(self, node_name, op_name, attrs, inputs):
raise NotImplementedError("Operator {} not implemented.".format(op_name))
if isinstance(op_name, string_types):
new_op = getattr(symbol, op_name, None)
+ if not new_op:
+ raise RuntimeError("Unable to map op_name {} to sym".format(op_name))
if node_name is None:
mxnet_sym = new_op(*inputs, **new_attrs)
else:
mxnet_sym = new_op(name=node_name, *inputs, **new_attrs)
- if not mxnet_sym:
- raise RuntimeError("Unable to map op_name {} to sym".format(op_name))
return mxnet_sym
return op_name
@@ -75,12 +74,10 @@ def from_onnx(self, graph):
The inputs from onnx graph is vague, only providing "1", "2"...
For convenience, we rename the `real` input names to "input_0",
"input_1"... And renaming parameters to "param_0", "param_1"...
-
Parameters
----------
graph : onnx protobuf object
The loaded onnx graph
-
Returns
-------
sym :symbol.Symbol
@@ -110,6 +107,10 @@ def from_onnx(self, graph):
self._nodes[name_input] = symbol.Variable(name=name_input)
self._renames[i.name] = name_input
+ # For storing arg and aux params for the graph.
+ auxDict = {}
+ argDict = {}
+
# constructing nodes, nodes are stored as directed acyclic graph
# converting NodeProto message
for node in graph.node:
@@ -120,19 +121,24 @@ def from_onnx(self, graph):
inputs = [self._nodes[self._renames.get(i, i)] for i in node.input]
mxnet_sym = self._convert_operator(node_name, op_name, onnx_attr, inputs)
- assert len(node.output) == len(mxnet_sym.list_outputs()), (
- "Output dimension mismatch between the onnx operator and the mxnet symbol " +
- "{} vs {} for the operator - {}.".format(
- len(node.output), len(mxnet_sym.list_outputs()), op_name))
- for k, i in zip(list(node.output), range(len(node.output))):
+ for k, i in zip(list(node.output), range(len(mxnet_sym.list_outputs()))):
self._nodes[k] = mxnet_sym[i]
+
+ # splitting params into args and aux params
+ for args in mxnet_sym.list_arguments():
+ if args in self._params:
+ argDict.update({args: nd.array(self._params[args])})
+ for aux in mxnet_sym.list_auxiliary_states():
+ if aux in self._params:
+ auxDict.update({aux: nd.array(self._params[aux])})
+
# now return the outputs
out = [self._nodes[i.name] for i in graph.output]
if len(out) > 1:
out = symbol.Group(out)
else:
out = out[0]
- return out, self._params
+ return out, argDict, auxDict
def _parse_array(self, tensor_proto):
"""Grab data in TensorProto and convert to numpy array."""
diff --git a/python/mxnet/contrib/onnx/_import/op_translations.py b/python/mxnet/contrib/onnx/_import/op_translations.py
index a67c18199eb..b69eadaad5d 100644
--- a/python/mxnet/contrib/onnx/_import/op_translations.py
+++ b/python/mxnet/contrib/onnx/_import/op_translations.py
@@ -164,10 +164,14 @@ def matrix_multiplication(attrs, inputs, cls):
def batch_norm(attrs, inputs, cls):
"""Batch normalization."""
- new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps'})
+ new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps',
+ 'is_test':'fix_gamma'})
new_attrs = translation_utils._remove_attributes(new_attrs,
- ['spatial', 'is_test', 'consumed_inputs'])
+ ['spatial', 'consumed_inputs'])
new_attrs = translation_utils._add_extra_attributes(new_attrs, {'cudnn_off': 1})
+
+ # in test mode "fix_gamma" should be unset.
+ new_attrs['fix_gamma'] = 0 if new_attrs['fix_gamma'] == 1 else 1
return 'BatchNorm', new_attrs, inputs
@@ -245,7 +249,7 @@ def global_maxpooling(attrs, inputs, cls):
new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,
'kernel': (1, 1),
'pool_type': 'max'})
- return 'pooling', new_attrs, inputs
+ return 'Pooling', new_attrs, inputs
def global_avgpooling(attrs, inputs, cls):
@@ -253,28 +257,49 @@ def global_avgpooling(attrs, inputs, cls):
new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,
'kernel': (1, 1),
'pool_type': 'avg'})
- return 'pooling', new_attrs, inputs
+ return 'Pooling', new_attrs, inputs
def linalg_gemm(attrs, inputs, cls):
"""Performs general matrix multiplication and accumulation"""
+ trans_a = 0
+ trans_b = 0
+ alpha = 1
+ beta = 1
+ if 'transA' in attrs:
+ trans_a = attrs['transA']
+ if 'transB' in attrs:
+ trans_b = attrs['transB']
+ if 'alpha' in attrs:
+ alpha = attrs['alpha']
+ if 'beta' in attrs:
+ beta = attrs['beta']
+ flatten_a = symbol.flatten(inputs[0])
+ matmul_op = symbol.linalg_gemm2(A=flatten_a, B=inputs[1],
+ transpose_a=trans_a, transpose_b=trans_b,
+ alpha=alpha)
+ gemm_op = symbol.broadcast_add(matmul_op, beta*inputs[2])
new_attrs = translation_utils._fix_attribute_names(attrs, {'transA': 'transpose_a',
'transB': 'transpose_b'})
new_attrs = translation_utils._remove_attributes(new_attrs, ['broadcast'])
- return translation_utils._fix_gemm('FullyConnected', inputs, new_attrs, cls)
+ return gemm_op, new_attrs, inputs
-def local_response_norm(op_name, attrs, inputs):
+def local_response_norm(attrs, inputs, cls):
"""Local Response Normalization."""
new_attrs = translation_utils._fix_attribute_names(attrs,
{'bias': 'knorm',
'size' : 'nsize'})
return 'LRN', new_attrs, inputs
-def dropout(op_name, attrs, inputs):
+def dropout(attrs, inputs, cls):
"""Dropout Regularization."""
+ mode = 'training'
+ if attrs['is_test'] == 0:
+ mode = 'always'
new_attrs = translation_utils._fix_attribute_names(attrs,
{'ratio': 'p'})
new_attrs = translation_utils._remove_attributes(new_attrs, ['is_test'])
+ new_attrs = translation_utils._add_extra_attributes(new_attrs, {'mode': mode})
return 'Dropout', new_attrs, inputs
# Changing shape and type.
@@ -328,6 +353,17 @@ def squeeze(attrs, inputs, cls):
mxnet_op = symbol.split(mxnet_op, axis=i-1, num_outputs=1, squeeze_axis=1)
return mxnet_op, new_attrs, inputs
+def take(attrs, inputs, cls):
+ """ Takes elements from an input array along the given axis.
+ Currently only slicing along axis 0 is supported for now."""
+ return 'take', attrs, inputs
+
+def flatten(attrs, inputs, cls):
+ """Flattens the input array into a 2-D array by collapsing the higher dimensions."""
+ #Mxnet does not have axis support.
+ new_attrs = translation_utils._remove_attributes(attrs, ['axis'])
+ return 'Flatten', new_attrs, inputs
+
#Powers
def reciprocal(attrs, inputs, cls):
"""Returns the reciprocal of the argument, element-wise."""
@@ -387,8 +423,7 @@ def avg_pooling(attrs, inputs, cls):
'pads': 'pad',
})
new_attrs = translation_utils._add_extra_attributes(new_attrs,
- {'pool_type': 'avg',
- 'pooling_convention': 'valid'
+ {'pooling_convention': 'valid'
})
new_op = translation_utils._fix_pooling('avg', inputs, new_attrs)
@@ -403,8 +438,7 @@ def max_pooling(attrs, inputs, cls):
'pads': 'pad',
})
new_attrs = translation_utils._add_extra_attributes(new_attrs,
- {'pool_type': 'avg',
- 'pooling_convention': 'valid'
+ {'pooling_convention': 'valid'
})
new_op = translation_utils._fix_pooling('max', inputs, new_attrs)
diff --git a/python/mxnet/contrib/onnx/_import/translation_utils.py b/python/mxnet/contrib/onnx/_import/translation_utils.py
index 0fdef647b50..ce7a5dd5d02 100644
--- a/python/mxnet/contrib/onnx/_import/translation_utils.py
+++ b/python/mxnet/contrib/onnx/_import/translation_utils.py
@@ -29,7 +29,6 @@ def _fix_attribute_names(attrs, change_map):
----------
:param attrs : dict Dict of operator attributes
:param change_map : dict Dict of onnx attribute name to mxnet attribute names.
-
Returns
-------
:return new_attr : dict Converted dict of operator attributes.
@@ -47,7 +46,6 @@ def _remove_attributes(attrs, remove_list):
Removes attributes in the remove list from the input attribute dict
:param attrs : Dict of operator attributes
:param remove_list : list of attributes to be removed
-
:return new_attr : Dict of operator attributes without the listed attributes.
"""
new_attrs = {}
@@ -90,10 +88,46 @@ def _fix_pooling(pool_type, inputs, new_attr):
stride = new_attr.get('stride')
kernel = new_attr.get('kernel')
padding = new_attr.get('pad')
- pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, len(kernel))
- new_pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)
- new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type,
- stride=stride, kernel=kernel)
+
+ # Adding default stride.
+ if stride is None:
+ stride = (1,) * len(kernel)
+
+ # Add padding attr if not provided.
+ if padding is None:
+ padding = (0,) * len(kernel) * 2
+
+ # Mxnet Pad operator supports only 4D/5D tensors.
+ # For 1D case, these are the steps:
+ # Step 1. Add extra dummy dimension to make it 4D. Adding to axis = 2
+ # Step 2. Apply padding to this changed tensor
+ # Step 3. Remove the extra dimension added in step 1.
+ if len(kernel) == 1:
+ dummy_axis = 2
+ # setting 0 padding to the new dim to be added.
+ padding = (0, padding[0], 0, padding[1])
+ pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=2)
+
+ # Step 1.
+ curr_sym = symbol.expand_dims(inputs[0], axis=dummy_axis)
+
+ # Step 2. Common for all tensor sizes
+ new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
+
+ # Step 3: Removing extra dim added.
+ new_pad_op = symbol.split(new_pad_op, axis=dummy_axis, num_outputs=1, squeeze_axis=1)
+ else:
+ # For 2D/3D cases:
+ # Apply padding
+ pad_width = (0, 0, 0, 0) + _pad_sequence_fix(padding, kernel_dim=len(kernel))
+ curr_sym = inputs[0]
+ if pool_type == 'max':
+ new_pad_op = symbol.pad(curr_sym, mode='edge', pad_width=pad_width)
+ else:
+ new_pad_op = symbol.pad(curr_sym, mode='constant', pad_width=pad_width)
+
+ # Apply pooling without pads.
+ new_pooling_op = symbol.Pooling(new_pad_op, pool_type=pool_type, stride=stride, kernel=kernel)
return new_pooling_op
def _fix_bias(op_name, attrs, num_inputs):
diff --git a/tests/python-pytest/onnx/backend.py b/tests/python-pytest/onnx/backend.py
index 3b99563bccf..452915604a9 100644
--- a/tests/python-pytest/onnx/backend.py
+++ b/tests/python-pytest/onnx/backend.py
@@ -78,7 +78,6 @@ def make_graph(node, inputs):
def run_node(cls, node, inputs, device='CPU'):
"""Running individual node inference on mxnet engine and
return the result to onnx test infrastructure.
-
Parameters
----------
node : onnx node object
@@ -87,19 +86,19 @@ def run_node(cls, node, inputs, device='CPU'):
input to run a node on
device : 'CPU'
device to run a node on
-
Returns
-------
params : numpy array
result obtained after running the operator
"""
graph = GraphProto()
- sym, _ = graph.from_onnx(MXNetBackend.make_graph(node, inputs))
- data_names = [i for i in sym.get_internals().list_inputs()]
+ sym, arg_params, aux_params = graph.from_onnx(MXNetBackend.make_graph(node, inputs))
+ data_names = [i for i in sym.list_inputs() if i not in (arg_params, aux_params)]
data_shapes = []
dim_change_op_types = set(['ReduceMin', 'ReduceMax', 'ReduceMean',
'ReduceProd', 'ReduceSum', 'Slice', 'Pad',
- 'Squeeze', 'Upsample', 'Reshape', 'Conv'])
+ 'Squeeze', 'Upsample', 'Reshape', 'Conv',
+ 'Concat', 'Softmax', 'Flatten', 'Transpose'])
# Adding extra dimension of batch_size 1 if the batch_size is different for multiple inputs.
for idx, input_name in enumerate(data_names):
@@ -123,7 +122,10 @@ def run_node(cls, node, inputs, device='CPU'):
mod.bind(for_training=False, data_shapes=data_shapes, label_shapes=None)
# initializing parameters for calculating result of each individual node
- mod.init_params()
+ if arg_params is None or aux_params is None:
+ mod.init_params()
+ else:
+ mod.set_params(arg_params=arg_params, aux_params=aux_params)
data_forward = []
for idx, input_name in enumerate(data_names):
@@ -145,7 +147,6 @@ def run_node(cls, node, inputs, device='CPU'):
@classmethod
def prepare(cls, model, device='CPU', **kwargs):
"""For running end to end model(used for onnx test backend)
-
Parameters
----------
model : onnx ModelProto object
@@ -154,7 +155,6 @@ def prepare(cls, model, device='CPU', **kwargs):
specifying device to run test on
kwargs :
other arguments
-
Returns
-------
MXNetBackendRep : object
@@ -162,8 +162,8 @@ def prepare(cls, model, device='CPU', **kwargs):
used to run inference on the input model and return the result for comparison.
"""
graph = GraphProto()
- sym, params = graph.from_onnx(model.graph)
- return MXNetBackendRep(sym, params, device)
+ sym, arg_params, aux_params = graph.from_onnx(model.graph)
+ return MXNetBackendRep(sym, arg_params, aux_params, device)
@classmethod
def supports_device(cls, device):
diff --git a/tests/python-pytest/onnx/backend_rep.py b/tests/python-pytest/onnx/backend_rep.py
index a125086bce2..d666a8deb8d 100644
--- a/tests/python-pytest/onnx/backend_rep.py
+++ b/tests/python-pytest/onnx/backend_rep.py
@@ -37,19 +37,18 @@
class MXNetBackendRep(BackendRep):
"""Running model inference on mxnet engine and return the result
to onnx test infrastructure for comparison."""
- def __init__(self, symbol, params, device):
+ def __init__(self, symbol, arg_params, aux_params, device):
self.symbol = symbol
- self.params = params
+ self.arg_params = arg_params
+ self.aux_params = aux_params
self.device = device
def run(self, inputs, **kwargs):
"""Run model inference and return the result
-
Parameters
----------
inputs : numpy array
input to run a layer on
-
Returns
-------
params : numpy array
@@ -67,7 +66,7 @@ def run(self, inputs, **kwargs):
label_names=None)
mod.bind(for_training=False, data_shapes=[('input_0', input_data.shape)],
label_shapes=None)
- mod.set_params(arg_params=self.params, aux_params=None)
+ mod.set_params(arg_params=self.arg_params, aux_params=self.aux_params)
# run inference
batch = namedtuple('Batch', ['data'])
diff --git a/tests/python-pytest/onnx/onnx_backend_test.py b/tests/python-pytest/onnx/onnx_backend_test.py
index 28e2aaefcdd..f5c52b0a755 100644
--- a/tests/python-pytest/onnx/onnx_backend_test.py
+++ b/tests/python-pytest/onnx/onnx_backend_test.py
@@ -34,7 +34,7 @@
BACKEND_TEST = onnx.backend.test.BackendTest(mxnet_backend, __name__)
-IMPLEMENTED_OPERATORS = [
+IMPLEMENTED_OPERATORS_TEST = [
#Generator Functions
#'test_constant*', # Identity Function
#'test_random_uniform',
@@ -57,28 +57,29 @@
'test_floor',
## Joining and spliting
- #'test_concat.*', #---Failing test
+ 'test_concat',
#Basic neural network functions
'test_sigmoid',
'test_relu',
- #'test_constant_pad',
- #'test_edge_pad',
- #'test_reflect_pad',
+ 'test_constant_pad',
+ 'test_edge_pad',
+ 'test_reflect_pad',
'test_matmul',
'test_leakyrelu',
'test_elu',
- #'test_softmax*',
+ 'test_softmax_example',
+ 'test_softmax_large_number',
+ 'test_softmax_axis_2',
'test_conv',
'test_basic_conv',
- #'test_globalmaxpool',
- #'test_globalaveragepool',
- #'test_batch_norm',
+ #'test_globalmaxpool', - tests to be added
+ #'test_globalaveragepool', - tests to be added
+ #'test_batch_norm', - tests to be added
+ #'test_gather',
#Changing shape and type.
'test_reshape_',
- #'test_AvgPool2D*',
- #'test_MaxPool2D*',
#'test_cast',
#'test_split',
'test_slice_cpu',
@@ -86,8 +87,9 @@
'test_slice_neg',
#'test_slice_start_out_of_bounds',
#'test_slice_end_out_of_bounds',
- #'test_transpose*',
+ 'test_transpose',
'test_squeeze_',
+ 'test_flatten_default',
#Powers
'test_reciprocal',
@@ -103,12 +105,62 @@
'test_argmax',
'test_argmin',
'test_max',
- 'test_min'
+ 'test_min',
+
+ #pytorch operator tests
+ #'test_operator_chunk',
+ #'test_operator_clip',
+ 'test_operator_conv',
+ #'test_operator_equal',
+ 'test_operator_exp',
+ #'test_operator_flatten',
+ #'test_operator_max',
+ 'test_operator_maxpool',
+ 'test_operator_non_float_params',
+ 'test_operator_params',
+ 'test_operator_permute2',
+ #'test_operator_transpose',
+ #'test_operator_view'
]
-for op_test in IMPLEMENTED_OPERATORS:
+BASIC_MODEL_TESTS = [
+ 'test_AvgPool2D',
+ 'test_BatchNorm',
+ 'test_ConstantPad2d'
+ 'test_Conv2d',
+ 'test_ELU',
+ 'test_LeakyReLU',
+ 'test_MaxPool',
+ 'test_PReLU',
+ 'test_ReLU',
+ 'test_Sigmoid',
+ 'test_Softmax',
+ 'test_softmax_functional',
+ 'test_softmax_lastdim',
+ 'test_Tanh'
+ ]
+
+STANDARD_MODEL = [
+ 'test_bvlc_alexnet',
+ 'test_densenet121',
+ #'test_inception_v1',
+ #'test_inception_v2',
+ 'test_resnet50',
+ #'test_shufflenet',
+ 'test_squeezenet',
+ 'test_vgg16',
+ 'test_vgg19'
+ ]
+
+for op_test in IMPLEMENTED_OPERATORS_TEST:
BACKEND_TEST.include(op_test)
+for std_model_test in STANDARD_MODEL:
+ BACKEND_TEST.include(std_model_test)
+
+for basic_model_test in BASIC_MODEL_TESTS:
+ BACKEND_TEST.include(basic_model_test)
+
# import all test cases at global scope to make them visible to python.unittest
globals().update(BACKEND_TEST.enable_report().test_cases)
diff --git a/tests/python-pytest/onnx/onnx_test.py b/tests/python-pytest/onnx/onnx_test.py
index 016490a4c4b..ec0b76658fc 100644
--- a/tests/python-pytest/onnx/onnx_test.py
+++ b/tests/python-pytest/onnx/onnx_test.py
@@ -93,9 +93,9 @@ def test_super_resolution_example():
sys.path.insert(0, os.path.join(CURR_PATH, '../../../example/onnx/'))
import super_resolution
- sym, params = super_resolution.import_onnx()
+ sym, arg_params, aux_params = super_resolution.import_onnx()
assert sym is not None
- assert params is not None
+ assert arg_params is not None
inputs = sym.list_inputs()
assert len(inputs) == 9
@@ -116,7 +116,7 @@ def test_super_resolution_example():
'transpose0']):
assert key_item in attrs_keys
- param_keys = params.keys()
+ param_keys = arg_params.keys()
assert len(param_keys) == 8
for i, param_item in enumerate(['param_5', 'param_4', 'param_7', 'param_6',
'param_1', 'param_0', 'param_3', 'param_2']):
@@ -126,8 +126,8 @@ def test_super_resolution_example():
output_img_dim = 672
input_image, img_cb, img_cr = super_resolution.get_test_image()
- result_img = super_resolution.perform_inference(sym, params, input_image,
- img_cb, img_cr)
+ result_img = super_resolution.perform_inference(sym, arg_params, aux_params,
+ input_image, img_cb, img_cr)
assert hashlib.md5(result_img.tobytes()).hexdigest() == '0d98393a49b1d9942106a2ed89d1e854'
assert result_img.size == (output_img_dim, output_img_dim)
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services