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