inference-engine/thirdparty/clDNN/tests/test_cases/max_unpooling_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/max_unpooling.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 #include <api/CPP/reorder.hpp>
  27 #include <api/CPP/data.hpp>
  28 #include <api/CPP/mutable_data.hpp>
  29 #include <api/CPP/pooling.hpp>
  30 #include "test_utils/float16.h"
  31
  32 using namespace cldnn;
  33 using namespace tests;
  34
  35 TEST(max_unpooling_gpu, basic_in2x3x2x2) {
  36     //  Input  : 2x2x2x1
  37     //  Argmax : 2x2x2x1
  38     //  Output : 2x2x3x2
  39
  40     //  Forward Max Pooling Input:
  41     //  f0: b0:  1    2  -10   b1:   0    0     -11
  42     //  f0: b0:  3    4  -14   b1:   0.5 -0.5   -15
  43     //  f1: b0:  5    6  -12   b1:   1.5  5.2   -13
  44     //  f1: b0:  7    8   16    b1:   12   9     17
  45     //
  46     //  Input:
  47     //  f0: b0:  4    4   b1:   0.5    0
  48     //  f1: b0:  8   16   b1:   12    17
  49     //
  50     //  Argmax:
  51     //  f0: b0:  4    4   b1:   15    13
  52     //  f1: b0:  10  11   b1:   21    23
  53     //
  54     //  Output:
  55     //  f0: b0:  0    0  0   b1:   0    0    0
  56     //  f0: b0:  0    4  0   b1:   0.5  0    0
  57     //  f1: b0:  0    0  0   b1:   0    0    0
  58     //  f1: b0:  0    8  16  b1:   12   0    17
  59
  60     const auto& engine = get_test_engine();
  61
  62     auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 2, 1 } });
  63     auto arg_max = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
  64
  65     set_values(input, {
  66         4.0f, 4.0f,
  67         8.0f, 16.0f,
  68         0.5f, 0.0f,
  69         12.0f, 17.0f
  70     });
  71
  72     set_values(arg_max, {
  73         4.0f, 4.0f,
  74         10.0f, 11.0f,
  75         15.0f, 13.0f,
  76         21.0f, 23.0f
  77     });
  78
  79     topology topology;
  80     topology.add(input_layout("input", input.get_layout()));
  81     topology.add(data("arg_max", arg_max));
  82     topology.add(max_unpooling("max_unpooling", "input", "arg_max", { 1, 1, 2, 2 }, { 1, 1, 1, 1 }));
  83
  84     network network(engine, topology);
  85
  86     network.set_input_data("input", input);
  87
  88     auto outputs = network.execute();
  89
  90     auto output = outputs.at("max_unpooling").get_memory();
  91     auto output_ptr = output.pointer<float>();
  92     auto output_layout = output.get_layout();
  93
  94     EXPECT_EQ(output_layout.format, format::bfyx);
  95     EXPECT_EQ(output_layout.size.spatial[1], 2);
  96     EXPECT_EQ(output_layout.size.spatial[0], 3);
  97     EXPECT_EQ(output_layout.size.feature[0], 2);
  98     EXPECT_EQ(output_layout.size.batch[0], 2);
  99
 100     std::vector<float> expected_output_vec = {
 101         0.f, 0.f, 0.f,
 102         0.f, 4.f, 0.f,
 103         0.f, 0.f, 0.f,
 104         0.f, 8.f, 16.f,
 105         0.f, 0.f, 0.f,
 106         0.5f, 0.f, 0.f,
 107         0.f, 0.f, 0.f,
 108         12.f, 0.f, 17.f,
 109     };
 110
 111     for (size_t i = 0; i < expected_output_vec.size(); ++i) {
 112         EXPECT_EQ(expected_output_vec[i], output_ptr[i]);
 113     }
 114 }
 115
 116 TEST(max_unpooling_gpu, basic_in2x3x2x2_output_padding) {
 117     //  Input  : 2x2x2x1
 118     //  Argmax : 2x2x2x1
 119     //  Output : 2x2x3x2
 120     //  Output Padding : 0x0x1x1
 121
 122     //  Forward Max Pooling Input:
 123     //  f0: b0:  1    2  -10   b1:   0    0     -11
 124     //  f0: b0:  3    4  -14   b1:   0.5 -0.5   -15
 125     //  f1: b0:  5    6  -12   b1:   1.5  5.2   -13
 126     //  f1: b0:  7    8   16    b1:   12   9     17
 127     //
 128     //  Input:
 129     //  f0: b0:  4    4   b1:   0.5    0
 130     //  f1: b0:  8   16   b1:   12    17
 131     //
 132     //  Argmax:
 133     //  f0: b0:  4    4   b1:   15    13
 134     //  f1: b0:  10  11   b1:   21    23
 135     //
 136     //  Output:
 137     //  f0: b0:  0    0  0   b1:   0    0    0
 138     //  f0: b0:  0    4  0   b1:   0.5  0    0
 139     //  f1: b0:  0    0  0   b1:   0    0    0
 140     //  f1: b0:  0    8  16  b1:   12   0    17
 141
 142     const auto& engine = get_test_engine();
 143
 144     auto input = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 145     auto arg_max = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 146
 147     set_values(input, {
 148         4.0f, 4.0f,
 149         8.0f, 16.0f,
 150         0.5f, 0.0f,
 151         12.0f, 17.0f
 152     });
 153
 154     set_values(arg_max, {
 155         4.0f, 4.0f,
 156         10.0f, 11.0f,
 157         15.0f, 13.0f,
 158         21.0f, 23.0f
 159     });
 160
 161     topology topology;
 162     topology.add(input_layout("input", input.get_layout()));
 163     topology.add(data("arg_max", arg_max));
 164     topology.add(max_unpooling("max_unpooling", "input", "arg_max", { 1, 1, 2, 2 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, padding({ 0, 0, 1, 1 }, 0)));
 165
 166     network network(engine, topology);
 167
 168     network.set_input_data("input", input);
 169
 170     auto outputs = network.execute();
 171
 172     auto output = outputs.at("max_unpooling").get_memory();
 173     auto output_ptr = output.pointer<float>();
 174     auto output_layout = output.get_layout();
 175
 176     EXPECT_EQ(output_layout.format, format::bfyx);
 177     EXPECT_EQ(output_layout.size.spatial[1], 2);
 178     EXPECT_EQ(output_layout.size.spatial[0], 3);
 179     EXPECT_EQ(output_layout.size.feature[0], 2);
 180     EXPECT_EQ(output_layout.size.batch[0], 2);
 181
 182     std::vector<float> expected_output_vec = {
 183         0.f, 0.f, 0.f, 0.f, 0.f,
 184         0.f, 0.f, 0.f, 0.f, 0.f,
 185         0.f, 0.f, 4.f, 0.f, 0.f,
 186         0.f, 0.f, 0.f, 0.f, 0.f,
 187         0.f, 0.f, 0.f, 0.f, 0.f,
 188         0.f, 0.f, 0.f, 0.f, 0.f,
 189         0.f, 0.f, 8.f, 16.f, 0.f,
 190         0.f, 0.f, 0.f, 0.f, 0.f,
 191         0.f, 0.f, 0.f, 0.f, 0.f,
 192         0.f, 0.f, 0.f, 0.f, 0.f,
 193         0.f, 0.5f, 0.f, 0.f, 0.f,
 194         0.f, 0.f, 0.f, 0.f, 0.f,
 195         0.f, 0.f, 0.f, 0.f, 0.f,
 196         0.f, 0.f, 0.f, 0.f, 0.f,
 197         0.f, 12.f, 0.f, 17.f, 0.f,
 198         0.f, 0.f, 0.f, 0.f, 0.f,
 199     };
 200     std::vector<float> out;
 201     for (size_t i = 0; i < expected_output_vec.size(); ++i) {
 202         out.push_back(output_ptr[i]);
 203         EXPECT_EQ(expected_output_vec[i], output_ptr[i]);
 204     }
 205 }
 206
 207 TEST(max_unpooling_gpu, basic_in2x3x2x2_output_size) {
 208     //  Input  : 2x2x2x1
 209     //  Argmax : 2x2x2x1
 210     //  Output : 2x2x3x2
 211     //  Output size explicitly provided
 212
 213     //  Forward Max Pooling Input:
 214     //  f0: b0:  1    2  -10   b1:   0    0     -11
 215     //  f0: b0:  3    4  -14   b1:   0.5 -0.5   -15
 216     //  f1: b0:  5    6  -12   b1:   1.5  5.2   -13
 217     //  f1: b0:  7    8   16    b1:   12   9     17
 218     //
 219     //  Input:
 220     //  f0: b0:  4    4   b1:   0.5    0
 221     //  f1: b0:  8   16   b1:   12    17
 222     //
 223     //  Argmax:
 224     //  f0: b0:  4    4   b1:   15    13
 225     //  f1: b0:  10  11   b1:   21    23
 226     //
 227     //  Output:
 228     //  f0: b0:  0    0  0   b1:   0    0    0
 229     //  f0: b0:  0    4  0   b1:   0.5  0    0
 230     //  f1: b0:  0    0  0   b1:   0    0    0
 231     //  f1: b0:  0    8  16  b1:   12   0    17
 232
 233     const auto& engine = get_test_engine();
 234
 235     auto input = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 236     auto arg_max = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 237
 238     set_values(input, {
 239         4.0f, 4.0f,
 240         8.0f, 16.0f,
 241         0.5f, 0.0f,
 242         12.0f, 17.0f
 243     });
 244
 245     set_values(arg_max, {
 246         4.0f, 4.0f,
 247         10.0f, 11.0f,
 248         15.0f, 13.0f,
 249         21.0f, 23.0f
 250     });
 251
 252     topology topology;
 253     topology.add(input_layout("input", input.get_layout()));
 254     topology.add(data("arg_max", arg_max));
 255     topology.add(max_unpooling("max_unpooling", "input", "arg_max", {2, 2, 3, 2}));
 256
 257     network network(engine, topology);
 258
 259     network.set_input_data("input", input);
 260
 261     auto outputs = network.execute();
 262
 263     auto output = outputs.at("max_unpooling").get_memory();
 264     auto output_ptr = output.pointer<float>();
 265     auto output_layout = output.get_layout();
 266
 267     EXPECT_EQ(output_layout.format, format::bfyx);
 268     EXPECT_EQ(output_layout.size.spatial[1], 2);
 269     EXPECT_EQ(output_layout.size.spatial[0], 3);
 270     EXPECT_EQ(output_layout.size.feature[0], 2);
 271     EXPECT_EQ(output_layout.size.batch[0], 2);
 272
 273     std::vector<float> expected_output_vec = {
 274         0.f, 0.f, 0.f,
 275         0.f, 4.f, 0.f,
 276         0.f, 0.f, 0.f,
 277         0.f, 8.f, 16.f,
 278         0.f, 0.f, 0.f,
 279         0.5f, 0.f, 0.f,
 280         0.f, 0.f, 0.f,
 281         12.f, 0.f, 17.f,
 282     };
 283     for (size_t i = 0; i < expected_output_vec.size(); ++i) {
 284         EXPECT_EQ(expected_output_vec[i], output_ptr[i]);
 285     }
 286 }
 287
 288 TEST(max_unpooling_gpu, basic_in2x3x2x2_fp16) {
 289     //  Input  : 2x2x2x1
 290     //  Argmax : 2x2x2x1
 291     //  Output : 2x2x3x2
 292     //  Input values in fp16
 293
 294     //  Forward Max Pooling Input:
 295     //  f0: b0:  1    2  -10   b1:   0    0     -11
 296     //  f0: b0:  3    4  -14   b1:   0.5 -0.5   -15
 297     //  f1: b0:  5    6  -12   b1:   1.5  5.2   -13
 298     //  f1: b0:  7    8   16    b1:   12   9     17
 299     //
 300     //  Input:
 301     //  f0: b0:  4    4   b1:   0.5    0
 302     //  f1: b0:  8   16   b1:   12    17
 303     //
 304     //  Argmax:
 305     //  f0: b0:  4    4   b1:   15    13
 306     //  f1: b0:  10  11   b1:   21    23
 307     //
 308     //  Output:
 309     //  f0: b0:  0    0  0   b1:   0    0    0
 310     //  f0: b0:  0    4  0   b1:   0.5  0    0
 311     //  f1: b0:  0    0  0   b1:   0    0    0
 312     //  f1: b0:  0    8  16  b1:   12   0    17
 313
 314     const auto& engine = get_test_engine();
 315
 316     auto input = memory::allocate(engine, { data_types::f16, format::bfyx,{ 2, 2, 2, 1 } });
 317     auto arg_max = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 318
 319     set_values(input, {
 320         FLOAT16(4.0f), FLOAT16(4.0f),
 321         FLOAT16(8.0f), FLOAT16(16.0f),
 322         FLOAT16(0.5f), FLOAT16(0.0f),
 323         FLOAT16(12.0f), FLOAT16(17.0f)
 324     });
 325
 326     set_values(arg_max, {
 327         4.0f, 4.0f,
 328         10.0f, 11.0f,
 329         15.0f, 13.0f,
 330         21.0f, 23.0f
 331     });
 332
 333     topology topology;
 334     topology.add(input_layout("input", input.get_layout()));
 335     topology.add(data("arg_max", arg_max));
 336     topology.add(max_unpooling("max_unpooling", "input", "arg_max", { 1, 1, 2, 2 }, { 1, 1, 1, 1 }));
 337
 338     network network(engine, topology);
 339
 340     network.set_input_data("input", input);
 341
 342     auto outputs = network.execute();
 343
 344     auto output = outputs.at("max_unpooling").get_memory();
 345     auto output_ptr = output.pointer<uint16_t>();
 346     auto output_layout = output.get_layout();
 347
 348     EXPECT_EQ(output_layout.format, format::bfyx);
 349     EXPECT_EQ(output_layout.size.spatial[1], 2);
 350     EXPECT_EQ(output_layout.size.spatial[0], 3);
 351     EXPECT_EQ(output_layout.size.feature[0], 2);
 352     EXPECT_EQ(output_layout.size.batch[0], 2);
 353
 354     std::vector<float> expected_output_vec = {
 355         0.f, 0.f, 0.f,
 356         0.f, 4.f, 0.f,
 357         0.f, 0.f, 0.f,
 358         0.f, 8.f, 16.f,
 359         0.f, 0.f, 0.f,
 360         0.5f, 0.f, 0.f,
 361         0.f, 0.f, 0.f,
 362         12.f, 0.f, 17.f,
 363     };
 364     for (size_t i = 0; i < expected_output_vec.size(); ++i) {
 365         EXPECT_EQ(expected_output_vec[i], float16_to_float32(output_ptr[i]));
 366     }
 367 }
 368
 369 TEST(max_unpooling_gpu, basic_in2x2x3x2_max_with_argmax_pooling_unpooling) {
 370     //  Input  : 2x2x3x2
 371     //  Argmax : 2x2x2x1
 372     //  Output : 2x2x2x2
 373
 374     //  Forward Max Pooling Input:
 375     //  f0: b0:  1    2  -10   b1:   0    0     -11
 376     //  f0: b0:  3    4  -14   b1:   0.5 -0.5   -15
 377     //  f1: b0:  5    6  -12   b1:   1.5  5.2   -13
 378     //  f1: b0:  7    8   16    b1:   12   9     17
 379     //
 380     //  Forward Max Pooling Output:
 381     //  f0: b0:  4    4   b1:   0.5    0
 382     //  f1: b0:  8   16   b1:   12    17
 383     //
 384     //  Argmax:
 385     //  f0: b0:  4    4   b1:   15    13
 386     //  f1: b0:  10  11   b1:   21    23
 387     //
 388     //  Unpooling output:
 389     //  f0: b0:  0    0  0   b1:   0    0    0
 390     //  f0: b0:  0    4  0   b1:   0.5  0    0
 391     //  f1: b0:  0    0  0   b1:   0    0    0
 392     //  f1: b0:  0    8  16  b1:   12   0    17
 393
 394
 395     const auto& engine = get_test_engine();
 396
 397     auto input = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 3, 2 } });
 398     auto arg_max = memory::allocate(engine, { data_types::f32, format::bfyx,{ 2, 2, 2, 1 } });
 399
 400     set_values(input, {
 401         1.0f, 2.0f, -10.f,
 402         3.0f, 4.0f, -14.f,
 403         5.0f, 6.0f, -12.f,
 404         7.0f, 8.0f, 16.0f,
 405         0.f, 0.f, -11.f,
 406         0.5f, -0.5f, -15.f,
 407         1.5f, 5.2f, -13.f,
 408         12.f, 9.f, 17.f
 409     });
 410
 411     topology topology;
 412     topology.add(input_layout("input", input.get_layout()));
 413     topology.add(mutable_data("arg_max", arg_max));
 414     topology.add(pooling("pooling_max_with_argmax", "input", "arg_max", pooling_mode::max_with_argmax, { 1, 1, 2, 2 }, { 1, 1, 1, 1 }));
 415     topology.add(max_unpooling("max_unpooling", "pooling_max_with_argmax", "arg_max", { 1, 1, 2, 2 }, { 1, 1, 1, 1 }));
 416
 417     network network(engine, topology);
 418
 419     network.set_input_data("input", input);
 420
 421     auto outputs = network.execute();
 422
 423     auto output = outputs.at("max_unpooling").get_memory();
 424     auto output_ptr = output.pointer<float>();
 425     auto output_layout = output.get_layout();
 426     auto argmax_ptr = arg_max.pointer<float>();
 427
 428     EXPECT_EQ(output_layout.format, format::bfyx);
 429     EXPECT_EQ(output_layout.size.spatial[1], 2);
 430     EXPECT_EQ(output_layout.size.spatial[0], 3);
 431     EXPECT_EQ(output_layout.size.feature[0], 2);
 432     EXPECT_EQ(output_layout.size.batch[0], 2);
 433
 434     std::vector<float> expected_argmax_vec = {
 435         4.0f, 4.0f,
 436         10.0f, 11.0f,
 437         15.0f, 13.0f,
 438         21.0f, 23.0f
 439     };
 440
 441     std::vector<float> expected_output_vec = {
 442         0.f, 0.f, 0.f,
 443         0.f, 4.f, 0.f,
 444         0.f, 0.f, 0.f,
 445         0.f, 8.f, 16.f,
 446         0.f, 0.f, 0.f,
 447         0.5f, 0.f, 0.f,
 448         0.f, 0.f, 0.f,
 449         12.f, 0.f, 17.f,
 450     };
 451
 452     for (size_t i = 0; i < expected_output_vec.size(); ++i) {
 453         EXPECT_EQ(expected_output_vec[i], output_ptr[i]);
 454     }
 455
 456     for (size_t i = 0; i < expected_argmax_vec.size(); ++i) {
 457         EXPECT_EQ(expected_argmax_vec[i], argmax_ptr[i]);
 458     }
 459 }