manual merge

test/onnx/const_of_shape2.onnx

+constant-of-shape:

+6shape"Constant*#
+value**Bshape_tensor 

+7
+shape
y"ConstantOfShape*
+value*
:

+Bvalue 
constant_of_shapeb
+
y
+

+
+
+B

test/onnx/const_of_shape3.onnx

+constant-of-shape:

+6shape"Constant*#
+value**Bshape_tensor 

+
+shape
y"ConstantOfShapeconstant_of_shapeb
+
y
+

+
+
+B

test/onnx/expand_test.onnx

+expand:

+7shape"Constant*$
+value**Bshape_tensor

+
+
x
+shape
y"ExpandexpandZ
+
x
+

+
+

+
b
+
y
+

+
+
+
+B

test/onnx/onnx_test.cpp

@@ -423,9 +423,7 @@ TEST_CASE(softmax_test)
 {
     migraphx::program p;
     auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
-    auto r  = p.add_instruction(migraphx::op::reshape{{1, 3, 1, 1}}, l0);
-    auto s  = p.add_instruction(migraphx::op::softmax{}, r);
-    p.add_instruction(migraphx::op::reshape{{1, 3}}, s);
+    p.add_instruction(migraphx::op::softmax{1}, l0);
     auto prog = migraphx::parse_onnx("softmax_test.onnx");
 
     EXPECT(p == prog);
@@ -447,6 +445,21 @@ TEST_CASE(reshape_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(reshape_non_standard)
+{
+    migraphx::program p;
+    migraphx::op::reshape op;
+    std::vector<int64_t> reshape_dims{4, 3, 2};
+    migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}};
+    auto x      = p.add_parameter("x", s);
+    auto tran_x = p.add_instruction(migraphx::op::transpose{{0, 2, 1}}, x);
+    auto cont_x = p.add_instruction(migraphx::op::contiguous{}, tran_x);
+    p.add_instruction(migraphx::op::reshape{{4, 3, 2}}, cont_x);
+    auto prog = migraphx::parse_onnx("reshape_non_standard.onnx");
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(shape_test)
 {
     migraphx::program p;
@@ -925,4 +938,78 @@ TEST_CASE(pow_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(cast_test)
+{
+    migraphx::program p;
+    auto l = p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
+    p.add_instruction(migraphx::op::convert{migraphx::shape::float_type}, l);
+
+    auto prog = migraphx::parse_onnx("cast_test.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(const_of_shape_float)
+{
+    migraphx::program p;
+    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
+    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
+    std::vector<float> vec(s.elements(), 10.0f);
+    p.add_literal(migraphx::literal(s, vec));
+
+    auto prog = migraphx::parse_onnx("const_of_shape1.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(const_of_shape_int64)
+{
+    migraphx::program p;
+    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
+    migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
+    std::vector<int64_t> vec(s.elements(), 10);
+    p.add_literal(migraphx::literal(s, vec));
+
+    auto prog = migraphx::parse_onnx("const_of_shape2.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(const_of_shape_no_value_attr)
+{
+    migraphx::program p;
+    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    p.add_literal(migraphx::literal(ss, {2, 3, 4}));
+    migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
+    std::vector<float> vec(s.elements(), 0.0f);
+    p.add_literal(migraphx::literal(s, vec));
+
+    auto prog = migraphx::parse_onnx("const_of_shape3.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(const_of_shape_empty_input)
+{
+    migraphx::program p;
+    p.add_literal(migraphx::literal());
+    migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
+    std::vector<int64_t> vec(s.elements(), 10);
+    p.add_literal(migraphx::literal(s, vec));
+
+    auto prog = migraphx::parse_onnx("const_of_shape4.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(expand_test)
+{
+    migraphx::program p;
+    migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
+    auto param = p.add_parameter("x", s);
+    migraphx::shape ss(migraphx::shape::int32_type, {4});
+    p.add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
+    p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, param);
+
+    auto prog = migraphx::parse_onnx("expand_test.onnx");
+    EXPECT(p == prog);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/tf/batchmatmul_test.pb

+
+:
+
0Placeholder*
+shape:
*
+dtype0

+:
+
1Placeholder*
+dtype0
*
+shape:

+D
+batchmatmul1BatchMatMul
0
1*
+adj_x(
*
+adj_y(
*
+
T0
"
\ No newline at end of file

test/tf/pow_test.pb

+
+:
+
0Placeholder*
+dtype0
*
+shape:

+:
+
1Placeholder*
+dtype0
*
+shape:

+
+pow1Pow
0
1*
+
T0
"
\ No newline at end of file

test/tf/rsqrt_test.pb

+
+:
+
0Placeholder*
+shape:
*
+dtype0

+
+rsqrtRsqrt
0*
+
T0
"
\ No newline at end of file

test/tf/tf_test.cpp

@@ -48,6 +48,21 @@ TEST_CASE(add_bcast_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(batchmatmul_test)
+{
+    migraphx::program p;
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 8, 4}});
+    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 4, 8}});
+
+    auto trans_l0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
+    auto trans_l1 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l1);
+
+    p.add_instruction(migraphx::op::dot{}, trans_l0, trans_l1);
+    auto prog = optimize_tf("batchmatmul_test.pb", false);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(batchnorm_test)
 {
     float epsilon  = 1.001e-5f;
@@ -103,6 +118,16 @@ TEST_CASE(concat_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(cast_test)
+{
+    migraphx::program p;
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
+    p.add_instruction(migraphx::op::convert{migraphx::shape::int32_type}, l0);
+    auto prog = optimize_tf("cast_test.pb", false);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(const_test)
 {
     migraphx::program p;
@@ -184,6 +209,22 @@ TEST_CASE(expanddims_test_neg_dims)
     EXPECT(p == prog);
 }
 
+TEST_CASE(gather_test)
+{
+    migraphx::program p;
+
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4}});
+    auto l1 =
+        p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {2}}, {1, 1}});
+    p.add_literal(1);
+
+    int axis = 1;
+    p.add_instruction(migraphx::op::gather{axis}, l0, l1);
+    auto prog = optimize_tf("gather_test.pb", false);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(identity_test)
 {
     migraphx::program p;
@@ -312,12 +353,22 @@ TEST_CASE(pooling_test)
     avg_pool_op.lengths      = {2, 2};
     max_pool_op.lengths      = {2, 2};
     p.add_instruction(max_pool_op, l0);
-    // p.add_instruction(avg_pool_op, l0);
     auto prog = optimize_tf("pooling_test.pb", true);
 
     EXPECT(p == prog);
 }
 
+TEST_CASE(pow_test)
+{
+    migraphx::program p;
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
+    auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
+    p.add_instruction(migraphx::op::pow{}, l0, l1);
+    auto prog = optimize_tf("pow_test.pb", false);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(relu_test)
 {
     migraphx::program p;
@@ -351,6 +402,16 @@ TEST_CASE(reshape_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(rsqrt_test)
+{
+    migraphx::program p;
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
+    p.add_instruction(migraphx::op::rsqrt{}, l0);
+    auto prog = optimize_tf("rsqrt_test.pb", false);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(slice_test)
 {
     migraphx::program p;
@@ -374,11 +435,8 @@ TEST_CASE(slice_test)
 TEST_CASE(softmax_test)
 {
     migraphx::program p;
-    auto l0   = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
-    auto dims = l0->get_shape().lens();
-    auto r    = p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1]), 1, 1}}, l0);
-    auto s    = p.add_instruction(migraphx::op::softmax{}, r);
-    p.add_instruction(migraphx::op::reshape{{long(dims[0]), long(dims[1])}}, s);
+    auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
+    p.add_instruction(migraphx::op::softmax{1}, l0);
     auto prog = optimize_tf("softmax_test.pb", false);
 
     EXPECT(p == prog);