xmos-ai-tools 1.3.2.dev19__py3-none-macosx_11_0_arm64.whl → 1.3.2.dev37__py3-none-macosx_11_0_arm64.whl

xmos_ai_tools/runtime/include/lib_tflite_micro/api/inference_engine.h

@@ -38,15 +38,15 @@
  * must therefore be allocated inside a C++ source file.
  */
 struct tflite_micro_objects {
-  tflite::micro::xcore::XCoreErrorReporter error_reporter;
-  tflite::micro::xcore::XCoreProfiler xcore_profiler;
+  tflite_micro::micro::xcore::XCoreErrorReporter error_reporter;
+  tflite_micro::micro::xcore::XCoreProfiler xcore_profiler;
   uint64_t interpreter_buffer
-      [(sizeof(tflite::micro::xcore::XCoreInterpreter) + sizeof(uint64_t) - 1) /
+      [(sizeof(tflite_micro::micro::xcore::XCoreInterpreter) + sizeof(uint64_t) - 1) /
        sizeof(uint64_t)]; // This needs to be aligned on a double word boundary
-  tflite::MicroMutableOpResolver<XTFLM_OPERATORS> resolver;
+  tflite_micro::MicroMutableOpResolver<XTFLM_OPERATORS> resolver;
 
-  tflite::micro::xcore::XCoreInterpreter *interpreter;
-  const tflite::Model *model;
+  tflite_micro::micro::xcore::XCoreInterpreter *interpreter;
+  const tflite_micro::Model *model;
 };
 #endif
 
@@ -122,8 +122,8 @@ typedef struct inference_engine {
  *                                                     &s0);
  *        resolver->AddAdd();
  *        resolver->AddConv2D();
- *        resolver->AddCustom(tflite::ops::micro::xcore::Conv2D_V2_OpCode,
- *                   tflite::ops::micro::xcore::Register_Conv2D_V2());
+ *        resolver->AddCustom(tflite_micro::ops::micro::xcore::Conv2D_V2_OpCode,
+ *                   tflite_micro::ops::micro::xcore::Register_Conv2D_V2());
  *    [...]
  *
  * Note that when tensorflow lite for micro is disabled this function will not
@@ -146,7 +146,7 @@ typedef struct inference_engine {
  * structures. Must be allocated by the caller.
  *
  */
-tflite::MicroMutableOpResolver<XTFLM_OPERATORS> *inference_engine_initialize(
+tflite_micro::MicroMutableOpResolver<XTFLM_OPERATORS> *inference_engine_initialize(
     inference_engine_t *UNSAFE ie, uint32_t memory_primary[],
     uint32_t n_memory_primary, uint32_t memory_secondary[],
     uint32_t n_secondary, struct tflite_micro_objects *UNSAFE xtflmo);

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_common.h

@@ -4,7 +4,7 @@
 #include <cassert>
 #include <cstdint>
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 namespace xcore {
@@ -14,6 +14,6 @@ void calculateThreadSplit(int &tc, int split_size, int split_start[], int split_
 } // namespace xcore
 } // namespace micro
 } // namespace ops
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_COMMON_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_custom_options.h

@@ -4,7 +4,7 @@
 #include "flatbuffers/flexbuffers.h"
 #include "xcore_ops.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 namespace xcore {
@@ -23,6 +23,6 @@ public:
 } // namespace xcore
 } // namespace micro
 } // namespace ops
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_CUSTOM_OPTIONS_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_error_reporter.h

@@ -6,11 +6,11 @@
 #include "tensorflow/lite/micro/compatibility.h"
 #include "tensorflow/lite/micro/tflite_bridge/micro_error_reporter.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace micro {
 namespace xcore {
 
-class XCoreErrorReporter : public tflite::MicroErrorReporter {
+class XCoreErrorReporter : public tflite_micro::MicroErrorReporter {
 public:
   explicit XCoreErrorReporter(){};
   ~XCoreErrorReporter() override = default;
@@ -27,6 +27,6 @@ private:
 
 } // namespace xcore
 } // namespace micro
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_ERROR_REPORTER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_interpreter.h

@@ -8,21 +8,21 @@
 #include "tensorflow/lite/micro/micro_interpreter.h"
 #include "xcore_profiler.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace micro {
 namespace xcore {
 
-class XCoreInterpreter : public tflite::MicroInterpreter {
+class XCoreInterpreter : public tflite_micro::MicroInterpreter {
 public:
-  XCoreInterpreter(const tflite::Model *model,
-                   const tflite::MicroOpResolver &resolver,
-                   tflite::MicroAllocator *allocator,
+  XCoreInterpreter(const tflite_micro::Model *model,
+                   const tflite_micro::MicroOpResolver &resolver,
+                   tflite_micro::MicroAllocator *allocator,
                    bool use_curent_thread = true,
                    XCoreProfiler *profiler = nullptr);
 
   static XCoreInterpreter *
-  Create(uint8_t interpreter_buffer[], const tflite::Model *model,
-         const tflite::MicroOpResolver &resolver, uint8_t *arena,
+  Create(uint8_t interpreter_buffer[], const tflite_micro::Model *model,
+         const tflite_micro::MicroOpResolver &resolver, uint8_t *arena,
          size_t arena_size, bool use_current_thread, XCoreProfiler *profiler);
 
   void PrintMemoryPlan();
@@ -44,6 +44,6 @@ public:
 
 } // namespace xcore
 } // namespace micro
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_INTERPRETER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_ops.h

@@ -3,7 +3,7 @@
 
 #include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 namespace xcore {
@@ -61,11 +61,11 @@ TFLMRegistration *Register_XC_mean();
 // Binarized ops
 TFLMRegistration *Register_XC_bsign_8();
 
-void RegisterXCOps(tflite::MicroOpResolver *res);
+void RegisterXCOps(tflite_micro::MicroOpResolver *res);
 
 } // namespace xcore
 } // namespace micro
 } // namespace ops
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_OPS_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_profiler.h

@@ -11,16 +11,16 @@
 #define XCORE_PROFILER_DEFAULT_MAX_LEVELS (64)
 #endif
 
-namespace tflite {
+namespace tflite_micro {
 namespace micro {
 namespace xcore {
 
-class XCoreProfiler : public tflite::MicroProfiler {
+class XCoreProfiler : public tflite_micro::MicroProfiler {
 public:
   explicit XCoreProfiler(){};
   ~XCoreProfiler() override = default;
 
-  void Init(tflite::MicroAllocator *allocator,
+  void Init(tflite_micro::MicroAllocator *allocator,
             size_t max_event_count = XCORE_PROFILER_DEFAULT_MAX_LEVELS);
 
   void ClearEvents();
@@ -44,6 +44,6 @@ private:
 
 } // namespace xcore
 } // namespace micro
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_PROFILER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_utils.h

@@ -9,7 +9,7 @@
 #include "tensorflow/lite/micro/kernels/kernel_util.h"
 #include "tensorflow/lite/micro/memory_helpers.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 
@@ -79,14 +79,14 @@ fetch_scratch_if_needed(TfLiteContext *context, T *&array,
   if (scratch_idx >= 0) {
     array =
         static_cast<const T *>(context->GetScratchBuffer(context, scratch_idx));
-    const RuntimeShape shape = tflite::micro::GetTensorShape(tensor);
+    const RuntimeShape shape = tflite_micro::micro::GetTensorShape(tensor);
 
     size_t sizeof_tensor_type;
     TfLiteTypeSizeOf(tensor->type, &sizeof_tensor_type);
-    FetchBuffer((int8_t **)&array, tflite::micro::GetTensorData<int8_t>(tensor),
+    FetchBuffer((int8_t **)&array, tflite_micro::micro::GetTensorData<int8_t>(tensor),
                 shape.FlatSize() * sizeof_tensor_type);
   } else {
-    array = tflite::micro::GetTensorData<T>(tensor);
+    array = tflite_micro::micro::GetTensorData<T>(tensor);
   }
   TF_LITE_ENSURE(context, array);
   return kTfLiteOk;
@@ -155,6 +155,6 @@ public:
 } // namespace xcore
 } // namespace micro
 } // namespace ops
-} // namespace tflite
+} // namespace tflite_micro
 
 #endif // XCORE_UTILS_H_

xmos_ai_tools/runtime/include/lib_xud/lib_xud/api/xud.h

@@ -354,7 +354,7 @@ void XUD_Kill(XUD_ep ep);
  *                         The buffer is assumed to be word aligned.
  * \return     XUD_RES_OKAY on success, for errors see `Status Reporting`.
  */
-inline int XUD_SetReady_OutPtr(XUD_ep ep, unsigned addr)
+static inline int XUD_SetReady_OutPtr(XUD_ep ep, unsigned addr)
 {
     int chan_array_ptr;
     int reset;
@@ -390,7 +390,7 @@ int XUD_SetReady_Out(XUD_ep ep, unsigned char buffer[]);
  * \param      len         The length of the data to transmit.
  * \return     XUD_RES_OKAY on success, for errors see `Status Reporting`.
  */
-inline XUD_Result_t XUD_SetReady_InPtr(XUD_ep ep, unsigned addr, int len)
+static inline XUD_Result_t XUD_SetReady_InPtr(XUD_ep ep, unsigned addr, int len)
 {
     int chan_array_ptr;
     int tmp, tmp2;
@@ -453,7 +453,7 @@ inline XUD_Result_t XUD_SetReady_InPtr(XUD_ep ep, unsigned addr, int len)
  * \param   len         The length of the data to transmit.
  * \return  XUD_RES_OKAY on success, for errors see `Status Reporting`.
  */
-inline XUD_Result_t XUD_SetReady_In(XUD_ep ep, unsigned char buffer[], int len)
+static inline XUD_Result_t XUD_SetReady_In(XUD_ep ep, unsigned char buffer[], int len)
 {
     unsigned addr;
 

xmos_ai_tools/runtime/include/tensorflow/lite/array.h

@@ -23,7 +23,7 @@ limitations under the License.
 
 #include "tensorflow/lite/core/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 /// TfLite*Array helpers
 
@@ -73,13 +73,13 @@ TfLiteArrayUniquePtr<T> BuildTfLiteArray(int size);
 // Allocates a TfLiteIntArray of given size using malloc.
 template <>
 inline IntArrayUniquePtr BuildTfLiteArray<int>(const int size) {
-  return IntArrayUniquePtr(TfLiteIntArrayCreate(size));
+  return IntArrayUniquePtr(TfLiteMicroIntArrayCreate(size));
 }
 
 // Allocates a TfLiteFloatArray of given size using malloc.
 template <>
 inline FloatArrayUniquePtr BuildTfLiteArray<float>(const int size) {
-  return FloatArrayUniquePtr(TfLiteFloatArrayCreate(size));
+  return FloatArrayUniquePtr(TfLiteMicroFloatArrayCreate(size));
 }
 
 // Allocates a TFLiteArray of given size and initializes it with the given
@@ -151,6 +151,6 @@ inline FloatArrayUniquePtr BuildTfLiteArray(const TfLiteFloatArray& other) {
   return BuildTfLiteArray(other.size, other.data);
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_ARRAY_H_

xmos_ai_tools/runtime/include/tensorflow/lite/context_util.h

@@ -23,7 +23,7 @@ limitations under the License.
 
 #include "tensorflow/lite/core/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 /// Provides a range iterable wrapper for TfLiteIntArray* (C lists) that TfLite
 /// C api uses.
@@ -49,6 +49,6 @@ class TfLiteIntArrayView {
   const TfLiteIntArray* int_array_;
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_CONTEXT_UTIL_H_

xmos_ai_tools/runtime/include/tensorflow/lite/core/api/error_reporter.h

@@ -17,7 +17,7 @@ limitations under the License.
 
 #include <cstdarg>
 
-namespace tflite {
+namespace tflite_micro {
 
 /// A functor that reports error to supporting system. Invoked similar to
 /// printf.
@@ -53,7 +53,7 @@ class ErrorReporter {
   int ReportError(void*, const char* format, ...);
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 // You should not make bare calls to the error reporter, instead use the
 // TF_LITE_REPORT_ERROR macro, since this allows message strings to be
@@ -63,7 +63,7 @@ class ErrorReporter {
 #ifndef TF_LITE_STRIP_ERROR_STRINGS
 #define TF_LITE_REPORT_ERROR(reporter, ...)                               \
   do {                                                                    \
-    static_cast<::tflite::ErrorReporter*>(reporter)->Report(__VA_ARGS__); \
+    static_cast<::tflite_micro::ErrorReporter*>(reporter)->Report(__VA_ARGS__); \
   } while (false)
 #else  // TF_LITE_STRIP_ERROR_STRINGS
 #define TF_LITE_REPORT_ERROR(reporter, ...)

xmos_ai_tools/runtime/include/tensorflow/lite/core/api/flatbuffer_conversions.h

@@ -27,7 +27,7 @@ limitations under the License.
 #include "tensorflow/lite/core/c/common.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Interface class for builtin data allocations.
 class BuiltinDataAllocator {
@@ -435,6 +435,6 @@ TfLiteStatus ParseStablehloGather(const Operator* op,
                                   BuiltinDataAllocator* allocator,
                                   void** builtin_data);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_CORE_API_FLATBUFFER_CONVERSIONS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/core/api/tensor_utils.h

@@ -18,11 +18,11 @@ limitations under the License.
 
 #include "tensorflow/lite/core/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Resets a variable tensor to the default value.
 TfLiteStatus ResetVariableTensor(TfLiteTensor* tensor);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_CORE_API_TENSOR_UTILS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/core/c/c_api_types.h

@@ -76,15 +76,15 @@ typedef enum TfLiteStatus {
   kTfLiteApplicationError = 3,
 
   /// Generally referring to serialized delegate data not being found.
-  /// See tflite::delegates::Serialization.
+  /// See tflite_micro::delegates::Serialization.
   kTfLiteDelegateDataNotFound = 4,
 
   /// Generally referring to data-writing issues in delegate serialization.
-  /// See tflite::delegates::Serialization.
+  /// See tflite_micro::delegates::Serialization.
   kTfLiteDelegateDataWriteError = 5,
 
   /// Generally referring to data-reading issues in delegate serialization.
-  /// See tflite::delegates::Serialization.
+  /// See tflite_micro::delegates::Serialization.
   kTfLiteDelegateDataReadError = 6,
 
   /// Generally referring to issues when the TF Lite model has ops that cannot

xmos_ai_tools/runtime/include/tensorflow/lite/core/c/common.h

@@ -107,28 +107,28 @@ typedef struct TfLiteIntArray {
 
 // Given the size (number of elements) in a TfLiteIntArray, calculate its size
 // in bytes.
-size_t TfLiteIntArrayGetSizeInBytes(int size);
+size_t TfLiteMicroIntArrayGetSizeInBytes(int size);
 
 #ifndef TF_LITE_STATIC_MEMORY
 // Create a array of a given `size` (uninitialized entries).
 // This returns a pointer, that you must free using TfLiteIntArrayFree().
-TfLiteIntArray* TfLiteIntArrayCreate(int size);
+TfLiteIntArray* TfLiteMicroIntArrayCreate(int size);
 #endif
 
 // Check if two intarrays are equal. Returns 1 if they are equal, 0 otherwise.
-int TfLiteIntArrayEqual(const TfLiteIntArray* a, const TfLiteIntArray* b);
+int TfLiteMicroIntArrayEqual(const TfLiteIntArray* a, const TfLiteIntArray* b);
 
 // Check if an intarray equals an array. Returns 1 if equals, 0 otherwise.
-int TfLiteIntArrayEqualsArray(const TfLiteIntArray* a, int b_size,
+int TfLiteMicroIntArrayEqualsArray(const TfLiteIntArray* a, int b_size,
                               const int b_data[]);
 
 #ifndef TF_LITE_STATIC_MEMORY
 // Create a copy of an array passed as `src`.
 // You are expected to free memory with TfLiteIntArrayFree
-TfLiteIntArray* TfLiteIntArrayCopy(const TfLiteIntArray* src);
+TfLiteIntArray* TfLiteMicroIntArrayCopy(const TfLiteIntArray* src);
 
 // Free memory of array `a`.
-void TfLiteIntArrayFree(TfLiteIntArray* a);
+void TfLiteMicroIntArrayFree(TfLiteIntArray* a);
 #endif  // TF_LITE_STATIC_MEMORY
 
 // Fixed size list of floats. Used for per-channel quantization.
@@ -156,14 +156,14 @@ int TfLiteFloatArrayGetSizeInBytes(int size);
 #ifndef TF_LITE_STATIC_MEMORY
 // Create a array of a given `size` (uninitialized entries).
 // This returns a pointer, that you must free using TfLiteFloatArrayFree().
-TfLiteFloatArray* TfLiteFloatArrayCreate(int size);
+TfLiteFloatArray* TfLiteMicroFloatArrayCreate(int size);
 
 // Create a copy of an array passed as `src`.
 // You are expected to free memory with TfLiteFloatArrayFree.
-TfLiteFloatArray* TfLiteFloatArrayCopy(const TfLiteFloatArray* src);
+TfLiteFloatArray* TfLiteMicroFloatArrayCopy(const TfLiteFloatArray* src);
 
 // Free memory of array `a`.
-void TfLiteFloatArrayFree(TfLiteFloatArray* a);
+void TfLiteMicroFloatArrayFree(TfLiteFloatArray* a);
 #endif  // TF_LITE_STATIC_MEMORY
 
 // Since we must not depend on any libraries, define a minimal subset of
@@ -238,8 +238,8 @@ void TfLiteFloatArrayFree(TfLiteFloatArray* a);
   do {                                                                     \
     if ((a) != (b)) {                                                      \
       TF_LITE_KERNEL_LOG((context), "%s:%d %s != %s (%s != %s)", __FILE__, \
-                         __LINE__, #a, #b, TfLiteTypeGetName(a),           \
-                         TfLiteTypeGetName(b));                            \
+                         __LINE__, #a, #b, TfLiteMicroTypeGetName(a),           \
+                         TfLiteMicroTypeGetName(b));                            \
       return kTfLiteError;                                                 \
     }                                                                      \
   } while (0)
@@ -279,7 +279,7 @@ typedef struct TfLiteFloat16 {
 } TfLiteFloat16;
 
 // Return the name of a given type, for error reporting purposes.
-const char* TfLiteTypeGetName(TfLiteType type);
+const char* TfLiteMicroTypeGetName(TfLiteType type);
 
 // SupportedQuantizationTypes.
 typedef enum TfLiteQuantizationType {
@@ -472,7 +472,7 @@ typedef struct TfLiteTensor {
   // bytes = sizeof(float) * 3 * 2 = 4 * 3 * 2 = 24.
   size_t bytes;
 
-  // An opaque pointer to a tflite::MMapAllocation
+  // An opaque pointer to a tflite_micro::MMapAllocation
   const void* allocation;
 
   // Null-terminated name of this tensor.
@@ -657,10 +657,10 @@ typedef struct TfLiteEvalTensor {
 void TfLiteTensorDataFree(TfLiteTensor* t);
 
 // Free quantization data.
-void TfLiteQuantizationFree(TfLiteQuantization* quantization);
+void TfLiteMicroQuantizationFree(TfLiteQuantization* quantization);
 
 // Free sparsity parameters.
-void TfLiteSparsityFree(TfLiteSparsity* sparsity);
+void TfLiteMicroSparsityFree(TfLiteSparsity* sparsity);
 
 // Free memory of tensor `t`.
 void TfLiteTensorFree(TfLiteTensor* t);
@@ -1311,8 +1311,8 @@ typedef struct TfLiteOpaqueDelegateBuilder {
 // the objects pointed to by any of the fields within the
 // 'opaque_delegate_builder' must outlive the returned
 // 'TfLiteOpaqueDelegate' and any 'TfLiteInterpreter',
-// 'TfLiteInterpreterOptions', 'tflite::Interpreter', or
-// 'tflite::InterpreterBuilder' that the delegate is added to.  The returned
+// 'TfLiteInterpreterOptions', 'tflite_micro::Interpreter', or
+// 'tflite_micro::InterpreterBuilder' that the delegate is added to.  The returned
 // address should be passed to 'TfLiteOpaqueDelegateDelete' for deletion.  If
 // 'opaque_delegate_builder' is a null pointer, then a null pointer will be
 // returned.

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/common.h

@@ -35,7 +35,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/optimized/neon_check.h"
 #include "tensorflow/lite/kernels/internal/types.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 constexpr int kReverseShift = -1;
 
@@ -1353,6 +1353,6 @@ void optimized_ops_prefetch_write_l1_keep(const T* ptr) {
 #endif
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_COMMON_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/cppmath.h

@@ -17,7 +17,7 @@ limitations under the License.
 
 #include <cmath>
 
-namespace tflite {
+namespace tflite_micro {
 
 #if defined(TF_LITE_USE_GLOBAL_CMATH_FUNCTIONS) || \
     (defined(__ANDROID__) && !defined(__NDK_MAJOR__)) || defined(__ZEPHYR__)
@@ -35,6 +35,6 @@ namespace tflite {
 DECLARE_STD_GLOBAL_SWITCH1(TfLiteRound, round)
 DECLARE_STD_GLOBAL_SWITCH1(TfLiteExpm1, expm1)
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_CPPMATH_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/max.h

@@ -17,7 +17,7 @@ limitations under the License.
 
 #include <cmath>
 
-namespace tflite {
+namespace tflite_micro {
 
 #if defined(TF_LITE_USE_GLOBAL_MAX) || defined(__ZEPHYR__)
 inline float TfLiteMax(const float& x, const float& y) {
@@ -30,6 +30,6 @@ inline T TfLiteMax(const T& x, const T& y) {
 }
 #endif
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_MAX_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/min.h

@@ -17,7 +17,7 @@ limitations under the License.
 
 #include <cmath>
 
-namespace tflite {
+namespace tflite_micro {
 
 #if defined(TF_LITE_USE_GLOBAL_MIN) || defined(__ZEPHYR__)
 inline float TfLiteMin(const float& x, const float& y) {
@@ -30,6 +30,6 @@ inline T TfLiteMin(const T& x, const T& y) {
 }
 #endif
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_MIN_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/portable_tensor.h

@@ -22,7 +22,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
 #include "tensorflow/lite/kernels/internal/types.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // A list of tensors in a format that can be used by kernels like split and
 // concatenation.
@@ -136,6 +136,6 @@ class SequentialTensorWriter {
   T* output_ptr_;
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_PORTABLE_TENSOR_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/portable_tensor_utils.h

@@ -27,7 +27,7 @@ limitations under the License.
 #define __restrict__ __restrict
 #endif
 
-namespace tflite {
+namespace tflite_micro {
 
 // Not all backends support CpuBackendContext usage, so forward declare to avoid
 // pulling in its implementation. Use of CpuBackendContext in method
@@ -618,6 +618,6 @@ void UnpackDenseInt4IntoInt8(const int8_t* src_buffer, int num_elements,
 
 }  // namespace tensor_utils
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_PORTABLE_TENSOR_UTILS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/quantization_util.h

@@ -23,7 +23,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/cppmath.h"
 #include "tensorflow/lite/kernels/internal/types.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Given the min and max values of a float array, return
 // reasonable quantization parameters to use for this array.
@@ -287,6 +287,6 @@ void QuantizeMultiplierArray(const double* effective_scales, size_t size,
                              int32_t* effective_scale_significand,
                              int* effective_shift);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_QUANTIZATION_UTIL_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/reference/add.h

@@ -24,7 +24,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/common.h"
 #include "tensorflow/lite/kernels/internal/compatibility.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 namespace reference_ops {
 
@@ -479,7 +479,7 @@ inline void BroadcastAddFivefold(const ArithmeticParams& unswitched_params,
 
   const bool use_unswitched =
       unswitched_params.broadcast_category ==
-      tflite::BroadcastableOpCategory::kFirstInputBroadcastsFast;
+      tflite_micro::BroadcastableOpCategory::kFirstInputBroadcastsFast;
 
   const ArithmeticParams& params =
       use_unswitched ? unswitched_params : switched_params;
@@ -556,6 +556,6 @@ inline void BroadcastAddFivefold(const ArithmeticParams& unswitched_params,
 }
 
 }  // namespace reference_ops
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_ADD_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/reference/add_n.h

@@ -20,7 +20,7 @@ limitations under the License.
 
 #include "tensorflow/lite/kernels/internal/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace reference_ops {
 
 // T is expected to be either float or int.
@@ -81,6 +81,6 @@ inline void AddN(const ArithmeticParams& params,
 }
 
 }  // namespace reference_ops
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_ADD_N_H_