src/armnn/backends/test/QuantizeHelper.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // See LICENSE file in the project root for full license information.
   4 //
   5 #pragma once
   6
   7 #include <armnn/ArmNN.hpp>
   8 #include <armnn/TypesUtils.hpp>
   9
  10 #include <initializer_list>
  11 #include <iterator>
  12 #include <vector>
  13 #include <boost/core/ignore_unused.hpp>
  14
  15 template<typename T, bool DoQuantize=true>
  16 struct SelectiveQuantizer
  17 {
  18     static T Quantize(float value, float scale, int32_t offset)
  19     {
  20         return armnn::Quantize<T>(value, scale, offset);
  21     }
  22
  23     static float Dequantize(T value, float scale, int32_t offset)
  24     {
  25         return armnn::Dequantize(value, scale, offset);
  26     }
  27 };
  28
  29 template<typename T>
  30 struct SelectiveQuantizer<T, false>
  31 {
  32     static T Quantize(float value, float scale, int32_t offset)
  33     {
  34         boost::ignore_unused(scale, offset);
  35         return value;
  36     }
  37
  38     static float Dequantize(T value, float scale, int32_t offset)
  39     {
  40         boost::ignore_unused(scale, offset);
  41         return value;
  42     }
  43 };
  44
  45 template<typename T>
  46 T SelectiveQuantize(float value, float scale, int32_t offset)
  47 {
  48     return SelectiveQuantizer<T, armnn::IsQuantizedType<T>()>::Quantize(value, scale, offset);
  49 };
  50
  51 template<typename T>
  52 float SelectiveDequantize(T value, float scale, int32_t offset)
  53 {
  54     return SelectiveQuantizer<T, armnn::IsQuantizedType<T>()>::Dequantize(value, scale, offset);
  55 };
  56
  57 template<typename ItType>
  58 struct IsFloatingPointIterator
  59 {
  60     static constexpr bool value=std::is_floating_point<typename std::iterator_traits<ItType>::value_type>::value;
  61 };
  62
  63 template <typename T, typename FloatIt,
  64 typename std::enable_if<IsFloatingPointIterator<FloatIt>::value, int>::type=0 // Makes sure fp iterator is valid.
  65 >
  66 std::vector<T> QuantizedVector(float qScale, int32_t qOffset, FloatIt first, FloatIt last)
  67 {
  68     std::vector<T> quantized;
  69     quantized.reserve(boost::numeric_cast<size_t>(std::distance(first, last)));
  70
  71     for (auto it = first; it != last; ++it)
  72     {
  73         auto f = *it;
  74         T q =SelectiveQuantize<T>(f, qScale, qOffset);
  75         quantized.push_back(q);
  76     }
  77
  78     return quantized;
  79 }
  80
  81 template<typename T>
  82 std::vector<T> QuantizedVector(float qScale, int32_t qOffset, const std::vector<float>& array)
  83 {
  84     return QuantizedVector<T>(qScale, qOffset, array.begin(), array.end());
  85 }
  86
  87 template<typename T>
  88 std::vector<T> QuantizedVector(float qScale, int32_t qOffset, std::initializer_list<float> array)
  89 {
  90     return QuantizedVector<T>(qScale, qOffset, array.begin(), array.end());
  91 }