def test_compress(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest( "ONNX version {} doesn't support Compress.".format( defs.onnx_opset_version())) axis = 1 node_def = helper.make_node( "Compress", inputs=['X', 'condition'], outputs=['Y'], axis=axis) x = self._get_rnd([5, 5, 5]) cond = np.array([1, 0, 1]) output = run_node(node_def, inputs=[x, cond]) np.testing.assert_almost_equal(output['Y'], np.compress(cond, x, axis=axis))
def test_shrink(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest( "ONNX version {} doesn't support Shrink.".format( defs.onnx_opset_version())) node_def = helper.make_node("Shrink", ["X"], ["Y"], bias=1.5, lambd=1.5) X = np.arange(-2.0, 2.1, dtype=np.float32) Y = np.array([-0.5, 0, 0, 0, 0.5], dtype=np.float32) output = run_node(node_def, [X]) np.testing.assert_almost_equal(output["Y"], Y)
def test_mod(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest("ONNX version {} doesn't support Mod.".format( defs.onnx_opset_version())) x = self._get_rnd([5, 5]) y = self._get_rnd([5, 5]) node_def = helper.make_node("Mod", ["X", "Y"], ["Z"], fmod=0) output = run_node(node_def, [x, y]) np.testing.assert_almost_equal(output["Z"], np.mod(x, y)) node_def = helper.make_node("Mod", ["X", "Y"], ["Z"], fmod=1) output = run_node(node_def, [x, y]) np.testing.assert_almost_equal(output["Z"], np.fmod(x, y))
def test_eye_like(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest("ONNX version {} doesn't support EyeLike.".format( defs.onnx_opset_version())) for shape in [[6, 10], [10, 6]]: for off_diagonal_offset in [-10, -6, -3, 0, 3, 6, 7, 10]: node_def = helper.make_node( "EyeLike", ['x'], ['y'], dtype=1, k=off_diagonal_offset) x = np.random.randint(0, 100, size=shape, dtype=np.int32) y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32) output = run_node(node_def, [x]) np.testing.assert_equal(output['y'], y)
def test_cast(self): if legacy_onnx_pre_ver(1, 2) or legacy_opset_pre_ver(6): test_cases = [("FLOAT", tf.float32), ("UINT8", tf.uint8), ("INT8", tf.int8), ("UINT16", tf.uint16), ("INT16", tf.int16), ("INT32", tf.int32), ("INT64", tf.int64), ("BOOL", tf.bool), ("FLOAT16", tf.float16), ("DOUBLE", tf.float64), ("COMPLEX64", tf.complex64), ("COMPLEX128", tf.complex128)] else: test_cases = [(TensorProto.FLOAT, tf.float32), (TensorProto.UINT8, tf.uint8), (TensorProto.INT8, tf.int8), (TensorProto.UINT16, tf.uint16), (TensorProto.INT16, tf.int16), (TensorProto.INT32, tf.int32), (TensorProto.INT64, tf.int64), (TensorProto.BOOL, tf.bool), (TensorProto.FLOAT16, tf.float16), (TensorProto.DOUBLE, tf.float64), (TensorProto.COMPLEX64, tf.complex64), (TensorProto.COMPLEX128, tf.complex128)] if not legacy_opset_pre_ver(9): test_cases.append((TensorProto.STRING, tf.string)) for ty, tf_type in test_cases: node_def = helper.make_node("Cast", ["input"], ["output"], to=ty) vector = [2, 3] output = run_node(node_def, [vector]) np.testing.assert_equal(output["output"].dtype, tf_type) if not legacy_opset_pre_ver(9): test_cases2 = [(TensorProto.FLOAT, tf.float32), (TensorProto.INT32, tf.int32), (TensorProto.INT64, tf.int64), (TensorProto.DOUBLE, tf.float64)] for ty, tf_type in test_cases2: node_def = helper.make_node("Cast", ["input"], ["output"], to=ty) vector = ['2', '3'] output = run_node(node_def, [vector]) np.testing.assert_equal(output["output"].dtype, tf_type)
def test_non_max_suppression(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest( "ONNX version {} doesn't support NonMaxSuppression.".format( defs.onnx_opset_version())) boxes = np.array([[[0.0, 0.0, 1.0, 1.0], [0.0, 0.1, 1.0, 1.1], [0.0, -0.1, 1.0, 0.9], [0.0, 10.0, 1.0, 11.0], [0.0, 10.1, 1.0, 11.1], [0.0, 100.0, 1.0, 101.0]], [[0.0, 0.0, 1.0, 1.0], [0.0, 0.1, 1.0, 1.1], [0.0, -0.1, 1.0, 0.9], [0.0, 10.0, 1.0, 11.0], [0.0, 10.1, 1.0, 11.1], [0.0, 100.0, 1.0, 101.0]]]).astype(np.float32) scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]], [[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) max_output_boxes_per_class = np.array([2]).astype(np.int64) iou_threshold = np.array([0.5]).astype(np.float32) score_threshold = np.array([0.0]).astype(np.float32) selected_indices = np.array([[0, 0, 3], [0, 0, 0], [1, 0, 3], [1, 0, 0]]).astype(np.int64) node_def = helper.make_node("NonMaxSuppression", [ "boxes", "scores", "max_output_boxes_per_class", "iou_threshold", "score_threshold" ], ["selected_indices"], center_point_box=0) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("boxes", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("scores", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("max_output_boxes_per_class", TensorProto.INT64, [None]), helper.make_tensor_value_info("iou_threshold", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("score_threshold", TensorProto.FLOAT, [None]) ], outputs=[ helper.make_tensor_value_info("selected_indices", TensorProto.INT64, [None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({ "boxes": boxes, "scores": scores, "max_output_boxes_per_class": max_output_boxes_per_class, "iou_threshold": iou_threshold, "score_threshold": score_threshold }) np.testing.assert_almost_equal(output["selected_indices"], selected_indices)
def test_topk(self): x = np.arange(15, dtype=np.float32).reshape(3, 5) values = np.array([[4, 3], [9, 8], [14, 13]], dtype=np.float32) indices = np.array([[4, 3],[4, 3],[4, 3]], dtype=np.int64) if legacy_opset_pre_ver(10): # for opset = 1 node_def = helper.make_node("TopK", ["x"], ["values", "indices"], k=2) output = run_node(node_def, [x]) elif legacy_opset_pre_ver(11): # for opset = 10 k = np.array([2], dtype=np.int64) node_def = helper.make_node("TopK", ["x", "k"], ["values", "indices"]) output = run_node(node_def, [x, k]) else: # for opset = 11 x = np.array([[3, 2, 5, 10, 7], [12, 15, 10, 7, 20], [21, 16, 5, 3, 6]], dtype=np.float32) values = np.array([[3, 2], [10, 7], [5, 3]], dtype=np.float32) indices = np.array([[0, 1], [2, 3], [2, 3]], dtype=np.int64) k = np.array([2], dtype=np.int64) node_def = helper.make_node( "TopK", ["x", "k"], ["values", "indices"], largest=0, sorted=0) output = run_node(node_def, [x, k]) np.testing.assert_almost_equal(output["values"], values) np.testing.assert_almost_equal(output["indices"], indices)
def test_dropout(self): # Since current ONNX only support inference and # dropout at inference mode is a no-op, # therefore dropout is always a no-op operator # in ONNX. node_def = helper.make_node("Dropout", ["X"], ["Y"]) if legacy_opset_pre_ver(7): # at inference mode, is_test is always set to 1 node_def = helper.make_node("Dropout", ["X"], ["Y"], is_test=1) x = self._get_rnd([3, 4, 5]) y = x output = run_node(node_def, [x]) np.testing.assert_equal(output["Y"], y)
def test_max_pool_with_argmax_2d_dilations_ceil_pads(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest( "ONNX version {} doesn't support dilations nor ceil mode.".format( defs.onnx_opset_version())) kernel_shape = [3, 3] strides = [2, 2] dilations = [3, 3] pads = [1, 1, 2, 2] ceil_mode = True input_shape = [10, 3, 23, 23] x = self._get_rnd_float32(shape=input_shape) - 2 node_def = helper.make_node("MaxPool", ["X"], ["Y", "Ind"], kernel_shape=kernel_shape, strides=strides, dilations=dilations, pads=pads, ceil_mode=ceil_mode) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None]), ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None]), helper.make_tensor_value_info("Ind", TensorProto.INT64, [None, None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({"X": x}) test_output, test_ind = py_pool(x, kernel_shape=kernel_shape, strides=strides, dilations=dilations, padding=pads, ceil_mode=ceil_mode, pooling_type="MAX") np.testing.assert_almost_equal(output["Y"], test_output) np.testing.assert_almost_equal(output["Ind"], test_ind)
def test_onehot(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest("ONNX version {} doesn't support OneHot.".format( defs.onnx_opset_version())) indices = np.array([[0, 2], [1, 2], [0, 1]]) depth = np.array([5], dtype=np.int32) on_value = 6.0 off_value = 2.0 values = np.array([off_value, on_value]) node_def = helper.make_node( 'OneHot', inputs=['indices', 'depth', 'values'], outputs=['y'], axis=-1) y = (np.arange(depth) == indices[..., None]).astype(int) y = y * (on_value - off_value) + off_value output = run_node(node_def, inputs=[indices, depth, values]) np.testing.assert_equal(output['y'], y)
def test_topk(self): x = np.arange(15, dtype=np.float32).reshape(3, 5) values = np.array([[4, 3], [9, 8], [14, 13]], dtype=np.float32) indices = np.array([[4, 3], [4, 3], [4, 3]], dtype=np.int64) if legacy_opset_pre_ver(10): # for opset = 1 node_def = helper.make_node("TopK", ["x"], ["values", "indices"], k=2) output = run_node(node_def, [x]) else: # for opset = 10 k = np.array([2], dtype=np.int64) node_def = helper.make_node("TopK", ["x", "k"], ["values", "indices"]) output = run_node(node_def, [x, k]) np.testing.assert_almost_equal(output["values"], values) np.testing.assert_almost_equal(output["indices"], indices)
def test_mean_variance_normalization(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest( "ONNX version {} doesn't have test for MeanVarianceNormalization" .format(defs.onnx_opset_version())) input_data = self._get_rnd([2,2,2,2]) # Calculate expected output data using formula: # (Input - Mean)/SD mean = np.mean(input_data, keepdims=1, axis=(0,2,3)) std = np.std(input_data, keepdims=1, axis=(0,2,3)) expected_output = (input_data - mean) / std # Testing without "axes" argument should default to axes=[0,2,3] node_def = helper.make_node("MeanVarianceNormalization", ["X"], ["Y"]) output = run_node(node_def, [input_data]) np.testing.assert_almost_equal(output["Y"], expected_output, decimal=5)
def test_batch_normalization(self): if legacy_opset_pre_ver(6): raise unittest.SkipTest("Backend doesn't support consumed flag") node_def = helper.make_node("BatchNormalization", ["X", "scale", "bias", "mean", "var"], ["Y"], epsilon=0.001) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None]), helper.make_tensor_value_info("scale", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("bias", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("mean", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("var", TensorProto.FLOAT, [None]) ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None]) ]) x_shape = [3, 5, 4, 2] param_shape = [5] _param_shape = [1, 5, 1, 1] x = self._get_rnd_float32(0, 1, shape=x_shape) m = self._get_rnd_float32(0, 1, shape=param_shape) _m = m.reshape(_param_shape) v = self._get_rnd_float32(0, 1, shape=param_shape) _v = v.reshape(_param_shape) scale = self._get_rnd_float32(0, 1, shape=param_shape) _scale = scale.reshape(_param_shape) bias = self._get_rnd_float32(0, 1, shape=param_shape) _bias = bias.reshape(_param_shape) golden = self._batch_normalization(x, _m, _v, _bias, _scale, 0.001) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) # export to tf.saved_model model_path = 'test_dynamic_shape/batch_normalization' tf_rep.export_graph(model_path) # load the saved_model back tf_model = tf.saved_model.load(model_path) # run the model tf_model_output = tf_model(X=x, scale=scale, bias=bias, mean=m, var=v) np.testing.assert_almost_equal(tf_model_output[0], golden, decimal=5)
def test_batch_normalization(self): if legacy_opset_pre_ver(6): raise unittest.SkipTest("Backend doesn't support consumed flag") node_def = helper.make_node("BatchNormalization", ["X", "scale", "bias", "mean", "var"], ["Y"], epsilon=0.001) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None]), helper.make_tensor_value_info("scale", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("bias", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("mean", TensorProto.FLOAT, [None]), helper.make_tensor_value_info("var", TensorProto.FLOAT, [None]) ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None]) ]) x_shape = [3, 5, 4, 2] param_shape = [5] _param_shape = [1, 5, 1, 1] x = self._get_rnd_float32(0, 1, shape=x_shape) m = self._get_rnd_float32(0, 1, shape=param_shape) _m = m.reshape(_param_shape) v = self._get_rnd_float32(0, 1, shape=param_shape) _v = v.reshape(_param_shape) scale = self._get_rnd_float32(0, 1, shape=param_shape) _scale = scale.reshape(_param_shape) bias = self._get_rnd_float32(0, 1, shape=param_shape) _bias = bias.reshape(_param_shape) golden = self._batch_normalization(x, _m, _v, _bias, _scale, 0.001) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({ "X": x, "scale": scale, "bias": bias, "mean": m, "var": v }) np.testing.assert_almost_equal(output["Y"], golden, decimal=5)
def test_is_inf(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest("ONNX version {} doesn't support IsInf.".format( defs.onnx_opset_version())) inp = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float32) expected_output = np.isinf(inp) node_def = helper.make_node("IsInf", ["X"], ["Y"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None]), ], outputs=[helper.make_tensor_value_info("Y", TensorProto.BOOL, [None])]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({"X": inp}) np.testing.assert_equal(output["Y"], expected_output)
def test_scatter_nd(self): if legacy_opset_pre_ver(11): raise unittest.SkipTest( "ONNX version {} doesn't support ScatterND.".format( defs.onnx_opset_version())) # valid positive and negative indices for slices data = np.reshape(np.arange(1, 25, dtype=np.float32), [2, 3, 4]) indices = np.array([[-1]], dtype=np.int64) updates = np.array( [[[43, 44, 45, 46], [47, 48, 49, 50], [51, 52, 53, 54]]], dtype=np.float32) ref_output = np.array( [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [[43, 44, 45, 46], [47, 48, 49, 50], [51, 52, 53, 54]]], dtype=np.float32) node_def = helper.make_node("ScatterND", ["data", "indices", "updates"], ["outputs"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("data", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("indices", TensorProto.INT64, [None, None]), helper.make_tensor_value_info("updates", TensorProto.FLOAT, [None, None, None]) ], outputs=[ helper.make_tensor_value_info("outputs", TensorProto.FLOAT, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) # export to tf.saved_model model_path = 'test_dynamic_shape/scatter_nd' tf_rep.export_graph(model_path) # load the saved_model back tf_model = tf.saved_model.load(model_path) # run the model tf_model_output = tf_model(data=data, indices=indices, updates=updates) np.testing.assert_almost_equal(tf_model_output[0], ref_output)
def test_batch_normalization(self): if legacy_opset_pre_ver(6): raise unittest.SkipTest("Backend doesn't support consumed flag") node_def = helper.make_node( "BatchNormalization", ["X", "scale", "bias", "mean", "var"], ["Y"], epsilon=0.001) x_shape = [3, 5, 4, 2] param_shape = [5] _param_shape = [1, 5, 1, 1] x = self._get_rnd(x_shape, 0, 1) m = self._get_rnd(param_shape, 0, 1) _m = m.reshape(_param_shape) v = self._get_rnd(param_shape, 0, 1) _v = v.reshape(_param_shape) scale = self._get_rnd(param_shape, 0, 1) _scale = scale.reshape(_param_shape) bias = self._get_rnd(param_shape, 0, 1) _bias = bias.reshape(_param_shape) golden = self._batch_normalization(x, _m, _v, _bias, _scale, 0.001) output = run_node(node_def, [x, scale, bias, m, v]) np.testing.assert_almost_equal(output["Y"], golden, decimal=5)
def test_constant(self): shape = [16, 16] values = np.random.randn(*shape).flatten().astype(float) const2_onnx = helper.make_tensor("const2", TensorProto.DOUBLE, shape, values) node_def = helper.make_node("Constant", [], ["Y"], value=const2_onnx) output = run_node(node_def, []) np.testing.assert_equal(output["Y"].shape, shape) np.testing.assert_almost_equal(output["Y"].flatten(), values) # test sparse tensor if not legacy_opset_pre_ver(11): expected = np.array([[1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0]]) x = np.array([[0, 0], [1, 2]]).flatten().astype(np.int64) values = helper.make_tensor("values", TensorProto.INT32, [2], [1, 2]) indices = helper.make_tensor("indices", TensorProto.INT64, [2, 2], x) a = helper.make_sparse_tensor(values, indices,[3, 4]) node_def = helper.make_node("Constant", [], ["Y"], sparse_value=a) output = run_node(node_def, []) b = tf.sparse_to_dense(output["Y"].indices, output["Y"].dense_shape, output["Y"].values) result = b.eval(session=tf.Session()) np.testing.assert_equal(result, expected)
def test_is_inf(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest( "ONNX version {} doesn't support IsInf.".format( defs.onnx_opset_version())) input = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float32) expected_output = { "node_def": np.isinf(input), "node_def_neg_false": np.isposinf(input), "node_def_pos_false": np.isneginf(input)} node_defs = { "node_def" : helper.make_node("IsInf", ["X"], ["Y"]), "node_def_neg_false" : helper.make_node("IsInf", ["X"], ["Y"], detect_negative = 0), "node_def_pos_false" : helper.make_node("IsInf", ["X"], ["Y"], detect_positive = 0) } for key in node_defs: output = run_node(node_defs[key], [input]) np.testing.assert_equal(output["Y"], expected_output[key])
def test_constant_fill(self): if not legacy_opset_pre_ver(9): raise unittest.SkipTest( "ONNX version {} doesn't support ConstantFill.".format( defs.onnx_opset_version())) shape = [1, 2, 3, 4] extra_shape = [5, 6] value = 3. node_def = helper.make_node( "ConstantFill", ["X"], ["Y"], value=value, extra_shape=extra_shape, dtype=1, ) x = self._get_rnd(shape) y = np.zeros(shape + extra_shape) y.fill(value) output = run_node(node_def, [x]) np.testing.assert_equal(output["Y"].dtype, tf.float32) np.testing.assert_equal(output["Y"], y)
def test_eye_like(self): if legacy_opset_pre_ver(9): raise unittest.SkipTest("ONNX version {} doesn't support EyeLike.".format( defs.onnx_opset_version())) shape = [6, 10] off_diagonal_offset = -3 x = self._get_rnd_int(0, 100, shape=shape) y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32) node_def = helper.make_node("EyeLike", ["x"], ["y"], dtype=TensorProto.FLOAT, k=off_diagonal_offset) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("x", TensorProto.INT32, [None, None]) ], outputs=[ helper.make_tensor_value_info("y", TensorProto.FLOAT, [None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({"x": x}) np.testing.assert_equal(output["y"], y)
def test_arg_max(self): if legacy_opset_pre_ver(12): raise unittest.SkipTest( "ONNX version {} doesn't support select_last_index attribute for ArgMax that depends on shape." .format(defs.onnx_opset_version())) axis = 1 node_def = helper.make_node("ArgMax", inputs=['X'], outputs=['Y'], axis=axis, keepdims=0, select_last_index=1) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None]) ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, None]) ]) x = np.array([[1, 2, 3, 5, 3, 4, 5, 1], [2, 9, 3, 5, 9, 4, 5, 1]]).astype(np.float32) # get tf_rep tf_rep = onnx_graph_to_tensorflow_rep(graph_def) # export to tf.saved_model model_path = 'test_dynamic_shape/arg_max' tf_rep.export_graph(model_path) # load the saved_model back tf_model = tf.saved_model.load(model_path) # run the model tf_model_output = tf_model(X=x) expected_output = np.argmax(np.flip(x, axis), axis=axis) expected_output = x.shape[axis] - expected_output - 1 np.testing.assert_almost_equal(tf_model_output[0], expected_output)
backend_test.exclude(r'test_mod_[a-z,_]*uint[0-9]+') backend_test.exclude(r'test_mod_[a-z,_]*int(8|(16))+') # TF doesn't support most of the attributes in resize op # test_node.py will cover the test backend_test.exclude(r'test_resize_[a-z,_]*') # range is using loop in the model test but all the outputs datatype are # missing in the body attribute of the loop backend_test.exclude(r'test_range_float_type_positive_delta_expanded[a-z,_]*') backend_test.exclude(r'test_range_int32_type_negative_delta_expanded[a-z,_]*') # skip all the cumsum testcases because all the axis in the testcases # are created as a 1-D 1 element tensor, but the spec clearly state # that axis should be a 0-D tensor(scalar) if legacy_opset_pre_ver(13): backend_test.exclude(r'test_cumsum_[a-z,_]*') # TF session run does not support sequence/RaggedTensor as model inputs backend_test.exclude(r'test_loop13_seq[a-z,_]*') # TF minimum/maximum do not support uint64 when auto-cast is False (default) backend_test.exclude(r'test_min_uint64_[a-z,_]*') backend_test.exclude(r'test_max_uint64_[a-z,_]*') if legacy_opset_pre_ver(7): backend_test.exclude(r'[a-z,_]*Upsample[a-z,_]*') if 'TRAVIS' in os.environ: backend_test.exclude('test_vgg19') backend_test.exclude('zfnet512')
model = onnx_model tf_rep = prepare(model) output_onnx_tf = tf_rep.run(backend_feed_dict) assert len(output_tf) == len(output_onnx_tf) for tf_output, onnx_backend_output in zip(output_tf, output_onnx_tf): np.testing.assert_allclose(tf_output, onnx_backend_output, rtol=1e-3, atol=1e-7) return do_test_expected if legacy_opset_pre_ver(10): dir_path = os.path.dirname(os.path.realpath(__file__)) with open(dir_path + "/test_model.yaml", 'r') as config: try: for test_model in yaml.safe_load_all(config): for device in test_model["devices"]: if supports_device(device): test_method = create_test(test_model) test_name_parts = ["test", test_model["name"], device] test_name = str("_".join(map(str, test_name_parts))) test_method.__name__ = test_name setattr(TestModel, test_method.__name__, test_method) except yaml.YAMLError as exception: print(exception) if __name__ == '__main__':
def test_if_with_sequence(self): if legacy_opset_pre_ver(14): raise unittest.SkipTest( "ONNX version {} doesn't support helper.make_tensor_sequence_value_info." .format(defs.onnx_opset_version())) # S = [a] # if cond is True # S = [a,b] # else # S = [a,c] a = np.random.randn(2, 1, 2).astype(np.float32) b = np.random.randn(1, 1, 2).astype(np.float32) c = np.random.randn(3, 1, 2).astype(np.float32) seq_construct_node = helper.make_node('SequenceConstruct', ['a'], ['S']) seq_insert_node1 = helper.make_node('SequenceInsert', ['S', 'b'], ['Sb']) seq_insert_node2 = helper.make_node('SequenceInsert', ['S', 'c'], ['Sc']) a_in = helper.make_tensor_value_info('a', onnx.TensorProto.FLOAT, [2, 1, 2]) b_in = helper.make_tensor_value_info('b', onnx.TensorProto.FLOAT, [1, 1, 2]) c_in = helper.make_tensor_value_info('c', onnx.TensorProto.FLOAT, [3, 1, 2]) cond_in = helper.make_tensor_value_info('cond', TensorProto.BOOL, []) s_in = helper.make_sequence_value_info('S', TensorProto.FLOAT, [None, None, None, None]) sb_out = helper.make_sequence_value_info('Sb', TensorProto.FLOAT, [None, None, None, None]) sc_out = helper.make_sequence_value_info('Sc', TensorProto.FLOAT, [None, None, None, None]) s_final_out = helper.make_sequence_value_info('S_final', TensorProto.FLOAT, [None, None, None, None]) then_graph = helper.make_graph(nodes=[seq_insert_node1], name="then_graph", inputs=[s_in, b_in], outputs=[sb_out]) else_graph = helper.make_graph(nodes=[seq_insert_node2], name="else_graph", inputs=[s_in, c_in], outputs=[sc_out]) if_node = helper.make_node('If', ['cond'], ['S_final'], then_branch=then_graph, else_branch=else_graph) graph_def = helper.make_graph(nodes=[seq_construct_node, if_node], name='test_if', inputs=[a_in, b_in, c_in, cond_in], outputs=[s_final_out]) tf_rep = prepare(helper.make_model(graph_def)) output = tf_rep.run({ 'a': a, 'b': b, 'c': c, 'cond': np.array(True, dtype=np.bool) }) np.testing.assert_almost_equal(output['S_final'][0], a) np.testing.assert_almost_equal(output['S_final'][1], b) output = tf_rep.run({ 'a': a, 'b': b, 'c': c, 'cond': np.array(False, dtype=np.bool) }) np.testing.assert_almost_equal(output['S_final'][0], a) np.testing.assert_almost_equal(output['S_final'][1], c)
# https://github.com/onnx/onnx/issues/349 backend_test.exclude(r'[a-z,_]*GLU[a-z,_]*') # TF does not support dialation and strides at the same time: # Will produce strides > 1 not supported in conjunction with dilation_rate > 1 backend_test.exclude(r'[a-z,_]*dilated_strided[a-z,_]*') backend_test.exclude(r'[a-z,_]*Conv2d_dilated[a-z,_]*') # TF does not have column major max_pool_with_argmax backend_test.exclude( r'[a-z,_]*maxpool_with_argmax_2d_precomputed_strides[a-z,_]*') # PRelu OnnxBackendPyTorchConvertedModelTest has wrong dim for broadcasting backend_test.exclude(r'[a-z,_]*PReLU_[0-9]d_multiparam[a-z,_]*') if legacy_opset_pre_ver(7): backend_test.exclude(r'[a-z,_]*Upsample[a-z,_]*') if 'TRAVIS' in os.environ: backend_test.exclude('test_vgg19') backend_test.exclude('zfnet512') if legacy_onnx_pre_ver(1, 2): # These following tests fails by a tiny margin with onnx<1.2: backend_test.exclude('test_operator_add_broadcast_cpu') backend_test.exclude('test_operator_add_size1_broadcast_cpu') backend_test.exclude('test_operator_add_size1_right_broadcast_cpu') backend_test.exclude('test_operator_add_size1_singleton_broadcast_cpu') backend_test.exclude('test_averagepool_3d_default_cpu') # Do not support consumed flag: backend_test.exclude('test_batch_normalization')
def test_slice(self): # test case 1 with normal inputs axes = [0, 1, 2] starts = [0, 0, 0] ends = [2, 2, 2] if legacy_opset_pre_ver(10): node_def = helper.make_node("Slice", ["X"], ["S"], axes=axes, starts=starts, ends=ends) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]) ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) else: node_def = helper.make_node("Slice", ["X", "starts", "ends", "axes"], ["S"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("starts", TensorProto.INT32, [None]), helper.make_tensor_value_info("ends", TensorProto.INT32, [None]), helper.make_tensor_value_info("axes", TensorProto.INT32, [None]), ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) if legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) output = tf_rep.run({"X": x}) np.testing.assert_almost_equal(output["S"], x[0:2, 0:2, 0:2]) else: x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) output = tf_rep.run({ "X": x, "starts": starts, "ends": ends, "axes": axes }) np.testing.assert_almost_equal(output["S"], x[0:2, 0:2, 0:2]) # test case 2 with negative, out-of-bound and default inputs axes = [0, 2] starts = [0, -7] ends = [-8, 20] steps = [1, 1] if legacy_opset_pre_ver(10): node_def = helper.make_node("Slice", ["X"], ["S"], axes=axes, starts=starts, ends=ends) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]) ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) else: node_def = helper.make_node( "Slice", ["X", "starts", "ends", "axes", "steps"], ["S"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("starts", TensorProto.INT32, [None]), helper.make_tensor_value_info("ends", TensorProto.INT32, [None]), helper.make_tensor_value_info("axes", TensorProto.INT32, [None]), helper.make_tensor_value_info("steps", TensorProto.INT32, [None]), ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) if legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) output = tf_rep.run({"X": x}) np.testing.assert_almost_equal(output["S"], x[0:-8, :, -7:20]) else: x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) output = tf_rep.run({ "X": x, "starts": starts, "ends": ends, "axes": axes, "steps": steps }) np.testing.assert_almost_equal(output["S"], x[0:-8, :, -7:20]) # test case 3 with non-default steps axes = [0, 1, 2] starts = [0, 0, 0] ends = [2, 2, 2] steps = [2, -2, -1] if not legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) output = tf_rep.run({ "X": x, "starts": starts, "ends": ends, "axes": axes, "steps": steps }) np.testing.assert_almost_equal(output["S"], x[0:2:2, 0:2:-2, 0:2:-1])
def test_matmul_integer(self): if legacy_opset_pre_ver(10): raise unittest.SkipTest( "ONNX version {} doesn't support MatMulInteger.".format( defs.onnx_opset_version())) node_def = helper.make_node("MatMulInteger", ["A", "B", "a_zero_point", "b_zero_point"], ["Z"]) # A & B are 3-D tensor and a_zero_point & b_zero_point are scalar A = self._get_rnd_int(-20, 20, shape=(2, 3, 4), dtype=np.int8) B = self._get_rnd_int(-20, 20, shape=(2, 4, 6), dtype=np.int8) a_zero_point = self._get_rnd_int(-20, 20, dtype=np.int8) b_zero_point = self._get_rnd_int(-20, 20, dtype=np.int8) A_minus_zero_point = np.subtract(A.astype(np.int32), a_zero_point.astype(np.int32)) B_minus_zero_point = np.subtract(B.astype(np.int32), b_zero_point.astype(np.int32)) z = np.matmul(A_minus_zero_point, B_minus_zero_point) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("A", TensorProto.INT8, [None, None, None]), helper.make_tensor_value_info("B", TensorProto.INT8, [None, None, None]), helper.make_tensor_value_info("a_zero_point", TensorProto.INT8, []), helper.make_tensor_value_info("b_zero_point", TensorProto.INT8, []) ], outputs=[ helper.make_tensor_value_info("Z", TensorProto.INT32, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({ "A": A, "B": B, "a_zero_point": a_zero_point, "b_zero_point": b_zero_point }) np.testing.assert_almost_equal(output["Z"], z) # A & B are 4-D tensor and a_zero_point & b_zero_point are 1-D tensor A = self._get_rnd_int(-20, 20, shape=(2, 5, 3, 4), dtype=np.int8) B = self._get_rnd_int(-20, 20, shape=(2, 1, 4, 6), dtype=np.int8) a_zero_point = self._get_rnd_int(-20, 20, shape=(A.shape[-2]), dtype=np.int8) b_zero_point = self._get_rnd_int(-20, 20, shape=(B.shape[-1]), dtype=np.int8) a_zero_point_with_reshape = np.reshape(a_zero_point, [A.shape[-2], 1]) A_minus_zero_point = np.subtract( A.astype(np.int32), a_zero_point_with_reshape.astype(np.int32)) B_minus_zero_point = np.subtract(B.astype(np.int32), b_zero_point.astype(np.int32)) z = np.matmul(A_minus_zero_point, B_minus_zero_point) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("A", TensorProto.INT8, [None, None, None, None]), helper.make_tensor_value_info("B", TensorProto.INT8, [None, None, None, None]), helper.make_tensor_value_info("a_zero_point", TensorProto.INT8, [None]), helper.make_tensor_value_info("b_zero_point", TensorProto.INT8, [None]) ], outputs=[ helper.make_tensor_value_info("Z", TensorProto.INT32, [None, None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) output = tf_rep.run({ "A": A, "B": B, "a_zero_point": a_zero_point, "b_zero_point": b_zero_point }) np.testing.assert_almost_equal(output["Z"], z)
("test_sqrt", tf.sqrt, "Sqrt", [get_rnd([10, 10])], {}), ("test_squeeze", tf.squeeze, "Squeeze", [get_rnd([1, 1, 10, 10])], {"axis":[0, 1]}), ("test_subtract", tf.subtract, "Sub", [get_rnd([10, 10]), get_rnd([10, 10])], {}), ("test_tanh", tf.tanh, "Tanh", [get_rnd([10, 10])], {}), ("test_top_k", tf.nn.top_k, "TopKV2", [get_rnd([10, 10, 10, 10])], {"k": 3}), # Use reverse to test ignore_unimplemented ("test_unimplemented", tf.reverse, "ReverseV2", [get_rnd([1, 2, 3, 4]), [3]], {}, {"ignore_unimplemented": True}), ("test_unpack", tf.unstack, "unstack", [get_rnd([2, 3, 4])], {}), ("test_xor", tf.logical_xor, "LogicalXor", [get_rnd([10, 10], dtype=np.bool_), get_rnd([10, 10], dtype=np.bool_)], {}), ("test_transpose", tf.transpose, "transpose", [get_rnd([2, 10])], {"perm":[1, 0]}), ("test_concat", tf.concat, "concat", [[get_rnd([1, 10]),get_rnd([10, 10]),get_rnd([20, 10])], 0], {}), ("test_bias_add_nchw", tf.nn.bias_add, "BiasAdd", [get_rnd([10, 32, 10, 10]),get_rnd([32])], {"data_format":"NCHW"}), ("test_bias_add_nhwc", tf.nn.bias_add, "BiasAdd", [get_rnd([10, 10, 10, 32]),get_rnd([32])], {"data_format":"NHWC"}), ] if not legacy_opset_pre_ver(6): test_cases.append(("test_tile", tf.tile, "Tile", [get_rnd([1, 2, 3, 4]), np.random.randint(1, 10, (4,), dtype=np.int32)], {})) if not legacy_opset_pre_ver(9): test_cases.append(("test_strided_slice", tf.strided_slice, "StridedSlice", [get_rnd([5, 5]), [0, 0], [1, 5], [1, 1]], {})) test_cases.append(("test_strided_slice_shrink", tf.strided_slice, "StridedSlice", [get_rnd([5, 5]), [0, 0], [1, 3], [1, 1]], {"shrink_axis_mask":1})) # yapf: enable for k, val in enumerate(test_cases): test_method = create_test(val) test_method.__name__ = str(val[0]) setattr(TestNode, test_method.__name__, test_method) if __name__ == '__main__': unittest.main()
def test_slice(self): # test case 1 with normal inputs axes = [0, 1, 2] starts = [0, 0, 0] ends = [2, 2, 2] if legacy_opset_pre_ver(10): node_def = helper.make_node("Slice", ["X"], ["S"], axes=axes, starts=starts, ends=ends) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]) ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) else: node_def = helper.make_node("Slice", ["X", "starts", "ends", "axes"], ["S"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("starts", TensorProto.INT32, [None]), helper.make_tensor_value_info("ends", TensorProto.INT32, [None]), helper.make_tensor_value_info("axes", TensorProto.INT32, [None]), ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) # export to tf.saved_model model_path = 'test_dynamic_shape/slice' tf_rep.export_graph(model_path) # load the saved_model back tf_model = tf.saved_model.load(model_path) if legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) tf_model_output = tf_model(X=x) np.testing.assert_almost_equal(tf_model_output[0], x[0:2, 0:2, 0:2]) else: x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) tf_model_output = tf_model(X=x, starts=starts, ends=ends, axes=axes) np.testing.assert_almost_equal(tf_model_output[0], x[0:2, 0:2, 0:2]) # test case 2 with negative, out-of-bound and default inputs axes = [0, 2] starts = [0, -7] ends = [-8, 20] steps = [1, 1] if legacy_opset_pre_ver(10): node_def = helper.make_node("Slice", ["X"], ["S"], axes=axes, starts=starts, ends=ends) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]) ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) else: node_def = helper.make_node( "Slice", ["X", "starts", "ends", "axes", "steps"], ["S"]) graph_def = helper.make_graph( [node_def], name="test_unknown_shape", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]), helper.make_tensor_value_info("starts", TensorProto.INT32, [None]), helper.make_tensor_value_info("ends", TensorProto.INT32, [None]), helper.make_tensor_value_info("axes", TensorProto.INT32, [None]), helper.make_tensor_value_info("steps", TensorProto.INT32, [None]), ], outputs=[ helper.make_tensor_value_info("S", TensorProto.FLOAT, [None, None, None]) ]) tf_rep = onnx_graph_to_tensorflow_rep(graph_def) # export to tf.saved_model model_path = 'test_dynamic_shape/slice' tf_rep.export_graph(model_path) # load the saved_model back tf_model = tf.saved_model.load(model_path) if legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) tf_model_output = tf_model(X=x) np.testing.assert_almost_equal(tf_model_output[0], x[0:-8, :, -7:20]) else: x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) tf_model_output = tf_model(X=x, starts=starts, ends=ends, axes=axes, steps=steps) np.testing.assert_almost_equal(tf_model_output[0], x[0:-8, :, -7:20]) # test case 3 with non-default steps axes = [0, 1, 2] starts = [0, 0, 0] ends = [2, 2, 2] steps = [2, -2, -1] if not legacy_opset_pre_ver(10): x = self._get_rnd_float32(shape=[1000]).reshape([10, 10, 10]) tf_model_output = tf_model(X=x, starts=starts, ends=ends, axes=axes, steps=steps) np.testing.assert_almost_equal(tf_model_output[0], x[0:2:2, 0:2:-2, 0:2:-1])