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

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2019 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/AveragePool2D.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 AveragePool2DTest : 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(AveragePool2DTest, Float)
  40 {
  41   Shape input_shape{1, 3, 5, 1};
  42   std::vector<float> input_data{
  43     -4, -3, -2, -1, 0,  //
  44     1,  2,  3,  4,  5,  //
  45     6,  7,  8,  9,  10, //
  46   };
  47   Tensor input_tensor =
  48     makeInputTensor<DataType::FLOAT32>(input_shape, input_data, _memory_manager.get());
  49   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  50   Tensor scratchpad(DataType::FLOAT32, Shape({}), {}, "");
  51
  52   Pool2DParams params{};
  53   params.padding = Padding::VALID;
  54   params.filter_height = 2;
  55   params.filter_width = 3;
  56   params.stride_height = 1;
  57   params.stride_width = 2;
  58   params.activation = Activation::RELU6;
  59
  60   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
  61   kernel.configure();
  62   _memory_manager->allocate_memory(scratchpad);
  63   _memory_manager->allocate_memory(output_tensor);
  64   kernel.execute();
  65
  66   std::vector<float> ref_output_data{
  67     0, 1.5, //
  68     4.5, 6, //
  69   };
  70   EXPECT_THAT(extractTensorData<float>(output_tensor), FloatArrayNear(ref_output_data));
  71   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 2, 1}));
  72 }
  73
  74 TEST_F(AveragePool2DTest, Uint8_0)
  75 {
  76   std::vector<float> input_data{
  77     0,  -6, 12, 4, //
  78     -3, -2, 10, 7, //
  79   };
  80   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
  81   Tensor input_tensor = makeInputTensor<DataType::U8>(
  82     {1, 2, 4, 1}, quant_param.first, quant_param.second, input_data, _memory_manager.get());
  83   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param.first, quant_param.second);
  84   Tensor scratchpad(DataType::U8, Shape({}), {}, "");
  85
  86   Pool2DParams params{};
  87   params.padding = Padding::VALID;
  88   params.filter_height = 2;
  89   params.filter_width = 2;
  90   params.stride_height = 2;
  91   params.stride_width = 2;
  92   params.activation = Activation::RELU6;
  93
  94   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
  95   kernel.configure();
  96   _memory_manager->allocate_memory(scratchpad);
  97   _memory_manager->allocate_memory(output_tensor);
  98   kernel.execute();
  99
 100   EXPECT_THAT(dequantizeTensorData(output_tensor), FloatArrayNear({0.0, 6.0}));
 101   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 1, 2, 1}));
 102 }
 103
 104 TEST_F(AveragePool2DTest, Uint8_1)
 105 {
 106   std::vector<float> input_data{
 107     0, 6, 12, 4, //
 108     3, 2, 10, 7, //
 109   };
 110
 111   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
 112   Tensor input_tensor = makeInputTensor<DataType::U8>(
 113     {1, 2, 4, 1}, quant_param.first, quant_param.second, input_data, _memory_manager.get());
 114   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param.first, quant_param.second);
 115   Tensor scratchpad(DataType::U8, Shape({}), {}, "");
 116
 117   Pool2DParams params{};
 118   params.padding = Padding::VALID;
 119   params.filter_height = 2;
 120   params.filter_width = 2;
 121   params.stride_height = 2;
 122   params.stride_width = 2;
 123   params.activation = Activation::RELU6;
 124
 125   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 126   kernel.configure();
 127   _memory_manager->allocate_memory(output_tensor);
 128   _memory_manager->allocate_memory(scratchpad);
 129   kernel.execute();
 130
 131   EXPECT_THAT(dequantizeTensorData(output_tensor), FloatArrayNear({2.75, 6.0}));
 132   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 1, 2, 1}));
 133 }
 134
 135 TEST_F(AveragePool2DTest, SInt16)
 136 {
 137   Shape input_shape{1, 3, 5, 1};
 138   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 139   std::vector<float> input_data{
 140     -4, -3, -2, -1, 0,  //
 141     1,  2,  3,  4,  5,  //
 142     6,  7,  8,  9,  10, //
 143   };
 144   std::vector<float> ref_output_data{
 145     0, 1.5, //
 146     4.5, 6, //
 147   };
 148   Tensor input_tensor =
 149     makeInputTensor<DataType::S16>(input_shape, 0.5, 0, input_data, _memory_manager.get());
 150   Tensor output_tensor = makeOutputTensor(DataType::S16, 0.5, 0);
 151   Tensor scratchpad(DataType::S16, Shape({}), {}, "");
 152
 153   Pool2DParams params{};
 154   params.padding = Padding::VALID;
 155   params.filter_height = 2;
 156   params.filter_width = 3;
 157   params.stride_height = 1;
 158   params.stride_width = 2;
 159   params.activation = Activation::RELU6;
 160
 161   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 162   kernel.configure();
 163   _memory_manager->allocate_memory(scratchpad);
 164   _memory_manager->allocate_memory(output_tensor);
 165   kernel.execute();
 166
 167   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 168   EXPECT_THAT(dequantizeTensorData(output_tensor), FloatArrayNear(ref_output_data));
 169 }
 170
 171 TEST_F(AveragePool2DTest, SInt8)
 172 {
 173   Shape input_shape{1, 4, 5, 1};
 174   std::vector<int32_t> ref_output_shape{1, 2, 2, 1};
 175   std::vector<float> input_data{-7, -3, 0,  2, -5, 12, -15, 3,  10, 5,
 176                                 7,  -6, -1, 9, -2, 0,  -5,  11, -1, -7};
 177   std::vector<float> ref_output_data{
 178     0, 2.5, //
 179     1, 1.5, //
 180   };
 181
 182   std::pair<float, int32_t> quant_param = quantizationParams<int8_t>(-15.9375f, 15.9375f);
 183   Tensor input_tensor = makeInputTensor<DataType::S8>(
 184     input_shape, quant_param.first, quant_param.second, input_data, _memory_manager.get());
 185   Tensor output_tensor = makeOutputTensor(DataType::S8, quant_param.first, quant_param.second);
 186   Tensor scratchpad(DataType::S8, Shape({}), {}, "");
 187
 188   Pool2DParams params{};
 189   params.padding = Padding::VALID;
 190   params.filter_height = 2;
 191   params.filter_width = 3;
 192   params.stride_height = 2;
 193   params.stride_width = 2;
 194   params.activation = Activation::RELU6;
 195
 196   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 197   kernel.configure();
 198   _memory_manager->allocate_memory(scratchpad);
 199   _memory_manager->allocate_memory(output_tensor);
 200   kernel.execute();
 201
 202   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(ref_output_shape));
 203   EXPECT_THAT(dequantizeTensorData(output_tensor), FloatArrayNear(ref_output_data));
 204 }
 205
 206 TEST_F(AveragePool2DTest, Invalid_Input_Shape_NEG)
 207 {
 208   Shape input_shape{1, 3, 5};
 209   std::vector<float> input_data{
 210     -4, -3, -2, -1, 0,  //
 211     1,  2,  3,  4,  5,  //
 212     6,  7,  8,  9,  10, //
 213   };
 214   Tensor input_tensor =
 215     makeInputTensor<DataType::FLOAT32>(input_shape, input_data, _memory_manager.get());
 216   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 217   Tensor scratchpad(DataType::FLOAT32, Shape({}), {}, "");
 218
 219   Pool2DParams params{};
 220   params.padding = Padding::VALID;
 221   params.filter_height = 2;
 222   params.filter_width = 3;
 223   params.stride_height = 1;
 224   params.stride_width = 2;
 225   params.activation = Activation::RELU6;
 226
 227   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 228   EXPECT_ANY_THROW(kernel.configure());
 229 }
 230
 231 TEST_F(AveragePool2DTest, In_Out_Type_NEG)
 232 {
 233   Shape input_shape{1, 3, 5, 1};
 234   std::vector<float> input_data{
 235     -4, -3, -2, -1, 0,  //
 236     1,  2,  3,  4,  5,  //
 237     6,  7,  8,  9,  10, //
 238   };
 239   Tensor input_tensor =
 240     makeInputTensor<DataType::FLOAT32>(input_shape, input_data, _memory_manager.get());
 241   Tensor output_tensor = makeOutputTensor(DataType::U8);
 242   Tensor scratchpad(DataType::FLOAT32, Shape({}), {}, "");
 243
 244   Pool2DParams params{};
 245   params.padding = Padding::VALID;
 246   params.filter_height = 2;
 247   params.filter_width = 3;
 248   params.stride_height = 1;
 249   params.stride_width = 2;
 250   params.activation = Activation::RELU6;
 251
 252   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 253   EXPECT_ANY_THROW(kernel.configure());
 254 }
 255
 256 TEST_F(AveragePool2DTest, Quant_Param_NEG)
 257 {
 258   std::vector<float> input_data{
 259     0,  -6, 12, 4, //
 260     -3, -2, 10, 7, //
 261   };
 262
 263   std::pair<float, int32_t> quant_param1 = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
 264   std::pair<float, int32_t> quant_param2 = quantizationParams<uint8_t>(-7.875f, 7.875f);
 265   Tensor input_tensor = makeInputTensor<DataType::U8>(
 266     {1, 2, 4, 1}, quant_param1.first, quant_param1.second, input_data, _memory_manager.get());
 267   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param2.first, quant_param2.second);
 268   Tensor scratchpad(DataType::U8, Shape({}), {}, "");
 269
 270   Pool2DParams params{};
 271   params.padding = Padding::VALID;
 272   params.filter_height = 2;
 273   params.filter_width = 2;
 274   params.stride_height = 2;
 275   params.stride_width = 2;
 276   params.activation = Activation::RELU6;
 277
 278   AveragePool2D kernel(&input_tensor, &output_tensor, &scratchpad, params);
 279   EXPECT_ANY_THROW(kernel.configure());
 280 }
 281
 282 } // namespace
 283 } // namespace kernels
 284 } // namespace luci_interpreter