Split onnx tests

test/onnx/parse/averagepool_dyn_autopad_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/common.hpp>
+
+
+TEST_CASE(averagepool_dyn_autopad_test)
+{
+    // Pooling with dynamic input and auto padding. Default padding values will be overridden.
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter(
+        "0", {migraphx::shape::float_type, {{1, 4}, {3, 3}, {5, 5}, {5, 5}, {5, 5}}});
+    auto ret = mm->add_instruction(
+        migraphx::make_op("pooling",
+                          {
+                              {"mode", migraphx::op::pooling_mode::average},
+                              {"stride", {2, 2, 2}},
+                              {"lengths", {3, 3, 3}},
+                              {"dilations", {1, 1, 1}},
+                              {"padding", {0, 0, 0, 0, 0, 0}},
+                              {"padding_mode", migraphx::op::padding_mode_t::same_upper},
+                          }),
+        l0);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog = migraphx::parse_onnx("averagepool_dyn_autopad_test.onnx", options);
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_dyn_cip_error_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(averagepool_dyn_cip_error_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("averagepool_dyn_cip_error_test.onnx", options); }));
+}
+
+

test/onnx/parse/averagepool_dyn_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(averagepool_dyn_test)
+{
+    // Pooling with dynamic input and no auto padding
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter(
+        "0", {migraphx::shape::float_type, {{1, 4}, {3, 3}, {5, 5}, {5, 5}, {5, 5}}});
+    auto ret =
+        mm->add_instruction(migraphx::make_op("pooling",
+                                              {
+                                                  {"mode", migraphx::op::pooling_mode::average},
+                                                  {"stride", {2, 2, 2}},
+                                                  {"lengths", {3, 3, 3}},
+                                                  {"dilations", {1, 1, 1}},
+                                                  {"padding", {1, 1, 1, 1, 1, 1}},
+                                                  {"padding_mode", 0},
+                                              }),
+                            l0);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog                     = migraphx::parse_onnx("averagepool_dyn_test.onnx", options);
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_notset_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(averagepool_notset_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
+    auto ins   = mm->add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", migraphx::op::pooling_mode::average},
+                                                        {"padding", {2, 2, 2, 2}},
+                                                        {"stride", {2, 2}},
+                                                        {"lengths", {6, 6}},
+                                                        {"dilations", {1, 1}}}),
+                                   input);
+    auto ret   = mm->add_instruction(
+        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {2, 2}}}), ins);
+    mm->add_return({ret});
+    auto prog = migraphx::parse_onnx("averagepool_notset_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_nt_cip_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(averagepool_nt_cip_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
+    std::vector<int64_t> pads = {0, 0, 0, 0, 0, 0, 1, 1};
+    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
+    auto ret                  = mm->add_instruction(migraphx::make_op("pooling",
+                                                                      {{"mode", migraphx::op::pooling_mode::average},
+                                                                       {"padding", {0, 0, 0, 0}},
+                                                                       {"stride", {2, 2}},
+                                                                       {"lengths", {6, 6}},
+                                                                       {"dilations", {1, 1}}}),
+                                   ins_pad);
+    mm->add_return({ret});
+
+    auto prog = migraphx::parse_onnx("averagepool_nt_cip_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_same_lower_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/common.hpp>
+
+
+TEST_CASE(averagepool_same_lower_test)
+{
+    // auto_pad mode of SAME_LOWER with a static input shape is handled in parsing and
+    // padding_mode is set to default_ when the operation is created
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
+    auto ins   = mm->add_instruction(
+        migraphx::make_op("pooling",
+                            {
+                              {"mode", migraphx::op::pooling_mode::average},
+                              {"padding", {1, 1, 1, 1}},
+                              {"stride", {1, 1}},
+                              {"lengths", {2, 2}},
+                              {"dilations", {1, 1}},
+                              {"padding_mode", migraphx::op::padding_mode_t::default_},
+                          }),
+        input);
+    auto ret = mm->add_instruction(
+        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {0, 0}}, {"ends", {5, 5}}}), ins);
+    mm->add_return({ret});
+    auto prog = migraphx::parse_onnx("averagepool_same_lower_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_same_upper_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(averagepool_same_upper_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
+    auto ins   = mm->add_instruction(migraphx::make_op("pooling",
+                                                       {{"mode", migraphx::op::pooling_mode::average},
+                                                        {"padding", {1, 1, 1, 1}},
+                                                        {"stride", {1, 1}},
+                                                        {"lengths", {2, 2}},
+                                                        {"dilations", {1, 1}}}),
+                                   input);
+    auto ret   = mm->add_instruction(
+        migraphx::make_op("slice", {{"axes", {2, 3}}, {"starts", {1, 1}}, {"ends", {6, 6}}}), ins);
+    mm->add_return({ret});
+    auto prog = migraphx::parse_onnx("averagepool_same_upper_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/averagepool_sl_cip_test.cpp

+
+#include <onnx_test.hpp>
+#include <migraphx/op/pooling.hpp>
+
+
+TEST_CASE(averagepool_sl_cip_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 5}});
+    std::vector<int64_t> pads = {0, 0, 1, 1, 0, 0, 0, 0};
+    auto ins_pad = mm->add_instruction(migraphx::make_op("pad", {{"pads", pads}}), input);
+    auto ret                  = mm->add_instruction(migraphx::make_op("pooling",
+                                                                      {{"mode", migraphx::op::pooling_mode::average},
+                                                                       {"padding", {0, 0, 0, 0}},
+                                                                       {"stride", {1, 1}},
+                                                                       {"lengths", {2, 2}},
+                                                                       {"dilations", {1, 1}}}),
+                                   ins_pad);
+    mm->add_return({ret});
+    auto prog = migraphx::parse_onnx("averagepool_sl_cip_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/batch_norm_1d_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(batch_norm_1d_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto x     = mm->add_parameter("x", {migraphx::shape::half_type, {2, 3, 4}});
+    auto scale = mm->add_parameter("scale", {migraphx::shape::float_type, {3}});
+    auto bias  = mm->add_parameter("bias", {migraphx::shape::float_type, {3}});
+    auto mean  = mm->add_parameter("mean", {migraphx::shape::float_type, {3}});
+    auto var   = mm->add_parameter("variance", {migraphx::shape::float_type, {3}});
+
+    auto eps = mm->add_literal(migraphx::literal{migraphx::shape::half_type, {1e-5f}});
+
+    auto usq_scale = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), scale);
+    auto usq_bias  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), bias);
+    auto usq_mean  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), mean);
+    auto usq_var   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), var);
+
+    auto x_sub_mean = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps    = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto rsqrt      = mm->add_instruction(migraphx::make_op("rsqrt"), var_eps);
+    auto mul0       = add_common_op(*mm, migraphx::make_op("mul"), {usq_scale, rsqrt});
+    auto r0         = add_common_op(*mm, migraphx::make_op("mul"), {x_sub_mean, mul0});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
+    auto prog = optimize_onnx("batch_norm_1d_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/batch_norm_2d_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(batch_norm_2d_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto x     = mm->add_parameter("x", {migraphx::shape::float_type, {2, 3, 4, 4}});
+    auto scale = mm->add_parameter("scale", {migraphx::shape::float_type, {3}});
+    auto bias  = mm->add_parameter("bias", {migraphx::shape::float_type, {3}});
+    auto mean  = mm->add_parameter("mean", {migraphx::shape::float_type, {3}});
+    auto var   = mm->add_parameter("variance", {migraphx::shape::float_type, {3}});
+
+    auto eps = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-5f}});
+
+    auto usq_scale = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+    auto usq_bias  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+    auto usq_mean  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+    auto usq_var   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), var);
+
+    auto x_sub_mean = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps    = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto rsqrt      = mm->add_instruction(migraphx::make_op("rsqrt"), var_eps);
+    auto mul0       = add_common_op(*mm, migraphx::make_op("mul"), {usq_scale, rsqrt});
+    auto r0         = add_common_op(*mm, migraphx::make_op("mul"), {x_sub_mean, mul0});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
+    auto prog = optimize_onnx("batch_norm_2d_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/batch_norm_3d_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(batch_norm_3d_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto x     = mm->add_parameter("x", {migraphx::shape::half_type, {2, 2, 2, 2, 2}});
+    auto scale = mm->add_parameter("scale", {migraphx::shape::half_type, {2}});
+    auto bias  = mm->add_parameter("bias", {migraphx::shape::half_type, {2}});
+    auto mean  = mm->add_parameter("mean", {migraphx::shape::half_type, {2}});
+    auto var   = mm->add_parameter("variance", {migraphx::shape::half_type, {2}});
+
+    auto eps = mm->add_literal(migraphx::literal{migraphx::shape::half_type, {1e-6f}});
+
+    auto usq_scale =
+        mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2, 3}}}), scale);
+    auto usq_bias =
+        mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2, 3}}}), bias);
+    auto usq_mean =
+        mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2, 3}}}), mean);
+    auto usq_var = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2, 3}}}), var);
+
+    auto x_sub_mean = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps    = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto rsqrt      = mm->add_instruction(migraphx::make_op("rsqrt"), var_eps);
+    auto mul0       = add_common_op(*mm, migraphx::make_op("mul"), {usq_scale, rsqrt});
+    auto r0         = add_common_op(*mm, migraphx::make_op("mul"), {x_sub_mean, mul0});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
+    auto prog = optimize_onnx("batch_norm_3d_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/batch_norm_flat_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(batch_norm_flat_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto x     = mm->add_parameter("x", {migraphx::shape::float_type, {10}});
+    auto scale = mm->add_parameter("scale", {migraphx::shape::float_type, {1}});
+    auto bias  = mm->add_parameter("bias", {migraphx::shape::float_type, {1}});
+    auto mean  = mm->add_parameter("mean", {migraphx::shape::float_type, {1}});
+    auto var   = mm->add_parameter("variance", {migraphx::shape::float_type, {1}});
+
+    auto eps = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-6f}});
+
+    auto x_sub_mean = add_common_op(*mm, migraphx::make_op("sub"), {x, mean});
+    auto var_eps    = add_common_op(*mm, migraphx::make_op("add"), {var, eps});
+    auto rsqrt      = mm->add_instruction(migraphx::make_op("rsqrt"), {var_eps});
+    auto mul0       = add_common_op(*mm, migraphx::make_op("mul"), {scale, rsqrt});
+    auto r0         = add_common_op(*mm, migraphx::make_op("mul"), {x_sub_mean, mul0});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, bias});
+
+    auto prog = optimize_onnx("batch_norm_flat_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/batch_norm_invalid_bias_rank.cpp

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

test/onnx/parse/batch_norm_invalid_rank.cpp

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

test/onnx/parse/batch_norm_rank_2_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(batch_norm_rank_2_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    auto x     = mm->add_parameter("x", {migraphx::shape::float_type, {2, 5}});
+    auto scale = mm->add_parameter("scale", {migraphx::shape::float_type, {5}});
+    auto bias  = mm->add_parameter("bias", {migraphx::shape::float_type, {5}});
+    auto mean  = mm->add_parameter("mean", {migraphx::shape::float_type, {5}});
+    auto var   = mm->add_parameter("variance", {migraphx::shape::float_type, {5}});
+
+    auto eps = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-6f}});
+
+    auto x_sub_mean = add_common_op(*mm, migraphx::make_op("sub"), {x, mean});
+    auto var_eps    = add_common_op(*mm, migraphx::make_op("add"), {var, eps});
+    auto rsqrt      = mm->add_instruction(migraphx::make_op("rsqrt"), {var_eps});
+    auto mul0       = add_common_op(*mm, migraphx::make_op("mul"), {scale, rsqrt});
+    auto r0         = add_common_op(*mm, migraphx::make_op("mul"), {x_sub_mean, mul0});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, bias});
+
+    auto prog = optimize_onnx("batch_norm_rank_2_test.onnx");
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/binary_dyn_brcst_add_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(binary_dyn_brcst_add_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::half_type, {4, 5}});
+    auto l1  = mm->add_parameter(
+        "1", migraphx::shape{migraphx::shape::float_type, {{1, 4}, {3, 3}, {4, 4}, {5, 5}}});
+
+    auto ret = add_common_op(*mm, migraphx::make_op("add"), {l0, l1});
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog                     = migraphx::parse_onnx("binary_dyn_brcst_add_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/binary_dyn_brcst_attr_error_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(binary_dyn_brcst_attr_error_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("binary_dyn_brcst_attr_error_test.onnx", options); }));
+}
+
+

test/onnx/parse/binary_dyn_brcst_mul_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(binary_dyn_brcst_mul_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {{1, 4}, {3, 3}, {4, 4}, {5, 5}}});
+    auto l1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1}});
+
+    auto bl1 = mm->add_instruction(
+        migraphx::make_op("multibroadcast",
+                          {{"out_dyn_dims", to_value(l0->get_shape().dyn_dims())}}),
+        l1,
+        l0);
+    auto ret = mm->add_instruction(migraphx::make_op("mul"), l0, bl1);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog                     = migraphx::parse_onnx("binary_dyn_brcst_mul_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/binary_dyn_brcst_prelu_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(binary_dyn_brcst_prelu_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {{1, 4}, {3, 3}, {4, 4}, {5, 5}}});
+    auto l1 = mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}});
+
+    auto ret = add_common_op(*mm, migraphx::make_op("prelu"), {l0, l1});
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto prog = migraphx::parse_onnx("binary_dyn_brcst_prelu_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
+

test/onnx/parse/cast_test.cpp

+
+#include <onnx_test.hpp>
+
+
+TEST_CASE(cast_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l   = mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
+    mm->add_instruction(
+        migraphx::make_op("convert",
+                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
+        l);
+
+    auto prog = optimize_onnx("cast_test.onnx");
+    EXPECT(p == prog);
+}
+
+