ngraph/test/backend/one_hot.in.cpp

   1 //*****************************************************************************
   2 // Copyright 2017-2020 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 #include <algorithm>
  18 #include <cinttypes>
  19 #include <cmath>
  20 #include <cstdlib>
  21 #include <random>
  22 #include <string>
  23
  24 #include "gtest/gtest.h"
  25 #include "ngraph/ngraph.hpp"
  26 #include "ngraph/runtime/tensor.hpp"
  27 #include "runtime/backend.hpp"
  28 #include "util/all_close.hpp"
  29 #include "util/all_close_f.hpp"
  30 #include "util/ndarray.hpp"
  31 #include "util/test_control.hpp"
  32 #include "util/test_tools.hpp"
  33
  34 NGRAPH_SUPPRESS_DEPRECATED_START
  35
  36 using namespace std;
  37 using namespace ngraph;
  38
  39 static string s_manifest = "${MANIFEST}";
  40
  41 NGRAPH_TEST(${BACKEND_NAME}, one_hot_scalar_2_in_3)
  42 {
  43     Shape shape_a{};
  44     auto A = make_shared<op::Parameter>(element::i32, shape_a);
  45     Shape shape_r{3};
  46     auto r = make_shared<op::OneHot>(A, Shape{3}, 0);
  47     auto f = make_shared<Function>(r, ParameterVector{A});
  48
  49     auto backend = runtime::Backend::create("${BACKEND_NAME}");
  50
  51     // Create some tensors for input/output
  52     auto a = backend->create_tensor(element::i32, shape_a);
  53     copy_data(a, vector<int32_t>{2});
  54     auto result = backend->create_tensor(element::i32, shape_r);
  55
  56     auto handle = backend->compile(f);
  57     handle->call_with_validate({result}, {a});
  58     EXPECT_EQ((vector<int32_t>{0, 0, 1}), read_vector<int32_t>(result));
  59 }
  60
  61 NGRAPH_TEST(${BACKEND_NAME}, one_hot_scalar_1_in_3)
  62 {
  63     Shape shape_a{};
  64     auto A = make_shared<op::Parameter>(element::i32, shape_a);
  65     Shape shape_r{3};
  66     auto r = make_shared<op::OneHot>(A, Shape{3}, 0);
  67     auto f = make_shared<Function>(r, ParameterVector{A});
  68
  69     auto backend = runtime::Backend::create("${BACKEND_NAME}");
  70
  71     // Create some tensors for input/output
  72     auto a = backend->create_tensor(element::i32, shape_a);
  73     copy_data(a, vector<int32_t>{1});
  74     auto result = backend->create_tensor(element::i32, shape_r);
  75
  76     auto handle = backend->compile(f);
  77     handle->call_with_validate({result}, {a});
  78     EXPECT_EQ((vector<int32_t>{0, 1, 0}), read_vector<int32_t>(result));
  79 }
  80
  81 NGRAPH_TEST(${BACKEND_NAME}, one_hot_scalar_0_in_3)
  82 {
  83     Shape shape_a{};
  84     auto A = make_shared<op::Parameter>(element::i32, shape_a);
  85     Shape shape_r{3};
  86     auto r = make_shared<op::OneHot>(A, Shape{3}, 0);
  87     auto f = make_shared<Function>(r, ParameterVector{A});
  88
  89     auto backend = runtime::Backend::create("${BACKEND_NAME}");
  90
  91     // Create some tensors for input/output
  92     auto a = backend->create_tensor(element::i32, shape_a);
  93     copy_data(a, vector<int32_t>{0});
  94     auto result = backend->create_tensor(element::i32, shape_r);
  95
  96     auto handle = backend->compile(f);
  97     handle->call_with_validate({result}, {a});
  98     EXPECT_EQ((vector<int32_t>{1, 0, 0}), read_vector<int32_t>(result));
  99 }
 100
 101 NGRAPH_TEST(${BACKEND_NAME}, one_hot_vector_0)
 102 {
 103     Shape shape_a{8};
 104     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 105     Shape shape_r{3, 8};
 106     auto r = make_shared<op::OneHot>(A, Shape{3, 8}, 0);
 107     auto f = make_shared<Function>(r, ParameterVector{A});
 108
 109     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 110
 111     // Create some tensors for input/output
 112     auto a = backend->create_tensor(element::i32, shape_a);
 113     copy_data(a, vector<int32_t>{2, 1, 0, 0, 2, 2, 1, 0});
 114     auto result = backend->create_tensor(element::i32, shape_r);
 115
 116     auto handle = backend->compile(f);
 117     handle->call_with_validate({result}, {a});
 118     EXPECT_EQ(
 119         (vector<int32_t>{0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0}),
 120         read_vector<int32_t>(result));
 121 }
 122
 123 NGRAPH_TEST(${BACKEND_NAME}, one_hot_vector_1)
 124 {
 125     Shape shape_a{8};
 126     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 127     Shape shape_r{8, 3};
 128     auto r = make_shared<op::OneHot>(A, Shape{8, 3}, 1);
 129     auto f = make_shared<Function>(r, ParameterVector{A});
 130
 131     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 132
 133     // Create some tensors for input/output
 134     auto a = backend->create_tensor(element::i32, shape_a);
 135     copy_data(a, vector<int32_t>{2, 1, 0, 0, 2, 2, 1, 0});
 136     auto result = backend->create_tensor(element::i32, shape_r);
 137
 138     auto handle = backend->compile(f);
 139     handle->call_with_validate({result}, {a});
 140     EXPECT_EQ(
 141         (vector<int32_t>{0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0}),
 142         read_vector<int32_t>(result));
 143 }
 144
 145 NGRAPH_TEST(${BACKEND_NAME}, one_hot_vector_1_barely_oob)
 146 {
 147     Shape shape_a{8};
 148     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 149     Shape shape_r{8, 3};
 150     auto r = make_shared<op::OneHot>(A, Shape{8, 3}, 1);
 151     auto f = make_shared<Function>(r, ParameterVector{A});
 152
 153     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 154
 155     // Create some tensors for input/output
 156     auto a = backend->create_tensor(element::i32, shape_a);
 157     copy_data(a, vector<int32_t>{2, 1, 0, 0, 3, 2, 1, 0});
 158     auto result = backend->create_tensor(element::i32, shape_r);
 159
 160     auto handle = backend->compile(f);
 161     handle->call_with_validate({result}, {a});
 162     vector<int32_t> rv = read_vector<int32_t>(result);
 163
 164     EXPECT_EQ(rv[0], 0);
 165     EXPECT_EQ(rv[1], 0);
 166     EXPECT_EQ(rv[2], 1);
 167
 168     EXPECT_EQ(rv[3], 0);
 169     EXPECT_EQ(rv[4], 1);
 170     EXPECT_EQ(rv[5], 0);
 171
 172     EXPECT_EQ(rv[6], 1);
 173     EXPECT_EQ(rv[7], 0);
 174     EXPECT_EQ(rv[8], 0);
 175
 176     EXPECT_EQ(rv[9], 1);
 177     EXPECT_EQ(rv[10], 0);
 178     EXPECT_EQ(rv[11], 0);
 179
 180     // These are undefined since value is out of bounds
 181     // EXPECT_EQ(rv[12], 0);
 182     // EXPECT_EQ(rv[13], 0);
 183     // EXPECT_EQ(rv[14], 0);
 184
 185     EXPECT_EQ(rv[15], 0);
 186     EXPECT_EQ(rv[16], 0);
 187     EXPECT_EQ(rv[17], 1);
 188
 189     EXPECT_EQ(rv[18], 0);
 190     EXPECT_EQ(rv[19], 1);
 191     EXPECT_EQ(rv[20], 0);
 192
 193     EXPECT_EQ(rv[21], 1);
 194     EXPECT_EQ(rv[22], 0);
 195     EXPECT_EQ(rv[23], 0);
 196 }
 197
 198 NGRAPH_TEST(${BACKEND_NAME}, one_hot_matrix_0)
 199 {
 200     Shape shape_a{3, 3};
 201     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 202     Shape shape_r{3, 3, 3};
 203     auto r = make_shared<op::OneHot>(A, Shape{3, 3, 3}, 0);
 204     auto f = make_shared<Function>(r, ParameterVector{A});
 205
 206     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 207
 208     // Create some tensors for input/output
 209     auto a = backend->create_tensor(element::i32, shape_a);
 210     copy_data(a,
 211               vector<int32_t>{
 212                   0, 1, 1, 2, 1, 0, 0, 2, 1,
 213               });
 214     auto result = backend->create_tensor(element::i32, shape_r);
 215
 216     auto handle = backend->compile(f);
 217     handle->call_with_validate({result}, {a});
 218     EXPECT_EQ((vector<int32_t>{1, 0, 0, 0, 0, 1, 1, 0, 0,
 219
 220                                0, 1, 1, 0, 1, 0, 0, 0, 1,
 221
 222                                0, 0, 0, 1, 0, 0, 0, 1, 0}),
 223               read_vector<int32_t>(result));
 224 }
 225
 226 NGRAPH_TEST(${BACKEND_NAME}, one_hot_vector_many_categories)
 227 {
 228     // Imagenet has roughly 20,000 categories
 229     uint32_t category_count = 20000;
 230     Shape shape_a{6};
 231     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 232     Shape shape_r{6, category_count};
 233     auto r = make_shared<op::OneHot>(A, Shape{6, category_count}, 1);
 234     auto f = make_shared<Function>(r, ParameterVector{A});
 235
 236     auto backend = runtime::Backend::create("${BACKEND_NAME}");
 237
 238     // Create some tensors for input/output
 239     auto a = backend->create_tensor(element::i32, shape_a);
 240     vector<int32_t> input_data{0, 11, 101, 1001, 10001, static_cast<int32_t>(category_count - 1)};
 241     copy_data(a, input_data);
 242     auto result = backend->create_tensor(element::i32, shape_r);
 243
 244     auto handle = backend->compile(f);
 245     handle->call_with_validate({result}, {a});
 246     vector<int32_t> data = read_vector<int32_t>(result);
 247
 248     vector<int32_t> bit_positions;
 249     for (size_t i = 0; i < shape_size(shape_r); ++i)
 250     {
 251         if (data[i] == 1)
 252         {
 253             bit_positions.push_back(i % category_count);
 254         }
 255     }
 256     EXPECT_EQ(bit_positions, input_data);
 257 }