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

   1 /*
   2 // Copyright (c) 2018 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 ///////////////////////////////////////////////////////////////////////////////////////////////////
  18 #include <gtest/gtest.h>
  19 #include "api/CPP/memory.hpp"
  20 #include <api/CPP/input_layout.hpp>
  21 #include "api/CPP/select.hpp"
  22 #include <api/CPP/topology.hpp>
  23 #include <api/CPP/network.hpp>
  24 #include <api/CPP/engine.hpp>
  25 #include "test_utils/test_utils.h"
  26
  27 using namespace cldnn;
  28 using namespace tests;
  29
  30 // select_gpu_f32
  31 TEST(select_gpu_f32, select_basic) {
  32     const auto& engine = get_test_engine();
  33
  34     auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 2, 2 } });
  35     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 2, 2 } });
  36     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
  37
  38     topology topology;
  39     topology.add(input_layout("input", input.get_layout()));
  40     topology.add(input_layout("input2", input2.get_layout()));
  41     topology.add(input_layout("mask", mask.get_layout()));
  42     topology.add(cldnn::select("select", "input", "input2", "mask"));
  43
  44     set_values(input, {
  45         1.f,   0.f, 5.f, 1.5f,
  46         2.f,   0.f, 6.f, 5.2f,
  47         3.f,  0.5f, 7.f, 12.f,
  48         4.f, -0.5f, 8.f,  8.f
  49     });
  50
  51     set_values(input2, {
  52         0.5f,   2.5f,  0.5f,  2.5f,
  53          5.f,   7.f,    2.f,   4.f,
  54         15.f,  17.f,    8.f,  10.f,
  55         -2.f,  6.5f,  -0.5f, -2.5f });
  56
  57     set_values(mask, {
  58         0.f,   0.f,  0.f,  0.f,
  59         1.f,   1.f,  1.f,  1.f,
  60         0.f,   1.f,  0.f,  1.f,
  61         1.f,   0.f,  1.f,  0.f });
  62
  63     network network(engine, topology);
  64
  65     network.set_input_data("input", input);
  66     network.set_input_data("input2", input2);
  67     network.set_input_data("mask", mask);
  68     auto outputs = network.execute();
  69
  70     auto output = outputs.at("select").get_memory();
  71
  72     float answers[16] = {  0.5f,  2.5f,   0.5f,  2.5f,
  73                            2.f,   0.f,    6.f,   5.2f,
  74                           15.f,   0.5f,   8.f,  12.f,
  75                            4.f,   6.5f,   8.f,  -2.5f };
  76
  77     auto output_ptr = output.pointer<float>();
  78
  79     for (int i = 0; i < 16; i++)
  80     {
  81         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
  82     }
  83 }
  84
  85 TEST(select_gpu_f32, select_basic_negative) {
  86     const auto& engine = get_test_engine();
  87
  88     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
  89     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
  90     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
  91
  92     topology topology;
  93     topology.add(input_layout("input", input.get_layout()));
  94     topology.add(input_layout("input2", input2.get_layout()));
  95     topology.add(input_layout("mask", mask.get_layout()));
  96     topology.add(cldnn::select("select", "input", "input2", "mask"));
  97
  98     set_values(input, {
  99         1.f,   0.f, 5.f, 1.5f,
 100         2.f,   0.f, 6.f, 5.2f,
 101         3.f,  0.5f, 7.f, 12.f,
 102         4.f, -0.5f, 8.f,  8.f
 103     });
 104
 105     set_values(input2, {
 106         0.5f,   2.5f,  0.5f,  2.5f,
 107         5.f,   7.f,    2.f,   4.f,
 108         15.f,  17.f,    8.f,  10.f,
 109         -2.f,  6.5f,  -0.5f, -2.5f });
 110
 111     set_values(mask, {
 112         -0.f,   -0.f,  -0.f,  -0.f,
 113         -1.f,   -1.f,  -1.f,  -1.f,
 114         -0.f,   -1.f,  -0.f,  -1.f,
 115         -1.f,   -0.f,  -1.f,  -0.f });
 116
 117     network network(engine, topology);
 118
 119     network.set_input_data("input", input);
 120     network.set_input_data("input2", input2);
 121     network.set_input_data("mask", mask);
 122     auto outputs = network.execute();
 123
 124     auto output = outputs.at("select").get_memory();
 125
 126     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 127         2.f,   0.f,    6.f,   5.2f,
 128         15.f,   0.5f,   8.f,  12.f,
 129         4.f,   6.5f,   8.f,  -2.5f };
 130
 131     auto output_ptr = output.pointer<float>();
 132
 133     for (int i = 0; i < 16; i++)
 134     {
 135         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 136     }
 137 }
 138
 139 TEST(select_gpu_f32, select_basic_comma) {
 140     const auto& engine = get_test_engine();
 141
 142     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 143     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 144     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 145
 146     topology topology;
 147     topology.add(input_layout("input", input.get_layout()));
 148     topology.add(input_layout("input2", input2.get_layout()));
 149     topology.add(input_layout("mask", mask.get_layout()));
 150     topology.add(cldnn::select("select", "input", "input2", "mask"));
 151
 152     set_values(input, {
 153         1.f,   0.f, 5.f, 1.5f,
 154         2.f,   0.f, 6.f, 5.2f,
 155         3.f,  0.5f, 7.f, 12.f,
 156         4.f, -0.5f, 8.f,  8.f
 157     });
 158
 159     set_values(input2, {
 160         0.5f,   2.5f,  0.5f,  2.5f,
 161         5.f,   7.f,    2.f,   4.f,
 162         15.f,  17.f,    8.f,  10.f,
 163         -2.f,  6.5f,  -0.5f, -2.5f });
 164
 165     set_values(mask, {
 166         0.f,   0.f,  0.f,  0.f,
 167         0.1f,   0.3f,  0.5f,  0.7f,
 168         -0.f,   -0.1f,  -0.f,  -0.5f,
 169         -0.7f,   -0.f,  -1.5f,  -0.f });
 170
 171     network network(engine, topology);
 172
 173     network.set_input_data("input", input);
 174     network.set_input_data("input2", input2);
 175     network.set_input_data("mask", mask);
 176     auto outputs = network.execute();
 177
 178     auto output = outputs.at("select").get_memory();
 179
 180     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 181         2.f,   0.f,    6.f,   5.2f,
 182         15.f,   0.5f,   8.f,  12.f,
 183         4.f,   6.5f,   8.f,  -2.5f };
 184
 185     auto output_ptr = output.pointer<float>();
 186
 187     for (int i = 0; i < 16; i++)
 188     {
 189         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 190     }
 191 }
 192
 193 TEST(select_gpu_f32, select_basic_error_input_sizes) {
 194     const auto& engine = get_test_engine();
 195
 196     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 197     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 3, 4, 5, 6 } });
 198     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 199
 200     topology topology;
 201     topology.add(input_layout("input", input.get_layout()));
 202     topology.add(input_layout("input2", input2.get_layout()));
 203     topology.add(input_layout("mask", mask.get_layout()));
 204     topology.add(cldnn::select("select", "input", "input2", "mask"));
 205
 206     EXPECT_ANY_THROW(network(engine, topology));
 207 }
 208
 209 TEST(select_gpu_f32, select_basic_error_mask_sizes) {
 210     const auto& engine = get_test_engine();
 211
 212     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 213     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 214     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 3, 4, 5, 6 } });
 215
 216     topology topology;
 217     topology.add(input_layout("input", input.get_layout()));
 218     topology.add(input_layout("input2", input2.get_layout()));
 219     topology.add(input_layout("mask", mask.get_layout()));
 220     topology.add(cldnn::select("select", "input", "input2", "mask"));
 221
 222     EXPECT_ANY_THROW(network(engine, topology));
 223 }
 224
 225 TEST(select_gpu_f32, select_basic_error_input_types) {
 226     const auto& engine = get_test_engine();
 227
 228     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 229     auto input2 = memory::allocate(engine, { data_types::i8, format::yxfb,{ 2, 2, 2, 2 } });
 230     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 231
 232     topology topology;
 233     topology.add(input_layout("input", input.get_layout()));
 234     topology.add(input_layout("input2", input2.get_layout()));
 235     topology.add(input_layout("mask", mask.get_layout()));
 236     topology.add(cldnn::select("select", "input", "input2", "mask"));
 237     EXPECT_ANY_THROW(network(engine, topology));
 238 }
 239
 240 TEST(select_gpu_f32, select_basic_error_input_formats) {
 241     const auto& engine = get_test_engine();
 242
 243     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 244     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 245     auto mask = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 2 } });
 246
 247     topology topology;
 248     topology.add(input_layout("input", input.get_layout()));
 249     topology.add(input_layout("input2", input2.get_layout()));
 250     topology.add(input_layout("mask", mask.get_layout()));
 251     topology.add(cldnn::select("select", "input", "input2", "mask"));
 252
 253     EXPECT_ANY_THROW(network(engine, topology));
 254 }
 255
 256 TEST(select_gpu_f32, select_basic_byxf) {
 257     const auto& engine = get_test_engine();
 258
 259     auto input = memory::allocate(engine, { data_types::f32, format::byxf,{ 2, 2, 2, 2 } });
 260     auto input2 = memory::allocate(engine, { data_types::f32, format::byxf,{ 2, 2, 2, 2 } });
 261     auto mask = memory::allocate(engine, { data_types::f32, format::byxf,{ 2, 2, 2, 2 } });
 262
 263     topology topology;
 264     topology.add(input_layout("input", input.get_layout()));
 265     topology.add(input_layout("input2", input2.get_layout()));
 266     topology.add(input_layout("mask", mask.get_layout()));
 267     topology.add(cldnn::select("select", "input", "input2", "mask"));
 268
 269     set_values(input, {
 270         1.f,   0.f, 5.f, 1.5f,
 271         2.f,   0.f, 6.f, 5.2f,
 272         3.f,  0.5f, 7.f, 12.f,
 273         4.f, -0.5f, 8.f,  8.f
 274     });
 275
 276     set_values(input2, {
 277         0.5f,   2.5f,  0.5f,  2.5f,
 278         5.f,   7.f,    2.f,   4.f,
 279         15.f,  17.f,    8.f,  10.f,
 280         -2.f,  6.5f,  -0.5f, -2.5f });
 281
 282     set_values(mask, {
 283         0.f,   0.f,  0.f,  0.f,
 284         1.f,   1.f,  1.f,  1.f,
 285         0.f,   1.f,  0.f,  1.f,
 286         1.f,   0.f,  1.f,  0.f });
 287
 288     network network(engine, topology);
 289
 290     network.set_input_data("input", input);
 291     network.set_input_data("input2", input2);
 292     network.set_input_data("mask", mask);
 293     auto outputs = network.execute();
 294
 295     auto output = outputs.at("select").get_memory();
 296
 297     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 298         2.f,   0.f,    6.f,   5.2f,
 299         15.f,   0.5f,   8.f,  12.f,
 300         4.f,   6.5f,   8.f,  -2.5f };
 301
 302     auto output_ptr = output.pointer<float>();
 303
 304     for (int i = 0; i < 16; i++)
 305     {
 306         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 307     }
 308 }
 309
 310 TEST(select_gpu_f32, select_basic_mask_f16) {
 311     const auto& engine = get_test_engine();
 312
 313     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 314     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 315     auto mask = memory::allocate(engine, { data_types::f16, format::yxfb,{ 2, 2, 2, 2 } });
 316
 317     topology topology;
 318     topology.add(input_layout("input", input.get_layout()));
 319     topology.add(input_layout("input2", input2.get_layout()));
 320     topology.add(input_layout("mask", mask.get_layout()));
 321     topology.add(cldnn::select("select", "input", "input2", "mask"));
 322
 323     set_values(input, {
 324         1.f,   0.f, 5.f, 1.5f,
 325         2.f,   0.f, 6.f, 5.2f,
 326         3.f,  0.5f, 7.f, 12.f,
 327         4.f, -0.5f, 8.f,  8.f
 328     });
 329
 330     set_values(input2, {
 331         0.5f,   2.5f,  0.5f,  2.5f,
 332         5.f,   7.f,    2.f,   4.f,
 333         15.f,  17.f,    8.f,  10.f,
 334         -2.f,  6.5f,  -0.5f, -2.5f });
 335
 336     set_values<uint16_t>(mask, {
 337         0,   0,  0,  0,
 338         1,   1,  1,  1,
 339         0,   1,  0,  1,
 340         1,   0,  1,  0 });
 341
 342     network network(engine, topology);
 343
 344     network.set_input_data("input", input);
 345     network.set_input_data("input2", input2);
 346     network.set_input_data("mask", mask);
 347     auto outputs = network.execute();
 348
 349     auto output = outputs.at("select").get_memory();
 350
 351     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 352         2.f,   0.f,    6.f,   5.2f,
 353         15.f,   0.5f,   8.f,  12.f,
 354         4.f,   6.5f,   8.f,  -2.5f };
 355
 356     auto output_ptr = output.pointer<float>();
 357
 358     for (int i = 0; i < 16; i++)
 359     {
 360         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 361     }
 362 }
 363
 364 TEST(select_gpu_f32, select_basic_mask_i8) {
 365     const auto& engine = get_test_engine();
 366
 367     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 368     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 369     auto mask = memory::allocate(engine, { data_types::i8, format::yxfb,{ 2, 2, 2, 2 } });
 370
 371     topology topology;
 372     topology.add(input_layout("input", input.get_layout()));
 373     topology.add(input_layout("input2", input2.get_layout()));
 374     topology.add(input_layout("mask", mask.get_layout()));
 375     topology.add(cldnn::select("select", "input", "input2", "mask"));
 376
 377     set_values(input, {
 378         1.f,   0.f, 5.f, 1.5f,
 379         2.f,   0.f, 6.f, 5.2f,
 380         3.f,  0.5f, 7.f, 12.f,
 381         4.f, -0.5f, 8.f,  8.f
 382     });
 383
 384     set_values(input2, {
 385         0.5f,   2.5f,  0.5f,  2.5f,
 386         5.f,   7.f,    2.f,   4.f,
 387         15.f,  17.f,    8.f,  10.f,
 388         -2.f,  6.5f,  -0.5f, -2.5f });
 389
 390     set_values<char>(mask, {
 391         0,   0,  0,  0,
 392         1,   1,  1,  1,
 393         0,   1,  0,  1,
 394         1,   0,  1,  0 });
 395
 396     network network(engine, topology);
 397
 398     network.set_input_data("input", input);
 399     network.set_input_data("input2", input2);
 400     network.set_input_data("mask", mask);
 401     auto outputs = network.execute();
 402
 403     auto output = outputs.at("select").get_memory();
 404
 405     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 406         2.f,   0.f,    6.f,   5.2f,
 407         15.f,   0.5f,   8.f,  12.f,
 408         4.f,   6.5f,   8.f,  -2.5f };
 409
 410     auto output_ptr = output.pointer<float>();
 411
 412     for (int i = 0; i < 16; i++)
 413     {
 414         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 415     }
 416 }
 417
 418 TEST(select_gpu_f32, select_basic_mask_u8) {
 419     const auto& engine = get_test_engine();
 420
 421     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 422     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 2, 2, 2, 2 } });
 423     auto mask = memory::allocate(engine, { data_types::u8, format::yxfb,{ 2, 2, 2, 2 } });
 424
 425     topology topology;
 426     topology.add(input_layout("input", input.get_layout()));
 427     topology.add(input_layout("input2", input2.get_layout()));
 428     topology.add(input_layout("mask", mask.get_layout()));
 429     topology.add(cldnn::select("select", "input", "input2", "mask"));
 430
 431     set_values(input, {
 432         1.f,   0.f, 5.f, 1.5f,
 433         2.f,   0.f, 6.f, 5.2f,
 434         3.f,  0.5f, 7.f, 12.f,
 435         4.f, -0.5f, 8.f,  8.f
 436     });
 437
 438     set_values(input2, {
 439         0.5f,   2.5f,  0.5f,  2.5f,
 440         5.f,   7.f,    2.f,   4.f,
 441         15.f,  17.f,    8.f,  10.f,
 442         -2.f,  6.5f,  -0.5f, -2.5f });
 443
 444     set_values<unsigned char>(mask, {
 445         0,   0,  0,  0,
 446         128,   210,  150,  177,
 447         0,   211,  0,  255,
 448         199,   0,  160,  0 });
 449
 450     network network(engine, topology);
 451
 452     network.set_input_data("input", input);
 453     network.set_input_data("input2", input2);
 454     network.set_input_data("mask", mask);
 455     auto outputs = network.execute();
 456
 457     auto output = outputs.at("select").get_memory();
 458
 459     float answers[16] = { 0.5f,  2.5f,   0.5f,  2.5f,
 460         2.f,   0.f,    6.f,   5.2f,
 461         15.f,   0.5f,   8.f,  12.f,
 462         4.f,   6.5f,   8.f,  -2.5f };
 463
 464     auto output_ptr = output.pointer<float>();
 465
 466     for (int i = 0; i < 16; i++)
 467     {
 468         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 469     }
 470 }
 471
 472 TEST(select_gpu_f32, select_basic_1x1x2x2) {
 473     const auto& engine = get_test_engine();
 474
 475     auto input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
 476     auto input2 = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
 477     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
 478
 479     topology topology;
 480     topology.add(input_layout("input", input.get_layout()));
 481     topology.add(input_layout("input2", input2.get_layout()));
 482     topology.add(input_layout("mask", mask.get_layout()));
 483     topology.add(cldnn::select("select", "input", "input2", "mask"));
 484
 485     set_values(input, {
 486         1.f,    0.f,    2.f,    0.f
 487     });
 488
 489     set_values(input2, {
 490         0.5f,    2.5f,    5.f,    7.f
 491     });
 492
 493     set_values(mask, {
 494         0.f,    0.f,    1.f,    1.f
 495     });
 496
 497     network network(engine, topology);
 498
 499     network.set_input_data("input", input);
 500     network.set_input_data("input2", input2);
 501     network.set_input_data("mask", mask);
 502     auto outputs = network.execute();
 503
 504     auto output = outputs.at("select").get_memory();
 505
 506     float answers[4] = {
 507         0.5f,    2.5f,    2.f,    0.f
 508     };
 509
 510     auto output_ptr = output.pointer<float>();
 511
 512     for (int i = 0; i < 4; i++)
 513     {
 514         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 515     }
 516 }
 517
 518 TEST(select_gpu_f32, select_basic_bfyx_1x1x2x2) {
 519     const auto& engine = get_test_engine();
 520
 521     auto input = memory::allocate(engine, { data_types::f32, format::bfyx,{ 1, 1, 2, 2 } });
 522     auto input2 = memory::allocate(engine, { data_types::f32, format::bfyx,{ 1, 1, 2, 2 } });
 523     auto mask = memory::allocate(engine, { data_types::f32, format::bfyx,{ 1, 1, 2, 2 } });
 524
 525     topology topology;
 526     topology.add(input_layout("input", input.get_layout()));
 527     topology.add(input_layout("input2", input2.get_layout()));
 528     topology.add(input_layout("mask", mask.get_layout()));
 529     topology.add(cldnn::select("select", "input", "input2", "mask"));
 530
 531     set_values(input, {
 532         1.f,   0.f,
 533         2.f,   0.f
 534     });
 535
 536     set_values(input2, {
 537         0.5f,   2.5f,
 538         5.f,   7.f
 539     });
 540
 541     set_values(mask, {
 542         0.f,   0.f,
 543         1.f,   1.f
 544     });
 545
 546     network network(engine, topology);
 547
 548     network.set_input_data("input", input);
 549     network.set_input_data("input2", input2);
 550     network.set_input_data("mask", mask);
 551     auto outputs = network.execute();
 552
 553     auto output = outputs.at("select").get_memory();
 554
 555     float answers[4] = {
 556         0.5f,  2.5f,
 557         2.f,   0.f
 558     };
 559
 560     auto output_ptr = output.pointer<float>();
 561
 562     for (int i = 0; i < 4; i++)
 563     {
 564         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 565     }
 566 }
 567
 568 TEST(select_gpu_f32, select_basic_byxf_1x1x2x2) {
 569     const auto& engine = get_test_engine();
 570
 571     auto input = memory::allocate(engine, { data_types::f32, format::byxf,{ 1, 1, 2, 2 } });
 572     auto input2 = memory::allocate(engine, { data_types::f32, format::byxf,{ 1, 1, 2, 2 } });
 573     auto mask = memory::allocate(engine, { data_types::f32, format::byxf,{ 1, 1, 2, 2 } });
 574
 575     topology topology;
 576     topology.add(input_layout("input", input.get_layout()));
 577     topology.add(input_layout("input2", input2.get_layout()));
 578     topology.add(input_layout("mask", mask.get_layout()));
 579     topology.add(cldnn::select("select", "input", "input2", "mask"));
 580
 581     set_values(input, {
 582         1.f,   0.f,
 583         2.f,   0.f
 584     });
 585
 586     set_values(input2, {
 587         0.5f,   2.5f,
 588         5.f,   7.f
 589     });
 590
 591     set_values(mask, {
 592         0.f,   0.f,
 593         1.f,   1.f
 594     });
 595
 596     network network(engine, topology);
 597
 598     network.set_input_data("input", input);
 599     network.set_input_data("input2", input2);
 600     network.set_input_data("mask", mask);
 601     auto outputs = network.execute();
 602
 603     auto output = outputs.at("select").get_memory();
 604
 605     float answers[4] = {
 606         0.5f,  2.5f,
 607         2.f,   0.f
 608     };
 609
 610     auto output_ptr = output.pointer<float>();
 611
 612     for (int i = 0; i < 4; i++)
 613     {
 614         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 615     }
 616 }
 617
 618 // select_gpu_f16
 619 TEST(select_gpu_f16, select_basic_1x1x2x2) {
 620     const auto& engine = get_test_engine();
 621
 622     auto input = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 623     auto input2 = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 624     auto mask = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 625
 626     topology topology;
 627     topology.add(input_layout("input", input.get_layout()));
 628     topology.add(input_layout("input2", input2.get_layout()));
 629     topology.add(input_layout("mask", mask.get_layout()));
 630     topology.add(cldnn::select("select", "input", "input2", "mask"));
 631
 632     set_values<uint16_t>(input, {
 633         1,   0,
 634         2,   0
 635     });
 636
 637     set_values<uint16_t>(input2, {
 638         0,   2,
 639         5,   7
 640     });
 641
 642     set_values<uint16_t>(mask, {
 643         0,   0,
 644         1,   1
 645     });
 646
 647     network network(engine, topology);
 648
 649     network.set_input_data("input", input);
 650     network.set_input_data("input2", input2);
 651     network.set_input_data("mask", mask);
 652     auto outputs = network.execute();
 653
 654     auto output = outputs.at("select").get_memory();
 655
 656     uint16_t answers[4] = {
 657         0,  2,
 658         2,   0
 659     };
 660
 661     auto output_ptr = output.pointer<uint16_t>();
 662
 663     for (int i = 0; i < 4; i++)
 664     {
 665         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 666     }
 667 }
 668
 669 TEST(select_gpu_f16, select_basic_mask_f32_1x1x2x2) {
 670     const auto& engine = get_test_engine();
 671
 672     auto input = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 673     auto input2 = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 674     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
 675
 676     topology topology;
 677     topology.add(input_layout("input", input.get_layout()));
 678     topology.add(input_layout("input2", input2.get_layout()));
 679     topology.add(input_layout("mask", mask.get_layout()));
 680     topology.add(cldnn::select("select", "input", "input2", "mask"));
 681
 682     set_values<uint16_t>(input, {
 683         1,   0,
 684         2,   0
 685     });
 686
 687     set_values<uint16_t>(input2, {
 688         0,   2,
 689         5,   7
 690     });
 691
 692     set_values<float>(mask, {
 693         0.f,   0.f,
 694         1.5f,   0.4f
 695     });
 696
 697     network network(engine, topology);
 698
 699     network.set_input_data("input", input);
 700     network.set_input_data("input2", input2);
 701     network.set_input_data("mask", mask);
 702     auto outputs = network.execute();
 703
 704     auto output = outputs.at("select").get_memory();
 705
 706     uint16_t answers[4] = {
 707         0,  2,
 708         2,   0
 709     };
 710
 711     auto output_ptr = output.pointer<uint16_t>();
 712
 713     for (int i = 0; i < 4; i++)
 714     {
 715         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 716     }
 717 }
 718
 719 TEST(select_gpu_f16, select_basic_mask_i8_1x1x2x2) {
 720     const auto& engine = get_test_engine();
 721
 722     auto input = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 723     auto input2 = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 724     auto mask = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 725
 726     topology topology;
 727     topology.add(input_layout("input", input.get_layout()));
 728     topology.add(input_layout("input2", input2.get_layout()));
 729     topology.add(input_layout("mask", mask.get_layout()));
 730     topology.add(cldnn::select("select", "input", "input2", "mask"));
 731
 732     set_values<uint16_t>(input, {
 733         1,   0,
 734         2,   0
 735     });
 736
 737     set_values<uint16_t>(input2, {
 738         0,   2,
 739         5,   7
 740     });
 741
 742     set_values<char>(mask, {
 743         0,   0,
 744         1,   1
 745     });
 746
 747     network network(engine, topology);
 748
 749     network.set_input_data("input", input);
 750     network.set_input_data("input2", input2);
 751     network.set_input_data("mask", mask);
 752     auto outputs = network.execute();
 753
 754     auto output = outputs.at("select").get_memory();
 755
 756     uint16_t answers[4] = {
 757         0,  2,
 758         2,   0
 759     };
 760
 761     auto output_ptr = output.pointer<uint16_t>();
 762
 763     for (int i = 0; i < 4; i++)
 764     {
 765         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 766     }
 767 }
 768
 769 TEST(select_gpu_f16, select_basic_mask_u8_1x1x2x2) {
 770     const auto& engine = get_test_engine();
 771
 772     auto input = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 773     auto input2 = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 774     auto mask = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
 775
 776     topology topology;
 777     topology.add(input_layout("input", input.get_layout()));
 778     topology.add(input_layout("input2", input2.get_layout()));
 779     topology.add(input_layout("mask", mask.get_layout()));
 780     topology.add(cldnn::select("select", "input", "input2", "mask"));
 781
 782     set_values<uint16_t>(input, {
 783         1,   0,
 784         2,   0
 785     });
 786
 787     set_values<uint16_t>(input2, {
 788         0,   2,
 789         5,   7
 790     });
 791
 792     set_values<unsigned char>(mask, {
 793         0,   0,
 794         128,   255
 795     });
 796
 797     network network(engine, topology);
 798
 799     network.set_input_data("input", input);
 800     network.set_input_data("input2", input2);
 801     network.set_input_data("mask", mask);
 802     auto outputs = network.execute();
 803
 804     auto output = outputs.at("select").get_memory();
 805
 806     uint16_t answers[4] = {
 807         0,  2,
 808         2,   0
 809     };
 810
 811     auto output_ptr = output.pointer<uint16_t>();
 812
 813     for (int i = 0; i < 4; i++)
 814     {
 815         EXPECT_TRUE(are_equal(answers[i], output_ptr[i]));
 816     }
 817 }
 818
 819 // select_gpu_i8
 820 TEST(select_gpu_i8, select_basic_1x1x2x2) {
 821     const auto& engine = get_test_engine();
 822
 823     auto input = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 824     auto input2 = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 825     auto mask = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 826
 827     topology topology;
 828     topology.add(input_layout("input", input.get_layout()));
 829     topology.add(input_layout("input2", input2.get_layout()));
 830     topology.add(input_layout("mask", mask.get_layout()));
 831     topology.add(cldnn::select("select", "input", "input2", "mask"));
 832
 833     set_values<char>(input, {
 834         1,   0,
 835         2,   0
 836     });
 837
 838     set_values<char>(input2, {
 839         0,   2,
 840         5,   7
 841     });
 842
 843     set_values<char>(mask, {
 844         0,   0,
 845         3,   5
 846     });
 847
 848     network network(engine, topology);
 849
 850     network.set_input_data("input", input);
 851     network.set_input_data("input2", input2);
 852     network.set_input_data("mask", mask);
 853     auto outputs = network.execute();
 854
 855     auto output = outputs.at("select").get_memory();
 856
 857     int answers[4] = {
 858         0,  2,
 859         2,  0
 860     };
 861
 862     auto output_ptr = output.pointer<char>();
 863
 864     for (int i = 0; i < 4; i++)
 865     {
 866         EXPECT_EQ(answers[i], output_ptr[i]);
 867     }
 868 }
 869
 870 TEST(select_gpu_i8, select_basic_mask_f32_1x1x2x2) {
 871     const auto& engine = get_test_engine();
 872
 873     auto input = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 874     auto input2 = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 875     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
 876
 877     topology topology;
 878     topology.add(input_layout("input", input.get_layout()));
 879     topology.add(input_layout("input2", input2.get_layout()));
 880     topology.add(input_layout("mask", mask.get_layout()));
 881     topology.add(cldnn::select("select", "input", "input2", "mask"));
 882
 883     set_values<char>(input, {
 884         1,   0,
 885         2,   0
 886     });
 887
 888     set_values<char>(input2, {
 889         0,   2,
 890         5,   7
 891     });
 892
 893     set_values<float>(mask, {
 894         0.f,   0.f,
 895         1.5f,  0.4f
 896     });
 897
 898     network network(engine, topology);
 899
 900     network.set_input_data("input", input);
 901     network.set_input_data("input2", input2);
 902     network.set_input_data("mask", mask);
 903     auto outputs = network.execute();
 904
 905     auto output = outputs.at("select").get_memory();
 906
 907     int answers[4] = {
 908         0,  2,
 909         2,  0
 910     };
 911
 912     auto output_ptr = output.pointer<char>();
 913
 914     for (int i = 0; i < 4; i++)
 915     {
 916         EXPECT_EQ(answers[i], output_ptr[i]);
 917     }
 918 }
 919
 920 TEST(select_gpu_i8, select_basic_mask_f16_1x1x2x2) {
 921     const auto& engine = get_test_engine();
 922
 923     auto input = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 924     auto input2 = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 925     auto mask = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
 926
 927     topology topology;
 928     topology.add(input_layout("input", input.get_layout()));
 929     topology.add(input_layout("input2", input2.get_layout()));
 930     topology.add(input_layout("mask", mask.get_layout()));
 931     topology.add(cldnn::select("select", "input", "input2", "mask"));
 932
 933     set_values<char>(input, {
 934         1,   0,
 935         2,   0
 936     });
 937
 938     set_values<char>(input2, {
 939         0,   2,
 940         5,   7
 941     });
 942
 943     set_values<uint16_t>(mask, {
 944         0,   0,
 945         3,   5
 946     });
 947
 948     network network(engine, topology);
 949
 950     network.set_input_data("input", input);
 951     network.set_input_data("input2", input2);
 952     network.set_input_data("mask", mask);
 953     auto outputs = network.execute();
 954
 955     auto output = outputs.at("select").get_memory();
 956
 957     int answers[4] = {
 958         0,  2,
 959         2,  0
 960     };
 961
 962     auto output_ptr = output.pointer<char>();
 963
 964     for (int i = 0; i < 4; i++)
 965     {
 966         EXPECT_EQ(answers[i], output_ptr[i]);
 967     }
 968 }
 969
 970 TEST(select_gpu_i8, select_basic_mask_u8_1x1x2x2) {
 971     const auto& engine = get_test_engine();
 972
 973     auto input = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 974     auto input2 = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
 975     auto mask = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
 976
 977     topology topology;
 978     topology.add(input_layout("input", input.get_layout()));
 979     topology.add(input_layout("input2", input2.get_layout()));
 980     topology.add(input_layout("mask", mask.get_layout()));
 981     topology.add(cldnn::select("select", "input", "input2", "mask"));
 982
 983     set_values<char>(input, {
 984         1,   0,
 985         2,   0
 986     });
 987
 988     set_values<char>(input2, {
 989         0,   2,
 990         5,   7
 991     });
 992
 993     set_values<unsigned char>(mask, {
 994         0,   0,
 995         128,   255
 996     });
 997
 998     network network(engine, topology);
 999
1000     network.set_input_data("input", input);
1001     network.set_input_data("input2", input2);
1002     network.set_input_data("mask", mask);
1003     auto outputs = network.execute();
1004
1005     auto output = outputs.at("select").get_memory();
1006
1007     int answers[4] = {
1008         0,  2,
1009         2,  0
1010     };
1011
1012     auto output_ptr = output.pointer<char>();
1013
1014     for (int i = 0; i < 4; i++)
1015     {
1016         EXPECT_EQ(answers[i], output_ptr[i]);
1017     }
1018 }
1019
1020 // select_gpu_u8
1021 TEST(select_gpu_u8, select_basic_1x1x2x2) {
1022     const auto& engine = get_test_engine();
1023
1024     auto input = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1025     auto input2 = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1026     auto mask = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1027
1028     topology topology;
1029     topology.add(input_layout("input", input.get_layout()));
1030     topology.add(input_layout("input2", input2.get_layout()));
1031     topology.add(input_layout("mask", mask.get_layout()));
1032     topology.add(cldnn::select("select", "input", "input2", "mask"));
1033
1034     set_values<unsigned char>(input, {
1035         128,   0,
1036         255,   0
1037     });
1038
1039     set_values<unsigned char>(input2, {
1040         0,   255,
1041         205,   128
1042     });
1043
1044     set_values<unsigned char>(mask, {
1045         0,   0,
1046         128,   255
1047     });
1048
1049     network network(engine, topology);
1050
1051     network.set_input_data("input", input);
1052     network.set_input_data("input2", input2);
1053     network.set_input_data("mask", mask);
1054     auto outputs = network.execute();
1055
1056     auto output = outputs.at("select").get_memory();
1057
1058     unsigned char answers[4] = {
1059         0,  255,
1060         255,  0
1061     };
1062
1063     auto output_ptr = output.pointer<unsigned char>();
1064
1065     for (int i = 0; i < 4; i++)
1066     {
1067         EXPECT_EQ(answers[i], output_ptr[i]);
1068     }
1069 }
1070
1071 TEST(select_gpu_u8, select_basic_mask_f32_1x1x2x2) {
1072     const auto& engine = get_test_engine();
1073
1074     auto input = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1075     auto input2 = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1076     auto mask = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, 2, 2 } });
1077
1078     topology topology;
1079     topology.add(input_layout("input", input.get_layout()));
1080     topology.add(input_layout("input2", input2.get_layout()));
1081     topology.add(input_layout("mask", mask.get_layout()));
1082     topology.add(cldnn::select("select", "input", "input2", "mask"));
1083
1084     set_values<unsigned char>(input, {
1085         128,   0,
1086         255,   0
1087     });
1088
1089     set_values<unsigned char>(input2, {
1090         0,   255,
1091         205,   128
1092     });
1093
1094     set_values<float>(mask, {
1095         0.f,   0.f,
1096         1.5f,  0.4f
1097     });
1098
1099     network network(engine, topology);
1100
1101     network.set_input_data("input", input);
1102     network.set_input_data("input2", input2);
1103     network.set_input_data("mask", mask);
1104     auto outputs = network.execute();
1105
1106     auto output = outputs.at("select").get_memory();
1107
1108     int answers[4] = {
1109         0,  255,
1110         255,  0
1111     };
1112
1113     auto output_ptr = output.pointer<unsigned char>();
1114
1115     for (int i = 0; i < 4; i++)
1116     {
1117         EXPECT_EQ(answers[i], output_ptr[i]);
1118     }
1119 }
1120
1121 TEST(select_gpu_u8, select_basic_mask_f16_1x1x2x2) {
1122     const auto& engine = get_test_engine();
1123
1124     auto input = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1125     auto input2 = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1126     auto mask = memory::allocate(engine, { data_types::f16, format::yxfb,{ 1, 1, 2, 2 } });
1127
1128     topology topology;
1129     topology.add(input_layout("input", input.get_layout()));
1130     topology.add(input_layout("input2", input2.get_layout()));
1131     topology.add(input_layout("mask", mask.get_layout()));
1132     topology.add(cldnn::select("select", "input", "input2", "mask"));
1133
1134     set_values<unsigned char>(input, {
1135         128,   0,
1136         255,   0
1137     });
1138
1139     set_values<unsigned char>(input2, {
1140         0,   255,
1141         205,   128
1142     });
1143
1144     set_values<uint16_t>(mask, {
1145         0,   0,
1146         1,   1
1147     });
1148
1149     network network(engine, topology);
1150
1151     network.set_input_data("input", input);
1152     network.set_input_data("input2", input2);
1153     network.set_input_data("mask", mask);
1154     auto outputs = network.execute();
1155
1156     auto output = outputs.at("select").get_memory();
1157
1158     unsigned char answers[4] = {
1159         0,  255,
1160         255,  0
1161     };
1162
1163     auto output_ptr = output.pointer<unsigned char>();
1164
1165     for (int i = 0; i < 4; i++)
1166     {
1167         EXPECT_EQ(answers[i], output_ptr[i]);
1168     }
1169 }
1170
1171 TEST(select_gpu_u8, select_basic_mask_i8_1x1x2x2) {
1172     const auto& engine = get_test_engine();
1173
1174     auto input = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1175     auto input2 = memory::allocate(engine, { data_types::u8, format::yxfb,{ 1, 1, 2, 2 } });
1176     auto mask = memory::allocate(engine, { data_types::i8, format::yxfb,{ 1, 1, 2, 2 } });
1177
1178     topology topology;
1179     topology.add(input_layout("input", input.get_layout()));
1180     topology.add(input_layout("input2", input2.get_layout()));
1181     topology.add(input_layout("mask", mask.get_layout()));
1182     topology.add(cldnn::select("select", "input", "input2", "mask"));
1183
1184     set_values<unsigned char>(input, {
1185         128,   0,
1186         255,   0
1187     });
1188
1189     set_values<unsigned char>(input2, {
1190         0,   255,
1191         205,   128
1192     });
1193
1194     set_values<char>(mask, {
1195         0,   0,
1196         1,   1
1197     });
1198
1199     network network(engine, topology);
1200
1201     network.set_input_data("input", input);
1202     network.set_input_data("input2", input2);
1203     network.set_input_data("mask", mask);
1204     auto outputs = network.execute();
1205
1206     auto output = outputs.at("select").get_memory();
1207
1208     unsigned char answers[4] = {
1209         0,  255,
1210         255,  0
1211     };
1212
1213     auto output_ptr = output.pointer<unsigned char>();
1214
1215     for (int i = 0; i < 4; i++)
1216     {
1217         EXPECT_EQ(answers[i], output_ptr[i]);
1218     }
1219 }