Skip to content

GitLab

Commit a8989ece authored by Shucai Xiao's avatar Shucai Xiao
Browse files

clang format

parent d7a28300
Hide whitespace changes
Inline Side-by-side
Showing with 1340 additions and 1475 deletions
test/onnx/gen_onnx.py
View file @ a8989ece
...@@ -11,16 +11,17 @@ def onnx_test(op_test): ...@@ -11,16 +11,17 @@ def onnx_test(op_test):
def run_test(): def run_test():
op_info = op_test() op_info = op_test()
if len(op_info) > 3: if len(op_info) > 3:
graph_def = helper.make_graph(op_info[0], graph_def = helper.make_graph(
op_test.__name__, op_info[0],
op_info[1], op_test.__name__,
op_info[2], op_info[1],
initializer=op_info[3]) op_info[2],
initializer=op_info[3])
else: else:
graph_def = helper.make_graph(op_info[0], op_test.__name__, graph_def = helper.make_graph(op_info[0], op_test.__name__,
op_info[1], op_info[2]) op_info[1], op_info[2])
model_def = helper.make_model(graph_def, model_def = helper.make_model(
producer_name=op_test.__name__) graph_def, producer_name=op_test.__name__)
onnx.save(model_def, '{}.onnx'.format(op_test.__name__)) onnx.save(model_def, '{}.onnx'.format(op_test.__name__))
return run_test return run_test
...@@ -60,11 +61,8 @@ def add_bcast_test(): ...@@ -60,11 +61,8 @@ def add_bcast_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4])
z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [2, 3, 4, 5]) z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [2, 3, 4, 5])
node = onnx.helper.make_node('Add', node = onnx.helper.make_node(
inputs=['0', '1'], 'Add', inputs=['0', '1'], broadcast=1, axis=1, outputs=['2'])
broadcast=1,
axis=1,
outputs=['2'])
return ([node], [x, y], [z]) return ([node], [x, y], [z])
...@@ -108,11 +106,8 @@ def argmax_test(): ...@@ -108,11 +106,8 @@ def argmax_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
node = onnx.helper.make_node('ArgMax', node = onnx.helper.make_node(
inputs=['x'], 'ArgMax', inputs=['x'], outputs=['y'], axis=2, keepdims=0)
outputs=['y'],
axis=2,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -122,11 +117,8 @@ def argmin_test(): ...@@ -122,11 +117,8 @@ def argmin_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5])
node = onnx.helper.make_node('ArgMin', node = onnx.helper.make_node(
inputs=['x'], 'ArgMin', inputs=['x'], outputs=['y'], axis=3, keepdims=0)
outputs=['y'],
axis=3,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -192,10 +184,8 @@ def averagepool_1d_test(): ...@@ -192,10 +184,8 @@ def averagepool_1d_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5])
out = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3]) out = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['0'], 'AveragePool', inputs=['0'], outputs=['1'], kernel_shape=[3])
outputs=['1'],
kernel_shape=[3])
return ([node], [x], [out]) return ([node], [x], [out])
...@@ -206,10 +196,8 @@ def averagepool_3d_test(): ...@@ -206,10 +196,8 @@ def averagepool_3d_test():
out = helper.make_tensor_value_info('1', TensorProto.FLOAT, out = helper.make_tensor_value_info('1', TensorProto.FLOAT,
[1, 3, 3, 3, 3]) [1, 3, 3, 3, 3])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['0'], 'AveragePool', inputs=['0'], outputs=['1'], kernel_shape=[3, 3, 3])
outputs=['1'],
kernel_shape=[3, 3, 3])
return ([node], [x], [out]) return ([node], [x], [out])
...@@ -219,13 +207,14 @@ def averagepool_notset_test(): ...@@ -219,13 +207,14 @@ def averagepool_notset_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['x'], 'AveragePool',
outputs=['y'], inputs=['x'],
kernel_shape=[6, 6], outputs=['y'],
strides=[2, 2], kernel_shape=[6, 6],
pads=[0, 0, 1, 1], strides=[2, 2],
auto_pad='NOTSET') pads=[0, 0, 1, 1],
auto_pad='NOTSET')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -235,14 +224,15 @@ def averagepool_nt_cip_test(): ...@@ -235,14 +224,15 @@ def averagepool_nt_cip_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['x'], 'AveragePool',
outputs=['y'], inputs=['x'],
kernel_shape=[6, 6], outputs=['y'],
strides=[2, 2], kernel_shape=[6, 6],
pads=[0, 0, 1, 1], strides=[2, 2],
auto_pad='NOTSET', pads=[0, 0, 1, 1],
count_include_pad=1) auto_pad='NOTSET',
count_include_pad=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -252,11 +242,12 @@ def averagepool_same_lower_test(): ...@@ -252,11 +242,12 @@ def averagepool_same_lower_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['x'], 'AveragePool',
outputs=['y'], inputs=['x'],
kernel_shape=[2, 2], outputs=['y'],
auto_pad='SAME_LOWER') kernel_shape=[2, 2],
auto_pad='SAME_LOWER')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -266,12 +257,13 @@ def averagepool_sl_cip_test(): ...@@ -266,12 +257,13 @@ def averagepool_sl_cip_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['x'], 'AveragePool',
outputs=['y'], inputs=['x'],
kernel_shape=[2, 2], outputs=['y'],
auto_pad='SAME_LOWER', kernel_shape=[2, 2],
count_include_pad=1) auto_pad='SAME_LOWER',
count_include_pad=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -281,11 +273,12 @@ def averagepool_same_upper_test(): ...@@ -281,11 +273,12 @@ def averagepool_same_upper_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('AveragePool', node = onnx.helper.make_node(
inputs=['x'], 'AveragePool',
outputs=['y'], inputs=['x'],
kernel_shape=[2, 2], outputs=['y'],
auto_pad='SAME_UPPER') kernel_shape=[2, 2],
auto_pad='SAME_UPPER')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -299,11 +292,12 @@ def batchnorm_1d_test(): ...@@ -299,11 +292,12 @@ def batchnorm_1d_test():
var = helper.make_tensor_value_info('4', TensorProto.FLOAT, [3]) var = helper.make_tensor_value_info('4', TensorProto.FLOAT, [3])
out = helper.make_tensor_value_info('5', TensorProto.FLOAT, [1, 3, 5]) out = helper.make_tensor_value_info('5', TensorProto.FLOAT, [1, 3, 5])
node = onnx.helper.make_node('BatchNormalization', node = onnx.helper.make_node(
inputs=['0', '1', '2', '3', '4'], 'BatchNormalization',
outputs=['5'], inputs=['0', '1', '2', '3', '4'],
epsilon=1e-6, outputs=['5'],
momentum=0.9) epsilon=1e-6,
momentum=0.9)
return ([node], [x, scale, bias, mean, var], [out]) return ([node], [x, scale, bias, mean, var], [out])
...@@ -318,11 +312,12 @@ def batchnorm_3d_test(): ...@@ -318,11 +312,12 @@ def batchnorm_3d_test():
out = helper.make_tensor_value_info('5', TensorProto.FLOAT, out = helper.make_tensor_value_info('5', TensorProto.FLOAT,
[1, 3, 5, 5, 5]) [1, 3, 5, 5, 5])
node = onnx.helper.make_node('BatchNormalization', node = onnx.helper.make_node(
inputs=['0', '1', '2', '3', '4'], 'BatchNormalization',
outputs=['5'], inputs=['0', '1', '2', '3', '4'],
epsilon=1e-6, outputs=['5'],
momentum=0.9) epsilon=1e-6,
momentum=0.9)
return ([node], [x, scale, bias, mean, var], [out]) return ([node], [x, scale, bias, mean, var], [out])
...@@ -356,10 +351,8 @@ def celu_alpha_test(): ...@@ -356,10 +351,8 @@ def celu_alpha_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3])
node = onnx.helper.make_node('Celu', node = onnx.helper.make_node(
inputs=['x'], 'Celu', inputs=['x'], outputs=['y'], alpha=0.8)
outputs=['y'],
alpha=0.8)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -379,10 +372,8 @@ def celu_verify_test(): ...@@ -379,10 +372,8 @@ def celu_verify_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
node = onnx.helper.make_node('Celu', node = onnx.helper.make_node(
inputs=['x'], 'Celu', inputs=['x'], outputs=['y'], alpha=0.5)
outputs=['y'],
alpha=0.5)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -402,10 +393,8 @@ def celu_zero_alpha_test(): ...@@ -402,10 +393,8 @@ def celu_zero_alpha_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
node = onnx.helper.make_node('Celu', node = onnx.helper.make_node(
inputs=['x'], 'Celu', inputs=['x'], outputs=['y'], alpha=0.0)
outputs=['y'],
alpha=0.0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -415,11 +404,8 @@ def clip_test(): ...@@ -415,11 +404,8 @@ def clip_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
node = onnx.helper.make_node('Clip', node = onnx.helper.make_node(
inputs=['0'], 'Clip', inputs=['0'], outputs=['1'], max=6.0, min=0.0)
outputs=['1'],
max=6.0,
min=0.0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -432,9 +418,8 @@ def clip_test_op11(): ...@@ -432,9 +418,8 @@ def clip_test_op11():
min_val = helper.make_tensor('min', TensorProto.FLOAT, [], [0.0]) min_val = helper.make_tensor('min', TensorProto.FLOAT, [], [0.0])
max_val = helper.make_tensor('max', TensorProto.FLOAT, [], [6.0]) max_val = helper.make_tensor('max', TensorProto.FLOAT, [], [6.0])
node = onnx.helper.make_node('Clip', node = onnx.helper.make_node(
inputs=['0', 'min', 'max'], 'Clip', inputs=['0', 'min', 'max'], outputs=['1'])
outputs=['1'])
return ([node], [x], [y], [min_val, max_val]) return ([node], [x], [y], [min_val, max_val])
...@@ -446,9 +431,8 @@ def clip_test_op11_max_only(): ...@@ -446,9 +431,8 @@ def clip_test_op11_max_only():
max_val = helper.make_tensor('max', TensorProto.FLOAT, [], [0.0]) max_val = helper.make_tensor('max', TensorProto.FLOAT, [], [0.0])
node = onnx.helper.make_node('Clip', node = onnx.helper.make_node(
inputs=['0', '', 'max'], 'Clip', inputs=['0', '', 'max'], outputs=['1'])
outputs=['1'])
return ([node], [x], [y], [max_val]) return ([node], [x], [y], [max_val])
...@@ -494,9 +478,8 @@ def clip_test_args_type_mismatch(): ...@@ -494,9 +478,8 @@ def clip_test_args_type_mismatch():
[1.5, 2.5, 3.5]) [1.5, 2.5, 3.5])
max_val = helper.make_tensor('max', TensorProto.INT64, [3, 1], [2, 3, 4]) max_val = helper.make_tensor('max', TensorProto.INT64, [3, 1], [2, 3, 4])
node = onnx.helper.make_node('Clip', node = onnx.helper.make_node(
inputs=['0', 'min', 'max'], 'Clip', inputs=['0', 'min', 'max'], outputs=['1'])
outputs=['1'])
return ([node], [x], [y], [min_val, max_val]) return ([node], [x], [y], [min_val, max_val])
...@@ -559,10 +542,11 @@ def constant_fill_input_as_shape_test(): ...@@ -559,10 +542,11 @@ def constant_fill_input_as_shape_test():
np_shape = np.array([2, 3]) np_shape = np.array([2, 3])
value = helper.make_tensor_value_info('value', TensorProto.FLOAT, [2, 3]) value = helper.make_tensor_value_info('value', TensorProto.FLOAT, [2, 3])
ts_shape = helper.make_tensor(name='shape_tensor', ts_shape = helper.make_tensor(
data_type=TensorProto.INT32, name='shape_tensor',
dims=np_shape.shape, data_type=TensorProto.INT32,
vals=np_shape.flatten().astype(int)) dims=np_shape.shape,
vals=np_shape.flatten().astype(int))
const_shape_node = onnx.helper.make_node( const_shape_node = onnx.helper.make_node(
'Constant', 'Constant',
...@@ -608,10 +592,11 @@ def const_of_shape_empty_input_test(): ...@@ -608,10 +592,11 @@ def const_of_shape_empty_input_test():
tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1], tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
[10]) [10])
empty_val = np.array([]).astype(np.int64) empty_val = np.array([]).astype(np.int64)
empty_ts = helper.make_tensor(name='empty_tensor', empty_ts = helper.make_tensor(
data_type=TensorProto.INT32, name='empty_tensor',
dims=empty_val.shape, data_type=TensorProto.INT32,
vals=empty_val.flatten().astype(int)) dims=empty_val.shape,
vals=empty_val.flatten().astype(int))
shape_const = helper.make_node( shape_const = helper.make_node(
'Constant', 'Constant',
inputs=[], inputs=[],
...@@ -636,10 +621,11 @@ def const_of_shape_float_test(): ...@@ -636,10 +621,11 @@ def const_of_shape_float_test():
[10]) [10])
shape_val = np.array([2, 3, 4]).astype(np.int64) shape_val = np.array([2, 3, 4]).astype(np.int64)
shape_ts = helper.make_tensor(name='shape_tensor', shape_ts = helper.make_tensor(
data_type=TensorProto.INT32, name='shape_tensor',
dims=shape_val.shape, data_type=TensorProto.INT32,
vals=shape_val.flatten().astype(int)) dims=shape_val.shape,
vals=shape_val.flatten().astype(int))
shape_const = helper.make_node( shape_const = helper.make_node(
'Constant', 'Constant',
...@@ -649,10 +635,8 @@ def const_of_shape_float_test(): ...@@ -649,10 +635,8 @@ def const_of_shape_float_test():
) )
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4])
node = onnx.helper.make_node('ConstantOfShape', node = onnx.helper.make_node(
inputs=['shape'], 'ConstantOfShape', inputs=['shape'], outputs=['y'], value=tensor_val)
outputs=['y'],
value=tensor_val)
return ([shape_const, node], [], [y]) return ([shape_const, node], [], [y])
...@@ -662,10 +646,11 @@ def const_of_shape_int64_test(): ...@@ -662,10 +646,11 @@ def const_of_shape_int64_test():
tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1], tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
[10]) [10])
shape_val = np.array([2, 3, 4]).astype(np.int64) shape_val = np.array([2, 3, 4]).astype(np.int64)
shape_ts = helper.make_tensor(name='shape_tensor', shape_ts = helper.make_tensor(
data_type=TensorProto.INT32, name='shape_tensor',
dims=shape_val.shape, data_type=TensorProto.INT32,
vals=shape_val.flatten().astype(int)) dims=shape_val.shape,
vals=shape_val.flatten().astype(int))
shape_const = helper.make_node( shape_const = helper.make_node(
'Constant', 'Constant',
inputs=[], inputs=[],
...@@ -674,10 +659,8 @@ def const_of_shape_int64_test(): ...@@ -674,10 +659,8 @@ def const_of_shape_int64_test():
) )
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4])
node = onnx.helper.make_node('ConstantOfShape', node = onnx.helper.make_node(
inputs=['shape'], 'ConstantOfShape', inputs=['shape'], outputs=['y'], value=tensor_val)
outputs=['y'],
value=tensor_val)
return ([shape_const, node], [], [y]) return ([shape_const, node], [], [y])
...@@ -685,10 +668,11 @@ def const_of_shape_int64_test(): ...@@ -685,10 +668,11 @@ def const_of_shape_int64_test():
@onnx_test @onnx_test
def const_of_shape_no_value_attr_test(): def const_of_shape_no_value_attr_test():
shape_val = np.array([2, 3, 4]).astype(np.int64) shape_val = np.array([2, 3, 4]).astype(np.int64)
shape_ts = helper.make_tensor(name='shape_tensor', shape_ts = helper.make_tensor(
data_type=TensorProto.INT32, name='shape_tensor',
dims=shape_val.shape, data_type=TensorProto.INT32,
vals=shape_val.flatten().astype(int)) dims=shape_val.shape,
vals=shape_val.flatten().astype(int))
shape_const = helper.make_node( shape_const = helper.make_node(
'Constant', 'Constant',
inputs=[], inputs=[],
...@@ -735,10 +719,8 @@ def conv_attr_fail_test(): ...@@ -735,10 +719,8 @@ def conv_attr_fail_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3])
out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 3]) out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 3])
node = onnx.helper.make_node('Conv', node = onnx.helper.make_node(
inputs=['0', '1'], 'Conv', inputs=['0', '1'], strides=[1, 1], outputs=['2'])
strides=[1, 1],
outputs=['2'])
return ([node], [x, y], [out]) return ([node], [x, y], [out])
...@@ -749,13 +731,14 @@ def conv_autopad_fail_test(): ...@@ -749,13 +731,14 @@ def conv_autopad_fail_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 34, 34]) out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 34, 34])
node = onnx.helper.make_node('Conv', node = onnx.helper.make_node(
inputs=['0', '1'], 'Conv',
outputs=['2'], inputs=['0', '1'],
dilations=[1, 1], outputs=['2'],
strides=[1, 1], dilations=[1, 1],
auto_pad='SAME', strides=[1, 1],
pads=[0, 0, 1, 1, 0, 0, 1, 1]) auto_pad='SAME',
pads=[0, 0, 1, 1, 0, 0, 1, 1])
return ([node], [x, y], [out]) return ([node], [x, y], [out])
...@@ -766,12 +749,13 @@ def conv_autopad_same_test(): ...@@ -766,12 +749,13 @@ def conv_autopad_same_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3])
out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 32, 32]) out = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 32, 32])
node = onnx.helper.make_node('Conv', node = onnx.helper.make_node(
inputs=['0', '1'], 'Conv',
outputs=['2'], inputs=['0', '1'],
dilations=[1, 1], outputs=['2'],
strides=[1, 1], dilations=[1, 1],
auto_pad='SAME') strides=[1, 1],
auto_pad='SAME')
return ([node], [x, y], [out]) return ([node], [x, y], [out])
...@@ -783,11 +767,12 @@ def conv_bias_test(): ...@@ -783,11 +767,12 @@ def conv_bias_test():
z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1]) z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1])
out = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 2, 28, 28]) out = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 2, 28, 28])
node = onnx.helper.make_node('Conv', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'Conv',
outputs=['3'], inputs=['0', '1', '2'],
dilations=[1, 1], outputs=['3'],
strides=[1, 1]) dilations=[1, 1],
strides=[1, 1])
return ([node], [x, y, z], [out]) return ([node], [x, y, z], [out])
...@@ -804,26 +789,29 @@ def conv_bn_relu_maxpool_test(): ...@@ -804,26 +789,29 @@ def conv_bn_relu_maxpool_test():
out = helper.make_tensor_value_info('10', TensorProto.FLOAT, out = helper.make_tensor_value_info('10', TensorProto.FLOAT,
[1, 1, 14, 14]) [1, 1, 14, 14])
node0 = onnx.helper.make_node('Conv', node0 = onnx.helper.make_node(
inputs=['0', '1', '2'], 'Conv',
outputs=['7'], inputs=['0', '1', '2'],
dilations=[1, 1], outputs=['7'],
strides=[1, 1], dilations=[1, 1],
pads=[0, 0, 0, 0]) strides=[1, 1],
pads=[0, 0, 0, 0])
node1 = onnx.helper.make_node('BatchNormalization',
inputs=['7', '3', '4', '5', '6'], node1 = onnx.helper.make_node(
outputs=['8'], 'BatchNormalization',
epsilon=9.99999974737875e-06, inputs=['7', '3', '4', '5', '6'],
momentum=0.899999976158142) outputs=['8'],
epsilon=9.99999974737875e-06,
momentum=0.899999976158142)
node2 = onnx.helper.make_node('Relu', inputs=['8'], outputs=['9']) node2 = onnx.helper.make_node('Relu', inputs=['8'], outputs=['9'])
node3 = onnx.helper.make_node('MaxPool', node3 = onnx.helper.make_node(
inputs=['9'], 'MaxPool',
outputs=['10'], inputs=['9'],
pads=[0, 0, 0, 0], outputs=['10'],
strides=[2, 2], pads=[0, 0, 0, 0],
kernel_shape=[2, 2]) strides=[2, 2],
kernel_shape=[2, 2])
return ([node0, node1, node2, node3], [x, y, z, m, n, k, l], [out]) return ([node0, node1, node2, node3], [x, y, z, m, n, k, l], [out])
...@@ -835,21 +823,23 @@ def conv_relu_maxpool_test(): ...@@ -835,21 +823,23 @@ def conv_relu_maxpool_test():
z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1]) z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1])
out = helper.make_tensor_value_info('5', TensorProto.FLOAT, [1, 1, 14, 14]) out = helper.make_tensor_value_info('5', TensorProto.FLOAT, [1, 1, 14, 14])
node1 = onnx.helper.make_node('Conv', node1 = onnx.helper.make_node(
inputs=['0', '1', '2'], 'Conv',
outputs=['3'], inputs=['0', '1', '2'],
dilations=[1, 1], outputs=['3'],
strides=[1, 1], dilations=[1, 1],
pads=[0, 0, 0, 0]) strides=[1, 1],
pads=[0, 0, 0, 0])
node2 = onnx.helper.make_node('Relu', inputs=['3'], outputs=['4']) node2 = onnx.helper.make_node('Relu', inputs=['3'], outputs=['4'])
node3 = onnx.helper.make_node('MaxPool', node3 = onnx.helper.make_node(
inputs=['4'], 'MaxPool',
outputs=['5'], inputs=['4'],
pads=[0, 0, 0, 0], outputs=['5'],
strides=[2, 2], pads=[0, 0, 0, 0],
kernel_shape=[2, 2]) strides=[2, 2],
kernel_shape=[2, 2])
return ([node1, node2, node3], [x, y, z], [out]) return ([node1, node2, node3], [x, y, z], [out])
...@@ -863,37 +853,41 @@ def conv_relu_maxpool_x2_test(): ...@@ -863,37 +853,41 @@ def conv_relu_maxpool_x2_test():
n = helper.make_tensor_value_info('4', TensorProto.FLOAT, [1]) n = helper.make_tensor_value_info('4', TensorProto.FLOAT, [1])
out = helper.make_tensor_value_info('10', TensorProto.FLOAT, [1, 1, 5, 5]) out = helper.make_tensor_value_info('10', TensorProto.FLOAT, [1, 1, 5, 5])
node1 = onnx.helper.make_node('Conv', node1 = onnx.helper.make_node(
inputs=['0', '1', '2'], 'Conv',
outputs=['5'], inputs=['0', '1', '2'],
dilations=[1, 1], outputs=['5'],
strides=[1, 1], dilations=[1, 1],
pads=[0, 0, 0, 0]) strides=[1, 1],
pads=[0, 0, 0, 0])
node2 = onnx.helper.make_node('Relu', inputs=['5'], outputs=['6']) node2 = onnx.helper.make_node('Relu', inputs=['5'], outputs=['6'])
node3 = onnx.helper.make_node('MaxPool', node3 = onnx.helper.make_node(
inputs=['6'], 'MaxPool',
outputs=['7'], inputs=['6'],
pads=[0, 0, 0, 0], outputs=['7'],
strides=[2, 2], pads=[0, 0, 0, 0],
kernel_shape=[2, 2]) strides=[2, 2],
kernel_shape=[2, 2])
node4 = onnx.helper.make_node('Conv', node4 = onnx.helper.make_node(
inputs=['7', '3', '4'], 'Conv',
outputs=['8'], inputs=['7', '3', '4'],
dilations=[1, 1], outputs=['8'],
strides=[1, 1], dilations=[1, 1],
pads=[0, 0, 0, 0]) strides=[1, 1],
pads=[0, 0, 0, 0])
node5 = onnx.helper.make_node('Relu', inputs=['8'], outputs=['9']) node5 = onnx.helper.make_node('Relu', inputs=['8'], outputs=['9'])
node6 = onnx.helper.make_node('MaxPool', node6 = onnx.helper.make_node(
inputs=['9'], 'MaxPool',
outputs=['10'], inputs=['9'],
pads=[0, 0, 0, 0], outputs=['10'],
strides=[2, 2], pads=[0, 0, 0, 0],
kernel_shape=[2, 2]) strides=[2, 2],
kernel_shape=[2, 2])
return ([node1, node2, node3, node4, node5, node6], [x, y, z, m, n], [out]) return ([node1, node2, node3, node4, node5, node6], [x, y, z, m, n], [out])
...@@ -905,11 +899,12 @@ def convinteger_bias_test(): ...@@ -905,11 +899,12 @@ def convinteger_bias_test():
z = helper.make_tensor_value_info('2', TensorProto.INT32, [1]) z = helper.make_tensor_value_info('2', TensorProto.INT32, [1])
out = helper.make_tensor_value_info('3', TensorProto.INT32, [1, 2, 28, 28]) out = helper.make_tensor_value_info('3', TensorProto.INT32, [1, 2, 28, 28])
node = onnx.helper.make_node('ConvInteger', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'ConvInteger',
outputs=['3'], inputs=['0', '1', '2'],
dilations=[1, 1], outputs=['3'],
strides=[1, 1]) dilations=[1, 1],
strides=[1, 1])
return ([node], [x, y, z], [out]) return ([node], [x, y, z], [out])
...@@ -948,10 +943,8 @@ def deconv_test(): ...@@ -948,10 +943,8 @@ def deconv_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 1, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 1, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
name='conv1', 'ConvTranspose', name='conv1', inputs=['x', 'w'], outputs=['y'])
inputs=['x', 'w'],
outputs=['y'])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -963,10 +956,8 @@ def deconv_bias_test(): ...@@ -963,10 +956,8 @@ def deconv_bias_test():
b = helper.make_tensor_value_info('b', TensorProto.FLOAT, [1]) b = helper.make_tensor_value_info('b', TensorProto.FLOAT, [1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
name='conv1', 'ConvTranspose', name='conv1', inputs=['x', 'w', 'b'], outputs=['y'])
inputs=['x', 'w', 'b'],
outputs=['y'])
return ([node], [x, w, b], [y]) return ([node], [x, w, b], [y])
...@@ -977,11 +968,12 @@ def deconv_input_pads_strides_test(): ...@@ -977,11 +968,12 @@ def deconv_input_pads_strides_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 7, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 7, 5])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2], outputs=['y'],
pads=[1, 1, 1, 1]) strides=[3, 2],
pads=[1, 1, 1, 1])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -992,11 +984,12 @@ def deconv_input_pads_asymm_test(): ...@@ -992,11 +984,12 @@ def deconv_input_pads_asymm_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 8, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 8, 6])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2], outputs=['y'],
pads=[0, 0, 1, 1]) strides=[3, 2],
pads=[0, 0, 1, 1])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1007,12 +1000,13 @@ def deconv_input_pads_asymm_1d_test(): ...@@ -1007,12 +1000,13 @@ def deconv_input_pads_asymm_1d_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 6])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[2], outputs=['y'],
pads=[0, 1], strides=[2],
dilations=[1]) pads=[0, 1],
dilations=[1])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1023,11 +1017,12 @@ def deconv_output_padding_test(): ...@@ -1023,11 +1017,12 @@ def deconv_output_padding_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2], outputs=['y'],
output_padding=[1, 1]) strides=[3, 2],
output_padding=[1, 1])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1038,11 +1033,12 @@ def deconv_output_padding_3d_test(): ...@@ -1038,11 +1033,12 @@ def deconv_output_padding_3d_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8, 8]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8, 8])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2, 2], outputs=['y'],
output_padding=[1, 1, 1]) strides=[3, 2, 2],
output_padding=[1, 1, 1])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1053,11 +1049,12 @@ def deconv_output_shape_test(): ...@@ -1053,11 +1049,12 @@ def deconv_output_shape_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2], outputs=['y'],
output_shape=[10, 8]) strides=[3, 2],
output_shape=[10, 8])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1068,11 +1065,12 @@ def deconv_output_shape_3d_test(): ...@@ -1068,11 +1065,12 @@ def deconv_output_shape_3d_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8, 8]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 10, 8, 8])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose',
outputs=['y'], inputs=['x', 'w'],
strides=[3, 2, 2], outputs=['y'],
output_shape=[10, 8, 8]) strides=[3, 2, 2],
output_shape=[10, 8, 8])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1083,10 +1081,8 @@ def deconv_stride_test(): ...@@ -1083,10 +1081,8 @@ def deconv_stride_test():
w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3]) w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 7, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 7, 3])
node = onnx.helper.make_node('ConvTranspose', node = onnx.helper.make_node(
inputs=['x', 'w'], 'ConvTranspose', inputs=['x', 'w'], outputs=['y'], strides=[3, 2])
outputs=['y'],
strides=[3, 2])
return ([node], [x, w], [y]) return ([node], [x, w], [y])
...@@ -1097,11 +1093,8 @@ def depthtospace_test(): ...@@ -1097,11 +1093,8 @@ def depthtospace_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 10, 10]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 10, 10])
node = onnx.helper.make_node('DepthToSpace', node = onnx.helper.make_node(
inputs=['x'], 'DepthToSpace', inputs=['x'], outputs=['y'], blocksize=2, mode='DCR')
outputs=['y'],
blocksize=2,
mode='DCR')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1112,11 +1105,8 @@ def depthtospace_simple_test(): ...@@ -1112,11 +1105,8 @@ def depthtospace_simple_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 8, 2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 8, 2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 4, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 4, 6])
node = onnx.helper.make_node('DepthToSpace', node = onnx.helper.make_node(
inputs=['x'], 'DepthToSpace', inputs=['x'], outputs=['y'], blocksize=2, mode='DCR')
outputs=['y'],
blocksize=2,
mode='DCR')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1127,11 +1117,8 @@ def depthtospace_crd_test(): ...@@ -1127,11 +1117,8 @@ def depthtospace_crd_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 10, 10]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 10, 10])
node = onnx.helper.make_node('DepthToSpace', node = onnx.helper.make_node(
inputs=['x'], 'DepthToSpace', inputs=['x'], outputs=['y'], blocksize=2, mode='CRD')
outputs=['y'],
blocksize=2,
mode='CRD')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1142,10 +1129,8 @@ def spacetodepth_test(): ...@@ -1142,10 +1129,8 @@ def spacetodepth_test():
x = helper.make_tensor_value_info('x', TensorProto.float, [2, 2, 10, 10]) x = helper.make_tensor_value_info('x', TensorProto.float, [2, 2, 10, 10])
y = helper.make_tensor_value_info('y', TensorProto.float, [2, 8, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.float, [2, 8, 5, 5])
node = onnx.helper.make_node('spacetodepth', node = onnx.helper.make_node(
inputs=['x'], 'spacetodepth', inputs=['x'], outputs=['y'], blocksize=2)
outputs=['y'],
blocksize=2)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1156,10 +1141,8 @@ def spacetodepth_simple_test(): ...@@ -1156,10 +1141,8 @@ def spacetodepth_simple_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 3])
node = onnx.helper.make_node('SpaceToDepth', node = onnx.helper.make_node(
inputs=['x'], 'SpaceToDepth', inputs=['x'], outputs=['y'], blocksize=2)
outputs=['y'],
blocksize=2)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1170,10 +1153,8 @@ def spacetodepth_invalid_blocksize_test(): ...@@ -1170,10 +1153,8 @@ def spacetodepth_invalid_blocksize_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 3])
node = onnx.helper.make_node('SpaceToDepth', node = onnx.helper.make_node(
inputs=['x'], 'SpaceToDepth', inputs=['x'], outputs=['y'], blocksize=0.3)
outputs=['y'],
blocksize=0.3)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1184,10 +1165,8 @@ def spacetodepth_nondivisibility_test(): ...@@ -1184,10 +1165,8 @@ def spacetodepth_nondivisibility_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 2]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 8, 2, 2])
node = onnx.helper.make_node('SpaceToDepth', node = onnx.helper.make_node(
inputs=['x'], 'SpaceToDepth', inputs=['x'], outputs=['y'], blocksize=2)
outputs=['y'],
blocksize=2)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1230,10 +1209,8 @@ def make_dequantizelinear_axis_graph(axis): ...@@ -1230,10 +1209,8 @@ def make_dequantizelinear_axis_graph(axis):
arg_out = helper.make_tensor_value_info('out', TensorProto.FLOAT, arg_out = helper.make_tensor_value_info('out', TensorProto.FLOAT,
[1, 1, 5, 1]) [1, 1, 5, 1])
node = onnx.helper.make_node('DequantizeLinear', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'DequantizeLinear', inputs=['0', '1', '2'], outputs=['out'], axis=axis)
outputs=['out'],
axis=axis)
return ([node], [arg0, arg1, arg2], [arg_out]) return ([node], [arg0, arg1, arg2], [arg_out])
...@@ -1267,10 +1244,8 @@ def elu_test(): ...@@ -1267,10 +1244,8 @@ def elu_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
node = onnx.helper.make_node('Elu', node = onnx.helper.make_node(
inputs=['0'], 'Elu', inputs=['0'], outputs=['1'], alpha=0.01)
outputs=['1'],
alpha=0.01)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1281,25 +1256,23 @@ def embedding_bag_test(): ...@@ -1281,25 +1256,23 @@ def embedding_bag_test():
index_val = np.array([1, 0, 2]) index_val = np.array([1, 0, 2])
offset_val = np.array([0]) offset_val = np.array([0])
index_tensor = helper.make_tensor(name='index_val', index_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='index_val',
dims=index_val.shape, data_type=TensorProto.INT32,
vals=index_val.astype(np.int32)) dims=index_val.shape,
vals=index_val.astype(np.int32))
index = onnx.helper.make_node('Constant', index = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['index'], value=index_tensor)
outputs=['index'],
value=index_tensor)
offset_tensor = helper.make_tensor(name='offset_val', offset_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='offset_val',
dims=offset_val.reshape(()).shape, data_type=TensorProto.INT32,
vals=offset_val.astype(np.int32)) dims=offset_val.reshape(()).shape,
vals=offset_val.astype(np.int32))
offset = onnx.helper.make_node('Constant', offset = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['offset'], value=offset_tensor)
outputs=['offset'],
value=offset_tensor)
weight = helper.make_tensor_value_info('weight', TensorProto.FLOAT, [4, 2]) weight = helper.make_tensor_value_info('weight', TensorProto.FLOAT, [4, 2])
...@@ -1307,23 +1280,26 @@ def embedding_bag_test(): ...@@ -1307,23 +1280,26 @@ def embedding_bag_test():
y2 = helper.make_tensor_value_info('y2', TensorProto.FLOAT, [1, 2]) y2 = helper.make_tensor_value_info('y2', TensorProto.FLOAT, [1, 2])
y3 = helper.make_tensor_value_info('y3', TensorProto.FLOAT, [1, 2]) y3 = helper.make_tensor_value_info('y3', TensorProto.FLOAT, [1, 2])
node1 = onnx.helper.make_node('ATen', node1 = onnx.helper.make_node(
inputs=['weight', 'index', 'offset'], 'ATen',
outputs=['y1'], inputs=['weight', 'index', 'offset'],
mode=0, outputs=['y1'],
operator='embedding_bag') mode=0,
operator='embedding_bag')
node2 = onnx.helper.make_node('ATen',
inputs=['weight', 'index', 'offset'],
outputs=['y2'],
mode=1,
operator='embedding_bag')
node3 = onnx.helper.make_node('ATen', node2 = onnx.helper.make_node(
inputs=['weight', 'index', 'offset'], 'ATen',
outputs=['y3'], inputs=['weight', 'index', 'offset'],
mode=2, outputs=['y2'],
operator='embedding_bag') mode=1,
operator='embedding_bag')
node3 = onnx.helper.make_node(
'ATen',
inputs=['weight', 'index', 'offset'],
outputs=['y3'],
mode=2,
operator='embedding_bag')
return ([index, offset, node1, node2, node3], [weight], [y1, y2, y3]) return ([index, offset, node1, node2, node3], [weight], [y1, y2, y3])
...@@ -1334,35 +1310,34 @@ def embedding_bag_offset_test(): ...@@ -1334,35 +1310,34 @@ def embedding_bag_offset_test():
index_val = np.array([1, 0]) index_val = np.array([1, 0])
offset_val = np.array([0, 1]) offset_val = np.array([0, 1])
index_tensor = helper.make_tensor(name='index_val', index_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='index_val',
dims=index_val.shape, data_type=TensorProto.INT32,
vals=index_val.astype(np.int32)) dims=index_val.shape,
vals=index_val.astype(np.int32))
index = onnx.helper.make_node('Constant', index = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['index'], value=index_tensor)
outputs=['index'],
value=index_tensor)
offset_tensor = helper.make_tensor(name='offset_val', offset_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='offset_val',
dims=offset_val.shape, data_type=TensorProto.INT32,
vals=offset_val.astype(np.int32)) dims=offset_val.shape,
vals=offset_val.astype(np.int32))
offset = onnx.helper.make_node('Constant', offset = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['offset'], value=offset_tensor)
outputs=['offset'],
value=offset_tensor)
weight = helper.make_tensor_value_info('weight', TensorProto.FLOAT, [2, 3]) weight = helper.make_tensor_value_info('weight', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
node = onnx.helper.make_node('ATen', node = onnx.helper.make_node(
inputs=['weight', 'index', 'offset'], 'ATen',
outputs=['y'], inputs=['weight', 'index', 'offset'],
mode=0, outputs=['y'],
operator='embedding_bag') mode=0,
operator='embedding_bag')
return ([index, offset, node], [weight], [y]) return ([index, offset, node], [weight], [y])
...@@ -1370,10 +1345,11 @@ def embedding_bag_offset_test(): ...@@ -1370,10 +1345,11 @@ def embedding_bag_offset_test():
@onnx_test @onnx_test
def equal_test(): def equal_test():
ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
x1 = helper.make_tensor("x1", x1 = helper.make_tensor(
data_type=TensorProto.FLOAT, "x1",
dims=(2, 3), data_type=TensorProto.FLOAT,
vals=ax1.astype(np.float32)) dims=(2, 3),
vals=ax1.astype(np.float32))
x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3]) x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
...@@ -1436,10 +1412,11 @@ def exp_test(): ...@@ -1436,10 +1412,11 @@ def exp_test():
@onnx_test @onnx_test
def expand_test(): def expand_test():
shape_val = np.array([2, 3, 4, 5]).astype(np.int64) shape_val = np.array([2, 3, 4, 5]).astype(np.int64)
shape_ts = helper.make_tensor(name='shape_tensor', shape_ts = helper.make_tensor(
data_type=TensorProto.INT32, name='shape_tensor',
dims=shape_val.shape, data_type=TensorProto.INT32,
vals=shape_val.flatten().astype(int)) dims=shape_val.shape,
vals=shape_val.flatten().astype(int))
shape_const = helper.make_node( shape_const = helper.make_node(
'Constant', 'Constant',
inputs=[], inputs=[],
...@@ -1449,9 +1426,8 @@ def expand_test(): ...@@ -1449,9 +1426,8 @@ def expand_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 1]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4, 5])
node = onnx.helper.make_node('Expand', node = onnx.helper.make_node(
inputs=['x', 'shape'], 'Expand', inputs=['x', 'shape'], outputs=['y'])
outputs=['y'])
return ([shape_const, node], [x], [y]) return ([shape_const, node], [x], [y])
...@@ -1507,10 +1483,8 @@ def eyelike_k_test(): ...@@ -1507,10 +1483,8 @@ def eyelike_k_test():
def eyelike_k_outofbounds_neg_test(): def eyelike_k_outofbounds_neg_test():
T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [2, 4]) T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [2, 4])
T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [2, 4]) T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [2, 4])
node = onnx.helper.make_node('EyeLike', node = onnx.helper.make_node(
inputs=['T1'], 'EyeLike', inputs=['T1'], outputs=['T2'], k=-2)
outputs=['T2'],
k=-2)
return ([node], [T1], [T2]) return ([node], [T1], [T2])
...@@ -1546,10 +1520,8 @@ def eyelike_verify_test(): ...@@ -1546,10 +1520,8 @@ def eyelike_verify_test():
def eyelike_verify_negk_test(): def eyelike_verify_negk_test():
T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4]) T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4]) T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
node = onnx.helper.make_node('EyeLike', node = onnx.helper.make_node(
inputs=['T1'], 'EyeLike', inputs=['T1'], outputs=['T2'], k=-2)
outputs=['T2'],
k=-2)
return ([node], [T1], [T2]) return ([node], [T1], [T2])
...@@ -1557,10 +1529,8 @@ def eyelike_verify_negk_test(): ...@@ -1557,10 +1529,8 @@ def eyelike_verify_negk_test():
def eyelike_set_dtype_test(): def eyelike_set_dtype_test():
T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4]) T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [3, 4]) T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [3, 4])
node = onnx.helper.make_node('EyeLike', node = onnx.helper.make_node(
inputs=['T1'], 'EyeLike', inputs=['T1'], outputs=['T2'], dtype=TensorProto.DOUBLE)
outputs=['T2'],
dtype=TensorProto.DOUBLE)
return ([node], [T1], [T2]) return ([node], [T1], [T2])
...@@ -1570,10 +1540,8 @@ def flatten_test(): ...@@ -1570,10 +1540,8 @@ def flatten_test():
y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [6, 20]) y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [6, 20])
y2 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [2, 60]) y2 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [2, 60])
node = onnx.helper.make_node('Flatten', node = onnx.helper.make_node(
inputs=['0'], 'Flatten', inputs=['0'], axis=2, outputs=['2'])
axis=2,
outputs=['2'])
node2 = onnx.helper.make_node('Flatten', inputs=['0'], outputs=['3']) node2 = onnx.helper.make_node('Flatten', inputs=['0'], outputs=['3'])
...@@ -1593,10 +1561,8 @@ def flatten_nonstd_test(): ...@@ -1593,10 +1561,8 @@ def flatten_nonstd_test():
perm=[0, 1, 3, 2], perm=[0, 1, 3, 2],
) )
node = onnx.helper.make_node('Flatten', node = onnx.helper.make_node(
inputs=['tx'], 'Flatten', inputs=['tx'], axis=2, outputs=['2'])
axis=2,
outputs=['2'])
node2 = onnx.helper.make_node('Flatten', inputs=['tx'], outputs=['3']) node2 = onnx.helper.make_node('Flatten', inputs=['tx'], outputs=['3'])
...@@ -1673,13 +1639,14 @@ def gemm_test(): ...@@ -1673,13 +1639,14 @@ def gemm_test():
z = helper.make_tensor_value_info('2', TensorProto.FLOAT, []) z = helper.make_tensor_value_info('2', TensorProto.FLOAT, [])
a = helper.make_tensor_value_info('3', TensorProto.FLOAT, [7, 11]) a = helper.make_tensor_value_info('3', TensorProto.FLOAT, [7, 11])
node = onnx.helper.make_node('Gemm', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'Gemm',
outputs=['3'], inputs=['0', '1', '2'],
alpha=2.0, outputs=['3'],
beta=2.0, alpha=2.0,
transA=1, beta=2.0,
transB=1) transA=1,
transB=1)
return ([node], [x, y, z], [a]) return ([node], [x, y, z], [a])
...@@ -1691,12 +1658,13 @@ def gemm_ex_test(): ...@@ -1691,12 +1658,13 @@ def gemm_ex_test():
m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 1, 6, 7]) m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 1, 6, 7])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 6, 7]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 6, 7])
node = onnx.helper.make_node('Gemm', node = onnx.helper.make_node(
inputs=['1', '2', '3'], 'Gemm',
outputs=['y'], inputs=['1', '2', '3'],
alpha=0.5, outputs=['y'],
beta=0.8, alpha=0.5,
transA=1) beta=0.8,
transA=1)
return ([node], [m1, m2, m3], [y]) return ([node], [m1, m2, m3], [y])
...@@ -1708,12 +1676,13 @@ def gemm_ex_brcst_test(): ...@@ -1708,12 +1676,13 @@ def gemm_ex_brcst_test():
m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 1, 6, 1]) m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 1, 6, 1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 6, 7]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 6, 7])
node = onnx.helper.make_node('Gemm', node = onnx.helper.make_node(
inputs=['1', '2', '3'], 'Gemm',
outputs=['y'], inputs=['1', '2', '3'],
alpha=0.5, outputs=['y'],
beta=0.8, alpha=0.5,
transA=1) beta=0.8,
transA=1)
return ([node], [m1, m2, m3], [y]) return ([node], [m1, m2, m3], [y])
...@@ -1725,12 +1694,13 @@ def gemm_half_test(): ...@@ -1725,12 +1694,13 @@ def gemm_half_test():
m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT16, [1, 1, 6, 1]) m3 = helper.make_tensor_value_info('3', TensorProto.FLOAT16, [1, 1, 6, 1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [1, 1, 6, 7]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [1, 1, 6, 7])
node = onnx.helper.make_node('Gemm', node = onnx.helper.make_node(
inputs=['1', '2', '3'], 'Gemm',
outputs=['y'], inputs=['1', '2', '3'],
alpha=0.5, outputs=['y'],
beta=0.8, alpha=0.5,
transA=1) beta=0.8,
transA=1)
return ([node], [m1, m2, m3], [y]) return ([node], [m1, m2, m3], [y])
...@@ -1766,10 +1736,11 @@ def globalmaxpool_test(): ...@@ -1766,10 +1736,11 @@ def globalmaxpool_test():
@onnx_test @onnx_test
def greater_test(): def greater_test():
ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
x1 = helper.make_tensor("x1", x1 = helper.make_tensor(
data_type=TensorProto.FLOAT, "x1",
dims=(2, 3), data_type=TensorProto.FLOAT,
vals=ax1.astype(np.float32)) dims=(2, 3),
vals=ax1.astype(np.float32))
x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3]) x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
...@@ -1848,11 +1819,8 @@ def hardsigmoid_double_test(): ...@@ -1848,11 +1819,8 @@ def hardsigmoid_double_test():
x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [1, 3, 4, 5]) x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [1, 3, 4, 5])
y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [1, 3, 4, 5]) y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [1, 3, 4, 5])
node = onnx.helper.make_node('HardSigmoid', node = onnx.helper.make_node(
inputs=['x'], 'HardSigmoid', inputs=['x'], outputs=['y'], alpha=0.3, beta=0.7)
outputs=['y'],
alpha=0.3,
beta=0.7)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -1892,32 +1860,30 @@ def if_else_test(): ...@@ -1892,32 +1860,30 @@ def if_else_test():
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3]) y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3])
then_out = onnx.helper.make_tensor_value_info('then_out', then_out = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'then_out', onnx.TensorProto.FLOAT, [2, 3])
[2, 3]) else_out = onnx.helper.make_tensor_value_info(
else_out = onnx.helper.make_tensor_value_info('else_out', 'else_out', onnx.TensorProto.FLOAT, [2, 3])
onnx.TensorProto.FLOAT,
[2, 3])
xt = np.ones((2, 3)).astype(np.float) xt = np.ones((2, 3)).astype(np.float)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
yt = np.random.randn(2, 3).astype(np.float) yt = np.random.randn(2, 3).astype(np.float)
yt_tensor = helper.make_tensor(name='yt', yt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='yt',
dims=yt.shape, data_type=TensorProto.FLOAT,
vals=yt.flatten().astype(np.float32)) dims=yt.shape,
vals=yt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['then_out'])
outputs=['then_out'])
else_mul_node = onnx.helper.make_node('Mul', else_mul_node = onnx.helper.make_node(
inputs=['y', 'yt'], 'Mul', inputs=['y', 'yt'], outputs=['else_out'])
outputs=['else_out'])
then_body = onnx.helper.make_graph([then_add_node], 'then_body', [], then_body = onnx.helper.make_graph([then_add_node], 'then_body', [],
[then_out]) [then_out])
...@@ -1926,17 +1892,19 @@ def if_else_test(): ...@@ -1926,17 +1892,19 @@ def if_else_test():
[else_out]) [else_out])
cond = np.array([0]).astype(np.bool) cond = np.array([0]).astype(np.bool)
cond_tensor = helper.make_tensor(name="cond", cond_tensor = helper.make_tensor(
data_type=TensorProto.BOOL, name="cond",
dims=cond.shape, data_type=TensorProto.BOOL,
vals=cond.astype(bool)) dims=cond.shape,
vals=cond.astype(bool))
res = onnx.helper.make_tensor_value_info('res', TensorProto.FLOAT, []) res = onnx.helper.make_tensor_value_info('res', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['res'], inputs=['cond'],
then_branch=then_body, outputs=['res'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor]) return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor])
...@@ -1980,23 +1948,22 @@ def if_literal_test(): ...@@ -1980,23 +1948,22 @@ def if_literal_test():
onnx.TensorProto.BOOL, []) onnx.TensorProto.BOOL, [])
ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, []) ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['ret'], inputs=['cond'],
then_branch=then_body, outputs=['ret'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [cond_input], [ret]) return ([node], [cond_input], [ret])
@onnx_test @onnx_test
def if_param_excp_test(): def if_param_excp_test():
then_out = onnx.helper.make_tensor_value_info('then_out', then_out = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'then_out', onnx.TensorProto.FLOAT, [2, 3])
[2, 3]) else_out = onnx.helper.make_tensor_value_info(
else_out = onnx.helper.make_tensor_value_info('else_out', 'else_out', onnx.TensorProto.FLOAT, [2, 3])
onnx.TensorProto.FLOAT,
[2, 3])
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 4]) y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 4])
...@@ -2004,23 +1971,23 @@ def if_param_excp_test(): ...@@ -2004,23 +1971,23 @@ def if_param_excp_test():
yt = np.random.randn(2, 4).astype(np.float) yt = np.random.randn(2, 4).astype(np.float)
xt = np.random.randn(2, 3).astype(np.float) xt = np.random.randn(2, 3).astype(np.float)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
yt_tensor = helper.make_tensor(name='yt', yt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='yt',
dims=yt.shape, data_type=TensorProto.FLOAT,
vals=yt.flatten().astype(np.float32)) dims=yt.shape,
vals=yt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['then_out'])
outputs=['then_out'])
else_mul_node = onnx.helper.make_node('Mul', else_mul_node = onnx.helper.make_node(
inputs=['y', 'yt'], 'Mul', inputs=['y', 'yt'], outputs=['else_out'])
outputs=['else_out'])
then_body = onnx.helper.make_graph([then_add_node], 'then_body', [], then_body = onnx.helper.make_graph([then_add_node], 'then_body', [],
[then_out], [xt_tensor]) [then_out], [xt_tensor])
...@@ -2032,33 +1999,33 @@ def if_param_excp_test(): ...@@ -2032,33 +1999,33 @@ def if_param_excp_test():
onnx.TensorProto.BOOL, []) onnx.TensorProto.BOOL, [])
ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, []) ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['ret'], inputs=['cond'],
then_branch=then_body, outputs=['ret'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [cond_input, x, y], [ret]) return ([node], [cond_input, x, y], [ret])
@onnx_test @onnx_test
def if_param_excp1_test(): def if_param_excp1_test():
then_out = onnx.helper.make_tensor_value_info('sub_out', then_out = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'sub_out', onnx.TensorProto.FLOAT, [2, 3])
[2, 3])
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
xt = np.random.randn(2, 3).astype(np.float) xt = np.random.randn(2, 3).astype(np.float)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['sub_out'])
outputs=['sub_out'])
sub_body = onnx.helper.make_graph([then_add_node], 'sub_body', [], sub_body = onnx.helper.make_graph([then_add_node], 'sub_body', [],
[then_out], [xt_tensor]) [then_out], [xt_tensor])
...@@ -2067,23 +2034,22 @@ def if_param_excp1_test(): ...@@ -2067,23 +2034,22 @@ def if_param_excp1_test():
onnx.TensorProto.BOOL, [2]) onnx.TensorProto.BOOL, [2])
ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, []) ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['ret'], inputs=['cond'],
then_branch=sub_body, outputs=['ret'],
else_branch=sub_body) then_branch=sub_body,
else_branch=sub_body)
return ([node], [cond_input, x], [ret]) return ([node], [cond_input, x], [ret])
@onnx_test @onnx_test
def if_param_test(): def if_param_test():
then_out = onnx.helper.make_tensor_value_info('then_out', then_out = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'then_out', onnx.TensorProto.FLOAT, [2, 3])
[2, 3]) else_out = onnx.helper.make_tensor_value_info(
else_out = onnx.helper.make_tensor_value_info('else_out', 'else_out', onnx.TensorProto.FLOAT, [2, 3])
onnx.TensorProto.FLOAT,
[2, 3])
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3]) y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3])
...@@ -2091,23 +2057,23 @@ def if_param_test(): ...@@ -2091,23 +2057,23 @@ def if_param_test():
yt = np.random.randn(2, 3).astype(np.float) yt = np.random.randn(2, 3).astype(np.float)
xt = np.random.randn(2, 3).astype(np.float) xt = np.random.randn(2, 3).astype(np.float)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
yt_tensor = helper.make_tensor(name='yt', yt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='yt',
dims=yt.shape, data_type=TensorProto.FLOAT,
vals=yt.flatten().astype(np.float32)) dims=yt.shape,
vals=yt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['then_out'])
outputs=['then_out'])
else_mul_node = onnx.helper.make_node('Mul', else_mul_node = onnx.helper.make_node(
inputs=['y', 'yt'], 'Mul', inputs=['y', 'yt'], outputs=['else_out'])
outputs=['else_out'])
then_body = onnx.helper.make_graph([then_add_node], 'then_body', [], then_body = onnx.helper.make_graph([then_add_node], 'then_body', [],
[then_out], [xt_tensor]) [then_out], [xt_tensor])
...@@ -2119,11 +2085,12 @@ def if_param_test(): ...@@ -2119,11 +2085,12 @@ def if_param_test():
onnx.TensorProto.BOOL, []) onnx.TensorProto.BOOL, [])
ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, []) ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['ret'], inputs=['cond'],
then_branch=then_body, outputs=['ret'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [cond_input, x, y], [ret]) return ([node], [cond_input, x, y], [ret])
...@@ -2132,14 +2099,12 @@ def if_param_test(): ...@@ -2132,14 +2099,12 @@ def if_param_test():
def if_pl_test(): def if_pl_test():
out_x = onnx.helper.make_tensor_value_info('out_x', onnx.TensorProto.FLOAT, out_x = onnx.helper.make_tensor_value_info('out_x', onnx.TensorProto.FLOAT,
[2, 3]) [2, 3])
out_l_x = onnx.helper.make_tensor_value_info('out_l_x', out_l_x = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'out_l_x', onnx.TensorProto.FLOAT, [2, 3])
[2, 3])
out_y = onnx.helper.make_tensor_value_info('out_y', onnx.TensorProto.FLOAT, out_y = onnx.helper.make_tensor_value_info('out_y', onnx.TensorProto.FLOAT,
[3, 3]) [3, 3])
out_l_y = onnx.helper.make_tensor_value_info('out_l_y', out_l_y = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'out_l_y', onnx.TensorProto.FLOAT, [3, 3])
[3, 3])
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [3, 3]) y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [3, 3])
...@@ -2147,23 +2112,23 @@ def if_pl_test(): ...@@ -2147,23 +2112,23 @@ def if_pl_test():
xt = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32) xt = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
yt = np.array([[8, 7, 6], [5, 4, 3], [2, 1, 0]]).astype(np.float32) yt = np.array([[8, 7, 6], [5, 4, 3], [2, 1, 0]]).astype(np.float32)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
yt_tensor = helper.make_tensor(name='yt', yt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='yt',
dims=yt.shape, data_type=TensorProto.FLOAT,
vals=yt.flatten().astype(np.float32)) dims=yt.shape,
vals=yt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['out_x'])
outputs=['out_x'])
else_mul_node = onnx.helper.make_node('Mul', else_mul_node = onnx.helper.make_node(
inputs=['y', 'yt'], 'Mul', inputs=['y', 'yt'], outputs=['out_y'])
outputs=['out_y'])
then_const_node = onnx.helper.make_node( then_const_node = onnx.helper.make_node(
'Constant', 'Constant',
...@@ -2187,11 +2152,12 @@ def if_pl_test(): ...@@ -2187,11 +2152,12 @@ def if_pl_test():
onnx.TensorProto.BOOL, []) onnx.TensorProto.BOOL, [])
ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, []) ret = onnx.helper.make_tensor_value_info('ret', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['ret'], inputs=['cond'],
then_branch=then_body, outputs=['ret'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [cond_input, x, y], [ret], [xt_tensor, yt_tensor]) return ([node], [cond_input, x, y], [ret], [xt_tensor, yt_tensor])
...@@ -2201,32 +2167,30 @@ def if_then_test(): ...@@ -2201,32 +2167,30 @@ def if_then_test():
x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3]) x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3]) y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3])
then_out = onnx.helper.make_tensor_value_info('then_out', then_out = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'then_out', onnx.TensorProto.FLOAT, [2, 3])
[2, 3]) else_out = onnx.helper.make_tensor_value_info(
else_out = onnx.helper.make_tensor_value_info('else_out', 'else_out', onnx.TensorProto.FLOAT, [2, 3])
onnx.TensorProto.FLOAT,
[2, 3])
xt = np.ones((2, 3)).astype(np.float) xt = np.ones((2, 3)).astype(np.float)
xt_tensor = helper.make_tensor(name='xt', xt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='xt',
dims=xt.shape, data_type=TensorProto.FLOAT,
vals=xt.flatten().astype(np.float32)) dims=xt.shape,
vals=xt.flatten().astype(np.float32))
yt = np.random.randn(2, 3).astype(np.float) yt = np.random.randn(2, 3).astype(np.float)
yt_tensor = helper.make_tensor(name='yt', yt_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='yt',
dims=yt.shape, data_type=TensorProto.FLOAT,
vals=yt.flatten().astype(np.float32)) dims=yt.shape,
vals=yt.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add', then_add_node = onnx.helper.make_node(
inputs=['x', 'xt'], 'Add', inputs=['x', 'xt'], outputs=['then_out'])
outputs=['then_out'])
else_mul_node = onnx.helper.make_node('Mul', else_mul_node = onnx.helper.make_node(
inputs=['y', 'yt'], 'Mul', inputs=['y', 'yt'], outputs=['else_out'])
outputs=['else_out'])
then_body = onnx.helper.make_graph([then_add_node], 'then_body', [], then_body = onnx.helper.make_graph([then_add_node], 'then_body', [],
[then_out]) [then_out])
...@@ -2235,17 +2199,19 @@ def if_then_test(): ...@@ -2235,17 +2199,19 @@ def if_then_test():
[else_out]) [else_out])
cond = np.array([1]).astype(np.bool) cond = np.array([1]).astype(np.bool)
cond_tensor = helper.make_tensor(name="cond", cond_tensor = helper.make_tensor(
data_type=TensorProto.BOOL, name="cond",
dims=cond.shape, data_type=TensorProto.BOOL,
vals=cond.astype(bool)) dims=cond.shape,
vals=cond.astype(bool))
res = onnx.helper.make_tensor_value_info('res', TensorProto.FLOAT, []) res = onnx.helper.make_tensor_value_info('res', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['res'], inputs=['cond'],
then_branch=then_body, outputs=['res'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor]) return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor])
...@@ -2257,50 +2223,45 @@ def if_tuple_test(): ...@@ -2257,50 +2223,45 @@ def if_tuple_test():
cond_input = onnx.helper.make_tensor_value_info('cond', cond_input = onnx.helper.make_tensor_value_info('cond',
onnx.TensorProto.BOOL, []) onnx.TensorProto.BOOL, [])
then_out0 = onnx.helper.make_tensor_value_info('then_out0', then_out0 = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'then_out0', onnx.TensorProto.FLOAT, [1, 4])
[1, 4]) then_out1 = onnx.helper.make_tensor_value_info(
then_out1 = onnx.helper.make_tensor_value_info('then_out1', 'then_out1', onnx.TensorProto.FLOAT, [3, 4])
onnx.TensorProto.FLOAT, else_out0 = onnx.helper.make_tensor_value_info(
[3, 4]) 'else_out0', onnx.TensorProto.FLOAT, [1, 4])
else_out0 = onnx.helper.make_tensor_value_info('else_out0', else_out1 = onnx.helper.make_tensor_value_info(
onnx.TensorProto.FLOAT, 'else_out1', onnx.TensorProto.FLOAT, [3, 4])
[1, 4])
else_out1 = onnx.helper.make_tensor_value_info('else_out1',
onnx.TensorProto.FLOAT,
[3, 4])
one = np.ones([1]).astype(np.float) one = np.ones([1]).astype(np.float)
one_tensor = helper.make_tensor(name='one', one_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='one',
dims=one.shape, data_type=TensorProto.FLOAT,
vals=one.flatten().astype(np.float32)) dims=one.shape,
vals=one.flatten().astype(np.float32))
two = np.array([2]).astype(np.float) two = np.array([2]).astype(np.float)
two_tensor = helper.make_tensor(name='two', two_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='two',
dims=two.shape, data_type=TensorProto.FLOAT,
vals=two.flatten().astype(np.float32)) dims=two.shape,
vals=two.flatten().astype(np.float32))
three = np.array([3]).astype(np.float) three = np.array([3]).astype(np.float)
three_tensor = helper.make_tensor(name='three', three_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='three',
dims=three.shape, data_type=TensorProto.FLOAT,
vals=three.flatten().astype(np.float32)) dims=three.shape,
vals=three.flatten().astype(np.float32))
then_add_node = onnx.helper.make_node('Add',
inputs=['x', 'one'], then_add_node = onnx.helper.make_node(
outputs=['then_out0']) 'Add', inputs=['x', 'one'], outputs=['then_out0'])
then_mul_node = onnx.helper.make_node('Mul', then_mul_node = onnx.helper.make_node(
inputs=['y', 'two'], 'Mul', inputs=['y', 'two'], outputs=['then_out1'])
outputs=['then_out1'])
else_mul_node = onnx.helper.make_node(
else_mul_node = onnx.helper.make_node('Mul', 'Mul', inputs=['x', 'three'], outputs=['else_out0'])
inputs=['x', 'three'], else_add_node = onnx.helper.make_node(
outputs=['else_out0']) 'Add', inputs=['y', 'three'], outputs=['else_out1'])
else_add_node = onnx.helper.make_node('Add',
inputs=['y', 'three'],
outputs=['else_out1'])
then_body = onnx.helper.make_graph([then_add_node, then_mul_node], then_body = onnx.helper.make_graph([then_add_node, then_mul_node],
'then_body', [], [then_out0, then_out1]) 'then_body', [], [then_out0, then_out1])
...@@ -2311,14 +2272,15 @@ def if_tuple_test(): ...@@ -2311,14 +2272,15 @@ def if_tuple_test():
res0 = onnx.helper.make_tensor_value_info('res0', TensorProto.FLOAT, []) res0 = onnx.helper.make_tensor_value_info('res0', TensorProto.FLOAT, [])
res1 = onnx.helper.make_tensor_value_info('res1', TensorProto.FLOAT, []) res1 = onnx.helper.make_tensor_value_info('res1', TensorProto.FLOAT, [])
node = onnx.helper.make_node('If', node = onnx.helper.make_node(
inputs=['cond'], 'If',
outputs=['res0', 'res1'], inputs=['cond'],
then_branch=then_body, outputs=['res0', 'res1'],
else_branch=else_body) then_branch=then_body,
else_branch=else_body)
return ([node], [cond_input, x, return ([node], [cond_input, x, y], [res0, res1],
y], [res0, res1], [one_tensor, two_tensor, three_tensor]) [one_tensor, two_tensor, three_tensor])
@onnx_test @onnx_test
...@@ -2326,11 +2288,12 @@ def imagescaler_test(): ...@@ -2326,11 +2288,12 @@ def imagescaler_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 16, 16]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 16, 16])
node = onnx.helper.make_node('ImageScaler', node = onnx.helper.make_node(
inputs=['0'], 'ImageScaler',
outputs=['1'], inputs=['0'],
bias=[0.01, 0.02, 0.03], outputs=['1'],
scale=0.5) bias=[0.01, 0.02, 0.03],
scale=0.5)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2340,11 +2303,12 @@ def imagescaler_half_test(): ...@@ -2340,11 +2303,12 @@ def imagescaler_half_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1, 3, 16, 16]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1, 3, 16, 16])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1, 3, 16, 16]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1, 3, 16, 16])
node = onnx.helper.make_node('ImageScaler', node = onnx.helper.make_node(
inputs=['0'], 'ImageScaler',
outputs=['1'], inputs=['0'],
bias=[0.01, 0.02, 0.03], outputs=['1'],
scale=0.5) bias=[0.01, 0.02, 0.03],
scale=0.5)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2399,10 +2363,11 @@ def implicit_sub_bcast_test(): ...@@ -2399,10 +2363,11 @@ def implicit_sub_bcast_test():
@onnx_test @onnx_test
def initializer_not_an_input(): def initializer_not_an_input():
values = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) values = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
w = helper.make_tensor(name='w', w = helper.make_tensor(
data_type=TensorProto.FLOAT, name='w',
dims=values.shape, data_type=TensorProto.FLOAT,
vals=values.flatten().astype(np.float)) dims=values.shape,
vals=values.flatten().astype(np.float))
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [5, 2]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [5, 2])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [5, 4]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [5, 4])
...@@ -2423,32 +2388,34 @@ def instance_norm_test(): ...@@ -2423,32 +2388,34 @@ def instance_norm_test():
bias = helper.make_tensor_value_info('2', TensorProto.FLOAT, [2]) bias = helper.make_tensor_value_info('2', TensorProto.FLOAT, [2])
y = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 2, 3, 3]) y = helper.make_tensor_value_info('3', TensorProto.FLOAT, [1, 2, 3, 3])
node = onnx.helper.make_node('InstanceNormalization', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'InstanceNormalization', inputs=['0', '1', '2'], outputs=['3'])
outputs=['3'])
return ([node], [x, scale, bias], [y]) return ([node], [x, scale, bias], [y])
@onnx_test @onnx_test
def instance_norm_val_test(): def instance_norm_val_test():
x = np.array([[[[0, 1, 2], [3, 4, 5], [6, 7, 8]], x = np.array([[[[0, 1, 2], [3, 4, 5], [6, 7, 8]], [[0, 1, 2], [3, 4, 5],
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]]]) [6, 7, 8]]]])
scale = np.array([1, 2]) scale = np.array([1, 2])
bias = np.array([0, 1]) bias = np.array([0, 1])
x_tensor = helper.make_tensor(name='x_tensor', x_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='x_tensor',
dims=x.shape, data_type=TensorProto.FLOAT,
vals=x.flatten().astype(np.float)) dims=x.shape,
scale_tensor = helper.make_tensor(name='scale_tensor', vals=x.flatten().astype(np.float))
data_type=TensorProto.FLOAT, scale_tensor = helper.make_tensor(
dims=scale.shape, name='scale_tensor',
vals=scale.flatten().astype(np.float)) data_type=TensorProto.FLOAT,
bias_tensor = helper.make_tensor(name='bias_tensor', dims=scale.shape,
data_type=TensorProto.FLOAT, vals=scale.flatten().astype(np.float))
dims=bias.shape, bias_tensor = helper.make_tensor(
vals=bias.flatten().astype(np.float)) name='bias_tensor',
data_type=TensorProto.FLOAT,
dims=bias.shape,
vals=bias.flatten().astype(np.float))
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 3, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 3, 3])
...@@ -2462,23 +2429,26 @@ def instance_norm_val_test(): ...@@ -2462,23 +2429,26 @@ def instance_norm_val_test():
@onnx_test @onnx_test
def instance_norm_val_3d_test(): def instance_norm_val_3d_test():
x = np.array([[[[[0, 1], [2, 3]], [[4, 5], [6, 7]]], x = np.array([[[[[0, 1], [2, 3]], [[4, 5], [6, 7]]], [[[0, 1], [2, 3]],
[[[0, 1], [2, 3]], [[4, 5], [6, 7]]]]]) [[4, 5], [6, 7]]]]])
scale = np.array([1, 2]) scale = np.array([1, 2])
bias = np.array([0, 1]) bias = np.array([0, 1])
x_tensor = helper.make_tensor(name='x_tensor', x_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='x_tensor',
dims=x.shape, data_type=TensorProto.FLOAT,
vals=x.flatten().astype(np.float)) dims=x.shape,
scale_tensor = helper.make_tensor(name='scale_tensor', vals=x.flatten().astype(np.float))
data_type=TensorProto.FLOAT, scale_tensor = helper.make_tensor(
dims=scale.shape, name='scale_tensor',
vals=scale.flatten().astype(np.float)) data_type=TensorProto.FLOAT,
bias_tensor = helper.make_tensor(name='bias_tensor', dims=scale.shape,
data_type=TensorProto.FLOAT, vals=scale.flatten().astype(np.float))
dims=bias.shape, bias_tensor = helper.make_tensor(
vals=bias.flatten().astype(np.float)) name='bias_tensor',
data_type=TensorProto.FLOAT,
dims=bias.shape,
vals=bias.flatten().astype(np.float))
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 2, 2, 2]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 2, 2, 2, 2])
...@@ -2526,57 +2496,47 @@ def layernorm_test(): ...@@ -2526,57 +2496,47 @@ def layernorm_test():
pow_2 = np.array([[[2, 2, 2, 2, 2]]]) pow_2 = np.array([[[2, 2, 2, 2, 2]]])
epsilon = np.array([1e-12]) epsilon = np.array([1e-12])
pow_tensor = helper.make_tensor(name='pow', pow_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='pow',
dims=pow_2.shape, data_type=TensorProto.FLOAT,
vals=pow_2.flatten().astype(np.float)) dims=pow_2.shape,
vals=pow_2.flatten().astype(np.float))
epsilon_tensor = helper.make_tensor(name='epsilon', epsilon_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='epsilon',
dims=epsilon.shape, data_type=TensorProto.FLOAT,
vals=epsilon.flatten().astype( dims=epsilon.shape,
np.float)) vals=epsilon.flatten().astype(np.float))
mean = onnx.helper.make_node('ReduceMean', mean = onnx.helper.make_node(
inputs=['0'], 'ReduceMean', inputs=['0'], outputs=['mean_out'], axes=axes)
outputs=['mean_out'],
axes=axes)
sub_mean = onnx.helper.make_node('Sub', sub_mean = onnx.helper.make_node(
inputs=['0', 'mean_out'], 'Sub', inputs=['0', 'mean_out'], outputs=['sub_out'])
outputs=['sub_out'])
sub_pow = onnx.helper.make_node('Pow', sub_pow = onnx.helper.make_node(
inputs=['sub_out', 'pow'], 'Pow', inputs=['sub_out', 'pow'], outputs=['pow_out'])
outputs=['pow_out'])
var = onnx.helper.make_node('ReduceMean', var = onnx.helper.make_node(
inputs=['pow_out'], 'ReduceMean', inputs=['pow_out'], outputs=['var_out'], axes=axes)
outputs=['var_out'],
axes=axes)
add = onnx.helper.make_node('Add', add = onnx.helper.make_node(
inputs=['var_out', 'epsilon'], 'Add', inputs=['var_out', 'epsilon'], outputs=['add_out'])
outputs=['add_out'])
sqrt = onnx.helper.make_node('Sqrt', sqrt = onnx.helper.make_node(
inputs=['add_out'], 'Sqrt', inputs=['add_out'], outputs=['sqrt_out'])
outputs=['sqrt_out'])
div = onnx.helper.make_node('Div', div = onnx.helper.make_node(
inputs=['sub_out', 'sqrt_out'], 'Div', inputs=['sub_out', 'sqrt_out'], outputs=['div_out'])
outputs=['div_out'])
mul = onnx.helper.make_node('Mul', mul = onnx.helper.make_node(
inputs=['scale', 'div_out'], 'Mul', inputs=['scale', 'div_out'], outputs=['mul_out'])
outputs=['mul_out'])
bias_add = onnx.helper.make_node('Add', bias_add = onnx.helper.make_node(
inputs=['mul_out', 'bias'], 'Add', inputs=['mul_out', 'bias'], outputs=['1'])
outputs=['1'])
return ([mean, sub_mean, sub_pow, var, add, sqrt, div, mul, return ([mean, sub_mean, sub_pow, var, add, sqrt, div, mul, bias_add],
bias_add], [x, scale, bias], [y], [pow_tensor, epsilon_tensor]) [x, scale, bias], [y], [pow_tensor, epsilon_tensor])
@onnx_test @onnx_test
...@@ -2584,10 +2544,8 @@ def leaky_relu_test(): ...@@ -2584,10 +2544,8 @@ def leaky_relu_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
node = onnx.helper.make_node('LeakyRelu', node = onnx.helper.make_node(
inputs=['0'], 'LeakyRelu', inputs=['0'], outputs=['1'], alpha=0.01)
outputs=['1'],
alpha=0.01)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2595,10 +2553,11 @@ def leaky_relu_test(): ...@@ -2595,10 +2553,11 @@ def leaky_relu_test():
@onnx_test @onnx_test
def less_test(): def less_test():
ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
x1 = helper.make_tensor("x1", x1 = helper.make_tensor(
data_type=TensorProto.FLOAT, "x1",
dims=(2, 3), data_type=TensorProto.FLOAT,
vals=ax1.astype(np.float32)) dims=(2, 3),
vals=ax1.astype(np.float32))
x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3]) x2 = helper.make_tensor_value_info('x2', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
...@@ -2698,10 +2657,8 @@ def logsoftmax_test(): ...@@ -2698,10 +2657,8 @@ def logsoftmax_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5, 6])
node = onnx.helper.make_node('LogSoftmax', node = onnx.helper.make_node(
inputs=['x'], 'LogSoftmax', inputs=['x'], outputs=['y'], axis=1)
outputs=['y'],
axis=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2711,17 +2668,16 @@ def logsoftmax_nonstd_input_test(): ...@@ -2711,17 +2668,16 @@ def logsoftmax_nonstd_input_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 9]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 9])
y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4]) y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4])
node0 = onnx.helper.make_node('Slice', node0 = onnx.helper.make_node(
inputs=['0'], 'Slice',
axes=[0, 1], inputs=['0'],
starts=[1, 0], axes=[0, 1],
ends=[4, 4], starts=[1, 0],
outputs=['1']) ends=[4, 4],
outputs=['1'])
node1 = onnx.helper.make_node('LogSoftmax', node1 = onnx.helper.make_node(
inputs=['1'], 'LogSoftmax', inputs=['1'], outputs=['2'], axis=-1)
outputs=['2'],
axis=-1)
return ([node0, node1], [x], [y]) return ([node0, node1], [x], [y])
...@@ -2809,10 +2765,8 @@ def lpnormalization_axis_error_test(): ...@@ -2809,10 +2765,8 @@ def lpnormalization_axis_error_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
node = onnx.helper.make_node('LpNormalization', node = onnx.helper.make_node(
inputs=['x'], 'LpNormalization', inputs=['x'], outputs=['y'], axis=2)
outputs=['y'],
axis=2)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2849,10 +2803,8 @@ def lpnormalization_l2_test(): ...@@ -2849,10 +2803,8 @@ def lpnormalization_l2_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
node = onnx.helper.make_node('LpNormalization', node = onnx.helper.make_node(
inputs=['x'], 'LpNormalization', inputs=['x'], outputs=['y'], p=2)
outputs=['y'],
p=2)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2861,10 +2813,8 @@ def lpnormalization_p_error_test(): ...@@ -2861,10 +2813,8 @@ def lpnormalization_p_error_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
node = onnx.helper.make_node('LpNormalization', node = onnx.helper.make_node(
inputs=['x'], 'LpNormalization', inputs=['x'], outputs=['y'], p=3)
outputs=['y'],
p=3)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -2873,13 +2823,14 @@ def lrn_test(): ...@@ -2873,13 +2823,14 @@ def lrn_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 28, 24, 24]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 28, 24, 24])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 28, 24, 24]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 28, 24, 24])
node = onnx.helper.make_node('LRN', node = onnx.helper.make_node(
inputs=['0'], 'LRN',
size=5, inputs=['0'],
alpha=0.0001, size=5,
beta=0.75, alpha=0.0001,
bias=1.0, beta=0.75,
outputs=['1']) bias=1.0,
outputs=['1'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3010,13 +2961,14 @@ def maxpool_notset_test(): ...@@ -3010,13 +2961,14 @@ def maxpool_notset_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
node = onnx.helper.make_node('MaxPool', node = onnx.helper.make_node(
inputs=['x'], 'MaxPool',
outputs=['y'], inputs=['x'],
kernel_shape=[6, 6], outputs=['y'],
strides=[2, 2], kernel_shape=[6, 6],
pads=[0, 0, 1, 1], strides=[2, 2],
auto_pad='NOTSET') pads=[0, 0, 1, 1],
auto_pad='NOTSET')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3026,11 +2978,12 @@ def maxpool_same_upper_test(): ...@@ -3026,11 +2978,12 @@ def maxpool_same_upper_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
node = onnx.helper.make_node('MaxPool', node = onnx.helper.make_node(
inputs=['x'], 'MaxPool',
outputs=['y'], inputs=['x'],
kernel_shape=[2, 2], outputs=['y'],
auto_pad='SAME_UPPER') kernel_shape=[2, 2],
auto_pad='SAME_UPPER')
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3047,9 +3000,8 @@ def mean_broadcast_test(): ...@@ -3047,9 +3000,8 @@ def mean_broadcast_test():
mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT, mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT,
[1, 2, 3, 4]) [1, 2, 3, 4])
node = onnx.helper.make_node("Mean", node = onnx.helper.make_node(
inputs=["0", "1", "2", "3", "4"], "Mean", inputs=["0", "1", "2", "3", "4"], outputs=["mean"])
outputs=["mean"])
return ([node], [data_0, data_1, data_2, data_3, data_4], [mean]) return ([node], [data_0, data_1, data_2, data_3, data_4], [mean])
...@@ -3063,9 +3015,8 @@ def mean_fp16_test(): ...@@ -3063,9 +3015,8 @@ def mean_fp16_test():
mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT16, mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT16,
[1, 2, 3]) [1, 2, 3])
node = onnx.helper.make_node("Mean", node = onnx.helper.make_node(
inputs=["0", "1", "2"], "Mean", inputs=["0", "1", "2"], outputs=["mean"])
outputs=["mean"])
return ([node], [data_0, data_1, data_2], [mean]) return ([node], [data_0, data_1, data_2], [mean])
...@@ -3078,9 +3029,8 @@ def mean_invalid_broadcast_test(): ...@@ -3078,9 +3029,8 @@ def mean_invalid_broadcast_test():
mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT, [1, 2, 3]) mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT, [1, 2, 3])
node = onnx.helper.make_node("Mean", node = onnx.helper.make_node(
inputs=["0", "1", "2"], "Mean", inputs=["0", "1", "2"], outputs=["mean"])
outputs=["mean"])
return ([node], [data_0, data_1, data_2], [mean]) return ([node], [data_0, data_1, data_2], [mean])
...@@ -3133,11 +3083,12 @@ def multinomial_test(): ...@@ -3133,11 +3083,12 @@ def multinomial_test():
output = helper.make_tensor_value_info("output", TensorProto.INT32, output = helper.make_tensor_value_info("output", TensorProto.INT32,
[1, 10]) [1, 10])
node = onnx.helper.make_node('Multinomial', node = onnx.helper.make_node(
inputs=['input'], 'Multinomial',
sample_size=sample_size, inputs=['input'],
seed=seed, sample_size=sample_size,
outputs=['output']) seed=seed,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3149,10 +3100,11 @@ def multinomial_generated_seed_test(): ...@@ -3149,10 +3100,11 @@ def multinomial_generated_seed_test():
output = helper.make_tensor_value_info("output", TensorProto.INT32, output = helper.make_tensor_value_info("output", TensorProto.INT32,
[1, 10]) [1, 10])
node = onnx.helper.make_node('Multinomial', node = onnx.helper.make_node(
inputs=['input'], 'Multinomial',
sample_size=sample_size, inputs=['input'],
outputs=['output']) sample_size=sample_size,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3165,11 +3117,12 @@ def multinomial_dtype_error_test(): ...@@ -3165,11 +3117,12 @@ def multinomial_dtype_error_test():
output = helper.make_tensor_value_info("output", TensorProto.INT64, output = helper.make_tensor_value_info("output", TensorProto.INT64,
[1, 10]) [1, 10])
node = onnx.helper.make_node('Multinomial', node = onnx.helper.make_node(
inputs=['input'], 'Multinomial',
sample_size=sample_size, inputs=['input'],
dtype=dtype, sample_size=sample_size,
outputs=['output']) dtype=dtype,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3183,12 +3136,13 @@ def multinomial_int64_test(): ...@@ -3183,12 +3136,13 @@ def multinomial_int64_test():
output = helper.make_tensor_value_info("output", TensorProto.INT64, output = helper.make_tensor_value_info("output", TensorProto.INT64,
[1, 10]) [1, 10])
node = onnx.helper.make_node('Multinomial', node = onnx.helper.make_node(
inputs=['input'], 'Multinomial',
sample_size=sample_size, inputs=['input'],
dtype=dtype, sample_size=sample_size,
seed=seed, dtype=dtype,
outputs=['output']) seed=seed,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3216,14 +3170,14 @@ def nms_test(): ...@@ -3216,14 +3170,14 @@ def nms_test():
out = helper.make_tensor_value_info('selected_indices', TensorProto.INT64, out = helper.make_tensor_value_info('selected_indices', TensorProto.INT64,
[6, 3]) [6, 3])
node = onnx.helper.make_node('NonMaxSuppression', node = onnx.helper.make_node(
inputs=[ 'NonMaxSuppression',
'boxes', 'scores', inputs=[
'max_output_boxes_per_class', 'boxes', 'scores', 'max_output_boxes_per_class', 'iou_threshold',
'iou_threshold', 'score_threshold' 'score_threshold'
], ],
outputs=['selected_indices'], outputs=['selected_indices'],
center_point_box=1) center_point_box=1)
return ([node], [b, s, mo, iou, st], [out]) return ([node], [b, s, mo, iou, st], [out])
...@@ -3253,10 +3207,8 @@ def no_pad_test(): ...@@ -3253,10 +3207,8 @@ def no_pad_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 2]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 2])
node = onnx.helper.make_node('Pad', node = onnx.helper.make_node(
inputs=['0'], 'Pad', inputs=['0'], pads=[0, 0, 0, 0], outputs=['1'])
pads=[0, 0, 0, 0],
outputs=['1'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3266,9 +3218,8 @@ def nonzero_dynamic_test(): ...@@ -3266,9 +3218,8 @@ def nonzero_dynamic_test():
x = helper.make_tensor_value_info('data', TensorProto.BOOL, [2, 2]) x = helper.make_tensor_value_info('data', TensorProto.BOOL, [2, 2])
y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 3]) y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 3])
node = onnx.helper.make_node('NonZero', node = onnx.helper.make_node(
inputs=['data'], 'NonZero', inputs=['data'], outputs=['indices'])
outputs=['indices'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3276,15 +3227,15 @@ def nonzero_dynamic_test(): ...@@ -3276,15 +3227,15 @@ def nonzero_dynamic_test():
@onnx_test @onnx_test
def nonzero_test(): def nonzero_test():
data1 = np.array([[1., 0.], [1., 1.]]) data1 = np.array([[1., 0.], [1., 1.]])
data = helper.make_tensor(name='data', data = helper.make_tensor(
data_type=TensorProto.FLOAT, name='data',
dims=data1.shape, data_type=TensorProto.FLOAT,
vals=data1.flatten().astype(np.float)) dims=data1.shape,
vals=data1.flatten().astype(np.float))
y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 3]) y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 3])
node = onnx.helper.make_node('NonZero', node = onnx.helper.make_node(
inputs=['data'], 'NonZero', inputs=['data'], outputs=['indices'])
outputs=['indices'])
return ([node], [], [y], [data]) return ([node], [], [y], [data])
...@@ -3292,15 +3243,15 @@ def nonzero_test(): ...@@ -3292,15 +3243,15 @@ def nonzero_test():
@onnx_test @onnx_test
def nonzero_int_test(): def nonzero_int_test():
data1 = np.array([[1, 1, 0], [1, 0, 1]]) data1 = np.array([[1, 1, 0], [1, 0, 1]])
data = helper.make_tensor(name='data', data = helper.make_tensor(
data_type=TensorProto.INT16, name='data',
dims=data1.shape, data_type=TensorProto.INT16,
vals=data1.flatten().astype(np.int16)) dims=data1.shape,
vals=data1.flatten().astype(np.int16))
y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 4]) y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 4])
node = onnx.helper.make_node('NonZero', node = onnx.helper.make_node(
inputs=['data'], 'NonZero', inputs=['data'], outputs=['indices'])
outputs=['indices'])
return ([node], [], [y], [data]) return ([node], [], [y], [data])
...@@ -3314,15 +3265,17 @@ def onehot_test(): ...@@ -3314,15 +3265,17 @@ def onehot_test():
values = helper.make_tensor_value_info("values", TensorProto.FLOAT16, [2]) values = helper.make_tensor_value_info("values", TensorProto.FLOAT16, [2])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [3, 5, 2]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [3, 5, 2])
depth_tensor = helper.make_tensor(name="depth", depth_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="depth",
dims=None, data_type=TensorProto.INT32,
vals=depth.astype(int)) dims=None,
vals=depth.astype(int))
node = onnx.helper.make_node('OneHot', node = onnx.helper.make_node(
inputs=['indices', 'depth', 'values'], 'OneHot',
outputs=['y'], inputs=['indices', 'depth', 'values'],
axis=axis_value) outputs=['y'],
axis=axis_value)
return ([node], [indices, values], [y], [depth_tensor]) return ([node], [indices, values], [y], [depth_tensor])
...@@ -3332,10 +3285,8 @@ def pad_test(): ...@@ -3332,10 +3285,8 @@ def pad_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 4]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 4])
node = onnx.helper.make_node('Pad', node = onnx.helper.make_node(
inputs=['0'], 'Pad', inputs=['0'], pads=[1, 1, 1, 1], outputs=['1'])
pads=[1, 1, 1, 1],
outputs=['1'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3343,31 +3294,28 @@ def pad_test(): ...@@ -3343,31 +3294,28 @@ def pad_test():
@onnx_test @onnx_test
def pad_3arg_test(): def pad_3arg_test():
values = np.array([1]) values = np.array([1])
val_tensor = helper.make_tensor(name='val', val_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='val',
dims=values.reshape(()).shape, data_type=TensorProto.FLOAT,
vals=values.astype(float)) dims=values.reshape(()).shape,
arg_val = onnx.helper.make_node('Constant', vals=values.astype(float))
inputs=[], arg_val = onnx.helper.make_node(
outputs=['arg_val'], 'Constant', inputs=[], outputs=['arg_val'], value=val_tensor)
value=val_tensor)
sizes = np.array([1, 1, 2, 2]) sizes = np.array([1, 1, 2, 2])
pad_tensor = helper.make_tensor(name='pad_size', pad_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='pad_size',
dims=sizes.shape, data_type=TensorProto.INT32,
vals=sizes.astype(int)) dims=sizes.shape,
arg_pad = onnx.helper.make_node('Constant', vals=sizes.astype(int))
inputs=[], arg_pad = onnx.helper.make_node(
outputs=['arg_pad'], 'Constant', inputs=[], outputs=['arg_pad'], value=pad_tensor)
value=pad_tensor)
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [5, 5]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [5, 5])
node = onnx.helper.make_node('Pad', node = onnx.helper.make_node(
inputs=['0', 'arg_pad', 'arg_val'], 'Pad', inputs=['0', 'arg_pad', 'arg_val'], outputs=['1'])
outputs=['1'])
return ([arg_val, arg_pad, node], [x], [y]) return ([arg_val, arg_pad, node], [x], [y])
...@@ -3378,19 +3326,16 @@ def pad_reflect_test(): ...@@ -3378,19 +3326,16 @@ def pad_reflect_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5])
sizes = np.array([0, 2, 0, 1]) sizes = np.array([0, 2, 0, 1])
pad_tensor = helper.make_tensor(name='pad_size', pad_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='pad_size',
dims=sizes.shape, data_type=TensorProto.INT32,
vals=sizes.astype(int)) dims=sizes.shape,
arg_pad = onnx.helper.make_node('Constant', vals=sizes.astype(int))
inputs=[], arg_pad = onnx.helper.make_node(
outputs=['arg_pad'], 'Constant', inputs=[], outputs=['arg_pad'], value=pad_tensor)
value=pad_tensor)
node = onnx.helper.make_node(
node = onnx.helper.make_node('Pad', 'Pad', mode='reflect', inputs=['0', 'arg_pad'], outputs=['1'])
mode='reflect',
inputs=['0', 'arg_pad'],
outputs=['1'])
return ([arg_pad, node], [x], [y]) return ([arg_pad, node], [x], [y])
...@@ -3401,19 +3346,16 @@ def pad_reflect_multiaxis_test(): ...@@ -3401,19 +3346,16 @@ def pad_reflect_multiaxis_test():
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 5]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 5])
sizes = np.array([0, 2, 2, 0]) sizes = np.array([0, 2, 2, 0])
pad_tensor = helper.make_tensor(name='pad_size', pad_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='pad_size',
dims=sizes.shape, data_type=TensorProto.INT32,
vals=sizes.astype(int)) dims=sizes.shape,
arg_pad = onnx.helper.make_node('Constant', vals=sizes.astype(int))
inputs=[], arg_pad = onnx.helper.make_node(
outputs=['arg_pad'], 'Constant', inputs=[], outputs=['arg_pad'], value=pad_tensor)
value=pad_tensor)
node = onnx.helper.make_node(
node = onnx.helper.make_node('Pad', 'Pad', mode='reflect', inputs=['0', 'arg_pad'], outputs=['1'])
mode='reflect',
inputs=['0', 'arg_pad'],
outputs=['1'])
return ([arg_pad, node], [x], [y]) return ([arg_pad, node], [x], [y])
...@@ -3471,15 +3413,13 @@ def prefix_scan_sum_test(): ...@@ -3471,15 +3413,13 @@ def prefix_scan_sum_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 2]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 2])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 2]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 2])
axis_val = np.array([0]) axis_val = np.array([0])
axis_tensor = helper.make_tensor(name="axis", axis_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="axis",
dims=axis_val.shape, data_type=TensorProto.INT32,
vals=axis_val.astype(int)) dims=axis_val.shape,
node = onnx.helper.make_node('CumSum', vals=axis_val.astype(int))
inputs=['x', 'axis'], node = onnx.helper.make_node(
outputs=['y'], 'CumSum', inputs=['x', 'axis'], outputs=['y'], exclusive=1, reverse=1)
exclusive=1,
reverse=1)
return ([node], [x], [y], [axis_tensor]) return ([node], [x], [y], [axis_tensor])
...@@ -3552,10 +3492,8 @@ def make_quantizelinear_axis_graph(axis): ...@@ -3552,10 +3492,8 @@ def make_quantizelinear_axis_graph(axis):
arg_out = helper.make_tensor_value_info('out', TensorProto.INT8, arg_out = helper.make_tensor_value_info('out', TensorProto.INT8,
[1, 1, 5, 1]) [1, 1, 5, 1])
node = onnx.helper.make_node('QuantizeLinear', node = onnx.helper.make_node(
inputs=['0', '1', '2'], 'QuantizeLinear', inputs=['0', '1', '2'], outputs=['out'], axis=axis)
outputs=['out'],
axis=axis)
return ([node], [arg0, arg1, arg2], [arg_out]) return ([node], [arg0, arg1, arg2], [arg_out])
...@@ -3580,14 +3518,15 @@ def randomnormal_test(): ...@@ -3580,14 +3518,15 @@ def randomnormal_test():
output = helper.make_tensor_value_info('output', TensorProto.DOUBLE, output = helper.make_tensor_value_info('output', TensorProto.DOUBLE,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomNormal', node = onnx.helper.make_node(
inputs=[], 'RandomNormal',
outputs=['output'], inputs=[],
dtype=dtype, outputs=['output'],
mean=mean, dtype=dtype,
scale=scale, mean=mean,
seed=seed, scale=scale,
shape=shape) seed=seed,
shape=shape)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3599,11 +3538,12 @@ def randomnormal_dtype_error_test(): ...@@ -3599,11 +3538,12 @@ def randomnormal_dtype_error_test():
output = helper.make_tensor_value_info('output', TensorProto.INT32, output = helper.make_tensor_value_info('output', TensorProto.INT32,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomNormal', node = onnx.helper.make_node(
inputs=[], 'RandomNormal',
outputs=['output'], inputs=[],
dtype=dtype, outputs=['output'],
shape=shape) dtype=dtype,
shape=shape)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3615,10 +3555,11 @@ def randomnormal_generated_seed_test(): ...@@ -3615,10 +3555,11 @@ def randomnormal_generated_seed_test():
output = helper.make_tensor_value_info("output", TensorProto.INT32, output = helper.make_tensor_value_info("output", TensorProto.INT32,
[1, 10]) [1, 10])
node = onnx.helper.make_node('RandomNormal', node = onnx.helper.make_node(
inputs=['input'], 'RandomNormal',
sample_size=sample_size, inputs=['input'],
outputs=['output']) sample_size=sample_size,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3629,10 +3570,8 @@ def randomnormal_shape_error_test(): ...@@ -3629,10 +3570,8 @@ def randomnormal_shape_error_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomNormal', node = onnx.helper.make_node(
inputs=[], 'RandomNormal', inputs=[], outputs=['output'], dtype=dtype)
outputs=['output'],
dtype=dtype)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3648,13 +3587,14 @@ def randomnormallike_test(): ...@@ -3648,13 +3587,14 @@ def randomnormallike_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT16, output = helper.make_tensor_value_info('output', TensorProto.FLOAT16,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomNormalLike', node = onnx.helper.make_node(
inputs=['input'], 'RandomNormalLike',
outputs=['output'], inputs=['input'],
dtype=dtype, outputs=['output'],
mean=mean, dtype=dtype,
scale=scale, mean=mean,
seed=seed) scale=scale,
seed=seed)
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3667,10 +3607,8 @@ def randomnormallike_type_error_test(): ...@@ -3667,10 +3607,8 @@ def randomnormallike_type_error_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomNormalLike', node = onnx.helper.make_node(
inputs=['input'], 'RandomNormalLike', inputs=['input'], outputs=['output'], seed=seed)
outputs=['output'],
seed=seed)
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3685,14 +3623,15 @@ def randomuniform_test(): ...@@ -3685,14 +3623,15 @@ def randomuniform_test():
output = helper.make_tensor_value_info('output', TensorProto.DOUBLE, output = helper.make_tensor_value_info('output', TensorProto.DOUBLE,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomUniform', node = onnx.helper.make_node(
inputs=[], 'RandomUniform',
outputs=['output'], inputs=[],
dtype=dtype, outputs=['output'],
high=high, dtype=dtype,
low=low, high=high,
seed=seed, low=low,
shape=shape) seed=seed,
shape=shape)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3704,11 +3643,12 @@ def randomuniform_dtype_error_test(): ...@@ -3704,11 +3643,12 @@ def randomuniform_dtype_error_test():
output = helper.make_tensor_value_info('output', TensorProto.INT32, output = helper.make_tensor_value_info('output', TensorProto.INT32,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomUniform', node = onnx.helper.make_node(
inputs=[], 'RandomUniform',
outputs=['output'], inputs=[],
dtype=dtype, outputs=['output'],
shape=shape) dtype=dtype,
shape=shape)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3720,10 +3660,11 @@ def randomuniform_generated_seed_test(): ...@@ -3720,10 +3660,11 @@ def randomuniform_generated_seed_test():
output = helper.make_tensor_value_info("output", TensorProto.INT32, output = helper.make_tensor_value_info("output", TensorProto.INT32,
[1, 10]) [1, 10])
node = onnx.helper.make_node('RandomUniform', node = onnx.helper.make_node(
inputs=['input'], 'RandomUniform',
sample_size=sample_size, inputs=['input'],
outputs=['output']) sample_size=sample_size,
outputs=['output'])
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3734,10 +3675,8 @@ def randomuniform_shape_error_test(): ...@@ -3734,10 +3675,8 @@ def randomuniform_shape_error_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomUniform', node = onnx.helper.make_node(
inputs=[], 'RandomUniform', inputs=[], outputs=['output'], dtype=dtype)
outputs=['output'],
dtype=dtype)
return ([node], [], [output]) return ([node], [], [output])
...@@ -3753,13 +3692,14 @@ def randomuniformlike_test(): ...@@ -3753,13 +3692,14 @@ def randomuniformlike_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT16, output = helper.make_tensor_value_info('output', TensorProto.FLOAT16,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomUniformLike', node = onnx.helper.make_node(
inputs=['input'], 'RandomUniformLike',
outputs=['output'], inputs=['input'],
dtype=dtype, outputs=['output'],
high=high, dtype=dtype,
low=low, high=high,
seed=seed) low=low,
seed=seed)
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3772,10 +3712,8 @@ def randomuniformlike_type_error_test(): ...@@ -3772,10 +3712,8 @@ def randomuniformlike_type_error_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 3, 4]) [2, 3, 4])
node = onnx.helper.make_node('RandomUniformLike', node = onnx.helper.make_node(
inputs=['input'], 'RandomUniformLike', inputs=['input'], outputs=['output'], seed=seed)
outputs=['output'],
seed=seed)
return ([node], [input], [output]) return ([node], [input], [output])
...@@ -3787,36 +3725,32 @@ def range_test(): ...@@ -3787,36 +3725,32 @@ def range_test():
limit_val = np.array([6]) limit_val = np.array([6])
delta_val = np.array([-3]) delta_val = np.array([-3])
start_tensor = helper.make_tensor(name='start_val', start_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name='start_val',
dims=start_val.reshape(()).shape, data_type=TensorProto.INT64,
vals=start_val.astype(np.int64)) dims=start_val.reshape(()).shape,
start = onnx.helper.make_node('Constant', vals=start_val.astype(np.int64))
inputs=[], start = onnx.helper.make_node(
outputs=['start'], 'Constant', inputs=[], outputs=['start'], value=start_tensor)
value=start_tensor)
limit_tensor = helper.make_tensor(
limit_tensor = helper.make_tensor(name='limit_val', name='limit_val',
data_type=TensorProto.INT64, data_type=TensorProto.INT64,
dims=limit_val.reshape(()).shape, dims=limit_val.reshape(()).shape,
vals=limit_val.astype(np.int64)) vals=limit_val.astype(np.int64))
limit = onnx.helper.make_node('Constant', limit = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['limit'], value=limit_tensor)
outputs=['limit'],
value=limit_tensor) delta_tensor = helper.make_tensor(
name='delta_val',
delta_tensor = helper.make_tensor(name='delta_val', data_type=TensorProto.INT64,
data_type=TensorProto.INT64, dims=delta_val.reshape(()).shape,
dims=delta_val.reshape(()).shape, vals=delta_val.astype(np.int64))
vals=delta_val.astype(np.int64)) delta = onnx.helper.make_node(
delta = onnx.helper.make_node('Constant', 'Constant', inputs=[], outputs=['delta'], value=delta_tensor)
inputs=[],
outputs=['delta'], node = onnx.helper.make_node(
value=delta_tensor) 'Range', inputs=['start', 'limit', 'delta'], outputs=['1'])
node = onnx.helper.make_node('Range',
inputs=['start', 'limit', 'delta'],
outputs=['1'])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
...@@ -3830,36 +3764,32 @@ def range_float_test(): ...@@ -3830,36 +3764,32 @@ def range_float_test():
limit_val = np.array([11]) limit_val = np.array([11])
delta_val = np.array([2]) delta_val = np.array([2])
start_tensor = helper.make_tensor(name='start_val', start_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='start_val',
dims=start_val.reshape(()).shape, data_type=TensorProto.FLOAT,
vals=start_val.astype(np.float)) dims=start_val.reshape(()).shape,
start = onnx.helper.make_node('Constant', vals=start_val.astype(np.float))
inputs=[], start = onnx.helper.make_node(
outputs=['start'], 'Constant', inputs=[], outputs=['start'], value=start_tensor)
value=start_tensor)
limit_tensor = helper.make_tensor(
limit_tensor = helper.make_tensor(name='limit_val', name='limit_val',
data_type=TensorProto.FLOAT, data_type=TensorProto.FLOAT,
dims=limit_val.reshape(()).shape, dims=limit_val.reshape(()).shape,
vals=limit_val.astype(np.float)) vals=limit_val.astype(np.float))
limit = onnx.helper.make_node('Constant', limit = onnx.helper.make_node(
inputs=[], 'Constant', inputs=[], outputs=['limit'], value=limit_tensor)
outputs=['limit'],
value=limit_tensor) delta_tensor = helper.make_tensor(
name='delta_val',
delta_tensor = helper.make_tensor(name='delta_val', data_type=TensorProto.FLOAT,
data_type=TensorProto.FLOAT, dims=delta_val.reshape(()).shape,
dims=delta_val.reshape(()).shape, vals=delta_val.astype(np.float))
vals=delta_val.astype(np.float)) delta = onnx.helper.make_node(
delta = onnx.helper.make_node('Constant', 'Constant', inputs=[], outputs=['delta'], value=delta_tensor)
inputs=[],
outputs=['delta'], node = onnx.helper.make_node(
value=delta_tensor) 'Range', inputs=['start', 'limit', 'delta'], outputs=['1'])
node = onnx.helper.make_node('Range',
inputs=['start', 'limit', 'delta'],
outputs=['1'])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
...@@ -3886,11 +3816,8 @@ def reducel1_test(): ...@@ -3886,11 +3816,8 @@ def reducel1_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
axes = [-2] axes = [-2]
node = onnx.helper.make_node('ReduceL1', node = onnx.helper.make_node(
inputs=['x'], 'ReduceL1', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3901,11 +3828,8 @@ def reducel2_test(): ...@@ -3901,11 +3828,8 @@ def reducel2_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5])
axes = [-1] axes = [-1]
node = onnx.helper.make_node('ReduceL2', node = onnx.helper.make_node(
inputs=['x'], 'ReduceL2', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3916,11 +3840,8 @@ def reduce_log_sum_test(): ...@@ -3916,11 +3840,8 @@ def reduce_log_sum_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 6])
axes = [-3] axes = [-3]
node = onnx.helper.make_node('ReduceLogSum', node = onnx.helper.make_node(
inputs=['x'], 'ReduceLogSum', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3931,11 +3852,8 @@ def reduce_log_sum_exp_test(): ...@@ -3931,11 +3852,8 @@ def reduce_log_sum_exp_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 5, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 5, 6])
axes = [-4] axes = [-4]
node = onnx.helper.make_node('ReduceLogSumExp', node = onnx.helper.make_node(
inputs=['x'], 'ReduceLogSumExp', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3946,11 +3864,8 @@ def reducemax_test(): ...@@ -3946,11 +3864,8 @@ def reducemax_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
axes = [2] axes = [2]
node = onnx.helper.make_node('ReduceMax', node = onnx.helper.make_node(
inputs=['x'], 'ReduceMax', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3961,11 +3876,8 @@ def reducemean_test(): ...@@ -3961,11 +3876,8 @@ def reducemean_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
axes = [2, 3] axes = [2, 3]
node = onnx.helper.make_node('ReduceMean', node = onnx.helper.make_node(
inputs=['x'], 'ReduceMean', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3976,11 +3888,8 @@ def reducemean_keepdims_test(): ...@@ -3976,11 +3888,8 @@ def reducemean_keepdims_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
axes = [2] axes = [2]
node = onnx.helper.make_node('ReduceMean', node = onnx.helper.make_node(
inputs=['x'], 'ReduceMean', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -3991,11 +3900,8 @@ def reducemin_test(): ...@@ -3991,11 +3900,8 @@ def reducemin_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 1])
axes = [1, 3] axes = [1, 3]
node = onnx.helper.make_node('ReduceMin', node = onnx.helper.make_node(
inputs=['x'], 'ReduceMin', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4006,11 +3912,8 @@ def reduceprod_test(): ...@@ -4006,11 +3912,8 @@ def reduceprod_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
axes = [2] axes = [2]
node = onnx.helper.make_node('ReduceProd', node = onnx.helper.make_node(
inputs=['x'], 'ReduceProd', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4021,11 +3924,8 @@ def reducesum_test(): ...@@ -4021,11 +3924,8 @@ def reducesum_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
axes = [2] axes = [2]
node = onnx.helper.make_node('ReduceSum', node = onnx.helper.make_node(
inputs=['x'], 'ReduceSum', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4035,16 +3935,18 @@ def reducesum_empty_axes_test(): ...@@ -4035,16 +3935,18 @@ def reducesum_empty_axes_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
axes = np.array([], dtype=np.int64) axes = np.array([], dtype=np.int64)
axes_tensor = helper.make_tensor(name="axes", axes_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name="axes",
dims=axes.shape, data_type=TensorProto.INT64,
vals=axes.astype(np.int64)) dims=axes.shape,
vals=axes.astype(np.int64))
node = onnx.helper.make_node('ReduceSum', node = onnx.helper.make_node(
inputs=['x', 'axes'], 'ReduceSum',
outputs=['y'], inputs=['x', 'axes'],
keepdims=0, outputs=['y'],
noop_with_empty_axes=False) keepdims=0,
noop_with_empty_axes=False)
return ([node], [x], [y], [axes_tensor]) return ([node], [x], [y], [axes_tensor])
...@@ -4054,16 +3956,18 @@ def reducesum_noop_test(): ...@@ -4054,16 +3956,18 @@ def reducesum_noop_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
axes = np.array([], dtype=np.int64) axes = np.array([], dtype=np.int64)
axes_tensor = helper.make_tensor(name="axes", axes_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name="axes",
dims=axes.shape, data_type=TensorProto.INT64,
vals=axes.astype(np.int64)) dims=axes.shape,
vals=axes.astype(np.int64))
node = onnx.helper.make_node('ReduceSum', node = onnx.helper.make_node(
inputs=['x', 'axes'], 'ReduceSum',
outputs=['y'], inputs=['x', 'axes'],
keepdims=0, outputs=['y'],
noop_with_empty_axes=True) keepdims=0,
noop_with_empty_axes=True)
return ([node], [x], [y], [axes_tensor]) return ([node], [x], [y], [axes_tensor])
...@@ -4074,11 +3978,8 @@ def reducesum_keepdims_test(): ...@@ -4074,11 +3978,8 @@ def reducesum_keepdims_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1])
axes = [2, 3] axes = [2, 3]
node = onnx.helper.make_node('ReduceSum', node = onnx.helper.make_node(
inputs=['x'], 'ReduceSum', inputs=['x'], outputs=['y'], axes=axes, keepdims=1)
outputs=['y'],
axes=axes,
keepdims=1)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4089,11 +3990,8 @@ def reducesum_multiaxis_test(): ...@@ -4089,11 +3990,8 @@ def reducesum_multiaxis_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1])
axes = [2, 3] axes = [2, 3]
node = onnx.helper.make_node('ReduceSum', node = onnx.helper.make_node(
inputs=['x'], 'ReduceSum', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4104,11 +4002,8 @@ def reducesum_square_test(): ...@@ -4104,11 +4002,8 @@ def reducesum_square_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
axes = [-2] axes = [-2]
node = onnx.helper.make_node('ReduceSumSquare', node = onnx.helper.make_node(
inputs=['x'], 'ReduceSumSquare', inputs=['x'], outputs=['y'], axes=axes, keepdims=0)
outputs=['y'],
axes=axes,
keepdims=0)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4123,10 +4018,8 @@ def reshape_test(): ...@@ -4123,10 +4018,8 @@ def reshape_test():
node = onnx.helper.make_node('Reshape', inputs=['0', '1'], outputs=['2']) node = onnx.helper.make_node('Reshape', inputs=['0', '1'], outputs=['2'])
node2 = onnx.helper.make_node('Reshape', node2 = onnx.helper.make_node(
inputs=['0'], 'Reshape', inputs=['0'], shape=x_shape_list, outputs=['3'])
shape=x_shape_list,
outputs=['3'])
return ([node, node2], [x, x_shape], [y, y2], return ([node, node2], [x, x_shape], [y, y2],
[helper.make_tensor('1', TensorProto.INT64, [2], [3, 8])]) [helper.make_tensor('1', TensorProto.INT64, [2], [3, 8])])
...@@ -4144,10 +4037,8 @@ def reshape_non_standard_test(): ...@@ -4144,10 +4037,8 @@ def reshape_non_standard_test():
perm=[0, 2, 1], perm=[0, 2, 1],
) )
res = onnx.helper.make_node('Reshape', res = onnx.helper.make_node(
inputs=['trans_x'], 'Reshape', inputs=['trans_x'], outputs=['y'], shape=[4, 3, 2])
outputs=['y'],
shape=[4, 3, 2])
return ([trans, res], [x], [y]) return ([trans, res], [x], [y])
...@@ -4155,10 +4046,11 @@ def reshape_non_standard_test(): ...@@ -4155,10 +4046,11 @@ def reshape_non_standard_test():
@onnx_test @onnx_test
def resize_downsample_f_test(): def resize_downsample_f_test():
scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, []) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [])
...@@ -4177,20 +4069,22 @@ def resize_downsample_f_test(): ...@@ -4177,20 +4069,22 @@ def resize_downsample_f_test():
@onnx_test @onnx_test
def resize_downsample_c_test(): def resize_downsample_c_test():
scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 1, 2]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 1, 2])
node = onnx.helper.make_node('Resize', node = onnx.helper.make_node(
inputs=['X', '', 'scales'], 'Resize',
outputs=['Y'], inputs=['X', '', 'scales'],
coordinate_transformation_mode='asymmetric', outputs=['Y'],
mode='nearest', coordinate_transformation_mode='asymmetric',
nearest_mode='ceil') mode='nearest',
nearest_mode='ceil')
return ([node], [X], [Y], [scale_tensor]) return ([node], [X], [Y], [scale_tensor])
...@@ -4198,18 +4092,17 @@ def resize_downsample_c_test(): ...@@ -4198,18 +4092,17 @@ def resize_downsample_c_test():
@onnx_test @onnx_test
def resize_downsample_linear_test(): def resize_downsample_linear_test():
scales = np.array([1.0, 1.0, 0.6, 0.5], dtype=np.float32) scales = np.array([1.0, 1.0, 0.6, 0.5], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, []) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [])
node = onnx.helper.make_node('Resize', node = onnx.helper.make_node(
inputs=['X', '', 'scales'], 'Resize', inputs=['X', '', 'scales'], outputs=['Y'], mode='linear')
outputs=['Y'],
mode='linear')
return ([node], [X], [Y], [scale_tensor]) return ([node], [X], [Y], [scale_tensor])
...@@ -4217,25 +4110,25 @@ def resize_downsample_linear_test(): ...@@ -4217,25 +4110,25 @@ def resize_downsample_linear_test():
@onnx_test @onnx_test
def resize_nonstd_input_test(): def resize_nonstd_input_test():
scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 4, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 4, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 1, 2]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 1, 2])
trn = onnx.helper.make_node('Transpose', trn = onnx.helper.make_node(
inputs=['X'], 'Transpose', inputs=['X'], outputs=['TX'], perm=[0, 1, 3, 2])
outputs=['TX'],
perm=[0, 1, 3, 2])
node = onnx.helper.make_node('Resize', node = onnx.helper.make_node(
inputs=['TX', '', 'scales'], 'Resize',
outputs=['Y'], inputs=['TX', '', 'scales'],
coordinate_transformation_mode='asymmetric', outputs=['Y'],
mode='nearest', coordinate_transformation_mode='asymmetric',
nearest_mode='ceil') mode='nearest',
nearest_mode='ceil')
return ([trn, node], [X], [Y], [scale_tensor]) return ([trn, node], [X], [Y], [scale_tensor])
...@@ -4243,11 +4136,11 @@ def resize_nonstd_input_test(): ...@@ -4243,11 +4136,11 @@ def resize_nonstd_input_test():
@onnx_test @onnx_test
def resize_outsize_test(): def resize_outsize_test():
out_lens = np.array([1, 1, 4, 6], dtype=np.int64) out_lens = np.array([1, 1, 4, 6], dtype=np.int64)
out_lens_tensor = helper.make_tensor(name='out_lens', out_lens_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name='out_lens',
dims=out_lens.shape, data_type=TensorProto.INT64,
vals=out_lens.flatten().astype( dims=out_lens.shape,
np.int64)) vals=out_lens.flatten().astype(np.int64))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6])
...@@ -4266,11 +4159,11 @@ def resize_outsize_test(): ...@@ -4266,11 +4159,11 @@ def resize_outsize_test():
@onnx_test @onnx_test
def resize_upsample_linear_ac_test(): def resize_upsample_linear_ac_test():
scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
scales_tensor = helper.make_tensor(name='scales', scales_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype( dims=scales.shape,
np.float32)) vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, []) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [])
...@@ -4287,18 +4180,16 @@ def resize_upsample_linear_ac_test(): ...@@ -4287,18 +4180,16 @@ def resize_upsample_linear_ac_test():
@onnx_test @onnx_test
def resize_upsample_linear_test(): def resize_upsample_linear_test():
scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
scales_tensor = helper.make_tensor(name='scales', scales_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype( dims=scales.shape,
np.float32)) vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, []) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [])
node = onnx.helper.make_node('Resize', node = onnx.helper.make_node(
inputs=['X', '', 'scales'], 'Resize', inputs=['X', '', 'scales'], outputs=['Y'], mode='linear')
outputs=['Y'],
mode='linear')
return ([node], [X], [Y], [scales_tensor]) return ([node], [X], [Y], [scales_tensor])
...@@ -4306,18 +4197,17 @@ def resize_upsample_linear_test(): ...@@ -4306,18 +4197,17 @@ def resize_upsample_linear_test():
@onnx_test @onnx_test
def resize_upsample_pf_test(): def resize_upsample_pf_test():
scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6])
node = onnx.helper.make_node('Resize', node = onnx.helper.make_node(
inputs=['X', '', 'scales'], 'Resize', inputs=['X', '', 'scales'], outputs=['Y'], mode='nearest')
outputs=['Y'],
mode='nearest')
return ([node], [X], [Y], [scale_tensor]) return ([node], [X], [Y], [scale_tensor])
...@@ -4325,10 +4215,11 @@ def resize_upsample_pf_test(): ...@@ -4325,10 +4215,11 @@ def resize_upsample_pf_test():
@onnx_test @onnx_test
def resize_upsample_pc_test(): def resize_upsample_pc_test():
scales = np.array([1.0, 1.0, 2.0, 1.5], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 1.5], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 4])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6])
...@@ -4352,9 +4243,8 @@ def roialign_default_test(): ...@@ -4352,9 +4243,8 @@ def roialign_default_test():
bi = helper.make_tensor_value_info('batch_ind', TensorProto.INT64, [8]) bi = helper.make_tensor_value_info('batch_ind', TensorProto.INT64, [8])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [8, 4, 1, 1]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [8, 4, 1, 1])
node = onnx.helper.make_node('RoiAlign', node = onnx.helper.make_node(
inputs=['x', 'rois', 'batch_ind'], 'RoiAlign', inputs=['x', 'rois', 'batch_ind'], outputs=['y'])
outputs=['y'])
return ([node], [x, roi, bi], [y]) return ([node], [x, roi, bi], [y])
...@@ -4450,10 +4340,11 @@ def scatternd_add_test(): ...@@ -4450,10 +4340,11 @@ def scatternd_add_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 2, 2]) [2, 2, 2])
node = onnx.helper.make_node('ScatterND', node = onnx.helper.make_node(
inputs=['data', 'indices', 'updates'], 'ScatterND',
outputs=['output'], inputs=['data', 'indices', 'updates'],
reduction="add") outputs=['output'],
reduction="add")
return ([node], [data, indices, updates], [output]) return ([node], [data, indices, updates], [output])
...@@ -4468,10 +4359,11 @@ def scatternd_mul_test(): ...@@ -4468,10 +4359,11 @@ def scatternd_mul_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 2, 2]) [2, 2, 2])
node = onnx.helper.make_node('ScatterND', node = onnx.helper.make_node(
inputs=['data', 'indices', 'updates'], 'ScatterND',
outputs=['output'], inputs=['data', 'indices', 'updates'],
reduction="mul") outputs=['output'],
reduction="mul")
return ([node], [data, indices, updates], [output]) return ([node], [data, indices, updates], [output])
...@@ -4486,9 +4378,8 @@ def scatternd_test(): ...@@ -4486,9 +4378,8 @@ def scatternd_test():
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
[2, 2, 2]) [2, 2, 2])
node = onnx.helper.make_node('ScatterND', node = onnx.helper.make_node(
inputs=['data', 'indices', 'updates'], 'ScatterND', inputs=['data', 'indices', 'updates'], outputs=['output'])
outputs=['output'])
return ([node], [data, indices, updates], [output]) return ([node], [data, indices, updates], [output])
...@@ -4498,11 +4389,8 @@ def selu_test(): ...@@ -4498,11 +4389,8 @@ def selu_test():
x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [2, 3]) x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [2, 3])
y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [2, 3]) y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [2, 3])
node = onnx.helper.make_node('Selu', node = onnx.helper.make_node(
inputs=['x'], 'Selu', inputs=['x'], outputs=['y'], alpha=0.3, gamma=0.5)
outputs=['y'],
alpha=0.3,
gamma=0.5)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4528,10 +4416,11 @@ def shape_gather_test(): ...@@ -4528,10 +4416,11 @@ def shape_gather_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [7, 3, 10]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [7, 3, 10])
z = helper.make_tensor_value_info('z', TensorProto.FLOAT, [1]) z = helper.make_tensor_value_info('z', TensorProto.FLOAT, [1])
value_tensor = helper.make_tensor(name='const_tensor', value_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name='const_tensor',
dims=values.shape, data_type=TensorProto.INT32,
vals=values.flatten().astype(int)) dims=values.shape,
vals=values.flatten().astype(int))
node_const = onnx.helper.make_node( node_const = onnx.helper.make_node(
'Constant', 'Constant',
...@@ -4651,12 +4540,13 @@ def slice_test(): ...@@ -4651,12 +4540,13 @@ def slice_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 2]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 2])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 2]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 2])
node = onnx.helper.make_node('Slice', node = onnx.helper.make_node(
inputs=['0'], 'Slice',
axes=[0, 1], inputs=['0'],
starts=[1, 0], axes=[0, 1],
ends=[2, 2], starts=[1, 0],
outputs=['1']) ends=[2, 2],
outputs=['1'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4666,29 +4556,26 @@ def slice_3arg_test(): ...@@ -4666,29 +4556,26 @@ def slice_3arg_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5])
start = np.array([0, 0]) start = np.array([0, 0])
start_tensor = helper.make_tensor(name="start", start_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="start",
dims=start.shape, data_type=TensorProto.INT32,
vals=start.astype(int)) dims=start.shape,
vals=start.astype(int))
arg_start = helper.make_node("Constant", arg_start = helper.make_node(
inputs=[], "Constant", inputs=[], outputs=['arg_start'], value=start_tensor)
outputs=['arg_start'],
value=start_tensor)
end = np.array([2, 5]) end = np.array([2, 5])
end_tensor = helper.make_tensor(name="end", end_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="end",
dims=end.shape, data_type=TensorProto.INT32,
vals=end.astype(int)) dims=end.shape,
arg_end = helper.make_node("Constant", vals=end.astype(int))
inputs=[], arg_end = helper.make_node(
outputs=['arg_end'], "Constant", inputs=[], outputs=['arg_end'], value=end_tensor)
value=end_tensor)
node = onnx.helper.make_node(
node = onnx.helper.make_node('Slice', 'Slice', inputs=['0', 'arg_start', 'arg_end'], outputs=['1'])
inputs=['0', 'arg_start', 'arg_end'],
outputs=['1'])
return ([arg_start, arg_end, node], [x], [y]) return ([arg_start, arg_end, node], [x], [y])
...@@ -4696,44 +4583,40 @@ def slice_3arg_test(): ...@@ -4696,44 +4583,40 @@ def slice_3arg_test():
@onnx_test @onnx_test
def slice_5arg_test(): def slice_5arg_test():
step = np.array([1, 1]) step = np.array([1, 1])
step_tensor = helper.make_tensor(name="step", step_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="step",
dims=step.shape, data_type=TensorProto.INT32,
vals=step.astype(int)) dims=step.shape,
arg_step = helper.make_node("Constant", vals=step.astype(int))
inputs=[], arg_step = helper.make_node(
outputs=['arg_step'], "Constant", inputs=[], outputs=['arg_step'], value=step_tensor)
value=step_tensor)
axis = np.array([-1, -2]) axis = np.array([-1, -2])
axis_tensor = helper.make_tensor(name="axis", axis_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="axis",
dims=axis.shape, data_type=TensorProto.INT32,
vals=axis.astype(int)) dims=axis.shape,
arg_axis = helper.make_node("Constant", vals=axis.astype(int))
inputs=[], arg_axis = helper.make_node(
outputs=['arg_axis'], "Constant", inputs=[], outputs=['arg_axis'], value=axis_tensor)
value=axis_tensor)
end = np.array([-1, -1]) end = np.array([-1, -1])
end_tensor = helper.make_tensor(name="end", end_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="end",
dims=end.shape, data_type=TensorProto.INT32,
vals=end.astype(int)) dims=end.shape,
arg_end = helper.make_node("Constant", vals=end.astype(int))
inputs=[], arg_end = helper.make_node(
outputs=['arg_end'], "Constant", inputs=[], outputs=['arg_end'], value=end_tensor)
value=end_tensor)
start = np.array([-5, -3]) start = np.array([-5, -3])
start_tensor = helper.make_tensor(name="start", start_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="start",
dims=start.shape, data_type=TensorProto.INT32,
vals=start.astype(int)) dims=start.shape,
arg_start = helper.make_node("Constant", vals=start.astype(int))
inputs=[], arg_start = helper.make_node(
outputs=['arg_start'], "Constant", inputs=[], outputs=['arg_start'], value=start_tensor)
value=start_tensor)
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2])
...@@ -4749,44 +4632,40 @@ def slice_5arg_test(): ...@@ -4749,44 +4632,40 @@ def slice_5arg_test():
@onnx_test @onnx_test
def slice_5arg_reverse_test(): def slice_5arg_reverse_test():
step = np.array([-1, 1]) step = np.array([-1, 1])
step_tensor = helper.make_tensor(name="step", step_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="step",
dims=step.shape, data_type=TensorProto.INT32,
vals=step.astype(int)) dims=step.shape,
arg_step = helper.make_node("Constant", vals=step.astype(int))
inputs=[], arg_step = helper.make_node(
outputs=['arg_step'], "Constant", inputs=[], outputs=['arg_step'], value=step_tensor)
value=step_tensor)
axis = np.array([-1, -2]) axis = np.array([-1, -2])
axis_tensor = helper.make_tensor(name="axis", axis_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="axis",
dims=axis.shape, data_type=TensorProto.INT32,
vals=axis.astype(int)) dims=axis.shape,
arg_axis = helper.make_node("Constant", vals=axis.astype(int))
inputs=[], arg_axis = helper.make_node(
outputs=['arg_axis'], "Constant", inputs=[], outputs=['arg_axis'], value=axis_tensor)
value=axis_tensor)
end = np.array([-5, -1]) end = np.array([-5, -1])
end_tensor = helper.make_tensor(name="end", end_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="end",
dims=end.shape, data_type=TensorProto.INT32,
vals=end.astype(int)) dims=end.shape,
arg_end = helper.make_node("Constant", vals=end.astype(int))
inputs=[], arg_end = helper.make_node(
outputs=['arg_end'], "Constant", inputs=[], outputs=['arg_end'], value=end_tensor)
value=end_tensor)
start = np.array([-1, -3]) start = np.array([-1, -3])
start_tensor = helper.make_tensor(name="start", start_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="start",
dims=start.shape, data_type=TensorProto.INT32,
vals=start.astype(int)) dims=start.shape,
arg_start = helper.make_node("Constant", vals=start.astype(int))
inputs=[], arg_start = helper.make_node(
outputs=['arg_start'], "Constant", inputs=[], outputs=['arg_start'], value=start_tensor)
value=start_tensor)
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2])
...@@ -4802,44 +4681,40 @@ def slice_5arg_reverse_test(): ...@@ -4802,44 +4681,40 @@ def slice_5arg_reverse_test():
@onnx_test @onnx_test
def slice_5arg_step_test(): def slice_5arg_step_test():
step = np.array([-2, 2]) step = np.array([-2, 2])
step_tensor = helper.make_tensor(name="step", step_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="step",
dims=step.shape, data_type=TensorProto.INT32,
vals=step.astype(int)) dims=step.shape,
arg_step = helper.make_node("Constant", vals=step.astype(int))
inputs=[], arg_step = helper.make_node(
outputs=['arg_step'], "Constant", inputs=[], outputs=['arg_step'], value=step_tensor)
value=step_tensor)
axis = np.array([-1, -2]) axis = np.array([-1, -2])
axis_tensor = helper.make_tensor(name="axis", axis_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="axis",
dims=axis.shape, data_type=TensorProto.INT32,
vals=axis.astype(int)) dims=axis.shape,
arg_axis = helper.make_node("Constant", vals=axis.astype(int))
inputs=[], arg_axis = helper.make_node(
outputs=['arg_axis'], "Constant", inputs=[], outputs=['arg_axis'], value=axis_tensor)
value=axis_tensor)
end = np.array([-5, -1]) end = np.array([-5, -1])
end_tensor = helper.make_tensor(name="end", end_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="end",
dims=end.shape, data_type=TensorProto.INT32,
vals=end.astype(int)) dims=end.shape,
arg_end = helper.make_node("Constant", vals=end.astype(int))
inputs=[], arg_end = helper.make_node(
outputs=['arg_end'], "Constant", inputs=[], outputs=['arg_end'], value=end_tensor)
value=end_tensor)
start = np.array([-1, -3]) start = np.array([-1, -3])
start_tensor = helper.make_tensor(name="start", start_tensor = helper.make_tensor(
data_type=TensorProto.INT32, name="start",
dims=start.shape, data_type=TensorProto.INT32,
vals=start.astype(int)) dims=start.shape,
arg_start = helper.make_node("Constant", vals=start.astype(int))
inputs=[], arg_start = helper.make_node(
outputs=['arg_start'], "Constant", inputs=[], outputs=['arg_start'], value=start_tensor)
value=start_tensor)
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 2])
...@@ -4857,12 +4732,13 @@ def slice_max_end_test(): ...@@ -4857,12 +4732,13 @@ def slice_max_end_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [10, 20]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [10, 20])
y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [9, 17]) y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [9, 17])
node = onnx.helper.make_node('Slice', node = onnx.helper.make_node(
inputs=['0'], 'Slice',
axes=[0, 1], inputs=['0'],
starts=[1, 2], axes=[0, 1],
ends=[3000000000, -1], starts=[1, 2],
outputs=['1']) ends=[3000000000, -1],
outputs=['1'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -4882,12 +4758,13 @@ def softmax_nonstd_input_test(): ...@@ -4882,12 +4758,13 @@ def softmax_nonstd_input_test():
x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 8]) x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 8])
y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4]) y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4])
node0 = onnx.helper.make_node('Slice', node0 = onnx.helper.make_node(
inputs=['0'], 'Slice',
axes=[0, 1], inputs=['0'],
starts=[1, 0], axes=[0, 1],
ends=[4, 4], starts=[1, 0],
outputs=['1']) ends=[4, 4],
outputs=['1'])
node1 = onnx.helper.make_node('Softmax', inputs=['1'], outputs=['2']) node1 = onnx.helper.make_node('Softmax', inputs=['1'], outputs=['2'])
...@@ -4956,11 +4833,12 @@ def split_test(): ...@@ -4956,11 +4833,12 @@ def split_test():
y2 = helper.make_tensor_value_info('y2', TensorProto.FLOAT, [10, 4]) y2 = helper.make_tensor_value_info('y2', TensorProto.FLOAT, [10, 4])
y3 = helper.make_tensor_value_info('y3', TensorProto.FLOAT, [10, 4]) y3 = helper.make_tensor_value_info('y3', TensorProto.FLOAT, [10, 4])
node = onnx.helper.make_node('Split', node = onnx.helper.make_node(
inputs=['x'], 'Split',
outputs=['y1', 'y2', 'y3'], inputs=['x'],
axis=1, outputs=['y1', 'y2', 'y3'],
split=[7, 4, 4]) axis=1,
split=[7, 4, 4])
return ([node], [x], [y1, y2, y3]) return ([node], [x], [y1, y2, y3])
...@@ -4999,14 +4877,14 @@ def squeeze_axes_input_test(): ...@@ -4999,14 +4877,14 @@ def squeeze_axes_input_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5])
axes = np.array([1, 3], dtype=np.int64) axes = np.array([1, 3], dtype=np.int64)
axes_tensor = helper.make_tensor(name="axes", axes_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name="axes",
dims=axes.shape, data_type=TensorProto.INT64,
vals=axes.astype(np.int64)) dims=axes.shape,
vals=axes.astype(np.int64))
node = onnx.helper.make_node('Squeeze', node = onnx.helper.make_node(
inputs=['x', 'axes'], 'Squeeze', inputs=['x', 'axes'], outputs=['y'])
outputs=['y'])
return ([node], [x], [y], [axes_tensor]) return ([node], [x], [y], [axes_tensor])
...@@ -5016,14 +4894,14 @@ def squeeze_empty_axes_test(): ...@@ -5016,14 +4894,14 @@ def squeeze_empty_axes_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5])
axes = np.array([], dtype=np.int64) axes = np.array([], dtype=np.int64)
axes_tensor = helper.make_tensor(name="axes", axes_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name="axes",
dims=axes.shape, data_type=TensorProto.INT64,
vals=axes.astype(np.int64)) dims=axes.shape,
vals=axes.astype(np.int64))
node = onnx.helper.make_node('Squeeze', node = onnx.helper.make_node(
inputs=['x', 'axes'], 'Squeeze', inputs=['x', 'axes'], outputs=['y'])
outputs=['y'])
return ([node], [x], [y], [axes_tensor]) return ([node], [x], [y], [axes_tensor])
...@@ -5035,15 +4913,11 @@ def squeeze_unsqueeze_test(): ...@@ -5035,15 +4913,11 @@ def squeeze_unsqueeze_test():
y = helper.make_tensor_value_info('2', TensorProto.FLOAT, y = helper.make_tensor_value_info('2', TensorProto.FLOAT,
[1, 1, 3, 1, 2, 1]) [1, 1, 3, 1, 2, 1])
node = onnx.helper.make_node('Squeeze', node = onnx.helper.make_node(
inputs=['0'], 'Squeeze', inputs=['0'], axes=[0, 2, 3, 5], outputs=['1'])
axes=[0, 2, 3, 5],
outputs=['1'])
node2 = onnx.helper.make_node('Unsqueeze', node2 = onnx.helper.make_node(
inputs=['1'], 'Unsqueeze', inputs=['1'], axes=[0, 1, 3, 5], outputs=['2'])
axes=[0, 1, 3, 5],
outputs=['2'])
return ([node, node2], [x], [y]) return ([node, node2], [x], [y])
...@@ -5074,10 +4948,11 @@ def sub_scalar_test(): ...@@ -5074,10 +4948,11 @@ def sub_scalar_test():
arg_out = helper.make_tensor_value_info('out', TensorProto.FLOAT, arg_out = helper.make_tensor_value_info('out', TensorProto.FLOAT,
[2, 3, 4, 5]) [2, 3, 4, 5])
values_tensor = helper.make_tensor(name='const', values_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='const',
dims=values.reshape(()).shape, data_type=TensorProto.FLOAT,
vals=values.flatten().astype(float)) dims=values.reshape(()).shape,
vals=values.flatten().astype(float))
arg_const = onnx.helper.make_node( arg_const = onnx.helper.make_node(
'Constant', 'Constant',
...@@ -5134,78 +5009,74 @@ def sum_test(): ...@@ -5134,78 +5009,74 @@ def sum_test():
@onnx_test @onnx_test
def sum_type_test(): def sum_type_test():
valb = np.array([1, 0]) valb = np.array([1, 0])
t_bool = helper.make_tensor(name="bool", t_bool = helper.make_tensor(
data_type=TensorProto.BOOL, name="bool",
dims=valb.shape, data_type=TensorProto.BOOL,
vals=valb.astype(np.bool)) dims=valb.shape,
vals=valb.astype(np.bool))
val = np.array([1, 1]) val = np.array([1, 1])
t_int8 = helper.make_tensor(name="int8", t_int8 = helper.make_tensor(
data_type=TensorProto.INT8, name="int8",
dims=val.shape, data_type=TensorProto.INT8,
vals=val.astype(np.int8)) dims=val.shape,
vals=val.astype(np.int8))
t_uint8 = helper.make_tensor(name="uint8",
data_type=TensorProto.UINT8, t_uint8 = helper.make_tensor(
dims=val.shape, name="uint8",
vals=val.astype(np.uint8)) data_type=TensorProto.UINT8,
dims=val.shape,
t_uint16 = helper.make_tensor(name="uint16", vals=val.astype(np.uint8))
data_type=TensorProto.UINT16,
dims=val.shape, t_uint16 = helper.make_tensor(
vals=val.astype(np.uint16)) name="uint16",
data_type=TensorProto.UINT16,
t_uint32 = helper.make_tensor(name="uint32", dims=val.shape,
data_type=TensorProto.UINT32, vals=val.astype(np.uint16))
dims=val.shape,
vals=val.astype(np.uint32)) t_uint32 = helper.make_tensor(
name="uint32",
t_uint64 = helper.make_tensor(name="uint64", data_type=TensorProto.UINT32,
data_type=TensorProto.UINT64, dims=val.shape,
dims=val.shape, vals=val.astype(np.uint32))
vals=val.astype(np.uint64))
t_uint64 = helper.make_tensor(
t_double = helper.make_tensor(name="double", name="uint64",
data_type=TensorProto.DOUBLE, data_type=TensorProto.UINT64,
dims=val.shape, dims=val.shape,
vals=val.astype(np.float64)) vals=val.astype(np.uint64))
t_double = helper.make_tensor(
name="double",
data_type=TensorProto.DOUBLE,
dims=val.shape,
vals=val.astype(np.float64))
valr = np.array([1.5, 2.0]) valr = np.array([1.5, 2.0])
t_raw = helper.make_tensor(name="raw", t_raw = helper.make_tensor(
data_type=TensorProto.DOUBLE, name="raw",
dims=valr.shape, data_type=TensorProto.DOUBLE,
vals=valr.tobytes(), dims=valr.shape,
raw=True) vals=valr.tobytes(),
raw=True)
n_bool = onnx.helper.make_node('Cast',
inputs=['bool'], n_bool = onnx.helper.make_node(
outputs=['o_bool'], 'Cast', inputs=['bool'], outputs=['o_bool'], to=11)
to=11)
n_int8 = onnx.helper.make_node(
n_int8 = onnx.helper.make_node('Cast', 'Cast', inputs=['int8'], outputs=['o_int8'], to=11)
inputs=['int8'],
outputs=['o_int8'], n_uint8 = onnx.helper.make_node(
to=11) 'Cast', inputs=['uint8'], outputs=['o_uint8'], to=11)
n_uint8 = onnx.helper.make_node('Cast', n_uint16 = onnx.helper.make_node(
inputs=['uint8'], 'Cast', inputs=['uint16'], outputs=['o_uint16'], to=11)
outputs=['o_uint8'],
to=11) n_uint32 = onnx.helper.make_node(
'Cast', inputs=['uint32'], outputs=['o_uint32'], to=11)
n_uint16 = onnx.helper.make_node('Cast',
inputs=['uint16'], n_uint64 = onnx.helper.make_node(
outputs=['o_uint16'], 'Cast', inputs=['uint64'], outputs=['o_uint64'], to=11)
to=11)
n_uint32 = onnx.helper.make_node('Cast',
inputs=['uint32'],
outputs=['o_uint32'],
to=11)
n_uint64 = onnx.helper.make_node('Cast',
inputs=['uint64'],
outputs=['o_uint64'],
to=11)
node = onnx.helper.make_node( node = onnx.helper.make_node(
'Sum', 'Sum',
...@@ -5218,11 +5089,11 @@ def sum_type_test(): ...@@ -5218,11 +5089,11 @@ def sum_type_test():
y = helper.make_tensor_value_info('out', TensorProto.DOUBLE, [2]) y = helper.make_tensor_value_info('out', TensorProto.DOUBLE, [2])
return ([n_bool, n_int8, n_uint8, n_uint16, n_uint32, n_uint64, return ([n_bool, n_int8, n_uint8, n_uint16, n_uint32, n_uint64, node], [],
node], [], [y], [ [y], [
t_bool, t_int8, t_uint8, t_uint16, t_uint32, t_uint64, t_bool, t_int8, t_uint8, t_uint16, t_uint32, t_uint64,
t_double, t_raw t_double, t_raw
]) ])
@onnx_test @onnx_test
...@@ -5258,9 +5129,8 @@ def thresholdedrelu_default_test(): ...@@ -5258,9 +5129,8 @@ def thresholdedrelu_default_test():
x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 3]) x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 3])
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3])
node = onnx.helper.make_node('ThresholdedRelu', node = onnx.helper.make_node(
inputs=['x'], 'ThresholdedRelu', inputs=['x'], outputs=['y'])
outputs=['y'])
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -5271,10 +5141,8 @@ def thresholdedrelu_test(): ...@@ -5271,10 +5141,8 @@ def thresholdedrelu_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3])
alpha = 3.0 alpha = 3.0
node = onnx.helper.make_node('ThresholdedRelu', node = onnx.helper.make_node(
inputs=['x'], 'ThresholdedRelu', inputs=['x'], outputs=['y'], alpha=alpha)
outputs=['y'],
alpha=alpha)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -5285,10 +5153,8 @@ def thresholdedrelu_int_test(): ...@@ -5285,10 +5153,8 @@ def thresholdedrelu_int_test():
y = helper.make_tensor_value_info('y', TensorProto.INT32, [2, 2, 3]) y = helper.make_tensor_value_info('y', TensorProto.INT32, [2, 2, 3])
alpha = 3.0 alpha = 3.0
node = onnx.helper.make_node('ThresholdedRelu', node = onnx.helper.make_node(
inputs=['x'], 'ThresholdedRelu', inputs=['x'], outputs=['y'], alpha=alpha)
outputs=['y'],
alpha=alpha)
return ([node], [x], [y]) return ([node], [x], [y])
...@@ -5324,10 +5190,8 @@ def topk_attrk_test(): ...@@ -5324,10 +5190,8 @@ def topk_attrk_test():
ind = helper.make_tensor_value_info('indices', TensorProto.INT64, ind = helper.make_tensor_value_info('indices', TensorProto.INT64,
[2, 2, 3, 2]) [2, 2, 3, 2])
node = onnx.helper.make_node('TopK', node = onnx.helper.make_node(
inputs=['data'], 'TopK', inputs=['data'], outputs=['val', 'indices'], k=2)
outputs=['val', 'indices'],
k=2)
return ([node], [x], [val, ind]) return ([node], [x], [val, ind])
...@@ -5339,16 +5203,18 @@ def topk_neg_axis_test(): ...@@ -5339,16 +5203,18 @@ def topk_neg_axis_test():
ind = helper.make_tensor_value_info('indices', TensorProto.INT64, ind = helper.make_tensor_value_info('indices', TensorProto.INT64,
[3, 3, 5, 6]) [3, 3, 5, 6])
k_tensor = helper.make_tensor(name='k', k_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name='k',
dims=k.shape, data_type=TensorProto.INT64,
vals=k.astype(np.int64)) dims=k.shape,
vals=k.astype(np.int64))
node = onnx.helper.make_node('TopK', node = onnx.helper.make_node(
inputs=['data', 'k'], 'TopK',
outputs=['val', 'indices'], inputs=['data', 'k'],
axis=-2, outputs=['val', 'indices'],
sorted=0) axis=-2,
sorted=0)
return ([node], [x], [val, ind], [k_tensor]) return ([node], [x], [val, ind], [k_tensor])
...@@ -5360,16 +5226,18 @@ def topk_test(): ...@@ -5360,16 +5226,18 @@ def topk_test():
ind = helper.make_tensor_value_info('indices', TensorProto.INT64, ind = helper.make_tensor_value_info('indices', TensorProto.INT64,
[2, 4, 3, 2]) [2, 4, 3, 2])
k_tensor = helper.make_tensor(name='k', k_tensor = helper.make_tensor(
data_type=TensorProto.INT64, name='k',
dims=k.shape, data_type=TensorProto.INT64,
vals=k.astype(np.int64)) dims=k.shape,
vals=k.astype(np.int64))
node = onnx.helper.make_node('TopK', node = onnx.helper.make_node(
inputs=['data', 'k'], 'TopK',
outputs=['val', 'indices'], inputs=['data', 'k'],
largest=0, outputs=['val', 'indices'],
axis=1) largest=0,
axis=1)
return ([node], [x], [val, ind], [k_tensor]) return ([node], [x], [val, ind], [k_tensor])
...@@ -5431,10 +5299,11 @@ def transpose_gather_test(): ...@@ -5431,10 +5299,11 @@ def transpose_gather_test():
perm=[0, 2, 1, 3], perm=[0, 2, 1, 3],
) )
ti = onnx.helper.make_node('Transpose', ti = onnx.helper.make_node(
inputs=['indices'], 'Transpose',
outputs=['tindices'], inputs=['indices'],
perm=[0, 2, 1, 3]) outputs=['tindices'],
perm=[0, 2, 1, 3])
node = onnx.helper.make_node( node = onnx.helper.make_node(
'Gather', 'Gather',
...@@ -5481,10 +5350,8 @@ def unknown_aten_test(): ...@@ -5481,10 +5350,8 @@ def unknown_aten_test():
a = helper.make_tensor_value_info('3', TensorProto.FLOAT, [2, 3, 4, 5]) a = helper.make_tensor_value_info('3', TensorProto.FLOAT, [2, 3, 4, 5])
node = onnx.helper.make_node('ATen', node = onnx.helper.make_node(
inputs=['0', '1'], 'ATen', inputs=['0', '1'], outputs=['2'], operator='unknown')
outputs=['2'],
operator='unknown')
return ([node], [x, y], [a]) return ([node], [x, y], [a])
...@@ -5492,18 +5359,16 @@ def unknown_aten_test(): ...@@ -5492,18 +5359,16 @@ def unknown_aten_test():
@onnx_test @onnx_test
def upsample_linear_test(): def upsample_linear_test():
scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
scales_tensor = helper.make_tensor(name='scales', scales_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype( dims=scales.shape,
np.float32)) vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, []) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [])
node = onnx.helper.make_node('Upsample', node = onnx.helper.make_node(
inputs=['X', '', 'scales'], 'Upsample', inputs=['X', '', 'scales'], outputs=['Y'], mode='linear')
outputs=['Y'],
mode='linear')
return ([node], [X], [Y], [scales_tensor]) return ([node], [X], [Y], [scales_tensor])
...@@ -5511,10 +5376,11 @@ def upsample_linear_test(): ...@@ -5511,10 +5376,11 @@ def upsample_linear_test():
@onnx_test @onnx_test
def upsample_test(): def upsample_test():
scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32) scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
scale_tensor = helper.make_tensor(name='scales', scale_tensor = helper.make_tensor(
data_type=TensorProto.FLOAT, name='scales',
dims=scales.shape, data_type=TensorProto.FLOAT,
vals=scales.flatten().astype(np.float32)) dims=scales.shape,
vals=scales.flatten().astype(np.float32))
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2]) X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [1, 1, 2, 2])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6]) Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [1, 1, 4, 6])
...@@ -5559,8 +5425,7 @@ def where_test(): ...@@ -5559,8 +5425,7 @@ def where_test():
y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 1, 2, 2]) y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 1, 2, 2])
z = helper.make_tensor_value_info('z', TensorProto.FLOAT, [2, 2, 2, 2]) z = helper.make_tensor_value_info('z', TensorProto.FLOAT, [2, 2, 2, 2])
node = onnx.helper.make_node('Where', node = onnx.helper.make_node(
inputs=['c', 'x', 'y'], 'Where', inputs=['c', 'x', 'y'], outputs=['z'])
outputs=['z'])
return ([node], [c, x, y], [z]) return ([node], [c, x, y], [z])
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment