onert-micro/luci-interpreter/src/kernels/LessEqual.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/LessEqual.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 LessEqualTest : 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(LessEqualTest, 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     true,  true, false, // Row 1
  53     false, true, true,  // 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   LessEqual 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(LessEqualTest, 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     true,  true, false, // Row 1
  83     false, true, true,  // Row 2
  84     true,  true, false, // 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   LessEqual 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
 100 template <loco::DataType DType>
 101 void checkIntegerSimple(luci_interpreter::IMemoryManager *memory_manager)
 102 {
 103   using dtype = typename loco::DataTypeImpl<DType>::Type;
 104   dtype min_value = std::numeric_limits<dtype>::min();
 105   dtype max_value = std::numeric_limits<dtype>::max();
 106   std::vector<dtype> x_data{min_value, 2, max_value};
 107
 108   std::vector<dtype> y_data{min_value + 1, -2, max_value};
 109
 110   std::vector<bool> ref_output_data{true, false, true};
 111
 112   Tensor x_tensor = makeInputTensor<DType>({3}, x_data, memory_manager);
 113   Tensor y_tensor = makeInputTensor<DType>({3}, y_data, memory_manager);
 114   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 115
 116   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 117   kernel.configure();
 118   memory_manager->allocate_memory(output_tensor);
 119   kernel.execute();
 120
 121   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 122   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({3}));
 123 }
 124
 125 template <loco::DataType DType>
 126 void checkIntegerBroadcast(luci_interpreter::IMemoryManager *memory_manager)
 127 {
 128   using dtype = typename loco::DataTypeImpl<DType>::Type;
 129   dtype min_value = std::numeric_limits<dtype>::min();
 130   dtype max_value = std::numeric_limits<dtype>::max();
 131   std::vector<dtype> x_data{
 132     min_value, 2,  3,         // Row 1
 133     4,         5,  max_value, // Row 2
 134     -1,        -4, -3,        // Row 3
 135     min_value, -2, max_value, // Row 4
 136   };
 137
 138   std::vector<dtype> y_data{
 139     min_value + 1, -2, max_value - 1, // Row 1
 140   };
 141
 142   std::vector<bool> ref_output_data{
 143     true,  false, true,  // Row 1
 144     false, false, false, // Row 2
 145     false, true,  true,  // Row 3
 146     true,  true,  false, // Row 4
 147   };
 148
 149   Tensor x_tensor = makeInputTensor<DType>({4, 3}, x_data, memory_manager);
 150   Tensor y_tensor = makeInputTensor<DType>({3}, y_data, memory_manager);
 151   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 152
 153   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 154   kernel.configure();
 155   memory_manager->allocate_memory(output_tensor);
 156   kernel.execute();
 157
 158   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 159   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({4, 3}));
 160 }
 161
 162 TEST_F(LessEqualTest, Int32)
 163 {
 164   checkIntegerSimple<loco::DataType::S32>(_memory_manager.get());
 165   checkIntegerBroadcast<loco::DataType::S32>(_memory_manager.get());
 166   SUCCEED();
 167 }
 168
 169 TEST_F(LessEqualTest, Int64)
 170 {
 171   checkIntegerSimple<loco::DataType::S64>(_memory_manager.get());
 172   checkIntegerBroadcast<loco::DataType::S64>(_memory_manager.get());
 173   SUCCEED();
 174 }
 175
 176 // Choose min / max in such a way that there are exactly 256 units to avoid rounding errors.
 177 const float F_MIN = -128.0 / 128.0;
 178 const float F_MAX = 127.0 / 128.0;
 179
 180 TEST_F(LessEqualTest, Uint8Quantized)
 181 {
 182   std::vector<float> x_data{
 183     0.5, 0.6, 0.7,  0.9, // Row 1
 184     1,   0,   0.05, -1,  // Row 2
 185   };
 186
 187   std::vector<float> y_data{
 188     0.9, 0.6,  0.55, 0.5, // Row 1
 189     -1,  0.05, 0,    1,   // Row 2
 190   };
 191
 192   std::vector<bool> ref_output_data{
 193     true,  true, false, false, // Row 1
 194     false, true, false, true,  // Row 2
 195   };
 196
 197   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 198   Tensor x_tensor = makeInputTensor<DataType::U8>(
 199     {1, 2, 4, 1}, quant_param.first, quant_param.second, x_data, _memory_manager.get());
 200   Tensor y_tensor = makeInputTensor<DataType::U8>(
 201     {1, 2, 4, 1}, quant_param.first, quant_param.second, y_data, _memory_manager.get());
 202   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 203
 204   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 205   kernel.configure();
 206   _memory_manager->allocate_memory(output_tensor);
 207   kernel.execute();
 208
 209   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 4, 1}));
 210   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 211 }
 212
 213 TEST_F(LessEqualTest, Uint8QuantizedRescale)
 214 {
 215   std::vector<float> x_data{
 216     0.5, 0.6, 0.7,  0.9, // Row 1
 217     1,   0,   0.05, -1,  // Row 2
 218   };
 219
 220   std::vector<float> y_data{
 221     0.9, 0.6,  0.6, 0.5, // Row 1
 222     -1,  0.05, 0,   1,   // Row 2
 223   };
 224
 225   std::vector<bool> ref_output_data{
 226     true,  true, false, false, // Row 1
 227     false, true, false, true,  // Row 2
 228   };
 229
 230   std::pair<float, int32_t> x_quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 231   std::pair<float, int32_t> y_quant_param = quantizationParams<uint8_t>(F_MIN * 1.2, F_MAX * 1.5);
 232
 233   Tensor x_tensor = makeInputTensor<DataType::U8>(
 234     {1, 2, 4, 1}, x_quant_param.first, x_quant_param.second, x_data, _memory_manager.get());
 235   Tensor y_tensor = makeInputTensor<DataType::U8>(
 236     {1, 2, 4, 1}, y_quant_param.first, y_quant_param.second, y_data, _memory_manager.get());
 237   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 238
 239   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 240   kernel.configure();
 241   _memory_manager->allocate_memory(output_tensor);
 242   kernel.execute();
 243
 244   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 4, 1}));
 245   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 246 }
 247
 248 TEST_F(LessEqualTest, Uint8QuantizedBroadcast)
 249 {
 250   std::vector<float> x_data{
 251     0.4,  -0.8, 0.7,  0.3, // Row 1
 252     -0.5, 0.1,  0,    0.5, // Row 2
 253     1,    0,    0.05, -1,  // Row 3
 254   };
 255
 256   std::vector<float> y_data{
 257     -1, 0.05, 0, 1, // Row 1
 258   };
 259
 260   std::vector<bool> ref_output_data{
 261     false, true,  false, true, // Row 1
 262     false, false, true,  true, // Row 2
 263     false, true,  false, true, // Row 3
 264   };
 265
 266   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(F_MIN, F_MAX);
 267   Tensor x_tensor = makeInputTensor<DataType::U8>(
 268     {1, 3, 4, 1}, quant_param.first, quant_param.second, x_data, _memory_manager.get());
 269   Tensor y_tensor = makeInputTensor<DataType::U8>(
 270     {1, 1, 4, 1}, quant_param.first, quant_param.second, y_data, _memory_manager.get());
 271   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 272
 273   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 274   kernel.configure();
 275   _memory_manager->allocate_memory(output_tensor);
 276   kernel.execute();
 277
 278   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 3, 4, 1}));
 279   EXPECT_THAT(extractTensorData<bool>(output_tensor), ::testing::ElementsAreArray(ref_output_data));
 280 }
 281
 282 TEST_F(LessEqualTest, Input_Type_Mismatch_NEG)
 283 {
 284   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 285   Tensor y_tensor = makeInputTensor<DataType::U8>({1}, {1}, _memory_manager.get());
 286   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 287
 288   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 289   EXPECT_ANY_THROW(kernel.configure());
 290 }
 291
 292 TEST_F(LessEqualTest, Input_Output_Type_NEG)
 293 {
 294   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 295   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({1}, {1.f}, _memory_manager.get());
 296   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 297
 298   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 299   EXPECT_ANY_THROW(kernel.configure());
 300 }
 301
 302 TEST_F(LessEqualTest, Float_Broadcast_NEG)
 303 {
 304   Tensor x_tensor = makeInputTensor<DataType::FLOAT32>({2}, {1.f, 2.f}, _memory_manager.get());
 305   Tensor y_tensor = makeInputTensor<DataType::FLOAT32>({3}, {1.f, 2.f, 3.f}, _memory_manager.get());
 306   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 307
 308   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 309   ASSERT_ANY_THROW(kernel.configure());
 310 }
 311
 312 TEST_F(LessEqualTest, Int32_Broadcast_NEG)
 313 {
 314   Tensor x_tensor = makeInputTensor<DataType::S32>({2}, {1, 2}, _memory_manager.get());
 315   Tensor y_tensor = makeInputTensor<DataType::S32>({3}, {1, 2, 3}, _memory_manager.get());
 316   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 317
 318   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 319   ASSERT_ANY_THROW(kernel.configure());
 320 }
 321
 322 TEST_F(LessEqualTest, Int64_Broadcast_NEG)
 323 {
 324   Tensor x_tensor = makeInputTensor<DataType::S64>({2}, {1, 2}, _memory_manager.get());
 325   Tensor y_tensor = makeInputTensor<DataType::S64>({3}, {1, 2, 3}, _memory_manager.get());
 326   Tensor output_tensor = makeOutputTensor(DataType::BOOL);
 327
 328   LessEqual kernel(&x_tensor, &y_tensor, &output_tensor);
 329   ASSERT_ANY_THROW(kernel.configure());
 330 }
 331
 332 } // namespace
 333 } // namespace kernels
 334 } // namespace luci_interpreter