merge changes from develop branch

test/eliminate_pad_test.cpp

@@ -55,7 +55,8 @@ TEST_CASE(rewrite_pad)
 
     auto l0 = create_im2col(padded_img, channels, m);
     auto l1 = create_conv(padded_img, channels, m);
-    auto l2 = m.add_instruction(migraphx::make_op("pooling", {{"mode", "max"}}), padded_img);
+    auto l2 = m.add_instruction(
+        migraphx::make_op("pooling", {{"mode", migraphx::op::pooling_mode::max}}), padded_img);
     m.add_instruction(migraphx::make_op("identity"), l0, l1, l2);
 
     auto s0 = l0->get_shape();

test/insert_pad_test.cpp

@@ -55,7 +55,9 @@ TEST_CASE(rewrite_pad)
     auto l0 = create_im2col(l_img, channels, m);
     auto l1 = create_conv(l_img, channels, m);
     auto l2 = m.add_instruction(
-        migraphx::make_op("pooling", {{"mode", "max"}, {"padding", {0, 0, 1, 1}}}), l_img);
+        migraphx::make_op("pooling",
+                          {{"mode", migraphx::op::pooling_mode::max}, {"padding", {0, 0, 1, 1}}}),
+        l_img);
     m.add_instruction(migraphx::make_op("identity"), l0, l1, l2);
 
     run_pass(m);
@@ -76,8 +78,10 @@ TEST_CASE(rewrite_pad_symmetric)
     migraphx::shape s_img{migraphx::shape::int32_type, {1, channels, img_dim[0], img_dim[1]}};
     auto l_img = m.add_literal(migraphx::literal{s_img, input});
 
-    m.add_instruction(migraphx::make_op("pooling", {{"mode", "max"}, {"padding", {1, 1, 1, 1}}}),
-                      l_img);
+    m.add_instruction(
+        migraphx::make_op("pooling",
+                          {{"mode", migraphx::op::pooling_mode::max}, {"padding", {1, 1, 1, 1}}}),
+        l_img);
 
     run_pass(m);
     EXPECT(std::none_of(

test/onnx/celu_alpha_test.onnx

+celu_alpha_test:R
+
+
x
y"Celu*
+alphaL?

celu_alpha_testZ
+
x
+
+

+b
+
y
+
+

+B
\ No newline at end of file

test/onnx/celu_default_test.onnx

+celu_default_test:K
+
+
x
y"Celucelu_default_testZ
+
x
+

+
+b
+
y
+

+
+B
\ No newline at end of file

test/onnx/celu_wrong_type_test.onnx

+celu_wrong_type_test:N
+
+
x
y"Celucelu_wrong_type_testZ
+
x
+
+
+
+b
+
y
+
+
+
+B
\ No newline at end of file

test/onnx/eyelike_default_test.onnx

+eyelike_default_test:U
+
+T1T2"EyeLikeeyelike_default_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_double_test.onnx

+eyelike_double_test:T
+
+T1T2"EyeLikeeyelike_double_testZ
+T1
+
+
+b
+T2
+
+
+B
\ No newline at end of file

test/onnx/eyelike_half_test.onnx

+eyelike_half_test:R
+
+T1T2"EyeLikeeyelike_half_testZ
+T1
+
+
+
+b
+T2
+
+
+
+B
\ No newline at end of file

test/onnx/eyelike_k_outofbounds_neg_test.onnx

+eyelike_k_outofbounds_neg_test:r
+$
+T1T2"EyeLike*
+
k

eyelike_k_outofbounds_neg_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_k_outofbounds_pos_test.onnx

+eyelike_k_outofbounds_pos_test:i
+
+T1T2"EyeLike*
+
k
eyelike_k_outofbounds_pos_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_k_test.onnx

+eyelike_k_test:Y
+
+T1T2"EyeLike*
+
k

eyelike_k_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_not_rank2_test.onnx

+eyelike_not_rank2_test:[
+
+T1T2"EyeLikeeyelike_not_rank2_testZ
+T1
+

+
+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_set_dtype_test.onnx

+eyelike_set_dtype_test:e
+
+T1T2"EyeLike*
+dtype
eyelike_set_dtype_testZ
+T1
+

+
+b
+T2
+
+
+B
\ No newline at end of file

test/onnx/eyelike_verify_negk_test.onnx

+eyelike_verify_negk_test:l
+$
+T1T2"EyeLike*
+
k

eyelike_verify_negk_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/eyelike_verify_test.onnx

+eyelike_verify_test:^
+
+T1T2"EyeLike*
+
k

eyelike_verify_testZ
+T1
+

+
+b
+T2
+

+
+B
\ No newline at end of file

test/onnx/gen_onnx.py

@@ -351,6 +351,65 @@ def ceil_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def celu_alpha_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3])
+
+    node = onnx.helper.make_node('Celu',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 alpha=0.8)
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def celu_default_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
+
+    node = onnx.helper.make_node('Celu', inputs=['x'], outputs=['y'])
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def celu_verify_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
+
+    node = onnx.helper.make_node('Celu',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 alpha=0.5)
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def celu_wrong_type_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [2, 3])
+
+    node = onnx.helper.make_node('Celu', inputs=['x'], outputs=['y'])
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def celu_zero_alpha_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
+
+    node = onnx.helper.make_node('Celu',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 alpha=0.0)
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def clip_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
@@ -426,6 +485,22 @@ def clip_test_op11_no_args1():
     return ([node], [x], [y])
 
 
+@onnx_test
+def clip_test_args_type_mismatch():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 3])
+    y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 3])
+
+    min_val = helper.make_tensor('min', TensorProto.FLOAT, [1, 3],
+                                 [1.5, 2.5, 3.5])
+    max_val = helper.make_tensor('max', TensorProto.INT64, [3, 1], [2, 3, 4])
+
+    node = onnx.helper.make_node('Clip',
+                                 inputs=['0', 'min', 'max'],
+                                 outputs=['1'])
+
+    return ([node], [x], [y], [min_val, max_val])
+
+
 @onnx_test
 def concat_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 4, 3])
@@ -1381,6 +1456,114 @@ def expand_test():
     return ([shape_const, node], [x], [y])
 
 
+@onnx_test
+def eyelike_default_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+
+    node = onnx.helper.make_node(
+        'EyeLike',
+        inputs=['T1'],
+        outputs=['T2'],
+    )
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_double_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.DOUBLE, [6, 15])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [6, 15])
+
+    node = onnx.helper.make_node(
+        'EyeLike',
+        inputs=['T1'],
+        outputs=['T2'],
+    )
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_half_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT16, [8, 8])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT16, [8, 8])
+
+    node = onnx.helper.make_node(
+        'EyeLike',
+        inputs=['T1'],
+        outputs=['T2'],
+    )
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_k_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+    node = onnx.helper.make_node('EyeLike', inputs=['T1'], outputs=['T2'], k=1)
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_k_outofbounds_neg_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [2, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [2, 4])
+    node = onnx.helper.make_node('EyeLike',
+                                 inputs=['T1'],
+                                 outputs=['T2'],
+                                 k=-2)
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_k_outofbounds_pos_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+    node = onnx.helper.make_node('EyeLike', inputs=['T1'], outputs=['T2'], k=4)
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_not_rank2_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4, 2])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+    node = onnx.helper.make_node(
+        'EyeLike',
+        inputs=['T1'],
+        outputs=['T2'],
+    )
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_verify_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+    node = onnx.helper.make_node('EyeLike', inputs=['T1'], outputs=['T2'], k=1)
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_verify_negk_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
+    node = onnx.helper.make_node('EyeLike',
+                                 inputs=['T1'],
+                                 outputs=['T2'],
+                                 k=-2)
+    return ([node], [T1], [T2])
+
+
+@onnx_test
+def eyelike_set_dtype_test():
+    T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
+    T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [3, 4])
+    node = onnx.helper.make_node('EyeLike',
+                                 inputs=['T1'],
+                                 outputs=['T2'],
+                                 dtype=TensorProto.DOUBLE)
+    return ([node], [T1], [T2])
+
+
 @onnx_test
 def flatten_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
@@ -2621,6 +2804,70 @@ def loop_test():
     return ([node], [iter, cond, a, b], [b_loop, uout])
 
 
+@onnx_test
+def lpnormalization_axis_error_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
+
+    node = onnx.helper.make_node('LpNormalization',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 axis=2)
+    return ([node], [x], [y])
+
+
+@onnx_test
+def lpnormalization_default_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
+
+    node = onnx.helper.make_node(
+        'LpNormalization',
+        inputs=['x'],
+        outputs=['y'],
+        axis=0,
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def lpnormalization_l1_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
+
+    node = onnx.helper.make_node(
+        'LpNormalization',
+        inputs=['x'],
+        outputs=['y'],
+        p=1,
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def lpnormalization_l2_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
+
+    node = onnx.helper.make_node('LpNormalization',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 p=2)
+    return ([node], [x], [y])
+
+
+@onnx_test
+def lpnormalization_p_error_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
+
+    node = onnx.helper.make_node('LpNormalization',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 p=3)
+    return ([node], [x], [y])
+
+
 @onnx_test
 def lrn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 28, 24, 24])
@@ -4310,6 +4557,54 @@ def sinh_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def size_float_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_half_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [3, 1])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_int_test():
+    x = helper.make_tensor_value_info('x', TensorProto.INT32, [8, 2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_verify_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
 @onnx_test
 def slice_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 2])

test/onnx/lpnormalization_axis_error_test.onnx

+lpnormalization_axis_error_test:q
+$
+
x
y"LpNormalization*
+axis 
lpnormalization_axis_error_testZ
+
x
+

+
+b
+
y
+

+
+B
\ No newline at end of file