Refactor micro_utils and test_helpers to use template methods.

PiperOrigin-RevId: 337845815
Change-Id: I013df3bf64b289fcde4a7c661fec53eaadbbb313

tensorflow/lite/micro/BUILD

@@ -81,6 +81,7 @@ cc_library(
     deps = [
         ":micro_utils",
         ":op_resolvers",
+        "//tensorflow/lite:type_to_tflitetype",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/core/api",
         "//tensorflow/lite/kernels:kernel_util",

tensorflow/lite/micro/kernels/BUILD

@@ -216,7 +216,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -231,7 +230,6 @@ tflite_micro_cc_test(
         ":kernel_runner",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/kernels/internal:tensor",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -243,10 +241,8 @@ tflite_micro_cc_test(
         "fully_connected_test.cc",
     ],
     deps = [
-        ":fully_connected",
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
         "//tensorflow/lite/micro:micro_utils",
         "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
@@ -290,7 +286,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -305,7 +300,6 @@ tflite_micro_cc_test(
         ":kernel_runner",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/micro:micro_utils",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -319,7 +313,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -389,7 +382,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -403,7 +395,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -431,7 +422,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -488,7 +478,6 @@ tflite_micro_cc_test(
         ":kernel_runner",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/micro:debug_log",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -503,7 +492,6 @@ tflite_micro_cc_test(
         ":kernel_runner",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/micro:debug_log",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -582,8 +570,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -597,8 +583,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -644,9 +628,7 @@ tflite_micro_cc_test(
         ":kernel_runner",
         "//tensorflow/lite/c:common",
         "//tensorflow/lite/kernels/internal:tensor",
-        "//tensorflow/lite/micro:micro_framework",
         "//tensorflow/lite/micro:micro_utils",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -674,7 +656,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -688,7 +669,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
         "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
@@ -758,8 +738,6 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
-        "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",
     ],
@@ -771,7 +749,18 @@ tflite_micro_cc_test(
     deps = [
         ":kernel_runner",
         "//tensorflow/lite/c:common",
-        "//tensorflow/lite/micro:micro_framework",
+        "//tensorflow/lite/micro:op_resolvers",
+        "//tensorflow/lite/micro:test_helpers",
+        "//tensorflow/lite/micro/testing:micro_test",
+    ],
+)
+
+cc_test(
+    name = "shape_test",
+    srcs = ["shape_test.cc"],
+    deps = [
+        ":kernel_runner",
+        "//tensorflow/lite/c:common",
         "//tensorflow/lite/micro:op_resolvers",
         "//tensorflow/lite/micro:test_helpers",
         "//tensorflow/lite/micro/testing:micro_test",

tensorflow/lite/micro/kernels/activations.cc

@@ -205,12 +205,12 @@ TfLiteStatus Relu6Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE(context, input != nullptr);
 
   if (input->type == kTfLiteInt8) {
-    data->six_int8 = FloatToAsymmetricQuantizedInt8(6.0f, input->params.scale,
+    data->six_int8 = FloatToQuantizedType<int8_t>(6.0f, input->params.scale,
-                                                    input->params.zero_point);
+                                                  input->params.zero_point);
     data->zero_int8 = input->params.zero_point;
   } else if (input->type == kTfLiteUInt8) {
-    data->six_uint8 = FloatToAsymmetricQuantizedUInt8(6.0f, input->params.scale,
+    data->six_uint8 = FloatToQuantizedType<uint8_t>(6.0f, input->params.scale,
-                                                      input->params.zero_point);
+                                                    input->params.zero_point);
     data->zero_uint8 = input->params.zero_point;
   }
 

tensorflow/lite/micro/kernels/activations_test.cc

@@ -35,8 +35,8 @@ void TestReluFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};
@@ -68,8 +68,8 @@ void TestRelu6Float(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};
@@ -123,8 +123,8 @@ void TestReluUint8(const int* input_dims_data, const float* input_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricQuantize(golden, golden_quantized, output_elements_count,
+  Quantize(golden, golden_quantized, output_elements_count, output_scale,
-                     output_scale, output_zero_point);
+           output_zero_point);
 
   for (int i = 0; i < output_elements_count; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);
@@ -164,8 +164,8 @@ void TestRelu6Uint8(const int* input_dims_data, const float* input_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricQuantize(golden, golden_quantized, output_elements_count,
+  Quantize(golden, golden_quantized, output_elements_count, output_scale,
-                     output_scale, output_zero_point);
+           output_zero_point);
 
   for (int i = 0; i < output_elements_count; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);
@@ -204,8 +204,8 @@ void TestReluInt8(const int* input_dims_data, const float* input_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricQuantize(golden, golden_quantized, output_elements_count,
+  Quantize(golden, golden_quantized, output_elements_count, output_scale,
-                     output_scale, output_zero_point);
+           output_zero_point);
 
   for (int i = 0; i < output_elements_count; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);
@@ -244,8 +244,8 @@ void TestRelu6Int8(const int* input_dims_data, const float* input_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricQuantize(golden, golden_quantized, output_elements_count,
+  Quantize(golden, golden_quantized, output_elements_count, output_scale,
-                     output_scale, output_zero_point);
+           output_zero_point);
 
   for (int i = 0; i < output_elements_count; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);

tensorflow/lite/micro/kernels/add_test.cc

@@ -100,9 +100,9 @@ void TestAddFloat(const int* input1_dims_data, const float* input1_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateAddGoldens(tensors, tensors_size, expected_output, output_data,
@@ -136,9 +136,8 @@ void TestAddQuantized(const int* input1_dims_data, const float* input1_data,
       tflite::testing::CreateQuantizedTensor(output_data, output_dims,
                                              output_scale, output_zero_point),
   };
-  tflite::AsymmetricQuantize(golden, golden_quantized,
+  tflite::Quantize(golden, golden_quantized, ElementCount(*output_dims),
-                             ElementCount(*output_dims), output_scale,
+                   output_scale, output_zero_point);
-                             output_zero_point);
 
   ValidateAddGoldens(tensors, tensors_size, golden_quantized, output_data,
                      ElementCount(*output_dims), activation);

tensorflow/lite/micro/kernels/arg_min_max_test.cc

@@ -60,9 +60,9 @@ void TestArgMinMaxFloat(const int* input_dims_data, const float* input_values,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_values, input_dims),
+      CreateTensor(input_values, input_dims),
-      CreateInt32Tensor(axis_values, axis_dims),
+      CreateTensor(axis_values, axis_dims),
-      CreateInt32Tensor(output, output_dims),
+      CreateTensor(output, output_dims),
   };
 
   ValidateArgMinMaxGoldens(tensors, tensors_size, goldens, output,
@@ -88,8 +88,8 @@ void TestArgMinMaxQuantized(const int* input_dims_data,
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_values, input_quantized, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(axis_values, axis_dims),
+      CreateTensor(axis_values, axis_dims),
-      CreateInt32Tensor(output, output_dims),
+      CreateTensor(output, output_dims),
   };
 
   ValidateArgMinMaxGoldens(tensors, tensors_size, goldens, output,

tensorflow/lite/micro/kernels/ceil_test.cc

@@ -33,8 +33,8 @@ void TestCeil(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};

tensorflow/lite/micro/kernels/comparisons_test.cc

@@ -61,9 +61,9 @@ void TestComparisonFloat(const TfLiteRegistration& registration,
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
 
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TestComparison(registration, tensors, expected_output_data, output_data);
@@ -79,9 +79,9 @@ void TestComparisonBool(const TfLiteRegistration& registration,
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
 
   TfLiteTensor tensors[tensors_size] = {
-      CreateBoolTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateBoolTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TestComparison(registration, tensors, expected_output_data, output_data);
@@ -97,9 +97,9 @@ void TestComparisonInt(const TfLiteRegistration& registration,
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
 
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateInt32Tensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TestComparison(registration, tensors, expected_output_data, output_data);
@@ -122,7 +122,7 @@ void TestComparisonQuantizedUInt8(const TfLiteRegistration& registration,
                             input1_scale, input1_zero_point),
       CreateQuantizedTensor(input2_data, input2_quantized, input2_dims,
                             input2_scale, input2_zero_point),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TestComparison(registration, tensors, expected_output_data, output_data);
@@ -145,7 +145,7 @@ void TestComparisonQuantizedInt8(const TfLiteRegistration& registration,
                             input1_scale, input1_zero_point),
       CreateQuantizedTensor(input2_data, input2_quantized, input2_dims,
                             input2_scale, input2_zero_point),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TestComparison(registration, tensors, expected_output_data, output_data);

tensorflow/lite/micro/kernels/concatenation_test.cc

@@ -38,10 +38,9 @@ void TestConcatenateTwoInputs(const int* input1_dims_data,
   constexpr int input_size = 2;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input1_data, input1_dims),
+                                        CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   int inputs_array_data[] = {2, 0, 1};
   TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);

tensorflow/lite/micro/kernels/conv_test.cc

@@ -107,10 +107,10 @@ void TestConvFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(filter_data, filter_dims),
+      CreateTensor(filter_data, filter_dims),
-      CreateFloatTensor(bias_data, bias_dims),
+      CreateTensor(bias_data, bias_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TF_LITE_MICRO_EXPECT_EQ(
@@ -133,8 +133,8 @@ void TestConvQuantizedPerLayer(
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
   const int output_dims_count = ElementCount(*output_dims);
 
-  tflite::AsymmetricQuantize(expected_output_data, expected_output_quantized,
+  tflite::Quantize(expected_output_data, expected_output_quantized,
-                             output_dims_count, output_scale, 128);
+                   output_dims_count, output_scale, 128);
 
   constexpr int inputs_size = 3;
   constexpr int outputs_size = 1;
@@ -218,9 +218,8 @@ void TestConvQuantizedPerChannel(
       output_tensor,
   };
 
-  tflite::AsymmetricQuantize(expected_output_data,
+  tflite::Quantize(expected_output_data, expected_output_data_quantized,
-                             expected_output_data_quantized, output_dims_count,
+                   output_dims_count, output_scale, output_zero_point);
-                             output_scale, output_zero_point);
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteOk,
       ValidateConvGoldens(tensors, tensors_size, expected_output_data_quantized,
@@ -286,8 +285,8 @@ TF_LITE_MICRO_TEST(SimpleTestQuantized) {
 }
 
 TF_LITE_MICRO_TEST(InputOutputDifferentTypeIsError) {
-  using tflite::testing::CreateFloatTensor;
   using tflite::testing::CreateQuantizedTensor;
+  using tflite::testing::CreateTensor;
   using tflite::testing::IntArrayFromInts;
 
   TfLiteIntArray* input_dims = IntArrayFromInts(tflite::testing::kInputShape);
@@ -301,9 +300,9 @@ TF_LITE_MICRO_TEST(InputOutputDifferentTypeIsError) {
 
   int8_t output_data[tflite::testing::kOutputElements];
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(tflite::testing::kInputData, input_dims),
+      CreateTensor(tflite::testing::kInputData, input_dims),
-      CreateFloatTensor(tflite::testing::kFilterData, filter_dims),
+      CreateTensor(tflite::testing::kFilterData, filter_dims),
-      CreateFloatTensor(tflite::testing::kBiasData, bias_dims),
+      CreateTensor(tflite::testing::kBiasData, bias_dims),
       CreateQuantizedTensor(output_data, output_dims, /*scale=*/0.0f,
                             /*zero_point=*/0),
   };
@@ -314,8 +313,8 @@ TF_LITE_MICRO_TEST(InputOutputDifferentTypeIsError) {
 }
 
 TF_LITE_MICRO_TEST(HybridModeIsError) {
-  using tflite::testing::CreateFloatTensor;
   using tflite::testing::CreateQuantizedTensor;
+  using tflite::testing::CreateTensor;
   using tflite::testing::IntArrayFromInts;
 
   TfLiteIntArray* input_dims = IntArrayFromInts(tflite::testing::kInputShape);
@@ -330,12 +329,12 @@ TF_LITE_MICRO_TEST(HybridModeIsError) {
   int8_t filter_data[tflite::testing::kFilterElements] = {};
   float output_data[tflite::testing::kOutputElements];
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(tflite::testing::kInputData, input_dims),
+      CreateTensor(tflite::testing::kInputData, input_dims),
       CreateQuantizedTensor(filter_data, filter_dims,
                             /*scale=*/0.0f,
                             /*zero_point=*/0),
-      CreateFloatTensor(tflite::testing::kBiasData, bias_dims),
+      CreateTensor(tflite::testing::kBiasData, bias_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteError, tflite::testing::InvokeConv(
@@ -632,8 +631,8 @@ TF_LITE_MICRO_TEST(FilterDimsNotMatchingAffineQuantization) {
       output_tensor,
   };
 
-  tflite::AsymmetricQuantize(tflite::testing::kGoldenData, golden_quantized,
+  tflite::Quantize(tflite::testing::kGoldenData, golden_quantized,
-                             output_dims_count, output_scale, 0);
+                   output_dims_count, output_scale, 0);
 
   // Set filter quant to mismatched dimension.
   TfLiteAffineQuantization* quant = reinterpret_cast<TfLiteAffineQuantization*>(
@@ -706,7 +705,7 @@ TF_LITE_MICRO_TEST(BroadcastPerLayerQuantizationToPerChannelShouldMatchGolden) {
                             tflite::testing::kBiasElements,
                             input_scale * output_scale);
   TfLiteTensor bias_tensor =
-      tflite::testing::CreateInt32Tensor(bias_quantized, bias_dims);
+      tflite::testing::CreateTensor(bias_quantized, bias_dims);
 
   int bias_zero_points[2] = {1, 0};
   float bias_scales[2] = {1, input_scale * filter_scale};
@@ -735,8 +734,8 @@ TF_LITE_MICRO_TEST(BroadcastPerLayerQuantizationToPerChannelShouldMatchGolden) {
       output_tensor,
   };
 
-  tflite::AsymmetricQuantize(tflite::testing::kGoldenData, golden_quantized,
+  tflite::Quantize(tflite::testing::kGoldenData, golden_quantized,
-                             output_dims_count, output_scale, 0);
+                   output_dims_count, output_scale, 0);
 
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteOk, tflite::testing::ValidateConvGoldens(
@@ -832,7 +831,7 @@ TF_LITE_MICRO_TEST(Int8Input32x1Filter32x32ShouldMatchGolden) {
   tflite::SymmetricQuantize(bias_values, bias_quantized, kSampleSize,
                             input_scale * output_scale);
   TfLiteTensor bias_tensor =
-      tflite::testing::CreateInt32Tensor(bias_quantized, bias_dims);
+      tflite::testing::CreateTensor(bias_quantized, bias_dims);
 
   // There is a single zero point of 0, and a single scale of
   // input_scale * filter_scale.
@@ -867,9 +866,8 @@ TF_LITE_MICRO_TEST(Int8Input32x1Filter32x32ShouldMatchGolden) {
   };
 
   int8_t golden_quantized[kSampleSize];
-  tflite::AsymmetricQuantize(expected_output, golden_quantized,
+  tflite::Quantize(expected_output, golden_quantized, output_dims_count,
-                             output_dims_count, output_scale,
+                   output_scale, output_zero_point);
-                             output_zero_point);
 
   // Rounding errors due to quantization should not exceed 1.
   constexpr int kQuantizationTolerance = 1;

tensorflow/lite/micro/kernels/depthwise_conv_test.cc

@@ -96,10 +96,10 @@ void TestDepthwiseConvFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(filter_data, filter_dims),
+      CreateTensor(filter_data, filter_dims),
-      CreateFloatTensor(bias_data, bias_dims),
+      CreateTensor(bias_data, bias_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateDepthwiseConvGoldens(expected_output_data, output_dims_count,
@@ -151,8 +151,8 @@ void TestDepthwiseConvQuantizedPerLayer(
                                          IntArrayFromInts(bias_zero_points), 0};
   tensors[2].quantization = {kTfLiteAffineQuantization, &bias_quant};
 
-  AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+  Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                     output_zero_point);
+           output_zero_point);
   ValidateDepthwiseConvGoldens(golden_quantized, output_dims_count, conv_params,
                                1.0, tensors_size, tensors);
 }
@@ -217,8 +217,8 @@ void TestDepthwiseConvQuantizedPerChannel(
       output_tensor,
   };
 
-  AsymmetricQuantize(expected_output_data, expected_output_data_quantized,
+  Quantize(expected_output_data, expected_output_data_quantized,
-                     output_dims_count, output_scale, output_zero_point);
+           output_dims_count, output_scale, output_zero_point);
 
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteOk, ValidateDepthwiseConvGoldens(expected_output_data_quantized,
@@ -810,7 +810,7 @@ TF_LITE_MICRO_TEST(PerChannelBroadcastQuantizationParams) {
   tflite::SymmetricQuantize(bias_values, bias_quantized, bias_elements,
                             input_scale * output_scale);
   TfLiteTensor bias_tensor =
-      tflite::testing::CreateInt32Tensor(bias_quantized, bias_dims);
+      tflite::testing::CreateTensor(bias_quantized, bias_dims);
 
   int bias_zero_points[2] = {1, 0};
   float bias_scales[2] = {1, input_scale * filter_scale};
@@ -839,8 +839,8 @@ TF_LITE_MICRO_TEST(PerChannelBroadcastQuantizationParams) {
       output_tensor,
   };
 
-  tflite::AsymmetricQuantize(golden, golden_quantized, output_dims_count,
+  tflite::Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                             output_scale, 0);
+                   0);
 
   TfLiteDepthwiseConvParams conv_params;
   conv_params.activation = kTfLiteActNone;
@@ -954,7 +954,7 @@ TF_LITE_MICRO_TEST(Int8Input32x4Filter32x4ShouldMatchGolden) {
   tflite::SymmetricQuantize(bias_values, bias_quantized, bias_elements,
                             input_scale * output_scale);
   TfLiteTensor bias_tensor =
-      tflite::testing::CreateInt32Tensor(bias_quantized, bias_dims);
+      tflite::testing::CreateTensor(bias_quantized, bias_dims);
 
   // Set zero point and scale arrays with a single element for each.
   int bias_zero_points[] = {1, 0};
@@ -989,8 +989,7 @@ TF_LITE_MICRO_TEST(Int8Input32x4Filter32x4ShouldMatchGolden) {
   };
 
   int8_t golden_quantized[output_elements];
-  tflite::AsymmetricQuantize(golden, golden_quantized, output_elements,
+  tflite::Quantize(golden, golden_quantized, output_elements, output_scale, 0);
-                             output_scale, 0);
 
   // Errors due to quantization should not exceed 1.
   constexpr int kQuantizationTolerance = 1;

tensorflow/lite/micro/kernels/dequantize_test.cc

@@ -61,7 +61,7 @@ void TestDequantizeToFloat(const int* input_dims_data, const float* input_data,
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_data, input_data_quantized, input_dims, scale,
                             zero_point),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateDequantizeGoldens(tensors, tensors_size, expected_output_data,
@@ -84,7 +84,7 @@ void TestDequantizeToInt32(const int* input_dims_data, const float* input_data,
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_data, input_data_quantized, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   tensors[1].params.scale = output_scale;

tensorflow/lite/micro/kernels/elementwise_test.cc

@@ -35,9 +35,8 @@ void TestElementwiseFloat(const TfLiteRegistration& registration,
   constexpr int input_size = 1;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input_data, input_dims),
-      CreateFloatTensor(input_data, input_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   // Place a unique value in the uninitialized output buffer.
   for (int i = 0; i < output_dims_count; ++i) {
@@ -72,9 +71,8 @@ void TestElementwiseBool(const TfLiteRegistration& registration,
   constexpr int input_size = 1;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input_data, input_dims),
-      CreateBoolTensor(input_data, input_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateBoolTensor(output_data, output_dims)};
 
   // Place false in the uninitialized output buffer.
   for (int i = 0; i < output_dims_count; ++i) {

tensorflow/lite/micro/kernels/floor_test.cc

@@ -34,8 +34,8 @@ void TestFloor(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};

tensorflow/lite/micro/kernels/fully_connected_test.cc

@@ -276,10 +276,10 @@ TfLiteStatus TestFullyConnectedFloat(
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(weights_data, weights_dims),
+      CreateTensor(weights_data, weights_dims),
-      CreateFloatTensor(bias_data, bias_dims),
+      CreateTensor(bias_data, bias_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   return ValidateFullyConnectedGoldens(tensors, tensors_size, activation, 1e-4f,
@@ -317,8 +317,8 @@ TfLiteStatus TestFullyConnectedQuantized(
                             output_zero_point),
   };
 
-  AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+  Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                     output_zero_point);
+           output_zero_point);
 
   return ValidateFullyConnectedGoldens(tensors, tensors_size, activation, 0.0f,
                                        output_dims_count, golden_quantized,

tensorflow/lite/micro/kernels/hard_swish_test.cc

@@ -114,8 +114,8 @@ void TestHardSwishQuantized(int size, const T* output_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricDequantize<T>(output_data, output_elements_count, output_scale,
+  Dequantize<T>(output_data, output_elements_count, output_scale,
-                          output_zero_point, dequantized_output);
+                output_zero_point, dequantized_output);
 
   for (int i = 0; i < output_elements_count; ++i) {
     TF_LITE_MICRO_EXPECT_NEAR(float_ref_output_values[i], dequantized_output[i],
@@ -194,8 +194,8 @@ void TestHardSwishQuantizedBias(const int size, const T* output_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  AsymmetricDequantize<T>(output_data, output_elements_count, output_scale,
+  Dequantize<T>(output_data, output_elements_count, output_scale,
-                          output_zero_point, dequantized_output);
+                output_zero_point, dequantized_output);
 
   float sum_diff = 0;
   for (int i = 0; i < size; i++) {
@@ -229,8 +229,8 @@ void TestHardSwishFloat(const int size, float* output_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(float_input_values, input_dims),
+      CreateTensor(float_input_values, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};

tensorflow/lite/micro/kernels/l2norm_test.cc

@@ -32,7 +32,7 @@ constexpr float kOutputMax = 127.0 / 128.0;
 
 TfLiteTensor CreateL2NormTensor(const float* data, TfLiteIntArray* dims,
                                 bool is_input) {
-  return CreateFloatTensor(data, dims);
+  return CreateTensor(data, dims);
 }
 
 template <typename T>

tensorflow/lite/micro/kernels/logical_test.cc

@@ -38,9 +38,9 @@ void TestLogicalOp(const TfLiteRegistration& registration,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateBoolTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateBoolTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateBoolTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {2, 0, 1};

tensorflow/lite/micro/kernels/logistic_test.cc

@@ -79,8 +79,8 @@ void TestLogisticFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateLogisticGoldens(tensors, tensors_size, output_data, golden,
@@ -108,8 +108,8 @@ void TestLogisticQuantized(const int* input_dims_data, const float* input_data,
                             output_zero_point),
   };
 
-  tflite::AsymmetricQuantize(golden, golden_quantized, output_elements_count,
+  tflite::Quantize(golden, golden_quantized, output_elements_count,
-                             output_scale, output_zero_point);
+                   output_scale, output_zero_point);
   ValidateLogisticGoldens(tensors, tensors_size, output_data, golden_quantized,
                           output_elements_count, 1.0);
 }

tensorflow/lite/micro/kernels/maximum_minimum_test.cc

@@ -38,9 +38,9 @@ void TestMaxMinFloat(const TfLiteRegistration& registration,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {2, 0, 1};
@@ -118,9 +118,9 @@ void TestMaxMinQuantizedInt32(
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateInt32Tensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateInt32Tensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {2, 0, 1};

tensorflow/lite/micro/kernels/mul_test.cc

@@ -80,9 +80,9 @@ void TestMulFloat(const int* input1_dims_data, const float* input1_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateMulGoldens(tensors, tensors_size, activation, golden,
@@ -114,8 +114,8 @@ void TestMulQuantized(const int* input1_dims_data, const float* input1_data,
       CreateQuantizedTensor(output_data, output_dims, output_scale,
                             output_zero_point)};
 
-  AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+  Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                     output_zero_point);
+           output_zero_point);
 
   ValidateMulGoldens(tensors, tensors_size, activation, golden_quantized,
                      output_dims_count, 1.0f, output_data);

tensorflow/lite/micro/kernels/neg_test.cc

@@ -34,8 +34,8 @@ void TestNegFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};

tensorflow/lite/micro/kernels/pack_test.cc

@@ -61,10 +61,9 @@ void TestPackTwoInputsFloat(const int* input1_dims_data,
   constexpr int input_size = 2;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input1_data, input1_dims),
+                                        CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   TfLitePackParams builtin_data = {
       .values_count = 2,
@@ -95,11 +94,10 @@ void TestPackThreeInputsFloat(
   constexpr int input_size = 3;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input1_data, input1_dims),
+                                        CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+                                        CreateTensor(input3_data, input3_dims),
-      CreateFloatTensor(input3_data, input3_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   TfLitePackParams builtin_data = {
       .values_count = 3,
@@ -167,10 +165,9 @@ void TestPackTwoInputsQuantized32(const int* input1_dims_data,
   constexpr int input_size = 2;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input1_data, input1_dims),
-      CreateInt32Tensor(input1_data, input1_dims),
+                                        CreateTensor(input2_data, input2_dims),
-      CreateInt32Tensor(input2_data, input2_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateInt32Tensor(output_data, output_dims)};
 
   TfLitePackParams builtin_data = {
       .values_count = 2,

tensorflow/lite/micro/kernels/pad_test.cc

@@ -101,10 +101,9 @@ void TestPadFloat(const int* input_dims_data, const float* input_data,
   constexpr int inputs_size = 2;
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input_data, input_dims),
-      CreateFloatTensor(input_data, input_dims),
+                                        CreateTensor(pad_data, pad_dims),
-      CreateInt32Tensor(pad_data, pad_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   // Pad tensor must be constant.
   tensors[1].allocation_type = kTfLiteMmapRo;
@@ -130,10 +129,9 @@ void TestPadV2Float(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims), CreateTensor(pad_data, pad_dims),
-      CreateInt32Tensor(pad_data, pad_dims),
+      CreateTensor(&pad_value, pad_value_dims),
-      CreateFloatTensor(&pad_value, pad_value_dims),
+      CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   // Pad tensor must be constant.
   tensors[1].allocation_type = kTfLiteMmapRo;
@@ -161,15 +159,15 @@ void TestPadQuantized(const int* input_dims_data, const float* input_data,
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_data, input_quantized, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(pad_data, pad_dims),
+      CreateTensor(pad_data, pad_dims),
       CreateQuantizedTensor(output_data, output_dims, output_scale,
                             output_zero_point)};
 
   // Pad tensor must be constant.
   tensors[1].allocation_type = kTfLiteMmapRo;
 
-  tflite::AsymmetricQuantize(golden, golden_quantized, output_dims_count,
+  tflite::Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                             output_scale, output_zero_point);
+                   output_zero_point);
   TF_LITE_MICRO_EXPECT_EQ(
       expected_status,
       ValidatePadGoldens(tensors, tensors_size, golden_quantized, output_data,
@@ -200,7 +198,7 @@ void TestPadV2Quantized(const int* input_dims_data, const float* input_data,
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_data, input_quantized, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(pad_data, pad_dims),
+      CreateTensor(pad_data, pad_dims),
       CreateQuantizedTensor(&pad_value, &pad_value_quantized, pad_value_dims,
                             pad_value_scale, pad_value_zero_point),
       CreateQuantizedTensor(output_data, output_dims, output_scale,
@@ -211,8 +209,8 @@ void TestPadV2Quantized(const int* input_dims_data, const float* input_data,
   tensors[2].params.scale = pad_value_scale;
   tensors[3].params.scale = output_scale;
 
-  tflite::AsymmetricQuantize(golden, golden_quantized, output_dims_count,
+  tflite::Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                             output_scale, output_zero_point);
+                   output_zero_point);
   TF_LITE_MICRO_EXPECT_EQ(
       expected_status,
       ValidatePadV2Goldens(tensors, tensors_size, golden_quantized, output_data,

tensorflow/lite/micro/kernels/pooling_test.cc

@@ -73,8 +73,8 @@ void TestAveragePoolFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   const TfLiteRegistration registration =
@@ -131,8 +131,8 @@ void TestMaxPoolFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   const TfLiteRegistration registration =

tensorflow/lite/micro/kernels/prelu_test.cc

@@ -57,9 +57,9 @@ void TestPreluFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(alpha_data, alpha_dims),
+      CreateTensor(alpha_data, alpha_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidatePreluGoldens(tensors, tensors_size, expected_output_data,
@@ -93,8 +93,8 @@ void TestPreluQuantized(const int* input_dims_data, const float* input_data,
                             output_zero_point),
   };
 
-  AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+  Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                     output_zero_point);
+           output_zero_point);
 
   ValidatePreluGoldens(tensors, tensors_size, golden_quantized,
                        output_dims_count, output_data);

tensorflow/lite/micro/kernels/quantize_test.cc

@@ -43,7 +43,7 @@ void ValidateQuantizeGoldens(TfLiteTensor* tensors, int tensors_size,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
   // Use reference quantization from test utils to compare against op output.
-  AsymmetricQuantize(golden, golden_quantized, output_len, scale, zero_point);
+  Quantize(golden, golden_quantized, output_len, scale, zero_point);
   for (int i = 0; i < output_len; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(golden_quantized[i], output_data[i]);
   }
@@ -71,7 +71,7 @@ void TestQuantizeFloat(const int* input_dims_data, const float* input_data,
   // 1 input, 1 output.
   constexpr int tensors_size = 2;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
       output_tensor,
   };
 

tensorflow/lite/micro/kernels/reduce_test.cc

@@ -106,9 +106,9 @@ void TestMeanFloatInput4D(const int* input_dims_data, const float* input_data,
 
   constexpr int tensors_size = num_of_inputs + num_of_outputs;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TF_LITE_MICRO_EXPECT_EQ(
@@ -133,9 +133,9 @@ void TestReduceOpFloat(const int* input_dims_data, const float* input_data,
 
   constexpr int tensors_size = num_of_inputs + num_of_outputs;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   TF_LITE_MICRO_EXPECT_EQ(
@@ -165,15 +165,14 @@ void TestReduceOpQuantized(
   TfLiteTensor tensors[] = {
       CreateQuantizedTensor(input_data, input_data_quant, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
       CreateQuantizedTensor(output_data_quant, output_dims, output_scale,
                             output_zero_point),
   };
 
   // Quantize expected output
-  tflite::AsymmetricQuantize(expected_output_data, expected_output_data_quant,
+  tflite::Quantize(expected_output_data, expected_output_data_quant,
-                             output_dims_count, output_scale,
+                   output_dims_count, output_scale, output_zero_point);
-                             output_zero_point);
 
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteOk,
@@ -204,15 +203,14 @@ void TestMeanOpQuantized(const int* input_dims_data, const float* input_data,
   TfLiteTensor tensors[] = {
       CreateQuantizedTensor(input_data, input_data_quant, input_dims,
                             input_scale, input_zero_point),
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
       CreateQuantizedTensor(output_data_quant, output_dims, output_scale,
                             output_zero_point),
   };
 
   // Quantize expected output
-  tflite::AsymmetricQuantize(expected_output_data, expected_output_data_quant,
+  tflite::Quantize(expected_output_data, expected_output_data_quant,
-                             output_dims_count, output_scale,
+                   output_dims_count, output_scale, output_zero_point);
-                             output_zero_point);
 
   TF_LITE_MICRO_EXPECT_EQ(
       kTfLiteOk,

tensorflow/lite/micro/kernels/reshape_test.cc

@@ -121,9 +121,9 @@ void TestReshape(const int* input_dims_data, const float* input_data,
   TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
   TfLiteIntArray* shape_dims = IntArrayFromInts(shape_dims_data);
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
-  TfLiteTensor input_tensor = CreateFloatTensor(input_data, input_dims);
+  TfLiteTensor input_tensor = CreateTensor(input_data, input_dims);
-  TfLiteTensor shape_tensor = CreateInt32Tensor(shape_data, shape_dims);
+  TfLiteTensor shape_tensor = CreateTensor(shape_data, shape_dims);
-  TfLiteTensor output_tensor = CreateFloatTensor(output_data, output_dims);
+  TfLiteTensor output_tensor = CreateTensor(output_data, output_dims);
 
   TestReshapeWithShape(&input_tensor, &shape_tensor, &output_tensor,
                        expected_output, expected_output_len, expected_dims,
@@ -144,7 +144,7 @@ void TestReshapeQuantized(const int* input_dims_data, const T* input_data,
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
   TfLiteTensor input_tensor = CreateQuantizedTensor(
       input_data, input_dims, /*scale=*/1.f, /*zero_point=*/0);
-  TfLiteTensor shape_tensor = CreateInt32Tensor(shape_data, shape_dims);
+  TfLiteTensor shape_tensor = CreateTensor(shape_data, shape_dims);
   TfLiteTensor output_tensor = CreateQuantizedTensor(
       output_data, output_dims, /*scale=*/1.f, /*zero_point=*/0);
 
@@ -213,14 +213,12 @@ TF_LITE_MICRO_TEST(ReshapeWithInvalidShapeShouldFail) {
   TfLiteIntArray* input_dims =
       tflite::testing::IntArrayFromInts(input_dims_data);
   const float input_data[] = {3.0f};
-  auto input_tensor =
+  auto input_tensor = tflite::testing::CreateTensor(input_data, input_dims);
-      tflite::testing::CreateFloatTensor(input_data, input_dims);
   float output_data[4];
   int output_dims_data[6] = {2, 2, 1, 2, 2, 1};
   TfLiteIntArray* output_dims =
       tflite::testing::IntArrayFromInts(output_dims_data);
-  auto output_tensor =
+  auto output_tensor = tflite::testing::CreateTensor(output_data, output_dims);
-      tflite::testing::CreateFloatTensor(output_data, output_dims);
   const int expected_output[] = {};
   const int expected_output_len = 0;
   const int expected_dims[] = {};
@@ -328,25 +326,24 @@ TF_LITE_MICRO_TEST(ReshapeWithScalarOutputShouldSucceed) {
 // Some old models specify '[0]' as the new shape, indicating that both input
 // and output are scalars.
 TF_LITE_MICRO_TEST(ReshapeWithLegacyScalarOutputShouldSucceed) {
-  using tflite::testing::CreateFloatTensor;
+  using tflite::testing::CreateTensor;
   using tflite::testing::IntArrayFromInts;
 
   int input_dims_data[] = {1, 1};
   TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
   const float input_data[] = {3.0f};
-  auto input_tensor = CreateFloatTensor(input_data, input_dims);
+  auto input_tensor = CreateTensor(input_data, input_dims);
 
   float output_data[1];
   int output_dims_data[2] = {1, 0};
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
-  auto output_tensor = CreateFloatTensor(output_data, output_dims);
+  auto output_tensor = CreateTensor(output_data, output_dims);
 
   int shape_dims_data[] = {1, 0};
   TfLiteIntArray* shape_dims = IntArrayFromInts(shape_dims_data);
 
   const int32_t shape_data[] = {0};
-  auto shape_tensor =
+  auto shape_tensor = tflite::testing::CreateTensor(shape_data, shape_dims);
-      tflite::testing::CreateInt32Tensor(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};

tensorflow/lite/micro/kernels/resize_nearest_neighbor_test.cc

@@ -27,7 +27,7 @@ using uint8_t = std::uint8_t;
 using int32_t = std::int32_t;
 
 TfLiteTensor TestCreateTensor(const float* data, TfLiteIntArray* dims) {
-  return CreateFloatTensor(data, dims);
+  return CreateTensor(data, dims);
 }
 
 TfLiteTensor TestCreateTensor(const uint8_t* data, TfLiteIntArray* dims) {
@@ -59,7 +59,7 @@ void TestResizeNearestNeighbor(const int* input_dims_data, const T* input_data,
   constexpr int tensors_size = 3;
   TfLiteTensor tensors[tensors_size] = {
       TestCreateTensor(input_data, input_dims),
-      CreateInt32Tensor(expected_size_data, expected_size_dims),
+      CreateTensor(expected_size_data, expected_size_dims),
       TestCreateTensor(output_data, output_dims),
   };
 

tensorflow/lite/micro/kernels/round_test.cc

@@ -33,8 +33,8 @@ void TestRound(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};

tensorflow/lite/micro/kernels/shape_test.cc

@@ -55,8 +55,8 @@ void TestShape(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(output_data, output_dims, true),
+      CreateTensor(output_data, output_dims, true),
   };
 
   ValidateShape(tensors, tensors_size, output_data, expected_output_data,

tensorflow/lite/micro/kernels/softmax_test.cc

@@ -281,8 +281,8 @@ void TestSoftmaxFloat(const int* input_dims_data, const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateSoftmaxGoldens(tensors, tensors_size, output_data,
@@ -310,8 +310,8 @@ void TestSoftmaxQuantized(const int* input_dims_data, const float* input_data,
                             output_zero_point),
   };
 
-  AsymmetricQuantize(golden, golden_quantized, output_dims_count, output_scale,
+  Quantize(golden, golden_quantized, output_dims_count, output_scale,
-                     output_zero_point);
+           output_zero_point);
 
   ValidateSoftmaxGoldens(tensors, tensors_size, output_data, golden_quantized,
                          output_dims_count, tolerance);

tensorflow/lite/micro/kernels/split_test.cc

@@ -42,10 +42,9 @@ void TestSplitTwoOutputsFloat(
   constexpr int axis_size = 1;
   constexpr int tensors_size = input_size + output_size + axis_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims), CreateTensor(input_data, input_dims),
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(output1_data, output1_dims),
-      CreateFloatTensor(output1_data, output1_dims),
+      CreateTensor(output2_data, output2_dims)};
-      CreateFloatTensor(output2_data, output2_dims)};
 
   // Currently only support constant axis tensor.
   tensors[0].allocation_type = kTfLiteMmapRo;
@@ -104,12 +103,12 @@ void TestSplitFourOutputsFloat(
   constexpr int axis_size = 1;
   constexpr int tensors_size = input_size + output_size + axis_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output1_data, output1_dims),
+      CreateTensor(output1_data, output1_dims),
-      CreateFloatTensor(output2_data, output2_dims),
+      CreateTensor(output2_data, output2_dims),
-      CreateFloatTensor(output3_data, output1_dims),
+      CreateTensor(output3_data, output1_dims),
-      CreateFloatTensor(output4_data, output1_dims)};
+      CreateTensor(output4_data, output1_dims)};
 
   // Currently only support constant axis tensor.
   tensors[0].allocation_type = kTfLiteMmapRo;
@@ -171,7 +170,7 @@ void TestSplitTwoOutputsQuantized(
   constexpr int axis_size = 1;
   constexpr int tensors_size = input_size + output_size + axis_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims),
       CreateQuantizedTensor(input_data, input_dims, 0, 10),
       CreateQuantizedTensor(output1_data, output1_dims, 0, 10),
       CreateQuantizedTensor(output2_data, output2_dims, 0, 10)};
@@ -227,10 +226,9 @@ void TestSplitTwoOutputsQuantized32(
   constexpr int axis_size = 1;
   constexpr int tensors_size = input_size + output_size + axis_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(axis_data, axis_dims),
+      CreateTensor(axis_data, axis_dims), CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(input_data, input_dims),
+      CreateTensor(output1_data, output1_dims),
-      CreateInt32Tensor(output1_data, output1_dims),
+      CreateTensor(output2_data, output2_dims)};
-      CreateInt32Tensor(output2_data, output2_dims)};
 
   // Currently only support constant axis tensor.
   tensors[0].allocation_type = kTfLiteMmapRo;

tensorflow/lite/micro/kernels/split_v_test.cc

@@ -63,13 +63,13 @@ void TestSplitVFloat(const int* input_dims_data, const float* input_data,
   // then come outputs
 
   TfLiteTensor tensors[tensors_size];
-  tensors[0] = CreateFloatTensor(input_data, input_dims);
+  tensors[0] = CreateTensor(input_data, input_dims);
-  tensors[1] = CreateInt32Tensor(split_data, split_dims);
+  tensors[1] = CreateTensor(split_data, split_dims);
-  tensors[2] = CreateInt32Tensor(axis_data, axis_dims);
+  tensors[2] = CreateTensor(axis_data, axis_dims);
 
   // add output tensors
   for (int i = 0; i < N; i++)
-    tensors[3 + i] = CreateFloatTensor(output_tensors.data[i], output_dims[i]);
+    tensors[3 + i] = CreateTensor(output_tensors.data[i], output_dims[i]);
 
   tensors[2].allocation_type = kTfLiteMmapRo;
   tensors[1].allocation_type = kTfLiteMmapRo;

tensorflow/lite/micro/kernels/strided_slice_test.cc

@@ -74,11 +74,11 @@ void TestStridedSliceFloat(const int* input_shape, const int* begin_shape,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(begin_data, begin_dims),
+      CreateTensor(begin_data, begin_dims),
-      CreateInt32Tensor(end_data, end_dims),
+      CreateTensor(end_data, end_dims),
-      CreateInt32Tensor(strides_data, strides_dims),
+      CreateTensor(strides_data, strides_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateStridedSliceGoldens(tensors, tensors_size, expected_output,
@@ -106,9 +106,9 @@ void TestStridedSliceQuantized(
       std::numeric_limits<T>::max() + std::numeric_limits<T>::min() / 2;
   TfLiteTensor tensors[tensors_size] = {
       CreateQuantizedTensor(input_data, input_dims, 1.0, zero_point),
-      CreateInt32Tensor(begin_data, begin_dims),
+      CreateTensor(begin_data, begin_dims),
-      CreateInt32Tensor(end_data, end_dims),
+      CreateTensor(end_data, end_dims),
-      CreateInt32Tensor(strides_data, strides_dims),
+      CreateTensor(strides_data, strides_dims),
       CreateQuantizedTensor(output_data, output_dims, 1.0, zero_point),
   };
 

tensorflow/lite/micro/kernels/sub_test.cc

@@ -99,9 +99,9 @@ void TestSubFloat(const int* input1_dims_data, const float* input1_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input1_data, input1_dims),
+      CreateTensor(input1_data, input1_dims),
-      CreateFloatTensor(input2_data, input2_dims),
+      CreateTensor(input2_data, input2_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateSubGoldens(tensors, tensors_size, expected_output, output_data,
@@ -135,9 +135,8 @@ void TestSubQuantized(const int* input1_dims_data, const float* input1_data,
       tflite::testing::CreateQuantizedTensor(output_data, output_dims,
                                              output_scale, output_zero_point),
   };
-  tflite::AsymmetricQuantize(golden, golden_quantized,
+  tflite::Quantize(golden, golden_quantized, ElementCount(*output_dims),
-                             ElementCount(*output_dims), output_scale,
+                   output_scale, output_zero_point);
-                             output_zero_point);
 
   ValidateSubGoldens(tensors, tensors_size, golden_quantized, output_data,
                      ElementCount(*output_dims), activation);

tensorflow/lite/micro/kernels/svdf_test.cc

@@ -565,13 +565,13 @@ void TestSVDF(const int batch_size, const int num_units, const int input_size,
 
   const int tensor_count = 6;  // 5 inputs, 1 output
   TfLiteTensor tensors[] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(feature_weights_data, feature_weights_dims),
+      CreateTensor(feature_weights_data, feature_weights_dims),
-      CreateFloatTensor(time_weights_data, time_weights_dims),
+      CreateTensor(time_weights_data, time_weights_dims),
-      CreateFloatTensor(bias_data, bias_dims),
+      CreateTensor(bias_data, bias_dims),
-      CreateFloatTensor(activation_state_data, activation_state_dims,
+      CreateTensor(activation_state_data, activation_state_dims,
-                        /*is_variable=*/true),
+                   /*is_variable=*/true),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   ValidateSVDFGoldens(batch_size, num_units, input_size, rank, tensors,
@@ -640,12 +640,10 @@ inline void TestIntegerSVDF(
       CreateQuantizedTensor(output_data, output_dims, output_scale,
                             output_zero_point)};
 
-  tflite::AsymmetricQuantize(golden_output, golden_output_quantized,
+  tflite::Quantize(golden_output, golden_output_quantized, golden_output_len,
-                             golden_output_len, output_scale,
+                   output_scale, output_zero_point);
-                             output_zero_point);
+  tflite::Quantize(input_sequences_data, input_sequences_quantized,
-  tflite::AsymmetricQuantize(input_sequences_data, input_sequences_quantized,
+                   input_sequences_len, input_scale, input_zero_point);
-                             input_sequences_len, input_scale,
-                             input_zero_point);
 
   ValidateSVDFGoldens(batch_size, num_units, input_size, rank, tensors,
                       tensor_count, activation, input_sequences_quantized,

tensorflow/lite/micro/kernels/tanh_test.cc

@@ -77,8 +77,8 @@ void TestTanhFloat(const int input_dims_data[], const float* input_data,
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output_data, output_dims),
+      CreateTensor(output_data, output_dims),
   };
 
   int inputs_array_data[] = {1, 0};
@@ -113,9 +113,8 @@ void TestTanhQuantized(const int input_dims_data[], const float* input_data,
   TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
   const int output_elements_count = ElementCount(*output_dims);
 
-  tflite::AsymmetricQuantize(expected_output_data, expected_output_quantized,
+  tflite::Quantize(expected_output_data, expected_output_quantized,
-                             output_elements_count, output_scale,
+                   output_elements_count, output_scale, output_zero_point);
-                             output_zero_point);
 
   constexpr int inputs_size = 1;
   constexpr int outputs_size = 1;

tensorflow/lite/micro/kernels/unpack_test.cc

@@ -41,10 +41,10 @@ void TestUnpackThreeOutputsFloat(
   constexpr int output_size = 3;
   constexpr int tensors_size = input_size + output_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateFloatTensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateFloatTensor(output1_data, output1_dims),
+      CreateTensor(output1_data, output1_dims),
-      CreateFloatTensor(output2_data, output2_dims),
+      CreateTensor(output2_data, output2_dims),
-      CreateFloatTensor(output3_data, output3_dims)};
+      CreateTensor(output3_data, output3_dims)};
 
   // Place a unique value in the uninitialized output buffer.
   for (int i = 0; i < output1_dims_count; ++i) {
@@ -102,9 +102,8 @@ void TestUnpackOneOutputFloat(const int* input_dims_data,
   constexpr int input_size = 1;
   constexpr int output_size = 1;
   constexpr int tensors_size = input_size + output_size;
-  TfLiteTensor tensors[tensors_size] = {
+  TfLiteTensor tensors[tensors_size] = {CreateTensor(input_data, input_dims),
-      CreateFloatTensor(input_data, input_dims),
+                                        CreateTensor(output_data, output_dims)};
-      CreateFloatTensor(output_data, output_dims)};
 
   // Place a unique value in the uninitialized output buffer.
   for (int i = 0; i < output_dims_count; ++i) {
@@ -222,10 +221,10 @@ void TestUnpackThreeOutputsQuantized32(
   constexpr int output_size = 3;
   constexpr int tensors_size = input_size + output_size;
   TfLiteTensor tensors[tensors_size] = {
-      CreateInt32Tensor(input_data, input_dims),
+      CreateTensor(input_data, input_dims),
-      CreateInt32Tensor(output1_data, output1_dims),
+      CreateTensor(output1_data, output1_dims),
-      CreateInt32Tensor(output2_data, output2_dims),
+      CreateTensor(output2_data, output2_dims),
-      CreateInt32Tensor(output3_data, output3_dims)};
+      CreateTensor(output3_data, output3_dims)};
 
   // Place a unique value in the uninitialized output buffer.
   for (int i = 0; i < output1_dims_count; ++i) {

tensorflow/lite/micro/memory_helpers_test.cc

@@ -180,11 +180,11 @@ TF_LITE_MICRO_TEST(TestAllocateOutputDimensionsFromInput) {
   const int input1_dims[] = {1, 1};
   const int input2_dims[] = {kDimsLen, 5, 5, 5, 5};
   int output_dims[] = {0, 0, 0, 0, 0};
-  TfLiteTensor input_tensor1 = tflite::testing::CreateInt32Tensor(
+  TfLiteTensor input_tensor1 = tflite::testing::CreateTensor<int32_t>(
       nullptr, tflite::testing::IntArrayFromInts(input1_dims));
-  TfLiteTensor input_tensor2 = tflite::testing::CreateInt32Tensor(
+  TfLiteTensor input_tensor2 = tflite::testing::CreateTensor<int32_t>(
       nullptr, tflite::testing::IntArrayFromInts(input2_dims));
-  TfLiteTensor output_tensor = tflite::testing::CreateInt32Tensor(
+  TfLiteTensor output_tensor = tflite::testing::CreateTensor<int32_t>(
       nullptr, tflite::testing::IntArrayFromInts(output_dims));
   TfLiteContext context;
   // Only need to allocate space for output_tensor.dims.  Use a simple

tensorflow/lite/micro/micro_utils.cc

@@ -15,34 +15,15 @@ limitations under the License.
 
 #include "tensorflow/lite/micro/micro_utils.h"
 
-#include <limits.h>
+#include <cmath>
-#include <math.h>
+#include <cstdint>
-#include <stdint.h>
+#include <limits>
 
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/op_macros.h"
 
 namespace tflite {
 
-namespace {
-
-static const uint8_t kAsymmetricUInt8Min = 0;
-static const uint8_t kAsymmetricUInt8Max = UINT8_MAX;
-static const uint8_t kSymmetricUInt8Min = 1;
-static const uint8_t kSymmetricUInt8Max = UINT8_MAX;
-static const int8_t kAsymmetricInt8Min = INT8_MIN;
-static const int8_t kAsymmetricInt8Max = INT8_MAX;
-static const int kSymmetricInt8Scale = kAsymmetricInt8Max;
-
-static const int16_t kAsymmetricInt16Min = INT16_MIN;
-static const int16_t kAsymmetricInt16Max = INT16_MAX;
-static const int kSymmetricInt16Scale = kAsymmetricInt16Max;
-
-static const int32_t kAsymmetricInt32Max = INT32_MAX;
-static const int kSymmetricInt32Scale = kAsymmetricInt32Max;
-
-}  // namespace
-
 int ElementCount(const TfLiteIntArray& dims) {
   int result = 1;
   for (int i = 0; i < dims.size; ++i) {
@@ -51,109 +32,6 @@ int ElementCount(const TfLiteIntArray& dims) {
   return result;
 }
 
-// Converts a float value into an unsigned eight-bit quantized value.
-uint8_t FloatToAsymmetricQuantizedUInt8(const float value, const float scale,
-                                        const int zero_point) {
-  int32_t result = round(value / scale) + zero_point;
-  if (result < kAsymmetricUInt8Min) {
-    result = kAsymmetricUInt8Min;
-  }
-  if (result > kAsymmetricUInt8Max) {
-    result = kAsymmetricUInt8Max;
-  }
-  return result;
-}
-
-uint8_t FloatToSymmetricQuantizedUInt8(const float value, const float scale) {
-  int32_t result = round(value / scale);
-  if (result < kSymmetricUInt8Min) {
-    result = kSymmetricUInt8Min;
-  }
-  if (result > kSymmetricUInt8Max) {
-    result = kSymmetricUInt8Max;
-  }
-  return result;
-}
-
-int8_t FloatToAsymmetricQuantizedInt8(const float value, const float scale,
-                                      const int zero_point) {
-  int32_t result = round(value / scale) + zero_point;
-  if (result < kAsymmetricInt8Min) {
-    result = kAsymmetricInt8Min;
-  }
-  if (result > kAsymmetricInt8Max) {
-    result = kAsymmetricInt8Max;
-  }
-  return result;
-}
-
-int16_t FloatToAsymmetricQuantizedInt16(const float value, const float scale,
-                                        const int zero_point) {
-  int32_t result = round(value / scale) + zero_point;
-  if (result < kAsymmetricInt16Min) {
-    result = kAsymmetricInt16Min;
-  }
-  if (result > kAsymmetricInt16Max) {
-    result = kAsymmetricInt16Max;
-  }
-  return result;
-}
-
-int8_t FloatToSymmetricQuantizedInt8(const float value, const float scale) {
-  return FloatToAsymmetricQuantizedInt8(value, scale, 0.0f);
-}
-
-int32_t FloatToSymmetricQuantizedInt32(const float value, const float scale) {
-  float quantized = round(value / scale);
-  if (static_cast<int>(quantized) > INT_MAX) {
-    quantized = static_cast<float>(INT_MAX);
-  } else if (quantized < INT_MIN) {
-    quantized = static_cast<float> INT_MIN;
-  }
-
-  return static_cast<int>(quantized);
-}
-
-void AsymmetricQuantize(const float* input, int8_t* output, int num_elements,
-                        float scale, int zero_point) {
-  for (int i = 0; i < num_elements; i++) {
-    output[i] = FloatToAsymmetricQuantizedInt8(input[i], scale, zero_point);
-  }
-}
-
-void AsymmetricQuantize(const float* input, uint8_t* output, int num_elements,
-                        float scale, int zero_point) {
-  for (int i = 0; i < num_elements; i++) {
-    output[i] = FloatToAsymmetricQuantizedUInt8(input[i], scale, zero_point);
-  }
-}
-
-void AsymmetricQuantize(const float* input, int16_t* output, int num_elements,
-                        float scale, int zero_point) {
-  for (int i = 0; i < num_elements; i++) {
-    output[i] = FloatToAsymmetricQuantizedInt16(input[i], scale, zero_point);
-  }
-}
-
-void SymmetricQuantize(const float* input, int32_t* output, int num_elements,
-                       float scale) {
-  for (int i = 0; i < num_elements; i++) {
-    output[i] = FloatToSymmetricQuantizedInt32(input[i], scale);
-  }
-}
-
-void SymmetricPerChannelQuantize(const float* input, int32_t* output,
-                                 int num_elements, int num_channels,
-                                 float* scales) {
-  int elements_per_channel = num_elements / num_channels;
-  for (int i = 0; i < num_channels; i++) {
-    for (int j = 0; j < elements_per_channel; j++) {
-      output[i * elements_per_channel + j] = FloatToSymmetricQuantizedInt32(
-          input[i * elements_per_channel + j], scales[i]);
-    }
-  }
-}
-
 void SignedSymmetricPerChannelQuantize(const float* values,
                                        TfLiteIntArray* dims,
                                        int quantized_dimension,
@@ -186,94 +64,17 @@ void SignedSymmetricPerChannelQuantize(const float* values,
       max = fmaxf(max, values[idx]);
     }
     scaling_factors[channel] =
-        fmaxf(fabs(min), fabs(max)) / kSymmetricInt8Scale;
+        fmaxf(fabs(min), fabs(max)) / std::numeric_limits<int8_t>::max();
     for (int i = 0; i < per_channel_size; i++) {
       int idx = channel * channel_stride + i * stride;
       const int32_t quantized_value =
           static_cast<int32_t>(roundf(values[idx] / scaling_factors[channel]));
       // Clamp: just in case some odd numeric offset.
-      quantized_values[idx] = fminf(
+      quantized_values[idx] =
-          kSymmetricInt8Scale, fmaxf(-kSymmetricInt8Scale, quantized_value));
+          fminf(std::numeric_limits<int8_t>::max(),
+                fmaxf(std::numeric_limits<int8_t>::min() + 1, quantized_value));
     }
   }
 }
 
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
-                             int8_t* quantized_values, float* scaling_factor) {
-  int input_size = ElementCount(*dims);
-
-  float min = 0;
-  float max = 0;
-  for (int i = 0; i < input_size; i++) {
-    min = fminf(min, values[i]);
-    max = fmaxf(max, values[i]);
-  }
-  *scaling_factor = fmaxf(fabs(min), fabs(max)) / kSymmetricInt8Scale;
-  for (int i = 0; i < input_size; i++) {
-    const int32_t quantized_value =
-        static_cast<int32_t>(roundf(values[i] / *scaling_factor));
-    // Clamp: just in case some odd numeric offset.
-    quantized_values[i] = fminf(kSymmetricInt8Scale,
-                                fmaxf(-kSymmetricInt8Scale, quantized_value));
-  }
-}
-
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
-                             int16_t* quantized_values, float* scaling_factor) {
-  int input_size = ElementCount(*dims);
-
-  float min = 0;
-  float max = 0;
-  for (int i = 0; i < input_size; i++) {
-    min = fminf(min, values[i]);
-    max = fmaxf(max, values[i]);
-  }
-  *scaling_factor = fmaxf(fabs(min), fabs(max)) / kSymmetricInt16Scale;
-  for (int i = 0; i < input_size; i++) {
-    const int32_t quantized_value =
-        static_cast<int32_t>(roundf(values[i] / *scaling_factor));
-    // Clamp: just in case some odd numeric offset.
-    quantized_values[i] = fminf(kSymmetricInt16Scale,
-                                fmaxf(-kSymmetricInt16Scale, quantized_value));
-  }
-}
-
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
-                             int32_t* quantized_values, float* scaling_factor) {
-  int input_size = ElementCount(*dims);
-
-  float min = 0;
-  float max = 0;
-  for (int i = 0; i < input_size; i++) {
-    min = fminf(min, values[i]);
-    max = fmaxf(max, values[i]);
-  }
-
-  *scaling_factor =
-      fmaxf(fabs(min), fabs(max)) / static_cast<float>(kSymmetricInt32Scale);
-  for (int i = 0; i < input_size; i++) {
-    const int32_t quantized_value =
-        static_cast<int32_t>(roundf(values[i] / *scaling_factor));
-    // Clamp: just in case some odd numeric offset.
-    quantized_values[i] = fminf(
-        static_cast<float>(kSymmetricInt32Scale),
-        fmaxf(static_cast<float>(-kSymmetricInt32Scale), quantized_value));
-  }
-}
-
-void SymmetricQuantize(const float* values, TfLiteIntArray* dims,
-                       uint8_t* quantized_values, float* scaling_factor) {
-  SignedSymmetricQuantize(values, dims,
-                          reinterpret_cast<int8_t*>(quantized_values),
-                          scaling_factor);
-}
-
-void SymmetricDequantize(const int8_t* values, const int size,
-                         const float dequantization_scale,
-                         float* dequantized_values) {
-  for (int i = 0; i < size; ++i) {
-    dequantized_values[i] = values[i] * dequantization_scale;
-  }
-}
-
 }  // namespace tflite

tensorflow/lite/micro/micro_utils.h

@@ -16,7 +16,9 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_
 #define TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_
 
-#include <stdint.h>
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
 
 #include "tensorflow/lite/c/common.h"
 
@@ -26,23 +28,28 @@ namespace tflite {
 
 int ElementCount(const TfLiteIntArray& dims);
 
-uint8_t FloatToAsymmetricQuantizedUInt8(const float value, const float scale,
+// Converts a float value into a quantized value.  Note that large values (close
-                                        const int zero_point);
+// to max int and min int) may see significant error due to a lack of floating
+// point granularity for large values.
+template <typename T>
+T FloatToQuantizedType(const float value, const float scale, int zero_point) {
+  int32_t result = round(value / scale) + zero_point;
+  result =
+      std::max(static_cast<int32_t>(std::numeric_limits<T>::min()), result);
+  result =
+      std::min(static_cast<int32_t>(std::numeric_limits<T>::max()), result);
+  return result;
+}
 
-uint8_t FloatToSymmetricQuantizedUInt8(const float value, const float scale);
+template <typename T>
-
+T FloatToSymmetricQuantizedType(const float value, const float scale) {
-int8_t FloatToAsymmetricQuantizedInt8(const float value, const float scale,
+  int32_t result = round(value / scale);
-                                      const int zero_point);
+  result =
-
+      std::max(static_cast<int32_t>(std::numeric_limits<T>::min() + 1), result);
-int16_t FloatToAsymmetricQuantizedInt16(const float value, const float scale,
+  result =
-                                        const int zero_point);
+      std::min(static_cast<int32_t>(std::numeric_limits<T>::max()), result);
-
+  return result;
-int8_t FloatToSymmetricQuantizedInt8(const float value, const float scale);
+}
-
-// Converts a float value into a signed thirty-two-bit quantized value.  Note
-// that values close to max int and min int may see significant error due to
-// a lack of floating point granularity for large values.
-int32_t FloatToSymmetricQuantizedInt32(const float value, const float scale);
 
 // Helper methods to quantize arrays of floats to the desired format.
 //
@@ -55,22 +62,34 @@ int32_t FloatToSymmetricQuantizedInt32(const float value, const float scale);
 //
 // The per-op quantization spec can be found here:
 // https://www.tensorflow.org/lite/performance/quantization_spec
+template <typename T>
+void Quantize(const float* input, T* output, int num_elements, float scale,
+              int zero_point) {
+  for (int i = 0; i < num_elements; i++) {
+    output[i] = FloatToQuantizedType<T>(input[i], scale, zero_point);
+  }
+}
 
-void AsymmetricQuantize(const float* input, int8_t* output, int num_elements,
+template <typename T>
-                        float scale, int zero_point = 0);
+void SymmetricQuantize(const float* input, T* output, int num_elements,
+                       float scale) {
+  for (int i = 0; i < num_elements; i++) {
+    output[i] = FloatToSymmetricQuantizedType<T>(input[i], scale);
+  }
+}
 
-void AsymmetricQuantize(const float* input, uint8_t* output, int num_elements,
+template <typename T>
-                        float scale, int zero_point = 128);
+void SymmetricPerChannelQuantize(const float* input, T* output,
-
-void AsymmetricQuantize(const float* input, int16_t* output, int num_elements,
-                        float scale, int zero_point = 0);
-
-void SymmetricQuantize(const float* input, int32_t* output, int num_elements,
-                       float scale);
-
-void SymmetricPerChannelQuantize(const float* input, int32_t* output,
                                  int num_elements, int num_channels,
-                                 float* scales);
+                                 float* scales) {
+  int elements_per_channel = num_elements / num_channels;
+  for (int i = 0; i < num_channels; i++) {
+    for (int j = 0; j < elements_per_channel; j++) {
+      output[i * elements_per_channel + j] = FloatToSymmetricQuantizedType<T>(
+          input[i * elements_per_channel + j], scales[i]);
+    }
+  }
+}
 
 void SignedSymmetricPerChannelQuantize(const float* values,
                                        TfLiteIntArray* dims,
@@ -78,30 +97,35 @@ void SignedSymmetricPerChannelQuantize(const float* values,
                                        int8_t* quantized_values,
                                        float* scaling_factor);
 
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+// Quantizes inputs based on the values provided, choosing the smallest range
-                             int8_t* quantized_values, float* scaling_factor);
+// which includes all input values.
+template <typename T>
+void SymmetricQuantizeCalculateScales(const float* values, TfLiteIntArray* dims,
+                                      T* output, float* scale) {
+  int input_size = ElementCount(*dims);
 
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+  float min = 0;
-                             int16_t* quantized_values, float* scaling_factor);
+  float max = 0;
-
+  for (int i = 0; i < input_size; i++) {
-void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+    min = fminf(min, values[i]);
-                             int32_t* quantized_values, float* scaling_factor);
+    max = fmaxf(max, values[i]);
-
+  }
-void SymmetricQuantize(const float* values, TfLiteIntArray* dims,
+  *scale = fmaxf(std::abs(min), std::abs(max)) / std::numeric_limits<T>::max();
-                       uint8_t* quantized_values, float* scaling_factor);
+  for (int i = 0; i < input_size; i++) {
-
+    const int32_t quantized_value =
-void SymmetricDequantize(const int8_t* values, const int size,
+        static_cast<int32_t>(roundf(values[i] / *scale));
-                         const float dequantization_scale,
+    // Clamp: just in case some odd numeric offset.
-                         float* dequantized_values);
+    quantized_value = fminf(std::numeric_limits<T>::max(), quantized_value);
+    quantized_value = fmaxf(std::numeric_limits<T>::min() + 1, quantized_value);
+    output[i] = quantized_value;
+  }
+}
 
 template <typename T>
-void AsymmetricDequantize(const T* values, const int size,
+void Dequantize(const T* values, const int size, const float scale,
-                          const float dequantization_scale,
+                int zero_point, float* dequantized_values) {
-                          int dequantization_zero_point,
-                          float* dequantized_values) {
   for (int i = 0; i < size; ++i) {
-    dequantized_values[i] =
+    dequantized_values[i] = (values[i] - zero_point) * scale;
-        (values[i] - dequantization_zero_point) * dequantization_scale;
   }
 }
 

tensorflow/lite/micro/micro_utils_test.cc

@@ -20,63 +20,68 @@ limitations under the License.
 TF_LITE_MICRO_TESTS_BEGIN
 
 TF_LITE_MICRO_TEST(FloatToAsymmetricQuantizedUInt8Test) {
-  using tflite::FloatToAsymmetricQuantizedUInt8;
+  using tflite::FloatToQuantizedType;
   // [0, 127.5] -> zero_point=0, scale=0.5
-  TF_LITE_MICRO_EXPECT_EQ(0, FloatToAsymmetricQuantizedUInt8(0, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(0, FloatToQuantizedType<uint8_t>(0, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(254, FloatToAsymmetricQuantizedUInt8(127, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(254, FloatToQuantizedType<uint8_t>(127, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(255, FloatToAsymmetricQuantizedUInt8(127.5, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(255, FloatToQuantizedType<uint8_t>(127.5, 0.5, 0));
   // [-10, 245] -> zero_point=10, scale=1.0
-  TF_LITE_MICRO_EXPECT_EQ(0, FloatToAsymmetricQuantizedUInt8(-10, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(0, FloatToQuantizedType<uint8_t>(-10, 1.0, 10));
-  TF_LITE_MICRO_EXPECT_EQ(1, FloatToAsymmetricQuantizedUInt8(-9, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(1, FloatToQuantizedType<uint8_t>(-9, 1.0, 10));
-  TF_LITE_MICRO_EXPECT_EQ(128, FloatToAsymmetricQuantizedUInt8(118, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(128, FloatToQuantizedType<uint8_t>(118, 1.0, 10));
-  TF_LITE_MICRO_EXPECT_EQ(253, FloatToAsymmetricQuantizedUInt8(243, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(253, FloatToQuantizedType<uint8_t>(243, 1.0, 10));
-  TF_LITE_MICRO_EXPECT_EQ(254, FloatToAsymmetricQuantizedUInt8(244, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(254, FloatToQuantizedType<uint8_t>(244, 1.0, 10));
-  TF_LITE_MICRO_EXPECT_EQ(255, FloatToAsymmetricQuantizedUInt8(245, 1.0, 10));
+  TF_LITE_MICRO_EXPECT_EQ(255, FloatToQuantizedType<uint8_t>(245, 1.0, 10));
 }
 
 TF_LITE_MICRO_TEST(FloatToAsymmetricQuantizedInt8Test) {
-  using tflite::FloatToAsymmetricQuantizedInt8;
+  using tflite::FloatToQuantizedType;
   // [-64, 63.5] -> zero_point=0, scale=0.5
-  TF_LITE_MICRO_EXPECT_EQ(2, FloatToAsymmetricQuantizedInt8(1, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(2, FloatToQuantizedType<int8_t>(1, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(4, FloatToAsymmetricQuantizedInt8(2, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(4, FloatToQuantizedType<int8_t>(2, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(6, FloatToAsymmetricQuantizedInt8(3, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(6, FloatToQuantizedType<int8_t>(3, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(-10, FloatToAsymmetricQuantizedInt8(-5, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(-10, FloatToQuantizedType<int8_t>(-5, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(-128, FloatToAsymmetricQuantizedInt8(-64, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(-128, FloatToQuantizedType<int8_t>(-64, 0.5, 0));
-  TF_LITE_MICRO_EXPECT_EQ(127, FloatToAsymmetricQuantizedInt8(63.5, 0.5, 0));
+  TF_LITE_MICRO_EXPECT_EQ(127, FloatToQuantizedType<int8_t>(63.5, 0.5, 0));
   // [-127, 128] -> zero_point=-1, scale=1.0
-  TF_LITE_MICRO_EXPECT_EQ(0, FloatToAsymmetricQuantizedInt8(1, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(0, FloatToQuantizedType<int8_t>(1, 1.0, -1));
-  TF_LITE_MICRO_EXPECT_EQ(-1, FloatToAsymmetricQuantizedInt8(0, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(-1, FloatToQuantizedType<int8_t>(0, 1.0, -1));
-  TF_LITE_MICRO_EXPECT_EQ(126, FloatToAsymmetricQuantizedInt8(127, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(126, FloatToQuantizedType<int8_t>(127, 1.0, -1));
-  TF_LITE_MICRO_EXPECT_EQ(127, FloatToAsymmetricQuantizedInt8(128, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(127, FloatToQuantizedType<int8_t>(128, 1.0, -1));
-  TF_LITE_MICRO_EXPECT_EQ(-127, FloatToAsymmetricQuantizedInt8(-126, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(-127, FloatToQuantizedType<int8_t>(-126, 1.0, -1));
-  TF_LITE_MICRO_EXPECT_EQ(-128, FloatToAsymmetricQuantizedInt8(-127, 1.0, -1));
+  TF_LITE_MICRO_EXPECT_EQ(-128, FloatToQuantizedType<int8_t>(-127, 1.0, -1));
 }
 
 TF_LITE_MICRO_TEST(FloatToSymmetricQuantizedInt8Test) {
-  using tflite::FloatToSymmetricQuantizedInt8;
+  using tflite::FloatToSymmetricQuantizedType;
   // [-64, 63.5] -> zero_point=0, scale=0.5
-  TF_LITE_MICRO_EXPECT_EQ(2, FloatToSymmetricQuantizedInt8(1, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(2, FloatToSymmetricQuantizedType<int8_t>(1, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(4, FloatToSymmetricQuantizedInt8(2, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(4, FloatToSymmetricQuantizedType<int8_t>(2, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(6, FloatToSymmetricQuantizedInt8(3, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(6, FloatToSymmetricQuantizedType<int8_t>(3, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(-10, FloatToSymmetricQuantizedInt8(-5, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(-10, FloatToSymmetricQuantizedType<int8_t>(-5, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(-128, FloatToSymmetricQuantizedInt8(-64, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(-127,
-  TF_LITE_MICRO_EXPECT_EQ(127, FloatToSymmetricQuantizedInt8(63.5, 0.5));
+                          FloatToSymmetricQuantizedType<int8_t>(-64, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(127,
+                          FloatToSymmetricQuantizedType<int8_t>(63.5, 0.5));
   // [-127, 128] -> zero_point=-1, scale=1.0
-  TF_LITE_MICRO_EXPECT_EQ(1, FloatToSymmetricQuantizedInt8(1, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(1, FloatToSymmetricQuantizedType<int8_t>(1, 1.0));
-  TF_LITE_MICRO_EXPECT_EQ(0, FloatToSymmetricQuantizedInt8(0, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(0, FloatToSymmetricQuantizedType<int8_t>(0, 1.0));
-  TF_LITE_MICRO_EXPECT_EQ(127, FloatToSymmetricQuantizedInt8(127, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(127, FloatToSymmetricQuantizedType<int8_t>(127, 1.0));
-  TF_LITE_MICRO_EXPECT_EQ(127, FloatToSymmetricQuantizedInt8(128, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(127, FloatToSymmetricQuantizedType<int8_t>(128, 1.0));
-  TF_LITE_MICRO_EXPECT_EQ(-126, FloatToSymmetricQuantizedInt8(-126, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(-126,
-  TF_LITE_MICRO_EXPECT_EQ(-127, FloatToSymmetricQuantizedInt8(-127, 1.0));
+                          FloatToSymmetricQuantizedType<int8_t>(-126, 1.0));
+  TF_LITE_MICRO_EXPECT_EQ(-127,
+                          FloatToSymmetricQuantizedType<int8_t>(-127, 1.0));
 }
 
 TF_LITE_MICRO_TEST(FloatToAsymmetricQuantizedInt32Test) {
-  using tflite::FloatToSymmetricQuantizedInt32;
+  using tflite::FloatToSymmetricQuantizedType;
-  TF_LITE_MICRO_EXPECT_EQ(0, FloatToSymmetricQuantizedInt32(0, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(0, FloatToSymmetricQuantizedType<int32_t>(0, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(2, FloatToSymmetricQuantizedInt32(1, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(2, FloatToSymmetricQuantizedType<int32_t>(1, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(-2, FloatToSymmetricQuantizedInt32(-1, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(-2, FloatToSymmetricQuantizedType<int32_t>(-1, 0.5));
-  TF_LITE_MICRO_EXPECT_EQ(-100, FloatToSymmetricQuantizedInt32(-50, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(-100,
-  TF_LITE_MICRO_EXPECT_EQ(100, FloatToSymmetricQuantizedInt32(50, 0.5));
+                          FloatToSymmetricQuantizedType<int32_t>(-50, 0.5));
+  TF_LITE_MICRO_EXPECT_EQ(100, FloatToSymmetricQuantizedType<int32_t>(50, 0.5));
 }
 
 TF_LITE_MICRO_TEST(AsymmetricQuantizeInt8) {
@@ -84,7 +89,7 @@ TF_LITE_MICRO_TEST(AsymmetricQuantizeInt8) {
   int8_t goldens[] = {-20, -5, -3, -3, -1, 1, 3, 5, 7, 9};
   constexpr int length = sizeof(values) / sizeof(float);
   int8_t quantized[length];
-  tflite::AsymmetricQuantize(values, quantized, length, 0.5, 1);
+  tflite::Quantize(values, quantized, length, 0.5, 1);
   for (int i = 0; i < length; i++) {
     TF_LITE_MICRO_EXPECT_EQ(quantized[i], goldens[i]);
   }
@@ -95,7 +100,7 @@ TF_LITE_MICRO_TEST(AsymmetricQuantizeUInt8) {
   uint8_t goldens[] = {106, 121, 123, 123, 125, 127, 129, 131, 133, 135};
   constexpr int length = sizeof(values) / sizeof(float);
   uint8_t quantized[length];
-  tflite::AsymmetricQuantize(values, quantized, length, 0.5, 127);
+  tflite::Quantize(values, quantized, length, 0.5, 127);
   for (int i = 0; i < length; i++) {
     TF_LITE_MICRO_EXPECT_EQ(quantized[i], goldens[i]);
   }

tensorflow/lite/micro/test_helpers.cc

@@ -870,101 +870,17 @@ TfLiteFloatArray* FloatArrayFromFloats(const float* floats) {
   return reinterpret_cast<TfLiteFloatArray*>(const_cast<float*>(floats));
 }
 
-TfLiteTensor CreateTensor(TfLiteIntArray* dims, bool is_variable) {
-  TfLiteTensor result;
-  result.dims = dims;
-  result.params = {};
-  result.quantization = {kTfLiteNoQuantization, nullptr};
-  result.is_variable = is_variable;
-  result.allocation_type = kTfLiteMemNone;
-  return result;
-}
-
-TfLiteTensor CreateFloatTensor(const float* data, TfLiteIntArray* dims,
-                               bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteFloat32;
-  result.data.f = const_cast<float*>(data);
-  result.bytes = ElementCount(*dims) * sizeof(float);
-  return result;
-}
-
-void PopulateFloatTensor(TfLiteTensor* tensor, float* begin, float* end) {
-  float* p = begin;
-  float* v = tensor->data.f;
-  while (p != end) {
-    *v++ = *p++;
-  }
-}
-
-TfLiteTensor CreateBoolTensor(const bool* data, TfLiteIntArray* dims,
-                              bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteBool;
-  result.data.b = const_cast<bool*>(data);
-  result.bytes = ElementCount(*dims) * sizeof(bool);
-  return result;
-}
-
-TfLiteTensor CreateInt32Tensor(const int32_t* data, TfLiteIntArray* dims,
-                               bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteInt32;
-  result.data.i32 = const_cast<int32_t*>(data);
-  result.bytes = ElementCount(*dims) * sizeof(int32_t);
-  return result;
-}
-
-TfLiteTensor CreateQuantizedTensor(const uint8_t* data, TfLiteIntArray* dims,
-                                   float scale, int zero_point,
-                                   bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteUInt8;
-  result.data.uint8 = const_cast<uint8_t*>(data);
-  result.params = {scale, zero_point};
-  result.quantization = {kTfLiteAffineQuantization, nullptr};
-  result.bytes = ElementCount(*dims) * sizeof(uint8_t);
-  return result;
-}
-
-TfLiteTensor CreateQuantizedTensor(const int8_t* data, TfLiteIntArray* dims,
-                                   float scale, int zero_point,
-                                   bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteInt8;
-  result.data.int8 = const_cast<int8_t*>(data);
-  result.params = {scale, zero_point};
-  result.quantization = {kTfLiteAffineQuantization, nullptr};
-  result.bytes = ElementCount(*dims) * sizeof(int8_t);
-  return result;
-}
-
-TfLiteTensor CreateQuantizedTensor(const int16_t* data, TfLiteIntArray* dims,
-                                   float scale, int zero_point,
-                                   bool is_variable) {
-  TfLiteTensor result = CreateTensor(dims, is_variable);
-  result.type = kTfLiteInt16;
-  result.data.i16 = const_cast<int16_t*>(data);
-  result.params = {scale, zero_point};
-  result.quantization = {kTfLiteAffineQuantization, nullptr};
-  result.bytes = ElementCount(*dims) * sizeof(int16_t);
-  return result;
-}
-
 TfLiteTensor CreateQuantizedBiasTensor(const float* data, int32_t* quantized,
                                        TfLiteIntArray* dims, float input_scale,
                                        float weights_scale, bool is_variable) {
   float bias_scale = input_scale * weights_scale;
   tflite::SymmetricQuantize(data, quantized, ElementCount(*dims), bias_scale);
-  TfLiteTensor result = CreateTensor(dims, is_variable);
+
-  result.type = kTfLiteInt32;
-  result.data.i32 = const_cast<int32_t*>(quantized);
   // Quantized int32_t tensors always have a zero point of 0, since the range of
   // int32_t values is large, and because zero point costs extra cycles during
   // processing.
-  result.params = {bias_scale, 0};
+  TfLiteTensor result =
-  result.quantization = {kTfLiteAffineQuantization, nullptr};
+      CreateQuantizedTensor(quantized, dims, bias_scale, 0, is_variable);
-  result.bytes = ElementCount(*dims) * sizeof(int32_t);
   return result;
 }
 
@@ -986,18 +902,15 @@ TfLiteTensor CreatePerChannelQuantizedBiasTensor(
     zero_points[i + 1] = 0;
   }
 
-  SymmetricPerChannelQuantize(input, quantized, input_size, num_channels,
+  SymmetricPerChannelQuantize<int32_t>(input, quantized, input_size,
-                              scales_array);
+                                       num_channels, scales_array);
 
   affine_quant->scale = FloatArrayFromFloats(scales);
   affine_quant->zero_point = IntArrayFromInts(zero_points);
   affine_quant->quantized_dimension = quantized_dimension;
 
-  TfLiteTensor result = CreateTensor(dims, is_variable);
+  TfLiteTensor result = CreateTensor(quantized, dims, is_variable);
-  result.type = kTfLiteInt32;
-  result.data.i32 = const_cast<int32_t*>(quantized);
   result.quantization = {kTfLiteAffineQuantization, affine_quant};
-  result.bytes = ElementCount(*dims) * sizeof(int32_t);
   return result;
 }
 
@@ -1020,11 +933,8 @@ TfLiteTensor CreateSymmetricPerChannelQuantizedTensor(
   affine_quant->zero_point = IntArrayFromInts(zero_points);
   affine_quant->quantized_dimension = quantized_dimension;
 
-  TfLiteTensor result = CreateTensor(dims, is_variable);
+  TfLiteTensor result = CreateTensor(quantized, dims, is_variable);
-  result.type = kTfLiteInt8;
-  result.data.int8 = const_cast<int8_t*>(quantized);
   result.quantization = {kTfLiteAffineQuantization, affine_quant};
-  result.bytes = ElementCount(*dims) * sizeof(int8_t);
   return result;
 }
 

tensorflow/lite/micro/test_helpers.h

@@ -22,10 +22,12 @@ limitations under the License.
 #include <limits>
 
 #include "flatbuffers/flatbuffers.h"  // from @flatbuffers
+#include "tensorflow/lite//kernels/internal/tensor_ctypes.h"
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/micro/all_ops_resolver.h"
 #include "tensorflow/lite/micro/micro_utils.h"
+#include "tensorflow/lite/portable_type_to_tflitetype.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
 namespace tflite {
@@ -140,35 +142,42 @@ TfLiteIntArray* IntArrayFromInts(const int* int_array);
 // supplied array must be the size of the array expressed as a float.
 TfLiteFloatArray* FloatArrayFromFloats(const float* floats);
 
-TfLiteTensor CreateFloatTensor(const float* data, TfLiteIntArray* dims,
+template <typename T>
-                               bool is_variable = false);
+TfLiteTensor CreateTensor(const T* data, TfLiteIntArray* dims,
+                          const bool is_variable = false) {
+  TfLiteTensor result;
+  result.dims = dims;
+  result.params = {};
+  result.quantization = {kTfLiteNoQuantization, nullptr};
+  result.is_variable = is_variable;
+  result.allocation_type = kTfLiteMemNone;
+  result.type = typeToTfLiteType<T>();
+  // Const cast is used to allow passing in const and non-const arrays within a
+  // single CreateTensor method. A Const array should be used for immutable
+  // input tensors and non-const array should be used for mutable and output
+  // tensors.
+  result.data.data = const_cast<T*>(data);
+  result.quantization = {kTfLiteAffineQuantization, nullptr};
+  result.bytes = ElementCount(*dims) * sizeof(T);
+  return result;
+}
 
-void PopulateFloatTensor(TfLiteTensor* tensor, float* begin, float* end);
+template <typename T>
-
+TfLiteTensor CreateQuantizedTensor(const T* data, TfLiteIntArray* dims,
-TfLiteTensor CreateBoolTensor(const bool* data, TfLiteIntArray* dims,
+                                   const float scale, const int zero_point = 0,
-                              bool is_variable = false);
+                                   const bool is_variable = false) {
-
+  TfLiteTensor result = CreateTensor(data, dims, is_variable);
-TfLiteTensor CreateInt32Tensor(const int32_t*, TfLiteIntArray* dims,
+  result.params = {scale, zero_point};
-                               bool is_variable = false);
+  result.quantization = {kTfLiteAffineQuantization, nullptr};
-
+  return result;
-TfLiteTensor CreateQuantizedTensor(const uint8_t* data, TfLiteIntArray* dims,
+}
-                                   float scale, int zero_point,
-                                   bool is_variable = false);
-
-TfLiteTensor CreateQuantizedTensor(const int8_t* data, TfLiteIntArray* dims,
-                                   float scale, int zero_point,
-                                   bool is_variable = false);
-
-TfLiteTensor CreateQuantizedTensor(const int16_t* data, TfLiteIntArray* dims,
-                                   float scale, int zero_point,
-                                   bool is_variable = false);
 
 template <typename T>
 TfLiteTensor CreateQuantizedTensor(const float* input, T* quantized,
                                    TfLiteIntArray* dims, float scale,
                                    int zero_point, bool is_variable = false) {
   int input_size = ElementCount(*dims);
-  tflite::AsymmetricQuantize(input, quantized, input_size, scale, zero_point);
+  tflite::Quantize(input, quantized, input_size, scale, zero_point);
   return CreateQuantizedTensor(quantized, dims, scale, zero_point, is_variable);
 }