onert-micro/luci-interpreter/src/kernels/GreaterEqual.test.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2017 The TensorFlow Authors. All Rights Reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *    http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include "kernels/GreaterEqual.h"
  19 #include "kernels/TestUtils.h"
  20 #include "luci_interpreter/TestMemoryManager.h"
  21
  22 namespace luci_interpreter
  23 {
  24 namespace kernels
  25 {
  26 namespace
  27 {
  28
  29 using namespace testing;
  30
  31 class GreaterEqualTest : public ::testing::Test
  32 {
  33 protected:
  34   void SetUp() override { _memory_manager = std::make_unique<TestMemoryManager>(); }
  35
  36   std::unique_ptr<IMemoryManager> _memory_manager;
  37 };
  38
  39 TEST_F(GreaterEqualTest, FloatSimple)
  40 {
  41   std::vector<float> x_data{
  42     0.5, 0.7, 0.9, // Row 1
  43     1,   0,   -1,  // Row 2
  44   };
  45
  46   std::vector<float> y_data{
  47     0.9, 0.7, 0.5, // Row 1
  48     -1,  0,   1,   // Row 2
  49   };
  50
  51   std::vector<bool> ref_output_data{
  52     false, true, true,  // Row 1
  53     true,  true, false, // Row 2
  54   };
  55
  56   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({2, 3}, x_data, _memory_manager.get());
  57   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({2, 3}, y_data, _memory_manager.get());
  58   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
  59
  60   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
  61   kernel.configure();
  62   _memory_manager->allocate_memory(output_tensor);
  63   kernel.execute();
  64
  65   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
  66   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({2, 3}));
  67 }
  68
  69 TEST_F(GreaterEqualTest, FloatBroardcast)
  70 {
  71   std::vector<float> x_data{
  72     0.5, 0.7, 0.9, // Row 1
  73     1,   0,   -1,  // Row 2
  74     -1,  0,   1,   // Row 3
  75   };
  76
  77   std::vector<float> y_data{
  78     0.9, 0.7, 0.5, // Row 1
  79   };
  80
  81   std::vector<bool> ref_output_data{
  82     false, true,  true,  // Row 1
  83     true,  false, false, // Row 2
  84     false, false, true,  // Row 3
  85   };
  86
  87   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({3, 3}, x_data, _memory_manager.get());
  88   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({1, 3}, y_data, _memory_manager.get());
  89   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
  90
  91   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
  92   kernel.configure();
  93   _memory_manager->allocate_memory(output_tensor);
  94   kernel.execute();
  95
  96   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
  97   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({3, 3}));
  98 }
  99 template <loco::DataType DType>
 100 void checkIntegerSimple(luci_interpreter::IMemoryManager *memory_manager)
 101 {
 102   using dtype = typename loco::DataTypeImpl<DType>::Type;
 103   dtype min_value = std::numeric_limits<dtype>::min();
 104   dtype max_value = std::numeric_limits<dtype>::max();
 105   std::vector<dtype> x_data{min_value, 2, max_value};
 106
 107   std::vector<dtype> y_data{min_value + 1, -2, max_value};
 108
 109   std::vector<bool> ref_output_data{false, true, true};
 110
 111   Tensor x_tensor = makeInputTensor<DType>({3}, x_data, memory_manager);
 112   Tensor y_tensor = makeInputTensor<DType>({3}, y_data, memory_manager);
 113   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 114
 115   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 116   kernel.configure();
 117   memory_manager->allocate_memory(output_tensor);
 118   kernel.execute();
 119
 120   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 121   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({3}));
 122 }
 123
 124 template <loco::DataType DType>
 125 void checkIntegerBroadcast(luci_interpreter::IMemoryManager *memory_manager)
 126 {
 127   using dtype = typename loco::DataTypeImpl<DType>::Type;
 128   dtype min_value = std::numeric_limits<dtype>::min();
 129   dtype max_value = std::numeric_limits<dtype>::max();
 130   std::vector<dtype> x_data{
 131     min_value, 2,  3,             // Row 1
 132     4,         5,  max_value,     // Row 2
 133     -1,        -4, -3,            // Row 3
 134     min_value, -2, max_value - 1, // Row 4
 135   };
 136
 137   std::vector<dtype> y_data{
 138     min_value + 1, -2, max_value - 1, // Row 1
 139   };
 140
 141   std::vector<bool> ref_output_data{
 142     false, true,  false, // Row 1
 143     true,  true,  true,  // Row 2
 144     true,  false, false, // Row 3
 145     false, true,  true,  // Row 4
 146   };
 147
 148   Tensor x_tensor = makeInputTensor<DType>({4, 3}, x_data, memory_manager);
 149   Tensor y_tensor = makeInputTensor<DType>({3}, y_data, memory_manager);
 150   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 151
 152   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 153   kernel.configure();
 154   memory_manager->allocate_memory(output_tensor);
 155   kernel.execute();
 156
 157   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 158   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({4, 3}));
 159 }
 160
 161 TEST_F(GreaterEqualTest, Int32)
 162 {
 163   checkIntegerSimple<loco::DataType::S32>(_memory_manager.get());
 164   checkIntegerBroadcast<loco::DataType::S32>(_memory_manager.get());
 165   SUCCEED();
 166 }
 167
 168 TEST_F(GreaterEqualTest, Int64)
 169 {
 170   checkIntegerSimple<loco::DataType::S64>(_memory_manager.get());
 171   checkIntegerBroadcast<loco::DataType::S64>(_memory_manager.get());
 172   SUCCEED();
 173 }
 174
 175 // Choose min / max in such a way that there are exactly 256 units to avoid rounding errors.
 176 const float F_MIN = -128.0 / 128.0;
 177 const float F_MAX = 127.0 / 128.0;
 178
 179 TEST_F(GreaterEqualTest, Uint8Quantized)
 180 {
 181   std::vector<float> x_data{
 182     0.5, 0.6, 0.7,  0.9, // Row 1
 183     1,   0,   0.05, -1,  // Row 2
 184   };
 185
 186   std::vector<float> y_data{
 187     0.9, 0.6,  0.55, 0.5, // Row 1
 188     -1,  0.05, 0,    1,   // Row 2
 189   };
 190
 191   std::vector<bool> ref_output_data{
 192     false, true,  true, true,  // Row 1
 193     true,  false, true, false, // Row 2
 194   };
 195
 196   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 197   Tensor x_tensor = makeInputTensor<DataType::U8>(
 198     {1, 2, 4, 1}, quant_param.first, quant_param.second, x_data, _memory_manager.get());
 199   Tensor y_tensor = makeInputTensor<DataType::U8>(
 200     {1, 2, 4, 1}, quant_param.first, quant_param.second, y_data, _memory_manager.get());
 201   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 202
 203   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 204   kernel.configure();
 205   _memory_manager->allocate_memory(output_tensor);
 206   kernel.execute();
 207
 208   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 4, 1}));
 209   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 210 }
 211
 212 TEST_F(GreaterEqualTest, Uint8QuantizedRescale)
 213 {
 214   std::vector<float> x_data{
 215     0.5, 0.5, 0.7,  0.9, // Row 1
 216     1,   0,   0.05, -1,  // Row 2
 217   };
 218
 219   std::vector<float> y_data{
 220     0.9, 0.5,  0.6, 0.5, // Row 1
 221     -1,  0.05, 0,   1,   // Row 2
 222   };
 223
 224   std::vector<bool> ref_output_data{
 225     false, true,  true, true,  // Row 1
 226     true,  false, true, false, // Row 2
 227   };
 228
 229   std::pair<float, int32_t> x_quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 230   std::pair<float, int32_t> y_quant_param = quantizationParams<uint8_t>(F_MIN * 1.2, F_MAX * 1.5);
 231
 232   Tensor x_tensor = makeInputTensor<DataType::U8>(
 233     {1, 2, 4, 1}, x_quant_param.first, x_quant_param.second, x_data, _memory_manager.get());
 234   Tensor y_tensor = makeInputTensor<DataType::U8>(
 235     {1, 2, 4, 1}, y_quant_param.first, y_quant_param.second, y_data, _memory_manager.get());
 236   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 237
 238   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 239   kernel.configure();
 240   _memory_manager->allocate_memory(output_tensor);
 241   kernel.execute();
 242
 243   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 4, 1}));
 244   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 245 }
 246
 247 TEST_F(GreaterEqualTest, Uint8QuantizedBroadcast)
 248 {
 249   std::vector<float> x_data{
 250     0.4,  -0.8, 0.7,  0.3, // Row 1
 251     -0.5, 0.1,  0,    0.5, // Row 2
 252     1,    0,    0.05, -1,  // Row 3
 253   };
 254
 255   std::vector<float> y_data{
 256     -1, 0.05, 0, 1, // Row 1
 257   };
 258
 259   std::vector<bool> ref_output_data{
 260     true, false, true, false, // Row 1
 261     true, true,  true, false, // Row 2
 262     true, false, true, false, // Row 3
 263   };
 264
 265   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 266   Tensor x_tensor = makeInputTensor<DataType::U8>(
 267     {1, 3, 4, 1}, quant_param.first, quant_param.second, x_data, _memory_manager.get());
 268   Tensor y_tensor = makeInputTensor<DataType::U8>(
 269     {1, 1, 4, 1}, quant_param.first, quant_param.second, y_data, _memory_manager.get());
 270   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 271
 272   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 273   kernel.configure();
 274   _memory_manager->allocate_memory(output_tensor);
 275   kernel.execute();
 276
 277   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 3, 4, 1}));
 278   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 279 }
 280
 281 TEST_F(GreaterEqualTest, Input_Type_Mismatch_NEG)
 282 {
 283   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 284   Tensor y_tensor = makeInputTensor<DataType::U8>({1}, {1}, _memory_manager.get());
 285   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 286
 287   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 288   EXPECT_ANY_THROW(kernel.configure());
 289 }
 290
 291 TEST_F(GreaterEqualTest, Input_Output_Type_NEG)
 292 {
 293   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 294   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 295   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 296
 297   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 298   EXPECT_ANY_THROW(kernel.configure());
 299 }
 300
 301 TEST_F(GreaterEqualTest, Float_Broadcast_NEG)
 302 {
 303   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({2}, {1.f, 2.f}, _memory_manager.get());
 304   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({3}, {1.f, 2.f, 3.f}, _memory_manager.get());
 305   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 306
 307   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 308   EXPECT_ANY_THROW(kernel.configure());
 309 }
 310
 311 TEST_F(GreaterEqualTest, Int32_Broadcast_NEG)
 312 {
 313   Tensor x_tensor = makeInputTensor<DataType::S32>({2}, {1, 2}, _memory_manager.get());
 314   Tensor y_tensor = makeInputTensor<DataType::S32>({3}, {1, 2, 3}, _memory_manager.get());
 315   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 316
 317   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 318   EXPECT_ANY_THROW(kernel.configure());
 319 }
 320
 321 TEST_F(GreaterEqualTest, Int64_Broadcast_NEG)
 322 {
 323   Tensor x_tensor = makeInputTensor<DataType::S64>({2}, {1, 2}, _memory_manager.get());
 324   Tensor y_tensor = makeInputTensor<DataType::S64>({3}, {1, 2, 3}, _memory_manager.get());
 325   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 326
 327   GreaterEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 328   EXPECT_ANY_THROW(kernel.configure());
 329 }
 330
 331 } // namespace
 332 } // namespace kernels
 333 } // namespace luci_interpreter