compiler/luci-interpreter/src/kernels/LocalResponseNormalization.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/LocalResponseNormalization.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 LocalResponseNormalizationTest : 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(LocalResponseNormalizationTest, SameAsL2Norm)
  40 {
  41   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
  42     {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
  43   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  44
  45   LocalResponseNormalizationParams params{};
  46   params.radius = 20;
  47   params.bias = 0.0;
  48   params.alpha = 1.0;
  49   params.beta = 0.5;
  50
  51   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
  52   kernel.configure();
  53   _memory_manager->allocate_memory(output_tensor);
  54   kernel.execute();
  55
  56   EXPECT_THAT(extractTensorData<float>(output_tensor),
  57               FloatArrayNear({-0.55, 0.3, 0.35, 0.6, -0.35, 0.05}));
  58 }
  59
  60 TEST_F(LocalResponseNormalizationTest, WithAlpha)
  61 {
  62   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
  63     {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
  64   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  65
  66   LocalResponseNormalizationParams params{};
  67   params.radius = 20;
  68   params.bias = 0.0;
  69   params.alpha = 4.0;
  70   params.beta = 0.5;
  71
  72   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
  73   kernel.configure();
  74   _memory_manager->allocate_memory(output_tensor);
  75   kernel.execute();
  76
  77   EXPECT_THAT(extractTensorData<float>(output_tensor),
  78               FloatArrayNear({-0.275, 0.15, 0.175, 0.3, -0.175, 0.025}));
  79 }
  80
  81 TEST_F(LocalResponseNormalizationTest, WithBias)
  82 {
  83   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
  84     {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
  85   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  86
  87   LocalResponseNormalizationParams params{};
  88   params.radius = 20;
  89   params.bias = 9.0;
  90   params.alpha = 4.0;
  91   params.beta = 0.5;
  92
  93   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
  94   kernel.configure();
  95   _memory_manager->allocate_memory(output_tensor);
  96   kernel.execute();
  97
  98   EXPECT_THAT(extractTensorData<float>(output_tensor),
  99               FloatArrayNear({-0.22, 0.12, 0.14, 0.24, -0.14, 0.02}));
 100 }
 101
 102 TEST_F(LocalResponseNormalizationTest, SmallRadius)
 103 {
 104   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
 105     {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
 106   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 107
 108   LocalResponseNormalizationParams params{};
 109   params.radius = 2;
 110   params.bias = 9.0;
 111   params.alpha = 4.0;
 112   params.beta = 0.5;
 113
 114   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
 115   kernel.configure();
 116   _memory_manager->allocate_memory(output_tensor);
 117   kernel.execute();
 118
 119   EXPECT_THAT(extractTensorData<float>(output_tensor),
 120               FloatArrayNear({-0.264926, 0.125109, 0.140112, 0.267261, -0.161788, 0.0244266}));
 121 }
 122
 123 TEST_F(LocalResponseNormalizationTest, InvalidInputDimension_NEG)
 124 {
 125   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
 126     {1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
 127   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 128
 129   LocalResponseNormalizationParams params{};
 130   params.radius = 20;
 131   params.bias = 0.0;
 132   params.alpha = 1.0;
 133   params.beta = 0.5;
 134
 135   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
 136   EXPECT_ANY_THROW(kernel.configure());
 137 }
 138
 139 TEST_F(LocalResponseNormalizationTest, InvalidInputOutputType_NEG)
 140 {
 141   Tensor input_tensor = makeInputTensor<DataType::FLOAT32>(
 142     {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1}, _memory_manager.get());
 143   Tensor output_tensor = makeOutputTensor(DataType::U8);
 144
 145   LocalResponseNormalizationParams params{};
 146   params.radius = 20;
 147   params.bias = 0.0;
 148   params.alpha = 1.0;
 149   params.beta = 0.5;
 150
 151   LocalResponseNormalization kernel(&input_tensor, &output_tensor, params);
 152   EXPECT_ANY_THROW(kernel.configure());
 153 }
 154
 155 } // namespace
 156 } // namespace kernels
 157 } // namespace luci_interpreter