Merge branch 'develop' of https://github.com/ROCmSoftwarePlatform/AMDMIGraphX into mlir-attention

test/onnx/trilu_row_one_test.onnx → test/onnx/triu_row_one_test.onnx

-trilu_row_one_test:\
+triu_row_one_test:[
 
 
x
-
k
y"Trilutrilu_row_one_test*
+
k
y"Trilutriu_row_one_test*
 
:

B
kZ
 
x
 

@@ -10,4 +10,4 @@
 
y
 

 

-B
\ No newline at end of file
+B
\ No newline at end of file

test/onnx/trilu_test.onnx → test/onnx/triu_test.onnx

-
-trilu_test:E
+	triu_test:D
 
-
x
y"Trilu
-trilu_testZ
+
x
y"Trilu	triu_testZ
 
x
 

 
@@ -10,4 +8,4 @@ trilu_testZ
 
y
 

 
-B
\ No newline at end of file
+B
\ No newline at end of file

test/onnx/verify_onnx.cpp

@@ -538,6 +538,70 @@ TEST_CASE(gemm_half_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+template <typename T = float>
+std::vector<T> norm_test(const std::vector<size_t>& x_dims,
+                         std::vector<T>& scale,
+                         std::vector<T>& bias,
+                         const std::string& onnx_file)
+{
+    migraphx::program p = migraphx::parse_onnx(onnx_file);
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s_x{migraphx::shape::get_type<T>{}, x_dims};
+    migraphx::shape s_s{migraphx::shape::get_type<T>{}, {scale.size()}};
+    migraphx::shape s_b{migraphx::shape::get_type<T>{}, {scale.size()}};
+
+    std::vector<T> x(s_x.elements());
+    std::iota(std::begin(x), std::end(x), 1);
+
+    migraphx::parameter_map pp;
+    pp["x"]     = migraphx::argument(s_x, x.data());
+    pp["scale"] = migraphx::argument(s_s, scale.data());
+    pp["bias"]  = migraphx::argument(s_b, bias.data());
+
+    auto result = p.eval(pp).back();
+
+    std::vector<T> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    return result_vector;
+}
+
+TEST_CASE(group_norm_test)
+{
+    std::vector<float> scale{1.2, 0.8};
+    std::vector<float> bias{0.5, 0.2};
+    std::vector<float> result_vector =
+        norm_test<float>({1, 4, 2}, scale, bias, "group_norm_3d_test.onnx");
+    std::vector<float> gold = {-1.10996256,
+                               -0.0366542,
+                               1.0366542,
+                               2.10996256,
+                               -0.87330837,
+                               -0.15776947,
+                               0.55776947,
+                               1.27330837};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(group_norm_half_test)
+{
+    using migraphx::half;
+    std::vector<half> scale{half{1.2}, half{0.8}};
+    std::vector<half> bias{half{0.5}, half{0.2}};
+    std::vector<half> result_vector =
+        norm_test<half>({1, 4, 2}, scale, bias, "group_norm_3d_half_test.onnx");
+    std::vector<half> gold = {half{-1.10996256},
+                              half{-0.0366542},
+                              half{1.0366542},
+                              half{2.10996256},
+                              half{-0.87330837},
+                              half{-0.15776947},
+                              half{0.55776947},
+                              half{1.27330837}};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(greaterorequal_test)
 {
     migraphx::program p = migraphx::parse_onnx("greaterorequal_test.onnx");
@@ -950,6 +1014,41 @@ TEST_CASE(instance_norm_3d_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(layer_norm_test)
+{
+    std::vector<float> scale{1.2, 0.8};
+    std::vector<float> bias{0.5, 0.2};
+    std::vector<float> result_vector =
+        norm_test<float>({1, 4, 2}, scale, bias, "layer_norm_3d_test.onnx");
+    std::vector<float> gold = {-0.69997597,
+                               0.99998398,
+                               -0.69997597,
+                               0.99998398,
+                               -0.69997597,
+                               0.99998398,
+                               -0.69997597,
+                               0.99998398};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(layer_norm_half_test)
+{
+    using migraphx::half;
+    std::vector<half> scale{half{1.2}, half{0.8}};
+    std::vector<half> bias{half{0.5}, half{0.2}};
+    std::vector<half> result_vector =
+        norm_test<half>({1, 4, 2}, scale, bias, "layer_norm_3d_half_test.onnx");
+    std::vector<half> gold = {half{-0.69997597},
+                              half{0.99998398},
+                              half{-0.69997597},
+                              half{0.99998398},
+                              half{-0.69997597},
+                              half{0.99998398},
+                              half{-0.69997597},
+                              half{0.99998398}};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(lessorequal_test)
 {
     migraphx::program p = migraphx::parse_onnx("lessorequal_test.onnx");
@@ -1112,6 +1211,115 @@ TEST_CASE(mean_integral_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+template <typename T = float>
+std::vector<T> mvn_test(std::vector<size_t> data_lens, const std::string& test_file)
+{
+    migraphx::program p = migraphx::parse_onnx(test_file);
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape data_shape(migraphx::shape::get_type<T>{}, std::move(data_lens));
+    std::vector<T> data(data_shape.elements());
+    std::iota(begin(data), end(data), 0);
+
+    migraphx::parameter_map pm;
+    pm["data"] = migraphx::argument(data_shape, data.data());
+
+    auto result = p.eval(pm).back();
+    std::vector<T> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    return result_vector;
+}
+
+TEST_CASE(mvn_default_axes_test)
+{
+    auto result = mvn_test({2, 2, 2, 2}, "mvn_default_axes_test.onnx");
+    std::vector<float> gold{-1.32424438,
+                            -1.08347268,
+                            -0.84270097,
+                            -0.60192927,
+                            -1.32424438,
+                            -1.08347268,
+                            -0.84270097,
+                            -0.60192927,
+                            0.60192927,
+                            0.84270097,
+                            1.08347268,
+                            1.32424438,
+                            0.60192927,
+                            0.84270097,
+                            1.08347268,
+                            1.32424438};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
+TEST_CASE(mvn_default_axes_fp16_test)
+{
+    using migraphx::half;
+    auto result = mvn_test<half>({2, 2, 2, 2}, "mvn_default_axes_fp16_test.onnx");
+    std::vector<half> gold{half{-1.324},
+                           half{-1.084},
+                           half{-0.843},
+                           half{-0.602},
+                           half{-1.324},
+                           half{-1.084},
+                           half{-0.843},
+                           half{-0.602},
+                           half{0.602},
+                           half{0.843},
+                           half{1.084},
+                           half{1.324},
+                           half{0.602},
+                           half{0.843},
+                           half{1.084},
+                           half{1.324}};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
+TEST_CASE(mvn_rank_2_test)
+{
+    auto result = mvn_test({2, 2}, "mvn_rank_2_test.onnx");
+    std::vector<float> gold{-1, 1, -1, 1};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
+TEST_CASE(mvn_rank_2_fp16_test)
+{
+    using migraphx::half;
+    auto result = mvn_test<migraphx::half>({2, 2}, "mvn_rank_2_fp16_test.onnx");
+    std::vector<migraphx::half> gold{half{-1}, half{1}, half{-1}, half{1}};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
+TEST_CASE(mvn_rank_3_test)
+{
+    auto result = mvn_test({2, 2, 2}, "mvn_rank_3_test.onnx");
+    std::vector<float> gold{-1.34164079,
+                            -1.34164079,
+                            -0.4472136,
+                            -0.4472136,
+                            0.4472136,
+                            0.4472136,
+                            1.34164079,
+                            1.34164079};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
+TEST_CASE(mvn_rank_3_fp16_test)
+{
+    using migraphx::half;
+    auto result = mvn_test<half>({2, 2, 2}, "mvn_rank_3_fp16_test.onnx");
+    std::vector<half> gold{half{-1.342},
+                           half{-1.342},
+                           half{-0.4473},
+                           half{-0.4473},
+                           half{0.4473},
+                           half{0.4473},
+                           half{1.342},
+                           half{1.342}};
+    EXPECT(migraphx::verify::verify_rms_range(result, gold));
+}
+
 TEST_CASE(mod_test)
 {
     migraphx::program p = migraphx::parse_onnx("mod_test.onnx");
@@ -1708,6 +1916,112 @@ TEST_CASE(selu_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(shrink_hard_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_hard_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::float_type, {5}};
+    std::vector<float> data{-2, -1, 0, 1, 2};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {-2, 0, 0, 0, 2};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(shrink_soft_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_soft_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::float_type, {5}};
+    std::vector<float> data{-2, -1, 0, 1, 2};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {-0.5, 0, 0, 0, 0.5};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(shrink_verify_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_verify_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::half_type, {5}};
+    std::vector<float> tmp = {-10.0, -5.0, 0.0, 5.0, 10.0};
+    std::vector<migraphx::half> data{tmp.cbegin(), tmp.cend()};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<migraphx::half> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    tmp = {-9.0, -4.0, 1.0, 4.0, 9.0};
+    std::vector<migraphx::half> gold{tmp.cbegin(), tmp.cend()};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(shrink_verify2_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_verify2_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::half_type, {5}};
+    std::vector<float> tmp = {-10.0, -5.0, 0.0, 5.0, 10.0};
+    std::vector<migraphx::half> data{tmp.cbegin(), tmp.cend()};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<migraphx::half> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    tmp = {-5.0, 0.0, 5.0, 10.0, 5.0};
+    std::vector<migraphx::half> gold{tmp.cbegin(), tmp.cend()};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(shrink_int8_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_int8_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::int8_type, {3, 3}};
+    std::vector<int8_t> data{-4, -3, -2, -1, 0, 1, 2, 3, 4};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<int8_t> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<int8_t> gold = {-2, -1, 0, 0, 0, 0, 0, 1, 2};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(shrink_uint8_test)
+{
+    migraphx::program p = migraphx::parse_onnx("shrink_uint8_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::uint8_type, {3, 3}};
+    std::vector<uint8_t> data{1, 2, 3, 4, 5, 6, 7, 8, 9};
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<uint8_t> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<uint8_t> gold = {0, 0, 0, 0, 0, 10, 11, 12, 13};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(size_verify_test)
 {
     migraphx::program p = migraphx::parse_onnx("size_verify_test.onnx");
@@ -1919,9 +2233,10 @@ std::vector<float> gen_trilu_test(const migraphx::shape& s, const migraphx::prog
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
     return result_vector;
 }
-TEST_CASE(trilu_test)
+
+TEST_CASE(triu_test)
 {
-    migraphx::program p = migraphx::parse_onnx("trilu_test.onnx");
+    migraphx::program p = migraphx::parse_onnx("triu_test.onnx");
 
     std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
 
@@ -1930,9 +2245,9 @@ TEST_CASE(trilu_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
-TEST_CASE(trilu_batch_diff_k_test)
+TEST_CASE(triu_batch_diff_k_test)
 {
-    migraphx::program p = migraphx::parse_onnx("trilu_batch_diff_k_test.onnx");
+    migraphx::program p = migraphx::parse_onnx("triu_batch_diff_k_test.onnx");
 
     std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {2, 2, 3}}, p);
 
@@ -1941,9 +2256,42 @@ TEST_CASE(trilu_batch_diff_k_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
-TEST_CASE(trilu_lower_test)
+TEST_CASE(tril_test)
 {
-    migraphx::program p = migraphx::parse_onnx("trilu_lower_test.onnx");
+    migraphx::program p = migraphx::parse_onnx("tril_test.onnx");
+
+    std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
+
+    std::vector<float> gold = {1, 0, 0, 0, 5, 6, 0, 0, 9, 10, 11, 0};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(tril_batch_diff_k_test)
+{
+    migraphx::program p = migraphx::parse_onnx("tril_batch_diff_k_test.onnx");
+
+    std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {2, 2, 3}}, p);
+
+    std::vector<float> gold = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(triu_neg_k_test)
+{
+    migraphx::program p = migraphx::parse_onnx("triu_neg_k_test.onnx");
+
+    std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
+
+    std::vector<float> gold = {1, 2, 3, 4, 5, 6, 7, 8, 0, 10, 11, 12};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(tril_neg_k_test)
+{
+    migraphx::program p = migraphx::parse_onnx("tril_neg_k_test.onnx");
 
     std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
 
@@ -1952,9 +2300,9 @@ TEST_CASE(trilu_lower_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
-TEST_CASE(trilu_out_k_test)
+TEST_CASE(triu_out_k_test)
 {
-    migraphx::program p = migraphx::parse_onnx("trilu_out_k_test.onnx");
+    migraphx::program p = migraphx::parse_onnx("triu_out_k_test.onnx");
 
     std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
 
@@ -1963,9 +2311,20 @@ TEST_CASE(trilu_out_k_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
-TEST_CASE(trilu_row_one_test)
+TEST_CASE(tril_out_k_test)
 {
-    migraphx::program p = migraphx::parse_onnx("trilu_row_one_test.onnx");
+    migraphx::program p = migraphx::parse_onnx("tril_out_k_test.onnx");
+
+    std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {3, 4}}, p);
+
+    std::vector<float> gold = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(triu_row_one_test)
+{
+    migraphx::program p = migraphx::parse_onnx("triu_row_one_test.onnx");
 
     std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {1, 4}}, p);
 
@@ -1974,4 +2333,15 @@ TEST_CASE(trilu_row_one_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(tril_row_one_test)
+{
+    migraphx::program p = migraphx::parse_onnx("tril_row_one_test.onnx");
+
+    std::vector<float> result_vector = gen_trilu_test({migraphx::shape::float_type, {1, 4}}, p);
+
+    std::vector<float> gold = {1, 2, 0, 0};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/op_shape_test.cpp

@@ -2684,7 +2684,7 @@ TEST_CASE(reshape_broadcast_squeeze_memlayout_change)
     expect_shape(output, migraphx::make_op("reshape", {{"dims", output.lens()}}), input);
 }
 
-TEST_CASE(reshape_dyn_shape)
+TEST_CASE(reshape_dyn_1in)
 {
     migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
     for(auto&& new_shape : std::vector<std::vector<int64_t>>{
@@ -2708,6 +2708,27 @@ TEST_CASE(reshape_dyn_shape)
     }
 }
 
+TEST_CASE(reshape_dyn_2in_0)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    migraphx::shape output{migraphx::shape::float_type, {{1, 4}, {8, 8}, {3, 3}, {1, 1}}};
+    expect_shape(output, migraphx::make_op("reshape"), input, output);
+}
+
+TEST_CASE(reshape_dyn_2in_1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    migraphx::shape output{migraphx::shape::float_type, {{12, 12}, {2, 2}, {1, 1}, {1, 4}}};
+    expect_shape(output, migraphx::make_op("reshape"), input, output);
+}
+
+TEST_CASE(reshape_dyn_2in_2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape output{migraphx::shape::float_type, {{1, 2}, {6, 12}, {1, 1}, {4, 4}}};
+    expect_shape(output, migraphx::make_op("reshape"), input, output);
+}
+
 TEST_CASE(reshape_multiple_non_fixed_error)
 {
     migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {10, 20}, {1, 1}}};

test/py/onnx_backend_test.py

@@ -66,16 +66,6 @@ class MIGraphXBackendTest(onnx.backend.test.BackendTest):
 def disabled_tests_onnx_1_7_0(backend_test):
     # fails
     # from OnnxBackendNodeModelTest
-    backend_test.exclude(r'test_argmax_keepdims_example_select_last_index_cpu')
-    backend_test.exclude(
-        r'test_argmax_negative_axis_keepdims_example_select_last_index_cpu')
-    backend_test.exclude(
-        r'test_argmax_no_keepdims_example_select_last_index_cpu')
-    backend_test.exclude(r'test_argmin_keepdims_example_select_last_index_cpu')
-    backend_test.exclude(
-        r'test_argmin_negative_axis_keepdims_example_select_last_index_cpu')
-    backend_test.exclude(
-        r'test_argmin_no_keepdims_example_select_last_index_cpu')
     backend_test.exclude(r'test_logsoftmax_axis_0_cpu')
     backend_test.exclude(r'test_logsoftmax_axis_1_cpu')
     backend_test.exclude(r'test_logsoftmax_default_axis_cpu')
@@ -154,7 +144,6 @@ def disabled_tests_onnx_1_7_0(backend_test):
     backend_test.exclude(r'test_maxunpool_export_without_output_shape_cpu')
     backend_test.exclude(r'test_mod_mixed_sign_int32_cpu')
     backend_test.exclude(r'test_mod_mixed_sign_int8_cpu')
-    backend_test.exclude(r'test_mvn_cpu')
     backend_test.exclude(
         r'test_negative_log_likelihood_loss_iinput_shape_is_NCd1_weight_ignore_index_cpu'
     )
@@ -249,8 +238,6 @@ def disabled_tests_onnx_1_7_0(backend_test):
     backend_test.exclude(r'test_reversesequence_time_cpu')
     backend_test.exclude(r'test_scan9_sum_cpu')
     backend_test.exclude(r'test_scan_sum_cpu')
-    backend_test.exclude(r'test_shrink_hard_cpu')
-    backend_test.exclude(r'test_shrink_soft_cpu')
     backend_test.exclude(r'test_slice_cpu')
     backend_test.exclude(r'test_slice_default_axes_cpu')
     backend_test.exclude(r'test_slice_default_steps_cpu')
@@ -463,7 +450,6 @@ def disabled_tests_onnx_1_7_0(backend_test):
     backend_test.exclude(r'test_sequence_model6_cpu')
     backend_test.exclude(r'test_sequence_model7_cpu')
     backend_test.exclude(r'test_sequence_model8_cpu')
-    backend_test.exclude(r'test_shrink_cpu')
     backend_test.exclude(r'test_strnorm_model_monday_casesensintive_lower_cpu')
     backend_test.exclude(
         r'test_strnorm_model_monday_casesensintive_nochangecase_cpu')
@@ -594,9 +580,6 @@ def disabled_tests_onnx_1_9_0(backend_test):
     backend_test.exclude(r'test_gru_batchwise_cpu')
     backend_test.exclude(r'test_lstm_batchwise_cpu')
     backend_test.exclude(r'test_simple_rnn_batchwise_cpu')
-    backend_test.exclude(r'test_tril_cpu')
-    backend_test.exclude(r'test_tril_one_row_neg_cpu')
-    backend_test.exclude(r'test_tril_square_cpu')
     # from OnnxBackendPyTorchConvertedModelTest
     backend_test.exclude(r'test_MaxPool1d_stride_padding_dilation_cpu')
     backend_test.exclude(r'test_MaxPool2d_stride_padding_dilation_cpu')
@@ -806,7 +789,6 @@ def disabled_tests_onnx_1_13_0(backend_test):
     backend_test.exclude(r'test_group_normalization_example_cpu')
     backend_test.exclude(r'test_group_normalization_example_expanded_cpu')
     backend_test.exclude(r'test_mish_cpu')
-    backend_test.exclude(r'test_mvn_expanded_ver18_cpu')
     backend_test.exclude(r'test_optional_get_element_optional_sequence_cpu')
     backend_test.exclude(r'test_optional_get_element_optional_tensor_cpu')
     backend_test.exclude(r'test_optional_get_element_tensor_cpu')

test/ref/argmax.cpp

@@ -147,3 +147,37 @@ TEST_CASE(argmax_test_nonstd_shape)
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }
+
+TEST_CASE(argmax_test_select_last_index_0)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {2.0305, -1.853, 2.0305, -1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {2, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmax", {{"axis", 1}, {"select_last_index", true}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}
+
+TEST_CASE(argmax_test_select_last_index_1)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {2.0305, -1.853, 2.0305, -1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {0, 1};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmax", {{"axis", 1}, {"select_last_index", false}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}

test/ref/argmin.cpp

@@ -125,3 +125,37 @@ TEST_CASE(argmin_test_nonstd_shape)
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }
+
+TEST_CASE(argmin_test_select_last_index_0)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {-2.0305, 0.853, -2.0305, 1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {2, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmin", {{"axis", 1}, {"select_last_index", true}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}
+
+TEST_CASE(argmin_test_select_last_index_1)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {-2.0305, 0.853, -2.0305, 1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {0, 1};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmin", {{"axis", 1}, {"select_last_index", false}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}

test/ref/reshape.cpp

@@ -153,7 +153,7 @@ TEST_CASE(reshape_test2)
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
-TEST_CASE(reshape_dyn_test)
+TEST_CASE(reshape_dyn_1in_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -173,3 +173,79 @@ TEST_CASE(reshape_dyn_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
+
+TEST_CASE(reshape_2in_test0)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{1, 4}, {6, 6}, {4, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 4, 1}};
+    params["X"] = migraphx::argument(input_fixed_shape, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    auto result = p.eval(params).back();
+    EXPECT(result.get_shape() == output_fixed_shape);
+    std::vector<float> results_vector{};
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(reshape_2in_test1)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{2, 4}, {6, 6}, {2, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 4, 1}};
+    params["X"] = migraphx::argument(s_in, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    auto result = p.eval(params).back();
+    EXPECT(result.get_shape() == output_fixed_shape);
+    std::vector<float> results_vector{};
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(reshape_2in_elements_runtime_error)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{2, 4}, {6, 6}, {2, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    // elements do not match up
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 2, 1}};
+    params["X"] = migraphx::argument(s_in, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    EXPECT(test::throws([&] { std::ignore = p.eval(params).back(); }));
+}

test/replace_allocate.cpp

@@ -54,7 +54,7 @@ struct allocate_no_out : migraphx::auto_register_op<allocate_no_out>
                                const migraphx::shape& output_shape,
                                const std::vector<migraphx::argument>&) const
     {
-        return {output_shape};
+        return migraphx::argument{output_shape};
     }
 };
 
@@ -78,7 +78,7 @@ struct allocate_with_out : migraphx::auto_register_op<allocate_with_out>
                                const migraphx::shape& output_shape,
                                const std::vector<migraphx::argument>&) const
     {
-        return {output_shape};
+        return migraphx::argument{output_shape};
     }
 };
 

test/rewrite_quantization_test.cpp

@@ -31,10 +31,13 @@
 #include <migraphx/ranges.hpp>
 #include <test.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/env.hpp>
 
 #include <migraphx/serialize.hpp>
 #include <migraphx/pass_manager.hpp>
 
+MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_ENABLE_CK_WORKAROUNDS);
+
 bool is_quantizelinear(migraphx::instruction& ins) { return ins.name() == "quantizelinear"; }
 bool is_dequantizelinear(migraphx::instruction& ins) { return ins.name() == "dequantizelinear"; }
 bool is_clip_scalar(migraphx::instruction& ins)
@@ -82,6 +85,10 @@ TEST_CASE(quantizelinear)
     EXPECT(any_of(*p1.get_main_module(), &is_quantizelinear));
     EXPECT(none_of(*p2.get_main_module(), &is_quantizelinear));
     // ensure clip literals created in quantized program are scalar
+    // unless CK workarounds are enabled
+    if(migraphx::enabled(MIGRAPHX_ENABLE_CK_WORKAROUNDS{}))
+        EXPECT(none_of(*p2.get_main_module(), &is_clip_scalar));
+    else
         EXPECT(any_of(*p2.get_main_module(), &is_clip_scalar));
 }
 

test/verify/test_arg_ops.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,8 +29,8 @@
 #include <migraphx/op/argmax.hpp>
 #include <migraphx/op/argmin.hpp>
 
-template <class T, int Axis, int NonStdShape>
-struct test_arg_ops : verify_program<test_arg_ops<T, Axis, NonStdShape>>
+template <class T, int Axis, bool LastIndex, int NonStdShape>
+struct test_arg_ops : verify_program<test_arg_ops<T, Axis, LastIndex, NonStdShape>>
 {
     migraphx::program create_program() const
     {
@@ -54,63 +54,111 @@ struct test_arg_ops : verify_program<test_arg_ops<T, Axis, NonStdShape>>
             break;
         default: break;
         }
-        mm->add_instruction(T{Axis}, param);
+        mm->add_instruction(T{Axis, LastIndex}, param);
         return p;
     }
 };
 // transpose argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 0>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 0>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 0>;
 // transpose argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 0>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 0>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 0>;
 // broadcast argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 1>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 1>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 1>;
 // broadcast argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 1>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 1>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 1>;
 // slice argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 2>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 2>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 2>;
 // slice argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 2>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 2>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 2>;
 // default case, standard shape argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 3>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 3>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 3>;
 // default case, standard shape argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 3>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 3>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 3>;

test/verify/test_shrink.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/op/common.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/common.hpp>
+
+template <migraphx::shape::type_t T>
+struct test_shrink : verify_program<test_shrink<T>>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        float bias  = 1.5;
+        float lambd = 1.5;
+        auto* mm    = p.get_main_module();
+        migraphx::shape is{T, {2, 3}};
+        std::vector<float> data;
+        migraphx::shape::visit(T, [&](auto as) {
+            as.is_signed() ? data.assign({-3.0, -2.0, -1.0, 0.0, 1.0, 2.0})
+                           : data.assign({3.0, 2.0, 1.0, 0.0, 1.0, 2.0});
+        });
+        auto x        = mm->add_literal(migraphx::literal{is, data});
+        auto lit_bias = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {bias}});
+        auto lit_neg_lambd =
+            mm->add_literal(migraphx::literal{migraphx::shape::float_type, {-lambd}});
+        auto lit_lambd = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {lambd}});
+
+        auto x_plus_bias = add_common_op(*mm, migraphx::make_op("add"), {x, lit_bias});
+        auto x_min_bias  = add_common_op(*mm, migraphx::make_op("sub"), {x, lit_bias});
+
+        auto cond1   = add_common_op(*mm, migraphx::make_op("less"), {x, lit_neg_lambd});
+        auto cond2_a = add_common_op(*mm, migraphx::make_op("not"), {cond1});
+        auto cond2_b = add_common_op(*mm, migraphx::make_op("greater"), {x, lit_lambd});
+        auto cond2   = add_common_op(*mm, migraphx::make_op("logical_and"), {cond2_a, cond2_b});
+
+        auto mul1 = mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), cond1);
+        auto mul2 = mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), cond2);
+
+        auto first  = add_common_op(*mm, migraphx::make_op("mul"), {mul1, x_plus_bias});
+        auto second = add_common_op(*mm, migraphx::make_op("mul"), {mul2, x_min_bias});
+        auto ret    = add_common_op(*mm, migraphx::make_op("add"), {first, second});
+        if(ret->get_shape().type() != T)
+        {
+            mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), ret);
+        }
+        return p;
+    }
+};
+
+template struct test_shrink<migraphx::shape::double_type>;
+template struct test_shrink<migraphx::shape::float_type>;
+template struct test_shrink<migraphx::shape::half_type>;
+template struct test_shrink<migraphx::shape::int64_type>;
+template struct test_shrink<migraphx::shape::int32_type>;
+template struct test_shrink<migraphx::shape::int16_type>;
+template struct test_shrink<migraphx::shape::int8_type>;
+template struct test_shrink<migraphx::shape::uint64_type>;
+template struct test_shrink<migraphx::shape::uint32_type>;
+template struct test_shrink<migraphx::shape::uint16_type>;
+template struct test_shrink<migraphx::shape::uint8_type>;

tools/accuracy/accuracy_checker.py

@@ -220,9 +220,15 @@ def main():
         else:
             test_input = np.zeros(in_shape).astype(get_np_datatype(in_type))
         test_inputs[name] = test_input
-        params[name] = migraphx.argument(test_input)
+        migraphx_arg = migraphx.argument(test_input)
+        if not args.offload_copy:
+            migraphx_arg = migraphx.to_gpu(migraphx_arg)
+        params[name] = migraphx_arg
 
     if not args.ort_run:
+        if not args.offload_copy:
+            pred_migx = np.array(migraphx.from_gpu(model.run(params)[-1]))
+        else:
             pred_migx = np.array(model.run(params)[-1])
 
     if use_onnx:

tools/accuracy/requirements.txt

@@ -22,4 +22,4 @@
 # THE SOFTWARE.
 #####################################################################################
 numpy==1.21.6
-onnxruntime==1.10.0
+onnxruntime==1.16.1

tools/build_and_test_onnxrt.sh

@@ -40,4 +40,4 @@ echo 'InferenceSessionTests.CheckRunProfilerWithSessionOptions' >> ../../../tool
 echo 'InferenceSessionTests.CheckRunProfilerWithSessionOptions2' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
 echo 'InferenceSessionTests.Test3LayerNestedSubgraph' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
 echo 'InferenceSessionTests.Test2LayerNestedSubgraph' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
-../../../tools/ci_build/github/pai/migraphx_test_launcher.sh || (gdb ./onnxruntime_test_all core -batch -ex bt && exit 1)
+../../../tools/ci_build/github/pai/pai_test_launcher.sh || (gdb ./onnxruntime_test_all core -batch -ex bt && exit 1)