openvela
/
apps_mlearning_tflite-micro
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
apps_mlearning_tflite-micro/tensorflow/lite/micro/kernels/quantize_test.cc

440 lines
18 KiB
C++
Raw Permalink Blame History

/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/lite/c/builtin_op_data.h"
#include "tensorflow/lite/c/common.h"
#include "tensorflow/lite/micro/kernels/kernel_runner.h"
#include "tensorflow/lite/micro/test_helpers.h"
#include "tensorflow/lite/micro/testing/micro_test.h"
namespace tflite {
namespace testing {
namespace {
template <typename T>
void ValidateQuantizeGoldens(TfLiteTensor* tensors, int tensors_size,
const float* golden, T* golden_quantized,
float scale, int zero_point, int output_len,
T* output_data) {
int inputs_array_data[] = {1, 0};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
int outputs_array_data[] = {1, 1};
TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
// Version 1 of quantize supports int8_t and uint8_t quantization.
const TFLMRegistration registration = Register_QUANTIZE();
micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
outputs_array,
/*builtin_data=*/nullptr);
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
// Use reference quantization from test utils to compare against op output.
Quantize(golden, golden_quantized, output_len, scale, zero_point);
for (int i = 0; i < output_len; ++i) {
TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);
}
}
template <typename T>
void TestQuantizeFloat(int* input_dims_data, const float* input_data,
int* output_dims_data, const float* golden,
T* golden_quantized, const float scale,
const int zero_point, T* output_data) {
TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
TfLiteTensor output_tensor =
CreateQuantizedTensor(output_data, output_dims, scale, zero_point);
TfLiteAffineQuantization quant;
float scales[] = {1, scale};
int zero_points[] = {1, zero_point};
quant.scale = FloatArrayFromFloats(scales);
quant.zero_point = IntArrayFromInts(zero_points);
output_tensor.quantization = {kTfLiteAffineQuantization, &quant};
// 1 input, 1 output.
constexpr int tensors_size = 2;
TfLiteTensor tensors[tensors_size] = {
CreateTensor(input_data, input_dims),
output_tensor,
};
ValidateQuantizeGoldens(tensors, tensors_size, golden, golden_quantized,
scale, zero_point, output_dims_count, output_data);
}
template <typename InputType, typename OutputType>
void TestRequantize(int* input_dims_data, const float* input_data,
InputType* input_quantized, const float input_scale,
const int input_zero_point, int* output_dims_data,
const float* golden, OutputType* golden_quantized,
const float output_scale, const int output_zero_point,
OutputType* output_data) {
TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
TfLiteTensor output_tensor = CreateQuantizedTensor(
output_data, output_dims, output_scale, output_zero_point);
TfLiteAffineQuantization quant;
float scales[] = {1, output_scale};
int zero_points[] = {1, output_zero_point};
quant.scale = FloatArrayFromFloats(scales);
quant.zero_point = IntArrayFromInts(zero_points);
output_tensor.quantization = {kTfLiteAffineQuantization, &quant};
// 1 input, 1 output.
constexpr int tensors_size = 2;
TfLiteTensor tensors[tensors_size] = {
CreateQuantizedTensor(input_data, input_quantized, input_dims,
input_scale, input_zero_point),
output_tensor,
};
ValidateQuantizeGoldens(tensors, tensors_size, golden, golden_quantized,
output_scale, output_zero_point, output_dims_count,
output_data);
}
} // namespace
} // namespace testing
} // namespace tflite
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(QuantizeOpTestInt16) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-63.5, -63, -62.5, -62, -61.5,
62, 62.5, 63, 63.5, 64};
const float scale = 0.5;
const int zero_point = -1;
int16_t output[kLength];
int16_t values_quantized[kLength];
tflite::testing::TestQuantizeFloat(
dims, values, dims, values, values_quantized, scale, zero_point, output);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt16NoScale) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-128, -127, -126, -125, -124,
123, 124, 125, 126, 127};
const float scale = 1.0;
const int zero_point = 0;
int16_t output[kLength];
int16_t values_quantized[kLength];
tflite::testing::TestQuantizeFloat(
dims, values, dims, values, values_quantized, scale, zero_point, output);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt16toInt16) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-64, -62, -60, -58, -56, 54, 56, 58, 60, 62};
const float input_scale = 2.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 32;
int16_t output_quantized[kLength];
int16_t values_quantized[kLength];
int16_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt16toInt16NoZeroPoint) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 0;
int16_t output_quantized[kLength];
int16_t values_quantized[kLength];
int16_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toInt8) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-64, -62, -60, -58, -56, 54, 56, 58, 60, 62};
const float input_scale = 2.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 32;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toInt8NoZeroPoint) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 0;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toInt16) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-64, -62, -60, -58, -56, 54, 56, 58, 60, 62};
const float input_scale = 2.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 32;
int16_t output_quantized[kLength];
int16_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt32toInt16) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
// TODO(b/155682734): Input scale must be smaller than output scale for
// xtensa.
const float input_scale = 0.4f;
const int input_zero_point = 0;
const float output_scale = 1.0f;
const int output_zero_point = 0;
int16_t output_quantized[kLength];
int16_t values_quantized[kLength];
int32_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt32toInt8) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
// TODO(b/155682734): Input scale must be smaller than output scale for
// xtensa.
const float input_scale = 0.4f;
const int input_zero_point = 0;
const float output_scale = 1.0f;
const int output_zero_point = 0;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
int32_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
// TODO(b/155682734): Hifimini optimized quantize requires input scale to be
// smaller than output scale.
TF_LITE_MICRO_TEST(QuantizeOpTestInt16toInt8) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-64, -62, -60, -58, -56, 54, 56, 58, 60, 62};
const float input_scale = 2.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 0;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
int16_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
// Test the fast algorithm from int8 to uint8 when zero point diff = -128
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toUInt8Fast) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.0f;
const int input_zero_point = 0;
const float output_scale = 0.5f;
const int output_zero_point = 128;
uint8_t output_quantized[kLength];
uint8_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
// Test the normal requant algorithm from int8 to uint8
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toUInt8Normal) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.0f;
const int input_zero_point = 50;
const float output_scale = 1.0f;
const int output_zero_point = 110;
uint8_t output_quantized[kLength];
uint8_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
// Test the fast algorithm from uint8 to int8 when zero point diff = 128
TF_LITE_MICRO_TEST(QuantizeOpTestUInt8toInt8Fast) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 0.4f;
const int input_zero_point = 0;
const float output_scale = 1.0f;
const int output_zero_point = -128;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
uint8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
// Test the normal requant algorithm from uint8 to int8
TF_LITE_MICRO_TEST(QuantizeOpTestUInt8toInt8Normal) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.0f;
const int input_zero_point = 50;
const float output_scale = 0.3f;
const int output_zero_point = 0;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
uint8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8toInt32) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 0;
int32_t output_quantized[kLength];
int32_t values_quantized[kLength];
int8_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt16toInt32) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float input_scale = 1.f;
const int input_zero_point = 0;
const float output_scale = 0.5;
const int output_zero_point = 0;
int32_t output_quantized[kLength];
int32_t values_quantized[kLength];
int16_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt16toInt8) {
constexpr int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
// TODO(b/155682734): Input scale must be smaller than output scale for
// xtensa.
const float input_scale = 0.4f;
const int input_zero_point = 0;
const float output_scale = 1.0f;
const int output_zero_point = 0;
int8_t output_quantized[kLength];
int8_t values_quantized[kLength];
int16_t input_quantized[kLength];
tflite::testing::TestRequantize(dims, values, input_quantized, input_scale,
input_zero_point, dims, values,
values_quantized, output_scale,
output_zero_point, output_quantized);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-63.5, -63, -62.5, -62, -61.5,
62, 62.5, 63, 63.5, 64};
const float scale = 0.5;
const int zero_point = -1;
int16_t output[kLength];
int16_t values_quantized[kLength];
tflite::testing::TestQuantizeFloat(
dims, values, dims, values, values_quantized, scale, zero_point, output);
}
TF_LITE_MICRO_TEST(QuantizeOpTestInt8NoZeroPoint) {
const int kLength = 10;
int dims[] = {2, 2, 5};
const float values[] = {-32, -31, -30, -29, -28, 27, 28, 29, 30, 31};
const float scale = 0.5;
const int zero_point = 0;
int8_t output[kLength];
int8_t values_quantized[kLength];
tflite::testing::TestQuantizeFloat(
dims, values, dims, values, values_quantized, scale, zero_point, output);
}
TF_LITE_MICRO_TESTS_END
Reference in New Issue View Git Blame Copy Permalink