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

test/onnx/round_half_test.onnx

+	round_half_test:J
+
+
x
y"Roundround_half_testZ
+
x
+
+
+
+b
+
y
+
+
+
+B
\ No newline at end of file

test/onnx/split_test_invalid_num_outputs.onnx

+	split_test_invalid_num_outputs:

+.
+
xy1y2y3y4"Split*
+num_outputs
split_test_invalid_num_outputsZ
+
x
+

+
+b
+y1
+

+
+b
+y2
+

+
+b
+y3
+

+
+b
+y4
+

+
+B
\ No newline at end of file

test/onnx/split_test_uneven_num_outputs.onnx

+	split_test_uneven_num_outputs:

+.
+
xy1y2y3y4"Split*
+num_outputs
split_test_uneven_num_outputsZ
+
x
+

+
+b
+y1
+

+
+b
+y2
+

+
+b
+y3
+

+
+b
+y4
+

+
+B
\ No newline at end of file

test/onnx/verify_onnx.cpp

@@ -1014,6 +1014,95 @@ TEST_CASE(instance_norm_3d_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(isinf_half_test)
+{
+    migraphx::program p = migraphx::parse_onnx("isinf_half_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::half_type, {2, 3}};
+    migraphx::parameter_map pp;
+    migraphx::half nan               = std::numeric_limits<migraphx::half>::quiet_NaN();
+    migraphx::half infinity          = std::numeric_limits<migraphx::half>::infinity();
+    migraphx::half max               = std::numeric_limits<migraphx::half>::max();
+    migraphx::half min               = std::numeric_limits<migraphx::half>::min();
+    migraphx::half val               = migraphx::half(3.6);
+    std::vector<migraphx::half> data = {-infinity, nan, min, val, max, infinity};
+    pp["t1"]                         = 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 = {1, 0, 0, 0, 0, 1};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(isinf_neg_test)
+{
+    migraphx::program p = migraphx::parse_onnx("isinf_neg_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
+    migraphx::parameter_map pp;
+    float nan               = std::numeric_limits<float>::quiet_NaN();
+    float infinity          = std::numeric_limits<float>::infinity();
+    float max               = std::numeric_limits<float>::max();
+    float min               = std::numeric_limits<float>::min();
+    std::vector<float> data = {-infinity, nan, min, 3.6, max, infinity};
+    pp["t1"]                = 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 = {1, 0, 0, 0, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(isinf_double_pos_test)
+{
+    migraphx::program p = migraphx::parse_onnx("isinf_double_pos_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::double_type, {2, 3}};
+    migraphx::parameter_map pp;
+    double nan               = std::numeric_limits<double>::quiet_NaN();
+    double infinity          = std::numeric_limits<double>::infinity();
+    double max               = std::numeric_limits<double>::max();
+    double min               = std::numeric_limits<double>::min();
+    std::vector<double> data = {-infinity, nan, min, 3.6, max, infinity};
+    pp["t1"]                 = 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, 0, 0, 0, 0, 1};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(isinf_no_detect_test)
+{
+    migraphx::program p = migraphx::parse_onnx("isinf_no_detect_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
+    migraphx::parameter_map pp;
+    float nan                = std::numeric_limits<float>::quiet_NaN();
+    float infinity           = std::numeric_limits<float>::infinity();
+    float max                = std::numeric_limits<float>::max();
+    float min                = std::numeric_limits<float>::min();
+    std::vector<double> data = {-infinity, nan, min, 3.6, max, infinity};
+    pp["t1"]                 = 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, 0, 0, 0, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(layer_norm_test)
 {
     std::vector<float> scale{1.2, 0.8};
@@ -1434,6 +1523,77 @@ TEST_CASE(mod_test_fmod_different_types)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(multinomial_dyn_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4};
+    auto p                        = migraphx::parse_onnx("multinomial_dyn_test.onnx", options);
+    const size_t batch_size(2);
+    const size_t categories(5);
+    const size_t sample_size(100000);
+    p.compile(migraphx::make_target("ref"));
+
+    // Distribution function (2 distributions of 5 categories each)
+    std::vector<int> dist{15, 25, 15, 25, 20, 20, 20, 10, 25, 25};
+    EXPECT(dist.size() == categories * batch_size);
+    std::vector<float> data(categories * batch_size);
+
+    std::transform(dist.begin(), dist.end(), data.begin(), [&](auto d) { return log(d); });
+    // Shape of the probability distribution, which also defines the number of categories
+    migraphx::shape s{migraphx::shape::float_type, {batch_size, categories}};
+
+    migraphx::parameter_map pp;
+    pp["input"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+
+    std::vector<int32_t> result_vec(batch_size * sample_size);
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+
+    // Make a categorical histogram of output
+    // for first result in batch
+    std::vector<int> res_dist(categories, 0);
+    size_t r = 0;
+    for(r = 0; r < result_vec.size() / 2; r++)
+        res_dist[result_vec[r]]++;
+
+    // normalizing factors for original and measured distributions
+    auto dist_sum     = std::accumulate(dist.begin(), dist.begin() + 5, 0);
+    auto res_dist_sum = std::accumulate(res_dist.begin(), res_dist.end(), 0);
+
+    //  Values approximate the distribution in dist
+    std::vector<float> norm(5);
+    std::vector<float> res_norm(5);
+
+    std::transform(dist.begin(), dist.begin() + 5, norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist.begin(), res_dist.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        norm, migraphx::verify::expected{res_norm}, migraphx::verify::tolerance{0.01}));
+
+    // Make a categorical histogram of output
+    // for second result in batch
+    std::fill(res_dist.begin(), res_dist.end(), 0);
+    for(; r < result_vec.size(); r++)
+        res_dist[result_vec[r]]++;
+
+    dist_sum     = std::accumulate(dist.begin() + 5, dist.end(), 0);
+    res_dist_sum = std::accumulate(res_dist.begin(), res_dist.end(), 0);
+    std::transform(dist.begin() + 5, dist.end(), norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist.begin(), res_dist.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
+}
+
 TEST_CASE(nonzero_test)
 {
     migraphx::program p = migraphx::parse_onnx("nonzero_dynamic_test.onnx");
@@ -1735,6 +1895,81 @@ TEST_CASE(qlinearmatmul_3D_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(qlinearmul_test)
+{
+    // github.com/microsoft/onnxruntime/blob/main/docs/ContribOperators.md#com.microsoft.QLinearMul
+    migraphx::program p = migraphx::parse_onnx("qlinearmul_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape a{migraphx::shape::uint8_type, {64}};
+    std::vector<uint8_t> data_a = {0,   2,   4,   6,   8,   10,  12,  14,  16,  18,  20,  22,  24,
+                                   26,  28,  30,  32,  34,  36,  38,  40,  42,  44,  46,  48,  50,
+                                   52,  54,  56,  58,  60,  62,  64,  66,  68,  70,  72,  74,  76,
+                                   78,  80,  82,  84,  86,  88,  90,  92,  94,  96,  98,  100, 102,
+                                   104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126};
+
+    migraphx::shape b{migraphx::shape::uint8_type, {64}};
+    std::vector<uint8_t> data_b = {128, 126, 124, 122, 120, 118, 116, 114, 112, 110, 108, 106, 104,
+                                   102, 100, 98,  96,  94,  92,  90,  88,  86,  84,  82,  80,  78,
+                                   76,  74,  72,  70,  68,  66,  64,  62,  60,  58,  56,  54,  52,
+                                   50,  48,  46,  44,  42,  40,  38,  36,  34,  32,  30,  28,  26,
+                                   24,  22,  20,  18,  16,  14,  12,  10,  8,   6,   4,   2};
+
+    migraphx::parameter_map pp;
+    pp["A"]     = migraphx::argument(a, data_a.data());
+    pp["B"]     = migraphx::argument(b, data_b.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 = {100, 111, 122, 132, 142, 151, 160, 169, 177, 185, 192, 199, 206,
+                                 212, 218, 223, 228, 233, 237, 241, 244, 247, 250, 252, 254, 255,
+                                 255, 255, 255, 255, 255, 255, 254, 252, 250, 247, 244, 241, 237,
+                                 233, 228, 223, 218, 212, 206, 199, 192, 185, 177, 169, 160, 151,
+                                 142, 132, 122, 111, 100, 89,  77,  65,  52,  39,  26,  12};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(qlinearmul_bcast_test)
+{
+    // github.com/microsoft/onnxruntime/blob/main/docs/ContribOperators.md#com.microsoft.QLinearMul
+    migraphx::program p = migraphx::parse_onnx("qlinearmul_bcast_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape a{migraphx::shape::int8_type, {64}};
+    std::vector<int8_t> data_a = {-64, -62, -60, -58, -56, -54, -52, -50, -48, -46, -44, -42, -40,
+                                  -38, -36, -34, -32, -30, -28, -26, -24, -22, -20, -18, -16, -14,
+                                  -12, -10, -8,  -6,  -4,  -2,  0,   2,   4,   6,   8,   10,  12,
+                                  14,  16,  18,  20,  22,  24,  26,  28,  30,  32,  34,  36,  38,
+                                  40,  42,  44,  46,  48,  50,  52,  54,  56,  58,  60,  62};
+
+    migraphx::shape b{migraphx::shape::int8_type, {1, 1, 64}};
+    std::vector<int8_t> data_b = {96, 94,  92,  90,  88,  86,  84,  82,  80,  78,  76,  74, 72,
+                                  70, 68,  66,  64,  62,  60,  58,  56,  54,  52,  50,  48, 46,
+                                  44, 42,  40,  38,  36,  34,  32,  30,  28,  26,  24,  22, 20,
+                                  18, 16,  14,  12,  10,  8,   6,   4,   2,   0,   -2,  -4, -6,
+                                  -8, -10, -12, -14, -16, -18, -20, -22, -24, -26, -28, -30};
+
+    migraphx::parameter_map pp;
+    pp["A"]     = migraphx::argument(a, data_a.data());
+    pp["B"]     = migraphx::argument(b, data_b.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 = {-128, -128, -128, -128, -128, -128, -128, -128, -128, -126, -118,
+                                -109, -101, -93,  -86,  -78,  -70,  -63,  -56,  -49,  -42,  -35,
+                                -28,  -21,  -15,  -9,   -2,   4,    10,   15,   21,   27,   32,
+                                37,   42,   47,   52,   57,   62,   66,   70,   75,   79,   83,
+                                86,   90,   94,   97,   100,  103,  106,  109,  112,  115,  117,
+                                119,  122,  124,  126,  127,  127,  127,  127,  127};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(resize_downsample_f_test)
 {
     migraphx::program p = migraphx::parse_onnx("resize_downsample_f_test.onnx");
@@ -1896,6 +2131,43 @@ TEST_CASE(reversesequence_time_verify_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(round_half_test)
+{
+    migraphx::program p = migraphx::parse_onnx("round_half_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape xs{migraphx::shape::half_type, {4, 4}};
+    std::vector<float> tmp = {-3.51,
+                              -3.5,
+                              -3.49,
+                              -2.51,
+                              -2.50,
+                              -2.49,
+                              -1.6,
+                              -1.5,
+                              -0.51,
+                              -0.5,
+                              0.5,
+                              0.6,
+                              2.4,
+                              2.5,
+                              3.5,
+                              4.5};
+    std::vector<migraphx::half> data{tmp.cbegin(), tmp.cend()};
+    migraphx::parameter_map param_map;
+    param_map["x"] = migraphx::argument(xs, data.data());
+
+    auto result = p.eval(param_map).back();
+
+    std::vector<migraphx::half> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    tmp = {-4.0, -4.0, -3.0, -3.0, -2.0, -2.0, -2.0, -2.0, -1.0, 0.0, 0.0, 1.0, 2.0, 2.0, 4.0, 4.0};
+    std::vector<migraphx::half> gold{tmp.cbegin(), tmp.cend()};
+
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 TEST_CASE(selu_test)
 {
     migraphx::program p = migraphx::parse_onnx("selu_test.onnx");

test/op_shape_test.cpp

@@ -1957,12 +1957,42 @@ TEST_CASE(multibroadcast_3in_dyn_dyn)
     expect_shape(expected_shape, migraphx::make_op("multibroadcast"), c_shape, a_shape, b_shape);
 }
 
-TEST_CASE(multinomial)
+TEST_CASE(multinomial_bool_type)
 {
-    migraphx::shape s{migraphx::shape::float_type, {2, 5}};
+    migraphx::shape s1{migraphx::shape::float_type, {1, 2}};
+    migraphx::shape s2{migraphx::shape::float_type, {3, 4}};
     int dtype = 0;
 
-    throws_shape(migraphx::make_op("multinomial", {{"dtype", dtype}}), s, s);
+    throws_shape(migraphx::make_op("multinomial", {{"dtype", dtype}}), s1, s2);
+}
+
+TEST_CASE(multinomial)
+{
+    migraphx::shape s1{migraphx::shape::float_type, {1, 2}};
+    migraphx::shape s2{migraphx::shape::float_type, {3, 4}};
+    migraphx::shape s3{migraphx::shape::float_type, {1, 4}};
+    int dtype = 2;
+
+    expect_shape(s3, migraphx::make_op("multinomial", {{"dtype", dtype}}), s1, s2);
+}
+
+TEST_CASE(multinomial_0size_input)
+{
+    migraphx::shape s1{migraphx::shape::float_type, {1, 2}};
+    migraphx::shape s2{migraphx::shape::float_type, {}};
+    int dtype = 2;
+
+    throws_shape(migraphx::make_op("multinomial", {{"dtype", dtype}}), s1, s2);
+}
+
+TEST_CASE(multinomial_dyn)
+{
+    migraphx::shape s1{migraphx::shape::int32_type, {{2, 3}, {5, 6}}};
+    migraphx::shape s2{migraphx::shape::int32_type, {{7, 8}, {9, 10}}};
+    migraphx::shape s3{migraphx::shape::int32_type, {{2, 3}, {9, 10}}};
+
+    expect_shape(
+        s3, migraphx::make_op("multinomial", {{"dtype", migraphx::shape::int32_type}}), s1, s2);
 }
 
 TEST_CASE(nms_shape)
@@ -3202,7 +3232,65 @@ TEST_CASE(slice_static_shape)
 }
 
 TEST_CASE(slice_var_inputs_static_shape0)
+{
+    // attr ends and axes set; inputs are (data, input_starts)
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 3}, {0, 4}, {0, 4}}},
+                 migraphx::make_op("slice", {{"ends", {2, 3}}, {"axes", {1, 2}}}),
+                 input,
+                 starts);
+}
+
+TEST_CASE(slice_var_inputs_static_mismatch_error0)
 {
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"ends", {2, 3, 4}}, {"axes", {0, 1, 2}}}), input, starts);
+}
+
+TEST_CASE(slice_var_inputs_static_shape1)
+{
+    // attr starts and axes set; inputs are (data, input_ends)
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 3}, {0, 4}, {0, 4}}},
+                 migraphx::make_op("slice", {{"starts", {0, 1}}, {"axes", {1, 2}}}),
+                 input,
+                 ends);
+}
+
+TEST_CASE(slice_var_inputs_static_mismatch_error1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"starts", {0, 1, 2}}, {"axes", {0, 1, 2}}}), input, ends);
+}
+
+TEST_CASE(slice_var_inputs_static_shape2)
+{
+    // attr starts and ends set; inputs are (data, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 3}, {0, 4}, {0, 4}}},
+                 migraphx::make_op("slice", {{"starts", {0, 1}}, {"ends", {1, 2}}}),
+                 input,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_static_mismatch_error2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"starts", {0, 1, 2}}, {"ends", {3, 4, 4}}}), input, axes);
+}
+
+TEST_CASE(slice_var_inputs_static_shape3)
+{
+    // attr axes set; inputs are (data, input_starts, input_ends)
     migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
     migraphx::shape starts{migraphx::shape::int64_type, {2}};
     migraphx::shape ends{migraphx::shape::int64_type, {2}};
@@ -3213,7 +3301,57 @@ TEST_CASE(slice_var_inputs_static_shape0)
                  ends);
 }
 
-TEST_CASE(slice_var_inputs_static_shape1)
+TEST_CASE(slice_var_inputs_static_mismatch_error3)
+{
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"axes", {0, 1, 2}}}), input, starts, ends);
+}
+
+TEST_CASE(slice_var_inputs_static_shape4)
+{
+    // attr ends set; inputs are (data, input_starts, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 3}, {0, 4}, {0, 4}}},
+                 migraphx::make_op("slice", {{"ends", {3, 4}}}),
+                 input,
+                 starts,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_static_mismatch_error4)
+{
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"ends", {3, 3, 3}}}), input, starts, axes);
+}
+
+TEST_CASE(slice_var_inputs_static_shape5)
+{
+    // attr starts set; inputs are (data, input_ends, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 3}, {0, 4}, {0, 4}}},
+                 migraphx::make_op("slice", {{"starts", {0, 2}}}),
+                 input,
+                 ends,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_static_mismatch_error5)
+{
+    migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"starts", {0, 1, 2}}}), input, ends, axes);
+}
+
+TEST_CASE(slice_var_inputs_static_shape6)
 {
     migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
     migraphx::shape starts{migraphx::shape::int64_type, {2}};
@@ -3227,7 +3365,7 @@ TEST_CASE(slice_var_inputs_static_shape1)
                  axes);
 }
 
-TEST_CASE(slice_var_inputs_static_error0)
+TEST_CASE(slice_var_inputs_static_mismatch_error6)
 {
     migraphx::shape input{migraphx::shape::float_type, {3, 4, 4}};
     migraphx::shape starts{migraphx::shape::int64_type, {2}};
@@ -3238,17 +3376,125 @@ TEST_CASE(slice_var_inputs_static_error0)
 
 TEST_CASE(slice_var_inputs_dyn_shape0)
 {
-    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {2, 4, {2, 4}}, {2, 4, {2, 4}}}};
+    // attr ends and axes set; inputs are (data, input_starts)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 6}, {0, 6}, {0, 6}}},
+                 migraphx::make_op("slice", {{"ends", {2, 3}}, {"axes", {1, 2}}}),
+                 input,
+                 starts);
+}
+
+TEST_CASE(slice_var_inputs_dyn_mismatch_error0)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"ends", {2, 3, 4}}, {"axes", {0, 1, 2}}}), input, starts);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape1)
+{
+    // attr starts and axes set; inputs are (data, input_ends)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 6}, {0, 6}, {0, 6}}},
+                 migraphx::make_op("slice", {{"starts", {0, 1}}, {"axes", {1, 2}}}),
+                 input,
+                 ends);
+}
+
+TEST_CASE(slice_var_inputs_dyn_mismatch_error1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"starts", {0, 1, 2}}, {"axes", {0, 1, 2}}}), input, ends);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape2)
+{
+    // attr starts and ends set; inputs are (data, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 6}, {0, 6}, {0, 6}}},
+                 migraphx::make_op("slice", {{"starts", {0, 1}}, {"ends", {8, 8}}}),
+                 input,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_mismatch_error2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(
+        migraphx::make_op("slice", {{"starts", {0, 1, 2}}, {"ends", {3, 4, 4}}}), input, axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape3)
+{
+    // attr axes set; inputs are (data, input_starts, input_ends)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
     migraphx::shape starts{migraphx::shape::int64_type, {2}};
     migraphx::shape ends{migraphx::shape::int64_type, {2}};
-    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 6}, {0, 4}, {0, 4}}},
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{3, 6}, {0, 6}, {0, 6}}},
                  migraphx::make_op("slice", {{"axes", {1, 2}}}),
                  input,
                  starts,
                  ends);
 }
 
-TEST_CASE(slice_var_inputs_dyn_shape1)
+TEST_CASE(slice_var_inputs_dyn_mismatch_error3)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"axes", {0, 1, 2}}}), input, starts, ends);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape4)
+{
+    // attr ends set; inputs are (data, input_starts, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 6}, {0, 6}, {0, 6}}},
+                 migraphx::make_op("slice", {{"ends", {3, 4}}}),
+                 input,
+                 starts,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_mismatch_error4)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"ends", {3, 3, 3}}}), input, starts, axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape5)
+{
+    // attr starts set; inputs are (data, input_ends, input_axes)
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    expect_shape(migraphx::shape{migraphx::shape::float_type, {{0, 6}, {0, 6}, {0, 6}}},
+                 migraphx::make_op("slice", {{"starts", {0, 2}}}),
+                 input,
+                 ends,
+                 axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_mismatch_error5)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {2}};
+    throws_shape(migraphx::make_op("slice", {{"starts", {0, 1, 2}}}), input, ends, axes);
+}
+
+TEST_CASE(slice_var_inputs_dyn_shape6)
 {
     migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {2, 4, {2, 4}}, {2, 4, {2, 4}}}};
     migraphx::shape starts{migraphx::shape::int64_type, {2}};
@@ -3262,6 +3508,15 @@ TEST_CASE(slice_var_inputs_dyn_shape1)
                  axes);
 }
 
+TEST_CASE(slice_var_inputs_dyn_mismatch_error6)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{3, 6}, {4, 6}, {4, 6}}};
+    migraphx::shape starts{migraphx::shape::int64_type, {2}};
+    migraphx::shape ends{migraphx::shape::int64_type, {2}};
+    migraphx::shape axes{migraphx::shape::int64_type, {3}};
+    throws_shape(migraphx::make_op("slice"), input, starts, ends, axes);
+}
+
 TEST_CASE(slice_dyn_shape0)
 {
     migraphx::shape input{migraphx::shape::int32_type, {{2, 3}, {7, 7}, {2, 3}}};

test/py/CMakeLists.txt

@@ -45,9 +45,17 @@ function(add_py_venv_fixture FIXTURE_NAME VIRTUAL_ENV_DIR REQUIREMENTS_FILE)
                 add_test(NAME py_${PYTHON_VERSION}_${FIXTURE_NAME}_initialize_env COMMAND ${PYTHON_EXECUTABLE} -m venv ${VIRTUAL_ENV_DIR}/${PYTHON_VERSION} --clear)
                 set_tests_properties(py_${PYTHON_VERSION}_${FIXTURE_NAME}_initialize_env PROPERTIES FIXTURES_SETUP ${FIXTURE_NAME}_${PYTHON_VERSION}_INIT_VENV)
                 set(PYTHON_EXECUTABLE ${VIRTUAL_ENV_DIR}/${PYTHON_VERSION}/bin/python)
+                if(EXISTS ${REQUIREMENTS_FILE})
                     add_test(
                         NAME py_${PYTHON_VERSION}_${FIXTURE_NAME}_setup_env
                         COMMAND ${PYTHON_EXECUTABLE} -m pip install -r ${REQUIREMENTS_FILE})
+                else()
+                    # If there is no requirements file, then there are no packages to install in the virtual env.
+                    # Just create a placeholder test for setting up the required fixture for running the tests.
+                    add_test(
+                        NAME py_${PYTHON_VERSION}_${FIXTURE_NAME}_setup_env
+                        COMMAND ${PYTHON_EXECUTABLE} -m pip install --help)
+                endif()
                 set_tests_properties(py_${PYTHON_VERSION}_${FIXTURE_NAME}_setup_env PROPERTIES FIXTURES_REQUIRED ${FIXTURE_NAME}_${PYTHON_VERSION}_INIT_VENV)
                 set_tests_properties(py_${PYTHON_VERSION}_${FIXTURE_NAME}_setup_env PROPERTIES FIXTURES_SETUP ${FIXTURE_NAME}_${PYTHON_VERSION}_VENV)
             endif()

test/py/onnx_backend_test.py

@@ -83,7 +83,6 @@ def disabled_tests_onnx_1_7_0(backend_test):
     backend_test.exclude(r'test_nonmaxsuppression_two_batches_cpu')
     backend_test.exclude(r'test_nonmaxsuppression_two_classes_cpu')
     backend_test.exclude(r'test_nonzero_example_cpu')
-    backend_test.exclude(r'test_round_cpu')
     backend_test.exclude(r'test_softmax_axis_0_cpu')
     backend_test.exclude(r'test_softmax_axis_1_cpu')
     backend_test.exclude(r'test_softmax_default_axis_cpu')
@@ -135,9 +134,6 @@ def disabled_tests_onnx_1_7_0(backend_test):
     backend_test.exclude(r'test_hardmax_example_cpu')
     backend_test.exclude(r'test_hardmax_negative_axis_cpu')
     backend_test.exclude(r'test_hardmax_one_hot_cpu')
-    backend_test.exclude(r'test_isinf_cpu')
-    backend_test.exclude(r'test_isinf_negative_cpu')
-    backend_test.exclude(r'test_isinf_positive_cpu')
     backend_test.exclude(r'test_matmulinteger_cpu')
     backend_test.exclude(r'test_maxpool_2d_uint8_cpu')
     backend_test.exclude(r'test_maxunpool_export_with_output_shape_cpu')
@@ -578,7 +574,6 @@ def disabled_tests_onnx_1_9_0(backend_test):
     # fails
     # from OnnxBackendNodeModelTest
     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')
     # from OnnxBackendPyTorchConvertedModelTest
     backend_test.exclude(r'test_MaxPool1d_stride_padding_dilation_cpu')
@@ -835,10 +830,6 @@ def disabled_tests_onnx_1_13_0(backend_test):
     backend_test.exclude(r'test_scatter_elements_with_reduction_max_cpu')
     backend_test.exclude(r'test_scatter_elements_with_reduction_min_cpu')
 
-    # The following tests fail due to the CastLike operator being unsupported
-    backend_test.exclude(r'test_split_1d_uneven_split_opset18_cpu')
-    backend_test.exclude(r'test_split_2d_uneven_split_opset18_cpu')
-
 
 def disabled_tests_onnx_1_14_0(backend_test):
     # fails

test/py/requirements.txt

-#####################################################################################
-# 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.
-#####################################################################################
-
-numpy==1.19.5
\ No newline at end of file

test/py/test_gpu.py

@@ -22,7 +22,6 @@
 # THE SOFTWARE.
 #####################################################################################
 import migraphx
-import numpy as np
 
 
 def test_conv_relu():
@@ -51,8 +50,12 @@ def test_sub_uint64():
     params = {}
 
     shapes = p.get_parameter_shapes()
-    params["0"] = np.arange(120).reshape(shapes["0"].lens()).astype(np.uint64)
-    params["1"] = np.arange(20).reshape(shapes["1"].lens()).astype(np.uint64)
+    params["0"] = migraphx.create_argument(
+        migraphx.shape(type='uint64_type', lens=shapes["0"].lens()),
+        list(range(120)))
+    params["1"] = migraphx.create_argument(
+        migraphx.shape(type='uint64_type', lens=shapes["1"].lens()),
+        list(range(20)))
 
     r = p.run(params)
     print(r)
@@ -67,7 +70,9 @@ def test_neg_int64():
     params = {}
 
     shapes = p.get_parameter_shapes()
-    params["0"] = np.arange(6).reshape(shapes["0"].lens()).astype(np.int64)
+    params["0"] = migraphx.create_argument(
+        migraphx.shape(type='int64_type', lens=shapes["0"].lens()),
+        list(range(6)))
 
     r = p.run(params)
     print(r)
@@ -82,8 +87,9 @@ def test_nonzero():
     params = {}
 
     shapes = p.get_parameter_shapes()
-    params["data"] = np.array([1, 1, 0,
-                               1]).reshape(shapes["data"].lens()).astype(bool)
+    params["data"] = migraphx.create_argument(
+        migraphx.shape(type='bool_type', lens=shapes["data"].lens()),
+        [1, 1, 0, 1])
 
     r = p.run(params)
     print(r)
@@ -101,8 +107,8 @@ def test_fp16_imagescaler():
 
     params = {}
     shapes = p.get_parameter_shapes()
-    params["0"] = np.random.randn(768).reshape(shapes["0"].lens()).astype(
-        np.float16)
+    params["0"] = migraphx.generate_argument(
+        migraphx.shape(type='half_type', lens=shapes["0"].lens()), 768)
 
     r = p.run(params)[-1]
     print(r)
@@ -120,10 +126,12 @@ def test_if_pl():
 
     params = {}
     shapes = p.get_parameter_shapes()
-    params["x"] = np.ones(6).reshape(shapes["x"].lens()).astype(np.float32)
-    params["y"] = np.array([2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0
-                            ]).reshape(shapes["y"].lens()).astype(np.float32)
-    params["cond"] = np.array([1]).reshape(()).astype(bool)
+    params["x"] = migraphx.fill_argument(
+        migraphx.shape(type='float_type', lens=shapes["x"].lens()), 1)
+    params["y"] = migraphx.fill_argument(
+        migraphx.shape(type='float_type', lens=shapes["y"].lens()), 2.0)
+    params["cond"] = migraphx.fill_argument(
+        migraphx.shape(type="bool", lens=[1], strides=[0]), 1)
 
     r = p.run(params)[-1]
     print(r)

test/quantization.cpp

@@ -638,11 +638,10 @@ TEST_CASE(dot_float)
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sb.lens()}}), zp);
         auto quant_b  = mm->add_instruction(migraphx::make_op("quantizelinear"), pb, scale_b, zp_b);
         auto quant    = mm->add_instruction(migraphx::make_op("quant_dot"), quant_a, quant_b);
-        std::vector<float> vec(sc.elements(), 100.0f);
-        auto dc = mm->add_literal(100.0f);
-        auto mdc =
-            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sc.lens()}}), dc);
-        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, mdc);
+        auto scale_mb = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", quant->get_shape().lens()}}), scale);
+        auto out_scale = mm->add_instruction(migraphx::make_op("mul"), scale_mb, scale_mb);
+        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, out_scale);
         mm->add_return({r});
 
         return p;
@@ -717,24 +716,28 @@ TEST_CASE(dot_double_2args)
         auto pa = mm->add_parameter("a", sa);
         auto pb = mm->add_parameter("b", sb);
 
-        auto scale_a = mm->add_literal(10.0);
+        auto scale_a_lit = mm->add_literal(10.0);
         auto zp          = mm->add_literal(static_cast<int8_t>(0));
-        scale_a      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}), scale_a);
+        auto scale_a     = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}), scale_a_lit);
         auto zp_a =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}), zp);
         auto qa = mm->add_instruction(migraphx::make_op("quantizelinear"), pa, scale_a, zp_a);
-        auto scale_b = mm->add_literal(5.0);
-        scale_b      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sb.lens()}}), scale_b);
+        auto scale_b_lit = mm->add_literal(5.0);
+        auto scale_b     = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sb.lens()}}), scale_b_lit);
         auto zp_b =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sb.lens()}}), zp);
         auto qb   = mm->add_instruction(migraphx::make_op("quantizelinear"), pb, scale_b, zp_b);
         auto qdot = mm->add_instruction(migraphx::make_op("quant_dot"), qa, qb);
-        auto scale = mm->add_literal(50.0);
-        scale      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", qdot->get_shape().lens()}}), scale);
-        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), qdot, scale);
+        auto scale_a_mb = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", qdot->get_shape().lens()}}),
+            scale_a_lit);
+        auto scale_b_mb = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", qdot->get_shape().lens()}}),
+            scale_b_lit);
+        auto out_scale = mm->add_instruction(migraphx::make_op("mul"), scale_a_mb, scale_b_mb);
+        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), qdot, out_scale);
         mm->add_return({r});
         return p;
     };
@@ -799,18 +802,15 @@ TEST_CASE(dot_half_1arg)
         auto x = mm->add_parameter("x", sa);
 
         auto zp        = mm->add_literal(static_cast<int8_t>(0));
-        auto scale = mm->add_literal(migraphx::literal({sa.type()}, {10.0}));
-        scale = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}),
-                                    scale);
+        auto scale_lit = mm->add_literal(migraphx::literal({sa.type()}, {10.0}));
+        auto scale     = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}), scale_lit);
         zp =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sa.lens()}}), zp);
         auto qx        = mm->add_instruction(migraphx::make_op("quantizelinear"), x, scale, zp);
         auto qdot      = mm->add_instruction(migraphx::make_op("quant_dot"), qx, qx);
-        auto dq_scale = mm->add_literal(migraphx::literal({sa.type()}, {100.0}));
-        dq_scale      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", qdot->get_shape().lens()}}),
-            dq_scale);
-        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), qdot, dq_scale);
+        auto out_scale = mm->add_instruction(migraphx::make_op("mul"), scale, scale);
+        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), qdot, out_scale);
         mm->add_return({r});
         return p;
     };
@@ -852,9 +852,9 @@ TEST_CASE(conv_float)
         auto pw = mm->add_parameter("w", sw);
 
         auto zp        = mm->add_literal(static_cast<int8_t>(0));
-        auto scale = mm->add_literal(10.0f);
-        scale = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}),
-                                    scale);
+        auto scale_lit = mm->add_literal(10.0f);
+        auto scale     = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}), scale_lit);
         zp =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}), zp);
         auto quant_x = mm->add_instruction(migraphx::make_op("quantizelinear"), px, scale, zp);
@@ -862,13 +862,11 @@ TEST_CASE(conv_float)
 
         auto quant = mm->add_instruction(migraphx::make_op("quant_convolution"), quant_x, quant_w);
 
-        migraphx::shape sc{migraphx::shape::float_type, {4, 4, 1, 1}};
-        std::vector<float> vec(sc.elements(), 100.0f);
-        migraphx::shape s_scale{migraphx::shape::float_type, sc.lens()};
-        auto d_scale = mm->add_literal(100.0f);
-        d_scale      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", {4, 4, 1, 1}}}), d_scale);
-        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, d_scale);
+        auto scale_mb = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", quant->get_shape().lens()}}),
+            scale_lit);
+        auto out_scale = mm->add_instruction(migraphx::make_op("mul"), scale_mb, scale_mb);
+        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, out_scale);
         mm->add_return({r});
 
         return p;
@@ -931,19 +929,20 @@ TEST_CASE(conv_half)
         auto pw = mm->add_parameter("w", sw);
 
         auto zp        = mm->add_literal(static_cast<int8_t>(0));
-        auto scale = mm->add_literal(migraphx::literal({sx.type()}, {10.0}));
-        scale = mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}),
-                                    scale);
+        auto scale_lit = mm->add_literal(migraphx::literal({sx.type()}, {10.0}));
+        auto scale     = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}), scale_lit);
         zp =
             mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", sx.lens()}}), zp);
         auto quant_x = mm->add_instruction(migraphx::make_op("quantizelinear"), px, scale, zp);
         auto quant_w = mm->add_instruction(migraphx::make_op("quantizelinear"), pw, scale, zp);
 
         auto quant = mm->add_instruction(migraphx::make_op("quant_convolution"), quant_x, quant_w);
-        auto d_scale = mm->add_literal(migraphx::literal({sx.type()}, {100.0}));
-        d_scale      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", {4, 4, 1, 1}}}), d_scale);
-        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, d_scale);
+        auto scale_mb = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", quant->get_shape().lens()}}),
+            scale_lit);
+        auto out_scale = mm->add_instruction(migraphx::make_op("mul"), scale_mb, scale_mb);
+        auto r = mm->add_instruction(migraphx::make_op("dequantizelinear"), quant, out_scale);
         mm->add_return({r});
 
         return p;
@@ -1187,9 +1186,9 @@ TEST_CASE(int8_subgraph)
             migraphx::make_op("multibroadcast", {{"out_lens", sy.lens()}}), zp1);
         auto qb    = then_mod->add_instruction(migraphx::make_op("quantizelinear"), b, sb, zpb);
         auto qdot  = then_mod->add_instruction(migraphx::make_op("quant_dot"), qa, qb);
-        auto so   = then_mod->add_literal(100.0f);
-        so        = then_mod->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sout.lens()}}), so);
+        auto s1_mb = then_mod->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", qdot->get_shape().lens()}}), s1);
+        auto so = then_mod->add_instruction(migraphx::make_op("mul"), s1_mb, s1_mb);
         auto r  = then_mod->add_instruction(migraphx::make_op("dequantizelinear"), qdot, so);
         then_mod->add_return({r});
 
@@ -1199,23 +1198,24 @@ TEST_CASE(int8_subgraph)
         auto w = mm->add_parameter("w", sw);
         // else submod
         auto* else_mod = p.create_module("If_6_else");
-        auto sax       = else_mod->add_literal(2.0f);
+        auto sax_lit   = else_mod->add_literal(2.0f);
         auto zp        = else_mod->add_literal(static_cast<int8_t>(0));
-        sax            = else_mod->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sd.lens()}}), sax);
+        auto sax       = else_mod->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sd.lens()}}), sax_lit);
         auto zpx = else_mod->add_instruction(
             migraphx::make_op("multibroadcast", {{"out_lens", sd.lens()}}), zp);
         auto qx      = else_mod->add_instruction(migraphx::make_op("quantizelinear"), x, sax, zpx);
-        auto ssw = else_mod->add_literal(1.66667f);
-        ssw      = else_mod->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sw.lens()}}), ssw);
+        auto ssw_lit = else_mod->add_literal(1.66667f);
+        auto ssw     = else_mod->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", sw.lens()}}), ssw_lit);
         auto zpw = else_mod->add_instruction(
             migraphx::make_op("multibroadcast", {{"out_lens", sw.lens()}}), zp);
         auto qw     = else_mod->add_instruction(migraphx::make_op("quantizelinear"), w, ssw, zpw);
         auto qconv  = else_mod->add_instruction(migraphx::make_op("quant_convolution"), qx, qw);
-        auto so1   = else_mod->add_literal(3.33333f);
-        so1        = else_mod->add_instruction(
-            migraphx::make_op("multibroadcast", {{"out_lens", sout.lens()}}), so1);
+        auto ssw_mb = else_mod->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", qconv->get_shape().lens()}}),
+            ssw_lit);
+        auto so1 = else_mod->add_instruction(migraphx::make_op("mul"), sax, ssw_mb);
         auto r1  = else_mod->add_instruction(migraphx::make_op("dequantizelinear"), qconv, so1);
         else_mod->add_return({r1});
 

test/ref/isinf.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 <migraphx/instruction.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/program.hpp>
+#include <migraphx/register_target.hpp>
+#include <migraphx/verify.hpp>
+
+#include <test.hpp>
+
+TEST_CASE(isinf_double_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::double_type, {2, 3}};
+    auto inf_val              = std::numeric_limits<double>::infinity();
+    std::vector<double> data0 = {1.2, 5.2, inf_val, -inf_val, 0., 100.};
+    auto l1                   = mm->add_literal(migraphx::literal{s, data0});
+    mm->add_instruction(migraphx::make_op("isinf"), l1);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<double> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<double> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(isinf_float_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::float_type, {2, 3}};
+    auto inf_val             = std::numeric_limits<float>::infinity();
+    std::vector<float> data0 = {1.2, 5.2, inf_val, -inf_val, 0., 100.};
+    auto l1                  = mm->add_literal(migraphx::literal{s, data0});
+    mm->add_instruction(migraphx::make_op("isinf"), l1);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(isinf_half_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::half_type, {2, 3}};
+    auto inf_val = std::numeric_limits<migraphx::half>::infinity();
+    migraphx::half a{1.2};
+    migraphx::half b{5.2};
+    std::vector<migraphx::half> data0 = {a, b, inf_val, -inf_val, b, a};
+    auto l1                           = mm->add_literal(migraphx::literal{s, data0});
+    mm->add_instruction(migraphx::make_op("isinf"), l1);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(isinf_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::float_type, {{2, 2}, {3, 8}}};
+    auto input   = mm->add_parameter("X", s);
+    auto inf_val = std::numeric_limits<migraphx::half>::infinity();
+    mm->add_instruction(migraphx::make_op("isinf"), input);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> input_data = {1.2, 5.2, inf_val, -inf_val, 0., 100.};
+    migraphx::parameter_map params0;
+    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3}};
+    params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
+    auto result  = p.eval(params0).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}

test/ref/multinomial.cpp

@@ -24,9 +24,10 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/program.hpp>
+#include <migraphx/onnx.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
+#include <numeric>
 #include <random>
 
 #include <test.hpp>
@@ -48,27 +49,37 @@ TEST_CASE(multinomial_test)
     migraphx::shape s{migraphx::shape::float_type, {1, 5}};
     std::vector<int> dist{15, 25, 15, 25, 20};
     std::vector<float> data(5);
-    std::transform(dist.begin(), dist.end(), data.begin(), [&](auto d) { return std::log(d); });
-    auto input = mm->add_literal(migraphx::literal(s, data));
+    std::vector<float> sum(5);
+    // convert to float
+    std::transform(dist.begin(), dist.end(), data.begin(), [&](auto d) { return d; });
+    // take cumulative sum
+    std::partial_sum(data.begin(), data.end(), sum.begin(), std::plus<float>());
+    // scale probabilities arbitrarily
+    float odd_scale = 10000.;
+    std::transform(sum.begin(), sum.end(), data.begin(), [&](auto d) { return d * odd_scale; });
 
-    auto maxes = mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {1}}}), input);
-    auto mb_maxes =
-        mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {1, 5}}}), maxes);
-    auto cdf = mm->add_instruction(migraphx::make_op("sub"), input, mb_maxes);
-    cdf      = mm->add_instruction(migraphx::make_op("exp"), cdf);
-    cdf      = mm->add_instruction(
-        migraphx::make_op("prefix_scan_sum", {{"axis", 1}, {"exclusive", false}}), cdf);
+    auto input = mm->add_literal(migraphx::literal(s, data));
 
-    mm->add_instruction(migraphx::make_op("multinomial"), cdf, rs_lit);
+    mm->add_instruction(migraphx::make_op("multinomial"), input, rs_lit);
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
+    // result_vec contains an index, or category label, for each random input value
     std::vector<int32_t> result_vec(sample_size);
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
+    // res_dist is a count, or histogram, of the number of samples in each category.  This is the
+    // sampled distribution.
     std::vector<int> res_dist(5, 0);
     for(const auto& r : result_vec)
         res_dist[r]++;
+
+    // To check the result, normalize the original probability distribution dist
+    // and the sampling result res_dist; they should be close
+
+    // Total the unnormalized probabilities
     auto dist_sum = std::accumulate(dist.begin(), dist.end(), 0);
+
+    // Total the number of values returned
     auto res_dist_sum = std::accumulate(res_dist.begin(), res_dist.end(), 0);
     std::vector<float> norm(5);
     std::vector<float> res_norm(5);
@@ -78,6 +89,204 @@ TEST_CASE(multinomial_test)
     std::transform(res_dist.begin(), res_dist.end(), res_norm.begin(), [&](auto n) {
         return static_cast<double>(n) / res_dist_sum;
     });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
+}
+
+TEST_CASE(multinomial_dyn_test)
+{
+    // Invokes random_uniform and multinomial ops together, to verify the interface
+    // Dynamic Batch dimension input of 2 means there are 2 different probability
+    // distribution functions contained in Input_2
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    size_t sample_size = 100000;
+    size_t batch_size  = 2;
+
+    //      Shape of the random data
+    migraphx::shape rs{migraphx::shape::float_type, {{1, 2}, {2, sample_size + 1}}};
+    auto input = mm->add_parameter("Input_1", rs);
+
+    // Runtime randomization seed
+    // To seed the random_uniform, we can provide a value by literal or input,
+    // or ask the system to auto-seed with random_seed op.
+    migraphx::shape seed_shape{migraphx::shape::uint32_type,
+                               {migraphx::shape::dynamic_dimension{0, 1}}};
+    auto seed_input = mm->add_parameter("Seed", seed_shape);
+
+    // Shape of the probability distribution, which also defines the number of categories
+    migraphx::shape s{migraphx::shape::float_type, {{2, 2}, {5, 6}}};
+
+    // Unnormalized distributions for batch size 2:
+    //   15, 25, 15, 15, 20
+    //   20, 20, 10, 25, 25
+    std::vector<int> dist{15, 25, 15, 25, 20, 20, 20, 10, 25, 25};
+    // Hard-coded non-normalized, accumulated distribution follows:
+    std::vector<float> data{.15f, .40f, .55f, .80f, 1.0f, 20.f, 40.f, 50.f, 75.f, 100.f};
+
+    auto input2 = mm->add_parameter("Input_2", s);
+
+    auto randoms = mm->add_instruction(migraphx::make_op("random_uniform"), seed_input, input);
+    mm->add_instruction(migraphx::make_op("multinomial"), input2, randoms);
+
+    p.compile(migraphx::make_target("ref"));
+
+    // Create a dummy input in the shape we want for the random data
+    std::vector<float> dummy(sample_size, 0);
+    migraphx::shape input_fixed_shape1{migraphx::shape::float_type, {batch_size, sample_size}};
+    migraphx::shape input_fixed_shape2{migraphx::shape::float_type, {batch_size, 5}};
+    migraphx::parameter_map params0;
+    params0["Input_1"] = migraphx::argument(input_fixed_shape1, dummy.data());
+
+    migraphx::shape seed_fixed_shape{migraphx::shape::uint32_type, {1}};
+    std::vector<uint32_t> seed_data = {4};
+    params0["Seed"]                 = migraphx::argument(seed_fixed_shape, seed_data.data());
+
+    params0["Input_2"] = migraphx::argument(input_fixed_shape2, data.data());
+    auto result        = p.eval(params0).back();
+
+    std::vector<float> result_vec(input_fixed_shape2.elements());
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+
+    // Make a categorical histogram of output
+    std::vector<int> res_dist(5, 0);
+    size_t r = 0;
+    for(r = 0; r < result_vec.size() / 2; r++)
+        res_dist[result_vec[r]]++;
+
+    //  histogram for second set of batch
+    std::vector<int> res_dist2(5, 0);
+    for(; r < result_vec.size(); r++)
+        res_dist2[result_vec[r]]++;
+
+    // Rescale or normalize both the input probability distribution and the output
+    // histogram, and compare.  Should be close but not identical.
+    auto dist_sum     = std::accumulate(dist.begin(), dist.begin() + 5, 0);
+    auto res_dist_sum = std::accumulate(res_dist.begin(), res_dist.end(), 0);
+    std::vector<float> norm(5);
+    std::vector<float> res_norm(5);
+
+    std::transform(dist.begin(), dist.begin() + 5, norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist.begin(), res_dist.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
+
+    // Do the same rescaling for the 2nd in batch, which has a different probability distribution
+    dist_sum     = std::accumulate(dist.begin() + 5, dist.end(), 0);
+    res_dist_sum = std::accumulate(res_dist2.begin(), res_dist2.end(), 0);
+    std::transform(dist.begin() + 5, dist.end(), norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist2.begin(), res_dist2.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
+}
+
+TEST_CASE(multinomial_float_dyn_test)
+{
+    // int data type for random_uniform op and float data type for multinomial.
+
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    size_t sample_size = 100000;
+    size_t batch_size  = 2;
+
+    //      Shape of the random data
+    migraphx::shape rs{migraphx::shape::int32_type, {{1, 2}, {2, sample_size + 1}}};
+    auto input = mm->add_parameter("Input_1", rs);
+
+    // Runtime randomization seed
+    // To seed the random_uniform, we can provide a value by literal or input,
+    // or ask the system to auto-seed with random_seed op.
+    migraphx::shape seed_shape{migraphx::shape::uint32_type,
+                               {migraphx::shape::dynamic_dimension{0, 1}}};
+    auto seed_input = mm->add_parameter("Seed", seed_shape);
+
+    // Shape of the probability distribution, which also defines the number of categories
+    migraphx::shape s{migraphx::shape::float_type, {{2, 2}, {5, 6}}};
+
+    // Unnormalized distributions for batch size 2:
+    //   15, 25, 15, 15, 20
+    //   20, 20, 10, 25, 25
+    std::vector<int> dist{15, 25, 15, 25, 20, 20, 20, 10, 25, 25};
+    // Hard-coded normalized, accumulated distribution follows:
+    std::vector<float> data{.15f, .40f, .55f, .80f, 1.0f, .20f, .40f, .50f, .75f, 1.0f};
+
+    auto input2 = mm->add_parameter("Input_2", s);
+
+    auto randoms = mm->add_instruction(migraphx::make_op("random_uniform"), seed_input, input);
+    mm->add_instruction(migraphx::make_op("multinomial", {{"dtype", migraphx::shape::float_type}}),
+                        input2,
+                        randoms);
+
+    p.compile(migraphx::make_target("ref"));
+
+    // Create a dummy input in the shape we want for the random data
+    std::vector<float> dummy(sample_size, 0);
+    migraphx::shape input_fixed_shape1{migraphx::shape::float_type, {batch_size, sample_size}};
+    migraphx::shape input_fixed_shape2{migraphx::shape::float_type, {batch_size, 5}};
+    migraphx::parameter_map params0;
+    params0["Input_1"] = migraphx::argument(input_fixed_shape1, dummy.data());
+
+    migraphx::shape seed_fixed_shape{migraphx::shape::uint32_type, {1}};
+    std::vector<uint32_t> seed_data = {4};
+    params0["Seed"]                 = migraphx::argument(seed_fixed_shape, seed_data.data());
+
+    params0["Input_2"] = migraphx::argument(input_fixed_shape2, data.data());
+    auto result        = p.eval(params0).back();
+
+    std::vector<float> result_vec(input_fixed_shape2.elements());
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+
+    // Make a categorical histogram of output
+    std::vector<int> res_dist(5, 0);
+    size_t r = 0;
+    for(r = 0; r < result_vec.size() / 2; r++)
+        res_dist[result_vec[r]]++;
+
+    //  histogram for second set of batch
+    std::vector<int> res_dist2(5, 0);
+    for(; r < result_vec.size(); r++)
+        res_dist2[result_vec[r]]++;
+
+    // Rescale or normalize both the input probability distribution and the output
+    // histogram, and compare.  Should be close but not identical.
+    auto dist_sum     = std::accumulate(dist.begin(), dist.begin() + 5, 0);
+    auto res_dist_sum = std::accumulate(res_dist.begin(), res_dist.end(), 0);
+    std::vector<float> norm(5);
+    std::vector<float> res_norm(5);
+
+    std::transform(dist.begin(), dist.begin() + 5, norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist.begin(), res_dist.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
+    EXPECT(migraphx::verify::verify_range_with_tolerance(
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
+
+    // Do the same rescaling for the 2nd in batch, which has a different probability distribution
+    dist_sum     = std::accumulate(dist.begin() + 5, dist.end(), 0);
+    res_dist_sum = std::accumulate(res_dist2.begin(), res_dist2.end(), 0);
+    std::transform(dist.begin() + 5, dist.end(), norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / dist_sum;
+    });
+    std::transform(res_dist2.begin(), res_dist2.end(), res_norm.begin(), [&](auto n) {
+        return static_cast<double>(n) / res_dist_sum;
+    });
+
     EXPECT(migraphx::verify::verify_range_with_tolerance(
         res_norm, migraphx::verify::expected{norm}, migraphx::verify::tolerance{0.01}));
 }

test/ref/round.cpp → test/ref/nearbyint.cpp

@@ -30,39 +30,71 @@
 
 #include <test.hpp>
 
-TEST_CASE(round_test)
+TEST_CASE(nearbyint_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
-    migraphx::shape s{migraphx::shape::float_type, {9}};
-    auto l =
-        mm->add_literal(migraphx::literal{s, {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0}});
-    mm->add_instruction(migraphx::make_op("round"), l);
+    migraphx::shape s{migraphx::shape::float_type, {4, 4}};
+    auto l = mm->add_literal(migraphx::literal{s,
+                                               {-3.51,
+                                                -3.5,
+                                                -3.49,
+                                                -2.51,
+                                                -2.50,
+                                                -2.49,
+                                                -1.6,
+                                                -1.5,
+                                                -0.51,
+                                                -0.5,
+                                                0.5,
+                                                0.6,
+                                                2.4,
+                                                2.5,
+                                                3.5,
+                                                4.5}});
+    mm->add_instruction(migraphx::make_op("nearbyint"), l);
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> gold = {1.0, 2.0, 2.0, -1.0, -2.0, -2.0, 0.0, 2.0, -2.0};
+    std::vector<float> gold = {
+        -4.0, -4.0, -3.0, -3.0, -2.0, -2.0, -2.0, -2.0, -1.0, 0.0, 0.0, 1.0, 2.0, 2.0, 4.0, 4.0};
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
-TEST_CASE(round_dyn_test)
+TEST_CASE(nearbyint_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{4, 10};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    mm->add_instruction(migraphx::make_op("round"), input);
+    mm->add_instruction(migraphx::make_op("nearbyint"), input);
     p.compile(migraphx::make_target("ref"));
 
-    std::vector<float> input_data{1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0};
+    std::vector<float> input_data{-3.51,
+                                  -3.5,
+                                  -3.49,
+                                  -2.51,
+                                  -2.50,
+                                  -2.49,
+                                  -1.6,
+                                  -1.5,
+                                  -0.51,
+                                  -0.5,
+                                  0.5,
+                                  0.6,
+                                  2.4,
+                                  2.5,
+                                  3.5,
+                                  4.5};
     migraphx::parameter_map params0;
-    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {9}};
+    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {16}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
     auto result  = p.eval(params0).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> gold = {1.0, 2.0, 2.0, -1.0, -2.0, -2.0, 0.0, 2.0, -2.0};
+    std::vector<float> gold = {
+        -4.0, -4.0, -3.0, -3.0, -2.0, -2.0, -2.0, -2.0, -1.0, 0.0, 0.0, 1.0, 2.0, 2.0, 4.0, 4.0};
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/quantizelinear.cpp

@@ -55,7 +55,7 @@ TEST_CASE(quantizelinear_1)
     std::vector<float> results_vector(18);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{
-        -128, 127, 65, -128, 1, 1, -1, 100, 92, -128, 127, 65, -128, 1, 1, -1, 100, 92};
+        -128, 127, 64, -128, 1, 1, -1, 100, 92, -128, 127, 64, -128, 1, 1, -1, 100, 92};
     EXPECT(results_vector == gold);
 }
 
@@ -80,6 +80,6 @@ TEST_CASE(quantizelinear_2)
     auto result = p1.eval({}).back();
     std::vector<float> results_vector(18);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> gold{0, 255, 65, 0, 2, 2, 0, 255, 255, 0, 255, 65, 0, 2, 2, 0, 255, 255};
+    std::vector<float> gold{0, 255, 64, 0, 2, 2, 0, 255, 255, 0, 255, 64, 0, 2, 2, 0, 255, 255};
     EXPECT(results_vector == gold);
 }

test/ref/reshape.cpp

@@ -226,7 +226,6 @@ TEST_CASE(reshape_2in_test1)
     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;

test/ref/rnn_ops.cpp

@@ -3228,6 +3228,264 @@ TEST_CASE(lstm_forward)
     }
 }
 
+TEST_CASE(lstm_forward_layout)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 1;
+
+    std::vector<float> w_data{
+        0.1236,  -0.3942, 0.4149,  0.0795,  0.4934,  -0.2858, 0.2602,  -0.3098, 0.0567,  0.3344,
+        0.3607,  -0.0551, 0.4952,  0.3799,  0.0630,  -0.3532, 0.0023,  -0.0592, 0.4267,  0.2382,
+        -0.0784, -0.0032, -0.2476, -0.0206, -0.4963, 0.4837,  0.0827,  0.0123,  -0.1203, -0.0279,
+        -0.0049, 0.4721,  -0.3564, -0.1286, 0.4090,  -0.0504, 0.0575,  -0.2138, 0.1071,  0.1976,
+        -0.0758, 0.0139,  -0.0761, 0.3991,  -0.2965, -0.4845, -0.1496, 0.3285};
+
+    std::vector<float> r_data{
+        0.1237,  0.1229,  -0.0766, -0.1144, -0.1186, 0.2922,  0.2478,  0.3159,  -0.0522, 0.1685,
+        -0.4621, 0.1728,  0.0670,  -0.2458, -0.3835, -0.4589, -0.3109, 0.4908,  -0.0133, -0.1858,
+        -0.0590, -0.0347, -0.2353, -0.0671, -0.3812, -0.0004, -0.1432, 0.2406,  0.1033,  -0.0265,
+        -0.3902, 0.0755,  0.3733,  0.4383,  -0.3140, 0.2537,  -0.1818, -0.4127, 0.3506,  0.2562,
+        0.2926,  0.1620,  -0.4849, -0.4861, 0.4426,  0.2106,  -0.0005, 0.4418,  -0.2926, -0.3100,
+        0.1500,  -0.0362, -0.3801, -0.0065, -0.0631, 0.1277,  0.2315,  0.4087,  -0.3963, -0.4161,
+        -0.2169, -0.1344, 0.3468,  -0.2260};
+
+    std::vector<float> bias_data{0.0088,  0.1183,  0.1642,  -0.2631, -0.1330, -0.4008, 0.3881,
+                                 -0.4407, -0.2760, 0.1274,  -0.0083, -0.2885, 0.3949,  -0.0182,
+                                 0.4445,  0.3477,  0.2266,  0.3423,  -0.0674, -0.4067, 0.0807,
+                                 0.1109,  -0.2036, 0.1782,  -0.2467, -0.0730, -0.4216, 0.0316,
+                                 -0.3025, 0.3637,  -0.3181, -0.4655};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.0910, 1.2122,  -0.1952, 0.3577,  1.3508,  -0.5366,
+        0.4583,  2.3794, 1.0372,  -0.4313, -0.9730, -0.2005, 0.4661,  0.6494,  2.1332,
+        1.7449,  0.5483, -0.0701, -0.8887, 0.7892,  -0.4012, 2.3930,  -0.5221, -0.1331,
+        -1.0972, 0.9816, 0.1122,  -0.4100, -2.2344, 0.3685,  -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.9104,
+                               -1.9004,
+                               0.3337,
+                               0.5741,
+                               0.5671,
+                               0.0458,
+                               0.4514,
+                               -0.8968,
+                               -0.9201,
+                               0.1962,
+                               0.5771,
+                               -0.5332};
+
+    std::vector<float> ic_data{0.9569,
+                               -0.5981,
+                               1.1312,
+                               1.0945,
+                               1.1055,
+                               -0.1212,
+                               -0.9097,
+                               0.7831,
+                               -1.6991,
+                               -1.9498,
+                               -1.2567,
+                               -0.4114};
+
+    std::vector<float> pph_data{1.84369764,
+                                0.68413646,
+                                -0.44892886,
+                                -1.50904413,
+                                0.3860796,
+                                -0.52186625,
+                                1.08474445,
+                                -1.80867321,
+                                1.32594529,
+                                0.4336262,
+                                -0.83699064,
+                                0.49162736};
+
+    float clip = 0.0f;
+    migraphx::shape in_shape{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+
+    // forward, hidden state concatenation as output
+    {
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            und);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> hs_data;
+        hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> hs_data_gold{
+            0.0417273,  -0.272355,   0.206765,  0.223879,   0.0742487,  -0.0800085, 0.259897,
+            0.0670196,  -0.00532985, 0.0440265, 0.29654,    -0.0463156, -0.0847427, 0.0874114,
+            0.304256,   -0.0585745,  0.138193,  -0.0322939, -0.0891815, 0.15773,    0.184266,
+            0.0610048,  -0.138041,   0.0963885, 0.0498799,  0.125772,   0.0533032,  -0.131413,
+            -0.0223018, 0.131113,    0.135643,  -0.056620,  0.19139,    -0.127708,  -0.409371,
+            -0.136186,  0.0213755,   -0.146027, -0.0324509, -0.0620429, 0.0988431,  -0.018085,
+            -0.159434,  0.030266,    0.142701,  0.0342236,  -0.198664,  0.0702607};
+        EXPECT(migraphx::verify::verify_rms_range(hs_data, hs_data_gold));
+    }
+
+    // forward, last_output as program output
+    {
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            und);
+        auto last_output = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), last_output);
+        p.compile(migraphx::make_target("ref"));
+
+        auto last_hs = p.eval({}).back();
+        std::vector<float> output_data;
+        last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{-0.0847427,
+                                            0.0874114,
+                                            0.304256,
+                                            -0.0585745,
+                                            -0.0223018,
+                                            0.131113,
+                                            0.135643,
+                                            -0.0566208,
+                                            0.142701,
+                                            0.0342236,
+                                            -0.198664,
+                                            0.0702607};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // forward, last_cell_output as program output
+    {
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            und);
+        auto cell_output = mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), cell_output);
+        p.compile(migraphx::make_target("ref"));
+
+        auto last_hs = p.eval({}).back();
+        std::vector<float> output_data;
+        last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{-0.111454,
+                                            0.247794,
+                                            0.471087,
+                                            -0.220574,
+                                            -0.048196,
+                                            0.263184,
+                                            0.283258,
+                                            -0.14882,
+                                            0.605585,
+                                            0.078598,
+                                            -0.64457,
+                                            0.119811};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+}
+
 TEST_CASE(lstm_forward_more)
 {
     std::size_t batch_size  = 3;
@@ -3519,7 +3777,7 @@ TEST_CASE(lstm_forward_more)
     }
 }
 
-TEST_CASE(lstm_reverse)
+TEST_CASE(lstm_forward_more_layout)
 {
     std::size_t batch_size  = 3;
     std::size_t seq_len     = 4;
@@ -3527,26 +3785,978 @@ TEST_CASE(lstm_reverse)
     std::size_t input_size  = 3;
     std::size_t num_dirct   = 1;
     std::vector<float> w_data{
-        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
-        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
-        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
-        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
-        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+        0.1236,  -0.3942, 0.4149,  0.0795,  0.4934,  -0.2858, 0.2602,  -0.3098, 0.0567,  0.3344,
+        0.3607,  -0.0551, 0.4952,  0.3799,  0.0630,  -0.3532, 0.0023,  -0.0592, 0.4267,  0.2382,
+        -0.0784, -0.0032, -0.2476, -0.0206, -0.4963, 0.4837,  0.0827,  0.0123,  -0.1203, -0.0279,
+        -0.0049, 0.4721,  -0.3564, -0.1286, 0.4090,  -0.0504, 0.0575,  -0.2138, 0.1071,  0.1976,
+        -0.0758, 0.0139,  -0.0761, 0.3991,  -0.2965, -0.4845, -0.1496, 0.3285};
 
     std::vector<float> r_data{
-        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
-        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
-        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
-        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
-        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
-        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
-        0.3987,  -0.1687, -0.0032, -0.1038};
-
-    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
-                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
-                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
-                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
-                                 -0.4386, 0.4208,  0.0717,  0.3789};
+        0.1237,  0.1229,  -0.0766, -0.1144, -0.1186, 0.2922,  0.2478,  0.3159,  -0.0522, 0.1685,
+        -0.4621, 0.1728,  0.0670,  -0.2458, -0.3835, -0.4589, -0.3109, 0.4908,  -0.0133, -0.1858,
+        -0.0590, -0.0347, -0.2353, -0.0671, -0.3812, -0.0004, -0.1432, 0.2406,  0.1033,  -0.0265,
+        -0.3902, 0.0755,  0.3733,  0.4383,  -0.3140, 0.2537,  -0.1818, -0.4127, 0.3506,  0.2562,
+        0.2926,  0.1620,  -0.4849, -0.4861, 0.4426,  0.2106,  -0.0005, 0.4418,  -0.2926, -0.3100,
+        0.1500,  -0.0362, -0.3801, -0.0065, -0.0631, 0.1277,  0.2315,  0.4087,  -0.3963, -0.4161,
+        -0.2169, -0.1344, 0.3468,  -0.2260};
+
+    std::vector<float> bias_data{0.0088,  0.1183,  0.1642,  -0.2631, -0.1330, -0.4008, 0.3881,
+                                 -0.4407, -0.2760, 0.1274,  -0.0083, -0.2885, 0.3949,  -0.0182,
+                                 0.4445,  0.3477,  0.2266,  0.3423,  -0.0674, -0.4067, 0.0807,
+                                 0.1109,  -0.2036, 0.1782,  -0.2467, -0.0730, -0.4216, 0.0316,
+                                 -0.3025, 0.3637,  -0.3181, -0.4655};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.0910, 1.2122,  -0.1952, 0.3577,  1.3508,  -0.5366,
+        0.4583,  2.3794, 1.0372,  -0.4313, -0.9730, -0.2005, 0.4661,  0.6494,  2.1332,
+        1.7449,  0.5483, -0.0701, -0.8887, 0.7892,  -0.4012, 2.3930,  -0.5221, -0.1331,
+        -1.0972, 0.9816, 0.1122,  -0.4100, -2.2344, 0.3685,  -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.9104,
+                               -1.9004,
+                               0.3337,
+                               0.5741,
+                               0.5671,
+                               0.0458,
+                               0.4514,
+                               -0.8968,
+                               -0.9201,
+                               0.1962,
+                               0.5771,
+                               -0.5332};
+
+    std::vector<float> ic_data{0.9569,
+                               -0.5981,
+                               1.1312,
+                               1.0945,
+                               1.1055,
+                               -0.1212,
+                               -0.9097,
+                               0.7831,
+                               -1.6991,
+                               -1.9498,
+                               -1.2567,
+                               -0.4114};
+
+    std::vector<float> pph_data{1.84369764,
+                                0.68413646,
+                                -0.44892886,
+                                -1.50904413,
+                                0.3860796,
+                                -0.52186625,
+                                1.08474445,
+                                -1.80867321,
+                                1.32594529,
+                                0.4336262,
+                                -0.83699064,
+                                0.49162736};
+
+    float clip = 0.0f;
+    migraphx::shape in_shape{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+
+    // forward, 3 args
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+
+        auto last_hs = p.eval({}).back();
+        std::vector<float> output_data;
+        last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{
+            -0.0327039, -0.0543852,  0.114378,   -0.0768855,  -0.0786602, -0.0613048, 0.179592,
+            -0.071286,  -0.102509,   -0.0372696, 0.252296,    -0.144544,  -0.165194,  -0.0372928,
+            0.273786,   -0.100877,   0.0319021,  -0.00298698, -0.0623361, 0.0598866,  0.074206,
+            0.0124086,  -0.139544,   0.108016,   0.00496085,  0.0662588,  -0.048577,  -0.187329,
+            -0.0458544, -0.0401315,  0.0737483,  -0.064505,   0.101585,   0.0687269,  -0.161725,
+            -0.25617,   -0.00973633, -0.0552699, 0.0252681,   -0.0562072, 0.0855831,  -0.0171894,
+            -0.140202,  0.0828391,   0.136898,   0.00160891,  -0.184812,  0.147774};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // forward, 8 args
+    {
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> hs_data;
+        hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> hs_data_gold{
+            0.079753,  -0.289854,  0.160043,   0.115056,   0.186991,   -0.0624168, 0.205513,
+            0.0836373, 0.0459033,  0.0414126,  0.272303,   0.0393149,  -0.058052,  0.0795391,
+            0.266617,  -0.0128746, 0.294074,   -0.0319677, -0.0955337, 0.104168,   0.421857,
+            0.0459771, -0.144955,  0.0720673,  0.218258,   0.0944405,  0.0431211,  -0.132394,
+            0.0309878, 0.0971544,  0.149294,   -0.0492549, 0.022618,   -0.121195,  -0.4065,
+            -0.252054, -0.0300906, -0.0890598, -0.135266,  -0.0413375, 0.103489,   0.0142918,
+            -0.123408, 0.0401075,  0.187761,   0.0501726,  -0.121584,  0.0606723};
+
+        EXPECT(migraphx::verify::verify_rms_range(hs_data, hs_data_gold));
+    }
+
+    // forward, last_output as program output, sequence length shorter
+    // than max_seq_len
+    {
+        migraphx::program p;
+        auto* mm      = p.get_main_module();
+        auto seq_orig = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w        = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r        = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias     = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih       = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic       = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        migraphx::shape pad_seq_s{migraphx::shape::float_type, {batch_size, 2, input_size}};
+        std::vector<float> pad_data(pad_seq_s.elements(), 0.0f);
+        auto seq_p = mm->add_literal(migraphx::literal{pad_seq_s, pad_data});
+        auto seq = mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), seq_orig, seq_p);
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data(batch_size, static_cast<int32_t>(seq_len));
+        auto sql = mm->add_literal(seq_len_s, len_data);
+
+        auto und = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            und);
+        auto last_output = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), last_output);
+        p.compile(migraphx::make_target("ref"));
+
+        auto last_hs = p.eval({}).back();
+        std::vector<float> output_data;
+        last_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{-0.0847427,
+                                            0.0874114,
+                                            0.304256,
+                                            -0.0585745,
+                                            -0.0223018,
+                                            0.131113,
+                                            0.135643,
+                                            -0.0566208,
+                                            0.142701,
+                                            0.0342236,
+                                            -0.198664,
+                                            0.0702607};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // seq_len = 1
+    {
+        seq_len = 1;
+        migraphx::shape in_shape1{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
+        std::vector<float> input_data1{
+            -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930, -0.5221, -0.1331};
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape1, input_data1});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::forward)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        auto last_output = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), last_output);
+        p.compile(migraphx::make_target("ref"));
+
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> hs_data;
+        hs_concat.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> hs_data_gold{0.079753,
+                                        -0.289854,
+                                        0.160043,
+                                        0.115056,
+                                        0.294074,
+                                        -0.0319677,
+                                        -0.0955337,
+                                        0.104168,
+                                        0.022618,
+                                        -0.121195,
+                                        -0.4065,
+                                        -0.252054};
+        EXPECT(migraphx::verify::verify_rms_range(hs_data, hs_data_gold));
+    }
+}
+
+TEST_CASE(lstm_reverse)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 1;
+    std::vector<float> w_data{
+        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
+        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
+        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
+        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
+        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
+        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
+        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
+        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
+        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
+        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
+        0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
+                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
+                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
+                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+                                 -0.4386, 0.4208,  0.0717,  0.3789};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
+        -0.0910, 1.2122, -0.1952, 0.4661,  0.6494,  2.1332,  -1.0972, 0.9816,  0.1122,
+        0.3577,  1.3508, -0.5366, 1.7449,  0.5483,  -0.0701, -0.4100, -2.2344, 0.3685,
+        0.4583,  2.3794, 1.0372,  -0.8887, 0.7892,  -0.4012, -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.5289,
+                               1.0986,
+                               0.6091,
+                               1.6462,
+                               0.8720,
+                               0.5349,
+                               -0.1962,
+                               -1.7416,
+                               -0.9912,
+                               1.2831,
+                               1.0896,
+                               -0.6959};
+
+    std::vector<float> ic_data{-0.8323,
+                               0.3998,
+                               0.1831,
+                               0.5938,
+                               2.7096,
+                               -0.1790,
+                               0.0022,
+                               -0.8040,
+                               0.1578,
+                               0.0567,
+                               0.8069,
+                               -0.5141};
+
+    std::vector<float> pph_data{-0.8271,
+                                -0.5683,
+                                0.4562,
+                                -1.2545,
+                                1.2729,
+                                -0.4082,
+                                -0.4392,
+                                -0.9406,
+                                0.7794,
+                                1.8194,
+                                -0.5811,
+                                0.2166};
+
+    migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+    float clip = 0.0f;
+    // reverse, concatenation of hidden states as program output
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+        mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{
+            -0.120174, 0.043157,  0.117138,   -0.222188, 0.789732,   0.128538,   0.20909,
+            0.0553812, -0.224905, 0.32421,    0.344048,  0.271694,   -0.175114,  -0.00543549,
+            0.178681,  -0.266999, 0.928866,   0.113685,  0.220626,   -0.0432316, -0.063456,
+            0.148524,  0.05108,   -0.0234895, -0.182201, -0.0232277, 0.235501,   -0.213485,
+            0.960938,  0.133565,  0.269741,   0.130438,  -0.0252804, 0.267356,   0.146353,
+            0.0789186, -0.185038, -0.026845,  0.177273,  -0.0774616, 0.946669,   0.0868676,
+            0.044508,  -0.373961, -0.0681467, 0.382748,  0.230211,   -0.161537};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // reverse, sequence lengths are the same, but less than max_seq_lens
+    {
+        migraphx::program p;
+        auto* mm      = p.get_main_module();
+        auto seq_orig = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+
+        migraphx::shape pad_seq_s{migraphx::shape::float_type, {2, batch_size, input_size}};
+        std::vector<float> pad_data(pad_seq_s.elements(), 0.0f);
+        auto seq_p = mm->add_literal(migraphx::literal{pad_seq_s, pad_data});
+        auto seq = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), seq_orig, seq_p);
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data(batch_size, static_cast<int32_t>(seq_len));
+        auto sql = mm->add_literal(seq_len_s, len_data);
+        mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{
+            -0.120174, 0.043157,  0.117138,   -0.222188, 0.789732,   0.128538,   0.20909,
+            0.0553812, -0.224905, 0.32421,    0.344048,  0.271694,   -0.175114,  -0.00543549,
+            0.178681,  -0.266999, 0.928866,   0.113685,  0.220626,   -0.0432316, -0.063456,
+            0.148524,  0.05108,   -0.0234895, -0.182201, -0.0232277, 0.235501,   -0.213485,
+            0.960938,  0.133565,  0.269741,   0.130438,  -0.0252804, 0.267356,   0.146353,
+            0.0789186, -0.185038, -0.026845,  0.177273,  -0.0774616, 0.946669,   0.0868676,
+            0.044508,  -0.373961, -0.0681467, 0.382748,  0.230211,   -0.161537,  0.0,
+            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
+            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
+            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
+            0.0,       0.0};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // variable sequence lengths
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data{3, 2, 1};
+        auto sql = mm->add_literal(seq_len_s, len_data);
+        mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{
+            -0.126517, 0.0359124,  0.107453, -0.0617278, 0.911307,  0.11468,   0.114449,
+            0.0196755, -0.102969,  0.295872, 0.515859,   0.246501,  -0.168327, 0.00023761,
+            0.167567,  -0.0621982, 0.96657,  0.0755112,  0.0620917, -0.264845, 0,
+            0,         0,          0,        -0.204545,  0.0146403, 0.210057,  0.0296268,
+            0,         0,          0,        0,          0,         0,         0,
+            0,         0,          0,        0,          0,         0,         0,
+            0,         0,          0,        0,          0,         0};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // reverse, 3 args, last cell output as program output
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto hs  = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                  {"actv_func",
+                   migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                       migraphx::make_op("tanh"),
+                                                                       migraphx::make_op("tanh")})},
+                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                  {"clip", clip},
+                  {"input_forget", 0}}),
+            seq,
+            w,
+            r);
+        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{-0.443077,
+                                            -0.325425,
+                                            -0.249367,
+                                            -0.270812,
+                                            0.122913,
+                                            0.118537,
+                                            0.0370199,
+                                            -0.0164687,
+                                            -0.00754759,
+                                            0.141613,
+                                            0.348002,
+                                            0.667298};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // reverse, 3 args, 0 actv function
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto hs  = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                  {"actv_func", {}},
+                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                  {"clip", clip},
+                  {"input_forget", 0}}),
+            seq,
+            w,
+            r);
+        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{-0.443077,
+                                            -0.325425,
+                                            -0.249367,
+                                            -0.270812,
+                                            0.122913,
+                                            0.118537,
+                                            0.0370199,
+                                            -0.0164687,
+                                            -0.00754759,
+                                            0.141613,
+                                            0.348002,
+                                            0.667298};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+}
+
+TEST_CASE(lstm_reverse_layout)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 1;
+    std::vector<float> w_data{
+        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
+        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
+        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
+        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
+        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
+        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
+        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
+        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
+        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
+        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
+        0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
+                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
+                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
+                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+                                 -0.4386, 0.4208,  0.0717,  0.3789};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.0910, 1.2122,  -0.1952, 0.3577,  1.3508,  -0.5366,
+        0.4583,  2.3794, 1.0372,  -0.4313, -0.9730, -0.2005, 0.4661,  0.6494,  2.1332,
+        1.7449,  0.5483, -0.0701, -0.8887, 0.7892,  -0.4012, 2.3930,  -0.5221, -0.1331,
+        -1.0972, 0.9816, 0.1122,  -0.4100, -2.2344, 0.3685,  -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.5289,
+                               1.0986,
+                               0.6091,
+                               1.6462,
+                               0.8720,
+                               0.5349,
+                               -0.1962,
+                               -1.7416,
+                               -0.9912,
+                               1.2831,
+                               1.0896,
+                               -0.6959};
+
+    std::vector<float> ic_data{-0.8323,
+                               0.3998,
+                               0.1831,
+                               0.5938,
+                               2.7096,
+                               -0.1790,
+                               0.0022,
+                               -0.8040,
+                               0.1578,
+                               0.0567,
+                               0.8069,
+                               -0.5141};
+
+    std::vector<float> pph_data{-0.8271,
+                                -0.5683,
+                                0.4562,
+                                -1.2545,
+                                1.2729,
+                                -0.4082,
+                                -0.4392,
+                                -0.9406,
+                                0.7794,
+                                1.8194,
+                                -0.5811,
+                                0.2166};
+
+    migraphx::shape in_shape{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+    float clip = 0.0f;
+
+    // reverse, concatenation of hidden states as program output
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{
+            -0.120174, 0.043157,   0.117138,   -0.222188, -0.175114,  -0.00543549, 0.178681,
+            -0.266999, -0.182201,  -0.0232277, 0.235501,  -0.213485,  -0.185038,   -0.026845,
+            0.177273,  -0.0774616, 0.789732,   0.128538,  0.20909,    0.0553812,   0.928866,
+            0.113685,  0.220626,   -0.0432316, 0.960938,  0.133565,   0.269741,    0.130438,
+            0.946669,  0.0868676,  0.044508,   -0.373961, -0.224905,  0.32421,     0.344048,
+            0.271694,  -0.063456,  0.148524,   0.05108,   -0.0234895, -0.0252804,  0.267356,
+            0.146353,  0.0789186,  -0.0681467, 0.382748,  0.230211,   -0.161537};
+
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // reverse, sequence lengths are the same, but less than max_seq_lens
+    {
+        migraphx::program p;
+        auto* mm      = p.get_main_module();
+        auto seq_orig = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+
+        migraphx::shape pad_seq_s{migraphx::shape::float_type, {batch_size, 2, input_size}};
+        std::vector<float> pad_data(pad_seq_s.elements(), 0.0f);
+        auto seq_p = mm->add_literal(migraphx::literal{pad_seq_s, pad_data});
+        auto seq = mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), seq_orig, seq_p);
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data(batch_size, static_cast<int32_t>(seq_len));
+        auto sql = mm->add_literal(seq_len_s, len_data);
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{
+            -0.120174,  0.043157,   0.117138,   -0.222188,  -0.175114,  -0.00543549, 0.178681,
+            -0.266999,  -0.182201,  -0.0232277, 0.235501,   -0.213485,  -0.185038,   -0.026845,
+            0.177273,   -0.0774616, 0.0,        0.0,        0.0,        0.0,         0.0,
+            0.0,        0.0,        0.0,        0.789732,   0.128538,   0.20909,     0.0553812,
+            0.928866,   0.113685,   0.220626,   -0.0432316, 0.960938,   0.133565,    0.269741,
+            0.130438,   0.946669,   0.0868676,  0.044508,   -0.373961,  0.0,         0.0,
+            0.0,        0.0,        0.0,        0.0,        0.0,        0.0,         -0.224905,
+            0.32421,    0.344048,   0.271694,   -0.063456,  0.148524,   0.05108,     -0.0234895,
+            -0.0252804, 0.267356,   0.146353,   0.0789186,  -0.0681467, 0.382748,    0.230211,
+            -0.161537,  0.0,        0.0,        0.0,        0.0,        0.0,         0.0,
+            0.0,        0.0};
+
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // variable sequence lengths
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data{3, 2, 1};
+        auto sql = mm->add_literal(seq_len_s, len_data);
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{
+            -0.126517,  0.0359124, 0.107453,  -0.0617278, -0.168327, 0.00023761, 0.167567,
+            -0.0621982, -0.204545, 0.0146403, 0.210057,   0.0296268, 0,          0,
+            0,          0,         0.911307,  0.11468,    0.114449,  0.0196755,  0.96657,
+            0.0755112,  0.0620917, -0.264845, 0,          0,         0,          0,
+            0,          0,         0,         0,          -0.102969, 0.295872,   0.515859,
+            0.246501,   0,         0,         0,          0,         0,          0,
+            0,          0,         0,         0,          0,         0};
+
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+
+    // reverse, 3 args, last cell output as program output
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+
+        auto hs  = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                  {"actv_func",
+                   migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                       migraphx::make_op("tanh"),
+                                                                       migraphx::make_op("tanh")})},
+                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                  {"clip", clip},
+                  {"input_forget", 0}}),
+            seq,
+            w,
+            r);
+        auto cell_output = mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), cell_output);
+
+        p.compile(migraphx::make_target("ref"));
+        auto hs_concat = p.eval({}).back();
+        std::vector<float> output_data;
+        hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        std::vector<float> output_data_gold{-0.443077,
+                                            -0.325425,
+                                            -0.249367,
+                                            -0.270812,
+                                            0.122913,
+                                            0.118537,
+                                            0.0370199,
+                                            -0.0164687,
+                                            -0.00754759,
+                                            0.141613,
+                                            0.348002,
+                                            0.667298};
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+    }
+}
+
+// lstm activation function test
+TEST_CASE(lstm_reverse_actv)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 1;
+    std::vector<float> w_data{
+        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
+        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
+        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
+        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
+        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
+        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
+        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
+        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
+        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
+        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
+        0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
+                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
+                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
+                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+                                 -0.4386, 0.4208,  0.0717,  0.3789};
 
     std::vector<float> input_data{
         -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
@@ -3601,127 +4811,94 @@ TEST_CASE(lstm_reverse)
     migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
     migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
     float clip = 0.0f;
-    // reverse, concatenation of hidden states as program output
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
 
-        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
-        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r = mm->add_literal(migraphx::literal{r_shape, r_data});
-        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
-        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
-        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
         mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
                  {"actv_func",
-                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
-                                                                      migraphx::make_op("tanh"),
-                                                                      migraphx::make_op("tanh")})},
+                  migraphx::to_value(
+                      std::vector<migraphx::operation>{migraphx::make_op("sigmoid")})},
                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
                  {"clip", clip},
                  {"input_forget", 0}}),
             seq,
             w,
-            r,
-            bias,
-            und,
-            ih,
-            ic,
-            pph);
+            r);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
-            -0.120174, 0.043157,  0.117138,   -0.222188, 0.789732,   0.128538,   0.20909,
-            0.0553812, -0.224905, 0.32421,    0.344048,  0.271694,   -0.175114,  -0.00543549,
-            0.178681,  -0.266999, 0.928866,   0.113685,  0.220626,   -0.0432316, -0.063456,
-            0.148524,  0.05108,   -0.0234895, -0.182201, -0.0232277, 0.235501,   -0.213485,
-            0.960938,  0.133565,  0.269741,   0.130438,  -0.0252804, 0.267356,   0.146353,
-            0.0789186, -0.185038, -0.026845,  0.177273,  -0.0774616, 0.946669,   0.0868676,
-            0.044508,  -0.373961, -0.0681467, 0.382748,  0.230211,   -0.161537};
+            0.246078, 0.199709, 0.303753, 0.301178, 0.264634, 0.304661, 0.349371, 0.288934,
+            0.405483, 0.445586, 0.515814, 0.473186, 0.301937, 0.264893, 0.254353, 0.269231,
+            0.359258, 0.400097, 0.288884, 0.247329, 0.276519, 0.264249, 0.1769,   0.23213,
+            0.310306, 0.262902, 0.276964, 0.295002, 0.373802, 0.366785, 0.419791, 0.393216,
+            0.262827, 0.371441, 0.369022, 0.298262, 0.334143, 0.309444, 0.174822, 0.251634,
+            0.244564, 0.214386, 0.185994, 0.226699, 0.28445,  0.376092, 0.338326, 0.259502};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
-    // reverse, sequence lengths are the same, but less than max_seq_lens
+    // reverse, 3 args, 2 actv functions
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto seq_orig = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
 
-        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
-        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w  = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r  = mm->add_literal(migraphx::literal{r_shape, r_data});
-        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
-        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
-
-        migraphx::shape pad_seq_s{migraphx::shape::float_type, {2, batch_size, input_size}};
-        std::vector<float> pad_data(pad_seq_s.elements(), 0.0f);
-        auto seq_p = mm->add_literal(migraphx::literal{pad_seq_s, pad_data});
-        auto seq = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), seq_orig, seq_p);
-        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
-        std::vector<int32_t> len_data(batch_size, static_cast<int32_t>(seq_len));
-        auto sql = mm->add_literal(seq_len_s, len_data);
-        mm->add_instruction(
+        auto hs = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
                  {"actv_func",
-                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
-                                                                      migraphx::make_op("tanh"),
-                                                                      migraphx::make_op("tanh")})},
+                  migraphx::to_value(std::vector<migraphx::operation>{
+                      migraphx::make_op("tanh"), migraphx::make_op("sigmoid")})},
                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
                  {"clip", clip},
                  {"input_forget", 0}}),
             seq,
             w,
-            r,
-            bias,
-            sql,
-            ih,
-            ic,
-            pph);
+            r);
+        mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{
-            -0.120174, 0.043157,  0.117138,   -0.222188, 0.789732,   0.128538,   0.20909,
-            0.0553812, -0.224905, 0.32421,    0.344048,  0.271694,   -0.175114,  -0.00543549,
-            0.178681,  -0.266999, 0.928866,   0.113685,  0.220626,   -0.0432316, -0.063456,
-            0.148524,  0.05108,   -0.0234895, -0.182201, -0.0232277, 0.235501,   -0.213485,
-            0.960938,  0.133565,  0.269741,   0.130438,  -0.0252804, 0.267356,   0.146353,
-            0.0789186, -0.185038, -0.026845,  0.177273,  -0.0774616, 0.946669,   0.0868676,
-            0.044508,  -0.373961, -0.0681467, 0.382748,  0.230211,   -0.161537,  0.0,
-            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
-            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
-            0.0,       0.0,       0.0,        0.0,       0.0,        0.0,        0.0,
-            0.0,       0.0};
+        std::vector<float> output_data_gold{-0.132123,
+                                            -0.37531,
+                                            -0.12943,
+                                            -0.00798307,
+                                            -0.133882,
+                                            -0.0251383,
+                                            0.0486486,
+                                            -0.0220606,
+                                            0.292495,
+                                            0.233866,
+                                            0.48646,
+                                            0.481844};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
-    // variable sequence lengths
+    // reverse, 3 args, seq_len = 1, concatenation of hidden states as program output
     {
+        seq_len = 1;
+        std::vector<float> input_data1{
+            -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930, -0.5221, -0.1331};
+        migraphx::shape in_shape1{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto seq = mm->add_literal(migraphx::literal{in_shape1, input_data1});
 
-        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
-        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r = mm->add_literal(migraphx::literal{r_shape, r_data});
-        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
-        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
-
-        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
-        std::vector<int32_t> len_data{3, 2, 1};
-        auto sql = mm->add_literal(seq_len_s, len_data);
         mm->add_instruction(
             migraphx::make_op(
                 "lstm",
@@ -3735,35 +4912,113 @@ TEST_CASE(lstm_reverse)
                  {"input_forget", 0}}),
             seq,
             w,
-            r,
-            bias,
-            sql,
-            ih,
-            ic,
-            pph);
+            r);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{
-            -0.126517, 0.0359124,  0.107453, -0.0617278, 0.911307,  0.11468,   0.114449,
-            0.0196755, -0.102969,  0.295872, 0.515859,   0.246501,  -0.168327, 0.00023761,
-            0.167567,  -0.0621982, 0.96657,  0.0755112,  0.0620917, -0.264845, 0,
-            0,         0,          0,        -0.204545,  0.0146403, 0.210057,  0.0296268,
-            0,         0,          0,        0,          0,         0,         0,
-            0,         0,          0,        0,          0,         0,         0,
-            0,         0,          0,        0,          0,         0};
+        std::vector<float> output_data_gold{-0.104351,
+                                            -0.0471426,
+                                            -0.0905753,
+                                            0.01506,
+                                            0.059797,
+                                            0.104239,
+                                            -0.0266768,
+                                            0.0727547,
+                                            -0.146298,
+                                            0.070535,
+                                            0.327809,
+                                            0.407388};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
+}
 
-    // reverse, 3 args, last cell output as program output
+TEST_CASE(lstm_bidirectional)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 2;
+    std::vector<float> w_data{
+        0.1236,  -0.3942, 0.4149,  0.0795,  0.4934,  -0.2858, 0.2602,  -0.3098, 0.0567,  0.3344,
+        0.3607,  -0.0551, 0.4952,  0.3799,  0.0630,  -0.3532, 0.0023,  -0.0592, 0.4267,  0.2382,
+        -0.0784, -0.0032, -0.2476, -0.0206, -0.4963, 0.4837,  0.0827,  0.0123,  -0.1203, -0.0279,
+        -0.0049, 0.4721,  -0.3564, -0.1286, 0.4090,  -0.0504, 0.0575,  -0.2138, 0.1071,  0.1976,
+        -0.0758, 0.0139,  -0.0761, 0.3991,  -0.2965, -0.4845, -0.1496, 0.3285,  -0.2763, -0.4715,
+        -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,  -0.1843, 0.2351,
+        0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914, -0.1480, 0.3734,
+        -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401, 0.1486,  0.1346,
+        0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,  -0.4462, 0.0729,
+        0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        0.1237,  0.1229,  -0.0766, -0.1144, -0.1186, 0.2922,  0.2478,  0.3159,  -0.0522, 0.1685,
+        -0.4621, 0.1728,  0.0670,  -0.2458, -0.3835, -0.4589, -0.3109, 0.4908,  -0.0133, -0.1858,
+        -0.0590, -0.0347, -0.2353, -0.0671, -0.3812, -0.0004, -0.1432, 0.2406,  0.1033,  -0.0265,
+        -0.3902, 0.0755,  0.3733,  0.4383,  -0.3140, 0.2537,  -0.1818, -0.4127, 0.3506,  0.2562,
+        0.2926,  0.1620,  -0.4849, -0.4861, 0.4426,  0.2106,  -0.0005, 0.4418,  -0.2926, -0.3100,
+        0.1500,  -0.0362, -0.3801, -0.0065, -0.0631, 0.1277,  0.2315,  0.4087,  -0.3963, -0.4161,
+        -0.2169, -0.1344, 0.3468,  -0.2260, -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,
+        0.2824,  0.4775,  -0.2729, -0.4707, 0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,
+        0.3794,  -0.1069, -0.3049, 0.1430,  -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,
+        0.2891,  0.1786,  -0.3274, 0.2365,  0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154,
+        0.2851,  -0.3930, -0.1174, 0.4360,  0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459,
+        -0.2991, -0.2624, 0.4194,  -0.3291, -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584,
+        0.2596,  0.2871,  -0.3509, -0.1910, 0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{
+        0.0088,  0.1183,  0.1642,  -0.2631, -0.1330, -0.4008, 0.3881,  -0.4407, -0.2760, 0.1274,
+        -0.0083, -0.2885, 0.3949,  -0.0182, 0.4445,  0.3477,  0.2266,  0.3423,  -0.0674, -0.4067,
+        0.0807,  0.1109,  -0.2036, 0.1782,  -0.2467, -0.0730, -0.4216, 0.0316,  -0.3025, 0.3637,
+        -0.3181, -0.4655, -0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,  -0.1823,
+        0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,  0.4755,  -0.4794, 0.2167,  -0.4474,
+        -0.3139, 0.1018,  0.4470,  -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+        -0.4386, 0.4208,  0.0717,  0.3789};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
+        -0.0910, 1.2122, -0.1952, 0.4661,  0.6494,  2.1332,  -1.0972, 0.9816,  0.1122,
+        0.3577,  1.3508, -0.5366, 1.7449,  0.5483,  -0.0701, -0.4100, -2.2344, 0.3685,
+        0.4583,  2.3794, 1.0372,  -0.8887, 0.7892,  -0.4012, -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.9104,  -1.9004, 0.3337,  0.5741, 0.5671, 0.0458,
+                               0.4514,  -0.8968, -0.9201, 0.1962, 0.5771, -0.5332,
+                               1.5289,  1.0986,  0.6091,  1.6462, 0.8720, 0.5349,
+                               -0.1962, -1.7416, -0.9912, 1.2831, 1.0896, -0.6959};
+
+    std::vector<float> ic_data{0.9569,  -0.5981, 1.1312,  1.0945,  1.1055,  -0.1212,
+                               -0.9097, 0.7831,  -1.6991, -1.9498, -1.2567, -0.4114,
+                               -0.8323, 0.3998,  0.1831,  0.5938,  2.7096,  -0.1790,
+                               0.0022,  -0.8040, 0.1578,  0.0567,  0.8069,  -0.5141};
+
+    std::vector<float> pph_data{1.84369764,  0.68413646, -0.44892886, -1.50904413, 0.3860796,
+                                -0.52186625, 1.08474445, -1.80867321, 1.32594529,  0.4336262,
+                                -0.83699064, 0.49162736, -0.8271,     -0.5683,     0.4562,
+                                -1.2545,     1.2729,     -0.4082,     -0.4392,     -0.9406,
+                                0.7794,      1.8194,     -0.5811,     0.2166};
+    float clip = 0.0f;
+    migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+
+    // concatenation of hidden states as program output
     {
         migraphx::program p;
         auto* mm  = p.get_main_module();
         auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
-        auto hs  = mm->add_instruction(
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+        mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
@@ -3771,242 +5026,177 @@ TEST_CASE(lstm_reverse)
                   migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
                                                                       migraphx::make_op("tanh"),
                                                                       migraphx::make_op("tanh")})},
-                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
                  {"clip", clip},
                  {"input_forget", 0}}),
             seq,
             w,
-            r);
-        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
-
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{-0.443077,
-                                            -0.325425,
-                                            -0.249367,
-                                            -0.270812,
-                                            0.122913,
-                                            0.118537,
-                                            0.0370199,
-                                            -0.0164687,
-                                            -0.00754759,
-                                            0.141613,
-                                            0.348002,
-                                            0.667298};
+        std::vector<float> output_data_gold{
+            0.079753,   -0.289854,  0.160043,    0.115056,   0.294074,   -0.0319677, -0.0955337,
+            0.104168,   0.022618,   -0.121195,   -0.4065,    -0.252054,  -0.120174,  0.043157,
+            0.117138,   -0.222188,  0.789732,    0.128538,   0.20909,    0.0553812,  -0.224905,
+            0.32421,    0.344048,   0.271694,    0.186991,   -0.0624168, 0.205513,   0.0836373,
+            0.421857,   0.0459771,  -0.144955,   0.0720673,  -0.0300906, -0.0890598, -0.135266,
+            -0.0413375, -0.175114,  -0.00543549, 0.178681,   -0.266999,  0.928866,   0.113685,
+            0.220626,   -0.0432316, -0.063456,   0.148524,   0.05108,    -0.0234895, 0.0459032,
+            0.0414126,  0.272303,   0.0393149,   0.218258,   0.0944405,  0.0431211,  -0.132394,
+            0.103489,   0.0142918,  -0.123408,   0.0401075,  -0.182201,  -0.0232277, 0.235501,
+            -0.213485,  0.960938,   0.133565,    0.269741,   0.130438,   -0.0252804, 0.267356,
+            0.146353,   0.0789186,  -0.058052,   0.0795391,  0.266617,   -0.0128746, 0.0309878,
+            0.0971544,  0.149294,   -0.0492549,  0.187761,   0.0501726,  -0.121584,  0.0606723,
+            -0.185038,  -0.026845,  0.177273,    -0.0774616, 0.946669,   0.0868676,  0.044508,
+            -0.373961,  -0.0681467, 0.382748,    0.230211,   -0.161537};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
-    // reverse, 3 args, 0 actv function
+    // last hidden state as program output
     {
         migraphx::program p;
         auto* mm  = p.get_main_module();
         auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
         auto hs   = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
-                  {"actv_func", {}},
-                  {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                   {"actv_func",
+                    migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                        migraphx::make_op("tanh"),
+                                                                        migraphx::make_op("tanh")})},
+                   {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
                    {"clip", clip},
                    {"input_forget", 0}}),
             seq,
             w,
-            r);
-        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
-
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{-0.443077,
-                                            -0.325425,
-                                            -0.249367,
-                                            -0.270812,
-                                            0.122913,
-                                            0.118537,
-                                            0.0370199,
-                                            -0.0164687,
-                                            -0.00754759,
-                                            0.141613,
-                                            0.348002,
-                                            0.667298};
+        std::vector<float> output_data_gold{
+            -0.058052, 0.0795391, 0.266617,  -0.0128746, 0.0309878, 0.0971544, 0.149294, -0.0492549,
+            0.187761,  0.0501726, -0.121584, 0.0606723,  -0.120174, 0.043157,  0.117138, -0.222188,
+            0.789732,  0.128538,  0.20909,   0.0553812,  -0.224905, 0.32421,   0.344048, 0.271694};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
-}
-
-// lstm activation function test
-TEST_CASE(lstm_reverse_actv)
-{
-    std::size_t batch_size  = 3;
-    std::size_t seq_len     = 4;
-    std::size_t hidden_size = 4;
-    std::size_t input_size  = 3;
-    std::size_t num_dirct   = 1;
-    std::vector<float> w_data{
-        -0.2763, -0.4715, -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,
-        -0.1843, 0.2351,  0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914,
-        -0.1480, 0.3734,  -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401,
-        0.1486,  0.1346,  0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,
-        -0.4462, 0.0729,  0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
-
-    std::vector<float> r_data{
-        -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,  0.2824,  0.4775,  -0.2729, -0.4707,
-        0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,  0.3794,  -0.1069, -0.3049, 0.1430,
-        -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,  0.2891,  0.1786,  -0.3274, 0.2365,
-        0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154, 0.2851,  -0.3930, -0.1174, 0.4360,
-        0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459, -0.2991, -0.2624, 0.4194,  -0.3291,
-        -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584, 0.2596,  0.2871,  -0.3509, -0.1910,
-        0.3987,  -0.1687, -0.0032, -0.1038};
-
-    std::vector<float> bias_data{-0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,
-                                 -0.1823, 0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,
-                                 0.4755,  -0.4794, 0.2167,  -0.4474, -0.3139, 0.1018,  0.4470,
-                                 -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
-                                 -0.4386, 0.4208,  0.0717,  0.3789};
-
-    std::vector<float> input_data{
-        -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
-        -0.0910, 1.2122, -0.1952, 0.4661,  0.6494,  2.1332,  -1.0972, 0.9816,  0.1122,
-        0.3577,  1.3508, -0.5366, 1.7449,  0.5483,  -0.0701, -0.4100, -2.2344, 0.3685,
-        0.4583,  2.3794, 1.0372,  -0.8887, 0.7892,  -0.4012, -0.2818, -2.3374, 1.5310};
-
-    std::vector<float> ih_data{1.5289,
-                               1.0986,
-                               0.6091,
-                               1.6462,
-                               0.8720,
-                               0.5349,
-                               -0.1962,
-                               -1.7416,
-                               -0.9912,
-                               1.2831,
-                               1.0896,
-                               -0.6959};
-
-    std::vector<float> ic_data{-0.8323,
-                               0.3998,
-                               0.1831,
-                               0.5938,
-                               2.7096,
-                               -0.1790,
-                               0.0022,
-                               -0.8040,
-                               0.1578,
-                               0.0567,
-                               0.8069,
-                               -0.5141};
-
-    std::vector<float> pph_data{-0.8271,
-                                -0.5683,
-                                0.4562,
-                                -1.2545,
-                                1.2729,
-                                -0.4082,
-                                -0.4392,
-                                -0.9406,
-                                0.7794,
-                                1.8194,
-                                -0.5811,
-                                0.2166};
 
-    migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
-    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
-    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
-    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
-    migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
-    migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
-    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
-    float clip = 0.0f;
+    // last cell output as program output
     {
         migraphx::program p;
         auto* mm  = p.get_main_module();
         auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
-
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
         auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
-        mm->add_instruction(
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+        auto hs   = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
                    {"actv_func",
-                  migraphx::to_value(
-                      std::vector<migraphx::operation>{migraphx::make_op("sigmoid")})},
-                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                    migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                        migraphx::make_op("tanh"),
+                                                                        migraphx::make_op("tanh")})},
+                   {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
                    {"clip", clip},
                    {"input_forget", 0}}),
             seq,
             w,
-            r);
+            r,
+            bias,
+            und,
+            ih,
+            ic,
+            pph);
+        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
-            0.246078, 0.199709, 0.303753, 0.301178, 0.264634, 0.304661, 0.349371, 0.288934,
-            0.405483, 0.445586, 0.515814, 0.473186, 0.301937, 0.264893, 0.254353, 0.269231,
-            0.359258, 0.400097, 0.288884, 0.247329, 0.276519, 0.264249, 0.1769,   0.23213,
-            0.310306, 0.262902, 0.276964, 0.295002, 0.373802, 0.366785, 0.419791, 0.393216,
-            0.262827, 0.371441, 0.369022, 0.298262, 0.334143, 0.309444, 0.174822, 0.251634,
-            0.244564, 0.214386, 0.185994, 0.226699, 0.28445,  0.376092, 0.338326, 0.259502};
+            -0.077353, 0.245616, 0.361023,  -0.0443759, 0.0685243, 0.20465,  0.277867, -0.112934,
+            0.67312,   0.120508, -0.726968, 0.113845,   -0.889294, 0.182463, 0.186512, -0.402334,
+            1.48161,   0.524116, 0.347113,  0.181813,   -0.434265, 0.747833, 0.416053, 0.558713};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
-    // reverse, 3 args, 2 actv functions
+    // 3 args, concatenation of hidden states as program output
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
-
         auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
-        auto hs = mm->add_instruction(
+        mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
                  {"actv_func",
-                  migraphx::to_value(std::vector<migraphx::operation>{
-                      migraphx::make_op("tanh"), migraphx::make_op("sigmoid")})},
-                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
                  {"clip", clip},
                  {"input_forget", 0}}),
             seq,
             w,
             r);
-        mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{-0.132123,
-                                            -0.37531,
-                                            -0.12943,
-                                            -0.00798307,
-                                            -0.133882,
-                                            -0.0251383,
-                                            0.0486486,
-                                            -0.0220606,
-                                            0.292495,
-                                            0.233866,
-                                            0.48646,
-                                            0.481844};
+        std::vector<float> output_data_gold{
+            -0.0327039, -0.0543852, 0.114378,  -0.0768855, 0.0319021,   -0.00298698, -0.0623361,
+            0.0598866,  0.101585,   0.0687269, -0.161725,  -0.25617,    -0.162851,   -0.102647,
+            -0.113827,  -0.142818,  0.0513685, 0.0547876,  0.0201981,   -0.00808453, -0.00520328,
+            0.0945081,  0.264123,   0.410805,  -0.0786602, -0.0613048,  0.179592,    -0.071286,
+            0.074206,   0.0124086,  -0.139544, 0.108016,   -0.00973633, -0.0552699,  0.0252681,
+            -0.0562072, -0.123496,  -0.153616, -0.032874,  -0.195349,   0.0192675,   -0.108636,
+            0.098927,   -0.140733,  0.162602,  0.0143099,  -0.0455534,  0.0151574,   -0.102509,
+            -0.0372696, 0.252296,   -0.144544, 0.00496085, 0.0662588,   -0.048577,   -0.187329,
+            0.0855831,  -0.0171894, -0.140202, 0.0828391,  -0.1073,     -0.150145,   0.015065,
+            -0.192699,  -0.112764,  -0.120496, 0.155754,   0.148256,    0.208491,    0.348432,
+            0.0291103,  0.230275,   -0.165194, -0.0372928, 0.273786,    -0.100877,   -0.0458544,
+            -0.0401315, 0.0737483,  -0.064505, 0.136898,   0.00160891,  -0.184812,   0.147774,
+            -0.021205,  -0.125423,  0.0206439, -0.187097,  -0.0051453,  -0.0767618,  -0.0735348,
+            -0.0826436, 0.214159,   0.262295,  0.0247127,  0.14472};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
-    // reverse, 3 args, seq_len = 1, concatenation of hidden states as program output
+    // sequence length is 1, contenation of hidden state as program output
     {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
         seq_len  = 1;
+        migraphx::shape in_shape1{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
         std::vector<float> input_data1{
             -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930, -0.5221, -0.1331};
-        migraphx::shape in_shape1{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
-
-        migraphx::program p;
-        auto* mm = p.get_main_module();
         auto seq = mm->add_literal(migraphx::literal{in_shape1, input_data1});
-
         auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
         mm->add_instruction(
@@ -4017,7 +5207,7 @@ TEST_CASE(lstm_reverse_actv)
                   migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
                                                                       migraphx::make_op("tanh"),
                                                                       migraphx::make_op("tanh")})},
-                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::reverse)},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
                  {"clip", clip},
                  {"input_forget", 0}}),
             seq,
@@ -4027,23 +5217,16 @@ TEST_CASE(lstm_reverse_actv)
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
-        std::vector<float> output_data_gold{-0.104351,
-                                            -0.0471426,
-                                            -0.0905753,
-                                            0.01506,
-                                            0.059797,
-                                            0.104239,
-                                            -0.0266768,
-                                            0.0727547,
-                                            -0.146298,
-                                            0.070535,
-                                            0.327809,
-                                            0.407388};
+        std::vector<float> output_data_gold{
+            -0.0327039, -0.0543852, 0.114378,   -0.0768855, 0.0319021, -0.00298698,
+            -0.0623361, 0.0598866,  0.101585,   0.0687269,  -0.161725, -0.25617,
+            -0.104351,  -0.0471426, -0.0905753, 0.01506,    0.059797,  0.104239,
+            -0.0266768, 0.0727547,  -0.146298,  0.070535,   0.327809,  0.407388};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 }
 
-TEST_CASE(lstm_bidirectional)
+TEST_CASE(lstm_bidirectional_layout)
 {
     std::size_t batch_size  = 3;
     std::size_t seq_len     = 4;
@@ -4087,20 +5270,20 @@ TEST_CASE(lstm_bidirectional)
         -0.4386, 0.4208,  0.0717,  0.3789};
 
     std::vector<float> input_data{
-        -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930,  -0.5221, -0.1331,
-        -0.0910, 1.2122, -0.1952, 0.4661,  0.6494,  2.1332,  -1.0972, 0.9816,  0.1122,
-        0.3577,  1.3508, -0.5366, 1.7449,  0.5483,  -0.0701, -0.4100, -2.2344, 0.3685,
-        0.4583,  2.3794, 1.0372,  -0.8887, 0.7892,  -0.4012, -0.2818, -2.3374, 1.5310};
+        -0.5516, 0.2391, -1.6951, -0.0910, 1.2122,  -0.1952, 0.3577,  1.3508,  -0.5366,
+        0.4583,  2.3794, 1.0372,  -0.4313, -0.9730, -0.2005, 0.4661,  0.6494,  2.1332,
+        1.7449,  0.5483, -0.0701, -0.8887, 0.7892,  -0.4012, 2.3930,  -0.5221, -0.1331,
+        -1.0972, 0.9816, 0.1122,  -0.4100, -2.2344, 0.3685,  -0.2818, -2.3374, 1.5310};
 
-    std::vector<float> ih_data{1.9104,  -1.9004, 0.3337,  0.5741, 0.5671, 0.0458,
-                               0.4514,  -0.8968, -0.9201, 0.1962, 0.5771, -0.5332,
-                               1.5289,  1.0986,  0.6091,  1.6462, 0.8720, 0.5349,
-                               -0.1962, -1.7416, -0.9912, 1.2831, 1.0896, -0.6959};
+    std::vector<float> ih_data{1.9104, -1.9004, 0.3337,  0.5741,  1.5289,  1.0986,
+                               0.6091, 1.6462,  0.5671,  0.0458,  0.4514,  -0.8968,
+                               0.8720, 0.5349,  -0.1962, -1.7416, -0.9201, 0.1962,
+                               0.5771, -0.5332, -0.9912, 1.2831,  1.0896,  -0.6959};
 
-    std::vector<float> ic_data{0.9569,  -0.5981, 1.1312,  1.0945,  1.1055,  -0.1212,
-                               -0.9097, 0.7831,  -1.6991, -1.9498, -1.2567, -0.4114,
-                               -0.8323, 0.3998,  0.1831,  0.5938,  2.7096,  -0.1790,
-                               0.0022,  -0.8040, 0.1578,  0.0567,  0.8069,  -0.5141};
+    std::vector<float> ic_data{0.9569,  -0.5981, 1.1312, 1.0945,  -0.8323, 0.3998,
+                               0.1831,  0.5938,  1.1055, -0.1212, -0.9097, 0.7831,
+                               2.7096,  -0.1790, 0.0022, -0.8040, -1.6991, -1.9498,
+                               -1.2567, -0.4114, 0.1578, 0.0567,  0.8069,  -0.5141};
 
     std::vector<float> pph_data{1.84369764,  0.68413646, -0.44892886, -1.50904413, 0.3860796,
                                 -0.52186625, 1.08474445, -1.80867321, 1.32594529,  0.4336262,
@@ -4108,12 +5291,12 @@ TEST_CASE(lstm_bidirectional)
                                 -1.2545,     1.2729,     -0.4082,     -0.4392,     -0.9406,
                                 0.7794,      1.8194,     -0.5811,     0.2166};
     float clip = 0.0f;
-    migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+    migraphx::shape in_shape{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
     migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
     migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
     migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
-    migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
-    migraphx::shape ic_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
     migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
 
     // concatenation of hidden states as program output
@@ -4128,7 +5311,13 @@ TEST_CASE(lstm_bidirectional)
         auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
         auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
         auto und  = mm->add_instruction(migraphx::make_op("undefined"));
-        mm->add_instruction(
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
@@ -4147,25 +5336,29 @@ TEST_CASE(lstm_bidirectional)
             ih,
             ic,
             pph);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
         std::vector<float> output_data_gold{
-            0.079753,   -0.289854,  0.160043,    0.115056,   0.294074,   -0.0319677, -0.0955337,
-            0.104168,   0.022618,   -0.121195,   -0.4065,    -0.252054,  -0.120174,  0.043157,
-            0.117138,   -0.222188,  0.789732,    0.128538,   0.20909,    0.0553812,  -0.224905,
-            0.32421,    0.344048,   0.271694,    0.186991,   -0.0624168, 0.205513,   0.0836373,
-            0.421857,   0.0459771,  -0.144955,   0.0720673,  -0.0300906, -0.0890598, -0.135266,
-            -0.0413375, -0.175114,  -0.00543549, 0.178681,   -0.266999,  0.928866,   0.113685,
-            0.220626,   -0.0432316, -0.063456,   0.148524,   0.05108,    -0.0234895, 0.0459032,
-            0.0414126,  0.272303,   0.0393149,   0.218258,   0.0944405,  0.0431211,  -0.132394,
-            0.103489,   0.0142918,  -0.123408,   0.0401075,  -0.182201,  -0.0232277, 0.235501,
-            -0.213485,  0.960938,   0.133565,    0.269741,   0.130438,   -0.0252804, 0.267356,
-            0.146353,   0.0789186,  -0.058052,   0.0795391,  0.266617,   -0.0128746, 0.0309878,
-            0.0971544,  0.149294,   -0.0492549,  0.187761,   0.0501726,  -0.121584,  0.0606723,
-            -0.185038,  -0.026845,  0.177273,    -0.0774616, 0.946669,   0.0868676,  0.044508,
-            -0.373961,  -0.0681467, 0.382748,    0.230211,   -0.161537};
+            0.079753,   -0.289854,  0.160043,   0.115056,   -0.120174, 0.043157,   0.117138,
+            -0.222188,  0.186991,   -0.0624168, 0.205513,   0.0836373, -0.175114,  -0.00543549,
+            0.178681,   -0.266999,  0.0459032,  0.0414126,  0.272303,  0.0393149,  -0.182201,
+            -0.0232277, 0.235501,   -0.213485,  -0.058052,  0.0795391, 0.266617,   -0.0128746,
+            -0.185038,  -0.026845,  0.177273,   -0.0774616, 0.294074,  -0.0319677, -0.0955337,
+            0.104168,   0.789732,   0.128538,   0.20909,    0.0553812, 0.421857,   0.0459771,
+            -0.144955,  0.0720673,  0.928866,   0.113685,   0.220626,  -0.0432316, 0.218258,
+            0.0944405,  0.0431211,  -0.132394,  0.960938,   0.133565,  0.269741,   0.130438,
+            0.0309878,  0.0971544,  0.149294,   -0.0492549, 0.946669,  0.0868676,  0.044508,
+            -0.373961,  0.022618,   -0.121195,  -0.4065,    -0.252054, -0.224905,  0.32421,
+            0.344048,   0.271694,   -0.0300906, -0.0890598, -0.135266, -0.0413375, -0.063456,
+            0.148524,   0.05108,    -0.0234895, 0.103489,   0.0142918, -0.123408,  0.0401075,
+            -0.0252804, 0.267356,   0.146353,   0.0789186,  0.187761,  0.0501726,  -0.121584,
+            0.0606723,  -0.0681467, 0.382748,   0.230211,   -0.161537};
+
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
@@ -4181,6 +5374,12 @@ TEST_CASE(lstm_bidirectional)
         auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
         auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
         auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
         auto hs   = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
@@ -4200,15 +5399,17 @@ TEST_CASE(lstm_bidirectional)
             ih,
             ic,
             pph);
-        mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        auto last_output = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), last_output);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
-            -0.058052, 0.0795391, 0.266617,  -0.0128746, 0.0309878, 0.0971544, 0.149294, -0.0492549,
-            0.187761,  0.0501726, -0.121584, 0.0606723,  -0.120174, 0.043157,  0.117138, -0.222188,
-            0.789732,  0.128538,  0.20909,   0.0553812,  -0.224905, 0.32421,   0.344048, 0.271694};
+            -0.058052, 0.0795391, 0.266617,  -0.0128746, -0.120174, 0.043157, 0.117138, -0.222188,
+            0.0309878, 0.0971544, 0.149294,  -0.0492549, 0.789732,  0.128538, 0.20909,  0.0553812,
+            0.187761,  0.0501726, -0.121584, 0.0606723,  -0.224905, 0.32421,  0.344048, 0.271694};
+
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
@@ -4224,6 +5425,12 @@ TEST_CASE(lstm_bidirectional)
         auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
         auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
         auto und  = mm->add_instruction(migraphx::make_op("undefined"));
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
         auto hs   = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
@@ -4243,15 +5450,17 @@ TEST_CASE(lstm_bidirectional)
             ih,
             ic,
             pph);
-        mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+        auto cell_output = mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), cell_output);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
         std::vector<float> output_data_gold{
-            -0.077353, 0.245616, 0.361023,  -0.0443759, 0.0685243, 0.20465,  0.277867, -0.112934,
-            0.67312,   0.120508, -0.726968, 0.113845,   -0.889294, 0.182463, 0.186512, -0.402334,
-            1.48161,   0.524116, 0.347113,  0.181813,   -0.434265, 0.747833, 0.416053, 0.558713};
+            -0.077353, 0.245616, 0.361023,  -0.0443759, -0.889294, 0.182463, 0.186512, -0.402334,
+            0.0685243, 0.20465,  0.277867,  -0.112934,  1.48161,   0.524116, 0.347113, 0.181813,
+            0.67312,   0.120508, -0.726968, 0.113845,   -0.434265, 0.747833, 0.416053, 0.558713};
+
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
@@ -4262,7 +5471,11 @@ TEST_CASE(lstm_bidirectional)
         auto seq = mm->add_literal(migraphx::literal{in_shape, input_data});
         auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
-        mm->add_instruction(
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+
+        auto hs = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
@@ -4276,25 +5489,28 @@ TEST_CASE(lstm_bidirectional)
             seq,
             w,
             r);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
         std::vector<float> output_data_gold{
-            -0.0327039, -0.0543852, 0.114378,  -0.0768855, 0.0319021,   -0.00298698, -0.0623361,
-            0.0598866,  0.101585,   0.0687269, -0.161725,  -0.25617,    -0.162851,   -0.102647,
-            -0.113827,  -0.142818,  0.0513685, 0.0547876,  0.0201981,   -0.00808453, -0.00520328,
-            0.0945081,  0.264123,   0.410805,  -0.0786602, -0.0613048,  0.179592,    -0.071286,
-            0.074206,   0.0124086,  -0.139544, 0.108016,   -0.00973633, -0.0552699,  0.0252681,
-            -0.0562072, -0.123496,  -0.153616, -0.032874,  -0.195349,   0.0192675,   -0.108636,
-            0.098927,   -0.140733,  0.162602,  0.0143099,  -0.0455534,  0.0151574,   -0.102509,
-            -0.0372696, 0.252296,   -0.144544, 0.00496085, 0.0662588,   -0.048577,   -0.187329,
-            0.0855831,  -0.0171894, -0.140202, 0.0828391,  -0.1073,     -0.150145,   0.015065,
-            -0.192699,  -0.112764,  -0.120496, 0.155754,   0.148256,    0.208491,    0.348432,
-            0.0291103,  0.230275,   -0.165194, -0.0372928, 0.273786,    -0.100877,   -0.0458544,
-            -0.0401315, 0.0737483,  -0.064505, 0.136898,   0.00160891,  -0.184812,   0.147774,
-            -0.021205,  -0.125423,  0.0206439, -0.187097,  -0.0051453,  -0.0767618,  -0.0735348,
-            -0.0826436, 0.214159,   0.262295,  0.0247127,  0.14472};
+            -0.0327039, -0.0543852, 0.114378,    -0.0768855, -0.162851,   -0.102647,   -0.113827,
+            -0.142818,  -0.0786602, -0.0613048,  0.179592,   -0.071286,   -0.123496,   -0.153616,
+            -0.032874,  -0.195349,  -0.102509,   -0.0372696, 0.252296,    -0.144544,   -0.1073,
+            -0.150145,  0.015065,   -0.192699,   -0.165194,  -0.0372928,  0.273786,    -0.100877,
+            -0.021205,  -0.125423,  0.0206439,   -0.187097,  0.0319021,   -0.00298698, -0.0623361,
+            0.0598866,  0.0513685,  0.0547876,   0.0201981,  -0.00808453, 0.074206,    0.0124086,
+            -0.139544,  0.108016,   0.0192675,   -0.108636,  0.098927,    -0.140733,   0.00496085,
+            0.0662588,  -0.048577,  -0.187329,   -0.112764,  -0.120496,   0.155754,    0.148256,
+            -0.0458544, -0.0401315, 0.0737483,   -0.064505,  -0.0051453,  -0.0767618,  -0.0735348,
+            -0.0826436, 0.101585,   0.0687269,   -0.161725,  -0.25617,    -0.00520328, 0.0945081,
+            0.264123,   0.410805,   -0.00973633, -0.0552699, 0.0252681,   -0.0562072,  0.162602,
+            0.0143099,  -0.0455534, 0.0151574,   0.0855831,  -0.0171894,  -0.140202,   0.0828391,
+            0.208491,   0.348432,   0.0291103,   0.230275,   0.136898,    0.00160891,  -0.184812,
+            0.147774,   0.214159,   0.262295,    0.0247127,  0.14472};
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 
@@ -4303,13 +5519,17 @@ TEST_CASE(lstm_bidirectional)
         migraphx::program p;
         auto* mm = p.get_main_module();
         seq_len  = 1;
-        migraphx::shape in_shape1{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+        migraphx::shape in_shape1{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
         std::vector<float> input_data1{
             -0.5516, 0.2391, -1.6951, -0.4313, -0.9730, -0.2005, 2.3930, -0.5221, -0.1331};
         auto seq = mm->add_literal(migraphx::literal{in_shape1, input_data1});
         auto w   = mm->add_literal(migraphx::literal{w_shape, w_data});
         auto r   = mm->add_literal(migraphx::literal{r_shape, r_data});
-        mm->add_instruction(
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+
+        auto hs = mm->add_instruction(
             migraphx::make_op(
                 "lstm",
                 {{"hidden_size", hidden_size},
@@ -4323,15 +5543,19 @@ TEST_CASE(lstm_bidirectional)
             seq,
             w,
             r);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
         p.compile(migraphx::make_target("ref"));
         auto hs_concat = p.eval({}).back();
         std::vector<float> output_data;
         hs_concat.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+
         std::vector<float> output_data_gold{
-            -0.0327039, -0.0543852, 0.114378,   -0.0768855, 0.0319021, -0.00298698,
-            -0.0623361, 0.0598866,  0.101585,   0.0687269,  -0.161725, -0.25617,
-            -0.104351,  -0.0471426, -0.0905753, 0.01506,    0.059797,  0.104239,
-            -0.0266768, 0.0727547,  -0.146298,  0.070535,   0.327809,  0.407388};
+            -0.0327039, -0.0543852, 0.114378,   -0.0768855,  -0.104351,  -0.0471426,
+            -0.0905753, 0.01506,    0.0319021,  -0.00298698, -0.0623361, 0.0598866,
+            0.059797,   0.104239,   -0.0266768, 0.0727547,   0.101585,   0.0687269,
+            -0.161725,  -0.25617,   -0.146298,  0.070535,    0.327809,   0.407388};
+
         EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
     }
 }
@@ -4577,6 +5801,275 @@ TEST_CASE(lstm_bidirectional_var_seq_lens)
     }
 }
 
+TEST_CASE(lstm_bidirectional_var_seq_lens_layout)
+{
+    std::size_t batch_size  = 3;
+    std::size_t seq_len     = 4;
+    std::size_t hidden_size = 4;
+    std::size_t input_size  = 3;
+    std::size_t num_dirct   = 2;
+    std::vector<float> w_data{
+        0.1236,  -0.3942, 0.4149,  0.0795,  0.4934,  -0.2858, 0.2602,  -0.3098, 0.0567,  0.3344,
+        0.3607,  -0.0551, 0.4952,  0.3799,  0.0630,  -0.3532, 0.0023,  -0.0592, 0.4267,  0.2382,
+        -0.0784, -0.0032, -0.2476, -0.0206, -0.4963, 0.4837,  0.0827,  0.0123,  -0.1203, -0.0279,
+        -0.0049, 0.4721,  -0.3564, -0.1286, 0.4090,  -0.0504, 0.0575,  -0.2138, 0.1071,  0.1976,
+        -0.0758, 0.0139,  -0.0761, 0.3991,  -0.2965, -0.4845, -0.1496, 0.3285,  -0.2763, -0.4715,
+        -0.3010, -0.2306, -0.2283, -0.2656, 0.2035,  0.3570,  -0.1499, 0.4390,  -0.1843, 0.2351,
+        0.3357,  0.1217,  0.1401,  0.3300,  -0.0429, 0.3266,  0.4834,  -0.3914, -0.1480, 0.3734,
+        -0.0372, -0.1746, 0.0550,  0.4177,  -0.1332, 0.4391,  -0.3287, -0.4401, 0.1486,  0.1346,
+        0.1048,  -0.4361, 0.0886,  -0.3840, -0.2730, -0.1710, 0.3274,  0.0169,  -0.4462, 0.0729,
+        0.3983,  -0.0669, 0.0756,  0.4150,  -0.4684, -0.2522};
+
+    std::vector<float> r_data{
+        0.1237,  0.1229,  -0.0766, -0.1144, -0.1186, 0.2922,  0.2478,  0.3159,  -0.0522, 0.1685,
+        -0.4621, 0.1728,  0.0670,  -0.2458, -0.3835, -0.4589, -0.3109, 0.4908,  -0.0133, -0.1858,
+        -0.0590, -0.0347, -0.2353, -0.0671, -0.3812, -0.0004, -0.1432, 0.2406,  0.1033,  -0.0265,
+        -0.3902, 0.0755,  0.3733,  0.4383,  -0.3140, 0.2537,  -0.1818, -0.4127, 0.3506,  0.2562,
+        0.2926,  0.1620,  -0.4849, -0.4861, 0.4426,  0.2106,  -0.0005, 0.4418,  -0.2926, -0.3100,
+        0.1500,  -0.0362, -0.3801, -0.0065, -0.0631, 0.1277,  0.2315,  0.4087,  -0.3963, -0.4161,
+        -0.2169, -0.1344, 0.3468,  -0.2260, -0.4564, -0.4432, 0.1605,  0.4387,  0.0034,  0.4116,
+        0.2824,  0.4775,  -0.2729, -0.4707, 0.1363,  0.2218,  0.0559,  0.2828,  0.2093,  0.4687,
+        0.3794,  -0.1069, -0.3049, 0.1430,  -0.2506, 0.4644,  0.2755,  -0.3645, -0.3155, 0.1425,
+        0.2891,  0.1786,  -0.3274, 0.2365,  0.2522,  -0.4312, -0.0562, -0.2748, 0.0776,  -0.3154,
+        0.2851,  -0.3930, -0.1174, 0.4360,  0.2436,  0.0164,  -0.0680, 0.3403,  -0.2857, -0.0459,
+        -0.2991, -0.2624, 0.4194,  -0.3291, -0.4659, 0.3300,  0.0454,  0.4981,  -0.4706, -0.4584,
+        0.2596,  0.2871,  -0.3509, -0.1910, 0.3987,  -0.1687, -0.0032, -0.1038};
+
+    std::vector<float> bias_data{
+        0.0088,  0.1183,  0.1642,  -0.2631, -0.1330, -0.4008, 0.3881,  -0.4407, -0.2760, 0.1274,
+        -0.0083, -0.2885, 0.3949,  -0.0182, 0.4445,  0.3477,  0.2266,  0.3423,  -0.0674, -0.4067,
+        0.0807,  0.1109,  -0.2036, 0.1782,  -0.2467, -0.0730, -0.4216, 0.0316,  -0.3025, 0.3637,
+        -0.3181, -0.4655, -0.0258, 0.0073,  -0.4780, -0.4101, -0.3556, -0.1017, 0.3632,  -0.1823,
+        0.1479,  0.1677,  -0.2603, 0.0381,  0.1575,  0.1896,  0.4755,  -0.4794, 0.2167,  -0.4474,
+        -0.3139, 0.1018,  0.4470,  -0.4232, 0.3247,  -0.1636, -0.1582, -0.1703, 0.3920,  0.2055,
+        -0.4386, 0.4208,  0.0717,  0.3789};
+
+    std::vector<float> input_data{
+        -0.5516, 0.2391, -1.6951, -0.0910, 1.2122,  -0.1952, 0.3577,  1.3508,  -0.5366,
+        0.4583,  2.3794, 1.0372,  -0.4313, -0.9730, -0.2005, 0.4661,  0.6494,  2.1332,
+        1.7449,  0.5483, -0.0701, -0.8887, 0.7892,  -0.4012, 2.3930,  -0.5221, -0.1331,
+        -1.0972, 0.9816, 0.1122,  -0.4100, -2.2344, 0.3685,  -0.2818, -2.3374, 1.5310};
+
+    std::vector<float> ih_data{1.9104, -1.9004, 0.3337,  0.5741,  1.5289,  1.0986,
+                               0.6091, 1.6462,  0.5671,  0.0458,  0.4514,  -0.8968,
+                               0.8720, 0.5349,  -0.1962, -1.7416, -0.9201, 0.1962,
+                               0.5771, -0.5332, -0.9912, 1.2831,  1.0896,  -0.6959};
+
+    std::vector<float> ic_data{0.9569,  -0.5981, 1.1312, 1.0945,  -0.8323, 0.3998,
+                               0.1831,  0.5938,  1.1055, -0.1212, -0.9097, 0.7831,
+                               2.7096,  -0.1790, 0.0022, -0.8040, -1.6991, -1.9498,
+                               -1.2567, -0.4114, 0.1578, 0.0567,  0.8069,  -0.5141};
+
+    std::vector<float> pph_data{1.84369764,  0.68413646, -0.44892886, -1.50904413, 0.3860796,
+                                -0.52186625, 1.08474445, -1.80867321, 1.32594529,  0.4336262,
+                                -0.83699064, 0.49162736, -0.8271,     -0.5683,     0.4562,
+                                -1.2545,     1.2729,     -0.4082,     -0.4392,     -0.9406,
+                                0.7794,      1.8194,     -0.5811,     0.2166};
+
+    float clip = 0.0f;
+    migraphx::shape in_shape{migraphx::shape::float_type, {batch_size, seq_len, input_size}};
+    migraphx::shape w_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, input_size}};
+    migraphx::shape r_shape{migraphx::shape::float_type, {num_dirct, 4 * hidden_size, hidden_size}};
+    migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 8 * hidden_size}};
+    migraphx::shape ih_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape ic_shape{migraphx::shape::float_type, {batch_size, num_dirct, hidden_size}};
+    migraphx::shape pph_shape{migraphx::shape::float_type, {num_dirct, 3 * hidden_size}};
+
+    // concatenation of hidden states as program output
+    {
+        std::vector<int> sl_data{1, 2, 3};
+        migraphx::shape sl_shape{migraphx::shape::int32_type, {batch_size}};
+        migraphx::program p;
+        auto* mm  = p.get_main_module();
+        auto seq  = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto ih   = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic   = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w    = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r    = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph  = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        auto sql  = mm->add_literal(migraphx::literal{sl_shape, sl_data});
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto out_hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        auto lho = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), out_hs);
+        auto lco = mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), out_hs);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        out_hs = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}),
+                                     out_hs);
+        lho    = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), lho);
+        lco    = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), lco);
+        mm->add_return({out_hs, lho, lco});
+        p.compile(migraphx::make_target("ref"));
+
+        auto outputs = p.eval({});
+        auto arg_hs  = outputs.front();
+        auto arg_lho = outputs.at(1);
+        auto arg_lco = outputs.at(2);
+
+        std::vector<float> output_data;
+        std::vector<float> last_output_data;
+        std::vector<float> last_cell_data;
+
+        arg_hs.visit([&](auto output) { output_data.assign(output.begin(), output.end()); });
+        arg_lho.visit([&](auto output) { last_output_data.assign(output.begin(), output.end()); });
+        arg_lco.visit([&](auto output) { last_cell_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> output_data_gold{
+            0.079753,   -0.289854, 0.160043,   0.115056,   -0.141643, 0.0451978,  0.140804,
+            0.0745128,  0,         0,          0,          0,         0,          0,
+            0,          0,         0,          0,          0,         0,          0,
+            0,          0,         0,          0,          0,         0,          0,
+            0,          0,         0,          0,          0.294074,  -0.0319677, -0.0955337,
+            0.104168,   0.911307,  0.11468,    0.114449,   0.0196755, 0.421857,   0.0459771,
+            -0.144955,  0.0720673, 0.96657,    0.0755112,  0.0620917, -0.264845,  0,
+            0,          0,         0,          0,          0,         0,          0,
+            0,          0,         0,          0,          0,         0,          0,
+            0,          0.022618,  -0.121195,  -0.4065,    -0.252054, -0.262807,  0.275286,
+            0.358395,   0.266267,  -0.0300906, -0.0890598, -0.135266, -0.0413375, -0.128254,
+            0.125398,   0.0665142, -0.163651,  0.103489,   0.0142918, -0.123408,  0.0401075,
+            -0.0644683, 0.371512,  0.212431,   -0.116131,  0,         0,          0,
+            0,          0,         0,          0,          0};
+
+        std::vector<float> last_output_data_gold{
+            0.079753, -0.289854, 0.160043,  0.115056,  -0.141643, 0.0451978, 0.140804, 0.0745128,
+            0.421857, 0.0459771, -0.144955, 0.0720673, 0.911307,  0.11468,   0.114449, 0.0196755,
+            0.103489, 0.0142918, -0.123408, 0.0401075, -0.262807, 0.275286,  0.358395, 0.266267};
+
+        std::vector<float> last_cell_data_gold{
+            0.600582, -0.601197, 0.353558,  0.789097,  -0.326822, 0.301121, 0.219523, 0.415242,
+            0.737121, 0.134902,  -0.303595, 0.241948,  2.08242,   0.442513, 0.187127, 0.0577626,
+            0.391174, 0.0308845, -0.561745, 0.0730323, -0.611307, 0.55454,  0.4364,   0.509436};
+
+        EXPECT(migraphx::verify::verify_rms_range(output_data, output_data_gold));
+        EXPECT(migraphx::verify::verify_rms_range(last_output_data, last_output_data_gold));
+        EXPECT(migraphx::verify::verify_rms_range(last_cell_data, last_cell_data_gold));
+    }
+
+    // last cell output as program output
+    {
+        migraphx::program p;
+        auto* mm      = p.get_main_module();
+        auto seq_orig = mm->add_literal(migraphx::literal{in_shape, input_data});
+        auto ih       = mm->add_literal(migraphx::literal{ih_shape, ih_data});
+        auto ic       = mm->add_literal(migraphx::literal{ic_shape, ic_data});
+        auto w        = mm->add_literal(migraphx::literal{w_shape, w_data});
+        auto r        = mm->add_literal(migraphx::literal{r_shape, r_data});
+        auto bias     = mm->add_literal(migraphx::literal{b_shape, bias_data});
+        auto pph      = mm->add_literal(migraphx::literal{pph_shape, pph_data});
+        migraphx::shape pad_seq_s{migraphx::shape::float_type, {batch_size, 2, input_size}};
+        std::vector<float> pad_data(pad_seq_s.elements(), 0.0f);
+        auto seq_p = mm->add_literal(migraphx::literal{pad_seq_s, pad_data});
+        auto seq = mm->add_instruction(migraphx::make_op("concat", {{"axis", 1}}), seq_orig, seq_p);
+        migraphx::shape seq_len_s{migraphx::shape::int32_type, {batch_size}};
+        std::vector<int32_t> len_data(batch_size, static_cast<int32_t>(seq_len));
+        auto sql = mm->add_literal(seq_len_s, len_data);
+
+        std::vector<int64_t> perm{1, 0, 2};
+        seq = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), seq);
+        ih  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ih);
+        ic  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), ic);
+
+        auto hs = mm->add_instruction(
+            migraphx::make_op(
+                "lstm",
+                {{"hidden_size", hidden_size},
+                 {"actv_func",
+                  migraphx::to_value(std::vector<migraphx::operation>{migraphx::make_op("sigmoid"),
+                                                                      migraphx::make_op("tanh"),
+                                                                      migraphx::make_op("tanh")})},
+                 {"direction", migraphx::to_value(migraphx::op::rnn_direction::bidirectional)},
+                 {"clip", clip},
+                 {"input_forget", 0}}),
+            seq,
+            w,
+            r,
+            bias,
+            sql,
+            ih,
+            ic,
+            pph);
+        auto lho = mm->add_instruction(migraphx::make_op("rnn_last_hs_output"), hs);
+        auto lco = mm->add_instruction(migraphx::make_op("rnn_last_cell_output"), hs);
+        std::vector<int64_t> perm_hid{2, 0, 1, 3};
+        hs  = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm_hid}}), hs);
+        lho = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), lho);
+        lco = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), lco);
+        mm->add_return({hs, lho, lco});
+        p.compile(migraphx::make_target("ref"));
+
+        auto outputs = p.eval({});
+        auto res_hs  = outputs.at(0);
+        auto res_lho = outputs.at(1);
+        auto res_lco = outputs.at(2);
+        std::vector<float> hs_data;
+        std::vector<float> lho_data;
+        std::vector<float> lco_data;
+        res_hs.visit([&](auto output) { hs_data.assign(output.begin(), output.end()); });
+        res_lho.visit([&](auto output) { lho_data.assign(output.begin(), output.end()); });
+        res_lco.visit([&](auto output) { lco_data.assign(output.begin(), output.end()); });
+
+        std::vector<float> hs_data_gold{
+            0.079753,   -0.289854,  0.160043,   0.115056,   -0.120174,  0.043157,   0.117138,
+            -0.222188,  0.186991,   -0.0624168, 0.205513,   0.0836373,  -0.175114,  -0.00543549,
+            0.178681,   -0.266999,  0.0459033,  0.0414126,  0.272303,   0.0393149,  -0.182201,
+            -0.0232277, 0.235501,   -0.213485,  -0.058052,  0.0795391,  0.266617,   -0.0128746,
+            -0.185038,  -0.026845,  0.177273,   -0.0774616, 0,          0,          0,
+            0,          0,          0,          0,          0,          0,          0,
+            0,          0,          0,          0,          0,          0,          0.294074,
+            -0.0319677, -0.0955337, 0.104168,   0.789732,   0.128538,   0.20909,    0.0553812,
+            0.421857,   0.0459771,  -0.144955,  0.0720673,  0.928866,   0.113685,   0.220626,
+            -0.0432316, 0.218258,   0.0944405,  0.0431211,  -0.132394,  0.960938,   0.133565,
+            0.269741,   0.130438,   0.0309878,  0.0971544,  0.149294,   -0.0492549, 0.946669,
+            0.0868676,  0.044508,   -0.373961,  0,          0,          0,          0,
+            0,          0,          0,          0,          0,          0,          0,
+            0,          0,          0,          0,          0,          0.022618,   -0.121195,
+            -0.4065,    -0.252054,  -0.224905,  0.32421,    0.344048,   0.271694,   -0.0300906,
+            -0.0890598, -0.135266,  -0.0413375, -0.063456,  0.148524,   0.05108,    -0.0234895,
+            0.103489,   0.0142918,  -0.123408,  0.0401075,  -0.0252804, 0.267356,   0.146353,
+            0.0789186,  0.187761,   0.0501726,  -0.121584,  0.0606723,  -0.0681467, 0.382748,
+            0.230211,   -0.161537,  0,          0,          0,          0,          0,
+            0,          0,          0,          0,          0,          0,          0,
+            0,          0,          0,          0};
+
+        std::vector<float> lho_data_gold{
+            -0.058052, 0.0795391, 0.266617,  -0.0128746, -0.120174, 0.043157, 0.117138, -0.222188,
+            0.0309878, 0.0971544, 0.149294,  -0.0492549, 0.789732,  0.128538, 0.20909,  0.0553812,
+            0.187761,  0.0501726, -0.121584, 0.0606723,  -0.224905, 0.32421,  0.344048, 0.271694};
+
+        std::vector<float> lco_data_gold{
+            -0.077353, 0.245616, 0.361023,  -0.0443759, -0.889294, 0.182463, 0.186512, -0.402334,
+            0.0685243, 0.20465,  0.277867,  -0.112934,  1.48161,   0.524116, 0.347113, 0.181813,
+            0.67312,   0.120508, -0.726968, 0.113845,   -0.434265, 0.747833, 0.416053, 0.558713};
+
+        EXPECT(migraphx::verify::verify_rms_range(hs_data, hs_data_gold));
+        EXPECT(migraphx::verify::verify_rms_range(lho_data, lho_data_gold));
+        EXPECT(migraphx::verify::verify_rms_range(lco_data, lco_data_gold));
+    }
+}
+
 TEST_CASE(lstm_bidirectional_actv_func)
 {
     std::size_t batch_size  = 3;