Remove all instances of initializer_list from TF Micro kernel tests and clean up tests.
PiperOrigin-RevId: 324669800
Change-Id: Ib47abca412a47f30bfc804f21e3194ded3e72bc5
diff --git a/tensorflow/lite/micro/examples/micro_speech/recognize_commands_test.cc b/tensorflow/lite/micro/examples/micro_speech/recognize_commands_test.cc
index eff7b4e..089da91 100644
--- a/tensorflow/lite/micro/examples/micro_speech/recognize_commands_test.cc
+++ b/tensorflow/lite/micro/examples/micro_speech/recognize_commands_test.cc
@@ -75,11 +75,11 @@
RecognizeCommands recognize_commands(µ_error_reporter);
- std::initializer_list<int8_t> result_data = {127, -128, -128, -128};
- auto result_dims = {2, 1, 4};
+ const int8_t result_data[] = {127, -128, -128, -128};
+ const int result_dims[] = {2, 1, 4};
TfLiteTensor results = tflite::testing::CreateQuantizedTensor(
- result_data, tflite::testing::IntArrayFromInitializer(result_dims),
- -128.0f, 127.0f);
+ result_data, tflite::testing::IntArrayFromInts(result_dims), -128.0f,
+ 127.0f);
const char* found_command;
uint8_t score;
@@ -94,11 +94,10 @@
RecognizeCommands recognize_commands(µ_error_reporter, 1000, 51);
- std::initializer_list<int8_t> yes_data = {-128, -128, 127, -128};
- auto yes_dims = {2, 1, 4};
+ const int8_t yes_data[] = {-128, -128, 127, -128};
+ const int yes_dims[] = {2, 1, 4};
TfLiteTensor yes_results = tflite::testing::CreateQuantizedTensor(
- yes_data, tflite::testing::IntArrayFromInitializer(yes_dims), -128.0f,
- 127.0f);
+ yes_data, tflite::testing::IntArrayFromInts(yes_dims), -128.0f, 127.0f);
bool has_found_new_command = false;
const char* new_command;
@@ -122,11 +121,10 @@
TF_LITE_MICRO_EXPECT_EQ(0, tflite::testing::TestStrcmp("yes", new_command));
}
- std::initializer_list<int8_t> no_data = {-128, -128, -128, 127};
- auto no_dims = {2, 1, 4};
+ const int8_t no_data[] = {-128, -128, -128, 127};
+ const int no_dims[] = {2, 1, 4};
TfLiteTensor no_results = tflite::testing::CreateQuantizedTensor(
- no_data, tflite::testing::IntArrayFromInitializer(no_dims), -128.0f,
- 127.0f);
+ no_data, tflite::testing::IntArrayFromInts(no_dims), -128.0f, 127.0f);
has_found_new_command = false;
new_command = "";
uint8_t score;
@@ -156,11 +154,10 @@
RecognizeCommands recognize_commands(µ_error_reporter, 1000, 51);
- std::initializer_list<int8_t> bad_data = {-128, -128, 127};
- auto bad_dims = {2, 1, 3};
+ const int8_t bad_data[] = {-128, -128, 127};
+ const int bad_dims[] = {2, 1, 3};
TfLiteTensor bad_results = tflite::testing::CreateQuantizedTensor(
- bad_data, tflite::testing::IntArrayFromInitializer(bad_dims), -128.0f,
- 127.0f);
+ bad_data, tflite::testing::IntArrayFromInts(bad_dims), -128.0f, 127.0f);
const char* found_command;
uint8_t score;
@@ -175,11 +172,11 @@
RecognizeCommands recognize_commands(µ_error_reporter, 1000, 51);
- std::initializer_list<int8_t> result_data = {-128, -128, 127, -128};
- auto result_dims = {2, 1, 4};
+ const int8_t result_data[] = {-128, -128, 127, -128};
+ const int result_dims[] = {2, 1, 4};
TfLiteTensor results = tflite::testing::CreateQuantizedTensor(
- result_data, tflite::testing::IntArrayFromInitializer(result_dims),
- -128.0f, 127.0f);
+ result_data, tflite::testing::IntArrayFromInts(result_dims), -128.0f,
+ 127.0f);
const char* found_command;
uint8_t score;
@@ -197,11 +194,11 @@
RecognizeCommands recognize_commands(µ_error_reporter, 1000, 51);
- std::initializer_list<int8_t> result_data = {-128, -128, 127, -128};
- auto result_dims = {2, 1, 4};
+ const int8_t result_data[] = {-128, -128, 127, -128};
+ const int result_dims[] = {2, 1, 4};
TfLiteTensor results = tflite::testing::CreateQuantizedTensor(
- result_data, tflite::testing::IntArrayFromInitializer(result_dims),
- -128.0f, 127.0f);
+ result_data, tflite::testing::IntArrayFromInts(result_dims), -128.0f,
+ 127.0f);
const char* found_command;
uint8_t score;
diff --git a/tensorflow/lite/micro/kernels/concatenation_test.cc b/tensorflow/lite/micro/kernels/concatenation_test.cc
index c3fa395..d82a804 100644
--- a/tensorflow/lite/micro/kernels/concatenation_test.cc
+++ b/tensorflow/lite/micro/kernels/concatenation_test.cc
@@ -24,17 +24,16 @@
namespace testing {
namespace {
-void TestConcatenateTwoInputs(std::initializer_list<int> input1_dims_data,
- std::initializer_list<float> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<float> input2_data,
- int axis,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<float> expected_output_data,
+void TestConcatenateTwoInputs(const int* input1_dims_data,
+ const float* input1_data,
+ const int* input2_dims_data,
+ const float* input2_data, int axis,
+ const int* output_dims_data,
+ const float* expected_output_data,
float* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
constexpr int input_size = 2;
constexpr int output_size = 1;
@@ -65,30 +64,31 @@
const int output_dims_count = ElementCount(*output_dims);
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
+ TF_LITE_MICRO_EXPECT_NEAR(expected_output_data[i], output_data[i], 1e-5f);
}
}
void TestConcatenateQuantizedTwoInputs(
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<uint8_t> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<uint8_t> input2_data, float input_min,
- float input_max, int axis, std::initializer_list<int> output_dims_data,
- std::initializer_list<uint8_t> expected_output_data, float output_min,
- float output_max, uint8_t* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ const int* input1_dims_data, const uint8_t* input1_data,
+ const int* input2_dims_data, const uint8_t* input2_data,
+ const float input_scale, const int input_zero_point, int axis,
+ const int* output_dims_data, const uint8_t* expected_output_data,
+ const float output_scale, const int output_zero_point,
+ uint8_t* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
constexpr int input_size = 2;
constexpr int output_size = 1;
constexpr int tensors_size = input_size + output_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input1_data, input1_dims, input_min, input_max),
- CreateQuantizedTensor(input2_data, input2_dims, input_min, input_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max)};
+ CreateQuantizedTensor(input1_data, input1_dims, input_scale,
+ input_zero_point),
+ CreateQuantizedTensor(input2_data, input2_dims, input_scale,
+ input_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point)};
int inputs_array_data[] = {2, 0, 1};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
@@ -111,7 +111,7 @@
const int output_dims_count = ElementCount(*output_dims);
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
+ TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
}
}
@@ -124,19 +124,19 @@
TF_LITE_MICRO_TEST(TwoInputsAllAxesCombinations) {
// Concatenate the same two input tensors along all possible axes.
- auto input_shape = {2, 2, 3};
- auto input1_value = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
- auto input2_value = {7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
+ const int input_shape[] = {2, 2, 3};
+ const float input1_value[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
+ const float input2_value[] = {7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
// expected output when concatenating on axis 0
- auto output_shape_axis0 = {2, 4, 3};
- auto output_value_axis0 = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
+ const int output_shape_axis0[] = {2, 4, 3};
+ const float output_value_axis0[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
// expected output when concatenating on axis 1
- auto output_shape_axis1 = {2, 2, 6};
- auto output_value_axis1 = {1.0f, 2.0f, 3.0f, 7.0f, 8.0f, 9.0f,
- 4.0f, 5.0f, 6.0f, 10.0f, 11.0f, 12.0f};
+ const int output_shape_axis1[] = {2, 2, 6};
+ const float output_value_axis1[] = {1.0f, 2.0f, 3.0f, 7.0f, 8.0f, 9.0f,
+ 4.0f, 5.0f, 6.0f, 10.0f, 11.0f, 12.0f};
float output_data[12];
@@ -162,59 +162,48 @@
}
TF_LITE_MICRO_TEST(TwoInputsQuantizedUint8) {
- using tflite::testing::F2Q;
-
const int axis = 2;
- auto input_shape = {3, 2, 1, 2};
- auto output_shape = {3, 2, 1, 4};
+ const int input_shape[] = {3, 2, 1, 2};
+ const int output_shape[] = {3, 2, 1, 4};
- const float input_min = -12.7f;
- const float input_max = 12.8f;
- const float output_min = -12.7f;
- const float output_max = 12.8f;
+ const float input_scale = 0.1f;
+ const int input_zero_point = 127;
+ const float output_scale = 0.1f;
+ const int output_zero_point = 127;
- auto input1_value = {
- F2Q(1.0, input_min, input_max),
- F2Q(3.0, input_min, input_max),
- F2Q(4.0, input_min, input_max),
- F2Q(7.0, input_min, input_max),
- };
+ const uint8_t input1_values[] = {137, 157, 167, 197};
- auto input2_value = {
- F2Q(1.1, input_min, input_max),
- F2Q(3.1, input_min, input_max),
- F2Q(4.1, input_min, input_max),
- F2Q(7.1, input_min, input_max),
- };
+ const uint8_t input2_values[] = {138, 158, 168, 198};
- std::initializer_list<uint8_t> output_value = {
+ const uint8_t output_value[] = {
137, 157, 138, 158, 167, 197, 168, 198,
};
uint8_t output_data[8];
tflite::testing::TestConcatenateQuantizedTwoInputs(
- input_shape, input1_value, input_shape, input2_value, input_min,
- input_max, axis, output_shape, output_value, output_min, output_max,
- output_data);
+ input_shape, input1_values, input_shape, input2_values, input_scale,
+ input_zero_point, axis, output_shape, output_value, output_scale,
+ output_zero_point, output_data);
}
TF_LITE_MICRO_TEST(ThreeDimensionalTwoInputsDifferentShapes) {
const int axis = 1;
- auto input1_shape = {3, 2, 1, 2};
- auto input2_shape = {3, 2, 3, 2};
- auto output_shape = {3, 2, 4, 2};
+ const int input1_shape[] = {3, 2, 1, 2};
+ const int input2_shape[] = {3, 2, 3, 2};
+ const int output_shape[] = {3, 2, 4, 2};
- auto input1_value = {1.0f, 3.0f, 4.0f, 7.0f};
- auto input2_value = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
- auto output_value = {1.0f, 3.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
- 4.0f, 7.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
+ const float input1_values[] = {1.0f, 3.0f, 4.0f, 7.0f};
+ const float input2_values[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f};
+ const float output_values[] = {1.0f, 3.0f, 1.0f, 2.0f, 3.0f, 4.0f,
+ 5.0f, 6.0f, 4.0f, 7.0f, 7.0f, 8.0f,
+ 9.0f, 10.0f, 11.0f, 12.0f};
float output_data[16];
tflite::testing::TestConcatenateTwoInputs(
- input1_shape, input1_value, input2_shape, input2_value, axis,
- output_shape, output_value, output_data);
+ input1_shape, input1_values, input2_shape, input2_values, axis,
+ output_shape, output_values, output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/maximum_minimum_test.cc b/tensorflow/lite/micro/kernels/maximum_minimum_test.cc
index ee84fcb..7fab540 100644
--- a/tensorflow/lite/micro/kernels/maximum_minimum_test.cc
+++ b/tensorflow/lite/micro/kernels/maximum_minimum_test.cc
@@ -25,16 +25,13 @@
namespace {
void TestMaxMinFloat(const TfLiteRegistration& registration,
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<float> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<float> input2_data,
- std::initializer_list<float> expected_output_data,
- std::initializer_list<int> output_dims_data,
- float* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ const int* input1_dims_data, const float* input1_data,
+ const int* input2_dims_data, const float* input2_data,
+ const float* expected_output_data,
+ const int* output_dims_data, float* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
@@ -59,34 +56,35 @@
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
+ TF_LITE_MICRO_EXPECT_NEAR(expected_output_data[i], output_data[i], 1e-5f);
}
}
void TestMaxMinQuantized(const TfLiteRegistration& registration,
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<uint8_t> input1_data,
- float input1_min, float input1_max,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<uint8_t> input2_data,
- float input2_min, float input2_max,
- std::initializer_list<uint8_t> expected_output_data,
- float output_min, float output_max,
- std::initializer_list<int> output_dims_data,
- uint8_t* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ const int* input1_dims_data,
+ const uint8_t* input1_data, float const input1_scale,
+ const int input1_zero_point,
+ const int* input2_dims_data,
+ const uint8_t* input2_data, const float input2_scale,
+ const int input2_zero_point,
+ const uint8_t* expected_output_data,
+ const float output_scale, const int output_zero_point,
+ const int* output_dims_data, uint8_t* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
constexpr int outputs_size = 1;
constexpr int tensors_size = inputs_size + outputs_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input1_data, input1_dims, input1_min, input1_max),
- CreateQuantizedTensor(input2_data, input2_dims, input2_min, input2_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max),
+ CreateQuantizedTensor(input1_data, input1_dims, input1_scale,
+ input1_zero_point),
+ CreateQuantizedTensor(input2_data, input2_dims, input2_scale,
+ input2_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point),
};
int inputs_array_data[] = {2, 0, 1};
@@ -102,21 +100,21 @@
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
+ TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
}
}
-void TestMaxMinQuantizedInt32(
- const TfLiteRegistration& registration,
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<int32_t> input1_data, float input1_scale,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<int32_t> input2_data, float input2_scale,
- std::initializer_list<int32_t> expected_output_data, float output_scale,
- std::initializer_list<int> output_dims_data, int32_t* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestMaxMinQuantizedInt32(const TfLiteRegistration& registration,
+ const int* input1_dims_data,
+ const int32_t* input1_data, float input1_scale,
+ const int* input2_dims_data,
+ const int32_t* input2_data, float input2_scale,
+ const int32_t* expected_output_data,
+ float output_scale, const int* output_dims_data,
+ int32_t* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
@@ -141,7 +139,7 @@
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
+ TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
}
}
@@ -152,109 +150,86 @@
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(FloatTest) {
- std::initializer_list<float> data1 = {1.0, 0.0, -1.0, 11.0, -2.0, -1.44};
- std::initializer_list<float> data2 = {-1.0, 0.0, 1.0, 12.0, -3.0, -1.43};
+ const int dims[] = {3, 3, 1, 2};
+ const float data1[] = {1.0, 0.0, -1.0, 11.0, -2.0, -1.44};
+ const float data2[] = {-1.0, 0.0, 1.0, 12.0, -3.0, -1.43};
+ const float golden_max[] = {1.0, 0.0, 1.0, 12.0, -2.0, -1.43};
+ const float golden_min[] = {-1.0, 0.0, -1.0, 11.0, -3.0, -1.44};
float output_data[6];
- tflite::testing::TestMaxMinFloat(
- tflite::ops::micro::Register_MAXIMUM(), {3, 3, 1, 2},
- data1, // input1 shape and data
- {3, 3, 1, 2}, data2, // input2 shape and data
- {1.0, 0.0, 1.0, 12.0, -2.0, -1.43}, // expected output
- {3, 3, 1, 2}, output_data); // output shape and data buffer
+ tflite::testing::TestMaxMinFloat(tflite::ops::micro::Register_MAXIMUM(), dims,
+ data1, dims, data2, golden_max, dims,
+ output_data);
- tflite::testing::TestMaxMinFloat(
- tflite::ops::micro::Register_MINIMUM(), {3, 3, 1, 2},
- data1, // input1 shape and data
- {3, 3, 1, 2}, data2, // input2 shape and data
- {-1.0, 0.0, -1.0, 11.0, -3.0, -1.44}, // expected output
- {3, 3, 1, 2}, output_data); // output shape and data buffer
+ tflite::testing::TestMaxMinFloat(tflite::ops::micro::Register_MINIMUM(), dims,
+ data1, dims, data2, golden_min, dims,
+ output_data);
}
TF_LITE_MICRO_TEST(Uint8Test) {
- std::initializer_list<uint8_t> data1 = {1, 0, 2, 11, 2, 23};
- std::initializer_list<uint8_t> data2 = {0, 0, 1, 12, 255, 1};
- const float input1_min = -63.5;
- const float input1_max = 64;
- const float input2_min = -63.5;
- const float input2_max = 64;
- const float output_min = -63.5;
- const float output_max = 64;
+ const int dims[] = {3, 3, 1, 2};
+ const uint8_t data1[] = {1, 0, 2, 11, 2, 23};
+ const uint8_t data2[] = {0, 0, 1, 12, 255, 1};
+ const uint8_t golden_max[] = {1, 0, 2, 12, 255, 23};
+ const uint8_t golden_min[] = {0, 0, 1, 11, 2, 1};
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
uint8_t output_data[6];
tflite::testing::TestMaxMinQuantized(
- tflite::ops::micro::Register_MAXIMUM(),
- // input1 shape, data and bounds
- {3, 3, 1, 2}, data1, input1_min, input1_max,
- // input2 shape, data and bounds
- {3, 3, 1, 2}, data2, input2_min, input2_max,
- // expected output
- {1, 0, 2, 12, 255, 23},
- // output bounds, shape and data buffer
- output_min, output_max, {3, 3, 1, 2}, output_data);
+ tflite::ops::micro::Register_MAXIMUM(), dims, data1, input_scale,
+ input_zero_point, dims, data2, input_scale, input_zero_point, golden_max,
+ output_scale, output_zero_point, dims, output_data);
tflite::testing::TestMaxMinQuantized(
- tflite::ops::micro::Register_MINIMUM(),
- // input1 shape, data and bounds
- {3, 3, 1, 2}, data1, input1_min, input1_max,
- // input2 shape, data and bounds
- {3, 3, 1, 2}, data2, input2_min, input2_max,
- // expected output
- {0, 0, 1, 11, 2, 1},
- // output bounds, shape and data buffer
- output_min, output_max, {3, 3, 1, 2}, output_data);
+ tflite::ops::micro::Register_MINIMUM(), dims, data1, input_scale,
+ input_zero_point, dims, data2, input_scale, input_zero_point, golden_min,
+ output_scale, output_zero_point, dims, output_data);
}
TF_LITE_MICRO_TEST(FloatWithBroadcastTest) {
- std::initializer_list<float> data1 = {1.0, 0.0, -1.0, -2.0, -1.44, 11.0};
- std::initializer_list<float> data2 = {0.5, 2.0};
+ const int dims[] = {3, 3, 1, 2};
+ const int dims_scalar[] = {1, 2};
+ const float data1[] = {1.0, 0.0, -1.0, -2.0, -1.44, 11.0};
+ const float data2[] = {0.5, 2.0};
+ const float golden_max[] = {1.0, 2.0, 0.5, 2.0, 0.5, 11.0};
+ const float golden_min[] = {0.5, 0.0, -1.0, -2.0, -1.44, 2.0};
float output_data[6];
- tflite::testing::TestMaxMinFloat(
- tflite::ops::micro::Register_MAXIMUM(), {3, 3, 1, 2},
- data1, // input1 shape and data
- {1, 2}, data2, // input2 shape and data
- {1.0, 2.0, 0.5, 2.0, 0.5, 11.0}, // expected output
- {3, 3, 1, 2}, output_data); // output shape and data buffer
+ tflite::testing::TestMaxMinFloat(tflite::ops::micro::Register_MAXIMUM(), dims,
+ data1, dims_scalar, data2, golden_max, dims,
+ output_data);
- tflite::testing::TestMaxMinFloat(
- tflite::ops::micro::Register_MINIMUM(), {3, 3, 1, 2},
- data1, // input1 shape and data
- {1, 2}, data2, // input2 shape and data
- {0.5, 0.0, -1.0, -2.0, -1.44, 2.0}, // expected output
- {3, 3, 1, 2}, output_data); // output shape and data buffer
+ tflite::testing::TestMaxMinFloat(tflite::ops::micro::Register_MINIMUM(), dims,
+ data1, dims_scalar, data2, golden_min, dims,
+ output_data);
}
TF_LITE_MICRO_TEST(Int32WithBroadcastTest) {
const float input1_scale = 0.5;
const float input2_scale = 0.5;
const float output_scale = 0.5;
- std::initializer_list<int32_t> data1 = {1, 0, -1, -2, 3, 11};
- std::initializer_list<int32_t> data2 = {2};
+ const int dims[] = {3, 3, 1, 2};
+ const int dims_scalar[] = {1, 1};
+ const int32_t data1[] = {1, 0, -1, -2, 3, 11};
+ const int32_t data2[] = {2};
+ const int32_t golden_max[] = {2, 2, 2, 2, 3, 11};
+ const int32_t golden_min[] = {1, 0, -1, -2, 2, 2};
int32_t output_data[6];
tflite::testing::TestMaxMinQuantizedInt32(
- tflite::ops::micro::Register_MAXIMUM(),
- // input1 shape, data and scale
- {3, 3, 1, 2}, data1, input1_scale,
- // input2 shape, data and scale
- {1, 1}, data2, input2_scale,
- // expected output
- {2, 2, 2, 2, 3, 11},
- // output scale, shape and data buffer
- output_scale, {3, 3, 1, 2}, output_data);
+ tflite::ops::micro::Register_MAXIMUM(), dims, data1, input1_scale,
+ dims_scalar, data2, input2_scale, golden_max, output_scale, dims,
+ output_data);
tflite::testing::TestMaxMinQuantizedInt32(
- tflite::ops::micro::Register_MINIMUM(),
- // input1 shape, data and scale
- {3, 3, 1, 2}, data1, input1_scale,
- // input2 shape, data and scale
- {1, 1}, data2, input2_scale,
- // expected output
- {1, 0, -1, -2, 2, 2},
- // output scale, shape and data buffer
- output_scale, {3, 3, 1, 2}, output_data);
+ tflite::ops::micro::Register_MINIMUM(), dims, data1, input1_scale,
+ dims_scalar, data2, input2_scale, golden_min, output_scale, dims,
+ output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/mul_test.cc b/tensorflow/lite/micro/kernels/mul_test.cc
index e39f669..86b4d8b 100644
--- a/tensorflow/lite/micro/kernels/mul_test.cc
+++ b/tensorflow/lite/micro/kernels/mul_test.cc
@@ -23,16 +23,57 @@
namespace testing {
namespace {
-void TestMulFloat(std::initializer_list<int> input1_dims_data,
- std::initializer_list<float> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<float> input2_data,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<float> expected_output_data,
+const int flat_size_simple = 4;
+const float scale_simple = 0.01;
+const int dims_simple[] = {4, 1, 2, 2, 1};
+const float input1_simple[] = {-0.8, 0.2, 0.9, 0.7};
+const float input2_simple[] = {0.6, 0.4, 0.9, 0.8};
+const float golden_simple[] = {-0.48, 0.08, 0.81, 0.56};
+const float golden_simple_relu[] = {0.0, 0.08, 0.81, 0.56};
+
+const int flat_size_broadcast = 6;
+const float input_scale_broadcast = 0.05f;
+const float output_scale_broadcast = 0.01f;
+const int dims_broadcast[] = {4, 1, 3, 1, 2};
+const int dims_scalar_broadcast[] = {1, 1};
+const float input1_broadcast[] = {-2.0, 0.2, 0.7, 0.8, 1.1, 2.0};
+const float input2_broadcast[] = {0.1};
+const float golden_broadcast[] = {-0.2, 0.02, 0.07, 0.08, 0.11, 0.2};
+const float golden_broadcast_relu[] = {0, 0.02, 0.07, 0.08, 0.11, 0.2};
+
+template <typename T>
+void ValidateMulGoldens(TfLiteTensor* tensors, int tensors_size,
+ TfLiteFusedActivation activation, const T* golden,
+ int output_len, float tolerance, T* output) {
+ TfLiteMulParams builtin_data = {
+ .activation = activation,
+ };
+
+ int inputs_array_data[] = {2, 0, 1};
+ TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
+ int outputs_array_data[] = {1, 2};
+ TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
+
+ const TfLiteRegistration registration = tflite::ops::micro::Register_MUL();
+ micro::KernelRunner runner(
+ registration, tensors, tensors_size, inputs_array, outputs_array,
+ reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
+
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
+
+ for (int i = 0; i < output_len; i++) {
+ TF_LITE_MICRO_EXPECT_NEAR(golden[i], output[i], tolerance);
+ }
+}
+
+void TestMulFloat(const int* input1_dims_data, const float* input1_data,
+ const int* input2_dims_data, const float* input2_data,
+ const int* output_dims_data, const float* golden,
float* output_data, TfLiteFusedActivation activation) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
@@ -44,75 +85,40 @@
CreateFloatTensor(output_data, output_dims),
};
- TfLiteMulParams builtin_data = {
- .activation = activation,
- };
-
- int inputs_array_data[] = {2, 0, 1};
- TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
- int outputs_array_data[] = {1, 2};
- TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
-
- const TfLiteRegistration registration = tflite::ops::micro::Register_MUL();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; i++) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidateMulGoldens(tensors, tensors_size, activation, golden,
+ output_dims_count, 1e-5, output_data);
}
template <typename T>
-void TestMulQuantized(std::initializer_list<int> input1_dims_data,
- std::initializer_list<T> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<T> input2_data,
- const float input_min, const float input_max,
- std::initializer_list<int> output_dims_data,
- const float output_min, const float output_max,
- std::initializer_list<T> expected_output_data,
- T* output_data, TfLiteFusedActivation activation,
- int error_tolerance) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestMulQuantized(const int* input1_dims_data, const float* input1_data,
+ T* input1_quantized, const int* input2_dims_data,
+ const float* input2_data, T* input2_quantized,
+ const float input_scale, const int input_zero_point,
+ const int* output_dims_data, const float* golden,
+ T* golden_quantized, const float output_scale,
+ const int output_zero_point, T* output_data,
+ TfLiteFusedActivation activation) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
constexpr int outputs_size = 1;
constexpr int tensors_size = inputs_size + outputs_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input1_data, input1_dims, input_min, input_max),
- CreateQuantizedTensor(input2_data, input2_dims, input_min, input_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max),
- };
+ CreateQuantizedTensor(input1_data, input1_quantized, input1_dims,
+ input_scale, input_zero_point),
+ CreateQuantizedTensor(input2_data, input2_quantized, input2_dims,
+ input_scale, input_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point)};
- TfLiteMulParams builtin_data = {
- .activation = activation,
- };
+ AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+ output_zero_point);
- int inputs_array_data[] = {2, 0, 1};
- TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
- int outputs_array_data[] = {1, 2};
- TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
-
- const TfLiteRegistration registration = tflite::ops::micro::Register_MUL();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; i++) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- error_tolerance);
- }
+ ValidateMulGoldens(tensors, tensors_size, activation, golden_quantized,
+ output_dims_count, 1.0f, output_data);
}
} // namespace
@@ -122,250 +128,105 @@
TF_LITE_MICRO_TESTS_BEGIN
-TF_LITE_MICRO_TEST(Int8NoActivation) {
- using tflite::testing::F2QS;
- const float input_min = -1;
- const float input_max = 1;
- const float output_min = -1;
- const float output_max = 1;
+TF_LITE_MICRO_TEST(SimpleFloatNoAcativationShouldMatchGolden) {
+ float output_data[tflite::testing::flat_size_simple];
- int8_t output_data[4];
- tflite::testing::TestMulQuantized({4, 1, 2, 2, 1}, // input1 dims
- {
- F2QS(-0.8, input_min, input_max),
- F2QS(0.2, input_min, input_max),
- F2QS(0.9, input_min, input_max),
- F2QS(0.7, input_min, input_max),
- }, // input1 data
- {4, 1, 2, 2, 1}, // input2 dims
- {
- F2QS(0.6, input_min, input_max),
- F2QS(0.4, input_min, input_max),
- F2QS(0.9, input_min, input_max),
- F2QS(0.8, input_min, input_max),
- }, // input2 data
- input_min, input_max,
- {4, 1, 2, 2, 1}, // output dims
- output_min, output_max,
- {
- F2QS(-0.48, output_min, output_max),
- F2QS(0.08, output_min, output_max),
- F2QS(0.81, output_min, output_max),
- F2QS(0.56, output_min, output_max),
- }, // expected output data
- output_data, kTfLiteActNone, 1);
-}
-
-TF_LITE_MICRO_TEST(Int8NoActivationLargeMultiplier) {
- using tflite::testing::F2QS;
- const float input_min = -100;
- const float input_max = 100;
- const float output_min = -10;
- const float output_max = 10;
-
- int8_t output_data[4];
- tflite::testing::TestMulQuantized(
- {4, 1, 2, 2, 1},
- {
- F2QS(-4, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(3, input_min, input_max),
- F2QS(1, input_min, input_max),
- },
- {4, 1, 2, 2, 1},
- {
- /* F2QS(-1, input_min, input_max), F2QS(-3, input_min, input_max), */
- F2QS(-1, input_min, input_max),
- F2QS(-3, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(2, input_min, input_max),
- },
- input_min, input_max, {4, 1, 2, 2, 1}, output_min, output_max,
- {
- F2QS(4, output_min, output_max),
- F2QS(-6, output_min, output_max),
- F2QS(12, output_min, output_max),
- F2QS(2, output_min, output_max),
- },
- // In Tensorflow Lite, this test have a max allowed error of 1.4f.
- // A difference of 1.4 in floating points corresponds to 18 quantized
- // for the output min/max [-10, 10].
- output_data, kTfLiteActNone, 18);
-}
-
-TF_LITE_MICRO_TEST(Int8NoActivationBroadcast) {
- using tflite::testing::F2QS;
- const float input_min = -3.0;
- const float input_max = 3.0;
- const float output_min = -3.0;
- const float output_max = 3.0;
-
- int8_t output_data[6];
- tflite::testing::TestMulQuantized({4, 1, 3, 1, 2}, // input1 shape
- {
- F2QS(-2.0, input_min, input_max),
- F2QS(0.2, input_min, input_max),
- F2QS(0.7, input_min, input_max),
- F2QS(0.8, input_min, input_max),
- F2QS(1.1, input_min, input_max),
- F2QS(2.0, input_min, input_max),
- }, // input1 data
- {1, 1}, // input2 shape
- {
- F2QS(0.1, input_min, input_max),
- }, // input2 data
- input_min, input_max,
- {4, 1, 3, 1, 2}, // output shape
- output_min, output_max,
- {
- F2QS(-0.2, output_min, output_max),
- F2QS(0.02, output_min, output_max),
- F2QS(0.07, output_min, output_max),
- F2QS(0.08, output_min, output_max),
- F2QS(0.11, output_min, output_max),
- F2QS(0.2, output_min, output_max),
- }, // expected output data
- output_data, kTfLiteActNone, 1);
-}
-
-TF_LITE_MICRO_TEST(UInt8NoActivation) {
- using tflite::testing::F2Q;
- const float input_min = -1;
- const float input_max = 1;
- const float output_min = -1;
- const float output_max = 1;
-
- uint8_t output_data[4];
- tflite::testing::TestMulQuantized({4, 1, 2, 2, 1}, // input1 dims
- {
- F2Q(-0.8, input_min, input_max),
- F2Q(0.2, input_min, input_max),
- F2Q(0.9, input_min, input_max),
- F2Q(0.7, input_min, input_max),
- }, // input1 data
- {4, 1, 2, 2, 1}, // input2 dims
- {
- F2Q(0.6, input_min, input_max),
- F2Q(0.4, input_min, input_max),
- F2Q(0.9, input_min, input_max),
- F2Q(0.8, input_min, input_max),
- }, // input2 data
- input_min, input_max,
- {4, 1, 2, 2, 1}, // output dims
- output_min, output_max,
- {
- F2Q(-0.48, output_min, output_max),
- F2Q(0.08, output_min, output_max),
- F2Q(0.81, output_min, output_max),
- F2Q(0.56, output_min, output_max),
- }, // expected output data
- output_data, kTfLiteActNone, 1);
-}
-
-TF_LITE_MICRO_TEST(UInt8NoActivationLargeMultiplier) {
- using tflite::testing::F2Q;
- const float input_min = -100;
- const float input_max = 100;
- const float output_min = -10;
- const float output_max = 10;
-
- uint8_t output_data[4];
- tflite::testing::TestMulQuantized(
- {4, 1, 2, 2, 1},
- {
- F2Q(-4, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(3, input_min, input_max),
- F2Q(1, input_min, input_max),
- },
- {4, 1, 2, 2, 1},
- {
- F2Q(-1, input_min, input_max),
- F2Q(-3, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(2, input_min, input_max),
- },
- input_min, input_max, {4, 1, 2, 2, 1}, output_min, output_max,
- {
- F2Q(4, output_min, output_max),
- F2Q(-6, output_min, output_max),
- F2Q(12, output_min, output_max),
- F2Q(2, output_min, output_max),
- },
- // In Tensorflow Lite, this test have a max allowed error of 1.4f.
- // A difference of 1.4 in floating points corresponds to 18 quantized
- // for the output min/max [-10, 10].
- output_data, kTfLiteActNone, 18);
-}
-
-TF_LITE_MICRO_TEST(UInt8NoActivationBroadcast) {
- using tflite::testing::F2Q;
- const float input_min = -3.0;
- const float input_max = 3.0;
- const float output_min = -3.0;
- const float output_max = 3.0;
-
- uint8_t output_data[6];
- tflite::testing::TestMulQuantized({4, 1, 3, 1, 2}, // input1 shape
- {
- F2Q(-2.0, input_min, input_max),
- F2Q(0.2, input_min, input_max),
- F2Q(0.7, input_min, input_max),
- F2Q(0.8, input_min, input_max),
- F2Q(1.1, input_min, input_max),
- F2Q(2.0, input_min, input_max),
- }, // input1 data
- {1, 1}, // input2 shape
- {
- F2Q(0.1, input_min, input_max),
- }, // input2 data
- input_min, input_max,
- {4, 1, 3, 1, 2}, // output shape
- output_min, output_max,
- {
- F2Q(-0.2, output_min, output_max),
- F2Q(0.02, output_min, output_max),
- F2Q(0.07, output_min, output_max),
- F2Q(0.08, output_min, output_max),
- F2Q(0.11, output_min, output_max),
- F2Q(0.2, output_min, output_max),
- }, // expected output data
- output_data, kTfLiteActNone, 1);
-}
-
-TF_LITE_MICRO_TEST(FloatNoActivation) {
- float output_data[4];
tflite::testing::TestMulFloat(
- {4, 1, 2, 2, 1}, // input1 shape
- {-2.0, 0.2, 0.7, 0.8}, // input1 data
- {4, 1, 2, 2, 1}, // input2 shape
- {0.1, 0.2, 0.3, 0.5}, // input2 data
- {4, 1, 2, 2, 1}, // output shape
- {-0.2, 0.04, 0.21, 0.4}, // expected output data
+ tflite::testing::dims_simple, tflite::testing::input1_simple,
+ tflite::testing::dims_simple, tflite::testing::input2_simple,
+ tflite::testing::dims_simple, tflite::testing::golden_simple, output_data,
+ kTfLiteActNone);
+}
+
+TF_LITE_MICRO_TEST(SimpleFloatReluShouldMatchGolden) {
+ float output_data[tflite::testing::flat_size_simple];
+
+ tflite::testing::TestMulFloat(
+ tflite::testing::dims_simple, tflite::testing::input1_simple,
+ tflite::testing::dims_simple, tflite::testing::input2_simple,
+ tflite::testing::dims_simple, tflite::testing::golden_simple_relu,
+ output_data, kTfLiteActRelu);
+}
+
+TF_LITE_MICRO_TEST(SimpleInt8NoAcativationShouldMatchGolden) {
+ int8_t input1_quantized[tflite::testing::flat_size_simple];
+ int8_t input2_quantized[tflite::testing::flat_size_simple];
+ int8_t golden_quantized[tflite::testing::flat_size_simple];
+ int8_t output_data[tflite::testing::flat_size_simple];
+
+ tflite::testing::TestMulQuantized(
+ tflite::testing::dims_simple, tflite::testing::input1_simple,
+ input1_quantized, tflite::testing::dims_simple,
+ tflite::testing::input2_simple, input2_quantized,
+ tflite::testing::scale_simple, 0, tflite::testing::dims_simple,
+ tflite::testing::golden_simple, golden_quantized,
+ tflite::testing::scale_simple, 0, output_data, kTfLiteActNone);
+}
+
+TF_LITE_MICRO_TEST(SimpleUInt8NoAcativationShouldMatchGolden) {
+ uint8_t input1_quantized[tflite::testing::flat_size_simple];
+ uint8_t input2_quantized[tflite::testing::flat_size_simple];
+ uint8_t golden_quantized[tflite::testing::flat_size_simple];
+ uint8_t output_data[tflite::testing::flat_size_simple];
+
+ tflite::testing::TestMulQuantized(
+ tflite::testing::dims_simple, tflite::testing::input1_simple,
+ input1_quantized, tflite::testing::dims_simple,
+ tflite::testing::input2_simple, input2_quantized,
+ tflite::testing::scale_simple, 128, tflite::testing::dims_simple,
+ tflite::testing::golden_simple, golden_quantized,
+ tflite::testing::scale_simple, 128, output_data, kTfLiteActNone);
+}
+
+TF_LITE_MICRO_TEST(BroadcastFloatNoActivationShouldMatchGolden) {
+ float output_data[tflite::testing::flat_size_broadcast];
+
+ tflite::testing::TestMulFloat(
+ tflite::testing::dims_broadcast, tflite::testing::input1_broadcast,
+ tflite::testing::dims_scalar_broadcast, tflite::testing::input2_broadcast,
+ tflite::testing::dims_broadcast, tflite::testing::golden_broadcast,
output_data, kTfLiteActNone);
}
-TF_LITE_MICRO_TEST(FloatRelu) {
- float output_data[4];
+TF_LITE_MICRO_TEST(BroadcastFloatReluShouldMatchGolden) {
+ float output_data[tflite::testing::flat_size_broadcast];
+
tflite::testing::TestMulFloat(
- {4, 1, 2, 2, 1}, // input1 shape
- {-2.0, 0.2, 0.7, 0.8}, // input1 data
- {4, 1, 2, 2, 1}, // input2 shape
- {0.1, 0.2, 0.3, 0.5}, // input2 data
- {4, 1, 2, 2, 1}, // output shape
- {-0.2, 0.04, 0.21, 0.4}, // expected output data
- output_data, kTfLiteActReluN1To1);
+ tflite::testing::dims_broadcast, tflite::testing::input1_broadcast,
+ tflite::testing::dims_scalar_broadcast, tflite::testing::input2_broadcast,
+ tflite::testing::dims_broadcast, tflite::testing::golden_broadcast_relu,
+ output_data, kTfLiteActRelu);
}
-TF_LITE_MICRO_TEST(FloatBroadcast) {
- float output_data[6];
- tflite::testing::TestMulFloat(
- {4, 1, 3, 1, 2}, // input1 shape
- {-2.0, 0.2, 0.7, 0.8, 1.1, 2.0}, // input1 data
- {1, 1}, // input2 shape
- {0.1}, // input2 data
- {4, 1, 3, 1, 2}, // output shape
- {-0.2, 0.02, 0.07, 0.08, 0.11, 0.2}, // expected output data
+TF_LITE_MICRO_TEST(BroadcastInt8NoAcativationShouldMatchGolden) {
+ int8_t input1_quantized[tflite::testing::flat_size_broadcast];
+ int8_t input2_quantized[tflite::testing::flat_size_broadcast];
+ int8_t golden_quantized[tflite::testing::flat_size_broadcast];
+ int8_t output_data[tflite::testing::flat_size_broadcast];
+
+ tflite::testing::TestMulQuantized(
+ tflite::testing::dims_broadcast, tflite::testing::input1_broadcast,
+ input1_quantized, tflite::testing::dims_scalar_broadcast,
+ tflite::testing::input2_broadcast, input2_quantized,
+ tflite::testing::input_scale_broadcast, 0,
+ tflite::testing::dims_broadcast, tflite::testing::golden_broadcast,
+ golden_quantized, tflite::testing::output_scale_broadcast, 0, output_data,
+ kTfLiteActNone);
+}
+
+TF_LITE_MICRO_TEST(BroadcastUInt8NoAcativationShouldMatchGolden) {
+ uint8_t input1_quantized[tflite::testing::flat_size_broadcast];
+ uint8_t input2_quantized[1];
+ uint8_t golden_quantized[tflite::testing::flat_size_broadcast];
+ uint8_t output_data[tflite::testing::flat_size_broadcast];
+
+ tflite::testing::TestMulQuantized(
+ tflite::testing::dims_broadcast, tflite::testing::input1_broadcast,
+ input1_quantized, tflite::testing::dims_scalar_broadcast,
+ tflite::testing::input2_broadcast, input2_quantized,
+ tflite::testing::input_scale_broadcast, 128,
+ tflite::testing::dims_broadcast, tflite::testing::golden_broadcast,
+ golden_quantized, tflite::testing::output_scale_broadcast, 128,
output_data, kTfLiteActNone);
}
diff --git a/tensorflow/lite/micro/kernels/neg_test.cc b/tensorflow/lite/micro/kernels/neg_test.cc
index 2d7c449..544a3ed 100644
--- a/tensorflow/lite/micro/kernels/neg_test.cc
+++ b/tensorflow/lite/micro/kernels/neg_test.cc
@@ -24,13 +24,11 @@
namespace testing {
namespace {
-void TestNegFloat(std::initializer_list<int> input_dims_data,
- std::initializer_list<float> input_data,
- std::initializer_list<float> expected_output_data,
- std::initializer_list<int> output_dims_data,
- float* output_data) {
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestNegFloat(const int* input_dims_data, const float* input_data,
+ const float* expected_output_data,
+ const int* output_dims_data, float* output_data) {
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 1;
constexpr int outputs_size = 1;
@@ -53,9 +51,9 @@
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[0], output_data[0]);
+ TF_LITE_MICRO_EXPECT_EQ(expected_output_data[0], output_data[0]);
for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
+ TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
}
}
@@ -66,23 +64,21 @@
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(NegOpSingleFloat) {
+ const int dims[] = {1, 2};
+ const float input_data[] = {8.5, 0.0};
+ const float golden[] = {-8.5, 0.0};
float output_data[2];
- tflite::testing::TestNegFloat(/*input_dims_data=*/{1, 2},
- /*input_data=*/{8.5f, 0.0f},
- /*expected_output_data=*/{-8.5f, 0.0f},
- /*output_dims_data*/ {1, 2},
- /*output_data=*/output_data);
+
+ tflite::testing::TestNegFloat(dims, input_data, golden, dims, output_data);
}
TF_LITE_MICRO_TEST(NegOpFloat) {
+ const int dims[] = {2, 2, 3};
+ const float input_data[] = {-2.0f, -1.0f, 0.f, 1.0f, 2.0f, 3.0f};
+ const float golden[] = {2.0f, 1.0f, -0.f, -1.0f, -2.0f, -3.0f};
float output_data[6];
- tflite::testing::TestNegFloat(/*input_dims_data=*/{2, 2, 3},
- /*input_data=*/
- {-2.0f, -1.0f, 0.f, 1.0f, 2.0f, 3.0f},
- /*expected_output_data=*/
- {2.0f, 1.0f, -0.f, -1.0f, -2.0f, -3.0f},
- /*output_dims_data=*/{2, 2, 3},
- /*output_data=*/output_data);
+
+ tflite::testing::TestNegFloat(dims, input_data, golden, dims, output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/pack_test.cc b/tensorflow/lite/micro/kernels/pack_test.cc
index 45d5e32..c05595d 100644
--- a/tensorflow/lite/micro/kernels/pack_test.cc
+++ b/tensorflow/lite/micro/kernels/pack_test.cc
@@ -23,16 +23,39 @@
namespace tflite {
namespace testing {
-void TestPackTwoInputsFloat(std::initializer_list<int> input1_dims_data,
- std::initializer_list<float> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<float> input2_data, int axis,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<float> expected_output_data,
+template <typename T>
+void ValidatePackGoldens(TfLiteTensor* tensors, int tensors_size,
+ TfLitePackParams params, TfLiteIntArray* inputs_array,
+ TfLiteIntArray* outputs_array, const T* golden,
+ int output_len, float tolerance, T* output) {
+ // Place a unique value in the uninitialized output buffer.
+ for (int i = 0; i < output_len; ++i) {
+ output[i] = 23;
+ }
+
+ const TfLiteRegistration registration = tflite::ops::micro::Register_PACK();
+ micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
+ outputs_array, reinterpret_cast<void*>(¶ms),
+ micro_test::reporter);
+
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
+
+ for (int i = 0; i < output_len; ++i) {
+ TF_LITE_MICRO_EXPECT_NEAR(golden[i], output[i], tolerance);
+ }
+}
+
+void TestPackTwoInputsFloat(const int* input1_dims_data,
+ const float* input1_data,
+ const int* input2_dims_data,
+ const float* input2_data, int axis,
+ const int* output_dims_data,
+ const float* expected_output_data,
float* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int input_size = 2;
@@ -43,11 +66,6 @@
CreateFloatTensor(input2_data, input2_dims),
CreateFloatTensor(output_data, output_dims)};
- // Place a unique value in the uninitialized output buffer.
- for (int i = 0; i < output_dims_count; ++i) {
- output_data[i] = 23;
- }
-
TfLitePackParams builtin_data = {
.values_count = 2,
.axis = axis,
@@ -57,34 +75,21 @@
int outputs_array_data[] = {1, 2};
TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
- const TfLiteRegistration registration = tflite::ops::micro::Register_PACK();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidatePackGoldens(tensors, tensors_size, builtin_data, inputs_array,
+ outputs_array, expected_output_data, output_dims_count,
+ 1e-5f, output_data);
}
-void TestPackThreeInputsFloat(std::initializer_list<int> input1_dims_data,
- std::initializer_list<float> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<float> input2_data,
- std::initializer_list<int> input3_dims_data,
- std::initializer_list<float> input3_data,
- int axis,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<float> expected_output_data,
- float* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* input3_dims = IntArrayFromInitializer(input3_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestPackThreeInputsFloat(
+ const int* input1_dims_data, const float* input1_data,
+ const int* input2_dims_data, const float* input2_data,
+ const int* input3_dims_data, const float* input3_data, int axis,
+ const int* output_dims_data, const float* expected_output_data,
+ float* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* input3_dims = IntArrayFromInts(input3_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int input_size = 3;
@@ -96,95 +101,67 @@
CreateFloatTensor(input3_data, input3_dims),
CreateFloatTensor(output_data, output_dims)};
- // Place a unique value in the uninitialized output buffer.
- for (int i = 0; i < output_dims_count; ++i) {
- output_data[i] = 23;
- }
-
TfLitePackParams builtin_data = {
.values_count = 3,
.axis = axis,
};
-
int inputs_array_data[] = {3, 0, 1, 2};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
int outputs_array_data[] = {1, 3};
TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
- const TfLiteRegistration registration = tflite::ops::micro::Register_PACK();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidatePackGoldens(tensors, tensors_size, builtin_data, inputs_array,
+ outputs_array, expected_output_data, output_dims_count,
+ 1e-5f, output_data);
}
-void TestPackTwoInputsQuantized(
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<uint8_t> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<uint8_t> input2_data, int axis,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<uint8_t> expected_output_data, uint8_t* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestPackTwoInputsQuantized(const int* input1_dims_data,
+ const uint8_t* input1_data,
+ const int* input2_dims_data,
+ const uint8_t* input2_data, int axis,
+ const int* output_dims_data,
+ const uint8_t* expected_output_data,
+ uint8_t* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int input_size = 2;
constexpr int output_size = 1;
constexpr int tensors_size = input_size + output_size;
TfLiteTensor tensors[tensors_size] = {
- // CreateQuantizedTensor needs min/max values as input, but these values
- // don't matter as to the functionality of PACK, so just set as 0 and 10.
- CreateQuantizedTensor(input1_data, input1_dims, 0, 10),
- CreateQuantizedTensor(input2_data, input2_dims, 0, 10),
- CreateQuantizedTensor(output_data, output_dims, 0, 10)};
-
- // Place a unique value in the uninitialized output buffer.
- for (int i = 0; i < output_dims_count; ++i) {
- output_data[i] = 23;
- }
+ // CreateQuantizedTensor needs scale/zero_point values as input, but these
+ // values don't matter as to the functionality of PACK, so just set as 1.0
+ // and 128.
+ CreateQuantizedTensor(input1_data, input1_dims, 1.0, 128),
+ CreateQuantizedTensor(input2_data, input2_dims, 1.0, 128),
+ CreateQuantizedTensor(output_data, output_dims, 1.0, 128)};
TfLitePackParams builtin_data = {
.values_count = 2,
.axis = axis,
};
-
int inputs_array_data[] = {2, 0, 1};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
int outputs_array_data[] = {1, 2};
TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
- const TfLiteRegistration registration = tflite::ops::micro::Register_PACK();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
- }
+ ValidatePackGoldens(tensors, tensors_size, builtin_data, inputs_array,
+ outputs_array, expected_output_data, output_dims_count,
+ 1e-5f, output_data);
}
-void TestPackTwoInputsQuantized32(
- std::initializer_list<int> input1_dims_data,
- std::initializer_list<int32_t> input1_data,
- std::initializer_list<int> input2_dims_data,
- std::initializer_list<int32_t> input2_data, int axis,
- std::initializer_list<int> output_dims_data,
- std::initializer_list<int32_t> expected_output_data, int32_t* output_data) {
- TfLiteIntArray* input1_dims = IntArrayFromInitializer(input1_dims_data);
- TfLiteIntArray* input2_dims = IntArrayFromInitializer(input2_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestPackTwoInputsQuantized32(const int* input1_dims_data,
+ const int32_t* input1_data,
+ const int* input2_dims_data,
+ const int32_t* input2_data, int axis,
+ const int* output_dims_data,
+ const int32_t* expected_output_data,
+ int32_t* output_data) {
+ TfLiteIntArray* input1_dims = IntArrayFromInts(input1_dims_data);
+ TfLiteIntArray* input2_dims = IntArrayFromInts(input2_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int input_size = 2;
@@ -195,32 +172,18 @@
CreateQuantized32Tensor(input2_data, input2_dims, 1.0),
CreateQuantized32Tensor(output_data, output_dims, 1.0)};
- // Place a unique value in the uninitialized output buffer.
- for (int i = 0; i < output_dims_count; ++i) {
- output_data[i] = 23;
- }
-
TfLitePackParams builtin_data = {
.values_count = 2,
.axis = axis,
};
-
int inputs_array_data[] = {2, 0, 1};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
int outputs_array_data[] = {1, 2};
TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
- const TfLiteRegistration registration = tflite::ops::micro::Register_PACK();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
- }
+ ValidatePackGoldens(tensors, tensors_size, builtin_data, inputs_array,
+ outputs_array, expected_output_data, output_dims_count,
+ 1e-5f, output_data);
}
} // namespace testing
@@ -229,99 +192,96 @@
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(PackFloatThreeInputs) {
+ const int input_shape[] = {1, 2};
+ const int output_shape[] = {2, 3, 2};
+ const float input1_values[] = {1, 4};
+ const float input2_values[] = {2, 5};
+ const float input3_values[] = {3, 6};
+ const float golden[] = {1, 4, 2, 5, 3, 6};
+ const int axis = 0;
constexpr int output_dims_count = 6;
float output_data[output_dims_count];
+
tflite::testing::TestPackThreeInputsFloat(
- {1, 2}, // Input1 shape
- {1, 4}, // Input1 values
- {1, 2}, // Input2 shape
- {2, 5}, // Input2 values
- {1, 2}, // Input3 shape
- {3, 6}, // Input3 values
- 0, {2, 3, 2}, // Output shape
- {
- 1, 4, 2, 5, 3, 6 // Output values
- },
- output_data);
+ input_shape, input1_values, input_shape, input2_values, input_shape,
+ input3_values, axis, output_shape, golden, output_data);
}
TF_LITE_MICRO_TEST(PackFloatThreeInputsDifferentAxis) {
+ const int input_shape[] = {1, 2};
+ const int output_shape[] = {2, 2, 3};
+ const float input1_values[] = {1, 4};
+ const float input2_values[] = {2, 5};
+ const float input3_values[] = {3, 6};
+ const float golden[] = {1, 2, 3, 4, 5, 6};
+ const int axis = 1;
constexpr int output_dims_count = 6;
float output_data[output_dims_count];
+
tflite::testing::TestPackThreeInputsFloat(
- {1, 2}, // Input1 shape
- {1, 4}, // Input1 values
- {1, 2}, // Input2 shape
- {2, 5}, // Input2 values
- {1, 2}, // Input3 shape
- {3, 6}, // Input3 values
- 1, {2, 2, 3}, // Output shape
- {
- 1, 2, 3, 4, 5, 6 // Output values
- },
- output_data);
+ input_shape, input1_values, input_shape, input2_values, input_shape,
+ input3_values, axis, output_shape, golden, output_data);
}
TF_LITE_MICRO_TEST(PackFloatThreeInputsNegativeAxis) {
+ const int input_shape[] = {1, 2};
+ const int output_shape[] = {2, 2, 3};
+ const float input1_values[] = {1, 4};
+ const float input2_values[] = {2, 5};
+ const float input3_values[] = {3, 6};
+ const float golden[] = {1, 2, 3, 4, 5, 6};
+ const int axis = -1;
constexpr int output_dims_count = 6;
float output_data[output_dims_count];
+
tflite::testing::TestPackThreeInputsFloat(
- {1, 2}, // Input1 shape
- {1, 4}, // Input1 values
- {1, 2}, // Input2 shape
- {2, 5}, // Input2 values
- {1, 2}, // Input3 shape
- {3, 6}, // Input3 values
- -1, {2, 2, 3}, // Output shape
- {
- 1, 2, 3, 4, 5, 6 // Output values
- },
- output_data);
+ input_shape, input1_values, input_shape, input2_values, input_shape,
+ input3_values, axis, output_shape, golden, output_data);
}
TF_LITE_MICRO_TEST(PackFloatMultilDimensions) {
+ const int input_shape[] = {2, 2, 3};
+ const int output_shape[] = {3, 2, 2, 3};
+ const float input1_values[] = {1, 2, 3, 4, 5, 6};
+ const float input2_values[] = {7, 8, 9, 10, 11, 12};
+ const float golden[] = {1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12};
+ const int axis = 1;
constexpr int output_dims_count = 12;
float output_data[output_dims_count];
- tflite::testing::TestPackTwoInputsFloat(
- {2, 2, 3}, // Input1 shape
- {1, 2, 3, 4, 5, 6}, // Input1 values
- {2, 2, 3}, // Input2 shape
- {7, 8, 9, 10, 11, 12}, // Input2 values
- 1, {3, 2, 2, 3}, // Output shape
- {
- 1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12 // Output values
- },
- output_data);
+
+ tflite::testing::TestPackTwoInputsFloat(input_shape, input1_values,
+ input_shape, input2_values, axis,
+ output_shape, golden, output_data);
}
TF_LITE_MICRO_TEST(PackQuantizedMultilDimensions) {
+ const int input_shape[] = {2, 2, 3};
+ const int output_shape[] = {3, 2, 2, 3};
+ const uint8_t input1_values[] = {1, 2, 3, 4, 5, 6};
+ const uint8_t input2_values[] = {7, 8, 9, 10, 11, 12};
+ const uint8_t golden[] = {1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12};
+ const int axis = 1;
constexpr int output_dims_count = 12;
uint8_t output_data[output_dims_count];
+
tflite::testing::TestPackTwoInputsQuantized(
- {2, 2, 3}, // Input1 shape
- {1, 2, 3, 4, 5, 6}, // Input1 values
- {2, 2, 3}, // Input2 shape
- {7, 8, 9, 10, 11, 12}, // Input2 values
- 1, {3, 2, 2, 3}, // Output shape
- {
- 1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12 // Output values
- },
- output_data);
+ input_shape, input1_values, input_shape, input2_values, axis,
+ output_shape, golden, output_data);
}
TF_LITE_MICRO_TEST(PackQuantized32MultilDimensions) {
+ const int input_shape[] = {2, 2, 3};
+ const int output_shape[] = {3, 2, 2, 3};
+ const int32_t input1_values[] = {1, 2, 3, 4, 5, 6};
+ const int32_t input2_values[] = {7, 8, 9, 10, 11, 12};
+ const int32_t golden[] = {1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12};
+ const int axis = 1;
constexpr int output_dims_count = 12;
int32_t output_data[output_dims_count];
+
tflite::testing::TestPackTwoInputsQuantized32(
- {2, 2, 3}, // Input1 shape
- {1, 2, 3, 4, 5, 6}, // Input1 values
- {2, 2, 3}, // Input2 shape
- {7, 8, 9, 10, 11, 12}, // Input2 values
- 1, {3, 2, 2, 3}, // Output shape
- {
- 1, 2, 3, 7, 8, 9, 4, 5, 6, 10, 11, 12 // Output values
- },
- output_data);
+ input_shape, input1_values, input_shape, input2_values, axis,
+ output_shape, golden, output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/pooling_test.cc b/tensorflow/lite/micro/kernels/pooling_test.cc
index ec5eb47..a33f5df 100644
--- a/tensorflow/lite/micro/kernels/pooling_test.cc
+++ b/tensorflow/lite/micro/kernels/pooling_test.cc
@@ -25,27 +25,14 @@
namespace testing {
namespace {
-void TestAveragePoolingFloat(std::initializer_list<int> input_dims_data,
- std::initializer_list<float> input_data,
- const int filter_height, const int filter_width,
- const int stride_height, const int stride_width,
- std::initializer_list<float> expected_output_data,
- std::initializer_list<int> output_dims_data,
- TfLitePadding padding,
- TfLiteFusedActivation activation,
- float* output_data) {
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
- const int output_dims_count = ElementCount(*output_dims);
-
- constexpr int inputs_size = 1;
- constexpr int outputs_size = 1;
- constexpr int tensors_size = inputs_size + outputs_size;
- TfLiteTensor tensors[tensors_size] = {
- CreateFloatTensor(input_data, input_dims),
- CreateFloatTensor(output_data, output_dims),
- };
-
+template <typename T>
+void ValidatePoolingGoldens(TfLiteTensor* tensors, int tensors_size,
+ const TfLiteRegistration registration,
+ const int filter_height, const int filter_width,
+ const int stride_height, const int stride_width,
+ const T* golden, const int output_length,
+ TfLitePadding padding,
+ TfLiteFusedActivation activation, T* output_data) {
int inputs_array_data[] = {1, 0};
TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
int outputs_array_data[] = {1, 1};
@@ -59,8 +46,6 @@
activation,
{}};
- const TfLiteRegistration registration =
- tflite::ops::micro::Register_AVERAGE_POOL_2D();
micro::KernelRunner runner(
registration, tensors, tensors_size, inputs_array, outputs_array,
reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
@@ -68,73 +53,78 @@
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
+ for (int i = 0; i < output_length; ++i) {
+ TF_LITE_MICRO_EXPECT_NEAR(golden[i], output_data[i], 1e-5f);
}
}
+void TestAveragePoolFloat(const int* input_dims_data, const float* input_data,
+ const int filter_height, const int filter_width,
+ const int stride_height, const int stride_width,
+ const float* expected_output_data,
+ const int* output_dims_data, TfLitePadding padding,
+ TfLiteFusedActivation activation,
+ float* output_data) {
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
+ const int output_dims_count = ElementCount(*output_dims);
+
+ constexpr int inputs_size = 1;
+ constexpr int outputs_size = 1;
+ constexpr int tensors_size = inputs_size + outputs_size;
+ TfLiteTensor tensors[tensors_size] = {
+ CreateFloatTensor(input_data, input_dims),
+ CreateFloatTensor(output_data, output_dims),
+ };
+
+ const TfLiteRegistration registration =
+ tflite::ops::micro::Register_AVERAGE_POOL_2D();
+
+ ValidatePoolingGoldens(tensors, tensors_size, registration, filter_height,
+ filter_width, stride_height, stride_width,
+ expected_output_data, output_dims_count, padding,
+ activation, output_data);
+}
+
template <typename T>
-void TestAveragePoolingQuantized(
- std::initializer_list<int> input_dims_data,
- std::initializer_list<T> input_data, const float input_min,
- const float input_max, const int filter_height, const int filter_width,
+void TestAveragePoolQuantized(
+ const int* input_dims_data, const T* input_data, const float input_scale,
+ const int input_zero_point, const int filter_height, const int filter_width,
const int stride_height, const int stride_width,
- std::initializer_list<T> expected_output_data,
- std::initializer_list<int> output_dims_data, float output_min,
- float output_max, TfLitePadding padding, TfLiteFusedActivation activation,
- T* output_data) {
+ const T* expected_output_data, const int* output_dims_data,
+ const float output_scale, const int output_zero_point,
+ TfLitePadding padding, TfLiteFusedActivation activation, T* output_data) {
static_assert(sizeof(T) == 1, "Only int8_t/uint8_t data types allowed.");
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 1;
constexpr int outputs_size = 1;
constexpr int tensors_size = inputs_size + outputs_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input_data, input_dims, input_min, input_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max),
+ CreateQuantizedTensor(input_data, input_dims, input_scale,
+ input_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point),
};
- 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);
-
- TfLitePoolParams builtin_data = {padding,
- stride_width,
- stride_height,
- filter_width,
- filter_height,
- activation,
- {}};
-
const TfLiteRegistration registration =
tflite::ops::micro::Register_AVERAGE_POOL_2D();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidatePoolingGoldens(tensors, tensors_size, registration, filter_height,
+ filter_width, stride_height, stride_width,
+ expected_output_data, output_dims_count, padding,
+ activation, output_data);
}
-void TestMaxPoolFloat(std::initializer_list<int> input_dims_data,
- std::initializer_list<float> input_data, int filter_width,
- int filter_height, int stride_width, int stride_height,
- std::initializer_list<float> expected_output_data,
- std::initializer_list<int> output_dims_data,
- TfLitePadding padding, TfLiteFusedActivation activation,
- float* output_data) {
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestMaxPoolFloat(const int* input_dims_data, const float* input_data,
+ int filter_width, int filter_height, int stride_width,
+ int stride_height, const float* expected_output_data,
+ const int* output_dims_data, TfLitePadding padding,
+ TfLiteFusedActivation activation, float* output_data) {
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 1;
@@ -145,83 +135,43 @@
CreateFloatTensor(output_data, output_dims),
};
- 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);
-
- TfLitePoolParams builtin_data = {padding,
- stride_width,
- stride_height,
- filter_width,
- filter_height,
- activation,
- {}};
-
const TfLiteRegistration registration =
tflite::ops::micro::Register_MAX_POOL_2D();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidatePoolingGoldens(tensors, tensors_size, registration, filter_height,
+ filter_width, stride_height, stride_width,
+ expected_output_data, output_dims_count, padding,
+ activation, output_data);
}
template <typename T>
-void TestMaxPoolQuantized(std::initializer_list<int> input_dims_data,
- std::initializer_list<T> input_data, float input_min,
- float input_max, int filter_width, int filter_height,
- int stride_width, int stride_height,
- std::initializer_list<T> expected_output_data,
- float output_min, float output_max,
- std::initializer_list<int> output_dims_data,
- TfLitePadding padding,
+void TestMaxPoolQuantized(const int* input_dims_data, const T* input_data,
+ const float input_scale, const int input_zero_point,
+ const int filter_height, const int filter_width,
+ const int stride_height, const int stride_width,
+ const T* expected_output_data,
+ const int* output_dims_data, const float output_scale,
+ const int output_zero_point, TfLitePadding padding,
TfLiteFusedActivation activation, T* output_data) {
- static_assert(sizeof(T) == 1, "Only int8_t/uint8_t data types allowed.");
-
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 1;
constexpr int outputs_size = 1;
constexpr int tensors_size = inputs_size + outputs_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input_data, input_dims, input_min, input_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max),
+ CreateQuantizedTensor(input_data, input_dims, input_scale,
+ input_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point),
};
- 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);
-
- TfLitePoolParams builtin_data = {padding,
- stride_width,
- stride_height,
- filter_width,
- filter_height,
- activation,
- {}};
-
const TfLiteRegistration registration =
tflite::ops::micro::Register_MAX_POOL_2D();
- micro::KernelRunner runner(
- registration, tensors, tensors_size, inputs_array, outputs_array,
- reinterpret_cast<void*>(&builtin_data), micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
- }
+ ValidatePoolingGoldens(tensors, tensors_size, registration, filter_height,
+ filter_width, stride_height, stride_width,
+ expected_output_data, output_dims_count, padding,
+ activation, output_data);
}
} // namespace
@@ -232,798 +182,535 @@
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(SimpleAveragePoolTestFloat) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const float golden[] = {2.75, 5.75};
+ const int output_shape[] = {4, 1, 1, 2, 1};
float output_data[2];
- tflite::testing::TestAveragePoolingFloat({4, 1, 2, 4, 1}, // Input shape
- { // Input values
- 0., 6., 2., 4., 3., 2., 10., 7.},
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- 2.75,
- 5.75,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone,
- output_data);
+ tflite::testing::TestAveragePoolFloat(
+ input_shape, input_values, filter_height, filter_width, stride_height,
+ stride_width, golden, output_shape, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleAveragePoolTestUint8) {
- using tflite::testing::F2Q;
-
- const float input_min = -15.9375;
- const float input_max = 15.9375;
- const float output_min = -15.9375;
- const float output_max = 15.9375;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values[] = {0, 24, 8, 16, 12, 8, 40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const uint8_t golden[] = {11, 23};
+ const int output_shape[] = {4, 1, 1, 2, 1};
uint8_t output_data[2];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0., input_min, input_max),
- F2Q(-6., input_min, input_max),
- F2Q(2., input_min, input_max),
- F2Q(4., input_min, input_max),
- F2Q(3., input_min, input_max),
- F2Q(2., input_min, input_max),
- F2Q(-10., input_min, input_max),
- F2Q(7., input_min, input_max),
- },
- input_min, input_max, // input quantization range
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- F2Q(0., output_min, output_max),
- F2Q(0.75, output_min, output_max),
- },
- {4, 1, 1, 2, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingValid, kTfLiteActRelu, output_data);
+
+ const float input_scale = 0.25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleAveragePoolTestInt8PaddingValidStride2ActNone) {
- using tflite::testing::F2QS;
-
- const float input_min = -15.9375;
- const float input_max = 15.8130;
- const float output_min = -15.9375;
- const float output_max = 15.8130;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values[] = {0, -24, 8, 16, 12, 8, -40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden[] = {-1, 3};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- { // Input values
- F2QS(0., input_min, input_max), F2QS(-6., input_min, input_max),
- F2QS(2., input_min, input_max), F2QS(4., input_min, input_max),
- F2QS(3., input_min, input_max), F2QS(2., input_min, input_max),
- F2QS(-10., input_min, input_max), F2QS(7., input_min, input_max)},
- input_min, input_max, // input quantization range
- 2, 2, // filter height, filter width
- 2, 2, // stride height, stride width
- { // Output values
- F2QS(-0.25, output_min, output_max), F2QS(0.75, output_min, output_max)},
- {4, 1, 1, 2, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingValid, kTfLiteActNone, output_data);
+
+ const float input_scale = .25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleAveragePoolTestInt8PaddingValidStride1Stride2Relu) {
- using tflite::testing::F2QS;
-
- const float input_min = -15.9375;
- const float input_max = 15.8130;
- const float output_min = -15.9375;
- const float output_max = 15.8130;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values[] = {0, -24, 8, 16, 12, 8, -40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 2;
+ const int8_t golden[] = {0, 0, 3};
+ const int output_shape[] = {4, 1, 1, 3, 1};
int8_t output_data[3];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- { // Input values
- F2QS(0., input_min, input_max), F2QS(-6., input_min, input_max),
- F2QS(2., input_min, input_max), F2QS(4., input_min, input_max),
- F2QS(3., input_min, input_max), F2QS(2., input_min, input_max),
- F2QS(-10., input_min, input_max), F2QS(7., input_min, input_max)},
- input_min, input_max, // input quantization range
- 2, 2, // filter height, filter width
- 2, 1, // stride height, stride width
- { // Output values
- F2QS(0., output_min, output_max), F2QS(0., output_min, output_max),
- F2QS(0.75, output_min, output_max)},
- {4, 1, 1, 3, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingValid, kTfLiteActRelu, output_data);
+
+ const float input_scale = .25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu,
+ output_data);
}
TF_LITE_MICRO_TEST(
SimpleAveragePoolTestInt8PaddingValidStride2Stride1ReluN1To1) {
- using tflite::testing::F2QS;
-
- const float input_min = -15.9375;
- const float input_max = 15.8130;
- const float output_min = -15.9375;
- const float output_max = 15.8130;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values[] = {0, -24, 8, 16, 12, 8, -40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 1;
+ const int8_t golden[] = {-1, 3};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- { // Input values
- F2QS(0., input_min, input_max), F2QS(-6., input_min, input_max),
- F2QS(2., input_min, input_max), F2QS(4., input_min, input_max),
- F2QS(3., input_min, input_max), F2QS(2., input_min, input_max),
- F2QS(-10., input_min, input_max), F2QS(7., input_min, input_max)},
- input_min, input_max, // input quantization range
- 2, 2, // filter height, filter width
- 1, 2, // stride height, stride width
- { // Output values
- F2QS(-0.25, output_min, output_max), F2QS(0.75, output_min, output_max)},
- {4, 1, 1, 2, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingValid, kTfLiteActReluN1To1, output_data);
+
+ const float input_scale = .25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActReluN1To1,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleAveragePoolTestInt8PaddingValidStride2Relu6) {
- using tflite::testing::F2QS;
-
- const float input_min = -15.9375;
- const float input_max = 15.8130;
- const float output_min = -15.9375;
- const float output_max = 15.8130;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values[] = {12, -24, 32, 16, 12, 8, 40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden[] = {2, 24};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- { // Input values
- F2QS(3., input_min, input_max), F2QS(-6., input_min, input_max),
- F2QS(8., input_min, input_max), F2QS(4., input_min, input_max),
- F2QS(3., input_min, input_max), F2QS(2., input_min, input_max),
- F2QS(10., input_min, input_max), F2QS(7., input_min, input_max)},
- input_min, input_max, // input quantization range
- 2, 2, // filter height, filter width
- 2, 2, // stride height, stride width
- { // Output values
- F2QS(0.5, output_min, output_max), F2QS(6., output_min, output_max)},
- {4, 1, 1, 2, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingValid, kTfLiteActRelu6, output_data);
+
+ const float input_scale = .25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu6,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleAveragePoolTestInt8PaddingSameStride1ActNone) {
- using tflite::testing::F2QS;
-
- const float input_min = -15.9375;
- const float input_max = 15.8130;
- const float output_min = -15.9375;
- const float output_max = 15.8130;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values[] = {12, -24, 32, 16, 12, 8, 40, 28};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const int8_t golden[] = {2, 14, 29, 22, 10, 24, 34, 28};
+ const int output_shape[] = {4, 1, 2, 4, 1};
int8_t output_data[8];
- tflite::testing::TestAveragePoolingQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- { // Input values
- F2QS(3., input_min, input_max), F2QS(-6., input_min, input_max),
- F2QS(8., input_min, input_max), F2QS(4., input_min, input_max),
- F2QS(3., input_min, input_max), F2QS(2., input_min, input_max),
- F2QS(10., input_min, input_max), F2QS(7., input_min, input_max)},
- input_min, input_max, // input quantization range
- 2, 2, // filter height, filter width
- 1, 1, // stride height, stride width
- { // Output values
- F2QS(0.5, output_min, output_max), F2QS(3.5, output_min, output_max),
- F2QS(7.25, output_min, output_max), F2QS(5.5, output_min, output_max),
- F2QS(2.5, output_min, output_max), F2QS(6., output_min, output_max),
- F2QS(8.5, output_min, output_max), F2QS(7., output_min, output_max)},
- {4, 1, 2, 4, 1}, // Output shape
- output_min, output_max, // output quantization range
- kTfLitePaddingSame, kTfLiteActNone, output_data);
+
+ const float input_scale = .25;
+ const int input_zero_point = 0;
+ const float output_scale = .25;
+ const int output_zero_point = 0;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestFloat) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const float golden[] = {6, 10};
+ const int output_shape[] = {4, 1, 1, 2, 1};
float output_data[2];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- { // Input values
- 0, 6, 2, 4, 3, 2, 10, 7},
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- 6,
- 10,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone,
- output_data);
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values, filter_height,
+ filter_width, stride_height, stride_width,
+ golden, output_shape, kTfLitePaddingValid,
+ kTfLiteActNone, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestFloatRelu) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values[] = {-1, -6, 2, 4, -3, -2, 10.5, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const float golden[] = {0, 10.5};
+ const int output_shape[] = {4, 1, 1, 2, 1};
float output_data[2];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- -1, -6, 2, 4, //
- -3, -2, 10.5, 7, //
- },
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- 0.0,
- 10.5,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu,
- output_data);
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values, filter_height,
+ filter_width, stride_height, stride_width,
+ golden, output_shape, kTfLitePaddingValid,
+ kTfLiteActRelu, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestFloatReluN1To1) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values1[] = {-2.75, -6, 0.2, 0.4, -3, -2, -0.3, 0.7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const float golden1[] = {-1.0, 0.7};
+ const int output_shape[] = {4, 1, 1, 2, 1};
float output_data[2];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- -2.75, -6, 0.2, 0.4, //
- -3, -2, -0.3, 0.7, //
- },
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- -1.0,
- 0.7,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActReluN1To1,
- output_data);
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values1, filter_height,
+ filter_width, stride_height, stride_width,
+ golden1, output_shape, kTfLitePaddingValid,
+ kTfLiteActReluN1To1, output_data);
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- -2.75, -6, -2, -4, //
- -3, -2, 10, -7, //
- },
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- -1.0,
- 1.0,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActReluN1To1,
- output_data);
+ const float input_values2[] = {-2.75, -6, -2, -4, -3, -2, 10, -7};
+ const float golden2[] = {-1.0, 1.0};
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values2, filter_height,
+ filter_width, stride_height, stride_width,
+ golden2, output_shape, kTfLitePaddingValid,
+ kTfLiteActReluN1To1, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestFloatRelu6) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values1[] = {-1.5, -6, 12, 4, -3, -2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const float golden1[] = {0, 6};
+ const int output_shape[] = {4, 1, 1, 2, 1};
float output_data[2];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- -1.5, -6, 12, 4, //
- -3, -2, 10, 7, //
- },
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- 0.0,
- 6.0,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6,
- output_data);
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values1, filter_height,
+ filter_width, stride_height, stride_width,
+ golden1, output_shape, kTfLitePaddingValid,
+ kTfLiteActRelu6, output_data);
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- 0, 4.5, 12, 4, //
- 3, 2, 10, 7, //
- },
- 2, 2, // filter width, filter height
- 2, 2, // stride width, stride height
- {
- // Output values
- 4.5,
- 6.0,
- },
- {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6,
- output_data);
+ const float input_values2[] = {0, 4.5, 12, 4, 3, 2, 10, 7};
+ const float golden2[] = {4.5, 6};
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values2, filter_height,
+ filter_width, stride_height, stride_width,
+ golden2, output_shape, kTfLitePaddingValid,
+ kTfLiteActRelu6, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestPaddingSameStride1) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const float golden[] = {6, 10, 10, 7, 3, 10, 10, 7};
+ const int output_shape[] = {4, 1, 2, 4, 1};
float output_data[8];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- 0, 6, 2, 4, //
- 3, 2, 10, 7, //
- },
- 2, 2, // filter width, filter height
- 1, 1, // stride width, stride height
- {
- // Output values
- 6, 10, 10, 7, //
- 3, 10, 10, 7, //
- },
- {4, 1, 2, 4, 1}, // Output shape
- kTfLitePaddingSame, kTfLiteActNone,
- output_data);
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values, filter_height,
+ filter_width, stride_height, stride_width,
+ golden, output_shape, kTfLitePaddingSame,
+ kTfLiteActNone, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestPaddingValidStride1) {
- float output_data[3];
- tflite::testing::TestMaxPoolFloat({4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- 0, 6, 2, 4, //
- 3, 2, 10, 7, //
- },
- 2, 2, // filter width, filter height
- 1, 1, // stride width, stride height
- {
- // Output values
- 6,
- 10,
- 10,
- },
- {4, 1, 1, 3, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone,
- output_data);
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const float input_values[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const float golden[] = {6, 10, 10};
+ const int output_shape[] = {4, 1, 1, 3, 1};
+ float output_data[8];
+ tflite::testing::TestMaxPoolFloat(input_shape, input_values, filter_height,
+ filter_width, stride_height, stride_width,
+ golden, output_shape, kTfLitePaddingValid,
+ kTfLiteActNone, output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestUInt8ActNone) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values[] = {0, 12, 4, 8, 6, 4, 20, 14};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const uint8_t golden[] = {12, 20};
+ const int output_shape[] = {4, 1, 1, 2, 1};
uint8_t output_data[2];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0, input_min, input_max),
- F2Q(6, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(3, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2Q(6, output_min, output_max), F2Q(10, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone, output_data);
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActRelu) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values[] = {0, 4, 2, 4, 3, 2, 14, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const uint8_t golden[] = {4, 14};
+ const int output_shape[] = {4, 1, 1, 2, 1};
uint8_t output_data[2];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 4;
+ const float output_scale = 1.0;
+ const int output_zero_point = 4;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(-1.5, input_min, input_max),
- F2Q(-6, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(-3, input_min, input_max),
- F2Q(-2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2Q(0, output_min, output_max), F2Q(10, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu, output_data);
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActReluN1To1) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values[] = {0, 4, 2, 4, 3, 2, 14, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const uint8_t golden[] = {3, 5};
+ const int output_shape[] = {4, 1, 1, 2, 1};
uint8_t output_data[2];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
- tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(-1.7, input_min, input_max),
- F2Q(-6, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(-3, input_min, input_max),
- F2Q(-2, input_min, input_max),
- F2Q(-10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2Q(-1.0, output_min, output_max), F2Q(1.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActReluN1To1, output_data);
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 4;
+ const float output_scale = 1.0;
+ const int output_zero_point = 4;
+ tflite::testing::TestAveragePoolQuantized(
+ input_shape, input_values, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActReluN1To1,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActRelu6) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values1[] = {12, 0, 36, 20, 6, 8, 32, 26};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const uint8_t golden1[] = {12, 24};
+ const int output_shape[] = {4, 1, 1, 2, 1};
uint8_t output_data[8];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
- tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0, input_min, input_max),
- F2Q(-6, input_min, input_max),
- F2Q(12, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(-3, input_min, input_max),
- F2Q(-2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2Q(0.0, output_min, output_max), F2Q(6.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6, output_data);
+ const float input_scale = 0.5;
+ const int input_zero_point = 12;
+ const float output_scale = 0.5;
+ const int output_zero_point = 12;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0, input_min, input_max),
- F2Q(4.5, input_min, input_max),
- F2Q(12, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(3, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2Q(4.5, output_min, output_max), F2Q(6.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu6,
+ output_data);
+
+ const uint8_t input_values2[] = {12, 21, 36, 16, 18, 16, 32, 26};
+
+ const uint8_t golden2[] = {21, 24};
+ tflite::testing::TestMaxPoolQuantized(
+ input_shape, input_values2, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden2, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu6,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8PaddingSameStride1) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values1[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const uint8_t golden1[] = {6, 10, 10, 7, 3, 10, 10, 7};
+ const int output_shape[] = {4, 1, 2, 4, 1};
uint8_t output_data[8];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 1;
- int stride_height = 1;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0, input_min, input_max),
- F2Q(6, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(3, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {
- // Output values
- F2Q(6, output_min, output_max),
- F2Q(10, output_min, output_max),
- F2Q(10, output_min, output_max),
- F2Q(7, output_min, output_max),
- F2Q(3, output_min, output_max),
- F2Q(10, output_min, output_max),
- F2Q(10, output_min, output_max),
- F2Q(7, output_min, output_max),
- },
- output_min, output_max, {4, 1, 2, 4, 1}, // Output shape
- kTfLitePaddingSame, kTfLiteActNone, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8PaddingValidStride1) {
- using tflite::testing::F2Q;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values1[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const uint8_t golden1[] = {6, 10, 10};
+ const int output_shape[] = {4, 1, 1, 3, 1};
uint8_t output_data[3];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 1;
- int stride_height = 1;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2Q(0, input_min, input_max),
- F2Q(6, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(4, input_min, input_max),
- F2Q(3, input_min, input_max),
- F2Q(2, input_min, input_max),
- F2Q(10, input_min, input_max),
- F2Q(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {
- // Output values
- F2Q(6, output_min, output_max),
- F2Q(10, output_min, output_max),
- F2Q(10, output_min, output_max),
- },
- output_min, output_max, {4, 1, 1, 3, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(SimpleMaxPoolTestInt8ActNone) {
- using tflite::testing::F2QS;
-
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values1[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden1[] = {6, 10};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(0, input_min, input_max),
- F2QS(6, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(3, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2QS(6, output_min, output_max), F2QS(10, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
-TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActRelu) {
- using tflite::testing::F2QS;
-
+TF_LITE_MICRO_TEST(MaxPoolTestInt8ActRelu) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values1[] = {-3, -12, 4, 8, -6, -4, 20, 14};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden1[] = {0, 20};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+
+ const float input_scale = 0.5;
+ const int input_zero_point = 0;
+ const float output_scale = 0.5;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(-1.5, input_min, input_max),
- F2QS(-6, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(-3, input_min, input_max),
- F2QS(-2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2QS(0, output_min, output_max), F2QS(10, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu,
+ output_data);
}
-TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActReluN1To1) {
- using tflite::testing::F2QS;
-
+TF_LITE_MICRO_TEST(MaxPoolTestInt8ActReluN1To1) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values1[] = {-2, -6, -2, -4, -3, -2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden1[] = {-1, 1};
+ const int output_shape[] = {4, 1, 1, 2, 1};
int8_t output_data[2];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(-1.7, input_min, input_max),
- F2QS(-6, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(-3, input_min, input_max),
- F2QS(-2, input_min, input_max),
- F2QS(-10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2QS(-1.0, output_min, output_max), F2QS(1.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActReluN1To1, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActReluN1To1,
+ output_data);
}
-TF_LITE_MICRO_TEST(MaxPoolTestUInt8ActRelu6) {
- using tflite::testing::F2QS;
+TF_LITE_MICRO_TEST(MaxPoolTestInt8ActRelu6) {
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const int8_t input_values1[] = {0, -6, 12, 4, -3, -2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 2;
+ const int stride_height = 2;
+ const int8_t golden1[] = {0, 6};
+ const int output_shape[] = {4, 1, 1, 2, 1};
+ int8_t output_data[2];
- int8_t output_data[8];
- float input_min = -15.9375;
- float input_max = 15.9375;
- float output_min = -15.9375;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 2;
- int stride_height = 2;
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(0, input_min, input_max),
- F2QS(-6, input_min, input_max),
- F2QS(12, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(-3, input_min, input_max),
- F2QS(-2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2QS(0.0, output_min, output_max), F2QS(6.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6, output_data);
-
- tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(0, input_min, input_max),
- F2QS(4.5, input_min, input_max),
- F2QS(12, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(3, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {// Output values
- F2QS(4.5, output_min, output_max), F2QS(6.0, output_min, output_max)},
- output_min, output_max, {4, 1, 1, 2, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActRelu6, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActRelu6,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8PaddingSameStride1) {
- using tflite::testing::F2QS;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values1[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const uint8_t golden1[] = {6, 10, 10, 7, 3, 10, 10, 7};
+ const int output_shape[] = {4, 1, 2, 4, 1};
+ uint8_t output_data[8];
- int8_t output_data[8];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 1;
- int stride_height = 1;
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(0, input_min, input_max),
- F2QS(6, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(3, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {
- // Output values
- F2QS(6, output_min, output_max),
- F2QS(10, output_min, output_max),
- F2QS(10, output_min, output_max),
- F2QS(7, output_min, output_max),
- F2QS(3, output_min, output_max),
- F2QS(10, output_min, output_max),
- F2QS(10, output_min, output_max),
- F2QS(7, output_min, output_max),
- },
- output_min, output_max, {4, 1, 2, 4, 1}, // Output shape
- kTfLitePaddingSame, kTfLiteActNone, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingSame, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TEST(MaxPoolTestUInt8PaddingValidStride1) {
- using tflite::testing::F2QS;
+ const int input_shape[] = {4, 1, 2, 4, 1};
+ const uint8_t input_values1[] = {0, 6, 2, 4, 3, 2, 10, 7};
+ const int filter_width = 2;
+ const int filter_height = 2;
+ const int stride_width = 1;
+ const int stride_height = 1;
+ const uint8_t golden1[] = {6, 10, 10};
+ const int output_shape[] = {4, 1, 1, 3, 1};
+ uint8_t output_data[3];
- int8_t output_data[3];
- float input_min = 0;
- float input_max = 15.9375;
- float output_min = 0;
- float output_max = 15.9375;
- int filter_width = 2;
- int filter_height = 2;
- int stride_width = 1;
- int stride_height = 1;
+ const float input_scale = 1.0;
+ const int input_zero_point = 0;
+ const float output_scale = 1.0;
+ const int output_zero_point = 0;
tflite::testing::TestMaxPoolQuantized(
- {4, 1, 2, 4, 1}, // Input shape
- {
- // Input values
- F2QS(0, input_min, input_max),
- F2QS(6, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(4, input_min, input_max),
- F2QS(3, input_min, input_max),
- F2QS(2, input_min, input_max),
- F2QS(10, input_min, input_max),
- F2QS(7, input_min, input_max),
- },
- input_min, input_max, filter_width, filter_height, stride_width,
- stride_height,
- {
- // Output values
- F2QS(6, output_min, output_max),
- F2QS(10, output_min, output_max),
- F2QS(10, output_min, output_max),
- },
- output_min, output_max, {4, 1, 1, 3, 1}, // Output shape
- kTfLitePaddingValid, kTfLiteActNone, output_data);
+ input_shape, input_values1, input_scale, input_zero_point, filter_height,
+ filter_width, stride_height, stride_width, golden1, output_shape,
+ output_scale, output_zero_point, kTfLitePaddingValid, kTfLiteActNone,
+ output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/prelu_test.cc b/tensorflow/lite/micro/kernels/prelu_test.cc
index 4e35276..f559ddf 100644
--- a/tensorflow/lite/micro/kernels/prelu_test.cc
+++ b/tensorflow/lite/micro/kernels/prelu_test.cc
@@ -23,16 +23,35 @@
namespace testing {
namespace {
-void TestPreluFloat(std::initializer_list<int> input_dims_data,
- std::initializer_list<float> input_data,
- std::initializer_list<int> alpha_dims_data,
- std::initializer_list<float> alpha_data,
- std::initializer_list<float> expected_output_data,
- std::initializer_list<int> output_dims_data,
- float* output_data) {
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* alpha_dims = IntArrayFromInitializer(alpha_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+template <typename T>
+void ValidatePreluGoldens(TfLiteTensor* tensors, int tensors_size,
+ const T* golden, const int output_length,
+ T* output_data) {
+ int inputs_array_data[] = {2, 0, 1};
+ TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
+ int outputs_array_data[] = {1, 2};
+ TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
+
+ const TfLiteRegistration registration = tflite::ops::micro::Register_PRELU();
+ micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
+ outputs_array,
+ /*builtin_data=*/nullptr, micro_test::reporter);
+
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
+ TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
+
+ for (int i = 0; i < output_length; ++i) {
+ TF_LITE_MICRO_EXPECT_NEAR(golden[i], output_data[i], 1e-5f);
+ }
+}
+
+void TestPreluFloat(const int* input_dims_data, const float* input_data,
+ const int* alpha_dims_data, const float* alpha_data,
+ const float* expected_output_data,
+ const int* output_dims_data, float* output_data) {
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* alpha_dims = IntArrayFromInts(alpha_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
constexpr int outputs_size = 1;
@@ -43,66 +62,42 @@
CreateFloatTensor(output_data, output_dims),
};
- int inputs_array_data[] = {2, 0, 1};
- TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
- int outputs_array_data[] = {1, 2};
- TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
-
- const TfLiteRegistration registration = tflite::ops::micro::Register_PRELU();
- micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
- outputs_array,
- /*builtin_data=*/nullptr, micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_NEAR(expected_output_data.begin()[i], output_data[i],
- 1e-5f);
- }
+ ValidatePreluGoldens(tensors, tensors_size, expected_output_data,
+ output_dims_count, output_data);
}
// Template argument T can be either uint8_t or int8_t depending on which type
// of quantization required to be tested.
template <typename T>
-void TestPreluQuantized(std::initializer_list<int> input_dims_data,
- std::initializer_list<T> input_data, float input_min,
- float input_max,
- std::initializer_list<int> alpha_dims_data,
- std::initializer_list<T> alpha_data, float alpha_min,
- float alpha_max,
- std::initializer_list<T> expected_output_data,
- std::initializer_list<int> output_dims_data,
- float output_min, float output_max, T* output_data) {
- TfLiteIntArray* input_dims = IntArrayFromInitializer(input_dims_data);
- TfLiteIntArray* alpha_dims = IntArrayFromInitializer(alpha_dims_data);
- TfLiteIntArray* output_dims = IntArrayFromInitializer(output_dims_data);
+void TestPreluQuantized(const int* input_dims_data, const float* input_data,
+ T* input_quantized, const float input_scale,
+ const int input_zero_point, const int* alpha_dims_data,
+ const float* alpha_data, T* alpha_quantized,
+ const float alpha_scale, const int alpha_zero_point,
+ const float* golden, T* golden_quantized,
+ const float output_scale, const int output_zero_point,
+ const int* output_dims_data, T* output_data) {
+ TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
+ TfLiteIntArray* alpha_dims = IntArrayFromInts(alpha_dims_data);
+ TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
const int output_dims_count = ElementCount(*output_dims);
constexpr int inputs_size = 2;
constexpr int outputs_size = 1;
constexpr int tensors_size = inputs_size + outputs_size;
TfLiteTensor tensors[tensors_size] = {
- CreateQuantizedTensor(input_data, input_dims, input_min, input_max),
- CreateQuantizedTensor(alpha_data, alpha_dims, alpha_min, alpha_max),
- CreateQuantizedTensor(output_data, output_dims, output_min, output_max),
+ CreateQuantizedTensor(input_data, input_quantized, input_dims,
+ input_scale, input_zero_point),
+ CreateQuantizedTensor(alpha_data, alpha_quantized, alpha_dims,
+ alpha_scale, alpha_zero_point),
+ CreateQuantizedTensor(output_data, output_dims, output_scale,
+ output_zero_point),
};
- int inputs_array_data[] = {2, 0, 1};
- TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
- int outputs_array_data[] = {1, 2};
- TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
+ AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+ output_zero_point);
- const TfLiteRegistration registration = tflite::ops::micro::Register_PRELU();
- micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
- outputs_array,
- /*builtin_data=*/nullptr, micro_test::reporter);
-
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
- TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
-
- for (int i = 0; i < output_dims_count; ++i) {
- TF_LITE_MICRO_EXPECT_EQ(expected_output_data.begin()[i], output_data[i]);
- }
+ ValidatePreluGoldens(tensors, tensors_size, golden_quantized,
+ output_dims_count, output_data);
}
} // namespace
} // namespace testing
@@ -111,74 +106,89 @@
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(FloatPreluActivationsOpTest) {
+ const int input_shape[] = {3, 2, 2, 3};
+ const float input_values[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 1.0f, 1.0f, 1.0f, // Row 1, Column 2
+ -1.0f, -1.0f, -1.0f, // Row 2, Column 1
+ -2.0f, -2.0f, -2.0f, // Row 1, Column 2
+ };
+ const int alpha_shape[] = {3, 1, 1, 3};
+ const float alpha_values[] = {0.0f, 1.0f, 2.0f};
+ const int output_shape[] = {3, 2, 2, 3};
+ const float golden[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 1.0f, 1.0f, 1.0f, // Row 1, Column 2
+ 0.0f, -1.0f, -2.0f, // Row 2, Column 1
+ 0.0f, -2.0f, -4.0f, // Row 1, Column 2
+ };
const int output_dims_count = 12;
float output_data[output_dims_count];
- tflite::testing::TestPreluFloat({3, 2, 2, 3}, // input shape
- {
- 0.0f, 0.0f, 0.0f, // Row 1, Column 1
- 1.0f, 1.0f, 1.0f, // Row 1, Column 2
- -1.0f, -1.0f, -1.0f, // Row 2, Column 1
- -2.0f, -2.0f, -2.0f, // Row 1, Column 2
- },
- {3, 1, 1, 3}, // alpha shape
- {0.0f, 1.0f, 2.0f}, // alpha values
- {
- 0.0f, 0.0f, 0.0f, // Row 1, Column 1
- 1.0f, 1.0f, 1.0f, // Row 1, Column 2
- 0.0f, -1.0f, -2.0f, // Row 2, Column 1
- 0.0f, -2.0f, -4.0f, // Row 1, Column 2
- },
- {3, 2, 2, 3}, // output shape
+ tflite::testing::TestPreluFloat(input_shape, input_values, alpha_shape,
+ alpha_values, golden, output_shape,
output_data);
}
TF_LITE_MICRO_TEST(QuantizedUint8PreluActivationsOpTest) {
- using tflite::testing::F2Q;
- const float kMin = -4;
- const float kMax = 127.f / 32.f;
- const int output_dims_count = 12;
- uint8_t output_data[output_dims_count];
+ const int input_shape[] = {3, 2, 2, 3};
+ const float input_values[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 0.5f, 0.5f, 0.5f, // Row 1, Column 2
+ -1.0f, -1.0f, -1.0f, // Row 2, Column 1
+ -0.25f, -0.25f, -0.25f, // Row 1, Column 2
+ };
+ const int alpha_shape[] = {3, 1, 1, 3};
+ const float alpha_values[] = {0.0f, 0.5f, -0.5f};
+ const int output_shape[] = {3, 2, 2, 3};
+ const float golden[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 0.5f, 0.5f, 0.5f, // Row 1, Column 2
+ 0.0f, -0.5f, 0.5f, // Row 2, Column 1
+ 0.0f, -0.125f, 0.125f, // Row 1, Column 2
+ };
+
+ const int dims_count = 12;
+
+ uint8_t input_quantized[dims_count];
+ uint8_t alpha_quantized[3];
+ uint8_t golden_quantized[dims_count];
+ float scale = 0.125;
+ int zero_point = 127;
+ uint8_t output_data[dims_count];
+
tflite::testing::TestPreluQuantized(
- {3, 2, 2, 3}, // input shape
- {F2Q(0.0f, kMin, kMax), F2Q(0.0f, kMin, kMax), F2Q(0.0f, kMin, kMax),
- F2Q(0.5f, kMin, kMax), F2Q(0.5f, kMin, kMax), F2Q(0.5f, kMin, kMax),
- F2Q(-1.0f, kMin, kMax), F2Q(-1.0f, kMin, kMax), F2Q(-1.0f, kMin, kMax),
- F2Q(-0.25f, kMin, kMax), F2Q(-0.25f, kMin, kMax),
- F2Q(-0.25f, kMin, kMax)},
- kMin, kMax, {3, 1, 1, 3}, // alpha shape
- {F2Q(0.0f, kMin, kMax), F2Q(0.5f, kMin, kMax), F2Q(-0.5f, kMin, kMax)},
- kMin, kMax,
- {F2Q(0.0f, kMin, kMax), F2Q(0.0f, kMin, kMax), F2Q(0.0f, kMin, kMax),
- F2Q(0.5f, kMin, kMax), F2Q(0.5f, kMin, kMax), F2Q(0.5f, kMin, kMax),
- F2Q(0.0f, kMin, kMax), F2Q(-0.5f, kMin, kMax), F2Q(0.5f, kMin, kMax),
- F2Q(0.0f, kMin, kMax), F2Q(-0.125f, kMin, kMax),
- F2Q(0.125f, kMin, kMax)},
- {3, 2, 2, 3}, // output shape
- kMin, kMax, output_data);
+ input_shape, input_values, input_quantized, scale, zero_point,
+ alpha_shape, alpha_values, alpha_quantized, scale, zero_point, golden,
+ golden_quantized, scale, zero_point, output_shape, output_data);
}
TF_LITE_MICRO_TEST(QuantizedInt8PreluActivationsOpTest) {
- using tflite::testing::F2QS;
- const float kMin = -1;
- const float kMax = 127.f / 128.f;
- const int output_dims_count = 12;
- int8_t output_data[output_dims_count];
+ const int input_shape[] = {3, 2, 2, 3};
+ const float input_values[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 0.5f, 0.5f, 0.5f, // Row 1, Column 2
+ -1.0f, -1.0f, -1.0f, // Row 2, Column 1
+ -0.25f, -0.25f, -0.25f, // Row 1, Column 2
+ };
+ const int alpha_shape[] = {3, 1, 1, 3};
+ const float alpha_values[] = {0.0f, 0.5f, -0.5f};
+ const int output_shape[] = {3, 2, 2, 3};
+ const float golden[] = {
+ 0.0f, 0.0f, 0.0f, // Row 1, Column 1
+ 0.5f, 0.5f, 0.5f, // Row 1, Column 2
+ 0.0f, -0.5f, 0.5f, // Row 2, Column 1
+ 0.0f, -0.125f, 0.125f, // Row 1, Column 2
+ };
+ const int dims_count = 12;
+ int8_t input_quantized[dims_count];
+ int8_t alpha_quantized[3];
+ int8_t golden_quantized[dims_count];
+ float scale = 2.0 / 255.0;
+ int zero_point = 0;
+ int8_t output_data[dims_count];
tflite::testing::TestPreluQuantized(
- {3, 2, 2, 3}, // input shape
- {F2QS(0.0f, kMin, kMax), F2QS(0.0f, kMin, kMax), F2QS(0.0f, kMin, kMax),
- F2QS(0.5f, kMin, kMax), F2QS(0.5f, kMin, kMax), F2QS(0.5f, kMin, kMax),
- F2QS(-1.0f, kMin, kMax), F2QS(-1.0f, kMin, kMax),
- F2QS(-1.0f, kMin, kMax), F2QS(-0.25f, kMin, kMax),
- F2QS(-0.25f, kMin, kMax), F2QS(-0.25f, kMin, kMax)},
- kMin, kMax, {3, 1, 1, 3}, // alpha shape
- {F2QS(0.0f, kMin, kMax), F2QS(0.5f, kMin, kMax), F2QS(-0.5f, kMin, kMax)},
- kMin, kMax,
- {F2QS(0.0f, kMin, kMax), F2QS(0.0f, kMin, kMax), F2QS(0.0f, kMin, kMax),
- F2QS(0.5f, kMin, kMax), F2QS(0.5f, kMin, kMax), F2QS(0.5f, kMin, kMax),
- F2QS(0.0f, kMin, kMax), F2QS(-0.5f, kMin, kMax), F2QS(0.5f, kMin, kMax),
- F2QS(0.0f, kMin, kMax), F2QS(-0.125f, kMin, kMax),
- F2QS(0.125f, kMin, kMax)},
- {3, 2, 2, 3}, // output shape
- kMin, kMax, output_data);
+ input_shape, input_values, input_quantized, scale, zero_point,
+ alpha_shape, alpha_values, alpha_quantized, scale, zero_point, golden,
+ golden_quantized, scale, zero_point, output_shape, output_data);
}
TF_LITE_MICRO_TESTS_END
diff --git a/tensorflow/lite/micro/kernels/reshape_test.cc b/tensorflow/lite/micro/kernels/reshape_test.cc
index 59d5577..91ecbdc 100644
--- a/tensorflow/lite/micro/kernels/reshape_test.cc
+++ b/tensorflow/lite/micro/kernels/reshape_test.cc
@@ -194,7 +194,7 @@
int input_dims_data[] = {3, 1, 2, 2};
TfLiteIntArray* input_dims =
tflite::testing::IntArrayFromInts(input_dims_data);
- auto input_data = {3.0f};
+ const float input_data[] = {3.0f};
auto input_tensor =
tflite::testing::CreateFloatTensor(input_data, input_dims);
float output_data[4];
@@ -315,7 +315,7 @@
int input_dims_data[] = {1, 1};
TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
- auto input_data = {3.0f};
+ const float input_data[] = {3.0f};
auto input_tensor = CreateFloatTensor(input_data, input_dims);
float output_data[1];
@@ -326,8 +326,9 @@
int shape_dims_data[] = {1, 0};
TfLiteIntArray* shape_dims = IntArrayFromInts(shape_dims_data);
- auto shape_tensor =
- tflite::testing::CreateTensor<int32_t, kTfLiteInt32>({0}, shape_dims);
+ const int32_t shape_data[] = {0};
+ auto shape_tensor = tflite::testing::CreateTensor<int32_t, kTfLiteInt32>(
+ shape_data, shape_dims);
const float expected_output_with_shape[] = {};
const int expected_output_with_shape_len = 0;
const float expected_output_no_shape[] = {3};
diff --git a/tensorflow/lite/micro/testing/test_utils.cc b/tensorflow/lite/micro/testing/test_utils.cc
index 0bb9785..4d931bd 100644
--- a/tensorflow/lite/micro/testing/test_utils.cc
+++ b/tensorflow/lite/micro/testing/test_utils.cc
@@ -150,16 +150,6 @@
}
}
-TfLiteTensor CreateFloatTensor(std::initializer_list<float> data,
- TfLiteIntArray* dims, bool is_variable) {
- return CreateFloatTensor(data.begin(), dims, is_variable);
-}
-
-TfLiteTensor CreateBoolTensor(std::initializer_list<bool> data,
- TfLiteIntArray* dims, bool is_variable) {
- return CreateBoolTensor(data.begin(), dims, is_variable);
-}
-
TfLiteTensor CreateQuantizedTensor(const uint8_t* data, TfLiteIntArray* dims,
float min, float max, bool is_variable) {
TfLiteTensor result;
@@ -174,12 +164,6 @@
return result;
}
-TfLiteTensor CreateQuantizedTensor(std::initializer_list<uint8_t> data,
- TfLiteIntArray* dims, float min, float max,
- bool is_variable) {
- return CreateQuantizedTensor(data.begin(), dims, min, max, is_variable);
-}
-
TfLiteTensor CreateQuantizedTensor(const int8_t* data, TfLiteIntArray* dims,
float min, float max, bool is_variable) {
TfLiteTensor result;
@@ -194,12 +178,6 @@
return result;
}
-TfLiteTensor CreateQuantizedTensor(std::initializer_list<int8_t> data,
- TfLiteIntArray* dims, float min, float max,
- bool is_variable) {
- return CreateQuantizedTensor(data.begin(), dims, min, max, is_variable);
-}
-
TfLiteTensor CreateQuantizedTensor(float* data, uint8_t* quantized_data,
TfLiteIntArray* dims, bool is_variable) {
TfLiteTensor result;
@@ -258,11 +236,5 @@
return result;
}
-TfLiteTensor CreateQuantized32Tensor(std::initializer_list<int32_t> data,
- TfLiteIntArray* dims, float scale,
- bool is_variable) {
- return CreateQuantized32Tensor(data.begin(), dims, scale, is_variable);
-}
-
} // namespace testing
} // namespace tflite
diff --git a/tensorflow/lite/micro/testing/test_utils.h b/tensorflow/lite/micro/testing/test_utils.h
index 053c441..e83ac80 100644
--- a/tensorflow/lite/micro/testing/test_utils.h
+++ b/tensorflow/lite/micro/testing/test_utils.h
@@ -17,7 +17,6 @@
#include <cmath>
#include <cstdint>
-#include <initializer_list>
#include <limits>
#include "tensorflow/lite/c/common.h"
@@ -31,12 +30,6 @@
// Note: These methods are deprecated, do not use. See b/141332970.
-// TODO(kreeger): Don't use this anymore in our tests. Optimized compiler
-// settings can play with pointer placement on the stack (b/140130236).
-inline TfLiteIntArray* IntArrayFromInitializer(
- std::initializer_list<int> int_initializer) {
- return IntArrayFromInts(int_initializer.begin());
-}
// Derives the quantization range max from scaling factor and zero point.
template <typename T>
@@ -80,28 +73,14 @@
void PopulateContext(TfLiteTensor* tensors, int tensors_size,
ErrorReporter* error_reporter, TfLiteContext* context);
-TfLiteTensor CreateFloatTensor(std::initializer_list<float> data,
- TfLiteIntArray* dims, bool is_variable = false);
-
-TfLiteTensor CreateBoolTensor(std::initializer_list<bool> data,
- TfLiteIntArray* dims, bool is_variable = false);
-
TfLiteTensor CreateQuantizedTensor(const uint8_t* data, TfLiteIntArray* dims,
float min, float max,
bool is_variable = false);
-TfLiteTensor CreateQuantizedTensor(std::initializer_list<uint8_t> data,
- TfLiteIntArray* dims, float min, float max,
- bool is_variable = false);
-
TfLiteTensor CreateQuantizedTensor(const int8_t* data, TfLiteIntArray* dims,
float min, float max,
bool is_variable = false);
-TfLiteTensor CreateQuantizedTensor(std::initializer_list<int8_t> data,
- TfLiteIntArray* dims, float min, float max,
- bool is_variable = false);
-
TfLiteTensor CreateQuantizedTensor(float* data, uint8_t* quantized_data,
TfLiteIntArray* dims,
bool is_variable = false);
@@ -117,10 +96,6 @@
TfLiteTensor CreateQuantized32Tensor(const int32_t* data, TfLiteIntArray* dims,
float scale, bool is_variable = false);
-TfLiteTensor CreateQuantized32Tensor(std::initializer_list<int32_t> data,
- TfLiteIntArray* dims, float scale,
- bool is_variable = false);
-
template <typename input_type = int32_t,
TfLiteType tensor_input_type = kTfLiteInt32>
inline TfLiteTensor CreateTensor(const input_type* data, TfLiteIntArray* dims,
@@ -135,15 +110,6 @@
return result;
}
-template <typename input_type = int32_t,
- TfLiteType tensor_input_type = kTfLiteInt32>
-inline TfLiteTensor CreateTensor(std::initializer_list<input_type> data,
- TfLiteIntArray* dims,
- bool is_variable = false) {
- return CreateTensor<input_type, tensor_input_type>(data.begin(), dims,
- is_variable);
-}
-
} // namespace testing
} // namespace tflite
