tflite_micro_person_detection_init

components/tflite_micro/tensorflow/lite/micro/micro_utils.h

@@ -0,0 +1,110 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_
+
+#include <stdint.h>
+
+#include "tensorflow/lite/c/common.h"
+
+namespace tflite {
+
+// Returns number of elements in the shape array.
+
+int ElementCount(const TfLiteIntArray& dims);
+
+uint8_t FloatToAsymmetricQuantizedUInt8(const float value, const float scale,
+                                        const int zero_point);
+
+uint8_t FloatToSymmetricQuantizedUInt8(const float value, const float scale);
+
+int8_t FloatToAsymmetricQuantizedInt8(const float value, const float scale,
+                                      const int zero_point);
+
+int16_t FloatToAsymmetricQuantizedInt16(const float value, const float scale,
+                                        const int zero_point);
+
+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.
+//
+// There are several key flavors of quantization in TfLite:
+//        asymmetric symmetric  per channel
+// int8_t  |     X    |    X    |     X      |
+// uint8_t |     X    |    X    |            |
+// int16_t |     X    |         |            |
+// int32_t |          |    X    |     X      |
+//
+// The per-op quantization spec can be found here:
+// https://www.tensorflow.org/lite/performance/quantization_spec
+
+void AsymmetricQuantize(const float* input, int8_t* output, int num_elements,
+                        float scale, int zero_point = 0);
+
+void AsymmetricQuantize(const float* input, uint8_t* output, int num_elements,
+                        float scale, int zero_point = 128);
+
+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);
+
+void SignedSymmetricPerChannelQuantize(const float* values,
+                                       TfLiteIntArray* dims,
+                                       int quantized_dimension,
+                                       int8_t* quantized_values,
+                                       float* scaling_factor);
+
+void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+                             int8_t* quantized_values, float* scaling_factor);
+
+void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+                             int16_t* quantized_values, float* scaling_factor);
+
+void SignedSymmetricQuantize(const float* values, TfLiteIntArray* dims,
+                             int32_t* quantized_values, float* scaling_factor);
+
+void SymmetricQuantize(const float* values, TfLiteIntArray* dims,
+                       uint8_t* quantized_values, float* scaling_factor);
+
+void SymmetricDequantize(const int8_t* values, const int size,
+                         const float dequantization_scale,
+                         float* dequantized_values);
+
+template <typename T>
+void AsymmetricDequantize(const T* values, const int size,
+                          const float dequantization_scale,
+                          int dequantization_zero_point,
+                          float* dequantized_values) {
+  for (int i = 0; i < size; ++i) {
+    dequantized_values[i] =
+        (values[i] - dequantization_zero_point) * dequantization_scale;
+  }
+}
+
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_