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/tensorflow/lite/micro/micro_log.h

@@ -24,11 +24,11 @@ void VMicroPrintf(const char* format, va_list args);
 #else
 // We use a #define to ensure that the strings are completely stripped, to
 // prevent an unnecessary increase in the binary size.
-#define MicroPrintf(...) tflite::Unused(__VA_ARGS__)
-#define VMicroPrintf(...) tflite::Unused(__VA_ARGS__)
+#define MicroPrintf(...) tflite_micro::Unused(__VA_ARGS__)
+#define VMicroPrintf(...) tflite_micro::Unused(__VA_ARGS__)
 #endif
 
-namespace tflite {
+namespace tflite_micro {
 
 // From
 // https://stackoverflow.com/questions/23235910/variadic-unused-function-macro
@@ -37,6 +37,6 @@ void Unused(Args&&... args) {
   (void)(sizeof...(args));
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_LOG_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_mutable_op_resolver.h

@@ -36,7 +36,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/micro_op_resolver.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 TFLMRegistration* Register_DETECTION_POSTPROCESS();
 
 template <unsigned int tOpCount>
@@ -46,7 +46,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   explicit MicroMutableOpResolver() {}
 
-  const TFLMRegistration* FindOp(tflite::BuiltinOperator op) const override {
+  const TFLMRegistration* FindOp(tflite_micro::BuiltinOperator op) const override {
     if (op == BuiltinOperator_CUSTOM) return nullptr;
 
     for (unsigned int i = 0; i < registrations_len_; ++i) {
@@ -121,7 +121,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddAddN() {
-    return AddBuiltin(BuiltinOperator_ADD_N, tflite::Register_ADD_N(),
+    return AddBuiltin(BuiltinOperator_ADD_N, tflite_micro::Register_ADD_N(),
                       ParseAddN);
   }
 
@@ -135,7 +135,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddAssignVariable() {
     return AddBuiltin(BuiltinOperator_ASSIGN_VARIABLE,
-                      tflite::Register_ASSIGN_VARIABLE(), ParseAssignVariable);
+                      tflite_micro::Register_ASSIGN_VARIABLE(), ParseAssignVariable);
   }
 
   TfLiteStatus AddAveragePool2D(
@@ -145,7 +145,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddBatchMatMul() {
     return AddBuiltin(BuiltinOperator_BATCH_MATMUL,
-                      tflite::Register_BATCH_MATMUL(), ParseBatchMatMul);
+                      tflite_micro::Register_BATCH_MATMUL(), ParseBatchMatMul);
   }
 
   TfLiteStatus AddBatchToSpaceNd() {
@@ -177,7 +177,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddCircularBuffer() {
-    return AddCustom("CIRCULAR_BUFFER", tflite::Register_CIRCULAR_BUFFER());
+    return AddCustom("CIRCULAR_BUFFER", tflite_micro::Register_CIRCULAR_BUFFER());
   }
 
   TfLiteStatus AddConcatenation() {
@@ -191,22 +191,22 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddCos() {
-    return AddBuiltin(BuiltinOperator_COS, tflite::Register_COS(), ParseCos);
+    return AddBuiltin(BuiltinOperator_COS, tflite_micro::Register_COS(), ParseCos);
   }
 
   TfLiteStatus AddCumSum() {
-    return AddBuiltin(BuiltinOperator_CUMSUM, tflite::Register_CUMSUM(),
+    return AddBuiltin(BuiltinOperator_CUMSUM, tflite_micro::Register_CUMSUM(),
                       ParseCumsum);
   }
 
   TfLiteStatus AddDelay() {
     // TODO(b/286250473): change back name to "Delay" and remove namespace
-    return AddCustom("SignalDelay", tflite::tflm_signal::Register_DELAY());
+    return AddCustom("SignalDelay", tflite_micro::tflm_signal::Register_DELAY());
   }
 
   TfLiteStatus AddDepthToSpace() {
     return AddBuiltin(BuiltinOperator_DEPTH_TO_SPACE,
-                      tflite::Register_DEPTH_TO_SPACE(), ParseDepthToSpace);
+                      tflite_micro::Register_DEPTH_TO_SPACE(), ParseDepthToSpace);
   }
 
   TfLiteStatus AddDepthwiseConv2D(
@@ -216,17 +216,17 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddDequantize() {
-    return AddBuiltin(BuiltinOperator_DEQUANTIZE, tflite::Register_DEQUANTIZE(),
+    return AddBuiltin(BuiltinOperator_DEQUANTIZE, tflite_micro::Register_DEQUANTIZE(),
                       ParseDequantize);
   }
 
   TfLiteStatus AddDetectionPostprocess() {
     return AddCustom("TFLite_Detection_PostProcess",
-                     tflite::Register_DETECTION_POSTPROCESS());
+                     tflite_micro::Register_DETECTION_POSTPROCESS());
   }
 
   TfLiteStatus AddDiv() {
-    return AddBuiltin(BuiltinOperator_DIV, tflite::Register_DIV(), ParseDiv);
+    return AddBuiltin(BuiltinOperator_DIV, tflite_micro::Register_DIV(), ParseDiv);
   }
 
   TfLiteStatus AddEmbeddingLookup() {
@@ -236,11 +236,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddEnergy() {
     // TODO(b/286250473): change back name to "Energy" and remove namespace
-    return AddCustom("SignalEnergy", tflite::tflm_signal::Register_ENERGY());
+    return AddCustom("SignalEnergy", tflite_micro::tflm_signal::Register_ENERGY());
   }
 
   TfLiteStatus AddElu() {
-    return AddBuiltin(BuiltinOperator_ELU, tflite::Register_ELU(), ParseElu);
+    return AddBuiltin(BuiltinOperator_ELU, tflite_micro::Register_ELU(), ParseElu);
   }
 
   TfLiteStatus AddEqual() {
@@ -248,9 +248,9 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddEthosU() {
-    TFLMRegistration* registration = tflite::Register_ETHOSU();
+    TFLMRegistration* registration = tflite_micro::Register_ETHOSU();
     if (registration) {
-      return AddCustom(tflite::GetString_ETHOSU(), registration);
+      return AddCustom(tflite_micro::GetString_ETHOSU(), registration);
     }
     return kTfLiteOk;
   }
@@ -267,36 +267,36 @@ class MicroMutableOpResolver : public MicroOpResolver {
   TfLiteStatus AddFftAutoScale() {
     // TODO(b/286250473): change back name and remove namespace
     return AddCustom("SignalFftAutoScale",
-                     tflite::tflm_signal::Register_FFT_AUTO_SCALE());
+                     tflite_micro::tflm_signal::Register_FFT_AUTO_SCALE());
   }
 
   TfLiteStatus AddFill() {
-    return AddBuiltin(BuiltinOperator_FILL, tflite::Register_FILL(), ParseFill);
+    return AddBuiltin(BuiltinOperator_FILL, tflite_micro::Register_FILL(), ParseFill);
   }
 
   TfLiteStatus AddFilterBank() {
     // TODO(b/286250473): change back name to "FilterBank" and remove namespace
     return AddCustom("SignalFilterBank",
-                     tflite::tflm_signal::Register_FILTER_BANK());
+                     tflite_micro::tflm_signal::Register_FILTER_BANK());
   }
   TfLiteStatus AddFilterBankLog() {
     // TODO(b/286250473): change back name to "FilterBankLog" and remove
     // namespace
     return AddCustom("SignalFilterBankLog",
-                     tflite::tflm_signal::Register_FILTER_BANK_LOG());
+                     tflite_micro::tflm_signal::Register_FILTER_BANK_LOG());
   }
   TfLiteStatus AddFilterBankSquareRoot() {
     // TODO(b/286250473): change back name to "FilterBankSquareRoot" and remove
     // namespace
     return AddCustom("SignalFilterBankSquareRoot",
-                     tflite::tflm_signal::Register_FILTER_BANK_SQUARE_ROOT());
+                     tflite_micro::tflm_signal::Register_FILTER_BANK_SQUARE_ROOT());
   }
   TfLiteStatus AddFilterBankSpectralSubtraction() {
     // TODO(b/286250473): change back name to "FilterBankSpectralSubtraction"
     // and remove namespace
     return AddCustom(
         "SignalFilterBankSpectralSubtraction",
-        tflite::tflm_signal::Register_FILTER_BANK_SPECTRAL_SUBTRACTION());
+        tflite_micro::tflm_signal::Register_FILTER_BANK_SPECTRAL_SUBTRACTION());
   }
 
   TfLiteStatus AddFloor() {
@@ -304,18 +304,18 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddFloorDiv() {
-    return AddBuiltin(BuiltinOperator_FLOOR_DIV, tflite::Register_FLOOR_DIV(),
+    return AddBuiltin(BuiltinOperator_FLOOR_DIV, tflite_micro::Register_FLOOR_DIV(),
                       ParseFloorDiv);
   }
 
   TfLiteStatus AddFloorMod() {
-    return AddBuiltin(BuiltinOperator_FLOOR_MOD, tflite::Register_FLOOR_MOD(),
+    return AddBuiltin(BuiltinOperator_FLOOR_MOD, tflite_micro::Register_FLOOR_MOD(),
                       ParseFloorMod);
   }
 
   TfLiteStatus AddFramer() {
     // TODO(b/286250473): change back name to "Framer" and remove namespace
-    return AddCustom("SignalFramer", tflite::tflm_signal::Register_FRAMER());
+    return AddCustom("SignalFramer", tflite_micro::tflm_signal::Register_FRAMER());
   }
 
   TfLiteStatus AddFullyConnected(
@@ -325,12 +325,12 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddGather() {
-    return AddBuiltin(BuiltinOperator_GATHER, tflite::Register_GATHER(),
+    return AddBuiltin(BuiltinOperator_GATHER, tflite_micro::Register_GATHER(),
                       ParseGather);
   }
 
   TfLiteStatus AddGatherNd() {
-    return AddBuiltin(BuiltinOperator_GATHER_ND, tflite::Register_GATHER_ND(),
+    return AddBuiltin(BuiltinOperator_GATHER_ND, tflite_micro::Register_GATHER_ND(),
                       ParseGatherNd);
   }
 
@@ -345,12 +345,12 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddHardSwish() {
-    return AddBuiltin(BuiltinOperator_HARD_SWISH, tflite::Register_HARD_SWISH(),
+    return AddBuiltin(BuiltinOperator_HARD_SWISH, tflite_micro::Register_HARD_SWISH(),
                       ParseHardSwish);
   }
 
   TfLiteStatus AddIf() {
-    return AddBuiltin(BuiltinOperator_IF, tflite::Register_IF(), ParseIf);
+    return AddBuiltin(BuiltinOperator_IF, tflite_micro::Register_IF(), ParseIf);
   }
 
   TfLiteStatus AddIrfft(const TFLMRegistration* registration =
@@ -365,12 +365,12 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddL2Pool2D() {
-    return AddBuiltin(BuiltinOperator_L2_POOL_2D, tflite::Register_L2_POOL_2D(),
+    return AddBuiltin(BuiltinOperator_L2_POOL_2D, tflite_micro::Register_L2_POOL_2D(),
                       ParsePool);
   }
 
   TfLiteStatus AddLeakyRelu() {
-    return AddBuiltin(BuiltinOperator_LEAKY_RELU, tflite::Register_LEAKY_RELU(),
+    return AddBuiltin(BuiltinOperator_LEAKY_RELU, tflite_micro::Register_LEAKY_RELU(),
                       ParseLeakyRelu);
   }
 
@@ -389,7 +389,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddLogicalAnd() {
     return AddBuiltin(BuiltinOperator_LOGICAL_AND,
-                      tflite::Register_LOGICAL_AND(), ParseLogicalAnd);
+                      tflite_micro::Register_LOGICAL_AND(), ParseLogicalAnd);
   }
 
   TfLiteStatus AddLogicalNot() {
@@ -398,18 +398,18 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddLogicalOr() {
-    return AddBuiltin(BuiltinOperator_LOGICAL_OR, tflite::Register_LOGICAL_OR(),
+    return AddBuiltin(BuiltinOperator_LOGICAL_OR, tflite_micro::Register_LOGICAL_OR(),
                       ParseLogicalOr);
   }
 
   TfLiteStatus AddLogistic() {
-    return AddBuiltin(BuiltinOperator_LOGISTIC, tflite::Register_LOGISTIC(),
+    return AddBuiltin(BuiltinOperator_LOGISTIC, tflite_micro::Register_LOGISTIC(),
                       ParseLogistic);
   }
 
   TfLiteStatus AddLogSoftmax() {
     return AddBuiltin(BuiltinOperator_LOG_SOFTMAX,
-                      tflite::Register_LOG_SOFTMAX(), ParseLogSoftmax);
+                      tflite_micro::Register_LOG_SOFTMAX(), ParseLogSoftmax);
   }
 
   TfLiteStatus AddMaximum() {
@@ -423,7 +423,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddMirrorPad() {
-    return AddBuiltin(BuiltinOperator_MIRROR_PAD, tflite::Register_MIRROR_PAD(),
+    return AddBuiltin(BuiltinOperator_MIRROR_PAD, tflite_micro::Register_MIRROR_PAD(),
                       ParseMirrorPad);
   }
 
@@ -452,7 +452,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   TfLiteStatus AddOverlapAdd() {
     // TODO(b/286250473): change back name to "OverlapAdd" and remove namespace
     return AddCustom("SignalOverlapAdd",
-                     tflite::tflm_signal::Register_OVERLAP_ADD());
+                     tflite_micro::tflm_signal::Register_OVERLAP_ADD());
   }
 
   TfLiteStatus AddPack() {
@@ -469,11 +469,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddPCAN() {
     // TODO(b/286250473): change back name to "PCAN" and remove namespace
-    return AddCustom("SignalPCAN", tflite::tflm_signal::Register_PCAN());
+    return AddCustom("SignalPCAN", tflite_micro::tflm_signal::Register_PCAN());
   }
 
   TfLiteStatus AddPrelu() {
-    return AddBuiltin(BuiltinOperator_PRELU, tflite::Register_PRELU(),
+    return AddBuiltin(BuiltinOperator_PRELU, tflite_micro::Register_PRELU(),
                       ParsePrelu);
   }
 
@@ -484,7 +484,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddReadVariable() {
     return AddBuiltin(BuiltinOperator_READ_VARIABLE,
-                      tflite::Register_READ_VARIABLE(), ParseReadVariable);
+                      tflite_micro::Register_READ_VARIABLE(), ParseReadVariable);
   }
 
   TfLiteStatus AddReduceMax() {
@@ -493,11 +493,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
   }
 
   TfLiteStatus AddRelu() {
-    return AddBuiltin(BuiltinOperator_RELU, tflite::Register_RELU(), ParseRelu);
+    return AddBuiltin(BuiltinOperator_RELU, tflite_micro::Register_RELU(), ParseRelu);
   }
 
   TfLiteStatus AddRelu6() {
-    return AddBuiltin(BuiltinOperator_RELU6, tflite::Register_RELU6(),
+    return AddBuiltin(BuiltinOperator_RELU6, tflite_micro::Register_RELU6(),
                       ParseRelu6);
   }
 
@@ -586,7 +586,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddSquaredDifference() {
     return AddBuiltin(BuiltinOperator_SQUARED_DIFFERENCE,
-                      tflite::Register_SQUARED_DIFFERENCE(),
+                      tflite_micro::Register_SQUARED_DIFFERENCE(),
                       ParseSquaredDifference);
   }
 
@@ -597,11 +597,11 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddStacker() {
     // TODO(b/286250473): change back name to "Stacker" and remove namespace
-    return AddCustom("SignalStacker", tflite::tflm_signal::Register_STACKER());
+    return AddCustom("SignalStacker", tflite_micro::tflm_signal::Register_STACKER());
   }
 
   TfLiteStatus AddSub() {
-    return AddBuiltin(BuiltinOperator_SUB, tflite::Register_SUB(), ParseSub);
+    return AddBuiltin(BuiltinOperator_SUB, tflite_micro::Register_SUB(), ParseSub);
   }
 
   TfLiteStatus AddSum() {
@@ -618,7 +618,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddTransposeConv() {
     return AddBuiltin(BuiltinOperator_TRANSPOSE_CONV,
-                      tflite::Register_TRANSPOSE_CONV(), ParseTransposeConv);
+                      tflite_micro::Register_TRANSPOSE_CONV(), ParseTransposeConv);
   }
 
   TfLiteStatus AddTranspose() {
@@ -648,7 +648,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
 
   TfLiteStatus AddWindow() {
     // TODO(b/286250473): change back name to "Window" and remove namespace
-    return AddCustom("SignalWindow", tflite::tflm_signal::Register_WINDOW());
+    return AddCustom("SignalWindow", tflite_micro::tflm_signal::Register_WINDOW());
   }
 
   TfLiteStatus AddZerosLike() {
@@ -659,7 +659,7 @@ class MicroMutableOpResolver : public MicroOpResolver {
   unsigned int GetRegistrationLength() { return registrations_len_; }
 
  private:
-  TfLiteStatus AddBuiltin(tflite::BuiltinOperator op,
+  TfLiteStatus AddBuiltin(tflite_micro::BuiltinOperator op,
                           const TFLMRegistration& registration,
                           TfLiteBridgeBuiltinParseFunction parser) {
     if (op == BuiltinOperator_CUSTOM) {
@@ -703,6 +703,6 @@ class MicroMutableOpResolver : public MicroOpResolver {
   unsigned int num_buitin_ops_ = 0;
 };
 
-};  // namespace tflite
+};  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_MUTABLE_OP_RESOLVER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_op_resolver.h

@@ -20,7 +20,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/tflite_bridge/flatbuffer_conversions_bridge.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // This is an interface for the OpResolver for TFLiteMicro. The differences from
 // the TFLite OpResolver base class are to:
@@ -57,6 +57,6 @@ TfLiteStatus GetRegistrationFromOpCode(const OperatorCode* opcode,
                                        const MicroOpResolver& op_resolver,
                                        const TFLMRegistration** registration);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_OP_RESOLVER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_profiler.h

@@ -19,7 +19,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/compatibility.h"
 #include "tensorflow/lite/micro/micro_profiler_interface.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // MicroProfiler creates a common way to gain fine-grained insight into runtime
 // performance. Bottleck operators can be identified along with slow code
@@ -135,6 +135,6 @@ class ScopedMicroProfiler {
 };
 #endif  // !defined(TF_LITE_STRIP_ERROR_STRINGS)
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_PROFILER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_profiler_interface.h

@@ -18,7 +18,7 @@ limitations under the License.
 
 #include <cstdint>
 
-namespace tflite {
+namespace tflite_micro {
 
 // Interface class that the TFLM framework relies on for profiling.
 class MicroProfilerInterface {
@@ -33,6 +33,6 @@ class MicroProfilerInterface {
   virtual void EndEvent(uint32_t event_handle) = 0;
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_PROFILER_INTERFACE_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_resource_variable.h

@@ -21,7 +21,7 @@ limitations under the License.
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/micro/micro_allocator.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 class MicroResourceVariables {
  public:
@@ -84,6 +84,6 @@ class MicroResourceVariables {
   int num_resource_variables_;
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TFLITE_MICRO_TENSORFLOW_LITE_MICRO_MICRO_RESOURCE_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_time.h

@@ -17,7 +17,7 @@ limitations under the License.
 
 #include <cstdint>
 
-namespace tflite {
+namespace tflite_micro {
 
 // These functions should be implemented by each target platform, and provide an
 // accurate tick count along with how many ticks there are per second.
@@ -31,6 +31,6 @@ inline uint32_t TicksToMs(int32_t ticks) {
                                static_cast<float>(ticks_per_second()));
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_TIME_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/micro_utils.h

@@ -23,7 +23,7 @@ limitations under the License.
 
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Returns number of elements in the shape array.
 
@@ -157,6 +157,6 @@ inline int QMaxFromTfLiteType(TfLiteType type) {
   }
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/mock_micro_graph.h

@@ -21,7 +21,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/micro_graph.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // MockMicroGraph stubs out all MicroGraph methods used during invoke. A count
 // of the number of calls to invoke for each subgraph is maintained for
@@ -55,6 +55,6 @@ class MockMicroGraph : public MicroGraph {
   TF_LITE_REMOVE_VIRTUAL_DELETE
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_MOCK_MICRO_GRAPH_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/python/tflite_size/src/flatbuffer_size.h

@@ -20,11 +20,11 @@ limitations under the License.
 #include "flatbuffers/flatbuffers.h"
 #include "flatbuffers/util.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 std::string FlatBufferSizeToJsonString(
     const uint8_t* buffer, const flatbuffers::TypeTable* type_table);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/python/tflite_size/src/flatbuffer_size_wrapper.h

@@ -19,7 +19,7 @@ limitations under the License.
 
 #include <string>
 
-namespace tflite {
+namespace tflite_micro {
 
 class FlatbufferSizeWrapper {
  public:
@@ -29,5 +29,5 @@ class FlatbufferSizeWrapper {
   std::string ConvertToJsonString(const char* in_flatbuffer);
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 #endif  // TENSORFLOW_LITE_MICRO_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_WRAPPER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/recording_micro_allocator.h

@@ -20,7 +20,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/compatibility.h"
 #include "tensorflow/lite/micro/micro_allocator.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // List of buckets currently recorded by this class. Each type keeps a list of
 // allocated information during model initialization.
@@ -120,6 +120,6 @@ class RecordingMicroAllocator : public MicroAllocator {
   TF_LITE_REMOVE_VIRTUAL_DELETE
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_RECORDING_MICRO_ALLOCATOR_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/recording_micro_interpreter.h

@@ -20,7 +20,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/micro_profiler_interface.h"
 #include "tensorflow/lite/micro/recording_micro_allocator.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Utility subclass that enables internal recordings of the MicroInterpreter.
 // This class should be used to audit and analyze memory arena usage for a given
@@ -64,6 +64,6 @@ class RecordingMicroInterpreter : public MicroInterpreter {
   const RecordingMicroAllocator& recording_micro_allocator_;
 };
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_RECORDING_MICRO_INTERPRETER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/system_setup.h

@@ -15,13 +15,13 @@ limitations under the License.
 #ifndef TENSORFLOW_LITE_MICRO_SYSTEM_SETUP_H_
 #define TENSORFLOW_LITE_MICRO_SYSTEM_SETUP_H_
 
-namespace tflite {
+namespace tflite_micro {
 
 // This should called during initialization of TFLM binaries and tests. It can
 // be specialized if there is a need for custom target-specific intialization.
 // For more information, see tensorflow/lite/micro/system_setup.cc.
 void InitializeTarget();
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_SYSTEM_SETUP_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/test_helper_custom_ops.h

@@ -27,7 +27,7 @@ limitations under the License.
 #include "tensorflow/lite/portable_type_to_tflitetype.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace testing {
 
 class PackerOp {
@@ -44,6 +44,6 @@ class PackerOp {
 };
 
 }  // namespace testing
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_TEST_HELPER_CUSTOM_OPS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/test_helpers.h

@@ -30,11 +30,11 @@ limitations under the License.
 #include "tensorflow/lite/portable_type_to_tflitetype.h"
 #include "tensorflow/lite/schema/schema_generated.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace testing {
 
 constexpr int kOfflinePlannerHeaderSize = 3;
-using TestingOpResolver = tflite::MicroMutableOpResolver<10>;
+using TestingOpResolver = tflite_micro::MicroMutableOpResolver<10>;
 
 struct NodeConnection_ {
   std::initializer_list<int32_t> input;
@@ -224,7 +224,7 @@ TfLiteTensor CreateTensor(const T* data, TfLiteIntArray* dims,
 
   if (type == kTfLiteInt4) {
     result.type = kTfLiteInt4;
-    PackInt4ValuesDenselyInPlace(tflite::GetTensorData<uint8_t>(&result),
+    PackInt4ValuesDenselyInPlace(tflite_micro::GetTensorData<uint8_t>(&result),
                                  ElementCount(*dims));
     result.bytes = ((ElementCount(*dims) + 1) / 2);
   } else {
@@ -254,7 +254,7 @@ TfLiteTensor CreateQuantizedTensor(const float* input, T* quantized,
                                    int zero_point, bool is_variable = false,
                                    TfLiteType type = kTfLiteNoType) {
   int input_size = ElementCount(*dims);
-  tflite::Quantize(input, quantized, input_size, scale, zero_point);
+  tflite_micro::Quantize(input, quantized, input_size, scale, zero_point);
   return CreateQuantizedTensor(quantized, dims, scale, zero_point, is_variable,
                                type);
 }
@@ -297,7 +297,7 @@ TfLiteTensor CreateSymmetricPerChannelQuantizedTensor(
     int quantized_dimension, bool is_variable = false,
     TfLiteType tensor_weight_type = kTfLiteNoType);
 
-// Returns the number of tensors in the default subgraph for a tflite::Model.
+// Returns the number of tensors in the default subgraph for a tflite_micro::Model.
 size_t GetModelTensorCount(const Model* model);
 
 // Derives the asymmetric quantization scaling factor from a min and max range.
@@ -329,6 +329,6 @@ inline int ZeroPointFromMinMax(const float min, const float max) {
 }
 
 }  // namespace testing
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_TEST_HELPERS_H_