def test_gather_nd(self):
if legacy_opset_pre_ver(11):
raise unittest.SkipTest(
"ONNX version {} doesn't support GatherND.".format(
defs.onnx_opset_version()))
# valid positive and negative indices for elements
data = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32)
indices = np.array([[0, 0], [1, -3]], dtype=np.int64)
ref_output = np.array([1, 4], dtype=np.int32)
node_def = helper.make_node("GatherND", ["data", "indices"],
["outputs"])
graph_def = helper.make_graph(
[node_def],
name="test_unknown_shape",
inputs=[
helper.make_tensor_value_info("data", TensorProto.INT32,
[None, None]),
helper.make_tensor_value_info("indices", TensorProto.INT64,
[None, None])
],
outputs=[
helper.make_tensor_value_info("outputs", TensorProto.INT32,
[None])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"data": data, "indices": indices})
np.testing.assert_almost_equal(output["outputs"], ref_output)
def test_gather_nd(self):
if legacy_opset_pre_ver(11):
raise unittest.SkipTest(
"ONNX version {} doesn't support GatherND.".format(
defs.onnx_opset_version()))
# valid positive and negative indices for elements
data = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32)
indices = np.array([[0, 0], [1, -3]], dtype=np.int64)
ref_output = np.array([1, 4], dtype=np.int32)
node_def = helper.make_node("GatherND", ["data", "indices"],
["outputs"])
graph_def = helper.make_graph(
[node_def],
name="test_unknown_shape",
inputs=[
helper.make_tensor_value_info("data", TensorProto.INT32,
[None, None]),
helper.make_tensor_value_info("indices", TensorProto.INT64,
[None, None])
],
outputs=[
helper.make_tensor_value_info("outputs", TensorProto.INT32,
[None])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/gather_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)
np.testing.assert_almost_equal(tf_model_output[0], ref_output)
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)
# export to tf.saved_model
model_path = 'test_dynamic_shape/eye_like'
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)
np.testing.assert_equal(tf_model_output[0], y)
def test_flatten(self):
shape = [2, 3, 4]
x = self._get_rnd_float32(shape=shape)
axis = 1
node_def = helper.make_node("Flatten", ["X"], ["Y"], axis=axis)
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("Y", TensorProto.FLOAT, [None])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/flatten'
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)
new_shape = (np.prod(shape[0:axis]).astype(int), -1)
np.testing.assert_almost_equal(tf_model_output[0],
np.reshape(x, new_shape))
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)
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("condition", TensorProto.BOOL,
[None])
],
outputs=[
helper.make_tensor_value_info("Y", TensorProto.FLOAT,
[None, None, None])
])
x = self._get_rnd_float32(shape=[5, 5, 5])
cond = np.array([1, 0, 1])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x, "condition": cond})
np.testing.assert_almost_equal(output['Y'],
np.compress(cond, x, axis=axis))
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)
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("condition", TensorProto.BOOL,
[None])
],
outputs=[
helper.make_tensor_value_info("Y", TensorProto.FLOAT,
[None, None, None])
])
x = self._get_rnd_float32(shape=[5, 5, 5])
cond = np.array([1, 0, 1]).astype(np.bool)
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/compress'
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, condition=cond)
np.testing.assert_almost_equal(tf_model_output[0],
np.compress(cond, x, axis=axis))
def test_arg_min(self):
if legacy_opset_pre_ver(12):
raise unittest.SkipTest(
"ONNX version {} doesn't support select_last_index attribute for ArgMin that depends on shape."
.format(defs.onnx_opset_version()))
axis = 1
node_def = helper.make_node("ArgMin",
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, 7, 3, 5, 2, 4, 5,
6]]).astype(np.float32)
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x})
expected_output = np.argmin(np.flip(x, axis), axis=axis)
expected_output = x.shape[axis] - expected_output - 1
np.testing.assert_almost_equal(output['Y'], expected_output)
def test_split(self):
shape = [12, 12]
axis = 0
output_count = 3
node_def = helper.make_node("Split", ["X"],
["Z%i" % i for i in range(output_count)],
axis=axis)
graph_def = helper.make_graph(
[node_def],
name="test_unknown_shape",
inputs=[
helper.make_tensor_value_info("X", TensorProto.FLOAT,
[None] * len(shape))
],
outputs=[
helper.make_tensor_value_info("Z%i" % i, TensorProto.FLOAT,
[None] * len(shape))
for i in range(output_count)
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/split'
tf_rep.export_graph(model_path)
# load the saved_model back
tf_model = tf.saved_model.load(model_path)
# run the model
x = self._get_rnd_float32(shape=shape)
tf_model_output = tf_model(X=x)
per_part = shape[axis] // output_count
split = [per_part] * output_count
for a, b in zip(list(tf_model_output),
np.split(x, np.cumsum(split))[:-1]):
np.testing.assert_almost_equal(a, b)
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)
output = tf_rep.run({"data": data, "indices": indices, "updates": updates})
np.testing.assert_almost_equal(output["outputs"], ref_output)
def test_average_pool_2d(self):
kernel_shape = [1, 2]
strides = [1, 2]
input_shape = [10, 10, 4, 4]
x = self._get_rnd_float32(shape=input_shape)
test_output = py_pool(x,
kernel_shape=kernel_shape,
strides=strides,
pooling_type="AVG",
include_indices=False)
node_def = helper.make_node(op_type="AveragePool",
inputs=["X"],
outputs=["Y"],
kernel_shape=kernel_shape,
strides=strides)
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])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x})
np.testing.assert_almost_equal(output["Y"], test_output)
def test_split(self):
shape = [12, 12]
axis = 0
output_count = 3
node_def = helper.make_node("Split", ["X"],
["Z%i" % i for i in range(output_count)],
axis=axis)
graph_def = helper.make_graph(
[node_def],
name="test_unknown_shape",
inputs=[
helper.make_tensor_value_info("X", TensorProto.FLOAT,
[None] * len(shape))
],
outputs=[
helper.make_tensor_value_info("Z%i" % i, TensorProto.FLOAT,
[None] * len(shape))
for i in range(output_count)
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
x = self._get_rnd_float32(shape=shape)
output = tf_rep.run({"X": x})
per_part = shape[axis] // output_count
split = [per_part] * output_count
for a, b in zip(list(output), np.split(x, np.cumsum(split))[:-1]):
np.testing.assert_almost_equal(a, b)
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)
# export to tf.saved_model
model_path = 'test_dynamic_shape/is_inf'
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=inp)
np.testing.assert_equal(tf_model_output[0], expected_output)
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_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)
# export to tf.saved_model
model_path = 'test_dynamic_shape/non_max_suppression'
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(
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(tf_model_output[0], selected_indices)
def test_conv_transpose(self):
# test dynamic batch size on transpose of 2d convolution
pads = [1, 1, 1, 1]
x_shape = [1, 3, 4, 6]
x = self._get_rnd_float32(shape=x_shape)
weight_shape = [3, 5, 2, 2]
weights = self._get_rnd_float32(shape=weight_shape)
node_def = helper.make_node("ConvTranspose", ["X", "weights"], ["Y"],
pads=pads)
graph_def = helper.make_graph(
[node_def],
name="test_unknown_shape",
inputs=[
helper.make_tensor_value_info("X", TensorProto.FLOAT,
[None, 3, 4, 6]),
helper.make_tensor_value_info("weights", TensorProto.FLOAT,
weight_shape)
],
outputs=[
helper.make_tensor_value_info("Y", TensorProto.FLOAT,
[None, None, None, None])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x, "weights": weights})
padh_left = weight_shape[2] - 1 - pads[0]
padh_right = weight_shape[2] - 1 - pads[1]
padw_left = weight_shape[3] - 1 - pads[2]
padw_right = weight_shape[3] - 1 - pads[3]
kh = weight_shape[2]
kw = weight_shape[3]
outh = x_shape[2] + padh_right + padh_right - (kh - 1)
outw = x_shape[3] + padw_right + padw_right - (kw - 1)
out_shape = [x_shape[0], weight_shape[1], outh, outw]
test_output = np.zeros(out_shape)
for b in range(0, x_shape[0]):
for m in range(0, weight_shape[1]):
for c in range(0, x_shape[1]):
for h in range(0, outh):
for w in range(0, outw):
for k1 in range(h, h + kh):
for k2 in range(w, w + kw):
if (k1 - padh_left >= 0
and k2 - padw_left >= 0):
test_output[b][m][h][w] += x[b][c][
k1 - padh_left][
k2 -
padw_left] * weights[c][m][
kh + h - 1 - k1][kw + w -
1 - k2]
np.testing.assert_almost_equal(output["Y"], test_output, decimal=5)
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)
# export to tf.saved_model
model_path = 'test_dynamic_shape/max_pool_with_argmax_2d_dilations_ceil_pads'
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)
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(tf_model_output[0], test_output)
np.testing.assert_almost_equal(tf_model_output[1], test_ind)
def test_max_unpool(self):
input_shape = [10, 3, 24, 24]
x = self._get_rnd_float32(shape=input_shape)
kernel_shape = [2, 2]
strides = [2, 2]
maxpool_node_def = helper.make_node(op_type="MaxPool",
inputs=["X"],
outputs=["Pool", "Indices"],
kernel_shape=kernel_shape,
strides=strides)
maxunpool_node_def = helper.make_node("MaxUnpool", ["Pool", "Indices"],
["Y"],
kernel_shape=kernel_shape,
strides=strides)
graph_def = helper.make_graph(
[maxpool_node_def, maxunpool_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])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/max_unpool'
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)
test_output = np.zeros(input_shape)
for i1 in range(0, input_shape[0]):
for i2 in range(0, input_shape[1]):
for i3 in range(0, input_shape[2], 2):
for i4 in range(0, input_shape[3], 2):
max_val = float('-inf')
for j1 in range(i3, i3 + 2):
for j2 in range(i4, i4 + 2):
if x[i1][i2][j1][j2] > max_val:
max_val = x[i1][i2][j1][j2]
max_ind = (j1, j2)
j1, j2 = max_ind
test_output[i1][i2][j1][j2] = max_val
np.testing.assert_almost_equal(tf_model_output[0], test_output)
def test_max_pool_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 = 1
input_shape = [10, 3, 23, 23]
x = self._get_rnd_float32(shape=input_shape)
test_output = py_pool(x,
kernel_shape=kernel_shape,
strides=strides,
dilations=dilations,
padding=pads,
ceil_mode=ceil_mode,
pooling_type="MAX",
include_indices=False)
node_def = helper.make_node(op_type="MaxPool",
inputs=["X"],
outputs=["Y"],
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])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x})
np.testing.assert_almost_equal(output["Y"], test_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)
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_flatten(self):
shape = [2, 3, 4]
x = self._get_rnd_float32(shape=shape)
axis = 1
node_def = helper.make_node("Flatten", ["X"], ["Y"], axis=axis)
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("Y", TensorProto.FLOAT, [None])])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
output = tf_rep.run({"X": x})
new_shape = (np.prod(shape[0:axis]).astype(int), -1)
np.testing.assert_almost_equal(output["Y"], np.reshape(x, new_shape))
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_average_pool_2d(self):
kernel_shape = [1, 2]
strides = [1, 2]
input_shape = [10, 10, 4, 4]
x = self._get_rnd_float32(shape=input_shape)
test_output = py_pool(x,
kernel_shape=kernel_shape,
strides=strides,
pooling_type="AVG",
include_indices=False)
node_def = helper.make_node(op_type="AveragePool",
inputs=["X"],
outputs=["Y"],
kernel_shape=kernel_shape,
strides=strides)
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])
])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/average_pool_2d'
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)
np.testing.assert_almost_equal(tf_model_output[0], test_output)
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)
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)
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])
def test_non_max_suppression_with_if(self):
# if cond
# return NonMaxSuppression suppress by IOU
# else
# return NonNaxSuppression suppress by IOU and score
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]]]).astype(np.float32)
scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5,
0.3]]]).astype(np.float32)
max_output_boxes_per_class = np.array([3]).astype(np.int64)
iou_threshold = np.array([0.5]).astype(np.float32)
score_threshold = np.array([0.4]).astype(np.float32)
selected_indices_1 = np.array([[0, 0, 3], [0, 0, 0],
[0, 0, 5]]).astype(np.int64)
selected_indices_2 = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
boxes_in = helper.make_tensor_value_info("boxes", TensorProto.FLOAT,
[None, None, None])
scores_in = helper.make_tensor_value_info("scores", TensorProto.FLOAT,
[None, None, None])
max_output_boxes_per_class_in = helper.make_tensor_value_info(
"max_output_boxes_per_class", TensorProto.INT64, [None])
iou_threshold_in = helper.make_tensor_value_info(
"iou_threshold", TensorProto.FLOAT, [None])
score_threshold_in = helper.make_tensor_value_info(
"score_threshold", TensorProto.FLOAT, [None])
cond_in = helper.make_tensor_value_info('cond', TensorProto.BOOL, [])
selected_indices_1_out = helper.make_tensor_value_info(
"selected_indices_1", TensorProto.INT64, [None, None])
selected_indices_2_out = helper.make_tensor_value_info(
"selected_indices_2", TensorProto.INT64, [None, None])
selected_indices_out = helper.make_tensor_value_info(
"selected_indices", TensorProto.INT64, [None, None])
non_max_suppression_node_1 = helper.make_node(
"NonMaxSuppression",
["boxes", "scores", "max_output_boxes_per_class", "iou_threshold"],
["selected_indices_1"],
center_point_box=0,
name='NonMaxSuppression_1')
non_max_suppression_node_2 = helper.make_node(
"NonMaxSuppression", [
"boxes", "scores", "max_output_boxes_per_class",
"iou_threshold", "score_threshold"
], ["selected_indices_2"],
center_point_box=0,
name='NonMaxSuppression_2')
then_graph = helper.make_graph(nodes=[non_max_suppression_node_1],
name="then_graph",
inputs=[
boxes_in, scores_in,
max_output_boxes_per_class_in,
iou_threshold_in
],
outputs=[selected_indices_1_out])
else_graph = helper.make_graph(nodes=[non_max_suppression_node_2],
name="then_graph",
inputs=[
boxes_in, scores_in,
max_output_boxes_per_class_in,
iou_threshold_in, score_threshold_in
],
outputs=[selected_indices_2_out])
if_node = helper.make_node('If', ['cond'], ["selected_indices"],
then_branch=then_graph,
else_branch=else_graph)
graph_def = helper.make_graph(nodes=[if_node],
name='test_if',
inputs=[
boxes_in, scores_in,
max_output_boxes_per_class_in,
iou_threshold_in, score_threshold_in,
cond_in
],
outputs=[selected_indices_out])
tf_rep = onnx_graph_to_tensorflow_rep(graph_def)
# export to tf.saved_model
model_path = 'test_dynamic_shape/non_max_suppression/if'
tf_rep.export_graph(model_path)
# load the saved_model back
tf_model = tf.saved_model.load(model_path)
# run the model
for cond, exp in [[True, selected_indices_1],
[False, selected_indices_2]]:
tf_model_output = tf_model(
boxes=boxes,
scores=scores,
max_output_boxes_per_class=max_output_boxes_per_class,
iou_threshold=iou_threshold,
score_threshold=score_threshold,
cond=cond)
np.testing.assert_almost_equal(tf_model_output[0], exp)
