inference-engine/thirdparty/clDNN/tests/test_cases/reverse_sequence_gpu_test.cpp

   1 // Copyright (c) 2019 Intel Corporation
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 ///////////////////////////////////////////////////////////////////////////////////////////////////
  16 #include <gtest/gtest.h>
  17
  18 #include <api/input_layout.hpp>
  19 #include <api/memory.hpp>
  20 #include <api/reverse_sequence.hpp>
  21 #include <api/topology.hpp>
  22 #include <api/network.hpp>
  23
  24 #include <cstddef>
  25 #include <tests/test_utils/test_utils.h>
  26
  27 using namespace cldnn;
  28 using namespace ::tests;
  29
  30 TEST(reverese_sequence_gpu_test, fp32_d2_2_ba1_sa0) {
  31     engine engine;
  32
  33     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 1, 1 } });
  34     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
  35     int32_t batch_axis = 1;
  36     int32_t seq_axis = 0;
  37
  38     set_values(input, {
  39             0.0f, 1.0f, 2.0f, 3.0f
  40     });
  41
  42     set_values(seq_lengths, {
  43             1.0f, 2.0f
  44     });
  45
  46     topology topology;
  47     topology.add(input_layout("input", input.get_layout()));
  48     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
  49     topology.add(
  50             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
  51     );
  52
  53     network network(engine, topology);
  54
  55     network.set_input_data("input", input);
  56     network.set_input_data("seq_lengths", seq_lengths);
  57
  58     auto outputs = network.execute();
  59
  60     auto output = outputs.at("reverse_sequence").get_memory();
  61     auto output_ptr = output.pointer<float>();
  62
  63     std::vector<float> expected_results = {
  64             0.0f, 3.0f, 2.0f, 1.0f
  65     };
  66
  67     for (size_t i = 0; i < expected_results.size(); ++i) {
  68         EXPECT_EQ(expected_results[i], output_ptr[i]);
  69     }
  70 }
  71
  72 TEST(reverese_sequence_gpu_test, fp32_d3_3_3_ba0_sa1) {
  73     engine engine;
  74
  75     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 3, 1, 3 } });
  76     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
  77     int32_t batch_axis = 0;
  78     int32_t seq_axis = 1;
  79
  80     set_values(input, {
  81         0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
  82         10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f,
  83         20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f
  84     });
  85
  86     set_values(seq_lengths, {
  87         2.0f, 2.0f, 2.0f
  88     });
  89
  90     topology topology;
  91     topology.add(input_layout("input", input.get_layout()));
  92     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
  93     topology.add(
  94             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
  95     );
  96
  97     network network(engine, topology);
  98
  99     network.set_input_data("input", input);
 100     network.set_input_data("seq_lengths", seq_lengths);
 101
 102     auto outputs = network.execute();
 103
 104     auto output = outputs.at("reverse_sequence").get_memory();
 105     auto output_ptr = output.pointer<float>();
 106
 107     std::vector<float> expected_results = {
 108             3.0f, 4.0f, 5.0f, 0.0f, 1.0f, 2.0f, 6.0f, 7.0f, 8.0f,
 109             12.0f, 13.0f, 14.0f, 9.0f, 10.0f, 11.0f, 15.0f, 16.0f, 17.0f,
 110             21.0f, 22.0f, 23.0f, 18.0f, 19.0f, 20.0f, 24.0f, 25.0f, 26.0f
 111     };
 112
 113     for (size_t i = 0; i < expected_results.size(); ++i) {
 114         EXPECT_EQ(expected_results[i], output_ptr[i]);
 115     }
 116 }
 117
 118 TEST(reverese_sequence_gpu_test, fp32_d3_3_3_ba2_sa0) {
 119     engine engine;
 120
 121     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 3, 1, 3 } });
 122     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
 123     int32_t batch_axis = 2;
 124     int32_t seq_axis = 0;
 125
 126     set_values(input, {
 127             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
 128             10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f,
 129             20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f
 130     });
 131
 132     set_values(seq_lengths, {
 133             2.0f, 2.0f, 2.0f
 134     });
 135
 136     topology topology;
 137     topology.add(input_layout("input", input.get_layout()));
 138     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 139     topology.add(
 140             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 141     );
 142
 143     network network(engine, topology);
 144
 145     network.set_input_data("input", input);
 146     network.set_input_data("seq_lengths", seq_lengths);
 147
 148     auto outputs = network.execute();
 149
 150     auto output = outputs.at("reverse_sequence").get_memory();
 151     auto output_ptr = output.pointer<float>();
 152
 153     std::vector<float> expected_results = {
 154             9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
 155             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
 156             18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f
 157     };
 158
 159     for (size_t i = 0; i < expected_results.size(); ++i) {
 160         EXPECT_EQ(expected_results[i], output_ptr[i]);
 161     }
 162 }
 163
 164 TEST(reverese_sequence_gpu_test, fp32_d2_2_3_2ba0_sa3) {
 165     engine engine;
 166
 167     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 2, 3 } });
 168     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
 169     int32_t batch_axis = 0;
 170     int32_t seq_axis = 3;
 171
 172     set_values(input, {
 173             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
 174             10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f,
 175             20.0f, 21.0f, 22.0f, 23.0f
 176     });
 177
 178     set_values(seq_lengths, {
 179             1.0f, 2.0f
 180     });
 181
 182     topology topology;
 183     topology.add(input_layout("input", input.get_layout()));
 184     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 185     topology.add(
 186             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 187     );
 188
 189     network network(engine, topology);
 190
 191     network.set_input_data("input", input);
 192     network.set_input_data("seq_lengths", seq_lengths);
 193
 194     auto outputs = network.execute();
 195
 196     auto output = outputs.at("reverse_sequence").get_memory();
 197     auto output_ptr = output.pointer<float>();
 198
 199     std::vector<float> expected_results = {
 200             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f,
 201             6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f,
 202             13.0f, 12.0f, 15.0f, 14.0f, 17.0f, 16.0f,
 203             19.0f, 18.0f, 21.0f, 20.0f, 23.0f, 22.0f
 204     };
 205
 206     for (size_t i = 0; i < expected_results.size(); ++i) {
 207         EXPECT_EQ(expected_results[i], output_ptr[i]);
 208     }
 209 }
 210
 211 TEST(reverese_sequence_gpu_test, fp32_d2_2_3_2ba0_sa2) {
 212     engine engine;
 213
 214     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 2, 3 } });
 215     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
 216     int32_t batch_axis = 0;
 217     int32_t seq_axis = 2;
 218
 219     set_values(input, {
 220             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
 221             10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f,
 222             20.0f, 21.0f, 22.0f, 23.0f
 223     });
 224
 225     set_values(seq_lengths, {
 226             2.0f, 2.0f
 227     });
 228
 229     topology topology;
 230     topology.add(input_layout("input", input.get_layout()));
 231     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 232     topology.add(
 233             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 234     );
 235
 236     network network(engine, topology);
 237
 238     network.set_input_data("input", input);
 239     network.set_input_data("seq_lengths", seq_lengths);
 240
 241     auto outputs = network.execute();
 242
 243     auto output = outputs.at("reverse_sequence").get_memory();
 244     auto output_ptr = output.pointer<float>();
 245
 246     std::vector<float> expected_results = {
 247             2.0f, 3.0f, 0.0f, 1.0f, 4.0f, 5.0f,
 248             8.0f, 9.0f, 6.0f, 7.0f, 10.0f, 11.0f,
 249             14.0f, 15.0f, 12.0f, 13.0f, 16.0f, 17.0f,
 250             20.0f, 21.0f, 18.0f, 19.0f, 22.0f, 23.0f
 251     };
 252
 253     for (size_t i = 0; i < expected_results.size(); ++i) {
 254         EXPECT_EQ(expected_results[i], output_ptr[i]);
 255     }
 256 }
 257
 258 TEST(reverese_sequence_gpu_test, fp32_d2_2_3_2ba2_sa0) {
 259     engine engine;
 260
 261     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 2, 3 } });
 262     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
 263     int32_t batch_axis = 2;
 264     int32_t seq_axis = 0;
 265
 266     set_values(input, {
 267             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
 268             10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f,
 269             20.0f, 21.0f, 22.0f, 23.0f
 270     });
 271
 272     set_values(seq_lengths, {
 273             1.0f, 1.0f, 2.0f
 274     });
 275
 276     topology topology;
 277     topology.add(input_layout("input", input.get_layout()));
 278     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 279     topology.add(
 280             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 281     );
 282
 283     network network(engine, topology);
 284
 285     network.set_input_data("input", input);
 286     network.set_input_data("seq_lengths", seq_lengths);
 287
 288     auto outputs = network.execute();
 289
 290     auto output = outputs.at("reverse_sequence").get_memory();
 291     auto output_ptr = output.pointer<float>();
 292
 293     std::vector<float> expected_results = {
 294             0.0f, 1.0f, 2.0f, 3.0f, 16.0f, 17.0f,
 295             6.0f, 7.0f, 8.0f, 9.0f, 22.0f, 23.0f,
 296             12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f,
 297             18.0f, 19.0f, 20.0f, 21.0f, 10.0f, 11.0f
 298     };
 299
 300     for (size_t i = 0; i < expected_results.size(); ++i) {
 301         EXPECT_EQ(expected_results[i], output_ptr[i]);
 302     }
 303 }
 304
 305 TEST(reverese_sequence_gpu_test, fp16_d2_2_ba1_sa0) {
 306     engine engine;
 307
 308     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 2, 2, 1, 1 } });
 309     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
 310     int32_t batch_axis = 1;
 311     int32_t seq_axis = 0;
 312
 313     set_values(input, {
 314             FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f)
 315     });
 316
 317     set_values(seq_lengths, {
 318             1.0f, 2.0f
 319     });
 320
 321     topology topology;
 322     topology.add(input_layout("input", input.get_layout()));
 323     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 324     topology.add(
 325             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 326     );
 327
 328     network network(engine, topology);
 329
 330     network.set_input_data("input", input);
 331     network.set_input_data("seq_lengths", seq_lengths);
 332
 333     auto outputs = network.execute();
 334
 335     auto output = outputs.at("reverse_sequence").get_memory();
 336     auto output_ptr = output.pointer<uint16_t>();
 337
 338     std::vector<float> expected_results = {
 339             0.0f, 3.0f, 2.0f, 1.0f
 340     };
 341
 342     for (size_t i = 0; i < expected_results.size(); ++i) {
 343         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 344     }
 345 }
 346
 347 TEST(reverese_sequence_gpu_test, fp16_d3_3_3_ba0_sa1) {
 348     engine engine;
 349
 350     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 3, 3, 1, 3 } });
 351     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
 352     int32_t batch_axis = 0;
 353     int32_t seq_axis = 1;
 354
 355     set_values(input, {
 356             FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f), FLOAT16(9.0f),
 357             FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f), FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
 358             FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f), FLOAT16(24.0f), FLOAT16(25.0f), FLOAT16(26.0f)
 359     });
 360
 361     set_values(seq_lengths, {
 362             2.0f, 2.0f, 2.0f
 363     });
 364
 365     topology topology;
 366     topology.add(input_layout("input", input.get_layout()));
 367     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 368     topology.add(
 369             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 370     );
 371
 372     network network(engine, topology);
 373
 374     network.set_input_data("input", input);
 375     network.set_input_data("seq_lengths", seq_lengths);
 376
 377     auto outputs = network.execute();
 378
 379     auto output = outputs.at("reverse_sequence").get_memory();
 380     auto output_ptr = output.pointer<uint16_t >();
 381
 382     std::vector<float> expected_results = {
 383             3.0f, 4.0f, 5.0f, 0.0f, 1.0f, 2.0f, 6.0f, 7.0f, 8.0f,
 384             12.0f, 13.0f, 14.0f, 9.0f, 10.0f, 11.0f, 15.0f, 16.0f, 17.0f,
 385             21.0f, 22.0f, 23.0f, 18.0f, 19.0f, 20.0f, 24.0f, 25.0f, 26.0f
 386     };
 387
 388     for (size_t i = 0; i < expected_results.size(); ++i) {
 389         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 390     }
 391 }
 392
 393 TEST(reverese_sequence_gpu_test, fp16_d3_3_3_ba2_sa0) {
 394     engine engine;
 395
 396     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 3, 3, 1, 3 } });
 397     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
 398     int32_t batch_axis = 2;
 399     int32_t seq_axis = 0;
 400
 401     set_values(input, {
 402             FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f), FLOAT16(9.0f),
 403             FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f), FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
 404             FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f), FLOAT16(24.0f), FLOAT16(25.0f), FLOAT16(26.0f)
 405     });
 406
 407     set_values(seq_lengths, {
 408             2.0f, 2.0f, 2.0f
 409     });
 410
 411     topology topology;
 412     topology.add(input_layout("input", input.get_layout()));
 413     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 414     topology.add(
 415             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 416     );
 417
 418     network network(engine, topology);
 419
 420     network.set_input_data("input", input);
 421     network.set_input_data("seq_lengths", seq_lengths);
 422
 423     auto outputs = network.execute();
 424
 425     auto output = outputs.at("reverse_sequence").get_memory();
 426     auto output_ptr = output.pointer<uint16_t>();
 427
 428     std::vector<float> expected_results = {
 429             9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
 430             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
 431             18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f
 432     };
 433
 434     for (size_t i = 0; i < expected_results.size(); ++i) {
 435         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 436     }
 437 }
 438
 439 TEST(reverese_sequence_gpu_test, fp16_d2_2_3_2ba0_sa3) {
 440     engine engine;
 441
 442     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 2, 2, 2, 3 } });
 443     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
 444     int32_t batch_axis = 0;
 445     int32_t seq_axis = 3;
 446
 447     set_values(input, {
 448             FLOAT16(0.0f), FLOAT16( 1.0f), FLOAT16( 2.0f), FLOAT16( 3.0f), FLOAT16( 4.0f), FLOAT16( 5.0f), FLOAT16( 6.0f), FLOAT16( 7.0f), FLOAT16( 8.0f), FLOAT16( 9.0f),
 449             FLOAT16(10.0f), FLOAT16( 11.0f), FLOAT16( 12.0f), FLOAT16( 13.0f), FLOAT16( 14.0f), FLOAT16( 15.0f), FLOAT16( 16.0f), FLOAT16( 17.0f), FLOAT16( 18.0f), FLOAT16( 19.0f),
 450             FLOAT16(20.0f), FLOAT16( 21.0f), FLOAT16( 22.0f), FLOAT16( 23.0f)
 451     });
 452
 453     set_values(seq_lengths, {
 454             1.0f, 2.0f
 455     });
 456
 457     topology topology;
 458     topology.add(input_layout("input", input.get_layout()));
 459     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 460     topology.add(
 461             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 462     );
 463
 464     network network(engine, topology);
 465
 466     network.set_input_data("input", input);
 467     network.set_input_data("seq_lengths", seq_lengths);
 468
 469     auto outputs = network.execute();
 470
 471     auto output = outputs.at("reverse_sequence").get_memory();
 472     auto output_ptr = output.pointer<uint16_t>();
 473
 474     std::vector<float> expected_results = {
 475             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f,
 476             6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f,
 477             13.0f, 12.0f, 15.0f, 14.0f, 17.0f, 16.0f,
 478             19.0f, 18.0f, 21.0f, 20.0f, 23.0f, 22.0f
 479     };
 480
 481     for (size_t i = 0; i < expected_results.size(); ++i) {
 482         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 483     }
 484 }
 485
 486 TEST(reverese_sequence_gpu_test, fp16_d2_2_3_2ba0_sa2) {
 487     engine engine;
 488
 489     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 2, 2, 2, 3 } });
 490     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 1, 1 } });
 491     int32_t batch_axis = 0;
 492     int32_t seq_axis = 2;
 493
 494     set_values(input, {
 495             FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f), FLOAT16(9.0f),
 496             FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f), FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
 497             FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f)
 498     });
 499
 500     set_values(seq_lengths, {
 501             2.0f, 2.0f
 502     });
 503
 504     topology topology;
 505     topology.add(input_layout("input", input.get_layout()));
 506     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 507     topology.add(
 508             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 509     );
 510
 511     network network(engine, topology);
 512
 513     network.set_input_data("input", input);
 514     network.set_input_data("seq_lengths", seq_lengths);
 515
 516     auto outputs = network.execute();
 517
 518     auto output = outputs.at("reverse_sequence").get_memory();
 519     auto output_ptr = output.pointer<uint16_t>();
 520
 521     std::vector<float> expected_results = {
 522             2.0f, 3.0f, 0.0f, 1.0f, 4.0f, 5.0f,
 523             8.0f, 9.0f, 6.0f, 7.0f, 10.0f, 11.0f,
 524             14.0f, 15.0f, 12.0f, 13.0f, 16.0f, 17.0f,
 525             20.0f, 21.0f, 18.0f, 19.0f, 22.0f, 23.0f
 526     };
 527
 528     for (size_t i = 0; i < expected_results.size(); ++i) {
 529         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 530     }
 531 }
 532
 533 TEST(reverese_sequence_gpu_test, fp16_d2_2_3_2ba2_sa0) {
 534     engine engine;
 535
 536     auto input = memory::allocate(engine, { data_types::f16, format::bfyx, { 2, 2, 2, 3 } });
 537     auto seq_lengths = memory::allocate(engine, { data_types::f32, format::bfyx, { 3, 1, 1, 1 } });
 538     int32_t batch_axis = 2;
 539     int32_t seq_axis = 0;
 540
 541     set_values(input, {
 542             FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f), FLOAT16(9.0f),
 543             FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f), FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
 544             FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f)
 545     });
 546
 547     set_values(seq_lengths, {
 548             1.0f, 1.0f, 2.0f
 549     });
 550
 551     topology topology;
 552     topology.add(input_layout("input", input.get_layout()));
 553     topology.add(input_layout("seq_lengths", seq_lengths.get_layout()));
 554     topology.add(
 555             reverse_sequence("reverse_sequence", "input", "seq_lengths", seq_axis, batch_axis)
 556     );
 557
 558     network network(engine, topology);
 559
 560     network.set_input_data("input", input);
 561     network.set_input_data("seq_lengths", seq_lengths);
 562
 563     auto outputs = network.execute();
 564
 565     auto output = outputs.at("reverse_sequence").get_memory();
 566     auto output_ptr = output.pointer<uint16_t>();
 567
 568     std::vector<float> expected_results = {
 569             0.0f, 1.0f, 2.0f, 3.0f, 16.0f, 17.0f,
 570             6.0f, 7.0f, 8.0f, 9.0f, 22.0f, 23.0f,
 571             12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f,
 572             18.0f, 19.0f, 20.0f, 21.0f, 10.0f, 11.0f
 573     };
 574
 575     for (size_t i = 0; i < expected_results.size(); ++i) {
 576         EXPECT_EQ(expected_results[i], float16_to_float32(output_ptr[i]));
 577     }
 578 }