compiler/luci-interpreter/src/kernels/AveragePool2D.test.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   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 "kernels/AveragePool2D.h"
  18 #include "kernels/TestUtils.h"
  19
  20 namespace luci_interpreter
  21 {
  22 namespace kernels
  23 {
  24 namespace
  25 {
  26
  27 using namespace testing;
  28
  29 TEST(AveragePool2DTest, Float)
  30 {
  31   Shape input_shape{1, 3, 5, 1};
  32   std::vector<float> input_data{
  33       -4, -3, -2, -1, 0,  //
  34       1,  2,  3,  4,  5,  //
  35       6,  7,  8,  9,  10, //
  36   };
  37   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(input_shape, input_data);
  38   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  39
  40   Pool2DParams params{};
  41   params.padding = Padding::VALID;
  42   params.filter_height = 2;
  43   params.filter_width = 3;
  44   params.stride_height = 1;
  45   params.stride_width = 2;
  46   params.activation = Activation::RELU6;
  47
  48   AveragePool2D kernel(&input_tensor, &output_tensor, params);
  49   kernel.configure();
  50   kernel.execute();
  51
  52   std::vector<float> ref_output_data{
  53       0, 1.5, //
  54       4.5, 6, //
  55   };
  56   EXPECT_THAT(extractTensorData<float>(output_tensor),
  57               ElementsAreArray(ArrayFloatNear(ref_output_data)));
  58   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 2, 2, 1}));
  59 }
  60
  61 TEST(AveragePool2DTest, Uint8_0)
  62 {
  63   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
  64   Tensor input_tensor{DataType::U8, {1, 2, 4, 1}, {{quant_param.first}, {quant_param.second}}, ""};
  65   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param.first, quant_param.second);
  66
  67   std::vector<uint8_t> quant_input = quantize<uint8_t>(
  68       {
  69           0, -6, 12, 4,  //
  70           -3, -2, 10, 7, //
  71       },
  72       quant_param.first, quant_param.second);
  73   input_tensor.writeData(quant_input.data(), quant_input.size() * sizeof(uint8_t));
  74
  75   Pool2DParams params{};
  76   params.padding = Padding::VALID;
  77   params.filter_height = 2;
  78   params.filter_width = 2;
  79   params.stride_height = 2;
  80   params.stride_width = 2;
  81   params.activation = Activation::RELU6;
  82
  83   AveragePool2D kernel(&input_tensor, &output_tensor, params);
  84   kernel.configure();
  85   kernel.execute();
  86
  87   EXPECT_THAT(dequantize(extractTensorData<uint8_t>(output_tensor), output_tensor.scale(),
  88                          output_tensor.zero_point()),
  89               ElementsAreArray(ArrayFloatNear({0.0, 6.0})));
  90   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 1, 2, 1}));
  91 }
  92
  93 TEST(AveragePool2DTest, Uint8_1)
  94 {
  95   std::pair<float, int32_t> quant_param = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
  96   Tensor input_tensor{DataType::U8, {1, 2, 4, 1}, {{quant_param.first}, {quant_param.second}}, ""};
  97   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param.first, quant_param.second);
  98
  99   std::vector<uint8_t> quant_input = quantize<uint8_t>(
 100       {
 101           0, 6, 12, 4, //
 102           3, 2, 10, 7, //
 103       },
 104       quant_param.first, quant_param.second);
 105   input_tensor.writeData(quant_input.data(), quant_input.size() * sizeof(uint8_t));
 106
 107   Pool2DParams params{};
 108   params.padding = Padding::VALID;
 109   params.filter_height = 2;
 110   params.filter_width = 2;
 111   params.stride_height = 2;
 112   params.stride_width = 2;
 113   params.activation = Activation::RELU6;
 114
 115   AveragePool2D kernel(&input_tensor, &output_tensor, params);
 116   kernel.configure();
 117   kernel.execute();
 118
 119   EXPECT_THAT(dequantize(extractTensorData<uint8_t>(output_tensor), output_tensor.scale(),
 120                          output_tensor.zero_point()),
 121               ElementsAreArray(ArrayFloatNear({2.75, 6.0})));
 122   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray({1, 1, 2, 1}));
 123 }
 124
 125 TEST(AveragePool2DTest, Invalid_Input_Shape_NEG)
 126 {
 127   Shape input_shape{1, 3, 5};
 128   std::vector<float> input_data{
 129       -4, -3, -2, -1, 0,  //
 130       1,  2,  3,  4,  5,  //
 131       6,  7,  8,  9,  10, //
 132   };
 133   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(input_shape, input_data);
 134   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 135
 136   Pool2DParams params{};
 137   params.padding = Padding::VALID;
 138   params.filter_height = 2;
 139   params.filter_width = 3;
 140   params.stride_height = 1;
 141   params.stride_width = 2;
 142   params.activation = Activation::RELU6;
 143
 144   AveragePool2D kernel(&input_tensor, &output_tensor, params);
 145   EXPECT_ANY_THROW(kernel.configure());
 146 }
 147
 148 TEST(AveragePool2DTest, In_Out_Type_NEG)
 149 {
 150   Shape input_shape{1, 3, 5, 1};
 151   std::vector<float> input_data{
 152       -4, -3, -2, -1, 0,  //
 153       1,  2,  3,  4,  5,  //
 154       6,  7,  8,  9,  10, //
 155   };
 156   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(input_shape, input_data);
 157   Tensor output_tensor = makeOutputTensor(DataType::U8);
 158
 159   Pool2DParams params{};
 160   params.padding = Padding::VALID;
 161   params.filter_height = 2;
 162   params.filter_width = 3;
 163   params.stride_height = 1;
 164   params.stride_width = 2;
 165   params.activation = Activation::RELU6;
 166
 167   AveragePool2D kernel(&input_tensor, &output_tensor, params);
 168   EXPECT_ANY_THROW(kernel.configure());
 169 }
 170
 171 TEST(AveragePool2DTest, Quant_Param_NEG)
 172 {
 173   std::pair<float, int32_t> quant_param1 = quantizationParams<uint8_t>(-15.9375f, 15.9375f);
 174   std::pair<float, int32_t> quant_param2 = quantizationParams<uint8_t>(-7.875f, 7.875f);
 175   Tensor input_tensor{
 176       DataType::U8, {1, 2, 4, 1}, {{quant_param1.first}, {quant_param1.second}}, ""};
 177   Tensor output_tensor = makeOutputTensor(DataType::U8, quant_param2.first, quant_param2.second);
 178
 179   std::vector<uint8_t> quant_input = quantize<uint8_t>(
 180       {
 181           0, -6, 12, 4,  //
 182           -3, -2, 10, 7, //
 183       },
 184       quant_param1.first, quant_param1.second);
 185   input_tensor.writeData(quant_input.data(), quant_input.size() * sizeof(uint8_t));
 186
 187   Pool2DParams params{};
 188   params.padding = Padding::VALID;
 189   params.filter_height = 2;
 190   params.filter_width = 2;
 191   params.stride_height = 2;
 192   params.stride_width = 2;
 193   params.activation = Activation::RELU6;
 194
 195   AveragePool2D kernel(&input_tensor, &output_tensor, params);
 196   EXPECT_ANY_THROW(kernel.configure());
 197 }
 198
 199 } // namespace
 200 } // namespace kernels
 201 } // namespace luci_interpreter