luci_interpreter::kernels::testing Namespace Reference

Functions
Tensor	makeOutputTensor (DataType element_type)
Tensor	makeOutputTensor (DataType element_type, float scale, int32_t zero_point)
std::vector< float >	dequantizeTensorData (const Tensor &tensor)
Matcher< std::vector< float > >	FloatArrayNear (const std::vector< float > &values, float max_abs_error)
std::vector< int32_t >	extractTensorShape (const Tensor &tensor)
template<typename T >
std::vector< T >	quantize (const float *data, size_t num_elements, float scale, int32_t zero_point)
template<DataType DT>
Tensor	makeInputTensor (const Shape &shape, const std::vector< typename DataTypeImpl< DT >::Type > &data, IMemoryManager *memory_manager)
template<DataType DT>
Tensor	makeInputTensor (const Shape &shape, float scale, int32_t zero_point, const std::vector< float > &data, IMemoryManager *memory_manager)
	Create layer-wise quantized tensor.
template<DataType DT>
Tensor	makeInputTensor (const Shape &shape, const std::vector< float > &scales, const std::vector< int32_t > &zero_points, int quantized_dimension, const std::vector< float > &data, IMemoryManager *memory_manager)
	Create channel-wise quantized tensor.
template<typename T >
constexpr DataType	getElementType ()
template<typename T >
std::vector< T >	extractTensorData (const Tensor &tensor)
template<typename T >
std::vector< float >	dequantize (const T *data, size_t num_elements, float scale, int32_t zero_point)
template<typename T >
std::pair< float, int32_t >	quantizationParams (float f_min, float f_max)
float	getTolerance (float min, float max, int quantize_steps)

Function Documentation

dequantize()

template<typename T >

std::vector< float > luci_interpreter::kernels::testing::dequantize	(	const T *	data,
		size_t	num_elements,
		float	scale,
		int32_t	zero_point
	)

Definition at line 201 of file TestUtils.h.

{
  static_assert(std::is_integral<T>::value, "Integral type expected.");
  std::vector<float> f;
  for (size_t i = 0; i < num_elements; ++i)
  {
    const T &q = data[i];
    f.push_back(scale * (q - zero_point));
  }
  return f;
}

References flatbuffers::data().

Referenced by dequantizeTensorData().

dequantizeTensorData()

std::vector< float > luci_interpreter::kernels::testing::dequantizeTensorData

(

const Tensor &

tensor

)

Definition at line 39 of file TestUtils.cpp.

{
  if (tensor.element_type() == DataType::U8)
  {
    std::vector<uint8_t> data = extractTensorData<uint8_t>(tensor);
    return dequantize(data.data(), data.size(), tensor.scale(), tensor.zero_point());
  }
  if (tensor.element_type() == DataType::S8)
  {
    std::vector<int8_t> data = extractTensorData<int8_t>(tensor);
    return dequantize(data.data(), data.size(), tensor.scale(), tensor.zero_point());
  }
  else if (tensor.element_type() == DataType::S16)
  {
    // S16 quantization is symmetric, so zero point should be zero.
    for (auto zp : tensor.zero_points())
    {
      (void)zp;
      assert(zp == 0);
    }
 
    std::vector<int16_t> data = extractTensorData<int16_t>(tensor);
    if (tensor.scales().size() == 1)
    {
      return dequantize(data.data(), data.size(), tensor.scale(), 0);
    }
 
    // quantize_dimension breaks shape into two parts:
    // inner dimensions that contains continuous data with one quantization type
    // outer dimensions that contains other dimensions
    const Shape shape = tensor.shape();
    const int32_t quantized_dimension = tensor.quantized_dimension();
    assert(quantized_dimension < shape.num_dims());
    size_t outer_dims_size = 1;
    int32_t quant_dim_size = shape.dim(quantized_dimension);
    size_t inner_dims_size = 1;
    assert(quant_dim_size == tensor.scales().size());
 
    for (int i = 0; i < quantized_dimension; ++i)
      outer_dims_size *= shape.dim(i);
    for (int i = quantized_dimension + 1; i < shape.num_dims(); ++i)
      inner_dims_size *= shape.dim(i);
 
    assert(shape.num_elements() == outer_dims_size * quant_dim_size * inner_dims_size);
 
    std::vector<float> dequantized_data;
    dequantized_data.reserve(shape.num_elements());
    for (size_t outer_it = 0; outer_it < outer_dims_size; ++outer_it)
      for (int32_t channel = 0; channel < quant_dim_size; ++channel)
      {
        float scale = tensor.scales()[channel];
        size_t offset = inner_dims_size * (quant_dim_size * outer_it + channel);
        std::vector<float> part_dequantized_data =
          dequantize(data.data() + offset, inner_dims_size, scale, 0);
        dequantized_data.insert(dequantized_data.end(), part_dequantized_data.begin(),
                                part_dequantized_data.end());
      }
    return dequantized_data;
  }
  else
  {
    throw std::runtime_error("Unsupported type.");
  }
}

References flatbuffers::data(), dequantize(), luci_interpreter::Shape::dim(), luci_interpreter::Shape::num_dims(), luci_interpreter::Shape::num_elements(), and offset().

extractTensorData()

template<typename T >

std::vector< T > luci_interpreter::kernels::testing::extractTensorData

(

const Tensor &

tensor

)

Definition at line 161 of file TestUtils.h.

{
  const auto *data_ptr = tensor.data<T>();
  return std::vector<T>(data_ptr, data_ptr + tensor.shape().num_elements());
}

extractTensorShape()

std::vector< int32_t > luci_interpreter::kernels::testing::extractTensorShape

(

const Tensor &

tensor

)

Definition at line 115 of file TestUtils.cpp.

{
  std::vector<int32_t> result;
  int dims = tensor.shape().num_dims();
  for (int i = 0; i < dims; i++)
  {
    result.push_back(tensor.shape().dim(i));
  }
  return result;
}

FloatArrayNear()

testing::Matcher< std::vector< float > > luci_interpreter::kernels::testing::FloatArrayNear	(	const std::vector< float > &	values,
		float	max_abs_error
	)

Definition at line 104 of file TestUtils.cpp.

{
  std::vector<Matcher<float>> matchers;
  matchers.reserve(values.size());
  for (const float v : values)
  {
    matchers.emplace_back(FloatNear(v, max_abs_error));
  }
  return ElementsAreArray(matchers);
}

getElementType()

template<typename T >

constexpr DataType luci_interpreter::kernels::testing::getElementType ( )

constexpr

Definition at line 134 of file TestUtils.h.

{
  if (std::is_same<T, float>::value)
    return DataType::FLOAT32;
  if (std::is_same<T, double>::value)
    return DataType::FLOAT64;
  if (std::is_same<T, uint8_t>::value)
    return DataType::U8;
  if (std::is_same<T, uint16_t>::value)
    return DataType::U16;
  if (std::is_same<T, uint32_t>::value)
    return DataType::U32;
  if (std::is_same<T, uint64_t>::value)
    return DataType::U64;
  if (std::is_same<T, int8_t>::value)
    return DataType::S8;
  if (std::is_same<T, int16_t>::value)
    return DataType::S16;
  if (std::is_same<T, int32_t>::value)
    return DataType::S32;
  if (std::is_same<T, int64_t>::value)
    return DataType::S64;
  if (std::is_same<T, bool>::value)
    return DataType::BOOL;
  return DataType::Unknown;
}

getTolerance()

float luci_interpreter::kernels::testing::getTolerance ( float  min, float  max, int  quantize_steps  )

inline

Definition at line 288 of file TestUtils.h.

{
  return ((max - min) / quantize_steps);
}

makeInputTensor() [1/3]

template<DataType DT>

Tensor luci_interpreter::kernels::testing::makeInputTensor	(	const Shape &	shape,
		const std::vector< float > &	scales,
		const std::vector< int32_t > &	zero_points,
		int	quantized_dimension,
		const std::vector< float > &	data,
		IMemoryManager *	memory_manager
	)

Create channel-wise quantized tensor.

Template Parameters

DT	base integer data type, for example DataType::U8, DataType::S16, DataType::S64

Parameters

shape	desired tensor shape
scales	scales of quantized number
zero_points	zero points of quantized number, should be 0 for signed datatypes
quantize_dimension	dimension to apply quantization along. Usually channels/output channels
data	floating point data for quantization
memory_manager	memory manager for allocating memory to tensor

Returns

created tensor

Definition at line 85 of file TestUtils.h.

{
  using NativeT = typename DataTypeImpl<DT>::Type;
  assert(quantized_dimension < shape.num_dims());
  Tensor tensor(DT, shape, {scales, zero_points, quantized_dimension}, "");
 
  // quantize_dimension breaks shape into two parts:
  // inner dimensions that contains continuous data with one quantization type
  // outer dimensions that contains other dimensions
  size_t outer_dims_size = 1;
  int32_t quant_dim_size = shape.dim(quantized_dimension);
  size_t inner_dims_size = 1;
  assert(quant_dim_size == scales.size());
  assert(quant_dim_size == zero_points.size());
 
  for (int i = 0; i < quantized_dimension; ++i)
    outer_dims_size *= shape.dim(i);
  for (int i = quantized_dimension + 1; i < shape.num_dims(); ++i)
    inner_dims_size *= shape.dim(i);
 
  assert(shape.num_elements() == outer_dims_size * quant_dim_size * inner_dims_size);
 
  std::vector<NativeT> quantized_data;
  quantized_data.reserve(shape.num_elements());
  for (size_t outer_it = 0; outer_it < outer_dims_size; ++outer_it)
    for (int32_t channel = 0; channel < quant_dim_size; ++channel)
    {
      int32_t zero_point = zero_points[channel];
      float scale = scales[channel];
      size_t offset = inner_dims_size * (quant_dim_size * outer_it + channel);
      std::vector<NativeT> part_quantized_data =
        quantize<NativeT>(data.data() + offset, inner_dims_size, scale, zero_point);
      quantized_data.insert(quantized_data.end(), part_quantized_data.begin(),
                            part_quantized_data.end());
    }
  assert(quantized_data.size() == shape.num_elements());
  memory_manager->allocate_memory(tensor);
  tensor.writeData(quantized_data.data(), quantized_data.size() * sizeof(NativeT));
  return tensor;
}

References luci_interpreter::IMemoryManager::allocate_memory(), flatbuffers::data(), luci_interpreter::Shape::dim(), luci_interpreter::Shape::num_dims(), luci_interpreter::Shape::num_elements(), and offset().

makeInputTensor() [2/3]

template<DataType DT>

Tensor luci_interpreter::kernels::testing::makeInputTensor	(	const Shape &	shape,
		const std::vector< typename DataTypeImpl< DT >::Type > &	data,
		IMemoryManager *	memory_manager
	)

Definition at line 41 of file TestUtils.h.

{
  Tensor tensor(DT, shape, {}, "");
  memory_manager->allocate_memory(tensor);
  tensor.writeData(data.data(), data.size() * sizeof(typename DataTypeImpl<DT>::Type));
  return tensor;
}

References luci_interpreter::IMemoryManager::allocate_memory(), and flatbuffers::data().

makeInputTensor() [3/3]

template<DataType DT>

Tensor luci_interpreter::kernels::testing::makeInputTensor	(	const Shape &	shape,
		float	scale,
		int32_t	zero_point,
		const std::vector< float > &	data,
		IMemoryManager *	memory_manager
	)

Create layer-wise quantized tensor.

Template Parameters

DT	base integer data type, for example DataType::U8, DataType::S16, DataType::S64

Parameters

shape	desired tensor shape
scale	scale of quantized number
zero_point	zero point of quantized number, should be 0 for signed datatypes
data	floating point data for quantization
memory_manager	memory manager for allocating memory to tensor

Returns

created tensor

Definition at line 61 of file TestUtils.h.

{
  using NativeT = typename DataTypeImpl<DT>::Type;
  Tensor tensor(DT, shape, {{scale}, {zero_point}}, "");
  std::vector<NativeT> quantized_data =
    quantize<NativeT>(data.data(), data.size(), scale, zero_point);
  memory_manager->allocate_memory(tensor);
  tensor.writeData(quantized_data.data(), quantized_data.size() * sizeof(NativeT));
  return tensor;
}

References luci_interpreter::IMemoryManager::allocate_memory(), and flatbuffers::data().

makeOutputTensor() [1/2]

Tensor luci_interpreter::kernels::testing::makeOutputTensor

(

DataType

element_type

)

Definition at line 32 of file TestUtils.cpp.

{ return Tensor(element_type, {}, {}, ""); }

makeOutputTensor() [2/2]

Tensor luci_interpreter::kernels::testing::makeOutputTensor	(	DataType	element_type,
		float	scale,
		int32_t	zero_point
	)

Definition at line 34 of file TestUtils.cpp.

{
  return Tensor(element_type, {}, {{scale}, {zero_point}}, "");
}

quantizationParams()

template<typename T >

std::pair< float, int32_t > luci_interpreter::kernels::testing::quantizationParams	(	float	f_min,
		float	f_max
	)

Definition at line 214 of file TestUtils.h.

{
  static_assert(std::is_integral<T>::value, "Integral type expected.");
  int32_t zero_point = 0;
  float scale = 0;
  const T qmin = std::numeric_limits<T>::lowest();
  const T qmax = std::numeric_limits<T>::max();
  const float qmin_double = qmin;
  const float qmax_double = qmax;
  // 0 should always be a representable value. Let's assume that the initial
  // min,max range contains 0.
  assert(f_max >= 0);
  assert(f_min <= 0);
  if (f_min == f_max)
  {
    // Special case where the min,max range is a point. Should be {0}.
    assert(f_max == 0);
    assert(f_min == 0);
    return {scale, zero_point};
  }
 
  // General case.
  //
  // First determine the scale.
  scale = (f_max - f_min) / (qmax_double - qmin_double);
 
  // Zero-point computation.
  // First the initial floating-point computation. The zero-point can be
  // determined from solving an affine equation for any known pair
  // (real value, corresponding quantized value).
  // We know two such pairs: (rmin, qmin) and (rmax, qmax).
  // The arithmetic error on the zero point computed from either pair
  // will be roughly machine_epsilon * (sum of absolute values of terms)
  // so we want to use the variant that adds the smaller terms.
  const float zero_point_from_min = qmin_double - f_min / scale;
  const float zero_point_from_max = qmax_double - f_max / scale;
 
  const float zero_point_from_min_error = std::abs(qmin_double) + std::abs(f_min / scale);
 
  const float zero_point_from_max_error = std::abs(qmax_double) + std::abs(f_max / scale);
 
  const float zero_point_double = zero_point_from_min_error < zero_point_from_max_error
                                    ? zero_point_from_min
                                    : zero_point_from_max;
 
  // Now we need to nudge the zero point to be an integer
  // (our zero points are integer, and this is motivated by the requirement
  // to be able to represent the real value "0" exactly as a quantized value,
  // which is required in multiple places, for example in Im2col with SAME
  //  padding).
 
  T nudged_zero_point = 0;
  if (zero_point_double < qmin_double)
  {
    nudged_zero_point = qmin;
  }
  else if (zero_point_double > qmax_double)
  {
    nudged_zero_point = qmax;
  }
  else
  {
    nudged_zero_point = static_cast<T>(std::round(zero_point_double));
  }
 
  // The zero point should always be in the range of quantized value,
  // // [qmin, qmax].
  assert(qmax >= nudged_zero_point);
  assert(qmin <= nudged_zero_point);
  zero_point = nudged_zero_point;
  // finally, return the values
  return {scale, zero_point};
}

quantize()

template<typename T >

std::vector< T > luci_interpreter::kernels::testing::quantize	(	const float *	data,
		size_t	num_elements,
		float	scale,
		int32_t	zero_point
	)

Definition at line 174 of file TestUtils.h.

{
  static_assert(std::is_integral<T>::value, "Integral type expected.");
 
  float q_min{}, q_max{};
  if (std::is_signed<T>::value)
  {
    q_min = -std::numeric_limits<T>::max();
    q_max = std::numeric_limits<T>::max();
  }
  else
  {
    q_min = 0;
    q_max = std::numeric_limits<T>::max();
  }
 
  std::vector<T> q;
  for (size_t i = 0; i < num_elements; ++i)
  {
    const auto &f = data[i];
    q.push_back(static_cast<T>(
      std::max<float>(q_min, std::min<float>(q_max, std::round(zero_point + (f / scale))))));
  }
  return q;
}

References flatbuffers::data().