Split onnx tests

test/onnx/parse/globalavgpool_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(globalavgpool_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    auto lens  = input->get_shape().lens();
+    op.lengths = {lens[2], lens[3]};
+    op.padding = {0, 0, 0, 0};
+    mm->add_instruction(op, input);
+
+    auto prog = optimize_onnx("globalavgpool_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/globallppool_dyn_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(globallppool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {{1, 1}, {3, 3}, {16, 32}, {16, 32}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::lpnorm},
+                                                      {"dyn_global", true},
+                                                      {"padding", {0, 0, 0, 0}},
+                                                      {"lengths", {}}}),
+                                   input);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {16, 32};
+    auto prog                     = migraphx::parse_onnx("globallppool_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/globallppool_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(globallppool_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::lpnorm};
+    auto lens  = input->get_shape().lens();
+    op.lengths = {lens[2], lens[3]};
+    op.padding = {0, 0, 0, 0};
+    mm->add_instruction(op, input);
+
+    auto prog = optimize_onnx("globallppool_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/globalmaxpool_dyn_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(globalmaxpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {{1, 4}, {3, 3}, {32, 32}, {32, 32}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::max},
+                                                      {"lengths", {32, 32}},
+                                                      {"padding", {0, 0, 0, 0}}}),
+                                   input);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog                     = parse_onnx("globalmaxpool_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/globalmaxpool_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(globalmaxpool_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    auto lens  = input->get_shape().lens();
+    op.lengths = {lens[2], lens[3]};
+    op.padding = {0, 0, 0, 0};
+    mm->add_instruction(op, input);
+
+    auto prog = optimize_onnx("globalmaxpool_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/greater_bool_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(greater_bool_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape sf{migraphx::shape::float_type, {2, 3}};
+    migraphx::shape sb{migraphx::shape::bool_type, {2, 3}};
+
+    auto input1 = mm->add_parameter("x1", sf);
+    auto input2 = mm->add_parameter("x2", sb);
+    auto cin1   = mm->add_instruction(
+        migraphx::make_op("convert",
+                            {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
+        input1);
+    auto ret = mm->add_instruction(migraphx::make_op("greater"), cin1, input2);
+    mm->add_return({ret});
+
+    auto prog = migraphx::parse_onnx("greater_bool_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/greater_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(greater_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
+    std::vector<float> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
+
+    auto input1 = mm->add_literal(migraphx::literal(s, data));
+    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {2, 3}});
+    auto gr     = mm->add_instruction(migraphx::make_op("greater"), input1, input2);
+    auto ret    = mm->add_instruction(
+        migraphx::make_op("convert",
+                             {{"target_type", migraphx::to_value(migraphx::shape::bool_type)}}),
+        gr);
+    mm->add_return({ret});
+
+    auto prog = migraphx::parse_onnx("greater_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/greaterorequal_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(greaterorequal_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto input1 = mm->add_parameter("x1", migraphx::shape{migraphx::shape::float_type, {3}});
+    auto input2 = mm->add_parameter("x2", migraphx::shape{migraphx::shape::float_type, {3}});
+    auto temp   = mm->add_instruction(migraphx::make_op("less"), input1, input2);
+    auto bt     = mm->add_instruction(
+        migraphx::make_op("convert", {{"target_type", migraphx::shape::bool_type}}), temp);
+    auto ge = mm->add_instruction(migraphx::make_op("not"), bt);
+
+    mm->add_return({ge});
+
+    auto prog = migraphx::parse_onnx("greaterorequal_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_conv_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/convolution.hpp>
+
+
+TEST_CASE(group_conv_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}});
+    auto l1  = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}});
+    migraphx::op::convolution op;
+    op.group = 4;
+    mm->add_instruction(op, l0, l1);
+    auto prog = optimize_onnx("group_conv_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_3d_half_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_3d_half_test)
+{
+    migraphx::program p = make_group_norm(
+        {1, 4, 2}, {2}, {2}, {1, 2, 2, 2}, {2, 3}, 1e-5f, migraphx::shape::half_type);
+    auto prog = optimize_onnx("group_norm_3d_half_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_3d_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_3d_test)
+{
+    migraphx::program p = make_group_norm(
+        {1, 4, 2}, {2}, {2}, {1, 2, 2, 2}, {2, 3}, 1e-5f, migraphx::shape::float_type);
+    auto prog = optimize_onnx("group_norm_3d_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_4d_half_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_4d_half_test)
+{
+    migraphx::program p = make_group_norm(
+        {1, 4, 3, 3}, {2}, {2}, {1, 2, 2, 3, 3}, {2, 3, 4}, 1e-5f, migraphx::shape::half_type);
+    auto prog = optimize_onnx("group_norm_4d_half_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_4d_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_4d_test)
+{
+    migraphx::program p = make_group_norm(
+        {1, 4, 3, 3}, {2}, {2}, {1, 2, 2, 3, 3}, {2, 3, 4}, 1e-5f, migraphx::shape::float_type);
+    auto prog = optimize_onnx("group_norm_4d_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_5d_half_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_5d_half_test)
+{
+    migraphx::program p = make_group_norm({3, 3, 3, 3, 3},
+                                          {1},
+                                          {1},
+                                          {3, 1, 3, 3, 3, 3},
+                                          {2, 3, 4, 5},
+                                          1e-5f,
+                                          migraphx::shape::half_type);
+    auto prog           = optimize_onnx("group_norm_5d_half_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_5d_test.cpp

+
+#include <onnx_test.hpp>
+#include <onnx_test_utils.hpp>
+
+
+TEST_CASE(group_norm_5d_test)
+{
+    migraphx::program p = make_group_norm({3, 3, 3, 3, 3},
+                                          {1},
+                                          {1},
+                                          {3, 1, 3, 3, 3, 3},
+                                          {2, 3, 4, 5},
+                                          1e-5f,
+                                          migraphx::shape::float_type);
+    auto prog           = optimize_onnx("group_norm_5d_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/group_norm_invalid_bias_shape_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(group_norm_invalid_bias_shape_test)
+{
+    EXPECT(test::throws([&] { migraphx::parse_onnx("group_norm_invalid_bias_shape_test.onnx"); }));
+}
+
+

test/onnx/parse/group_norm_invalid_input_count_error_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(group_norm_invalid_input_count_error_test)
+{
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("group_norm_invalid_input_count_error_test.onnx"); }));
+}
+
+

test/onnx/parse/group_norm_invalid_input_shape_error_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(group_norm_invalid_input_shape_error_test)
+{
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("group_norm_invalid_input_shape_error_test.onnx"); }));
+}
+
+

test/onnx/parse/group_norm_invalid_num_groups_error_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(group_norm_invalid_num_groups_error_test)
+{
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("group_norm_invalid_num_groups_error_test.onnx"); }));
+}
+
+

test/onnx/parse/group_norm_invalid_scale_shape_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(group_norm_invalid_scale_shape_test)
+{
+    EXPECT(test::throws([&] { migraphx::parse_onnx("group_norm_invalid_scale_shape_test.onnx"); }));
+}
+
+