compiler/luci-interpreter/src/kernels/L2Normalize.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 #include "kernels/L2Normalize.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, std::initializer_list<int32_t> output_shape,
  32            std::initializer_list<float> input_data, std::initializer_list<float> output_data)
  33 {
  34   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  35   Tensor input_tensor =
  36     makeInputTensor<DataType::FLOAT32>(input_shape, input_data, memory_manager.get());
  37   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
  38
  39   L2NormParams params{};
  40   params.activation = Activation::NONE;
  41
  42   L2Normalize kernel(&input_tensor, &output_tensor, params);
  43   kernel.configure();
  44   memory_manager->allocate_memory(output_tensor);
  45   kernel.execute();
  46
  47   EXPECT_THAT(extractTensorData<float>(output_tensor), FloatArrayNear(output_data));
  48   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(output_shape));
  49 }
  50
  51 template <>
  52 void Check<uint8_t>(std::initializer_list<int32_t> input_shape,
  53                     std::initializer_list<int32_t> output_shape,
  54                     std::initializer_list<float> input_data,
  55                     std::initializer_list<float> output_data)
  56 {
  57   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  58   std::pair<float, int32_t> quant_param =
  59     quantizationParams<uint8_t>(std::min(input_data) < 0 ? std::min(input_data) : 0.f,
  60                                 std::max(input_data) > 0 ? std::max(input_data) : 0.f);
  61
  62   Tensor input_tensor = makeInputTensor<DataType::U8>(
  63     input_shape, quant_param.first, quant_param.second, input_data, memory_manager.get());
  64   Tensor output_tensor = makeOutputTensor(DataType::U8, 1. / 128., 128);
  65
  66   L2NormParams params{};
  67   params.activation = Activation::NONE;
  68
  69   L2Normalize kernel(&input_tensor, &output_tensor, params);
  70   kernel.configure();
  71   memory_manager->allocate_memory(output_tensor);
  72   kernel.execute();
  73
  74   EXPECT_THAT(dequantizeTensorData(output_tensor),
  75               FloatArrayNear(output_data, output_tensor.scale()));
  76   EXPECT_THAT(extractTensorShape(output_tensor), ::testing::ElementsAreArray(output_shape));
  77 }
  78
  79 template <typename T> class L2NormalizeTest : public ::testing::Test
  80 {
  81 };
  82
  83 using DataTypes = ::testing::Types<float, uint8_t>;
  84 TYPED_TEST_CASE(L2NormalizeTest, DataTypes);
  85
  86 TYPED_TEST(L2NormalizeTest, Simple)
  87 {
  88   Check<TypeParam>({1, 1, 1, 6}, {1, 1, 1, 6}, {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1},
  89                    {-0.55, 0.3, 0.35, 0.6, -0.35, 0.05});
  90 }
  91
  92 TEST(L2NormalizeTest, ActivationType_NEG)
  93 {
  94   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
  95   std::vector<float> input_data = {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1};
  96
  97   Tensor input_tensor =
  98     makeInputTensor<DataType::FLOAT32>({1, 1, 1, 6}, input_data, memory_manager.get());
  99   Tensor output_tensor = makeOutputTensor(DataType::FLOAT32);
 100
 101   L2NormParams params{};
 102   params.activation = Activation::RELU6;
 103
 104   L2Normalize kernel(&input_tensor, &output_tensor, params);
 105   EXPECT_ANY_THROW(kernel.configure());
 106 }
 107
 108 TEST(L2NormalizeTest, InvalidOutputQuantParam_NEG)
 109 {
 110   std::unique_ptr<IMemoryManager> memory_manager = std::make_unique<TestMemoryManager>();
 111   std::vector<float> input_data = {-1.1, 0.6, 0.7, 1.2, -0.7, 0.1};
 112
 113   Tensor input_tensor =
 114     makeInputTensor<DataType::U8>({1, 1, 1, 6}, 1. / 64., 127, input_data, memory_manager.get());
 115   Tensor output_tensor = makeOutputTensor(DataType::U8, 1. / 64., 127);
 116
 117   L2NormParams params{};
 118   params.activation = Activation::NONE;
 119
 120   L2Normalize kernel(&input_tensor, &output_tensor, params);
 121   EXPECT_ANY_THROW(kernel.configure());
 122 }
 123
 124 } // namespace
 125 } // namespace kernels
 126 } // namespace luci_interpreter