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

   1 /*
   2  * Copyright (c) 2021 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/SpaceToBatchND.h"
  18 #include "kernels/TestUtils.h"
  19 #include "luci_interpreter/TestMemoryManager.h"
  20
  21 namespace luci_interpreter
  22 {
  23 namespace kernels
  24 {
  25 namespace
  26 {
  27
  28 using namespace testing;
  29
  30 template <typename T>
  31 void Check(std::initializer_list<int32_t> input_shape,
  32            std::initializer_list<int32_t> block_shape_shape,
  33            std::initializer_list<int32_t> paddings_shape,
  34            std::initializer_list<int32_t> output_shape, std::initializer_list<float> input_data,
  35            std::initializer_list<int32_t> block_shape_data,
  36            std::initializer_list<int32_t> paddings_data, std::initializer_list<float> output_data)
  37 {
  38   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  39   constexpr DataType element_type = getElementType<T>();
  40   Tensor input_tensor =
  41     makeInputTensor<element_type>(input_shape, input_data, memory_manager.get());
  42   Tensor block_shape_tensor =
  43     makeInputTensor<DataType::S32>(block_shape_shape, block_shape_data, memory_manager.get());
  44   Tensor paddings_tensor =
  45     makeInputTensor<DataType::S32>(paddings_shape, paddings_data, memory_manager.get());
  46   Tensor output_tensor = makeOutputTensor(element_type);
  47
  48   SpaceToBatchND kernel(&input_tensor, &block_shape_tensor, &paddings_tensor, &output_tensor);
  49   kernel.configure();
  50   memory_manager->allocate_memory(output_tensor);
  51   kernel.execute();
  52
  53   EXPECT_THAT(extractTensorData<T>(output_tensor), ::testing::ElementsAreArray(output_data));
  54   EXPECT_THAT(extractTensorShape(output_tensor), output_shape);
  55 }
  56
  57 template <>
  58 void Check<uint8_t>(
  59   std::initializer_list<int32_t> input_shape, std::initializer_list<int32_t> block_shape_shape,
  60   std::initializer_list<int32_t> paddings_shape, std::initializer_list<int32_t> output_shape,
  61   std::initializer_list<float> input_data, std::initializer_list<int32_t> block_shape_data,
  62   std::initializer_list<int32_t> paddings_data, std::initializer_list<float> output_data)
  63 {
  64   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  65
  66   std::pair<float, int32_t> input_quant_param =
  67     quantizationParams<uint8_t>(std::min(input_data), std::max(input_data));
  68   Tensor input_tensor =
  69     makeInputTensor<DataType::U8>(input_shape, input_quant_param.first, input_quant_param.second,
  70                                   input_data, memory_manager.get());
  71   Tensor block_shape_tensor =
  72     makeInputTensor<DataType::S32>(block_shape_shape, block_shape_data, memory_manager.get());
  73   Tensor paddings_tensor =
  74     makeInputTensor<DataType::S32>(paddings_shape, paddings_data, memory_manager.get());
  75   Tensor output_tensor =
  76     makeOutputTensor(DataType::U8, input_quant_param.first, input_quant_param.second);
  77
  78   SpaceToBatchND kernel(&input_tensor, &block_shape_tensor, &paddings_tensor, &output_tensor);
  79   kernel.configure();
  80   memory_manager->allocate_memory(output_tensor);
  81   kernel.execute();
  82
  83   EXPECT_THAT(dequantizeTensorData(output_tensor),
  84               FloatArrayNear(output_data, output_tensor.scale()));
  85   EXPECT_THAT(extractTensorShape(output_tensor), output_shape);
  86 }
  87
  88 template <typename T> class SpaceToBatchNDTest : public ::testing::Test
  89 {
  90 };
  91
  92 using DataTypes = ::testing::Types<float, uint8_t>;
  93 TYPED_TEST_SUITE(SpaceToBatchNDTest, DataTypes);
  94
  95 TYPED_TEST(SpaceToBatchNDTest, Simple)
  96 {
  97   Check<TypeParam>(/*input_shape=*/{1, 5, 2, 1}, /*block_shape_shape=*/{2},
  98                    /*paddings_shape=*/{2, 2},
  99                    /*output_shape=*/{6, 2, 2, 1},
 100                    /*input_data=*/{-1.0, 0.2, -0.3, 0.4, -0.5, 0.6, -0.7, 0.8, -0.9, 1.0},
 101                    /*block_shape_data=*/{3, 2}, /*paddings_data=*/{1, 0, 2, 0},
 102                    /*output_data=*/{0, 0,   0, -0.5, 0, 0,    0, 0.6,  0, -1.0, 0, -0.7,
 103                                     0, 0.2, 0, 0.8,  0, -0.3, 0, -0.9, 0, 0.4,  0, 1.0});
 104 }
 105
 106 TEST(SpaceToBatchNDTest, Invalid_Shape_NEG)
 107 {
 108   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
 109
 110   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
 111     {1, 3, 3, 1}, {1, 2, 3, 4, 5, 6, 7, 8, 9}, memory_manager.get());
 112   Tensor block_shape_tensor = makeInputTensor<DataType::S32>({2}, {2, 2}, memory_manager.get());
 113   Tensor paddings_tensor =
 114     makeInputTensor<DataType::S32>({2, 2}, {0, 0, 0, 0}, memory_manager.get());
 115   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 116
 117   SpaceToBatchND kernel(&input_tensor, &block_shape_tensor, &paddings_tensor, &output_tensor);
 118   EXPECT_ANY_THROW(kernel.configure());
 119 }
 120
 121 } // namespace
 122 } // namespace kernels
 123 } // namespace luci_interpreter